Merge branch 'master' of https://twinetfs.visualstudio.com/_git/Tango

18 files changed, 1290 insertions, 101 deletions

diff --git a/Software/Embedded_SW/Embedded/Communication/Container.c b/Software/Embedded_SW/Embedded/Communication/Container.c
index 5282ab9e0..c35b0ca45 100644
--- a/Software/Embedded_SW/Embedded/Communication/Container.c
+++ b/Software/Embedded_SW/Embedded/Communication/Container.c
@@ -32,6 +32,7 @@
 
 #include "Modules/General/GeneralHardware.h"
 #include "Modules/General/MachineStatus.h"
+#include "Drivers/I2C_Communication/Dispenser_Card/EEPROM/Dispenser_EEPROM.h"
 
 #include "Modules/heaters/heaters_ex.h"
 #include "Modules/AlarmHandling/AlarmHandling.h"
@@ -483,6 +484,9 @@ void receive_callback(char* buffer, size_t length)
          case MESSAGE_TYPE__StopThreadLoadingRequest:
              StopThreadLoadingFunc(requestContainer);
              break;
+         case MESSAGE_TYPE__DispenserEEpromRequest:
+             DispenserEEpromRequestFunc(requestContainer);
+             break;
          default:
              //unsupported message type !!
              LOG_ERROR (requestContainer->type,"unsupported message type");
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Common/MessageType.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/Common/MessageType.pb-c.c
index c54567f65..831795919 100644
--- a/Software/Embedded_SW/Embedded/Communication/PMR/Common/MessageType.pb-c.c
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/Common/MessageType.pb-c.c
@@ -7,7 +7,7 @@
 #endif
 
 #include "MessageType.pb-c.h"
-static const ProtobufCEnumValue message_type__enum_values_by_number[245] =
+static const ProtobufCEnumValue message_type__enum_values_by_number[247] =
 {
   { "None", "MESSAGE_TYPE__None", 0 },
   { "ErrorResponse", "MESSAGE_TYPE__ErrorResponse", 1 },
@@ -178,6 +178,8 @@ static const ProtobufCEnumValue message_type__enum_values_by_number[245] =
   { "StopCartridgesUpdateResponse", "MESSAGE_TYPE__StopCartridgesUpdateResponse", 2043 },
   { "CartridgeValidationRequest", "MESSAGE_TYPE__CartridgeValidationRequest", 2044 },
   { "CartridgeValidationResponse", "MESSAGE_TYPE__CartridgeValidationResponse", 2045 },
+  { "DispenserEEpromRequest", "MESSAGE_TYPE__DispenserEEpromRequest", 2046 },
+  { "DispenserEEpromResponse", "MESSAGE_TYPE__DispenserEEpromResponse", 2047 },
   { "JobRequest", "MESSAGE_TYPE__JobRequest", 3000 },
   { "JobResponse", "MESSAGE_TYPE__JobResponse", 3001 },
   { "AbortJobRequest", "MESSAGE_TYPE__AbortJobRequest", 3002 },
@@ -256,80 +258,82 @@ static const ProtobufCEnumValue message_type__enum_values_by_number[245] =
   { "StopThreadLoadingResponse", "MESSAGE_TYPE__StopThreadLoadingResponse", 11005 },
 };
 static const ProtobufCIntRange message_type__value_ranges[] = {
-{0, 0},{3, 2},{1000, 104},{2000, 123},{3000, 169},{4000, 183},{5000, 191},{6000, 195},{7000, 201},{8000, 225},{9000, 231},{10000, 235},{11000, 239},{0, 245}
+{0, 0},{3, 2},{1000, 104},{2000, 123},{3000, 171},{4000, 185},{5000, 193},{6000, 197},{7000, 203},{8000, 227},{9000, 233},{10000, 237},{11000, 241},{0, 247}
 };
-static const ProtobufCEnumValueIndex message_type__enum_values_by_name[245] =
+static const ProtobufCEnumValueIndex message_type__enum_values_by_name[247] =
 {
-  { "AbortHeadCleaningRequest", 181 },
-  { "AbortHeadCleaningResponse", 182 },
-  { "AbortJobRequest", 171 },
-  { "AbortJobResponse", 172 },
-  { "AbortPowerDownRequest", 237 },
-  { "AbortPowerDownResponse", 238 },
-  { "ActivateVersionRequest", 223 },
-  { "ActivateVersionResponse", 224 },
+  { "AbortHeadCleaningRequest", 183 },
+  { "AbortHeadCleaningResponse", 184 },
+  { "AbortJobRequest", 173 },
+  { "AbortJobResponse", 174 },
+  { "AbortPowerDownRequest", 239 },
+  { "AbortPowerDownResponse", 240 },
+  { "ActivateVersionRequest", 225 },
+  { "ActivateVersionResponse", 226 },
   { "CalculateRequest", 2 },
   { "CalculateResponse", 3 },
   { "CartridgeValidationRequest", 167 },
   { "CartridgeValidationResponse", 168 },
   { "ColorProfileRequest", 117 },
   { "ColorProfileResponse", 118 },
-  { "ConnectRequest", 197 },
-  { "ConnectResponse", 198 },
-  { "ContinueThreadLoadingRequest", 241 },
-  { "ContinueThreadLoadingResponse", 242 },
-  { "CreateRequest", 209 },
-  { "CreateResponse", 210 },
-  { "CurrentJobRequest", 175 },
-  { "CurrentJobResponse", 176 },
-  { "DeleteRequest", 211 },
-  { "DeleteResponse", 212 },
+  { "ConnectRequest", 199 },
+  { "ConnectResponse", 200 },
+  { "ContinueThreadLoadingRequest", 243 },
+  { "ContinueThreadLoadingResponse", 244 },
+  { "CreateRequest", 211 },
+  { "CreateResponse", 212 },
+  { "CurrentJobRequest", 177 },
+  { "CurrentJobResponse", 178 },
+  { "DeleteRequest", 213 },
+  { "DeleteResponse", 214 },
   { "DirectSynchronizationRequest", 109 },
   { "DirectSynchronizationResponse", 110 },
-  { "DisconnectRequest", 199 },
-  { "DisconnectResponse", 200 },
+  { "DisconnectRequest", 201 },
+  { "DisconnectResponse", 202 },
   { "DispenserAbortHomingRequest", 133 },
   { "DispenserAbortHomingResponse", 134 },
   { "DispenserAbortJoggingRequest", 139 },
   { "DispenserAbortJoggingResponse", 140 },
-  { "DispenserDataRequest", 225 },
-  { "DispenserDataResponse", 226 },
+  { "DispenserDataRequest", 227 },
+  { "DispenserDataResponse", 228 },
+  { "DispenserEEpromRequest", 169 },
+  { "DispenserEEpromResponse", 170 },
   { "DispenserHomingRequest", 135 },
   { "DispenserHomingResponse", 136 },
   { "DispenserJoggingRequest", 137 },
   { "DispenserJoggingResponse", 138 },
   { "ErrorResponse", 1 },
-  { "ExecuteProcessRequest", 205 },
-  { "ExecuteProcessResponse", 206 },
+  { "ExecuteProcessRequest", 207 },
+  { "ExecuteProcessResponse", 208 },
   { "ExternalBridgeLoginRequest", 105 },
   { "ExternalBridgeLoginResponse", 106 },
   { "ExternalBridgeLogoutRequest", 107 },
   { "ExternalBridgeLogoutResponse", 108 },
   { "ExternalBridgeUdpDiscoveryPacket", 104 },
-  { "FileChunkDownloadRequest", 219 },
-  { "FileChunkDownloadResponse", 220 },
-  { "FileChunkUploadRequest", 203 },
-  { "FileChunkUploadResponse", 204 },
-  { "FileDownloadRequest", 217 },
-  { "FileDownloadResponse", 218 },
-  { "FileUploadRequest", 201 },
-  { "FileUploadResponse", 202 },
+  { "FileChunkDownloadRequest", 221 },
+  { "FileChunkDownloadResponse", 222 },
+  { "FileChunkUploadRequest", 205 },
+  { "FileChunkUploadResponse", 206 },
+  { "FileDownloadRequest", 219 },
+  { "FileDownloadResponse", 220 },
+  { "FileUploadRequest", 203 },
+  { "FileUploadResponse", 204 },
   { "GenericRequest", 121 },
   { "GenericResponse", 122 },
-  { "GetFilesRequest", 215 },
-  { "GetFilesResponse", 216 },
-  { "GetStorageInfoRequest", 213 },
-  { "GetStorageInfoResponse", 214 },
-  { "JobRequest", 169 },
-  { "JobResponse", 170 },
-  { "KeepAliveRequest", 195 },
-  { "KeepAliveResponse", 196 },
-  { "KillProcessRequest", 207 },
-  { "KillProcessResponse", 208 },
-  { "MachineCalibrationDataRequest", 229 },
-  { "MachineCalibrationDataResponse", 230 },
-  { "MidTankDataSetupRequest", 227 },
-  { "MidTankDataSetupResponse", 228 },
+  { "GetFilesRequest", 217 },
+  { "GetFilesResponse", 218 },
+  { "GetStorageInfoRequest", 215 },
+  { "GetStorageInfoResponse", 216 },
+  { "JobRequest", 171 },
+  { "JobResponse", 172 },
+  { "KeepAliveRequest", 197 },
+  { "KeepAliveResponse", 198 },
+  { "KillProcessRequest", 209 },
+  { "KillProcessResponse", 210 },
+  { "MachineCalibrationDataRequest", 231 },
+  { "MachineCalibrationDataResponse", 232 },
+  { "MidTankDataSetupRequest", 229 },
+  { "MidTankDataSetupResponse", 230 },
   { "MotorAbortHomingRequest", 125 },
   { "MotorAbortHomingResponse", 126 },
   { "MotorAbortJoggingRequest", 131 },
@@ -345,54 +349,54 @@ static const ProtobufCEnumValueIndex message_type__enum_values_by_name[245] =
   { "ProgressResponse", 5 },
   { "ResolveEventRequest", 149 },
   { "ResolveEventResponse", 150 },
-  { "ResumeCurrentJobRequest", 177 },
-  { "ResumeCurrentJobResponse", 178 },
+  { "ResumeCurrentJobRequest", 179 },
+  { "ResumeCurrentJobResponse", 180 },
   { "SetBlowerStateRequest", 159 },
   { "SetBlowerStateResponse", 160 },
   { "SetComponentValueRequest", 147 },
   { "SetComponentValueResponse", 148 },
-  { "SetDebugLogCategoryRequest", 187 },
-  { "SetDebugLogCategoryResponse", 188 },
+  { "SetDebugLogCategoryRequest", 189 },
+  { "SetDebugLogCategoryResponse", 190 },
   { "SetDigitalOutRequest", 141 },
   { "SetDigitalOutResponse", 142 },
   { "SetHeaterStateRequest", 157 },
   { "SetHeaterStateResponse", 158 },
   { "SetValveStateRequest", 161 },
   { "SetValveStateResponse", 162 },
-  { "SetupDebugDisributorsRequest", 189 },
-  { "SetupDebugDisributorsResponse", 190 },
+  { "SetupDebugDisributorsRequest", 191 },
+  { "SetupDebugDisributorsResponse", 192 },
   { "StartApplicationLogsRequest", 113 },
   { "StartApplicationLogsResponse", 114 },
   { "StartCartridgesUpdateRequest", 163 },
   { "StartCartridgesUpdateResponse", 164 },
-  { "StartDebugLogRequest", 183 },
-  { "StartDebugLogResponse", 184 },
+  { "StartDebugLogRequest", 185 },
+  { "StartDebugLogResponse", 186 },
   { "StartDiagnosticsRequest", 123 },
   { "StartDiagnosticsResponse", 124 },
   { "StartEventsNotificationRequest", 153 },
   { "StartEventsNotificationResponse", 154 },
-  { "StartHeadCleaningRequest", 179 },
-  { "StartHeadCleaningResponse", 180 },
-  { "StartMachineStatusUpdateRequest", 231 },
-  { "StartMachineStatusUpdateResponse", 232 },
-  { "StartPowerDownRequest", 235 },
-  { "StartPowerDownResponse", 236 },
-  { "StartThreadLoadingRequest", 239 },
-  { "StartThreadLoadingResponse", 240 },
+  { "StartHeadCleaningRequest", 181 },
+  { "StartHeadCleaningResponse", 182 },
+  { "StartMachineStatusUpdateRequest", 233 },
+  { "StartMachineStatusUpdateResponse", 234 },
+  { "StartPowerDownRequest", 237 },
+  { "StartPowerDownResponse", 238 },
+  { "StartThreadLoadingRequest", 241 },
+  { "StartThreadLoadingResponse", 242 },
   { "StopApplicationLogsRequest", 115 },
   { "StopApplicationLogsResponse", 116 },
   { "StopCartridgesUpdateRequest", 165 },
   { "StopCartridgesUpdateResponse", 166 },
-  { "StopDebugLogRequest", 185 },
-  { "StopDebugLogResponse", 186 },
+  { "StopDebugLogRequest", 187 },
+  { "StopDebugLogResponse", 188 },
   { "StopDiagnosticsRequest", 151 },
   { "StopDiagnosticsResponse", 152 },
   { "StopEventsNotificationRequest", 155 },
   { "StopEventsNotificationResponse", 156 },
-  { "StopMachineStatusUpdateRequest", 233 },
-  { "StopMachineStatusUpdateResponse", 234 },
-  { "StopThreadLoadingRequest", 243 },
-  { "StopThreadLoadingResponse", 244 },
+  { "StopMachineStatusUpdateRequest", 235 },
+  { "StopMachineStatusUpdateResponse", 236 },
+  { "StopThreadLoadingRequest", 245 },
+  { "StopThreadLoadingResponse", 246 },
   { "StubAbortJobRequest", 100 },
   { "StubAbortJobResponse", 101 },
   { "StubCartridgeReadRequest", 6 },
@@ -491,20 +495,20 @@ static const ProtobufCEnumValueIndex message_type__enum_values_by_name[245] =
   { "StubTivaWriteRegResponse", 79 },
   { "StubValveRequest", 30 },
   { "StubValveResponse", 31 },
-  { "SystemResetRequest", 193 },
-  { "SystemResetResponse", 194 },
+  { "SystemResetRequest", 195 },
+  { "SystemResetResponse", 196 },
   { "ThreadAbortJoggingRequest", 145 },
   { "ThreadAbortJoggingResponse", 146 },
   { "ThreadJoggingRequest", 143 },
   { "ThreadJoggingResponse", 144 },
   { "UpdateStatusRequest", 119 },
   { "UpdateStatusResponse", 120 },
-  { "UploadHardwareConfigurationRequest", 191 },
-  { "UploadHardwareConfigurationResponse", 192 },
-  { "UploadProcessParametersRequest", 173 },
-  { "UploadProcessParametersResponse", 174 },
-  { "ValidateVersionRequest", 221 },
-  { "ValidateVersionResponse", 222 },
+  { "UploadHardwareConfigurationRequest", 193 },
+  { "UploadHardwareConfigurationResponse", 194 },
+  { "UploadProcessParametersRequest", 175 },
+  { "UploadProcessParametersResponse", 176 },
+  { "ValidateVersionRequest", 223 },
+  { "ValidateVersionResponse", 224 },
 };
 const ProtobufCEnumDescriptor message_type__descriptor =
 {
@@ -513,9 +517,9 @@ const ProtobufCEnumDescriptor message_type__descriptor =
   "MessageType",
   "MessageType",
   "",
-  245,
+  247,
   message_type__enum_values_by_number,
-  245,
+  247,
   message_type__enum_values_by_name,
   13,
   message_type__value_ranges,
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Common/MessageType.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/Common/MessageType.pb-c.h
index 363aaa17a..fdc7d1bd8 100644
--- a/Software/Embedded_SW/Embedded/Communication/PMR/Common/MessageType.pb-c.h
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/Common/MessageType.pb-c.h
@@ -189,6 +189,8 @@ typedef enum _MessageType {
   MESSAGE_TYPE__StopCartridgesUpdateResponse = 2043,
   MESSAGE_TYPE__CartridgeValidationRequest = 2044,
   MESSAGE_TYPE__CartridgeValidationResponse = 2045,
+  MESSAGE_TYPE__DispenserEEpromRequest = 2046,
+  MESSAGE_TYPE__DispenserEEpromResponse = 2047,
   MESSAGE_TYPE__JobRequest = 3000,
   MESSAGE_TYPE__JobResponse = 3001,
   MESSAGE_TYPE__AbortJobRequest = 3002,
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/DispenserEEPROM.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/DispenserEEPROM.pb-c.c
new file mode 100644
index 000000000..a3c1f603f
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/DispenserEEPROM.pb-c.c
@@ -0,0 +1,495 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: DispenserEEPROM.proto */
+
+/* Do not generate deprecated warnings for self */
+#ifndef PROTOBUF_C__NO_DEPRECATED
+#define PROTOBUF_C__NO_DEPRECATED
+#endif
+
+#include "DispenserEEPROM.pb-c.h"
+void   dispenser_eeprom__init
+                     (DispenserEEprom         *message)
+{
+  static const DispenserEEprom init_value = DISPENSER_EEPROM__INIT;
+  *message = init_value;
+}
+size_t dispenser_eeprom__get_packed_size
+                     (const DispenserEEprom *message)
+{
+  assert(message->base.descriptor == &dispenser_eeprom__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t dispenser_eeprom__pack
+                     (const DispenserEEprom *message,
+                      uint8_t       *out)
+{
+  assert(message->base.descriptor == &dispenser_eeprom__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t dispenser_eeprom__pack_to_buffer
+                     (const DispenserEEprom *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->base.descriptor == &dispenser_eeprom__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+DispenserEEprom *
+       dispenser_eeprom__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (DispenserEEprom *)
+     protobuf_c_message_unpack (&dispenser_eeprom__descriptor,
+                                allocator, len, data);
+}
+void   dispenser_eeprom__free_unpacked
+                     (DispenserEEprom *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->base.descriptor == &dispenser_eeprom__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+static const ProtobufCFieldDescriptor dispenser_eeprom__field_descriptors[32] =
+{
+  {
+    "Header",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(DispenserEEprom, has_header),
+    offsetof(DispenserEEprom, header),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "TableLength",
+    2,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(DispenserEEprom, has_tablelength),
+    offsetof(DispenserEEprom, tablelength),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "Tableversion",
+    3,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(DispenserEEprom, has_tableversion),
+    offsetof(DispenserEEprom, tableversion),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "DispenserP_N",
+    4,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(DispenserEEprom, dispenserp_n),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "PCBS_N",
+    5,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(DispenserEEprom, pcbs_n),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "PCBPartNumber",
+    6,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(DispenserEEprom, pcbpartnumber),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "DispenserS_N",
+    7,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(DispenserEEprom, dispensers_n),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "MinimalPressure",
+    8,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(DispenserEEprom, has_minimalpressure),
+    offsetof(DispenserEEprom, minimalpressure),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "MaximalPressure",
+    9,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(DispenserEEprom, has_maximalpressure),
+    offsetof(DispenserEEprom, maximalpressure),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "MinimalMV",
+    10,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(DispenserEEprom, has_minimalmv),
+    offsetof(DispenserEEprom, minimalmv),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "MaximalMV",
+    11,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(DispenserEEprom, has_maximalmv),
+    offsetof(DispenserEEprom, maximalmv),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "TotalCycles",
+    12,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(DispenserEEprom, has_totalcycles),
+    offsetof(DispenserEEprom, totalcycles),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "BubbleSize",
+    13,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(DispenserEEprom, has_bubblesize),
+    offsetof(DispenserEEprom, bubblesize),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "AVG_Nl_stepValue_1_4",
+    14,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(DispenserEEprom, has_avg_nl_stepvalue_1_4),
+    offsetof(DispenserEEprom, avg_nl_stepvalue_1_4),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "AVG_Nl_stepValue_2_4",
+    15,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(DispenserEEprom, has_avg_nl_stepvalue_2_4),
+    offsetof(DispenserEEprom, avg_nl_stepvalue_2_4),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "AVG_Nl_stepValue_3_4",
+    16,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(DispenserEEprom, has_avg_nl_stepvalue_3_4),
+    offsetof(DispenserEEprom, avg_nl_stepvalue_3_4),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "AVG_Nl_stepValue_4_4",
+    17,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(DispenserEEprom, has_avg_nl_stepvalue_4_4),
+    offsetof(DispenserEEprom, avg_nl_stepvalue_4_4),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "SW_Reserve",
+    18,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(DispenserEEprom, has_sw_reserve),
+    offsetof(DispenserEEprom, sw_reserve),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "Spare1_pressure",
+    19,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_INT32,
+    offsetof(DispenserEEprom, has_spare1_pressure),
+    offsetof(DispenserEEprom, spare1_pressure),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "Spare2_pressure",
+    20,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_INT32,
+    offsetof(DispenserEEprom, has_spare2_pressure),
+    offsetof(DispenserEEprom, spare2_pressure),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "MotorPulsesPerCycle",
+    21,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(DispenserEEprom, has_motorpulsespercycle),
+    offsetof(DispenserEEprom, motorpulsespercycle),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "Color",
+    22,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(DispenserEEprom, has_color),
+    offsetof(DispenserEEprom, color),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "PressureSlope",
+    23,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(DispenserEEprom, has_pressureslope),
+    offsetof(DispenserEEprom, pressureslope),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "ProductionDate",
+    24,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(DispenserEEprom, productiondate),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "ATSlocation",
+    25,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(DispenserEEprom, has_atslocation),
+    offsetof(DispenserEEprom, atslocation),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "Spare1",
+    26,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(DispenserEEprom, has_spare1),
+    offsetof(DispenserEEprom, spare1),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "Spare2",
+    27,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(DispenserEEprom, has_spare2),
+    offsetof(DispenserEEprom, spare2),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "ATSChannel",
+    28,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(DispenserEEprom, has_atschannel),
+    offsetof(DispenserEEprom, atschannel),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "UnitEmpty",
+    29,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(DispenserEEprom, has_unitempty),
+    offsetof(DispenserEEprom, unitempty),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "DryRunPass_Fail",
+    30,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(DispenserEEprom, has_dryrunpass_fail),
+    offsetof(DispenserEEprom, dryrunpass_fail),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "FlowPass_Fail",
+    31,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(DispenserEEprom, has_flowpass_fail),
+    offsetof(DispenserEEprom, flowpass_fail),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "CheckSum",
+    32,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(DispenserEEprom, has_checksum),
+    offsetof(DispenserEEprom, checksum),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned dispenser_eeprom__field_indices_by_name[] = {
+  27,   /* field[27] = ATSChannel */
+  24,   /* field[24] = ATSlocation */
+  13,   /* field[13] = AVG_Nl_stepValue_1_4 */
+  14,   /* field[14] = AVG_Nl_stepValue_2_4 */
+  15,   /* field[15] = AVG_Nl_stepValue_3_4 */
+  16,   /* field[16] = AVG_Nl_stepValue_4_4 */
+  12,   /* field[12] = BubbleSize */
+  31,   /* field[31] = CheckSum */
+  21,   /* field[21] = Color */
+  3,   /* field[3] = DispenserP_N */
+  6,   /* field[6] = DispenserS_N */
+  29,   /* field[29] = DryRunPass_Fail */
+  30,   /* field[30] = FlowPass_Fail */
+  0,   /* field[0] = Header */
+  10,   /* field[10] = MaximalMV */
+  8,   /* field[8] = MaximalPressure */
+  9,   /* field[9] = MinimalMV */
+  7,   /* field[7] = MinimalPressure */
+  20,   /* field[20] = MotorPulsesPerCycle */
+  5,   /* field[5] = PCBPartNumber */
+  4,   /* field[4] = PCBS_N */
+  22,   /* field[22] = PressureSlope */
+  23,   /* field[23] = ProductionDate */
+  17,   /* field[17] = SW_Reserve */
+  25,   /* field[25] = Spare1 */
+  18,   /* field[18] = Spare1_pressure */
+  26,   /* field[26] = Spare2 */
+  19,   /* field[19] = Spare2_pressure */
+  1,   /* field[1] = TableLength */
+  2,   /* field[2] = Tableversion */
+  11,   /* field[11] = TotalCycles */
+  28,   /* field[28] = UnitEmpty */
+};
+static const ProtobufCIntRange dispenser_eeprom__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 32 }
+};
+const ProtobufCMessageDescriptor dispenser_eeprom__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "DispenserEEprom",
+  "DispenserEEprom",
+  "DispenserEEprom",
+  "",
+  sizeof(DispenserEEprom),
+  32,
+  dispenser_eeprom__field_descriptors,
+  dispenser_eeprom__field_indices_by_name,
+  1,  dispenser_eeprom__number_ranges,
+  (ProtobufCMessageInit) dispenser_eeprom__init,
+  NULL,NULL,NULL    /* reserved[123] */
+};
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/DispenserEEPROM.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/DispenserEEPROM.pb-c.h
new file mode 100644
index 000000000..34b9b333d
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/DispenserEEPROM.pb-c.h
@@ -0,0 +1,129 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: DispenserEEPROM.proto */
+
+#ifndef PROTOBUF_C_DispenserEEPROM_2eproto__INCLUDED
+#define PROTOBUF_C_DispenserEEPROM_2eproto__INCLUDED
+
+#include <protobuf-c/protobuf-c.h>
+
+PROTOBUF_C__BEGIN_DECLS
+
+#if PROTOBUF_C_VERSION_NUMBER < 1003000
+# error This file was generated by a newer version of protoc-c which is incompatible with your libprotobuf-c headers. Please update your headers.
+#elif 1003000 < PROTOBUF_C_MIN_COMPILER_VERSION
+# error This file was generated by an older version of protoc-c which is incompatible with your libprotobuf-c headers. Please regenerate this file with a newer version of protoc-c.
+#endif
+
+
+typedef struct _DispenserEEprom DispenserEEprom;
+
+
+/* --- enums --- */
+
+
+/* --- messages --- */
+
+struct  _DispenserEEprom
+{
+  ProtobufCMessage base;
+  protobuf_c_boolean has_header;
+  uint32_t header;
+  protobuf_c_boolean has_tablelength;
+  uint32_t tablelength;
+  protobuf_c_boolean has_tableversion;
+  uint32_t tableversion;
+  char *dispenserp_n;
+  char *pcbs_n;
+  char *pcbpartnumber;
+  char *dispensers_n;
+  protobuf_c_boolean has_minimalpressure;
+  uint32_t minimalpressure;
+  protobuf_c_boolean has_maximalpressure;
+  uint32_t maximalpressure;
+  protobuf_c_boolean has_minimalmv;
+  uint32_t minimalmv;
+  protobuf_c_boolean has_maximalmv;
+  uint32_t maximalmv;
+  protobuf_c_boolean has_totalcycles;
+  uint32_t totalcycles;
+  protobuf_c_boolean has_bubblesize;
+  uint32_t bubblesize;
+  protobuf_c_boolean has_avg_nl_stepvalue_1_4;
+  uint32_t avg_nl_stepvalue_1_4;
+  protobuf_c_boolean has_avg_nl_stepvalue_2_4;
+  uint32_t avg_nl_stepvalue_2_4;
+  protobuf_c_boolean has_avg_nl_stepvalue_3_4;
+  uint32_t avg_nl_stepvalue_3_4;
+  protobuf_c_boolean has_avg_nl_stepvalue_4_4;
+  uint32_t avg_nl_stepvalue_4_4;
+  protobuf_c_boolean has_sw_reserve;
+  uint32_t sw_reserve;
+  protobuf_c_boolean has_spare1_pressure;
+  int32_t spare1_pressure;
+  protobuf_c_boolean has_spare2_pressure;
+  int32_t spare2_pressure;
+  protobuf_c_boolean has_motorpulsespercycle;
+  uint32_t motorpulsespercycle;
+  protobuf_c_boolean has_color;
+  uint32_t color;
+  protobuf_c_boolean has_pressureslope;
+  uint32_t pressureslope;
+  char *productiondate;
+  protobuf_c_boolean has_atslocation;
+  uint32_t atslocation;
+  protobuf_c_boolean has_spare1;
+  uint32_t spare1;
+  protobuf_c_boolean has_spare2;
+  uint32_t spare2;
+  protobuf_c_boolean has_atschannel;
+  uint32_t atschannel;
+  protobuf_c_boolean has_unitempty;
+  protobuf_c_boolean unitempty;
+  protobuf_c_boolean has_dryrunpass_fail;
+  protobuf_c_boolean dryrunpass_fail;
+  protobuf_c_boolean has_flowpass_fail;
+  protobuf_c_boolean flowpass_fail;
+  protobuf_c_boolean has_checksum;
+  protobuf_c_boolean checksum;
+};
+#define DISPENSER_EEPROM__INIT \
+ { PROTOBUF_C_MESSAGE_INIT (&dispenser_eeprom__descriptor) \
+    , 0, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
+
+
+/* DispenserEEprom methods */
+void   dispenser_eeprom__init
+                     (DispenserEEprom         *message);
+size_t dispenser_eeprom__get_packed_size
+                     (const DispenserEEprom   *message);
+size_t dispenser_eeprom__pack
+                     (const DispenserEEprom   *message,
+                      uint8_t             *out);
+size_t dispenser_eeprom__pack_to_buffer
+                     (const DispenserEEprom   *message,
+                      ProtobufCBuffer     *buffer);
+DispenserEEprom *
+       dispenser_eeprom__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   dispenser_eeprom__free_unpacked
+                     (DispenserEEprom *message,
+                      ProtobufCAllocator *allocator);
+/* --- per-message closures --- */
+
+typedef void (*DispenserEEprom_Closure)
+                 (const DispenserEEprom *message,
+                  void *closure_data);
+
+/* --- services --- */
+
+
+/* --- descriptors --- */
+
+extern const ProtobufCMessageDescriptor dispenser_eeprom__descriptor;
+
+PROTOBUF_C__END_DECLS
+
+
+#endif  /* PROTOBUF_C_DispenserEEPROM_2eproto__INCLUDED */
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/DispenserEEpromRequest.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/DispenserEEpromRequest.pb-c.c
new file mode 100644
index 000000000..013ecbf5a
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/DispenserEEpromRequest.pb-c.c
@@ -0,0 +1,118 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: DispenserEEpromRequest.proto */
+
+/* Do not generate deprecated warnings for self */
+#ifndef PROTOBUF_C__NO_DEPRECATED
+#define PROTOBUF_C__NO_DEPRECATED
+#endif
+
+#include "DispenserEEpromRequest.pb-c.h"
+void   dispenser_eeprom_request__init
+                     (DispenserEEpromRequest         *message)
+{
+  static const DispenserEEpromRequest init_value = DISPENSER_EEPROM_REQUEST__INIT;
+  *message = init_value;
+}
+size_t dispenser_eeprom_request__get_packed_size
+                     (const DispenserEEpromRequest *message)
+{
+  assert(message->base.descriptor == &dispenser_eeprom_request__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t dispenser_eeprom_request__pack
+                     (const DispenserEEpromRequest *message,
+                      uint8_t       *out)
+{
+  assert(message->base.descriptor == &dispenser_eeprom_request__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t dispenser_eeprom_request__pack_to_buffer
+                     (const DispenserEEpromRequest *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->base.descriptor == &dispenser_eeprom_request__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+DispenserEEpromRequest *
+       dispenser_eeprom_request__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (DispenserEEpromRequest *)
+     protobuf_c_message_unpack (&dispenser_eeprom_request__descriptor,
+                                allocator, len, data);
+}
+void   dispenser_eeprom_request__free_unpacked
+                     (DispenserEEpromRequest *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->base.descriptor == &dispenser_eeprom_request__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+static const ProtobufCFieldDescriptor dispenser_eeprom_request__field_descriptors[3] =
+{
+  {
+    "DispenserId",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(DispenserEEpromRequest, has_dispenserid),
+    offsetof(DispenserEEpromRequest, dispenserid),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "BurnRequest",
+    2,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(DispenserEEpromRequest, has_burnrequest),
+    offsetof(DispenserEEpromRequest, burnrequest),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "DispenserEEprom",
+    3,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_MESSAGE,
+    0,   /* quantifier_offset */
+    offsetof(DispenserEEpromRequest, dispensereeprom),
+    &dispenser_eeprom__descriptor,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned dispenser_eeprom_request__field_indices_by_name[] = {
+  1,   /* field[1] = BurnRequest */
+  2,   /* field[2] = DispenserEEprom */
+  0,   /* field[0] = DispenserId */
+};
+static const ProtobufCIntRange dispenser_eeprom_request__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 3 }
+};
+const ProtobufCMessageDescriptor dispenser_eeprom_request__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "DispenserEEpromRequest",
+  "DispenserEEpromRequest",
+  "DispenserEEpromRequest",
+  "",
+  sizeof(DispenserEEpromRequest),
+  3,
+  dispenser_eeprom_request__field_descriptors,
+  dispenser_eeprom_request__field_indices_by_name,
+  1,  dispenser_eeprom_request__number_ranges,
+  (ProtobufCMessageInit) dispenser_eeprom_request__init,
+  NULL,NULL,NULL    /* reserved[123] */
+};
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/DispenserEEpromRequest.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/DispenserEEpromRequest.pb-c.h
new file mode 100644
index 000000000..e7db7f73e
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/DispenserEEpromRequest.pb-c.h
@@ -0,0 +1,76 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: DispenserEEpromRequest.proto */
+
+#ifndef PROTOBUF_C_DispenserEEpromRequest_2eproto__INCLUDED
+#define PROTOBUF_C_DispenserEEpromRequest_2eproto__INCLUDED
+
+#include <protobuf-c/protobuf-c.h>
+
+PROTOBUF_C__BEGIN_DECLS
+
+#if PROTOBUF_C_VERSION_NUMBER < 1003000
+# error This file was generated by a newer version of protoc-c which is incompatible with your libprotobuf-c headers. Please update your headers.
+#elif 1003000 < PROTOBUF_C_MIN_COMPILER_VERSION
+# error This file was generated by an older version of protoc-c which is incompatible with your libprotobuf-c headers. Please regenerate this file with a newer version of protoc-c.
+#endif
+
+#include "DispenserEEprom.pb-c.h"
+
+typedef struct _DispenserEEpromRequest DispenserEEpromRequest;
+
+
+/* --- enums --- */
+
+
+/* --- messages --- */
+
+struct  _DispenserEEpromRequest
+{
+  ProtobufCMessage base;
+  protobuf_c_boolean has_dispenserid;
+  uint32_t dispenserid;
+  protobuf_c_boolean has_burnrequest;
+  protobuf_c_boolean burnrequest;
+  DispenserEEprom *dispensereeprom;
+};
+#define DISPENSER_EEPROM_REQUEST__INIT \
+ { PROTOBUF_C_MESSAGE_INIT (&dispenser_eeprom_request__descriptor) \
+    , 0, 0, 0, 0, NULL }
+
+
+/* DispenserEEpromRequest methods */
+void   dispenser_eeprom_request__init
+                     (DispenserEEpromRequest         *message);
+size_t dispenser_eeprom_request__get_packed_size
+                     (const DispenserEEpromRequest   *message);
+size_t dispenser_eeprom_request__pack
+                     (const DispenserEEpromRequest   *message,
+                      uint8_t             *out);
+size_t dispenser_eeprom_request__pack_to_buffer
+                     (const DispenserEEpromRequest   *message,
+                      ProtobufCBuffer     *buffer);
+DispenserEEpromRequest *
+       dispenser_eeprom_request__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   dispenser_eeprom_request__free_unpacked
+                     (DispenserEEpromRequest *message,
+                      ProtobufCAllocator *allocator);
+/* --- per-message closures --- */
+
+typedef void (*DispenserEEpromRequest_Closure)
+                 (const DispenserEEpromRequest *message,
+                  void *closure_data);
+
+/* --- services --- */
+
+
+/* --- descriptors --- */
+
+extern const ProtobufCMessageDescriptor dispenser_eeprom_request__descriptor;
+
+PROTOBUF_C__END_DECLS
+
+
+#endif  /* PROTOBUF_C_DispenserEEpromRequest_2eproto__INCLUDED */
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/DispenserEEpromResponse.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/DispenserEEpromResponse.pb-c.c
new file mode 100644
index 000000000..ece1a19b6
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/DispenserEEpromResponse.pb-c.c
@@ -0,0 +1,105 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: DispenserEEpromResponse.proto */
+
+/* Do not generate deprecated warnings for self */
+#ifndef PROTOBUF_C__NO_DEPRECATED
+#define PROTOBUF_C__NO_DEPRECATED
+#endif
+
+#include "DispenserEEpromResponse.pb-c.h"
+void   dispenser_eeprom_response__init
+                     (DispenserEEpromResponse         *message)
+{
+  static const DispenserEEpromResponse init_value = DISPENSER_EEPROM_RESPONSE__INIT;
+  *message = init_value;
+}
+size_t dispenser_eeprom_response__get_packed_size
+                     (const DispenserEEpromResponse *message)
+{
+  assert(message->base.descriptor == &dispenser_eeprom_response__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t dispenser_eeprom_response__pack
+                     (const DispenserEEpromResponse *message,
+                      uint8_t       *out)
+{
+  assert(message->base.descriptor == &dispenser_eeprom_response__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t dispenser_eeprom_response__pack_to_buffer
+                     (const DispenserEEpromResponse *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->base.descriptor == &dispenser_eeprom_response__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+DispenserEEpromResponse *
+       dispenser_eeprom_response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (DispenserEEpromResponse *)
+     protobuf_c_message_unpack (&dispenser_eeprom_response__descriptor,
+                                allocator, len, data);
+}
+void   dispenser_eeprom_response__free_unpacked
+                     (DispenserEEpromResponse *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->base.descriptor == &dispenser_eeprom_response__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+static const ProtobufCFieldDescriptor dispenser_eeprom_response__field_descriptors[2] =
+{
+  {
+    "DispenserId",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(DispenserEEpromResponse, has_dispenserid),
+    offsetof(DispenserEEpromResponse, dispenserid),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "DispenserEEprom",
+    2,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_MESSAGE,
+    0,   /* quantifier_offset */
+    offsetof(DispenserEEpromResponse, dispensereeprom),
+    &dispenser_eeprom__descriptor,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned dispenser_eeprom_response__field_indices_by_name[] = {
+  1,   /* field[1] = DispenserEEprom */
+  0,   /* field[0] = DispenserId */
+};
+static const ProtobufCIntRange dispenser_eeprom_response__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 2 }
+};
+const ProtobufCMessageDescriptor dispenser_eeprom_response__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "DispenserEEpromResponse",
+  "DispenserEEpromResponse",
+  "DispenserEEpromResponse",
+  "",
+  sizeof(DispenserEEpromResponse),
+  2,
+  dispenser_eeprom_response__field_descriptors,
+  dispenser_eeprom_response__field_indices_by_name,
+  1,  dispenser_eeprom_response__number_ranges,
+  (ProtobufCMessageInit) dispenser_eeprom_response__init,
+  NULL,NULL,NULL    /* reserved[123] */
+};
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/DispenserEEpromResponse.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/DispenserEEpromResponse.pb-c.h
new file mode 100644
index 000000000..b4e7f98b5
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/DispenserEEpromResponse.pb-c.h
@@ -0,0 +1,74 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: DispenserEEpromResponse.proto */
+
+#ifndef PROTOBUF_C_DispenserEEpromResponse_2eproto__INCLUDED
+#define PROTOBUF_C_DispenserEEpromResponse_2eproto__INCLUDED
+
+#include <protobuf-c/protobuf-c.h>
+
+PROTOBUF_C__BEGIN_DECLS
+
+#if PROTOBUF_C_VERSION_NUMBER < 1003000
+# error This file was generated by a newer version of protoc-c which is incompatible with your libprotobuf-c headers. Please update your headers.
+#elif 1003000 < PROTOBUF_C_MIN_COMPILER_VERSION
+# error This file was generated by an older version of protoc-c which is incompatible with your libprotobuf-c headers. Please regenerate this file with a newer version of protoc-c.
+#endif
+
+#include "DispenserEEprom.pb-c.h"
+
+typedef struct _DispenserEEpromResponse DispenserEEpromResponse;
+
+
+/* --- enums --- */
+
+
+/* --- messages --- */
+
+struct  _DispenserEEpromResponse
+{
+  ProtobufCMessage base;
+  protobuf_c_boolean has_dispenserid;
+  uint32_t dispenserid;
+  DispenserEEprom *dispensereeprom;
+};
+#define DISPENSER_EEPROM_RESPONSE__INIT \
+ { PROTOBUF_C_MESSAGE_INIT (&dispenser_eeprom_response__descriptor) \
+    , 0, 0, NULL }
+
+
+/* DispenserEEpromResponse methods */
+void   dispenser_eeprom_response__init
+                     (DispenserEEpromResponse         *message);
+size_t dispenser_eeprom_response__get_packed_size
+                     (const DispenserEEpromResponse   *message);
+size_t dispenser_eeprom_response__pack
+                     (const DispenserEEpromResponse   *message,
+                      uint8_t             *out);
+size_t dispenser_eeprom_response__pack_to_buffer
+                     (const DispenserEEpromResponse   *message,
+                      ProtobufCBuffer     *buffer);
+DispenserEEpromResponse *
+       dispenser_eeprom_response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   dispenser_eeprom_response__free_unpacked
+                     (DispenserEEpromResponse *message,
+                      ProtobufCAllocator *allocator);
+/* --- per-message closures --- */
+
+typedef void (*DispenserEEpromResponse_Closure)
+                 (const DispenserEEpromResponse *message,
+                  void *closure_data);
+
+/* --- services --- */
+
+
+/* --- descriptors --- */
+
+extern const ProtobufCMessageDescriptor dispenser_eeprom_response__descriptor;
+
+PROTOBUF_C__END_DECLS
+
+
+#endif  /* PROTOBUF_C_DispenserEEpromResponse_2eproto__INCLUDED */
diff --git a/Software/Embedded_SW/Embedded/DataDef.h b/Software/Embedded_SW/Embedded/DataDef.h
index 1621f2ecc..3729ee739 100644
--- a/Software/Embedded_SW/Embedded/DataDef.h
+++ b/Software/Embedded_SW/Embedded/DataDef.h
@@ -517,6 +517,7 @@ typedef struct
     uint32_t Pressure_Slope;
     uint8_t  Production_Test_Date[8];//string
     uint32_t ATS_Location;
+    uint32_t ATS_Channel;
     uint32_t Spare1;
     uint32_t Spare2;
     uint8_t  Unit_Empty;
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Dispenser_Card/EEPROM/Dispenser_EEPROM.c b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Dispenser_Card/EEPROM/Dispenser_EEPROM.c
index 1c9935a52..346eb65f6 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Dispenser_Card/EEPROM/Dispenser_EEPROM.c
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Dispenser_Card/EEPROM/Dispenser_EEPROM.c
@@ -21,6 +21,10 @@
 #include <drivers/FPGA/FPGA_Comm.h>
 #include "drivers/FPGA/FPGA_GPIO/FPGA_GPIO.h"
 
+#include "PMR/Diagnostics/DispenserEEprom.pb-c.h"
+#include "PMR/Diagnostics/DispenserEEpromRequest.pb-c.h"
+#include "PMR/Diagnostics/DispenserEEpromResponse.pb-c.h"
+
 
 
 #define I2C_Slave_EEprom_Add   0xA0 //eeprom address - 32kByte & 128kByte
@@ -235,5 +239,164 @@ uint8_t Check_Dispenser_Type(uint8_t Dispenser_ID)
 
     return Dispenser_struct[Dispenser_ID].Status;
 }
+uint32_t Get_EEPROM_DATA_From_Dispenser(int Dispenser_ID,DispenserEEprom *dispensereeprom)
+{
+    uint32_t status = OK;
+    status |= I2C_EEprom_Set_for_Read_Ch(Dispenser_ID, 0xA0);
+    status |= I2C_EEprom_Read_Ch(Dispenser_ID, 0xA0);
+
+    if (status == OK)
+    {
+        dispensereeprom->has_header = true;
+        dispensereeprom->header = Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.Header;
+        dispensereeprom->has_tablelength = true;
+        dispensereeprom->tablelength = Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.Table_Length;
+        dispensereeprom->has_tableversion = true;
+        dispensereeprom->tableversion = Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.Table_version;
+        memcpy(dispensereeprom->dispenserp_n,Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.Dispenser_Part_Number,sizeof(Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.Dispenser_Part_Number));
+        memcpy(dispensereeprom->pcbs_n,Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.PCB_SN,sizeof(Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.PCB_SN));
+        memcpy(dispensereeprom->pcbpartnumber,Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.PCB_Part_Number,sizeof(Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.PCB_Part_Number));
+        memcpy(dispensereeprom->dispensers_n,Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.Dispenser_SN,sizeof(Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.Dispenser_SN));
+        dispensereeprom->has_minimalpressure = true;
+        dispensereeprom->minimalpressure = Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.Maximal_Pressure;
+        dispensereeprom->has_maximalpressure = true;
+        dispensereeprom->maximalpressure = Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.Maximal_Pressure;
+        dispensereeprom->has_minimalmv = true;
+        dispensereeprom->minimalmv = Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.Minimal_MV;
+        dispensereeprom->has_maximalmv = true;
+        dispensereeprom->maximalmv = Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.Maximal_MV;
+        dispensereeprom->has_totalcycles = true;
+        dispensereeprom->totalcycles = Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.Total_Cycles;
+        dispensereeprom->has_bubblesize = true;
+        dispensereeprom->bubblesize = Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.Bubble_Size;
+        dispensereeprom->has_avg_nl_stepvalue_1_4 = true;
+        dispensereeprom->avg_nl_stepvalue_1_4 = Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.AVG_Nl_Step_Value_1_4;
+        dispensereeprom->has_avg_nl_stepvalue_2_4 = true;
+        dispensereeprom->avg_nl_stepvalue_2_4 = Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.AVG_Nl_Step_Value_2_4;
+        dispensereeprom->has_avg_nl_stepvalue_3_4 = true;
+        dispensereeprom->avg_nl_stepvalue_3_4 = Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.AVG_Nl_Step_Value_3_4;
+        dispensereeprom->has_avg_nl_stepvalue_4_4 = true;
+        dispensereeprom->avg_nl_stepvalue_4_4 = Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.AVG_Nl_Step_Value_4_4;
+        dispensereeprom->has_sw_reserve = true;
+        dispensereeprom->sw_reserve = Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.SW_Reserve;
+        dispensereeprom->has_spare1_pressure = true;
+        dispensereeprom->spare1_pressure = Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.Spare1_pressure;
+        dispensereeprom->has_spare2_pressure = true;
+        dispensereeprom->spare2_pressure = Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.Spare2_pressure;
+        dispensereeprom->has_motorpulsespercycle = true;
+        dispensereeprom->motorpulsespercycle = Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.Motor_PPC;
+        dispensereeprom->has_color = true;
+        dispensereeprom->color = Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.color;
+        dispensereeprom->has_pressureslope = true;
+        dispensereeprom->pressureslope = Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.Pressure_Slope;
+        memcpy(dispensereeprom->productiondate,Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.Production_Test_Date,sizeof(Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.Production_Test_Date));
+        dispensereeprom->has_atslocation = true;
+        dispensereeprom->atslocation = Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.ATS_Location;
+        dispensereeprom->has_spare1 = true;
+        dispensereeprom->spare1 = Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.Spare1;
+        dispensereeprom->has_spare2 = true;
+        dispensereeprom->spare2 = Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.Spare2;
+        dispensereeprom->has_atschannel = true;
+        dispensereeprom->atschannel = Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.ATS_Channel;
+        dispensereeprom->has_unitempty = true;
+        dispensereeprom->unitempty = Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.Unit_Empty;
+        dispensereeprom->has_dryrunpass_fail = true;
+        dispensereeprom->dryrunpass_fail = Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.Dry_Run_Status;
+        dispensereeprom->has_flowpass_fail = true;
+        dispensereeprom->flowpass_fail = Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.Flow_Status;
+        dispensereeprom->has_checksum = true;
+        dispensereeprom->checksum = Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.CheckSum;
+
+    }
+    return status;
+}
+uint32_t Prepare_EEPROM_DATA_For_Burning(int Dispenser_ID,DispenserEEprom *dispensereeprom)
+{
+    uint32_t status = OK;
+    Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.Header = dispensereeprom->header;
+    Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.Table_Length = dispensereeprom->tablelength;
+    Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.Table_version = dispensereeprom->tableversion;
+    Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.Maximal_Pressure = dispensereeprom->minimalpressure;
+    Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.Maximal_Pressure = dispensereeprom->maximalpressure;
+    Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.Minimal_MV = dispensereeprom->minimalmv;
+    Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.Maximal_MV = dispensereeprom->maximalmv;
+    Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.Total_Cycles = dispensereeprom->totalcycles;
+    Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.Bubble_Size = dispensereeprom->bubblesize;
+    Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.AVG_Nl_Step_Value_1_4 = dispensereeprom->avg_nl_stepvalue_1_4;
+    Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.AVG_Nl_Step_Value_2_4 = dispensereeprom->avg_nl_stepvalue_2_4;
+    Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.AVG_Nl_Step_Value_3_4 = dispensereeprom->avg_nl_stepvalue_3_4;
+    Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.AVG_Nl_Step_Value_4_4 = dispensereeprom->avg_nl_stepvalue_4_4;
+    Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.SW_Reserve = dispensereeprom->sw_reserve;
+    Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.Spare1_pressure = dispensereeprom->spare1_pressure;
+    Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.Spare2_pressure = dispensereeprom->spare2_pressure;
+    Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.Motor_PPC = dispensereeprom->motorpulsespercycle;
+    Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.color = dispensereeprom->color;
+    Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.Pressure_Slope = dispensereeprom->pressureslope;
+    Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.ATS_Location = dispensereeprom->atslocation;
+    Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.Spare1 = dispensereeprom->spare1;
+    Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.Spare2 = dispensereeprom->spare2;
+    Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.ATS_Channel = dispensereeprom->atschannel;
+    Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.Unit_Empty = dispensereeprom->unitempty;
+    Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.Dry_Run_Status = dispensereeprom->dryrunpass_fail;
+    Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.Flow_Status = dispensereeprom->flowpass_fail;
+    Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.CheckSum = dispensereeprom->checksum;
+    if (dispensereeprom->dispenserp_n)
+        strncpy(Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.Dispenser_Part_Number,dispensereeprom->dispenserp_n,sizeof(Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.Dispenser_Part_Number));
+    if (dispensereeprom->pcbs_n)
+        strncpy(Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.PCB_SN,dispensereeprom->pcbs_n,sizeof(Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.PCB_SN));
+    if (dispensereeprom->pcbpartnumber)
+        strncpy(Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.PCB_Part_Number,dispensereeprom->pcbpartnumber,sizeof(Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.PCB_Part_Number));
+    if (dispensereeprom->dispensers_n)
+        strncpy(Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.Dispenser_SN,dispensereeprom->dispensers_n,sizeof(Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.Dispenser_SN));
+    if (dispensereeprom->productiondate)
+        strncpy(Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.Production_Test_Date,dispensereeprom->productiondate,sizeof(Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.bytes.Production_Test_Date));
+    status = I2C_EEprom_Write_Ch(Dispenser_ID, 0xA0);
+    SysCtlDelay(5000000);//Must delay for at least 5 milli. !!!  (See data sheet )
+    return status;
+}
+uint32_t DispenserEEpromRequestFunc(MessageContainer* requestContainer)
+{
+    DispenserEEpromRequest *request = dispenser_eeprom_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
+    DispenserEEpromResponse Cresponse = DISPENSER_EEPROM_RESPONSE__INIT;
+    MessageContainer responseContainer;
+
+    uint32_t status = OK;
+    DispenserEEprom *DispenserEEpromInstance;
+    Report("DispenserEEpromRequestFunc",__FILE__,__LINE__,request->dispenserid,RpWarning,(int)request->burnrequest,0);
 
+    if (request->burnrequest == true)
+    {
+        status = Prepare_EEPROM_DATA_For_Burning(request->dispenserid,request->dispensereeprom);
+    }
+    else
+    {
+        DispenserEEpromInstance = my_malloc(sizeof(DispenserEEprom));
+        if (DispenserEEpromInstance)
+            status = Get_EEPROM_DATA_From_Dispenser(request->dispenserid,DispenserEEpromInstance);
+        else
+        {
+            status = FAILED;
+            LOG_ERROR(request->dispenserid,"my_malloc failed");
+        }
+    }
+    if ((request->burnrequest == false) && (status = OK))
+    {
+        Cresponse.dispensereeprom = DispenserEEpromInstance;
+    }
+    Cresponse.has_dispenserid = true;
+    Cresponse.dispenserid = request->dispenserid;
+    responseContainer = createContainer(MESSAGE_TYPE__DispenserEEpromResponse, requestContainer->token, true, &Cresponse, &dispenser_eeprom_response__pack, &dispenser_eeprom_response__get_packed_size);
+    responseContainer.continuous = false;
+    if (status != OK)
+    {
+        responseContainer.error = ERROR_CODE__INVALID_PARAMETER;
+        responseContainer.has_error = true;
+    }
+    uint8_t* container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
+    size_t container_size = message_container__pack(&responseContainer, container_buffer);
+    my_free(responseContainer.data.data);
+    SendChars((char*)container_buffer, container_size);
+    return OK;
+
+}
 
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Dispenser_Card/EEPROM/Dispenser_EEPROM.h b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Dispenser_Card/EEPROM/Dispenser_EEPROM.h
index 2db341914..3483e4033 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Dispenser_Card/EEPROM/Dispenser_EEPROM.h
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Dispenser_Card/EEPROM/Dispenser_EEPROM.h
@@ -12,11 +12,12 @@
 
 
 uint32_t I2C_EEprom_Write_Ch(uint8_t Dispenser_ID);
-uint32_t I2C_EEprom_Set_for_Read_Ch(uint8_t Dispenser_ID);;
+uint32_t I2C_EEprom_Set_for_Read_Ch(uint8_t Dispenser_ID);
 uint32_t I2C_EEprom_Read_Ch(uint8_t Dispenser_ID);
 uint32_t test_disp_eeprom(uint8_t Dispenser_ID , uint8_t EEprom_Add);
 uint8_t Check_Dispenser_Type();
 
+uint32_t DispenserEEpromRequestFunc(MessageContainer* requestContainer);
 
 
 #endif /* DRIVERS_I2C_COMMUNICATION_DISPENSERS_EEPROM_MUX_DISP_EEPROM_MUX_H_ */
diff --git a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
index 84b31c322..d31ea3c05 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
+++ b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
@@ -621,6 +621,7 @@ uint32_t MillisecLowLoop(uint32_t tick)
     }
     if(Fifty_msTick)
     {
+        WHS_Read_GPI_Registers();
         Trigger_PT100_Read();//call every 50mSec (minimum delay 30mSec)
         //Set_HeadCard_PT100();//call every 50mSec (minimum delay 30mSec)
     }
diff --git a/Software/Embedded_SW/Embedded/Modules/General/process.c b/Software/Embedded_SW/Embedded/Modules/General/process.c
index 5760d5b79..289cc6c7a 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/process.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/process.c
@@ -42,7 +42,7 @@ double dryerbufferMeters = 0;
 double dryerbufferCentimeters = 0;
 
 #define MAX_ALLOWED_TEMPERATURE 280
-
+int MaxAllowedTemperature = MAX_ALLOWED_TEMPERATURE;
 char ProcessParamsConfigPath[50] = "0://SysInfo//ProcessP.cfg";
 
 ProcessParameters ProcessParametersKeep;
@@ -85,16 +85,16 @@ uint32_t HandleProcessParameters(ProcessParameters* ProcessParams,bool saveData)
             ReportWithPackageFilter(InitFilter,"HandleProcessParameters NULL",__FILE__,(int)__LINE__,(int)0,RpWarning,(int)0,0);
             return status;
         }
-    if (ProcessParams->dryerzone1temp > MAX_ALLOWED_TEMPERATURE) status = ERROR_CODE__INVALID_PARAMETER;
-    if (ProcessParams->dryerzone2temp > MAX_ALLOWED_TEMPERATURE) status = ERROR_CODE__INVALID_PARAMETER;
-    if (ProcessParams->dryerzone3temp > MAX_ALLOWED_TEMPERATURE) status = ERROR_CODE__INVALID_PARAMETER;
-    if (ProcessParams->mixertemp > MAX_ALLOWED_TEMPERATURE) status = ERROR_CODE__INVALID_PARAMETER;
-    if (ProcessParams->headzone1temp > MAX_ALLOWED_TEMPERATURE) status = ERROR_CODE__INVALID_PARAMETER;
-    if (ProcessParams->headzone2temp > MAX_ALLOWED_TEMPERATURE) status = ERROR_CODE__INVALID_PARAMETER;
-    if (ProcessParams->headzone3temp > MAX_ALLOWED_TEMPERATURE) status = ERROR_CODE__INVALID_PARAMETER;
-    if (ProcessParams->headzone4temp > MAX_ALLOWED_TEMPERATURE) status = ERROR_CODE__INVALID_PARAMETER;
-    if (ProcessParams->headzone5temp > MAX_ALLOWED_TEMPERATURE) status = ERROR_CODE__INVALID_PARAMETER;
-    if (ProcessParams->headzone6temp > MAX_ALLOWED_TEMPERATURE) status = ERROR_CODE__INVALID_PARAMETER;
+    if (ProcessParams->dryerzone1temp > MaxAllowedTemperature) status = ERROR_CODE__INVALID_PARAMETER;
+    if (ProcessParams->dryerzone2temp > MaxAllowedTemperature) status = ERROR_CODE__INVALID_PARAMETER;
+    if (ProcessParams->dryerzone3temp > MaxAllowedTemperature) status = ERROR_CODE__INVALID_PARAMETER;
+    if (ProcessParams->mixertemp > MaxAllowedTemperature) status = ERROR_CODE__INVALID_PARAMETER;
+    if (ProcessParams->headzone1temp > MaxAllowedTemperature) status = ERROR_CODE__INVALID_PARAMETER;
+    if (ProcessParams->headzone2temp > MaxAllowedTemperature) status = ERROR_CODE__INVALID_PARAMETER;
+    if (ProcessParams->headzone3temp > MaxAllowedTemperature) status = ERROR_CODE__INVALID_PARAMETER;
+    if (ProcessParams->headzone4temp > MaxAllowedTemperature) status = ERROR_CODE__INVALID_PARAMETER;
+    if (ProcessParams->headzone5temp > MaxAllowedTemperature) status = ERROR_CODE__INVALID_PARAMETER;
+    if (ProcessParams->headzone6temp > MaxAllowedTemperature) status = ERROR_CODE__INVALID_PARAMETER;
     if (status != 0)
     {
         ReportWithPackageFilter(InitFilter,"HandleProcessParameters Temperature too high",__FILE__,(int)__LINE__,(int)status,RpWarning,(int)0,0);
diff --git a/Software/Embedded_SW/Embedded/Modules/General/process.h b/Software/Embedded_SW/Embedded/Modules/General/process.h
index 695cf9516..6be41bccb 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/process.h
+++ b/Software/Embedded_SW/Embedded/Modules/General/process.h
@@ -31,6 +31,7 @@ extern uint32_t HandleProcessParameters(ProcessParameters* ProcessParams,bool sa
 uint32_t LoadProcessParamsFromFile(void);
 uint32_t ProcessParamsInit(void);
 
+extern int MaxAllowedTemperature;
 
 
 #endif /* MODULES_GENERAL_PROCESS_H_ */
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
index 53f395198..c13b8ca15 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
@@ -1509,6 +1509,8 @@ void HeaterSafetyTestSetLimits(int limit)
      RemoveControlCallback(DisasterControlId, HeatersDisasterControl);
      RemoveControlCallback(MainDryerHeaterMaxTempControl ,HeaterMaxTempCBFunction);
      RemoveControlCallback(SecondDryerHeaterMaxTempControl ,HeaterMaxTempCBFunction);
+
+     MaxAllowedTemperature = limit+1;
 }
 
 bool UseSecondaryDrierHeater = true;
diff --git a/Software/Embedded_SW/Embedded/Modules/Waste/Waste_init.c b/Software/Embedded_SW/Embedded/Modules/Waste/Waste_init.c
index c8101c031..7da33efc3 100644
--- a/Software/Embedded_SW/Embedded/Modules/Waste/Waste_init.c
+++ b/Software/Embedded_SW/Embedded/Modules/Waste/Waste_init.c
@@ -450,7 +450,7 @@ U8 CartridgeWasteFilling(bool status)
 bool RdWasteTankEmptySensor()
 {
     bool ret = notOK;
-    WHS_Read_GPI_Registers();
+    //WHS_Read_GPI_Registers();
     //WHS_info.WHS_sensors.waste_tank_empty_sensor = WHS_GPI_WCONTAINER_WARN();
     //ret = WHS_info.WHS_sensors.waste_tank_empty_sensor;
      ret = WHS_GPI_WCONTAINER_WARN();
@@ -460,7 +460,7 @@ bool RdWasteTankEmptySensor()
 bool RdWasteTankFullSensor()
 {
     bool ret = notOK;
-    WHS_Read_GPI_Registers();
+    //WHS_Read_GPI_Registers();
     //WHS_info.WHS_sensors.waste_tank_full_sensor =  WHS_GPI_WCONTAINER_FULL();
     //ret = WHS_info.WHS_sensors.waste_tank_full_sensor;
     ret = WHS_GPI_WCONTAINER_FULL();
@@ -470,7 +470,7 @@ bool RdWasteTankFullSensor()
 bool RdWasteTankOverFlowSensor()
 {
     bool ret = notOK;
-    WHS_Read_GPI_Registers();
+    //WHS_Read_GPI_Registers();
     //WHS_info.WHS_sensors.waste_tank_over_flow_sensor =  WHS_GPI_WASTE_OVERFULL();
     //ret = WHS_info.WHS_sensors.waste_tank_over_flow_sensor;
     ret = WHS_GPI_WASTE_OVERFULL();
@@ -940,7 +940,7 @@ bool RdCartridgeCoverSensor()
 
     //REPORT_MSG(parameter," ------------ RD Cartridge Cover Sensor    ----------------- ");
     bool ret = notOK;
-    WHS_Read_GPI_Registers();
+    //WHS_Read_GPI_Registers();
    // WHS_info.WHS_sensors.cartridge_cover = Get_COVER_1_State(CartridgesDoor);
    // ret = WHS_info.WHS_sensors.cartridge_cover;
     ret = Get_COVER_1_State(CartridgesDoor);
@@ -1146,7 +1146,7 @@ bool InitCartStatus()
 bool RdInkCartridgeSensor()
 {
     bool ret = notOK;
-    WHS_Read_GPI_Registers();
+    //WHS_Read_GPI_Registers();
     ret = Is_Cartridge_Present(CART_1);
     return ret;
 }
@@ -1154,7 +1154,7 @@ bool RdInkCartridgeSensor()
 bool RdWasteCartridge1Sensor()
 {
     bool ret = notOK;
-    WHS_Read_GPI_Registers();
+    //WHS_Read_GPI_Registers();
     ret = Is_Cartridge_Present(CART_2);
     return ret;
 }
@@ -1162,7 +1162,7 @@ bool RdWasteCartridge1Sensor()
 bool RdWasteCartridge2Sensor()
 {
     bool ret = notOK;
-    WHS_Read_GPI_Registers();
+    //WHS_Read_GPI_Registers();
     ret = Is_Cartridge_Present(CART_3);
     return ret;
 }
@@ -1248,7 +1248,7 @@ U8 WHS_init(void)
 bool RdWasteTankFilterSensor()
 {
     bool ret = notOK;
-    WHS_Read_GPI_Registers();
+    //WHS_Read_GPI_Registers();
     WHS_info.WHS_sensors.waste_tank_filter_sensor = WHS_GPI_SW_FILTER_PRES();
     ret = WHS_info.WHS_sensors.waste_tank_filter_sensor;
     return ret;
diff --git a/Software/Embedded_SW/Embedded/Software Release Notes.txt b/Software/Embedded_SW/Embedded/Software Release Notes.txt
index 7640e88de..9a1eb66c4 100644
--- a/Software/Embedded_SW/Embedded/Software Release Notes.txt
+++ b/Software/Embedded_SW/Embedded/Software Release Notes.txt
@@ -1,3 +1,16 @@
+Embedded SW Release note - Version 1.4.6.20 - Pack 1+ 
+=============================================================
+File system improved
+Cleaning job (simple job, 143 meters) NOT TESTED YET
+improved RML - dancers tension, cleaning and more
+support new LTFU - tension changes in job, loading thread
+fix bug in alarm handling predecessor
+fix lids homing actions
+cancel obsolete embedded parameters
+support heaters limit tests for Nadav
+support dye head sequence changes for uniformity
+fix tamper alarms
+
 Embedded SW Release note - Version 1.4.6.17 - Pack 1 
 =============================================================
 fixed file system bug that caused disconnection.