Support for new head in ProtoBif and embedded (initial)

46 files changed, 1936 insertions, 872 deletions

diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/DiagnosticsMonitors.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/DiagnosticsMonitors.pb-c.c
index ae8c238a9..fdd62c3e9 100644
--- a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/DiagnosticsMonitors.pb-c.c
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/DiagnosticsMonitors.pb-c.c
@@ -52,7 +52,7 @@ void   diagnostics_monitors__free_unpacked
   assert(message->base.descriptor == &diagnostics_monitors__descriptor);
   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 }
-static const ProtobufCFieldDescriptor diagnostics_monitors__field_descriptors[66] =
+static const ProtobufCFieldDescriptor diagnostics_monitors__field_descriptors[85] =
 {
   {
     "Dancer1Angle",
@@ -846,6 +846,234 @@ static const ProtobufCFieldDescriptor diagnostics_monitors__field_descriptors[66
     0,             /* flags */
     0,NULL,NULL    /* reserved1,reserved2, etc */
   },
+  {
+    "HeadZone7HeaterCurrent",
+    67,
+    PROTOBUF_C_LABEL_REPEATED,
+    PROTOBUF_C_TYPE_DOUBLE,
+    offsetof(DiagnosticsMonitors, n_headzone7heatercurrent),
+    offsetof(DiagnosticsMonitors, headzone7heatercurrent),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "HeadZone7Temperature",
+    68,
+    PROTOBUF_C_LABEL_REPEATED,
+    PROTOBUF_C_TYPE_DOUBLE,
+    offsetof(DiagnosticsMonitors, n_headzone7temperature),
+    offsetof(DiagnosticsMonitors, headzone7temperature),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "HeadZone8HeaterCurrent",
+    69,
+    PROTOBUF_C_LABEL_REPEATED,
+    PROTOBUF_C_TYPE_DOUBLE,
+    offsetof(DiagnosticsMonitors, n_headzone8heatercurrent),
+    offsetof(DiagnosticsMonitors, headzone8heatercurrent),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "HeadZone8Temperature",
+    70,
+    PROTOBUF_C_LABEL_REPEATED,
+    PROTOBUF_C_TYPE_DOUBLE,
+    offsetof(DiagnosticsMonitors, n_headzone8temperature),
+    offsetof(DiagnosticsMonitors, headzone8temperature),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "HeadZone9HeaterCurrent",
+    71,
+    PROTOBUF_C_LABEL_REPEATED,
+    PROTOBUF_C_TYPE_DOUBLE,
+    offsetof(DiagnosticsMonitors, n_headzone9heatercurrent),
+    offsetof(DiagnosticsMonitors, headzone9heatercurrent),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "HeadZone9Temperature",
+    72,
+    PROTOBUF_C_LABEL_REPEATED,
+    PROTOBUF_C_TYPE_DOUBLE,
+    offsetof(DiagnosticsMonitors, n_headzone9temperature),
+    offsetof(DiagnosticsMonitors, headzone9temperature),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "HeadZone10HeaterCurrent",
+    73,
+    PROTOBUF_C_LABEL_REPEATED,
+    PROTOBUF_C_TYPE_DOUBLE,
+    offsetof(DiagnosticsMonitors, n_headzone10heatercurrent),
+    offsetof(DiagnosticsMonitors, headzone10heatercurrent),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "HeadZone10Temperature",
+    74,
+    PROTOBUF_C_LABEL_REPEATED,
+    PROTOBUF_C_TYPE_DOUBLE,
+    offsetof(DiagnosticsMonitors, n_headzone10temperature),
+    offsetof(DiagnosticsMonitors, headzone10temperature),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "HeadZone11HeaterCurrent",
+    75,
+    PROTOBUF_C_LABEL_REPEATED,
+    PROTOBUF_C_TYPE_DOUBLE,
+    offsetof(DiagnosticsMonitors, n_headzone11heatercurrent),
+    offsetof(DiagnosticsMonitors, headzone11heatercurrent),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "HeadZone11Temperature",
+    76,
+    PROTOBUF_C_LABEL_REPEATED,
+    PROTOBUF_C_TYPE_DOUBLE,
+    offsetof(DiagnosticsMonitors, n_headzone11temperature),
+    offsetof(DiagnosticsMonitors, headzone11temperature),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "HeadZone12HeaterCurrent",
+    77,
+    PROTOBUF_C_LABEL_REPEATED,
+    PROTOBUF_C_TYPE_DOUBLE,
+    offsetof(DiagnosticsMonitors, n_headzone12heatercurrent),
+    offsetof(DiagnosticsMonitors, headzone12heatercurrent),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "HeadZone12Temperature",
+    78,
+    PROTOBUF_C_LABEL_REPEATED,
+    PROTOBUF_C_TYPE_DOUBLE,
+    offsetof(DiagnosticsMonitors, n_headzone12temperature),
+    offsetof(DiagnosticsMonitors, headzone12temperature),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "HeadBlowerVoltage1",
+    79,
+    PROTOBUF_C_LABEL_REPEATED,
+    PROTOBUF_C_TYPE_DOUBLE,
+    offsetof(DiagnosticsMonitors, n_headblowervoltage1),
+    offsetof(DiagnosticsMonitors, headblowervoltage1),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "HeadBlowerVoltage2",
+    80,
+    PROTOBUF_C_LABEL_REPEATED,
+    PROTOBUF_C_TYPE_DOUBLE,
+    offsetof(DiagnosticsMonitors, n_headblowervoltage2),
+    offsetof(DiagnosticsMonitors, headblowervoltage2),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "HeadCoverHeater1Current",
+    81,
+    PROTOBUF_C_LABEL_REPEATED,
+    PROTOBUF_C_TYPE_DOUBLE,
+    offsetof(DiagnosticsMonitors, n_headcoverheater1current),
+    offsetof(DiagnosticsMonitors, headcoverheater1current),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "HeadCoverHeater1Temperature",
+    82,
+    PROTOBUF_C_LABEL_REPEATED,
+    PROTOBUF_C_TYPE_DOUBLE,
+    offsetof(DiagnosticsMonitors, n_headcoverheater1temperature),
+    offsetof(DiagnosticsMonitors, headcoverheater1temperature),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "HeadCoverHeater2Current",
+    83,
+    PROTOBUF_C_LABEL_REPEATED,
+    PROTOBUF_C_TYPE_DOUBLE,
+    offsetof(DiagnosticsMonitors, n_headcoverheater2current),
+    offsetof(DiagnosticsMonitors, headcoverheater2current),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "HeadCoverHeater2Temperature",
+    84,
+    PROTOBUF_C_LABEL_REPEATED,
+    PROTOBUF_C_TYPE_DOUBLE,
+    offsetof(DiagnosticsMonitors, n_headcoverheater2temperature),
+    offsetof(DiagnosticsMonitors, headcoverheater2temperature),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "WHSBlower2Voltage",
+    85,
+    PROTOBUF_C_LABEL_REPEATED,
+    PROTOBUF_C_TYPE_DOUBLE,
+    offsetof(DiagnosticsMonitors, n_whsblower2voltage),
+    offsetof(DiagnosticsMonitors, whsblower2voltage),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
 };
 static const unsigned diagnostics_monitors__field_indices_by_name[] = {
   38,   /* field[38] = BlowerVoltage */
@@ -885,6 +1113,18 @@ static const unsigned diagnostics_monitors__field_indices_by_name[] = {
   14,   /* field[14] = FeederTension */
   25,   /* field[25] = FilterDeltaPressure */
   13,   /* field[13] = HeadAirFlow */
+  78,   /* field[78] = HeadBlowerVoltage1 */
+  79,   /* field[79] = HeadBlowerVoltage2 */
+  80,   /* field[80] = HeadCoverHeater1Current */
+  81,   /* field[81] = HeadCoverHeater1Temperature */
+  82,   /* field[82] = HeadCoverHeater2Current */
+  83,   /* field[83] = HeadCoverHeater2Temperature */
+  72,   /* field[72] = HeadZone10HeaterCurrent */
+  73,   /* field[73] = HeadZone10Temperature */
+  74,   /* field[74] = HeadZone11HeaterCurrent */
+  75,   /* field[75] = HeadZone11Temperature */
+  76,   /* field[76] = HeadZone12HeaterCurrent */
+  77,   /* field[77] = HeadZone12Temperature */
   57,   /* field[57] = HeadZone1HeaterCurrent */
   10,   /* field[10] = HeadZone1Temperature */
   58,   /* field[58] = HeadZone2HeaterCurrent */
@@ -896,6 +1136,12 @@ static const unsigned diagnostics_monitors__field_indices_by_name[] = {
   36,   /* field[36] = HeadZone5Temperature */
   61,   /* field[61] = HeadZone5_6HeaterCurrent */
   37,   /* field[37] = HeadZone6Temperature */
+  66,   /* field[66] = HeadZone7HeaterCurrent */
+  67,   /* field[67] = HeadZone7Temperature */
+  68,   /* field[68] = HeadZone8HeaterCurrent */
+  69,   /* field[69] = HeadZone8Temperature */
+  70,   /* field[70] = HeadZone9HeaterCurrent */
+  71,   /* field[71] = HeadZone9Temperature */
   47,   /* field[47] = MidTank1Level */
   48,   /* field[48] = MidTank2Level */
   49,   /* field[49] = MidTank3Level */
@@ -912,13 +1158,14 @@ static const unsigned diagnostics_monitors__field_indices_by_name[] = {
   15,   /* field[15] = PullerTension */
   7,   /* field[7] = ScrewMotor */
   8,   /* field[8] = ThreadSpeed */
+  84,   /* field[84] = WHSBlower2Voltage */
   6,   /* field[6] = WinderMotor */
   20,   /* field[20] = WinderTension */
 };
 static const ProtobufCIntRange diagnostics_monitors__number_ranges[1 + 1] =
 {
   { 1, 0 },
-  { 0, 66 }
+  { 0, 85 }
 };
 const ProtobufCMessageDescriptor diagnostics_monitors__descriptor =
 {
@@ -928,7 +1175,7 @@ const ProtobufCMessageDescriptor diagnostics_monitors__descriptor =
   "DiagnosticsMonitors",
   "",
   sizeof(DiagnosticsMonitors),
-  66,
+  85,
   diagnostics_monitors__field_descriptors,
   diagnostics_monitors__field_indices_by_name,
   1,  diagnostics_monitors__number_ranges,
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/DiagnosticsMonitors.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/DiagnosticsMonitors.pb-c.h
index 203c1d92c..38ee1ce97 100644
--- a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/DiagnosticsMonitors.pb-c.h
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/DiagnosticsMonitors.pb-c.h
@@ -159,10 +159,48 @@ struct  _DiagnosticsMonitors
   DoubleArray **midtanksinklevel;
   size_t n_overalltemperature;
   double *overalltemperature;
+  size_t n_headzone7heatercurrent;
+  double *headzone7heatercurrent;
+  size_t n_headzone7temperature;
+  double *headzone7temperature;
+  size_t n_headzone8heatercurrent;
+  double *headzone8heatercurrent;
+  size_t n_headzone8temperature;
+  double *headzone8temperature;
+  size_t n_headzone9heatercurrent;
+  double *headzone9heatercurrent;
+  size_t n_headzone9temperature;
+  double *headzone9temperature;
+  size_t n_headzone10heatercurrent;
+  double *headzone10heatercurrent;
+  size_t n_headzone10temperature;
+  double *headzone10temperature;
+  size_t n_headzone11heatercurrent;
+  double *headzone11heatercurrent;
+  size_t n_headzone11temperature;
+  double *headzone11temperature;
+  size_t n_headzone12heatercurrent;
+  double *headzone12heatercurrent;
+  size_t n_headzone12temperature;
+  double *headzone12temperature;
+  size_t n_headblowervoltage1;
+  double *headblowervoltage1;
+  size_t n_headblowervoltage2;
+  double *headblowervoltage2;
+  size_t n_headcoverheater1current;
+  double *headcoverheater1current;
+  size_t n_headcoverheater1temperature;
+  double *headcoverheater1temperature;
+  size_t n_headcoverheater2current;
+  double *headcoverheater2current;
+  size_t n_headcoverheater2temperature;
+  double *headcoverheater2temperature;
+  size_t n_whsblower2voltage;
+  double *whsblower2voltage;
 };
 #define DIAGNOSTICS_MONITORS__INIT \
  { PROTOBUF_C_MESSAGE_INIT (&diagnostics_monitors__descriptor) \
-    , 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL }
+    , 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL }
 
 
 /* DiagnosticsMonitors methods */
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/EventType.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/EventType.pb-c.c
index 9c97628bb..dbd0f88e0 100644
--- a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/EventType.pb-c.c
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/EventType.pb-c.c
@@ -7,7 +7,7 @@
 #endif
 
 #include "EventType.pb-c.h"
-static const ProtobufCEnumValue event_type__enum_values_by_number[291] =
+static const ProtobufCEnumValue event_type__enum_values_by_number[294] =
 {
   { "None", "EVENT_TYPE__None", 0 },
   { "REQUEST_SENT", "EVENT_TYPE__REQUEST_SENT", 1000 },
@@ -43,6 +43,8 @@ static const ProtobufCEnumValue event_type__enum_values_by_number[291] =
   { "UNSPECIFIED", "EVENT_TYPE__UNSPECIFIED", 2016 },
   { "MACHINE_INTERNAL_OVERTEMPERATURE_2", "EVENT_TYPE__MACHINE_INTERNAL_OVERTEMPERATURE_2", 2017 },
   { "ELECTRICAL_CABINET_OVERTEMPERATURE", "EVENT_TYPE__ELECTRICAL_CABINET_OVERTEMPERATURE", 2018 },
+  { "FPGA_WATCHDOG_ACTIVATED", "EVENT_TYPE__FPGA_WATCHDOG_ACTIVATED", 2019 },
+  { "UNINTENDED_RESET", "EVENT_TYPE__UNINTENDED_RESET", 2020 },
   { "THREAD_BREAK", "EVENT_TYPE__THREAD_BREAK", 3000 },
   { "THREAD_TENSION_CONTROL_FAILURE_FEEDER_DANCER", "EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_FEEDER_DANCER", 3001 },
   { "WINDER_CONE_DOES_NOT_EXIST", "EVENT_TYPE__WINDER_CONE_DOES_NOT_EXIST", 3002 },
@@ -94,6 +96,7 @@ static const ProtobufCEnumValue event_type__enum_values_by_number[291] =
   { "THREAD_TENSION_CONTROL_FAILURE_PULLER_DANCER", "EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_PULLER_DANCER", 3048 },
   { "THREAD_TENSION_CONTROL_FAILURE_WINDER_DANCER", "EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_WINDER_DANCER", 3049 },
   { "MACHINE_STATE_NO_THREAD_DETECTED", "EVENT_TYPE__MACHINE_STATE_NO_THREAD_DETECTED", 3050 },
+  { "THREAD_LOADING_ERROR", "EVENT_TYPE__THREAD_LOADING_ERROR", 3051 },
   { "DRYER_MOTOR_OVERCURRENT", "EVENT_TYPE__DRYER_MOTOR_OVERCURRENT", 4000 },
   { "DRYER_MOTOR_OVERTEMPERATURE", "EVENT_TYPE__DRYER_MOTOR_OVERTEMPERATURE", 4001 },
   { "DRYER_MOTOR_STALL", "EVENT_TYPE__DRYER_MOTOR_STALL", 4002 },
@@ -302,206 +305,207 @@ static const ProtobufCEnumValue event_type__enum_values_by_number[291] =
   { "WASTE_CARTRIDGE_RFID_TIMEOUT", "EVENT_TYPE__WASTE_CARTRIDGE_RFID_TIMEOUT", 10005 },
 };
 static const ProtobufCIntRange event_type__value_ranges[] = {
-{0, 0},{1000, 1},{2000, 15},{3000, 34},{4000, 85},{5000, 107},{6000, 150},{7000, 156},{8000, 244},{9000, 276},{10000, 285},{0, 291}
+{0, 0},{1000, 1},{2000, 15},{3000, 36},{4000, 88},{5000, 110},{6000, 153},{7000, 159},{8000, 247},{9000, 279},{10000, 288},{0, 294}
 };
-static const ProtobufCEnumValueIndex event_type__enum_values_by_name[291] =
+static const ProtobufCEnumValueIndex event_type__enum_values_by_name[294] =
 {
-  { "AIR_FILTER_CLOGGED", 277 },
-  { "AIR_FILTER_NOT_INSTALLED", 276 },
-  { "ALL_WASTE_CARTRIDGES_FULL", 288 },
+  { "AIR_FILTER_CLOGGED", 280 },
+  { "AIR_FILTER_NOT_INSTALLED", 279 },
+  { "ALL_WASTE_CARTRIDGES_FULL", 291 },
   { "APPLICATION_EXCEPTION", 4 },
   { "APPLICATION_INFORMATION", 5 },
   { "APPLICATION_STARTED", 6 },
   { "APPLICATION_TERMINATED", 7 },
   { "CARTRIDGES_COVER_OPEN", 21 },
-  { "CHILLER_DRY_CONTACT", 282 },
-  { "DISPENSER_1_EMPTY", 172 },
-  { "DISPENSER_1_HIGH_PRESSURE", 236 },
-  { "DISPENSER_1_LOWER_HARD_LIMIT", 228 },
-  { "DISPENSER_1_MOTOR_OVERCURRENT", 188 },
-  { "DISPENSER_1_MOTOR_OVERTEMPERATURE", 196 },
-  { "DISPENSER_1_MOTOR_STALL", 204 },
-  { "DISPENSER_1_MOTOR_UNDERVOLTAGE", 212 },
-  { "DISPENSER_1_OVERPRESSURE", 156 },
-  { "DISPENSER_1_REFILL_FAILURE", 180 },
-  { "DISPENSER_1_UNDERPRESSURE", 164 },
-  { "DISPENSER_1_UPPER_HARD_LIMIT", 220 },
-  { "DISPENSER_2_EMPTY", 173 },
-  { "DISPENSER_2_HIGH_PRESSURE", 237 },
-  { "DISPENSER_2_LOWER_HARD_LIMIT", 229 },
-  { "DISPENSER_2_MOTOR_OVERCURRENT", 189 },
-  { "DISPENSER_2_MOTOR_OVERTEMPERATURE", 197 },
-  { "DISPENSER_2_MOTOR_STALL", 205 },
-  { "DISPENSER_2_MOTOR_UNDERVOLTAGE", 213 },
-  { "DISPENSER_2_OVERPRESSURE", 157 },
-  { "DISPENSER_2_REFILL_FAILURE", 181 },
-  { "DISPENSER_2_UNDERPRESSURE", 165 },
-  { "DISPENSER_2_UPPER_HARD_LIMIT", 221 },
-  { "DISPENSER_3_EMPTY", 174 },
-  { "DISPENSER_3_HIGH_PRESSURE", 238 },
-  { "DISPENSER_3_LOWER_HARD_LIMIT", 230 },
-  { "DISPENSER_3_MOTOR_OVERCURRENT", 190 },
-  { "DISPENSER_3_MOTOR_OVERTEMPERATURE", 198 },
-  { "DISPENSER_3_MOTOR_STALL", 206 },
-  { "DISPENSER_3_MOTOR_UNDERVOLTAGE", 214 },
-  { "DISPENSER_3_OVERPRESSURE", 158 },
-  { "DISPENSER_3_REFILL_FAILURE", 182 },
-  { "DISPENSER_3_UNDERPRESSURE", 166 },
-  { "DISPENSER_3_UPPER_HARD_LIMIT", 222 },
-  { "DISPENSER_4_EMPTY", 175 },
-  { "DISPENSER_4_HIGH_PRESSURE", 239 },
-  { "DISPENSER_4_LOWER_HARD_LIMIT", 231 },
-  { "DISPENSER_4_MOTOR_OVERCURRENT", 191 },
-  { "DISPENSER_4_MOTOR_OVERTEMPERATURE", 199 },
-  { "DISPENSER_4_MOTOR_STALL", 207 },
-  { "DISPENSER_4_MOTOR_UNDERVOLTAGE", 215 },
-  { "DISPENSER_4_OVERPRESSURE", 159 },
-  { "DISPENSER_4_REFILL_FAILURE", 183 },
-  { "DISPENSER_4_UNDERPRESSURE", 167 },
-  { "DISPENSER_4_UPPER_HARD_LIMIT", 223 },
-  { "DISPENSER_5_EMPTY", 176 },
-  { "DISPENSER_5_HIGH_PRESSURE", 240 },
-  { "DISPENSER_5_LOWER_HARD_LIMIT", 232 },
-  { "DISPENSER_5_MOTOR_OVERCURRENT", 192 },
-  { "DISPENSER_5_MOTOR_OVERTEMPERATURE", 200 },
-  { "DISPENSER_5_MOTOR_STALL", 208 },
-  { "DISPENSER_5_MOTOR_UNDERVOLTAGE", 216 },
-  { "DISPENSER_5_OVERPRESSURE", 160 },
-  { "DISPENSER_5_REFILL_FAILURE", 184 },
-  { "DISPENSER_5_UNDERPRESSURE", 168 },
-  { "DISPENSER_5_UPPER_HARD_LIMIT", 224 },
-  { "DISPENSER_6_EMPTY", 177 },
-  { "DISPENSER_6_HIGH_PRESSURE", 241 },
-  { "DISPENSER_6_LOWER_HARD_LIMIT", 233 },
-  { "DISPENSER_6_MOTOR_OVERCURRENT", 193 },
-  { "DISPENSER_6_MOTOR_OVERTEMPERATURE", 201 },
-  { "DISPENSER_6_MOTOR_STALL", 209 },
-  { "DISPENSER_6_MOTOR_UNDERVOLTAGE", 217 },
-  { "DISPENSER_6_OVERPRESSURE", 161 },
-  { "DISPENSER_6_REFILL_FAILURE", 185 },
-  { "DISPENSER_6_UNDERPRESSURE", 169 },
-  { "DISPENSER_6_UPPER_HARD_LIMIT", 225 },
-  { "DISPENSER_7_EMPTY", 178 },
-  { "DISPENSER_7_HIGH_PRESSURE", 242 },
-  { "DISPENSER_7_LOWER_HARD_LIMIT", 234 },
-  { "DISPENSER_7_MOTOR_OVERCURRENT", 194 },
-  { "DISPENSER_7_MOTOR_OVERTEMPERATURE", 202 },
-  { "DISPENSER_7_MOTOR_STALL", 210 },
-  { "DISPENSER_7_MOTOR_UNDERVOLTAGE", 218 },
-  { "DISPENSER_7_OVERPRESSURE", 162 },
-  { "DISPENSER_7_REFILL_FAILURE", 186 },
-  { "DISPENSER_7_UNDERPRESSURE", 170 },
-  { "DISPENSER_7_UPPER_HARD_LIMIT", 226 },
-  { "DISPENSER_8_EMPTY", 179 },
-  { "DISPENSER_8_HIGH_PRESSURE", 243 },
-  { "DISPENSER_8_LOWER_HARD_LIMIT", 235 },
-  { "DISPENSER_8_MOTOR_OVERCURRENT", 195 },
-  { "DISPENSER_8_MOTOR_OVERTEMPERATURE", 203 },
-  { "DISPENSER_8_MOTOR_STALL", 211 },
-  { "DISPENSER_8_MOTOR_UNDERVOLTAGE", 219 },
-  { "DISPENSER_8_OVERPRESSURE", 163 },
-  { "DISPENSER_8_REFILL_FAILURE", 187 },
-  { "DISPENSER_8_UNDERPRESSURE", 171 },
-  { "DISPENSER_8_UPPER_HARD_LIMIT", 227 },
-  { "DRYER_DOOR_OPEN", 89 },
-  { "DRYER_FAN_RPM_TOO_LOW", 100 },
-  { "DRYER_FAN_STOPPED", 101 },
-  { "DRYER_HEATERS_ZONE_1_CURRENT_LOOP_BREAK", 98 },
-  { "DRYER_HEATERS_ZONE_1_CURRENT_OUT_OF_RANGE", 96 },
-  { "DRYER_HEATERS_ZONE_2_CURRENT_LOOP_BREAK", 99 },
-  { "DRYER_HEATERS_ZONE_2_CURRENT_OUT_OF_RANGE", 97 },
-  { "DRYER_LID_MOTOR_OVERCURRENT", 102 },
-  { "DRYER_LID_MOTOR_OVERTEMPERATURE", 103 },
-  { "DRYER_LID_MOTOR_STALL", 104 },
-  { "DRYER_LID_MOTOR_UNDERVOLTAGE", 105 },
-  { "DRYER_MOTOR_OVERCURRENT", 85 },
-  { "DRYER_MOTOR_OVERTEMPERATURE", 86 },
-  { "DRYER_MOTOR_STALL", 87 },
-  { "DRYER_MOTOR_UNDERVOLTAGE", 88 },
-  { "DRYER_THERMAL_CUTOFF", 95 },
-  { "DRYER_ZONE_1_OVERTEMPERATURE", 90 },
-  { "DRYER_ZONE_1_UNDERTEMPERATURE_A", 92 },
-  { "DRYER_ZONE_1_UNDERTEMPERATURE_B", 93 },
-  { "DRYER_ZONE_2_OVERTEMPERATURE", 91 },
-  { "DRYER_ZONE_2_UNDERTEMPERATURE_A", 106 },
-  { "DRYER_ZONE_2_UNDERTEMPERATURE_B", 94 },
-  { "DYEING_HEAD_CLEANING_HEAD_MOTOR_OVERCURRENT", 146 },
-  { "DYEING_HEAD_CLEANING_HEAD_MOTOR_OVERTEMPERATURE", 147 },
-  { "DYEING_HEAD_CLEANING_HEAD_MOTOR_STALL", 148 },
-  { "DYEING_HEAD_CLEANING_HEAD_MOTOR_UNDERVOLTAGE", 149 },
-  { "DYEING_HEAD_CLEANING_MECHANISM_MOTOR_OVERCURRENT", 142 },
-  { "DYEING_HEAD_CLEANING_MECHANISM_MOTOR_OVERTEMPERATURE", 143 },
-  { "DYEING_HEAD_CLEANING_MECHANISM_MOTOR_STALL", 144 },
-  { "DYEING_HEAD_CLEANING_MECHANISM_MOTOR_UNDERVOLTAGE", 145 },
-  { "DYEING_HEAD_COVER_CLOSE_TIMEOUT", 137 },
-  { "DYEING_HEAD_COVER_MOTOR_OVERCURRENT", 138 },
-  { "DYEING_HEAD_COVER_MOTOR_OVERTEMPERATURE", 139 },
-  { "DYEING_HEAD_COVER_MOTOR_STALL", 140 },
-  { "DYEING_HEAD_COVER_MOTOR_UNDERVOLTAGE", 141 },
-  { "DYEING_HEAD_COVER_OPEN_TIMEOUT", 136 },
-  { "DYEING_HEAD_THERMAL_CUTOFF", 135 },
-  { "DYEING_HEAD_ZONE_1_CURRENT_LOOP_BREAK", 130 },
-  { "DYEING_HEAD_ZONE_1_CURRENT_OUT_OF_RANGE", 125 },
-  { "DYEING_HEAD_ZONE_1_OVERTEMPERATURE", 107 },
-  { "DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_A", 113 },
-  { "DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_B", 119 },
-  { "DYEING_HEAD_ZONE_2_CURRENT_LOOP_BREAK", 131 },
-  { "DYEING_HEAD_ZONE_2_CURRENT_OUT_OF_RANGE", 126 },
-  { "DYEING_HEAD_ZONE_2_OVERTEMPERATURE", 108 },
-  { "DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_A", 114 },
-  { "DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_B", 120 },
-  { "DYEING_HEAD_ZONE_3_CURRENT_LOOP_BREAK", 132 },
-  { "DYEING_HEAD_ZONE_3_CURRENT_OUT_OF_RANGE", 127 },
-  { "DYEING_HEAD_ZONE_3_OVERTEMPERATURE", 109 },
-  { "DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_A", 115 },
-  { "DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_B", 121 },
-  { "DYEING_HEAD_ZONE_4_CURRENT_LOOP_BREAK", 133 },
-  { "DYEING_HEAD_ZONE_4_CURRENT_OUT_OF_RANGE", 128 },
-  { "DYEING_HEAD_ZONE_4_OVERTEMPERATURE", 110 },
-  { "DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_A", 116 },
-  { "DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_B", 122 },
-  { "DYEING_HEAD_ZONE_5_6_CURRENT_LOOP_BREAK", 134 },
-  { "DYEING_HEAD_ZONE_5_6_CURRENT_OUT_OF_RANGE", 129 },
-  { "DYEING_HEAD_ZONE_5_OVERTEMPERATURE", 111 },
-  { "DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_A", 117 },
-  { "DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_B", 123 },
-  { "DYEING_HEAD_ZONE_6_OVERTEMPERATURE", 112 },
-  { "DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_A", 118 },
-  { "DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_B", 124 },
+  { "CHILLER_DRY_CONTACT", 285 },
+  { "DISPENSER_1_EMPTY", 175 },
+  { "DISPENSER_1_HIGH_PRESSURE", 239 },
+  { "DISPENSER_1_LOWER_HARD_LIMIT", 231 },
+  { "DISPENSER_1_MOTOR_OVERCURRENT", 191 },
+  { "DISPENSER_1_MOTOR_OVERTEMPERATURE", 199 },
+  { "DISPENSER_1_MOTOR_STALL", 207 },
+  { "DISPENSER_1_MOTOR_UNDERVOLTAGE", 215 },
+  { "DISPENSER_1_OVERPRESSURE", 159 },
+  { "DISPENSER_1_REFILL_FAILURE", 183 },
+  { "DISPENSER_1_UNDERPRESSURE", 167 },
+  { "DISPENSER_1_UPPER_HARD_LIMIT", 223 },
+  { "DISPENSER_2_EMPTY", 176 },
+  { "DISPENSER_2_HIGH_PRESSURE", 240 },
+  { "DISPENSER_2_LOWER_HARD_LIMIT", 232 },
+  { "DISPENSER_2_MOTOR_OVERCURRENT", 192 },
+  { "DISPENSER_2_MOTOR_OVERTEMPERATURE", 200 },
+  { "DISPENSER_2_MOTOR_STALL", 208 },
+  { "DISPENSER_2_MOTOR_UNDERVOLTAGE", 216 },
+  { "DISPENSER_2_OVERPRESSURE", 160 },
+  { "DISPENSER_2_REFILL_FAILURE", 184 },
+  { "DISPENSER_2_UNDERPRESSURE", 168 },
+  { "DISPENSER_2_UPPER_HARD_LIMIT", 224 },
+  { "DISPENSER_3_EMPTY", 177 },
+  { "DISPENSER_3_HIGH_PRESSURE", 241 },
+  { "DISPENSER_3_LOWER_HARD_LIMIT", 233 },
+  { "DISPENSER_3_MOTOR_OVERCURRENT", 193 },
+  { "DISPENSER_3_MOTOR_OVERTEMPERATURE", 201 },
+  { "DISPENSER_3_MOTOR_STALL", 209 },
+  { "DISPENSER_3_MOTOR_UNDERVOLTAGE", 217 },
+  { "DISPENSER_3_OVERPRESSURE", 161 },
+  { "DISPENSER_3_REFILL_FAILURE", 185 },
+  { "DISPENSER_3_UNDERPRESSURE", 169 },
+  { "DISPENSER_3_UPPER_HARD_LIMIT", 225 },
+  { "DISPENSER_4_EMPTY", 178 },
+  { "DISPENSER_4_HIGH_PRESSURE", 242 },
+  { "DISPENSER_4_LOWER_HARD_LIMIT", 234 },
+  { "DISPENSER_4_MOTOR_OVERCURRENT", 194 },
+  { "DISPENSER_4_MOTOR_OVERTEMPERATURE", 202 },
+  { "DISPENSER_4_MOTOR_STALL", 210 },
+  { "DISPENSER_4_MOTOR_UNDERVOLTAGE", 218 },
+  { "DISPENSER_4_OVERPRESSURE", 162 },
+  { "DISPENSER_4_REFILL_FAILURE", 186 },
+  { "DISPENSER_4_UNDERPRESSURE", 170 },
+  { "DISPENSER_4_UPPER_HARD_LIMIT", 226 },
+  { "DISPENSER_5_EMPTY", 179 },
+  { "DISPENSER_5_HIGH_PRESSURE", 243 },
+  { "DISPENSER_5_LOWER_HARD_LIMIT", 235 },
+  { "DISPENSER_5_MOTOR_OVERCURRENT", 195 },
+  { "DISPENSER_5_MOTOR_OVERTEMPERATURE", 203 },
+  { "DISPENSER_5_MOTOR_STALL", 211 },
+  { "DISPENSER_5_MOTOR_UNDERVOLTAGE", 219 },
+  { "DISPENSER_5_OVERPRESSURE", 163 },
+  { "DISPENSER_5_REFILL_FAILURE", 187 },
+  { "DISPENSER_5_UNDERPRESSURE", 171 },
+  { "DISPENSER_5_UPPER_HARD_LIMIT", 227 },
+  { "DISPENSER_6_EMPTY", 180 },
+  { "DISPENSER_6_HIGH_PRESSURE", 244 },
+  { "DISPENSER_6_LOWER_HARD_LIMIT", 236 },
+  { "DISPENSER_6_MOTOR_OVERCURRENT", 196 },
+  { "DISPENSER_6_MOTOR_OVERTEMPERATURE", 204 },
+  { "DISPENSER_6_MOTOR_STALL", 212 },
+  { "DISPENSER_6_MOTOR_UNDERVOLTAGE", 220 },
+  { "DISPENSER_6_OVERPRESSURE", 164 },
+  { "DISPENSER_6_REFILL_FAILURE", 188 },
+  { "DISPENSER_6_UNDERPRESSURE", 172 },
+  { "DISPENSER_6_UPPER_HARD_LIMIT", 228 },
+  { "DISPENSER_7_EMPTY", 181 },
+  { "DISPENSER_7_HIGH_PRESSURE", 245 },
+  { "DISPENSER_7_LOWER_HARD_LIMIT", 237 },
+  { "DISPENSER_7_MOTOR_OVERCURRENT", 197 },
+  { "DISPENSER_7_MOTOR_OVERTEMPERATURE", 205 },
+  { "DISPENSER_7_MOTOR_STALL", 213 },
+  { "DISPENSER_7_MOTOR_UNDERVOLTAGE", 221 },
+  { "DISPENSER_7_OVERPRESSURE", 165 },
+  { "DISPENSER_7_REFILL_FAILURE", 189 },
+  { "DISPENSER_7_UNDERPRESSURE", 173 },
+  { "DISPENSER_7_UPPER_HARD_LIMIT", 229 },
+  { "DISPENSER_8_EMPTY", 182 },
+  { "DISPENSER_8_HIGH_PRESSURE", 246 },
+  { "DISPENSER_8_LOWER_HARD_LIMIT", 238 },
+  { "DISPENSER_8_MOTOR_OVERCURRENT", 198 },
+  { "DISPENSER_8_MOTOR_OVERTEMPERATURE", 206 },
+  { "DISPENSER_8_MOTOR_STALL", 214 },
+  { "DISPENSER_8_MOTOR_UNDERVOLTAGE", 222 },
+  { "DISPENSER_8_OVERPRESSURE", 166 },
+  { "DISPENSER_8_REFILL_FAILURE", 190 },
+  { "DISPENSER_8_UNDERPRESSURE", 174 },
+  { "DISPENSER_8_UPPER_HARD_LIMIT", 230 },
+  { "DRYER_DOOR_OPEN", 92 },
+  { "DRYER_FAN_RPM_TOO_LOW", 103 },
+  { "DRYER_FAN_STOPPED", 104 },
+  { "DRYER_HEATERS_ZONE_1_CURRENT_LOOP_BREAK", 101 },
+  { "DRYER_HEATERS_ZONE_1_CURRENT_OUT_OF_RANGE", 99 },
+  { "DRYER_HEATERS_ZONE_2_CURRENT_LOOP_BREAK", 102 },
+  { "DRYER_HEATERS_ZONE_2_CURRENT_OUT_OF_RANGE", 100 },
+  { "DRYER_LID_MOTOR_OVERCURRENT", 105 },
+  { "DRYER_LID_MOTOR_OVERTEMPERATURE", 106 },
+  { "DRYER_LID_MOTOR_STALL", 107 },
+  { "DRYER_LID_MOTOR_UNDERVOLTAGE", 108 },
+  { "DRYER_MOTOR_OVERCURRENT", 88 },
+  { "DRYER_MOTOR_OVERTEMPERATURE", 89 },
+  { "DRYER_MOTOR_STALL", 90 },
+  { "DRYER_MOTOR_UNDERVOLTAGE", 91 },
+  { "DRYER_THERMAL_CUTOFF", 98 },
+  { "DRYER_ZONE_1_OVERTEMPERATURE", 93 },
+  { "DRYER_ZONE_1_UNDERTEMPERATURE_A", 95 },
+  { "DRYER_ZONE_1_UNDERTEMPERATURE_B", 96 },
+  { "DRYER_ZONE_2_OVERTEMPERATURE", 94 },
+  { "DRYER_ZONE_2_UNDERTEMPERATURE_A", 109 },
+  { "DRYER_ZONE_2_UNDERTEMPERATURE_B", 97 },
+  { "DYEING_HEAD_CLEANING_HEAD_MOTOR_OVERCURRENT", 149 },
+  { "DYEING_HEAD_CLEANING_HEAD_MOTOR_OVERTEMPERATURE", 150 },
+  { "DYEING_HEAD_CLEANING_HEAD_MOTOR_STALL", 151 },
+  { "DYEING_HEAD_CLEANING_HEAD_MOTOR_UNDERVOLTAGE", 152 },
+  { "DYEING_HEAD_CLEANING_MECHANISM_MOTOR_OVERCURRENT", 145 },
+  { "DYEING_HEAD_CLEANING_MECHANISM_MOTOR_OVERTEMPERATURE", 146 },
+  { "DYEING_HEAD_CLEANING_MECHANISM_MOTOR_STALL", 147 },
+  { "DYEING_HEAD_CLEANING_MECHANISM_MOTOR_UNDERVOLTAGE", 148 },
+  { "DYEING_HEAD_COVER_CLOSE_TIMEOUT", 140 },
+  { "DYEING_HEAD_COVER_MOTOR_OVERCURRENT", 141 },
+  { "DYEING_HEAD_COVER_MOTOR_OVERTEMPERATURE", 142 },
+  { "DYEING_HEAD_COVER_MOTOR_STALL", 143 },
+  { "DYEING_HEAD_COVER_MOTOR_UNDERVOLTAGE", 144 },
+  { "DYEING_HEAD_COVER_OPEN_TIMEOUT", 139 },
+  { "DYEING_HEAD_THERMAL_CUTOFF", 138 },
+  { "DYEING_HEAD_ZONE_1_CURRENT_LOOP_BREAK", 133 },
+  { "DYEING_HEAD_ZONE_1_CURRENT_OUT_OF_RANGE", 128 },
+  { "DYEING_HEAD_ZONE_1_OVERTEMPERATURE", 110 },
+  { "DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_A", 116 },
+  { "DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_B", 122 },
+  { "DYEING_HEAD_ZONE_2_CURRENT_LOOP_BREAK", 134 },
+  { "DYEING_HEAD_ZONE_2_CURRENT_OUT_OF_RANGE", 129 },
+  { "DYEING_HEAD_ZONE_2_OVERTEMPERATURE", 111 },
+  { "DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_A", 117 },
+  { "DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_B", 123 },
+  { "DYEING_HEAD_ZONE_3_CURRENT_LOOP_BREAK", 135 },
+  { "DYEING_HEAD_ZONE_3_CURRENT_OUT_OF_RANGE", 130 },
+  { "DYEING_HEAD_ZONE_3_OVERTEMPERATURE", 112 },
+  { "DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_A", 118 },
+  { "DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_B", 124 },
+  { "DYEING_HEAD_ZONE_4_CURRENT_LOOP_BREAK", 136 },
+  { "DYEING_HEAD_ZONE_4_CURRENT_OUT_OF_RANGE", 131 },
+  { "DYEING_HEAD_ZONE_4_OVERTEMPERATURE", 113 },
+  { "DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_A", 119 },
+  { "DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_B", 125 },
+  { "DYEING_HEAD_ZONE_5_6_CURRENT_LOOP_BREAK", 137 },
+  { "DYEING_HEAD_ZONE_5_6_CURRENT_OUT_OF_RANGE", 132 },
+  { "DYEING_HEAD_ZONE_5_OVERTEMPERATURE", 114 },
+  { "DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_A", 120 },
+  { "DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_B", 126 },
+  { "DYEING_HEAD_ZONE_6_OVERTEMPERATURE", 115 },
+  { "DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_A", 121 },
+  { "DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_B", 127 },
   { "ELECTRICAL_CABINET_FANS_RPM_TOO_LOW", 26 },
   { "ELECTRICAL_CABINET_FANS_STOPPED", 27 },
   { "ELECTRICAL_CABINET_OVERTEMPERATURE", 33 },
   { "EMERGENCY_PUSH_BUTTON_PRESSED", 16 },
-  { "FEEDER_DANCER_MOTOR_OVERCURRENT", 72 },
-  { "FEEDER_DANCER_MOTOR_OVERTEMPERATURE", 75 },
-  { "FEEDER_DANCER_MOTOR_STALL", 78 },
-  { "FEEDER_DANCER_MOTOR_UNDERVOLTAGE", 81 },
-  { "FEEDER_MOTOR_OVERCURRENT", 37 },
-  { "FEEDER_MOTOR_OVERTEMPERATURE", 44 },
-  { "FEEDER_MOTOR_STALL", 51 },
-  { "FEEDER_MOTOR_UNDERVOLTAGE", 58 },
+  { "FEEDER_DANCER_MOTOR_OVERCURRENT", 74 },
+  { "FEEDER_DANCER_MOTOR_OVERTEMPERATURE", 77 },
+  { "FEEDER_DANCER_MOTOR_STALL", 80 },
+  { "FEEDER_DANCER_MOTOR_UNDERVOLTAGE", 83 },
+  { "FEEDER_MOTOR_OVERCURRENT", 39 },
+  { "FEEDER_MOTOR_OVERTEMPERATURE", 46 },
+  { "FEEDER_MOTOR_STALL", 53 },
+  { "FEEDER_MOTOR_UNDERVOLTAGE", 60 },
+  { "FPGA_WATCHDOG_ACTIVATED", 34 },
   { "FRONT_COVER_1_OPEN", 17 },
   { "FRONT_COVER_2_OPEN", 18 },
   { "FRONT_COVER_3_OPEN", 19 },
   { "FRONT_COVER_4_OPEN", 20 },
-  { "INK_CARTRIDGE_PRESENCE_SENSOR_TIMEOUT", 285 },
-  { "INK_CARTRIDGE_RFID_TIMEOUT", 286 },
-  { "INSUFFICIENT_AIR_FLOW", 283 },
+  { "INK_CARTRIDGE_PRESENCE_SENSOR_TIMEOUT", 288 },
+  { "INK_CARTRIDGE_RFID_TIMEOUT", 289 },
+  { "INSUFFICIENT_AIR_FLOW", 286 },
   { "JOB_ABORTED", 12 },
   { "JOB_COMPLETED", 14 },
   { "JOB_FAILED", 13 },
   { "JOB_STARTED", 11 },
   { "JOB_STATUS", 10 },
-  { "LEFT_LOADER_MOTOR_OVERCURRENT", 40 },
-  { "LEFT_LOADER_MOTOR_OVERTEMPERATURE", 47 },
-  { "LEFT_LOADER_MOTOR_STALL", 54 },
-  { "LEFT_LOADER_MOTOR_UNDERVOLTAGE", 61 },
-  { "LOADING_ARM_MOTOR_OVERCURRENT", 43 },
-  { "LOADING_ARM_MOTOR_OVERTEMPERATURE", 50 },
-  { "LOADING_ARM_MOTOR_STALL", 57 },
-  { "LOADING_ARM_MOTOR_UNDERVOLTAGE", 64 },
-  { "LTFU_DOWN_TIMEOUT", 66 },
-  { "LTFU_UP_TIMEOUT", 65 },
+  { "LEFT_LOADER_MOTOR_OVERCURRENT", 42 },
+  { "LEFT_LOADER_MOTOR_OVERTEMPERATURE", 49 },
+  { "LEFT_LOADER_MOTOR_STALL", 56 },
+  { "LEFT_LOADER_MOTOR_UNDERVOLTAGE", 63 },
+  { "LOADING_ARM_MOTOR_OVERCURRENT", 45 },
+  { "LOADING_ARM_MOTOR_OVERTEMPERATURE", 52 },
+  { "LOADING_ARM_MOTOR_STALL", 59 },
+  { "LOADING_ARM_MOTOR_UNDERVOLTAGE", 66 },
+  { "LTFU_DOWN_TIMEOUT", 68 },
+  { "LTFU_UP_TIMEOUT", 67 },
   { "MACHINE_FANS_RPM_TOO_LOW", 24 },
   { "MACHINE_FANS_STOPPED", 25 },
   { "MACHINE_INTERNAL_OVERTEMPERATURE", 23 },
@@ -509,94 +513,96 @@ static const ProtobufCEnumValueIndex event_type__enum_values_by_name[291] =
   { "MACHINE_STATE_HW_CONFIG_FAILED", 29 },
   { "MACHINE_STATE_INITIAL_BLOWER_FAILED", 30 },
   { "MACHINE_STATE_NO_CFG_FILE", 28 },
-  { "MACHINE_STATE_NO_THREAD_DETECTED", 84 },
-  { "MID_TANK_1_EMPTY", 252 },
-  { "MID_TANK_1_FILL_TIMEOUT", 268 },
-  { "MID_TANK_1_LOW_LEVEL", 244 },
-  { "MID_TANK_1_OVERFLOW", 260 },
-  { "MID_TANK_2_EMPTY", 253 },
-  { "MID_TANK_2_FILL_TIMEOUT", 269 },
-  { "MID_TANK_2_LOW_LEVEL", 245 },
-  { "MID_TANK_2_OVERFLOW", 261 },
-  { "MID_TANK_3_EMPTY", 254 },
-  { "MID_TANK_3_FILL_TIMEOUT", 270 },
-  { "MID_TANK_3_LOW_LEVEL", 246 },
-  { "MID_TANK_3_OVERFLOW", 262 },
-  { "MID_TANK_4_EMPTY", 255 },
-  { "MID_TANK_4_FILL_TIMEOUT", 271 },
-  { "MID_TANK_4_LOW_LEVEL", 247 },
-  { "MID_TANK_4_OVERFLOW", 263 },
-  { "MID_TANK_5_EMPTY", 256 },
-  { "MID_TANK_5_FILL_TIMEOUT", 272 },
-  { "MID_TANK_5_LOW_LEVEL", 248 },
-  { "MID_TANK_5_OVERFLOW", 264 },
-  { "MID_TANK_6_EMPTY", 257 },
-  { "MID_TANK_6_FILL_TIMEOUT", 273 },
-  { "MID_TANK_6_LOW_LEVEL", 249 },
-  { "MID_TANK_6_OVERFLOW", 265 },
-  { "MID_TANK_7_EMPTY", 258 },
-  { "MID_TANK_7_FILL_TIMEOUT", 274 },
-  { "MID_TANK_7_LOW_LEVEL", 250 },
-  { "MID_TANK_7_OVERFLOW", 266 },
-  { "MID_TANK_8_EMPTY", 259 },
-  { "MID_TANK_8_FILL_TIMEOUT", 275 },
-  { "MID_TANK_8_LOW_LEVEL", 251 },
-  { "MID_TANK_8_OVERFLOW", 267 },
-  { "MIXER_CURRENT_LOOP_BREAK", 155 },
-  { "MIXER_CURRENT_OUT_OF_RANGE", 154 },
-  { "MIXER_OVERTEMPERATURE", 150 },
-  { "MIXER_THERMAL_CUTOFF", 153 },
-  { "MIXER_UNDERTEMPERATURE_A", 151 },
-  { "MIXER_UNDERTEMPERATURE_B", 152 },
-  { "NO_AIR_PRESSURE", 279 },
-  { "NO_WASTE_CARTRIDGE_AVAILABLE", 287 },
+  { "MACHINE_STATE_NO_THREAD_DETECTED", 86 },
+  { "MID_TANK_1_EMPTY", 255 },
+  { "MID_TANK_1_FILL_TIMEOUT", 271 },
+  { "MID_TANK_1_LOW_LEVEL", 247 },
+  { "MID_TANK_1_OVERFLOW", 263 },
+  { "MID_TANK_2_EMPTY", 256 },
+  { "MID_TANK_2_FILL_TIMEOUT", 272 },
+  { "MID_TANK_2_LOW_LEVEL", 248 },
+  { "MID_TANK_2_OVERFLOW", 264 },
+  { "MID_TANK_3_EMPTY", 257 },
+  { "MID_TANK_3_FILL_TIMEOUT", 273 },
+  { "MID_TANK_3_LOW_LEVEL", 249 },
+  { "MID_TANK_3_OVERFLOW", 265 },
+  { "MID_TANK_4_EMPTY", 258 },
+  { "MID_TANK_4_FILL_TIMEOUT", 274 },
+  { "MID_TANK_4_LOW_LEVEL", 250 },
+  { "MID_TANK_4_OVERFLOW", 266 },
+  { "MID_TANK_5_EMPTY", 259 },
+  { "MID_TANK_5_FILL_TIMEOUT", 275 },
+  { "MID_TANK_5_LOW_LEVEL", 251 },
+  { "MID_TANK_5_OVERFLOW", 267 },
+  { "MID_TANK_6_EMPTY", 260 },
+  { "MID_TANK_6_FILL_TIMEOUT", 276 },
+  { "MID_TANK_6_LOW_LEVEL", 252 },
+  { "MID_TANK_6_OVERFLOW", 268 },
+  { "MID_TANK_7_EMPTY", 261 },
+  { "MID_TANK_7_FILL_TIMEOUT", 277 },
+  { "MID_TANK_7_LOW_LEVEL", 253 },
+  { "MID_TANK_7_OVERFLOW", 269 },
+  { "MID_TANK_8_EMPTY", 262 },
+  { "MID_TANK_8_FILL_TIMEOUT", 278 },
+  { "MID_TANK_8_LOW_LEVEL", 254 },
+  { "MID_TANK_8_OVERFLOW", 270 },
+  { "MIXER_CURRENT_LOOP_BREAK", 158 },
+  { "MIXER_CURRENT_OUT_OF_RANGE", 157 },
+  { "MIXER_OVERTEMPERATURE", 153 },
+  { "MIXER_THERMAL_CUTOFF", 156 },
+  { "MIXER_UNDERTEMPERATURE_A", 154 },
+  { "MIXER_UNDERTEMPERATURE_B", 155 },
+  { "NO_AIR_PRESSURE", 282 },
+  { "NO_WASTE_CARTRIDGE_AVAILABLE", 290 },
   { "None", 0 },
   { "POWER_UP_BIT_FAILURE", 15 },
-  { "PULLER_DANCER_MOTOR_OVERCURRENT", 71 },
-  { "PULLER_DANCER_MOTOR_OVERTEMPERATURE", 74 },
-  { "PULLER_DANCER_MOTOR_STALL", 77 },
-  { "PULLER_DANCER_MOTOR_UNDERVOLTAGE", 80 },
-  { "PULLER_MOTOR_OVERCURRENT", 39 },
-  { "PULLER_MOTOR_OVERTEMPERATURE", 46 },
-  { "PULLER_MOTOR_STALL", 53 },
-  { "PULLER_MOTOR_UNDERVOLTAGE", 60 },
+  { "PULLER_DANCER_MOTOR_OVERCURRENT", 73 },
+  { "PULLER_DANCER_MOTOR_OVERTEMPERATURE", 76 },
+  { "PULLER_DANCER_MOTOR_STALL", 79 },
+  { "PULLER_DANCER_MOTOR_UNDERVOLTAGE", 82 },
+  { "PULLER_MOTOR_OVERCURRENT", 41 },
+  { "PULLER_MOTOR_OVERTEMPERATURE", 48 },
+  { "PULLER_MOTOR_STALL", 55 },
+  { "PULLER_MOTOR_UNDERVOLTAGE", 62 },
   { "REAR_COVER_OPEN", 22 },
   { "RECORDING_STARTED", 8 },
   { "RECORDING_STOPPED", 9 },
   { "REQUEST_FAILED", 3 },
   { "REQUEST_SENT", 1 },
   { "RESPONSE_RECEIVED", 2 },
-  { "RIGHT_LOADER_MOTOR_OVERCURRENT", 38 },
-  { "RIGHT_LOADER_MOTOR_OVERTEMPERATURE", 45 },
-  { "RIGHT_LOADER_MOTOR_STALL", 52 },
-  { "RIGHT_LOADER_MOTOR_UNDERVOLTAGE", 59 },
-  { "RTFU_DOWN_TIMEOUT", 68 },
-  { "RTFU_UP_TIMEOUT", 67 },
-  { "SCREW_MOTOR_LIMIT_TIMEOUT", 69 },
-  { "SCREW_MOTOR_OVERCURRENT", 42 },
-  { "SCREW_MOTOR_OVERTEMPERATURE", 49 },
-  { "SCREW_MOTOR_STALL", 56 },
-  { "SCREW_MOTOR_UNDERVOLTAGE", 63 },
-  { "THREAD_BREAK", 34 },
-  { "THREAD_TENSION_CONTROL_FAILURE_FEEDER_DANCER", 35 },
-  { "THREAD_TENSION_CONTROL_FAILURE_PULLER_DANCER", 82 },
-  { "THREAD_TENSION_CONTROL_FAILURE_WINDER_DANCER", 83 },
+  { "RIGHT_LOADER_MOTOR_OVERCURRENT", 40 },
+  { "RIGHT_LOADER_MOTOR_OVERTEMPERATURE", 47 },
+  { "RIGHT_LOADER_MOTOR_STALL", 54 },
+  { "RIGHT_LOADER_MOTOR_UNDERVOLTAGE", 61 },
+  { "RTFU_DOWN_TIMEOUT", 70 },
+  { "RTFU_UP_TIMEOUT", 69 },
+  { "SCREW_MOTOR_LIMIT_TIMEOUT", 71 },
+  { "SCREW_MOTOR_OVERCURRENT", 44 },
+  { "SCREW_MOTOR_OVERTEMPERATURE", 51 },
+  { "SCREW_MOTOR_STALL", 58 },
+  { "SCREW_MOTOR_UNDERVOLTAGE", 65 },
+  { "THREAD_BREAK", 36 },
+  { "THREAD_LOADING_ERROR", 87 },
+  { "THREAD_TENSION_CONTROL_FAILURE_FEEDER_DANCER", 37 },
+  { "THREAD_TENSION_CONTROL_FAILURE_PULLER_DANCER", 84 },
+  { "THREAD_TENSION_CONTROL_FAILURE_WINDER_DANCER", 85 },
+  { "UNINTENDED_RESET", 35 },
   { "UNSPECIFIED", 31 },
-  { "VOC_SENSOR_ALARM_SLOPE", 284 },
-  { "VOC_SENSOR_ALARM_TIME", 281 },
-  { "WASTE_CARTRIDGE_PRESENCE_SENSOR_TIMEOUT", 289 },
-  { "WASTE_CARTRIDGE_RFID_TIMEOUT", 290 },
-  { "WASTE_CONTAINER_EMPTYING_TIMEOUT", 278 },
-  { "WASTE_CONTAINER_OVERFLOW", 280 },
-  { "WINDER_CONE_DOES_NOT_EXIST", 36 },
-  { "WINDER_DANCER_MOTOR_OVERCURRENT", 70 },
-  { "WINDER_DANCER_MOTOR_OVERTEMPERATURE", 73 },
-  { "WINDER_DANCER_MOTOR_STALL", 76 },
-  { "WINDER_DANCER_MOTOR_UNDERVOLTAGE", 79 },
-  { "WINDER_MOTOR_OVERCURRENT", 41 },
-  { "WINDER_MOTOR_OVERTEMPERATURE", 48 },
-  { "WINDER_MOTOR_STALL", 55 },
-  { "WINDER_MOTOR_UNDERVOLTAGE", 62 },
+  { "VOC_SENSOR_ALARM_SLOPE", 287 },
+  { "VOC_SENSOR_ALARM_TIME", 284 },
+  { "WASTE_CARTRIDGE_PRESENCE_SENSOR_TIMEOUT", 292 },
+  { "WASTE_CARTRIDGE_RFID_TIMEOUT", 293 },
+  { "WASTE_CONTAINER_EMPTYING_TIMEOUT", 281 },
+  { "WASTE_CONTAINER_OVERFLOW", 283 },
+  { "WINDER_CONE_DOES_NOT_EXIST", 38 },
+  { "WINDER_DANCER_MOTOR_OVERCURRENT", 72 },
+  { "WINDER_DANCER_MOTOR_OVERTEMPERATURE", 75 },
+  { "WINDER_DANCER_MOTOR_STALL", 78 },
+  { "WINDER_DANCER_MOTOR_UNDERVOLTAGE", 81 },
+  { "WINDER_MOTOR_OVERCURRENT", 43 },
+  { "WINDER_MOTOR_OVERTEMPERATURE", 50 },
+  { "WINDER_MOTOR_STALL", 57 },
+  { "WINDER_MOTOR_UNDERVOLTAGE", 64 },
 };
 const ProtobufCEnumDescriptor event_type__descriptor =
 {
@@ -605,9 +611,9 @@ const ProtobufCEnumDescriptor event_type__descriptor =
   "EventType",
   "EventType",
   "",
-  291,
+  294,
   event_type__enum_values_by_number,
-  291,
+  294,
   event_type__enum_values_by_name,
   11,
   event_type__value_ranges,
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/EventType.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/EventType.pb-c.h
index cd8abc59a..8bea8b3e9 100644
--- a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/EventType.pb-c.h
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/EventType.pb-c.h
@@ -54,6 +54,8 @@ typedef enum _EventType {
   EVENT_TYPE__UNSPECIFIED = 2016,
   EVENT_TYPE__MACHINE_INTERNAL_OVERTEMPERATURE_2 = 2017,
   EVENT_TYPE__ELECTRICAL_CABINET_OVERTEMPERATURE = 2018,
+  EVENT_TYPE__FPGA_WATCHDOG_ACTIVATED = 2019,
+  EVENT_TYPE__UNINTENDED_RESET = 2020,
   EVENT_TYPE__THREAD_BREAK = 3000,
   EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_FEEDER_DANCER = 3001,
   EVENT_TYPE__WINDER_CONE_DOES_NOT_EXIST = 3002,
@@ -105,6 +107,7 @@ typedef enum _EventType {
   EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_PULLER_DANCER = 3048,
   EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_WINDER_DANCER = 3049,
   EVENT_TYPE__MACHINE_STATE_NO_THREAD_DETECTED = 3050,
+  EVENT_TYPE__THREAD_LOADING_ERROR = 3051,
   EVENT_TYPE__DRYER_MOTOR_OVERCURRENT = 4000,
   EVENT_TYPE__DRYER_MOTOR_OVERTEMPERATURE = 4001,
   EVENT_TYPE__DRYER_MOTOR_STALL = 4002,
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/HeaterType.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/HeaterType.pb-c.c
index b4715655e..8e7e8f861 100644
--- a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/HeaterType.pb-c.c
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/HeaterType.pb-c.c
@@ -7,7 +7,7 @@
 #endif
 
 #include "HeaterType.pb-c.h"
-static const ProtobufCEnumValue heater_type__enum_values_by_number[10] =
+static const ProtobufCEnumValue heater_type__enum_values_by_number[18] =
 {
   { "DryerAirHeater", "HEATER_TYPE__DryerAirHeater", 0 },
   { "DryerMainHeater", "HEATER_TYPE__DryerMainHeater", 1 },
@@ -19,21 +19,37 @@ static const ProtobufCEnumValue heater_type__enum_values_by_number[10] =
   { "HeaterZone5", "HEATER_TYPE__HeaterZone5", 7 },
   { "HeaterZone6", "HEATER_TYPE__HeaterZone6", 8 },
   { "MixerHeater", "HEATER_TYPE__MixerHeater", 9 },
+  { "HeaterZone7", "HEATER_TYPE__HeaterZone7", 10 },
+  { "HeaterZone8", "HEATER_TYPE__HeaterZone8", 11 },
+  { "HeaterZone9", "HEATER_TYPE__HeaterZone9", 12 },
+  { "HeaterZone10", "HEATER_TYPE__HeaterZone10", 13 },
+  { "HeaterZone11", "HEATER_TYPE__HeaterZone11", 14 },
+  { "HeaterZone12", "HEATER_TYPE__HeaterZone12", 15 },
+  { "HeadCoverHeater1", "HEATER_TYPE__HeadCoverHeater1", 16 },
+  { "HeadCoverHeater2", "HEATER_TYPE__HeadCoverHeater2", 17 },
 };
 static const ProtobufCIntRange heater_type__value_ranges[] = {
-{0, 0},{0, 10}
+{0, 0},{0, 18}
 };
-static const ProtobufCEnumValueIndex heater_type__enum_values_by_name[10] =
+static const ProtobufCEnumValueIndex heater_type__enum_values_by_name[18] =
 {
   { "DryerAirHeater", 0 },
   { "DryerMainHeater", 1 },
   { "DryerSecondaryHeater", 2 },
+  { "HeadCoverHeater1", 16 },
+  { "HeadCoverHeater2", 17 },
   { "HeaterZone1", 3 },
+  { "HeaterZone10", 13 },
+  { "HeaterZone11", 14 },
+  { "HeaterZone12", 15 },
   { "HeaterZone2", 4 },
   { "HeaterZone3", 5 },
   { "HeaterZone4", 6 },
   { "HeaterZone5", 7 },
   { "HeaterZone6", 8 },
+  { "HeaterZone7", 10 },
+  { "HeaterZone8", 11 },
+  { "HeaterZone9", 12 },
   { "MixerHeater", 9 },
 };
 const ProtobufCEnumDescriptor heater_type__descriptor =
@@ -43,9 +59,9 @@ const ProtobufCEnumDescriptor heater_type__descriptor =
   "HeaterType",
   "HeaterType",
   "",
-  10,
+  18,
   heater_type__enum_values_by_number,
-  10,
+  18,
   heater_type__enum_values_by_name,
   1,
   heater_type__value_ranges,
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/HeaterType.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/HeaterType.pb-c.h
index 3544e688c..cacd3a6cc 100644
--- a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/HeaterType.pb-c.h
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/HeaterType.pb-c.h
@@ -29,7 +29,15 @@ typedef enum _HeaterType {
   HEATER_TYPE__HeaterZone4 = 6,
   HEATER_TYPE__HeaterZone5 = 7,
   HEATER_TYPE__HeaterZone6 = 8,
-  HEATER_TYPE__MixerHeater = 9
+  HEATER_TYPE__MixerHeater = 9,
+  HEATER_TYPE__HeaterZone7 = 10,
+  HEATER_TYPE__HeaterZone8 = 11,
+  HEATER_TYPE__HeaterZone9 = 12,
+  HEATER_TYPE__HeaterZone10 = 13,
+  HEATER_TYPE__HeaterZone11 = 14,
+  HEATER_TYPE__HeaterZone12 = 15,
+  HEATER_TYPE__HeadCoverHeater1 = 16,
+  HEATER_TYPE__HeadCoverHeater2 = 17
     PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(HEATER_TYPE)
 } HeaterType;
 
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/StartThreadLoadingUpdateRequest.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/StartThreadLoadingUpdateRequest.pb-c.c
new file mode 100644
index 000000000..2809668e3
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/StartThreadLoadingUpdateRequest.pb-c.c
@@ -0,0 +1,72 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: StartThreadLoadingUpdateRequest.proto */
+
+/* Do not generate deprecated warnings for self */
+#ifndef PROTOBUF_C__NO_DEPRECATED
+#define PROTOBUF_C__NO_DEPRECATED
+#endif
+
+#include "StartThreadLoadingUpdateRequest.pb-c.h"
+void   start_thread_loading_update_request__init
+                     (StartThreadLoadingUpdateRequest         *message)
+{
+  static const StartThreadLoadingUpdateRequest init_value = START_THREAD_LOADING_UPDATE_REQUEST__INIT;
+  *message = init_value;
+}
+size_t start_thread_loading_update_request__get_packed_size
+                     (const StartThreadLoadingUpdateRequest *message)
+{
+  assert(message->base.descriptor == &start_thread_loading_update_request__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t start_thread_loading_update_request__pack
+                     (const StartThreadLoadingUpdateRequest *message,
+                      uint8_t       *out)
+{
+  assert(message->base.descriptor == &start_thread_loading_update_request__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t start_thread_loading_update_request__pack_to_buffer
+                     (const StartThreadLoadingUpdateRequest *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->base.descriptor == &start_thread_loading_update_request__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+StartThreadLoadingUpdateRequest *
+       start_thread_loading_update_request__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (StartThreadLoadingUpdateRequest *)
+     protobuf_c_message_unpack (&start_thread_loading_update_request__descriptor,
+                                allocator, len, data);
+}
+void   start_thread_loading_update_request__free_unpacked
+                     (StartThreadLoadingUpdateRequest *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->base.descriptor == &start_thread_loading_update_request__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+#define start_thread_loading_update_request__field_descriptors NULL
+#define start_thread_loading_update_request__field_indices_by_name NULL
+#define start_thread_loading_update_request__number_ranges NULL
+const ProtobufCMessageDescriptor start_thread_loading_update_request__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "StartThreadLoadingUpdateRequest",
+  "StartThreadLoadingUpdateRequest",
+  "StartThreadLoadingUpdateRequest",
+  "",
+  sizeof(StartThreadLoadingUpdateRequest),
+  0,
+  start_thread_loading_update_request__field_descriptors,
+  start_thread_loading_update_request__field_indices_by_name,
+  0,  start_thread_loading_update_request__number_ranges,
+  (ProtobufCMessageInit) start_thread_loading_update_request__init,
+  NULL,NULL,NULL    /* reserved[123] */
+};
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/StartThreadLoadingUpdateRequest.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/StartThreadLoadingUpdateRequest.pb-c.h
new file mode 100644
index 000000000..1ba64b8c1
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/StartThreadLoadingUpdateRequest.pb-c.h
@@ -0,0 +1,70 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: StartThreadLoadingUpdateRequest.proto */
+
+#ifndef PROTOBUF_C_StartThreadLoadingUpdateRequest_2eproto__INCLUDED
+#define PROTOBUF_C_StartThreadLoadingUpdateRequest_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 _StartThreadLoadingUpdateRequest StartThreadLoadingUpdateRequest;
+
+
+/* --- enums --- */
+
+
+/* --- messages --- */
+
+struct  _StartThreadLoadingUpdateRequest
+{
+  ProtobufCMessage base;
+};
+#define START_THREAD_LOADING_UPDATE_REQUEST__INIT \
+ { PROTOBUF_C_MESSAGE_INIT (&start_thread_loading_update_request__descriptor) \
+     }
+
+
+/* StartThreadLoadingUpdateRequest methods */
+void   start_thread_loading_update_request__init
+                     (StartThreadLoadingUpdateRequest         *message);
+size_t start_thread_loading_update_request__get_packed_size
+                     (const StartThreadLoadingUpdateRequest   *message);
+size_t start_thread_loading_update_request__pack
+                     (const StartThreadLoadingUpdateRequest   *message,
+                      uint8_t             *out);
+size_t start_thread_loading_update_request__pack_to_buffer
+                     (const StartThreadLoadingUpdateRequest   *message,
+                      ProtobufCBuffer     *buffer);
+StartThreadLoadingUpdateRequest *
+       start_thread_loading_update_request__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   start_thread_loading_update_request__free_unpacked
+                     (StartThreadLoadingUpdateRequest *message,
+                      ProtobufCAllocator *allocator);
+/* --- per-message closures --- */
+
+typedef void (*StartThreadLoadingUpdateRequest_Closure)
+                 (const StartThreadLoadingUpdateRequest *message,
+                  void *closure_data);
+
+/* --- services --- */
+
+
+/* --- descriptors --- */
+
+extern const ProtobufCMessageDescriptor start_thread_loading_update_request__descriptor;
+
+PROTOBUF_C__END_DECLS
+
+
+#endif  /* PROTOBUF_C_StartThreadLoadingUpdateRequest_2eproto__INCLUDED */
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/StartThreadLoadingUpdateResponse.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/StartThreadLoadingUpdateResponse.pb-c.c
new file mode 100644
index 000000000..b7e1c9346
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/StartThreadLoadingUpdateResponse.pb-c.c
@@ -0,0 +1,92 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: StartThreadLoadingUpdateResponse.proto */
+
+/* Do not generate deprecated warnings for self */
+#ifndef PROTOBUF_C__NO_DEPRECATED
+#define PROTOBUF_C__NO_DEPRECATED
+#endif
+
+#include "StartThreadLoadingUpdateResponse.pb-c.h"
+void   start_thread_loading_update_response__init
+                     (StartThreadLoadingUpdateResponse         *message)
+{
+  static const StartThreadLoadingUpdateResponse init_value = START_THREAD_LOADING_UPDATE_RESPONSE__INIT;
+  *message = init_value;
+}
+size_t start_thread_loading_update_response__get_packed_size
+                     (const StartThreadLoadingUpdateResponse *message)
+{
+  assert(message->base.descriptor == &start_thread_loading_update_response__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t start_thread_loading_update_response__pack
+                     (const StartThreadLoadingUpdateResponse *message,
+                      uint8_t       *out)
+{
+  assert(message->base.descriptor == &start_thread_loading_update_response__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t start_thread_loading_update_response__pack_to_buffer
+                     (const StartThreadLoadingUpdateResponse *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->base.descriptor == &start_thread_loading_update_response__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+StartThreadLoadingUpdateResponse *
+       start_thread_loading_update_response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (StartThreadLoadingUpdateResponse *)
+     protobuf_c_message_unpack (&start_thread_loading_update_response__descriptor,
+                                allocator, len, data);
+}
+void   start_thread_loading_update_response__free_unpacked
+                     (StartThreadLoadingUpdateResponse *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->base.descriptor == &start_thread_loading_update_response__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+static const ProtobufCFieldDescriptor start_thread_loading_update_response__field_descriptors[1] =
+{
+  {
+    "ThreadLoadingState",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_ENUM,
+    offsetof(StartThreadLoadingUpdateResponse, has_threadloadingstate),
+    offsetof(StartThreadLoadingUpdateResponse, threadloadingstate),
+    &thread_loading_state__descriptor,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned start_thread_loading_update_response__field_indices_by_name[] = {
+  0,   /* field[0] = ThreadLoadingState */
+};
+static const ProtobufCIntRange start_thread_loading_update_response__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 1 }
+};
+const ProtobufCMessageDescriptor start_thread_loading_update_response__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "StartThreadLoadingUpdateResponse",
+  "StartThreadLoadingUpdateResponse",
+  "StartThreadLoadingUpdateResponse",
+  "",
+  sizeof(StartThreadLoadingUpdateResponse),
+  1,
+  start_thread_loading_update_response__field_descriptors,
+  start_thread_loading_update_response__field_indices_by_name,
+  1,  start_thread_loading_update_response__number_ranges,
+  (ProtobufCMessageInit) start_thread_loading_update_response__init,
+  NULL,NULL,NULL    /* reserved[123] */
+};
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/StartThreadLoadingUpdateResponse.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/StartThreadLoadingUpdateResponse.pb-c.h
new file mode 100644
index 000000000..894969b80
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/StartThreadLoadingUpdateResponse.pb-c.h
@@ -0,0 +1,73 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: StartThreadLoadingUpdateResponse.proto */
+
+#ifndef PROTOBUF_C_StartThreadLoadingUpdateResponse_2eproto__INCLUDED
+#define PROTOBUF_C_StartThreadLoadingUpdateResponse_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 "ThreadLoadingState.pb-c.h"
+
+typedef struct _StartThreadLoadingUpdateResponse StartThreadLoadingUpdateResponse;
+
+
+/* --- enums --- */
+
+
+/* --- messages --- */
+
+struct  _StartThreadLoadingUpdateResponse
+{
+  ProtobufCMessage base;
+  protobuf_c_boolean has_threadloadingstate;
+  ThreadLoadingState threadloadingstate;
+};
+#define START_THREAD_LOADING_UPDATE_RESPONSE__INIT \
+ { PROTOBUF_C_MESSAGE_INIT (&start_thread_loading_update_response__descriptor) \
+    , 0, THREAD_LOADING_STATE__ThreadLoadInit }
+
+
+/* StartThreadLoadingUpdateResponse methods */
+void   start_thread_loading_update_response__init
+                     (StartThreadLoadingUpdateResponse         *message);
+size_t start_thread_loading_update_response__get_packed_size
+                     (const StartThreadLoadingUpdateResponse   *message);
+size_t start_thread_loading_update_response__pack
+                     (const StartThreadLoadingUpdateResponse   *message,
+                      uint8_t             *out);
+size_t start_thread_loading_update_response__pack_to_buffer
+                     (const StartThreadLoadingUpdateResponse   *message,
+                      ProtobufCBuffer     *buffer);
+StartThreadLoadingUpdateResponse *
+       start_thread_loading_update_response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   start_thread_loading_update_response__free_unpacked
+                     (StartThreadLoadingUpdateResponse *message,
+                      ProtobufCAllocator *allocator);
+/* --- per-message closures --- */
+
+typedef void (*StartThreadLoadingUpdateResponse_Closure)
+                 (const StartThreadLoadingUpdateResponse *message,
+                  void *closure_data);
+
+/* --- services --- */
+
+
+/* --- descriptors --- */
+
+extern const ProtobufCMessageDescriptor start_thread_loading_update_response__descriptor;
+
+PROTOBUF_C__END_DECLS
+
+
+#endif  /* PROTOBUF_C_StartThreadLoadingUpdateResponse_2eproto__INCLUDED */
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/ThreadLoadingState.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/ThreadLoadingState.pb-c.c
new file mode 100644
index 000000000..c193bd981
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/ThreadLoadingState.pb-c.c
@@ -0,0 +1,63 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: ThreadLoadingState.proto */
+
+/* Do not generate deprecated warnings for self */
+#ifndef PROTOBUF_C__NO_DEPRECATED
+#define PROTOBUF_C__NO_DEPRECATED
+#endif
+
+#include "ThreadLoadingState.pb-c.h"
+static const ProtobufCEnumValue thread_loading_state__enum_values_by_number[15] =
+{
+  { "ThreadLoadInit", "THREAD_LOADING_STATE__ThreadLoadInit", 0 },
+  { "ThreadLoadReduceHeat", "THREAD_LOADING_STATE__ThreadLoadReduceHeat", 1 },
+  { "ThreadLoadSetLoadArmToStartPosition", "THREAD_LOADING_STATE__ThreadLoadSetLoadArmToStartPosition", 2 },
+  { "ThreadLoadOpenCovers", "THREAD_LOADING_STATE__ThreadLoadOpenCovers", 3 },
+  { "ThreadLoadLiftDancers", "THREAD_LOADING_STATE__ThreadLoadLiftDancers", 4 },
+  { "ThreadLoadLiftRockers", "THREAD_LOADING_STATE__ThreadLoadLiftRockers", 5 },
+  { "ThreadLoadInitialTension", "THREAD_LOADING_STATE__ThreadLoadInitialTension", 6 },
+  { "ThreadLoadCloseRockers", "THREAD_LOADING_STATE__ThreadLoadCloseRockers", 7 },
+  { "ThreadLoadCloseDancers", "THREAD_LOADING_STATE__ThreadLoadCloseDancers", 8 },
+  { "ThreadLoadCloseLids", "THREAD_LOADING_STATE__ThreadLoadCloseLids", 9 },
+  { "ThreadLoadJogFeederToMiddlePoint", "THREAD_LOADING_STATE__ThreadLoadJogFeederToMiddlePoint", 10 },
+  { "ThreadLoadDryerLoading", "THREAD_LOADING_STATE__ThreadLoadDryerLoading", 11 },
+  { "ThreadLoadResumeHeating", "THREAD_LOADING_STATE__ThreadLoadResumeHeating", 12 },
+  { "ThreadLoadJogThread", "THREAD_LOADING_STATE__ThreadLoadJogThread", 13 },
+  { "ThreadLoadEnd", "THREAD_LOADING_STATE__ThreadLoadEnd", 14 },
+};
+static const ProtobufCIntRange thread_loading_state__value_ranges[] = {
+{0, 0},{0, 15}
+};
+static const ProtobufCEnumValueIndex thread_loading_state__enum_values_by_name[15] =
+{
+  { "ThreadLoadCloseDancers", 8 },
+  { "ThreadLoadCloseLids", 9 },
+  { "ThreadLoadCloseRockers", 7 },
+  { "ThreadLoadDryerLoading", 11 },
+  { "ThreadLoadEnd", 14 },
+  { "ThreadLoadInit", 0 },
+  { "ThreadLoadInitialTension", 6 },
+  { "ThreadLoadJogFeederToMiddlePoint", 10 },
+  { "ThreadLoadJogThread", 13 },
+  { "ThreadLoadLiftDancers", 4 },
+  { "ThreadLoadLiftRockers", 5 },
+  { "ThreadLoadOpenCovers", 3 },
+  { "ThreadLoadReduceHeat", 1 },
+  { "ThreadLoadResumeHeating", 12 },
+  { "ThreadLoadSetLoadArmToStartPosition", 2 },
+};
+const ProtobufCEnumDescriptor thread_loading_state__descriptor =
+{
+  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
+  "ThreadLoadingState",
+  "ThreadLoadingState",
+  "ThreadLoadingState",
+  "",
+  15,
+  thread_loading_state__enum_values_by_number,
+  15,
+  thread_loading_state__enum_values_by_name,
+  1,
+  thread_loading_state__value_ranges,
+  NULL,NULL,NULL,NULL   /* reserved[1234] */
+};
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/ThreadLoadingState.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/ThreadLoadingState.pb-c.h
new file mode 100644
index 000000000..d9ae6b614
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/ThreadLoadingState.pb-c.h
@@ -0,0 +1,56 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: ThreadLoadingState.proto */
+
+#ifndef PROTOBUF_C_ThreadLoadingState_2eproto__INCLUDED
+#define PROTOBUF_C_ThreadLoadingState_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
+
+
+
+
+/* --- enums --- */
+
+typedef enum _ThreadLoadingState {
+  THREAD_LOADING_STATE__ThreadLoadInit = 0,
+  THREAD_LOADING_STATE__ThreadLoadReduceHeat = 1,
+  THREAD_LOADING_STATE__ThreadLoadSetLoadArmToStartPosition = 2,
+  THREAD_LOADING_STATE__ThreadLoadOpenCovers = 3,
+  THREAD_LOADING_STATE__ThreadLoadLiftDancers = 4,
+  THREAD_LOADING_STATE__ThreadLoadLiftRockers = 5,
+  THREAD_LOADING_STATE__ThreadLoadInitialTension = 6,
+  THREAD_LOADING_STATE__ThreadLoadCloseRockers = 7,
+  THREAD_LOADING_STATE__ThreadLoadCloseDancers = 8,
+  THREAD_LOADING_STATE__ThreadLoadCloseLids = 9,
+  THREAD_LOADING_STATE__ThreadLoadJogFeederToMiddlePoint = 10,
+  THREAD_LOADING_STATE__ThreadLoadDryerLoading = 11,
+  THREAD_LOADING_STATE__ThreadLoadResumeHeating = 12,
+  THREAD_LOADING_STATE__ThreadLoadJogThread = 13,
+  THREAD_LOADING_STATE__ThreadLoadEnd = 14
+    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(THREAD_LOADING_STATE)
+} ThreadLoadingState;
+
+/* --- messages --- */
+
+/* --- per-message closures --- */
+
+
+/* --- services --- */
+
+
+/* --- descriptors --- */
+
+extern const ProtobufCEnumDescriptor    thread_loading_state__descriptor;
+
+PROTOBUF_C__END_DECLS
+
+
+#endif  /* PROTOBUF_C_ThreadLoadingState_2eproto__INCLUDED */
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Hardware/HardwareBlowerType.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/Hardware/HardwareBlowerType.pb-c.c
index 785821681..5c50b430e 100644
--- a/Software/Embedded_SW/Embedded/Communication/PMR/Hardware/HardwareBlowerType.pb-c.c
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/Hardware/HardwareBlowerType.pb-c.c
@@ -7,16 +7,22 @@
 #endif
 
 #include "HardwareBlowerType.pb-c.h"
-static const ProtobufCEnumValue hardware_blower_type__enum_values_by_number[1] =
+static const ProtobufCEnumValue hardware_blower_type__enum_values_by_number[4] =
 {
   { "DefaultBlower", "HARDWARE_BLOWER_TYPE__DefaultBlower", 0 },
+  { "HeadBlower1", "HARDWARE_BLOWER_TYPE__HeadBlower1", 1 },
+  { "HeadBlower2", "HARDWARE_BLOWER_TYPE__HeadBlower2", 2 },
+  { "WHSBlower2", "HARDWARE_BLOWER_TYPE__WHSBlower2", 3 },
 };
 static const ProtobufCIntRange hardware_blower_type__value_ranges[] = {
-{0, 0},{0, 1}
+{0, 0},{0, 4}
 };
-static const ProtobufCEnumValueIndex hardware_blower_type__enum_values_by_name[1] =
+static const ProtobufCEnumValueIndex hardware_blower_type__enum_values_by_name[4] =
 {
   { "DefaultBlower", 0 },
+  { "HeadBlower1", 1 },
+  { "HeadBlower2", 2 },
+  { "WHSBlower2", 3 },
 };
 const ProtobufCEnumDescriptor hardware_blower_type__descriptor =
 {
@@ -25,9 +31,9 @@ const ProtobufCEnumDescriptor hardware_blower_type__descriptor =
   "HardwareBlowerType",
   "HardwareBlowerType",
   "",
-  1,
+  4,
   hardware_blower_type__enum_values_by_number,
-  1,
+  4,
   hardware_blower_type__enum_values_by_name,
   1,
   hardware_blower_type__value_ranges,
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Hardware/HardwareBlowerType.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/Hardware/HardwareBlowerType.pb-c.h
index 5be545162..b530430ff 100644
--- a/Software/Embedded_SW/Embedded/Communication/PMR/Hardware/HardwareBlowerType.pb-c.h
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/Hardware/HardwareBlowerType.pb-c.h
@@ -20,7 +20,10 @@ PROTOBUF_C__BEGIN_DECLS
 /* --- enums --- */
 
 typedef enum _HardwareBlowerType {
-  HARDWARE_BLOWER_TYPE__DefaultBlower = 0
+  HARDWARE_BLOWER_TYPE__DefaultBlower = 0,
+  HARDWARE_BLOWER_TYPE__HeadBlower1 = 1,
+  HARDWARE_BLOWER_TYPE__HeadBlower2 = 2,
+  HARDWARE_BLOWER_TYPE__WHSBlower2 = 3
     PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(HARDWARE_BLOWER_TYPE)
 } HardwareBlowerType;
 
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Hardware/HardwarePidControlType.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/Hardware/HardwarePidControlType.pb-c.c
index 3d172a588..e23a43487 100644
--- a/Software/Embedded_SW/Embedded/Communication/PMR/Hardware/HardwarePidControlType.pb-c.c
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/Hardware/HardwarePidControlType.pb-c.c
@@ -7,7 +7,7 @@
 #endif
 
 #include "HardwarePidControlType.pb-c.h"
-static const ProtobufCEnumValue hardware_pid_control_type__enum_values_by_number[23] =
+static const ProtobufCEnumValue hardware_pid_control_type__enum_values_by_number[33] =
 {
   { "DryerAirTemperature", "HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature", 0 },
   { "DryerHeaterMain", "HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain", 1 },
@@ -32,11 +32,21 @@ static const ProtobufCEnumValue hardware_pid_control_type__enum_values_by_number
   { "Dispenser6", "HARDWARE_PID_CONTROL_TYPE__Dispenser6", 20 },
   { "Dispenser7", "HARDWARE_PID_CONTROL_TYPE__Dispenser7", 21 },
   { "Dispenser8", "HARDWARE_PID_CONTROL_TYPE__Dispenser8", 22 },
+  { "HeadHeaterZ7", "HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ7", 23 },
+  { "HeadHeaterZ8", "HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ8", 24 },
+  { "HeadHeaterZ9", "HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ9", 25 },
+  { "HeadHeaterZ10", "HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ10", 26 },
+  { "HeadHeaterZ11", "HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ11", 27 },
+  { "HeadHeaterZ12", "HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ12", 28 },
+  { "HeadCoverHeater1", "HARDWARE_PID_CONTROL_TYPE__HeadCoverHeater1", 29 },
+  { "HeadCoverHeater2", "HARDWARE_PID_CONTROL_TYPE__HeadCoverHeater2", 30 },
+  { "HeadBlower_1", "HARDWARE_PID_CONTROL_TYPE__HeadBlower_1", 31 },
+  { "HeadBlower_2", "HARDWARE_PID_CONTROL_TYPE__HeadBlower_2", 32 },
 };
 static const ProtobufCIntRange hardware_pid_control_type__value_ranges[] = {
-{0, 0},{0, 23}
+{0, 0},{0, 33}
 };
-static const ProtobufCEnumValueIndex hardware_pid_control_type__enum_values_by_name[23] =
+static const ProtobufCEnumValueIndex hardware_pid_control_type__enum_values_by_name[33] =
 {
   { "Dispenser1", 15 },
   { "Dispenser2", 16 },
@@ -49,12 +59,22 @@ static const ProtobufCEnumValueIndex hardware_pid_control_type__enum_values_by_n
   { "DryerAirTemperature", 0 },
   { "DryerHeaterMain", 1 },
   { "DryerHeaterSecondary", 2 },
+  { "HeadBlower_1", 31 },
+  { "HeadBlower_2", 32 },
+  { "HeadCoverHeater1", 29 },
+  { "HeadCoverHeater2", 30 },
   { "HeadHeaterZ1", 3 },
+  { "HeadHeaterZ10", 26 },
+  { "HeadHeaterZ11", 27 },
+  { "HeadHeaterZ12", 28 },
   { "HeadHeaterZ2", 4 },
   { "HeadHeaterZ3", 5 },
   { "HeadHeaterZ4", 6 },
   { "HeadHeaterZ5", 7 },
   { "HeadHeaterZ6", 8 },
+  { "HeadHeaterZ7", 23 },
+  { "HeadHeaterZ8", 24 },
+  { "HeadHeaterZ9", 25 },
   { "MixerHeater", 9 },
   { "MotorDryer", 11 },
   { "MotorFeeder", 12 },
@@ -69,9 +89,9 @@ const ProtobufCEnumDescriptor hardware_pid_control_type__descriptor =
   "HardwarePidControlType",
   "HardwarePidControlType",
   "",
-  23,
+  33,
   hardware_pid_control_type__enum_values_by_number,
-  23,
+  33,
   hardware_pid_control_type__enum_values_by_name,
   1,
   hardware_pid_control_type__value_ranges,
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Hardware/HardwarePidControlType.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/Hardware/HardwarePidControlType.pb-c.h
index 83d8fe072..dd0fd770b 100644
--- a/Software/Embedded_SW/Embedded/Communication/PMR/Hardware/HardwarePidControlType.pb-c.h
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/Hardware/HardwarePidControlType.pb-c.h
@@ -42,7 +42,17 @@ typedef enum _HardwarePidControlType {
   HARDWARE_PID_CONTROL_TYPE__Dispenser5 = 19,
   HARDWARE_PID_CONTROL_TYPE__Dispenser6 = 20,
   HARDWARE_PID_CONTROL_TYPE__Dispenser7 = 21,
-  HARDWARE_PID_CONTROL_TYPE__Dispenser8 = 22
+  HARDWARE_PID_CONTROL_TYPE__Dispenser8 = 22,
+  HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ7 = 23,
+  HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ8 = 24,
+  HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ9 = 25,
+  HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ10 = 26,
+  HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ11 = 27,
+  HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ12 = 28,
+  HARDWARE_PID_CONTROL_TYPE__HeadCoverHeater1 = 29,
+  HARDWARE_PID_CONTROL_TYPE__HeadCoverHeater2 = 30,
+  HARDWARE_PID_CONTROL_TYPE__HeadBlower_1 = 31,
+  HARDWARE_PID_CONTROL_TYPE__HeadBlower_2 = 32
     PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(HARDWARE_PID_CONTROL_TYPE)
 } HardwarePidControlType;
 
diff --git a/Software/Embedded_SW/Embedded/DataDef.h b/Software/Embedded_SW/Embedded/DataDef.h
index 2d5a39909..a7674f041 100644
--- a/Software/Embedded_SW/Embedded/DataDef.h
+++ b/Software/Embedded_SW/Embedded/DataDef.h
@@ -9,13 +9,11 @@
 
 //#define EVALUATION_BOARD // to use the LCD only when using the evaluation board
 //#define USE_USB
-//#define DEMO_TEMPERATURE 1
 #define Stub_Mode 1
 #define USE_HIGH_SPEED_GPIO // to use AHB GPIO (A..J) ports A-J APB or AHB, ports K-Q on AHB only
 //#define WithTempSensorFiltrer (to use the function Filter_Temparature_Measurement)
 //#define DEBUG_TEST_FUNCTIONS
 #define  HIZ_TIMEOUT 1000
-//#define DEMO_TEMPERATURE
 //#define TEST_LONGER_PID_THREAD
 //#define HUNDRED_MICROSECONDS_DANCER_READ
 #define NO_INITIAL_HEATING
diff --git a/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_GPIO/FPGA_GPIO.c b/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_GPIO/FPGA_GPIO.c
index f5ef82720..648f535f8 100644
--- a/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_GPIO/FPGA_GPIO.c
+++ b/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_GPIO/FPGA_GPIO.c
@@ -515,13 +515,16 @@ uint32_t DeActivateCoolerPump() //WHS  - Pump the waste accumulated in cooler to
 uint32_t MagnetControlId = 0xFF;
 uint32_t MagnetCallBackFunction(uint32_t IfIndex, uint32_t BusyFlag)
 {
+#ifdef Use_Head_Card
+    HeadCard_HeadMagnet_Disable();
     if (SafeRemoveControlCallback(MagnetControlId, MagnetCallBackFunction )==OK)
         MagnetControlId = 0xFF;
     else
         Report("Remove control callback failed",__FILE__,__LINE__,(int)MagnetControlId,RpWarning,(int)MagnetCallBackFunction,0);
     Report("MagnetCallBackFunction",__FILE__,__LINE__,(int)MagnetControlId,RpWarning,(int)MagnetCallBackFunction,0);
+#else
     MotorStop(HARDWARE_MOTOR_TYPE__MOTO_RLOADARM,Hard_Hiz );
-
+#endif
     return OK;
 }
 
@@ -529,20 +532,34 @@ uint32_t ActivateHeadMagnet()
 {
     Report("ActivateHeadMagnet - Close the lid magnet",__FILE__,__LINE__,(int)HARDWARE_MOTOR_TYPE__MOTO_RLOADARM,RpWarning,(int)DH_LID_OPEN,0);
     //Task_sleep(500);
+#ifdef Use_Head_Card
+    HeadCard_ActivateHeadMagnet();
+
+#else
     F2_CTRL_Reg.ushort &= ~SPARE_SSR13_CTRL;
     F2_CTRL = F2_CTRL_Reg.ushort;
     if (isMotorConfigured(HARDWARE_MOTOR_TYPE__MOTO_RLOADARM))
     {
         MotorGoTo(HARDWARE_MOTOR_TYPE__MOTO_RLOADARM,DH_LID_CLOSE );
-        MagnetControlId = AddControlCallback(NULL, MagnetCallBackFunction, 2* eOneSecond, TemplateDataReadCBFunction,0,0, 0 );
 
         //MotorGotoWithCallback(HARDWARE_MOTOR_TYPE__MOTO_RLOADARM, DH_LID_CLOSE, Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_RLOADARM], NULL,1000);
     }
+#endif
+    MagnetControlId = AddControlCallback(NULL, MagnetCallBackFunction, 2* eOneSecond, TemplateDataReadCBFunction,0,0, 0 );
     return OK;
 }
-
+/*
+uint32_t HeadCard_ActivateHeadMagnet();
+uint32_t HeadCard_DeActivateHeadMagnet();
+uint32_t HeadCard_HeadMagnet_Disable();
+*/
 uint32_t DeActivateHeadMagnet()
 {
+
+#ifdef Use_Head_Card
+    HeadCard_DeActivateHeadMagnet();
+    MagnetControlId = AddControlCallback(NULL, MagnetCallBackFunction, 2* eOneSecond, TemplateDataReadCBFunction,0,0, 0 );
+#else
     Report("DeActivateHeadMagnet - open the lid magnet",__FILE__,__LINE__,(int)HARDWARE_MOTOR_TYPE__MOTO_RLOADARM,RpWarning,(int)DH_LID_CLOSE,0);
     if (isMotorConfigured(HARDWARE_MOTOR_TYPE__MOTO_RLOADARM))
     {
@@ -551,6 +568,7 @@ uint32_t DeActivateHeadMagnet()
     }
     F2_CTRL_Reg.ushort |= SPARE_SSR13_CTRL;
     F2_CTRL = F2_CTRL_Reg.ushort;
+#endif
     Task_sleep(500);
     return OK;
 }
diff --git a/Software/Embedded_SW/Embedded/Drivers/Heater/Heater.c b/Software/Embedded_SW/Embedded/Drivers/Heater/Heater.c
index 89b9be968..3479aff9b 100644
--- a/Software/Embedded_SW/Embedded/Drivers/Heater/Heater.c
+++ b/Software/Embedded_SW/Embedded/Drivers/Heater/Heater.c
@@ -19,15 +19,14 @@
 #include "driverlib/sysctl.h"
 
 #include <drivers/FPGA/FPGA_Comm.h>
+#include "Drivers/I2C_Communication/Head_Card/IO_Ports/Head_IO.h"
 #include <DataDef.h>
 
 #include <Modules/Stubs_Handler/User_Leds.h>
 #include "PMR/Hardware/HardwarePIDControl.pb-c.h"
+#include "PMR/Diagnostics/HeaterType.pb-c.h"
 
 #define MAX_HEATERS_NUM  HARDWARE_PID_CONTROL_TYPE__MixerHeater+1
-#ifdef DEMO_TEMPERATURE
-bool HeaterTestActive[MAX_HEATERS_NUM] = {0,0,0,0,0,0,0,0,0,0};
-#endif
 
 typedef struct
 {
@@ -56,13 +55,63 @@ static GPIOIntPortMap portMap[MAX_HEATERS_NUM] =
     {MIXCHIP_SSR4_CTRL,  false},  // HARDWARE_PID_CONTROL_TYPE__MixerHeater
 
 };
+HeaterType HeaterPidtoHeaterId[HARDWARE_PID_CONTROL_TYPE__HeadBlower_2+1]=
+{ HEATER_TYPE__DryerAirHeater,HEATER_TYPE__DryerMainHeater,HEATER_TYPE__DryerSecondaryHeater,
+  HEATER_TYPE__HeaterZone1,HEATER_TYPE__HeaterZone2,  HEATER_TYPE__HeaterZone3,HEATER_TYPE__HeaterZone4,HEATER_TYPE__HeaterZone5,HEATER_TYPE__HeaterZone6,HEATER_TYPE__MixerHeater,
+  0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,/*motors and dispensers*/
+  HEATER_TYPE__HeaterZone7, HEATER_TYPE__HeaterZone8, HEATER_TYPE__HeaterZone9, HEATER_TYPE__HeaterZone10, HEATER_TYPE__HeaterZone11, HEATER_TYPE__HeaterZone12,
+  HEATER_TYPE__HeadCoverHeater1,HEATER_TYPE__HeadCoverHeater2,0xFF,0xFF};
+HardwarePidControlType HeaterIdtoHeaterpid[HEATER_TYPE_MAX_HEATERS ]=
+{ HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature,HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain,HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2,
+  HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6,HARDWARE_PID_CONTROL_TYPE__MixerHeater,
+  HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ7, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ8, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ9,
+  HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ10, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ11, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ12};
+HeaterType HeaterTypetoHeadHeater[HEATER_TYPE_MAX_HEATERS] = {HEATER_TYPE_MAX_HEATERS,HEATER_TYPE_MAX_HEATERS,HEATER_TYPE_MAX_HEATERS,HEADCARD_HIT_ZN1,HEADCARD_HIT_ZN2,HEADCARD_HIT_ZN3,HEADCARD_HIT_ZN4,HEADCARD_HIT_ZN5,HEADCARD_HIT_ZN6,
+    HEADCARD_HIT_MIXER,HEADCARD_HIT_ZN8,HEADCARD_HIT_ZN9,HEADCARD_HIT_ZN10,HEADCARD_HIT_ZN11,HEADCARD_HIT_ZN12,HEADCARD_UPPER_HIT_IN1,HEADCARD_UPPER_HIT_OUT1};
+HEADCARD_HEATERS_ENUM HeadHeatertoHeaterType[HEADCARD_HIT_MIXER+1] = {HEATER_TYPE__HeaterZone1,HEATER_TYPE__HeaterZone2,HEATER_TYPE__HeaterZone3,HEATER_TYPE__HeaterZone4,HEATER_TYPE__HeaterZone5,HEATER_TYPE__HeaterZone6,
+    HEATER_TYPE__HeaterZone7,HEATER_TYPE__HeaterZone8,HEATER_TYPE__HeaterZone9,HEATER_TYPE__HeaterZone10,HEATER_TYPE__HeaterZone11,HEATER_TYPE__HeaterZone12,
+    HEATER_TYPE__HeadCoverHeater1,HEATER_TYPE_MAX_HEATERS,HEATER_TYPE_MAX_HEATERS,HEATER_TYPE_MAX_HEATERS,
+    HEATER_TYPE__HeadCoverHeater2,HEATER_TYPE_MAX_HEATERS,HEATER_TYPE_MAX_HEATERS,HEATER_TYPE_MAX_HEATERS,
+    HEATER_TYPE__MixerHeater};
+
+bool isHeater(HardwarePidControlType HeaterId)
+{
+    switch (HeaterId)
+    {
+      case HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature:
+      case HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain:
+      case HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary:
+      case HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1:
+      case HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2:
+      case HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3:
+      case HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4:
+      case HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5:
+      case HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6:
+      case HARDWARE_PID_CONTROL_TYPE__MixerHeater:
+      case HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ7:
+      case HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ8:
+      case HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ9:
+      case HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ10:
+      case HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ11:
+      case HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ12:
+        return true;
+    default:
+        return false;
+    }
+}
 
 uint32_t ActivateHeater (int HeaterId)
 {
-    assert(HeaterId < MAX_HEATERS_NUM);
-#ifdef DEMO_TEMPERATURE
-    if (HeaterTestActive[HeaterId])
-        return OK;
+    assert(isHeater(HeaterIdtoHeaterpid[HeaterId]));
+#ifdef Use_Head_Card
+    if (HeaterId>HEATER_TYPE__DryerSecondaryHeater)
+    {
+        HeadCard_Control_Heaters(HeaterIdtoHeaterpid[HeaterId],ON);
+    }
+    else
+    {
+#else
+        if (HeaterId >= HEATER_TYPE__HeaterZone7) return OK;
 #endif
     if (HeaterId == HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature)
     {
@@ -90,7 +139,7 @@ uint32_t ActivateHeater (int HeaterId)
         F2_CTRL = F2_CTRL_Reg.ushort;
     }
 #endif
-   //---------------------------------------------------------------------------------------
+//---------------------------------------------------------------------------------------
 //    if(HeaterId < HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1) // Turn On FPGA LED
 //        F3_GPO_01_bus |= (0x01 << HeaterId);
 //    else
@@ -110,7 +159,9 @@ uint32_t ActivateHeater (int HeaterId)
     //---------------------------------------------------------------------------------------
 
     HeaterActive |= 1 << HeaterId;
-
+#ifdef Use_Head_Card
+    }
+#endif
     //---------------------------------------------------------------------------------------
 
     return OK;
@@ -118,10 +169,16 @@ uint32_t ActivateHeater (int HeaterId)
 
 uint32_t DeActivateHeater (int HeaterId)
 {
-    assert(HeaterId < MAX_HEATERS_NUM);
-#ifdef DEMO_TEMPERATURE
-    if (HeaterTestActive[HeaterId])
-        return OK;
+    assert(isHeater(HeaterIdtoHeaterpid[HeaterId]));
+#ifdef Use_Head_Card
+    if (HeaterId>HEATER_TYPE__DryerSecondaryHeater)
+    {
+        HeadCard_Control_Heaters(HeaterIdtoHeaterpid[HeaterId],ON);
+    }
+    else
+    {
+#else
+    if (HeaterId >= HEATER_TYPE__HeaterZone7) return OK;
 #endif
 #ifndef EVALUATION_BOARD
     if(HeaterId == HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5)
@@ -160,13 +217,28 @@ uint32_t DeActivateHeater (int HeaterId)
     portMap[HeaterId].Active = false;
 
     HeaterActive &= ~(1 << HeaterId);
+#ifdef Use_Head_Card
+    }
+#endif
 
     return OK;
 }
 bool GetHeaterState (int HeaterId)
 {
-    assert(HeaterId < MAX_HEATERS_NUM);
+    assert(isHeater(HeaterIdtoHeaterpid[HeaterId]));
+#ifdef Use_Head_Card
+    if (HeaterId<=HEATER_TYPE__DryerSecondaryHeater)
+    {
+        return portMap[HeaterId].Active;
+    }
+    else
+    {
+        return(Get_HeadCard_Heater_State(HeaterIdtoHeaterpid[HeaterId]));
+    }
+
+#else
     return portMap[HeaterId].Active;
+#endif
 }
 
 
diff --git a/Software/Embedded_SW/Embedded/Drivers/Heater/Heater.h b/Software/Embedded_SW/Embedded/Drivers/Heater/Heater.h
index 835571200..cf6a2d235 100644
--- a/Software/Embedded_SW/Embedded/Drivers/Heater/Heater.h
+++ b/Software/Embedded_SW/Embedded/Drivers/Heater/Heater.h
@@ -1,18 +1,28 @@
+#ifndef DRIVERS_HEATER_HEATER_H_
+#define DRIVERS_HEATER_HEATER_H_
+
 #define HEATER_ON true
 #define HEATER_OFF false
 
 #include "include.h"
+#include "PMR/Hardware/HardwarePidControlType.pb-c.h"
+#include "PMR/Diagnostics/HeaterType.pb-c.h"
+#include "Drivers/I2C_Communication/Head_Card/IO_Ports/Head_IO.h"
+
+#define HEATER_TYPE_MAX_HEATERS HEATER_TYPE__HeadCoverHeater2+1
 
+extern HeaterType HeaterPidtoHeaterId[ HARDWARE_PID_CONTROL_TYPE__HeadBlower_2+1];
+extern HardwarePidControlType HeaterIdtoHeaterpid[HEATER_TYPE_MAX_HEATERS];
+extern HeaterType HeaterTypetoHeadHeater[HEATER_TYPE_MAX_HEATERS];
+extern HEADCARD_HEATERS_ENUM HeadHeatertoHeaterType[HEADCARD_HIT_MIXER+1];
 
 uint32_t  ActivateHeater (int HeaterId);
 uint32_t  DeActivateHeater (int HeaterId);
 bool    GetHeaterState (int HeaterId);
 uint32_t HeaterSetTemperatureWithCallback (int HeaterId, uint32_t RequestedTemperature, callback_fptr callback);
 //uint32_t HeaterBalanceLoadControlCBFunction(uint32_t IfIndex, uint32_t readValue);
-
-#ifdef DEMO_TEMPERATURE
-extern bool HeaterTestActive[];
-#endif
+bool isHeater(HardwarePidControlType HeaterId);
+inline HeaterType getHeaterId(HardwarePidControlType HeaterId){ return HeaterPidtoHeaterId[HeaterId];};
 
 extern uint32_t HeaterActive;
-
+#endif
diff --git a/Software/Embedded_SW/Embedded/Drivers/Heater/TemperatureSensor.c b/Software/Embedded_SW/Embedded/Drivers/Heater/TemperatureSensor.c
index 8aa441bec..201df8ec8 100644
--- a/Software/Embedded_SW/Embedded/Drivers/Heater/TemperatureSensor.c
+++ b/Software/Embedded_SW/Embedded/Drivers/Heater/TemperatureSensor.c
@@ -23,8 +23,6 @@
 uint32_t TemperatureSensorReadFromFPGA_Res(TEMPERATURE_SENSOR_ID_ENUM SensorId);
 //uint32_t TemperatureSendSensorDummyClk(TEMP_SENSE_ANALOG_DYEINGH_TEMP1);
 
-
-
 SENSOR_CONFIG_STAGES_ENUM SensConfigStages[MAX_MAIN_CARD_TEMP_SENS_ID] = {SENSOR_CONFIG_REG0}; // TODO remove buffer if it is the same for all the sensors
 
 uint8_t FPGA_SensorInitConfigReg()
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/IO_Ports/Head_IO.c b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/IO_Ports/Head_IO.c
index 6bba1b464..571e30b4e 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/IO_Ports/Head_IO.c
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/IO_Ports/Head_IO.c
@@ -272,15 +272,15 @@ uint32_t HeadCard_Valve_Control(bool Direction)
 {
     uint32_t status = OK;
 
-    Head_I2C_EXP2_0x42.bits.OUTPUT_VALVE_EN  = ENABLE;
-    Head_I2C_EXP2_0x42.bits.OUTPUT_VALVE_DIR = Direction;
+    Head_I2C_EXP2_0x42.bits.OUTPUT_VALVE_EN  = Direction;
+//    Head_I2C_EXP2_0x42.bits.OUTPUT_VALVE_DIR = Direction;
 
     status |= Head_Write_IO_Reg(0x42);
 
     return status;
 }
 
-uint32_t HeadCard_Valve_Disable()
+/*uint32_t HeadCard_Valve_Disable()
 {
     uint32_t status = OK;
 
@@ -290,7 +290,7 @@ uint32_t HeadCard_Valve_Disable()
 
     return status;
 }
-
+*/
 uint32_t HeadCard_Enable_8_Upper_Heaters(bool Pwr_Cmd)//ON/OFF
 {
     uint32_t status = OK;
@@ -301,11 +301,18 @@ uint32_t HeadCard_Enable_8_Upper_Heaters(bool Pwr_Cmd)//ON/OFF
 
     return status;
 }
-
+bool HeaterMap[HEADCARD_HIT_MIXER+1] = {0};
+bool Get_HeadCard_Heater_State(uint8_t Heater_ID)
+{
+    assert(Heater_ID<=HEADCARD_HIT_MIXER);
+    return HeaterMap[Heater_ID];
+}
 uint32_t HeadCard_Control_Heaters(uint8_t Heater_ID, bool Pwr_Cmd)//ON/OFF
 {
     uint32_t status = OK;
 
+    assert(Heater_ID<=HEADCARD_HIT_MIXER);
+    HeaterMap[Heater_ID] = Pwr_Cmd;
     switch(Heater_ID)
     {
         case HEADCARD_HIT_ZN1:
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/IO_Ports/Head_IO.h b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/IO_Ports/Head_IO.h
index 07a2e284c..aa4e0f024 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/IO_Ports/Head_IO.h
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/IO_Ports/Head_IO.h
@@ -162,7 +162,7 @@ extern HEAD_I2C_EXP3_0x44  Head_I2C_EXP3_0x44;
 extern HEAD_I2C_EXP4_0x46  Head_I2C_EXP4_0x46;
 
 #warning move to heaters enum
-enum
+typedef enum
 {
     HEADCARD_HIT_ZN1,
     HEADCARD_HIT_ZN2,
@@ -201,6 +201,17 @@ uint32_t Head_Write_IO_Reg(uint8_t TCA9555_ADDRESS);
 uint32_t Head_Read_IO_Reg(uint8_t TCA9555_ADDRESS);
 uint32_t HeadCard_Toggle_PT100_SEL(bool Odd_OR_Even);
 
+uint32_t HeadCard_Valve_Control(bool Direction);
+
+uint32_t HeadCard_ActivateHeadMagnet();
+uint32_t HeadCard_DeActivateHeadMagnet();
+uint32_t HeadCard_HeadMagnet_Disable();
+
+uint32_t HeadCard_Valve_Control(bool Direction);
+
+uint32_t HeadCard_Control_Heaters(uint8_t Heater_ID, bool Pwr_Cmd);
+bool Get_HeadCard_Heater_State(uint8_t Heater_ID);
+
 //------------------------------
 uint8_t Head_Test_IO();
 
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C_Task.c b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C_Task.c
index aa6bfccac..272713389 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C_Task.c
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C_Task.c
@@ -11,6 +11,7 @@
 #include "inc/hw_memmap.h"
 
 #include "drivers/ADC_Sampling/adc.h"
+#include "drivers/I2C_Communication/Head_Card/ADC/Head_ADC.h"
 
 #include "ADC_MUX/ADC_MUX.h"
 #include "modules/ids/ids_ex.h"
@@ -31,8 +32,11 @@ void Trigger_Heater_Current_Read(void)
 {
     I2C_ReadingMessageStruc I2C_ReadingMessage;
     uint8_t Heater_i;
-
+#ifdef Use_Head_Card
+    for (Heater_i = 0;Heater_i < HEAD_NUM_OF_ADC;Heater_i++)
+#else
     for (Heater_i = 0;Heater_i < NUM_OF_CURRENT_HEATERS;Heater_i++)
+#endif
     {
         I2C_ReadingMessage.messageId = Heater_Current_Reading;
         I2C_ReadingMessage.parameter = Heater_i;
@@ -76,8 +80,12 @@ void I2C_ReadingTask(UArg arg0, UArg arg1)
             break;
         case Heater_Current_Reading:
             //Report("Read_Heaters_Current",__FILE__,__LINE__,255,RpWarning,0,0);
+#ifdef Use_Head_Card
+            Read_Head_ADC(I2C_ReadingMessage.parameter);
+#else
             Read_Heaters_Current(I2C_ReadingMessage.parameter);
-            break;
+#endif
+        break;
         default:
             break;
         }
diff --git a/Software/Embedded_SW/Embedded/Drivers/Valves/Valve.c b/Software/Embedded_SW/Embedded/Drivers/Valves/Valve.c
index a604f9bc6..9f96b4deb 100644
--- a/Software/Embedded_SW/Embedded/Drivers/Valves/Valve.c
+++ b/Software/Embedded_SW/Embedded/Drivers/Valves/Valve.c
@@ -17,6 +17,7 @@
 
 #include "drivers/FPGA/FPGA_Comm.h"
 #include <Drivers/Valves/Valve.h>
+#include "Drivers/I2C_Communication/Head_Card/IO_Ports/Head_IO.h"
 
 #include "Modules/Control/Control.h"
 
@@ -125,7 +126,11 @@ void Valve_Command(Valves_t Valve_Id) //1 - OPEN, 0 - CLOSE
                 F1_GPO_Reg.bits.F1_VALVE_WASTE_TANK = ValveRequest[Valve_Id].Direction;
             break;
         case VALVE_MIXCHIP_WASTECH:
+#ifdef Use_Head_Card
+            HeadCard_Valve_Control(ValveRequest[Valve_Id].Direction);
+#else
                 F1_GPO_Reg.bits.F1_VALVE_MIXCHIP_WASTECH = ValveRequest[Valve_Id].Direction;
+#endif
             break;
 
         case VALVE_DISPENSER_1:
@@ -372,13 +377,13 @@ uint32_t Control3WayValvesWithCallback (Valves_t _ValveId, bool direction, callb
 
     Valve3WayModuleCallback[_ValveId] = callback;
 
-    busy = FPGA_GetDispenserValveBusyOCD(_ValveId,0);
-    //Report("Set valve id, dir, busy",__FILE__,_ValveId,(int)direction,RpWarning,(int)busy,0);
     Valve3WayControlId[_ValveId] = AddControlCallback("Valve3WayControlId", Valve3WayCallBackFunction,  eOneSecond/*eHundredMillisecond*/, FPGA_GetDispenserValveBusyOCD,(IfTypeDisopenser*0x100+_ValveId), _ValveId, 0 );
     if (Valve3WayControlId[_ValveId] == 0xFF)
         Report("Add control callback failed",__FILE__,__LINE__,(int)_ValveId,RpWarning,(int)Valve3WayControlId[_ValveId],0);
     //else
     //    Report("Add control callback",__FILE__,__LINE__,(int)_ValveId,RpWarning,(int)Valve3WayControlId[_ValveId],0);
+    busy = FPGA_GetDispenserValveBusyOCD(_ValveId,0);
+    //Report("Set valve id, dir, busy",__FILE__,_ValveId,(int)direction,RpWarning,(int)busy,0);
 
     EnableDisableDispenserValve(_ValveId, ENABLE);
 
diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
index 11d08d45a..b62b33cc5 100644
--- a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
+++ b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
@@ -171,265 +171,265 @@ uint32_t * pAlarmItemSize = (uint32_t *)(ALARM_MAP_IN_FLASH);
 uint32_t AlarmItemSize ;
 AlarmHandlingItemStruc  *AlarmItem  = (AlarmHandlingItemStruc *)(ALARM_MAP_IN_FLASH+4);
 AlarmHandlingItemStruc  HardCodedAlarmItem[MAX_SYSTEM_ALARMS]={
-/*	7016	*/     {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_1,0,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_1_EMPTY},
-/*	7017	*/     {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_2,1,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_2_EMPTY},
-/*	7018	*/     {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_3,2,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_3_EMPTY},
-/*	7019	*/     {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_4,3,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_4_EMPTY},
-/*	7020	*/     {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_5,4,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_5_EMPTY},
-/*	7021	*/     {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_6,5,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_6_EMPTY},
-/*	7022	*/     {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_7,6,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_7_EMPTY},
-/*	7023	*/     {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_8,7,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_8_EMPTY},
+//* 7016    */     {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_1,0,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_1_EMPTY},
+//* 7017    */     {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_2,1,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_2_EMPTY},
+//* 7018    */     {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_3,2,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_3_EMPTY},
+//* 7019    */     {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_4,3,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_4_EMPTY},
+//* 7020    */     {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_5,4,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_5_EMPTY},
+//* 7021    */     {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_6,5,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_6_EMPTY},
+//* 7022    */     {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_7,6,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_7_EMPTY},
+//* 7023    */     {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_8,7,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_8_EMPTY},
 
-/*	7064	*/     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,0,0,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_1_UPPER_HARD_LIMIT},
-/*	7065	*/     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,1,1,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_2_UPPER_HARD_LIMIT},
-/*	7066	*/     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,2,2,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_3_UPPER_HARD_LIMIT},
-/*	7067	*/     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,3,3,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_4_UPPER_HARD_LIMIT},
-/*	7068	*/     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,4,4,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_5_UPPER_HARD_LIMIT},
-/*	7069	*/     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,5,5,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_6_UPPER_HARD_LIMIT},
-/*	7070	*/     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,6,6,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_7_UPPER_HARD_LIMIT},
-/*	7071	*/     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,7,7,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_8_UPPER_HARD_LIMIT},
-/*	7072	*/     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,0,0,true,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_1_LOWER_HARD_LIMIT},
-/*	7073	*/     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,1,1,true,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_2_LOWER_HARD_LIMIT},
-/*	7074	*/     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,2,2,true,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_3_LOWER_HARD_LIMIT},
-/*	7075	*/     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,3,3,true,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_4_LOWER_HARD_LIMIT},
-/*	7076	*/     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,4,4,true,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_5_LOWER_HARD_LIMIT},
-/*	7077	*/     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,5,5,true,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_6_LOWER_HARD_LIMIT},
-/*	7078	*/     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,6,6,true,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_7_LOWER_HARD_LIMIT},
-/*	7079	*/     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,7,7,true,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_8_LOWER_HARD_LIMIT},
+//* 7064    */     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,0,0,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_1_UPPER_HARD_LIMIT},
+//* 7065    */     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,1,1,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_2_UPPER_HARD_LIMIT},
+//* 7066    */     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,2,2,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_3_UPPER_HARD_LIMIT},
+//* 7067    */     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,3,3,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_4_UPPER_HARD_LIMIT},
+//* 7068    */     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,4,4,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_5_UPPER_HARD_LIMIT},
+//* 7069    */     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,5,5,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_6_UPPER_HARD_LIMIT},
+//* 7070    */     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,6,6,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_7_UPPER_HARD_LIMIT},
+//* 7071    */     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,7,7,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_8_UPPER_HARD_LIMIT},
+//* 7072    */     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,0,0,true,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_1_LOWER_HARD_LIMIT},
+//* 7073    */     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,1,1,true,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_2_LOWER_HARD_LIMIT},
+//* 7074    */     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,2,2,true,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_3_LOWER_HARD_LIMIT},
+//* 7075    */     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,3,3,true,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_4_LOWER_HARD_LIMIT},
+//* 7076    */     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,4,4,true,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_5_LOWER_HARD_LIMIT},
+//* 7077    */     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,5,5,true,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_6_LOWER_HARD_LIMIT},
+//* 7078    */     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,6,6,true,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_7_LOWER_HARD_LIMIT},
+//* 7079    */     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,7,7,true,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_8_LOWER_HARD_LIMIT},
 
-/*	7080	*/     {eOneSecond,ALARM_SOURCE_TYPE__PressureAlarm,0,0,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_1_HIGH_PRESSURE},
-/*	7081	*/     {eOneSecond,ALARM_SOURCE_TYPE__PressureAlarm,1,1,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_2_HIGH_PRESSURE},
-/*	7082	*/     {eOneSecond,ALARM_SOURCE_TYPE__PressureAlarm,2,2,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_3_HIGH_PRESSURE},
-/*	7083	*/     {eOneSecond,ALARM_SOURCE_TYPE__PressureAlarm,3,3,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_4_HIGH_PRESSURE},
-/*	7084	*/     {eOneSecond,ALARM_SOURCE_TYPE__PressureAlarm,4,4,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_5_HIGH_PRESSURE},
-/*	7085	*/     {eOneSecond,ALARM_SOURCE_TYPE__PressureAlarm,5,5,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_6_HIGH_PRESSURE},
-/*	7086	*/     {eOneSecond,ALARM_SOURCE_TYPE__PressureAlarm,6,6,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_7_HIGH_PRESSURE},
-/*	7087	*/     {eOneSecond,ALARM_SOURCE_TYPE__PressureAlarm,7,7,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_8_HIGH_PRESSURE},
+//* 7080    */     {eOneSecond,ALARM_SOURCE_TYPE__PressureAlarm,0,0,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_1_HIGH_PRESSURE},
+//* 7081    */     {eOneSecond,ALARM_SOURCE_TYPE__PressureAlarm,1,1,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_2_HIGH_PRESSURE},
+//* 7082    */     {eOneSecond,ALARM_SOURCE_TYPE__PressureAlarm,2,2,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_3_HIGH_PRESSURE},
+//* 7083    */     {eOneSecond,ALARM_SOURCE_TYPE__PressureAlarm,3,3,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_4_HIGH_PRESSURE},
+//* 7084    */     {eOneSecond,ALARM_SOURCE_TYPE__PressureAlarm,4,4,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_5_HIGH_PRESSURE},
+//* 7085    */     {eOneSecond,ALARM_SOURCE_TYPE__PressureAlarm,5,5,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_6_HIGH_PRESSURE},
+//* 7086    */     {eOneSecond,ALARM_SOURCE_TYPE__PressureAlarm,6,6,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_7_HIGH_PRESSURE},
+//* 7087    */     {eOneSecond,ALARM_SOURCE_TYPE__PressureAlarm,7,7,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_8_HIGH_PRESSURE},
 
-/*	7000	*/     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_1_OVERPRESSURE},
-/*	7001	*/     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_2_OVERPRESSURE},
-/*	7002	*/     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_3_OVERPRESSURE},
-/*	7003	*/     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_4_OVERPRESSURE},
-/*	7004	*/     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_5_OVERPRESSURE},
-/*	7005	*/     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_6_OVERPRESSURE},
-/*	7006	*/     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_7_OVERPRESSURE},
-/*	7007	*/     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_8_OVERPRESSURE},
+//* 7000    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_1_OVERPRESSURE},
+//* 7001    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_2_OVERPRESSURE},
+//* 7002    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_3_OVERPRESSURE},
+//* 7003    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_4_OVERPRESSURE},
+//* 7004    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_5_OVERPRESSURE},
+//* 7005    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_6_OVERPRESSURE},
+//* 7006    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_7_OVERPRESSURE},
+//* 7007    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_8_OVERPRESSURE},
 
-/*	8000	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,0,0,300/*300cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_1_LOW_LEVEL},
-/*	8001	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,1,1,300/*300cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_2_LOW_LEVEL},
-/*	8002	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,2,2,300/*300cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_3_LOW_LEVEL},
-/*	8003	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,3,3,300/*300cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_4_LOW_LEVEL},
-/*	8004	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,4,4,300/*300cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_5_LOW_LEVEL},
-/*	8005	*/     //{eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,5,5,300/*300cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_6_LOW_LEVEL},
-/*	8006	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,6,6,300/*300cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_7_LOW_LEVEL},
-/*	8007	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,7,7,300/*300cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_8_LOW_LEVEL},
-/*	8008	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,0,0,200/*200cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_1_EMPTY},
-/*	8009	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,1,1,200/*200cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_2_EMPTY},
-/*	8010	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,2,2,200/*200cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_3_EMPTY},
-/*	8011	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,3,3,200/*200cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_4_EMPTY},
-/*	8012	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,4,4,200/*200cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_5_EMPTY},
-/*	8013	*/     //{eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,5,5,200/*200cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_6_EMPTY},
-/*	8014	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,6,6,200/*200cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_7_EMPTY},
-/*	8015	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,7,7,200/*200cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_8_EMPTY},
+//* 8000    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,0,0,300//*300cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_1_LOW_LEVEL},
+//* 8001    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,1,1,300//*300cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_2_LOW_LEVEL},
+//* 8002    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,2,2,300//*300cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_3_LOW_LEVEL},
+//* 8003    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,3,3,300//*300cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_4_LOW_LEVEL},
+//* 8004    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,4,4,300//*300cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_5_LOW_LEVEL},
+//* 8005    */     //{eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,5,5,300//*300cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_6_LOW_LEVEL},
+//* 8006    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,6,6,300//*300cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_7_LOW_LEVEL},
+//* 8007    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,7,7,300//*300cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_8_LOW_LEVEL},
+//* 8008    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,0,0,200//*200cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_1_EMPTY},
+//* 8009    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,1,1,200//*200cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_2_EMPTY},
+//* 8010    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,2,2,200//*200cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_3_EMPTY},
+//* 8011    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,3,3,200//*200cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_4_EMPTY},
+//* 8012    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,4,4,200//*200cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_5_EMPTY},
+//* 8013    */     //{eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,5,5,200//*200cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_6_EMPTY},
+//* 8014    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,6,6,200//*200cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_7_EMPTY},
+//* 8015    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,7,7,200//*200cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_8_EMPTY},
 
-/*	8016	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,0,0,1800/*1800cc*/,true,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_1_OVERFLOW},
-/*	8017	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,1,1,1800/*1800cc*/,true,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_2_OVERFLOW},
-/*	8018	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,2,2,1800/*1800cc*/,true,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_3_OVERFLOW},
-/*	8019	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,3,3,1800/*1800cc*/,true,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_4_OVERFLOW},
-/*	8020	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,4,4,1800/*1800cc*/,true,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_5_OVERFLOW},
-/*	8021	*/     //{eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,5,5,1800/*1800cc*/,true,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_6_OVERFLOW},
-/*	8022	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,6,6,1800/*1800cc*/,true,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_7_OVERFLOW},
-/*	8023	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,7,7,1800/*1800cc*/,true,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_8_OVERFLOW},
+//* 8016    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,0,0,1800//*1800cc*/,true,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_1_OVERFLOW},
+//* 8017    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,1,1,1800//*1800cc*/,true,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_2_OVERFLOW},
+//* 8018    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,2,2,1800//*1800cc*/,true,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_3_OVERFLOW},
+//* 8019    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,3,3,1800//*1800cc*/,true,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_4_OVERFLOW},
+//* 8020    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,4,4,1800//*1800cc*/,true,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_5_OVERFLOW},
+//* 8021    */     //{eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,5,5,1800//*1800cc*/,true,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_6_OVERFLOW},
+//* 8022    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,6,6,1800//*1800cc*/,true,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_7_OVERFLOW},
+//* 8023    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,7,7,1800//*1800cc*/,true,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_8_OVERFLOW},
 
 
-/*	4000	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DRYER_MOTOR_OVERCURRENT  },
-/*	3003	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,     HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,     x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__FEEDER_MOTOR_OVERCURRENT },
-/*	3008	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_SCREW,        HARDWARE_MOTOR_TYPE__MOTO_SCREW,        x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__SCREW_MOTOR_OVERCURRENT  },
-/*	3007	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_WINDER,       HARDWARE_MOTOR_TYPE__MOTO_WINDER,       x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__WINDER_MOTOR_OVERCURRENT },
-/*	3005	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,     HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,     x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__PULLER_MOTOR_OVERCURRENT },
-/*	7032	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,  x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_1_MOTOR_OVERCURRENT},
-/*	7033	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,  x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_2_MOTOR_OVERCURRENT},
-/*	7034	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,  x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_3_MOTOR_OVERCURRENT},
-/*	7035	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,  x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_4_MOTOR_OVERCURRENT},
-/*	7036	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,  x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_5_MOTOR_OVERCURRENT},
-/*	7037	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,  x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_6_MOTOR_OVERCURRENT},
-/*	7038	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,  x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_7_MOTOR_OVERCURRENT},
-/*	7039	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,  x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_8_MOTOR_OVERCURRENT},
-/*	4001	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DRYER_MOTOR_OVERTEMPERATURE},
-/*	3010	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,     HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,     x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__FEEDER_MOTOR_OVERTEMPERATURE},
-/*	3015	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_SCREW,        HARDWARE_MOTOR_TYPE__MOTO_SCREW,        x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__SCREW_MOTOR_OVERTEMPERATURE },
-/*	3014	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_WINDER,       HARDWARE_MOTOR_TYPE__MOTO_WINDER,       x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__WINDER_MOTOR_OVERTEMPERATURE},
-/*	3012	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,     HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,     x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__PULLER_MOTOR_OVERTEMPERATURE},
-/*	7040	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,  x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_1_MOTOR_OVERTEMPERATURE},
-/*	7041	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,  x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_2_MOTOR_OVERTEMPERATURE},
-/*	7042	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,  x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_3_MOTOR_OVERTEMPERATURE},
-/*	7043	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,  x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_4_MOTOR_OVERTEMPERATURE},
-/*	7044	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,  x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_5_MOTOR_OVERTEMPERATURE},
-/*	7045	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,  x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_6_MOTOR_OVERTEMPERATURE},
-/*	7046	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,  x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_7_MOTOR_OVERTEMPERATURE},
-/*	7047	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,  x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_8_MOTOR_OVERTEMPERATURE},
-/*	4003	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DRYER_MOTOR_UNDERVOLTAGE },
-/*	3024	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,     HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,     x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__FEEDER_MOTOR_UNDERVOLTAGE},
-/*	3029	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_SCREW,        HARDWARE_MOTOR_TYPE__MOTO_SCREW,        x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__SCREW_MOTOR_UNDERVOLTAGE },
-/*	3028	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_WINDER,       HARDWARE_MOTOR_TYPE__MOTO_WINDER,       x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__WINDER_MOTOR_UNDERVOLTAGE},
-/*	3026	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,     HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,     x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__PULLER_MOTOR_UNDERVOLTAGE},
-/*	7056	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,  x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_1_MOTOR_UNDERVOLTAGE},
-/*	7057	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,  x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_2_MOTOR_UNDERVOLTAGE},
-/*	7058	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,  x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_3_MOTOR_UNDERVOLTAGE},
-/*	7059	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,  x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_4_MOTOR_UNDERVOLTAGE},
-/*	7060	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,  x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_5_MOTOR_UNDERVOLTAGE},
-/*	7061	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,  x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_6_MOTOR_UNDERVOLTAGE},
-/*	7062	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,  x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_7_MOTOR_UNDERVOLTAGE},
-/*	7063	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,  x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_8_MOTOR_UNDERVOLTAGE},
-/*	4002	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DRYER_MOTOR_STALL    },
-/*	3017	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,     HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,     x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__FEEDER_MOTOR_STALL   },
-/*	3022	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_SCREW,        HARDWARE_MOTOR_TYPE__MOTO_SCREW,        x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__SCREW_MOTOR_STALL    },
-/*	3021	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_WINDER,       HARDWARE_MOTOR_TYPE__MOTO_WINDER,       x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__WINDER_MOTOR_STALL   },
-/*	3019	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,     HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,     x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__PULLER_MOTOR_STALL   },
-/*	7048	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,  x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_1_MOTOR_STALL},
-/*	7049	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,  x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_2_MOTOR_STALL},
-/*	7050	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,  x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_3_MOTOR_STALL},
-/*	7051	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,  x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_4_MOTOR_STALL},
-/*	7052	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,  x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_5_MOTOR_STALL},
-/*	7053	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,  x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_6_MOTOR_STALL},
-/*	7054	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,  x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_7_MOTOR_STALL},
-/*	7055	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,  x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_8_MOTOR_STALL},
+//* 4000    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DRYER_MOTOR_OVERCURRENT  },
+//* 3003    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,     HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,     x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__FEEDER_MOTOR_OVERCURRENT },
+//* 3008    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_SCREW,        HARDWARE_MOTOR_TYPE__MOTO_SCREW,        x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__SCREW_MOTOR_OVERCURRENT  },
+//* 3007    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_WINDER,       HARDWARE_MOTOR_TYPE__MOTO_WINDER,       x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__WINDER_MOTOR_OVERCURRENT },
+//* 3005    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,     HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,     x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__PULLER_MOTOR_OVERCURRENT },
+//* 7032    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,  x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_1_MOTOR_OVERCURRENT},
+//* 7033    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,  x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_2_MOTOR_OVERCURRENT},
+//* 7034    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,  x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_3_MOTOR_OVERCURRENT},
+//* 7035    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,  x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_4_MOTOR_OVERCURRENT},
+//* 7036    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,  x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_5_MOTOR_OVERCURRENT},
+//* 7037    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,  x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_6_MOTOR_OVERCURRENT},
+//* 7038    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,  x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_7_MOTOR_OVERCURRENT},
+//* 7039    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,  x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_8_MOTOR_OVERCURRENT},
+//* 4001    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DRYER_MOTOR_OVERTEMPERATURE},
+//* 3010    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,     HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,     x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__FEEDER_MOTOR_OVERTEMPERATURE},
+//* 3015    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_SCREW,        HARDWARE_MOTOR_TYPE__MOTO_SCREW,        x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__SCREW_MOTOR_OVERTEMPERATURE },
+//* 3014    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_WINDER,       HARDWARE_MOTOR_TYPE__MOTO_WINDER,       x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__WINDER_MOTOR_OVERTEMPERATURE},
+//* 3012    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,     HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,     x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__PULLER_MOTOR_OVERTEMPERATURE},
+//* 7040    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,  x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_1_MOTOR_OVERTEMPERATURE},
+//* 7041    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,  x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_2_MOTOR_OVERTEMPERATURE},
+//* 7042    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,  x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_3_MOTOR_OVERTEMPERATURE},
+//* 7043    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,  x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_4_MOTOR_OVERTEMPERATURE},
+//* 7044    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,  x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_5_MOTOR_OVERTEMPERATURE},
+//* 7045    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,  x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_6_MOTOR_OVERTEMPERATURE},
+//* 7046    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,  x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_7_MOTOR_OVERTEMPERATURE},
+//* 7047    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,  x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_8_MOTOR_OVERTEMPERATURE},
+//* 4003    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DRYER_MOTOR_UNDERVOLTAGE },
+//* 3024    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,     HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,     x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__FEEDER_MOTOR_UNDERVOLTAGE},
+//* 3029    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_SCREW,        HARDWARE_MOTOR_TYPE__MOTO_SCREW,        x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__SCREW_MOTOR_UNDERVOLTAGE },
+//* 3028    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_WINDER,       HARDWARE_MOTOR_TYPE__MOTO_WINDER,       x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__WINDER_MOTOR_UNDERVOLTAGE},
+//* 3026    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,     HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,     x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__PULLER_MOTOR_UNDERVOLTAGE},
+//* 7056    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,  x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_1_MOTOR_UNDERVOLTAGE},
+//* 7057    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,  x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_2_MOTOR_UNDERVOLTAGE},
+//* 7058    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,  x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_3_MOTOR_UNDERVOLTAGE},
+//* 7059    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,  x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_4_MOTOR_UNDERVOLTAGE},
+//* 7060    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,  x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_5_MOTOR_UNDERVOLTAGE},
+//* 7061    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,  x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_6_MOTOR_UNDERVOLTAGE},
+//* 7062    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,  x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_7_MOTOR_UNDERVOLTAGE},
+//* 7063    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,  x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_8_MOTOR_UNDERVOLTAGE},
+//* 4002    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DRYER_MOTOR_STALL    },
+//* 3017    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,     HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,     x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__FEEDER_MOTOR_STALL   },
+//* 3022    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_SCREW,        HARDWARE_MOTOR_TYPE__MOTO_SCREW,        x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__SCREW_MOTOR_STALL    },
+//* 3021    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_WINDER,       HARDWARE_MOTOR_TYPE__MOTO_WINDER,       x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__WINDER_MOTOR_STALL   },
+//* 3019    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,     HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,     x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__PULLER_MOTOR_STALL   },
+//* 7048    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,  x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_1_MOTOR_STALL},
+//* 7049    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,  x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_2_MOTOR_STALL},
+//* 7050    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,  x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_3_MOTOR_STALL},
+//* 7051    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,  x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_4_MOTOR_STALL},
+//* 7052    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,  x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_5_MOTOR_STALL},
+//* 7053    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,  x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_6_MOTOR_STALL},
+//* 7054    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,  x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_7_MOTOR_STALL},
+//* 7055    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,  x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_8_MOTOR_STALL},
 
-/*	6000	*/     {eHundredMillisecond,ALARM_SOURCE_TYPE__TemperatureAlarm,MIXER_PT100,   HARDWARE_PID_CONTROL_TYPE__MixerHeater        ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MIXER_OVERTEMPERATURE},
-/*	5000	*/     {eHundredMillisecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1       ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_1_OVERTEMPERATURE},
-/*	5001	*/     {eHundredMillisecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2       ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_2_OVERTEMPERATURE},
-/*	5002	*/     {eHundredMillisecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3       ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_3_OVERTEMPERATURE},
-/*	5003	*/     {eHundredMillisecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4       ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_4_OVERTEMPERATURE},
-/*	5004	*/     {eHundredMillisecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5       ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_5_OVERTEMPERATURE},
-/*	5005	*/     {eHundredMillisecond,ALARM_SOURCE_TYPE__TemperatureAlarm,HEAD6_PT100, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6       ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_6_OVERTEMPERATURE                   },
-/*	4005	*/     {eHundredMillisecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1,  HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DRYER_ZONE_1_OVERTEMPERATURE      },
+//* 6000    */     {eHundredMillisecond,ALARM_SOURCE_TYPE__TemperatureAlarm,MIXER_PT100,   HARDWARE_PID_CONTROL_TYPE__MixerHeater        ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MIXER_OVERTEMPERATURE},
+//* 5000    */     {eHundredMillisecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1       ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_1_OVERTEMPERATURE},
+//* 5001    */     {eHundredMillisecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2       ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_2_OVERTEMPERATURE},
+//* 5002    */     {eHundredMillisecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3       ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_3_OVERTEMPERATURE},
+//* 5003    */     {eHundredMillisecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4       ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_4_OVERTEMPERATURE},
+//* 5004    */     {eHundredMillisecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5       ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_5_OVERTEMPERATURE},
+//* 5005    */     {eHundredMillisecond,ALARM_SOURCE_TYPE__TemperatureAlarm,HEAD6_PT100, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6       ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_6_OVERTEMPERATURE                   },
+//* 4005    */     {eHundredMillisecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1,  HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DRYER_ZONE_1_OVERTEMPERATURE      },
 
-/*	2008	*/     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_AN_ENCLOSURETEMP1,  0,40,true,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__MACHINE_INTERNAL_OVERTEMPERATURE      },
-/*	2017	*/     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_AN_ENCLOSURETEMP2,  1,40,true,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__MACHINE_INTERNAL_OVERTEMPERATURE      },
+//* 2008    */     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_AN_ENCLOSURETEMP1,  0,40,true,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__MACHINE_INTERNAL_OVERTEMPERATURE      },
+//* 2017    */     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_AN_ENCLOSURETEMP2,  1,40,true,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__MACHINE_INTERNAL_OVERTEMPERATURE      },
 
-/*	2002	*/  //   {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,FrontDoor1_EC      ,1,true,true,DEBUG_LOG_CATEGORY__Error,  0xFF,5,EVENT_TYPE__FRONT_COVER_1_OPEN},
-/*	2003	*/  //   {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,FrontDoor2_PPC     ,1,true,true,DEBUG_LOG_CATEGORY__Error,  0xFF,5,EVENT_TYPE__FRONT_COVER_2_OPEN},
-/*	2004	*/  //   {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,FrontDoor3_DH_DRYER,1,true,true,DEBUG_LOG_CATEGORY__Error,  0xFF,5,EVENT_TYPE__FRONT_COVER_3_OPEN},
-/*	2005	*/  //   {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,FrontDoor4_MIDTANKS,1,true,true,DEBUG_LOG_CATEGORY__Error,  0xFF,5,EVENT_TYPE__FRONT_COVER_4_OPEN},
-/*	2007	*/  //  {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,RearDoor           ,1,true,true,DEBUG_LOG_CATEGORY__Error,  0xFF,5,EVENT_TYPE__REAR_COVER_OPEN     },
+//* 2002    */  //   {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,FrontDoor1_EC      ,1,true,true,DEBUG_LOG_CATEGORY__Error,  0xFF,5,EVENT_TYPE__FRONT_COVER_1_OPEN},
+//* 2003    */  //   {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,FrontDoor2_PPC     ,1,true,true,DEBUG_LOG_CATEGORY__Error,  0xFF,5,EVENT_TYPE__FRONT_COVER_2_OPEN},
+//* 2004    */  //   {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,FrontDoor3_DH_DRYER,1,true,true,DEBUG_LOG_CATEGORY__Error,  0xFF,5,EVENT_TYPE__FRONT_COVER_3_OPEN},
+//* 2005    */  //   {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,FrontDoor4_MIDTANKS,1,true,true,DEBUG_LOG_CATEGORY__Error,  0xFF,5,EVENT_TYPE__FRONT_COVER_4_OPEN},
+//* 2007    */  //  {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,RearDoor           ,1,true,true,DEBUG_LOG_CATEGORY__Error,  0xFF,5,EVENT_TYPE__REAR_COVER_OPEN     },
 
-/*	2006	*/     {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,CartridgesDoor     ,1,true,true,DEBUG_LOG_CATEGORY__Warning,0xFF,5,EVENT_TYPE__CARTRIDGES_COVER_OPEN},
+//* 2006    */     {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,CartridgesDoor     ,1,true,true,DEBUG_LOG_CATEGORY__Warning,0xFF,5,EVENT_TYPE__CARTRIDGES_COVER_OPEN},
 
-/*	6001	*/     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,MIXER_PT100,   HARDWARE_PID_CONTROL_TYPE__MixerHeater        ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__MIXER_UNDERTEMPERATURE_A},
-/*	5006	*/     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1       ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_A},
-/*	5007	*/     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2       ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_A},
-/*	5008	*/     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3       ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_A},
-/*	5009	*/     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4       ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_A},
-/*	5010	*/     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5       ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_A},
-/*	5011	*/     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,HEAD6_PT100, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6       ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_A},
+//* 6001    */     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,MIXER_PT100,   HARDWARE_PID_CONTROL_TYPE__MixerHeater        ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__MIXER_UNDERTEMPERATURE_A},
+//* 5006    */     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1       ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_A},
+//* 5007    */     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2       ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_A},
+//* 5008    */     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3       ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_A},
+//* 5009    */     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4       ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_A},
+//* 5010    */     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5       ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_A},
+//* 5011    */     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,HEAD6_PT100, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6       ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_A},
 
-/*	4007	*/     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1,  HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_A},
-/*	6002	*/     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,MIXER_PT100,   HARDWARE_PID_CONTROL_TYPE__MixerHeater        ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MIXER_UNDERTEMPERATURE_B},
-/*	5012	*/     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_B},
-/*	5013	*/     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_B},
-/*	5014	*/     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_B},
-/*	5015	*/     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_B},
-/*	5016	*/     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_B},
-/*	5017	*/     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,HEAD6_PT100, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_B                   },
-/*	4008	*/     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1,  HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_B      },
+//* 4007    */     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1,  HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_A},
+//* 6002    */     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,MIXER_PT100,   HARDWARE_PID_CONTROL_TYPE__MixerHeater        ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MIXER_UNDERTEMPERATURE_B},
+//* 5012    */     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_B},
+//* 5013    */     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_B},
+//* 5014    */     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_B},
+//* 5015    */     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_B},
+//* 5016    */     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_B},
+//* 5017    */     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,HEAD6_PT100, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_B                   },
+//* 4008    */     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1,  HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_B      },
 
-/*	3004	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RLOADING        , HARDWARE_MOTOR_TYPE__MOTO_RLOADING        , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__RIGHT_LOADER_MOTOR_OVERCURRENT                            },                                           /* 3004 */
-/*	3006	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LLOADING        , HARDWARE_MOTOR_TYPE__MOTO_LLOADING        , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LEFT_LOADER_MOTOR_OVERCURRENT                            },                                           /* 3006 */
-/*	3009	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM   , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM   , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LOADING_ARM_MOTOR_OVERCURRENT                            },                                           /* 3009 */
-/*	3036	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER2        , HARDWARE_MOTOR_TYPE__MOTO_LDANCER2        , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__WINDER_MOTOR_OVERCURRENT /*EVENT_TYPE__WINDER_DANCER_MOTOR_OVERCURRENT*/            },   /* 3036 */
-/*	3037	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER1   , HARDWARE_MOTOR_TYPE__MOTO_LDANCER1   , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__PULLER_MOTOR_OVERCURRENT /*EVENT_TYPE__PULLER_DANCER_MOTOR_OVERCURRENT*/            },   /* 3037 */
-/*	3038	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RDANCER   , HARDWARE_MOTOR_TYPE__MOTO_RDANCER   , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__FEEDER_MOTOR_OVERCURRENT /*EVENT_TYPE__FEEDER_DANCER_MOTOR_OVERCURRENT*/            },   /* 3038 */
-/*	4017	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID       , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID       , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DRYER_MOTOR_OVERCURRENT  /*EVENT_TYPE__DRYER_LID_MOTOR_OVERCURRENT*/                },   /* 4017 */
-/*	5031	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_LID          , HARDWARE_MOTOR_TYPE__MOTO_DH_LID          , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_COVER_MOTOR_OVERCURRENT                    },                                       /* 5031 */
-/*	5035	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH    , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH    , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_MECHANISM_MOTOR_OVERCURRENT       },                                       /* 5035 */
-/*	5039	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD    , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD    , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_HEAD_MOTOR_OVERCURRENT            },                                       /* 5039 */
+//* 3004    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RLOADING        , HARDWARE_MOTOR_TYPE__MOTO_RLOADING        , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__RIGHT_LOADER_MOTOR_OVERCURRENT                            },                                           //* 3004 */
+//* 3006    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LLOADING        , HARDWARE_MOTOR_TYPE__MOTO_LLOADING        , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LEFT_LOADER_MOTOR_OVERCURRENT                            },                                           //* 3006 */
+//* 3009    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM   , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM   , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LOADING_ARM_MOTOR_OVERCURRENT                            },                                           //* 3009 */
+//* 3036    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER2        , HARDWARE_MOTOR_TYPE__MOTO_LDANCER2        , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__WINDER_MOTOR_OVERCURRENT //*EVENT_TYPE__WINDER_DANCER_MOTOR_OVERCURRENT*/            },   //* 3036 */
+//* 3037    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER1   , HARDWARE_MOTOR_TYPE__MOTO_LDANCER1   , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__PULLER_MOTOR_OVERCURRENT //*EVENT_TYPE__PULLER_DANCER_MOTOR_OVERCURRENT*/            },   //* 3037 */
+//* 3038    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RDANCER   , HARDWARE_MOTOR_TYPE__MOTO_RDANCER   , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__FEEDER_MOTOR_OVERCURRENT //*EVENT_TYPE__FEEDER_DANCER_MOTOR_OVERCURRENT*/            },   //* 3038 */
+//* 4017    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID       , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID       , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DRYER_MOTOR_OVERCURRENT  //*EVENT_TYPE__DRYER_LID_MOTOR_OVERCURRENT*/                },   //* 4017 */
+//* 5031    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_LID          , HARDWARE_MOTOR_TYPE__MOTO_DH_LID          , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_COVER_MOTOR_OVERCURRENT                    },                                       //* 5031 */
+//* 5035    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH    , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH    , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_MECHANISM_MOTOR_OVERCURRENT       },                                       //* 5035 */
+//* 5039    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD    , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD    , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_HEAD_MOTOR_OVERCURRENT            },                                       //* 5039 */
 
-/*	3011	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RLOADING        , HARDWARE_MOTOR_TYPE__MOTO_RLOADING        , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__RIGHT_LOADER_MOTOR_OVERTEMPERATURE                     },                                           /* 3011 */
-/*	3013	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LLOADING        , HARDWARE_MOTOR_TYPE__MOTO_LLOADING        , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LEFT_LOADER_MOTOR_OVERTEMPERATURE                      },                                           /* 3013 */
-/*	3016	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM   , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM   , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LOADING_ARM_MOTOR_OVERTEMPERATURE                      },                                           /* 3016 */
-/*	3039	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER2        , HARDWARE_MOTOR_TYPE__MOTO_LDANCER2        , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__WINDER_DANCER_MOTOR_OVERTEMPERATURE                    },                                           /* 3039 */
-/*	3040	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER1   , HARDWARE_MOTOR_TYPE__MOTO_LDANCER1   , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__PULLER_DANCER_MOTOR_OVERTEMPERATURE                                },                                           /* 3040 */
-/*	3041	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RDANCER   , HARDWARE_MOTOR_TYPE__MOTO_RDANCER   , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__FEEDER_DANCER_MOTOR_OVERTEMPERATURE                   },                                           /* 3041 */
-/*	4018	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID       , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID       , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DRYER_LID_MOTOR_OVERTEMPERATURE                       },                                           /* 4018 */
-/*	5032	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_LID          , HARDWARE_MOTOR_TYPE__MOTO_DH_LID          , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_COVER_MOTOR_OVERTEMPERATURE          },                                           /* 5032 */
-/*	5036	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH    , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH    , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_MECHANISM_MOTOR_OVERTEMPERATURE  },                                           /* 5036 */
-/*	5040	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD    , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD    , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_HEAD_MOTOR_OVERTEMPERATURE       },                                           /* 5040 */
+//* 3011    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RLOADING        , HARDWARE_MOTOR_TYPE__MOTO_RLOADING        , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__RIGHT_LOADER_MOTOR_OVERTEMPERATURE                     },                                           //* 3011 */
+//* 3013    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LLOADING        , HARDWARE_MOTOR_TYPE__MOTO_LLOADING        , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LEFT_LOADER_MOTOR_OVERTEMPERATURE                      },                                           //* 3013 */
+//* 3016    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM   , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM   , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LOADING_ARM_MOTOR_OVERTEMPERATURE                      },                                           //* 3016 */
+//* 3039    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER2        , HARDWARE_MOTOR_TYPE__MOTO_LDANCER2        , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__WINDER_DANCER_MOTOR_OVERTEMPERATURE                    },                                           //* 3039 */
+//* 3040    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER1   , HARDWARE_MOTOR_TYPE__MOTO_LDANCER1   , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__PULLER_DANCER_MOTOR_OVERTEMPERATURE                                },                                           //* 3040 */
+//* 3041    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RDANCER   , HARDWARE_MOTOR_TYPE__MOTO_RDANCER   , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__FEEDER_DANCER_MOTOR_OVERTEMPERATURE                   },                                           //* 3041 */
+//* 4018    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID       , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID       , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DRYER_LID_MOTOR_OVERTEMPERATURE                       },                                           //* 4018 */
+//* 5032    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_LID          , HARDWARE_MOTOR_TYPE__MOTO_DH_LID          , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_COVER_MOTOR_OVERTEMPERATURE          },                                           //* 5032 */
+//* 5036    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH    , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH    , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_MECHANISM_MOTOR_OVERTEMPERATURE  },                                           //* 5036 */
+//* 5040    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD    , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD    , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_HEAD_MOTOR_OVERTEMPERATURE       },                                           //* 5040 */
 
-/*	3018	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RLOADING        , HARDWARE_MOTOR_TYPE__MOTO_RLOADING         ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LOADING_ARM_MOTOR_STALL                             },                                           /* 3018 */
-/*	3020	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LLOADING        , HARDWARE_MOTOR_TYPE__MOTO_LLOADING         ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__WINDER_DANCER_MOTOR_STALL                              },                                           /* 3020 */
-/*	3023	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM   , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM    ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LOADING_ARM_MOTOR_STALL                             },                                           /* 3023 */
-/*	3042	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER2        , HARDWARE_MOTOR_TYPE__MOTO_LDANCER2         ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__WINDER_DANCER_MOTOR_STALL                              },                                           /* 3042 */
-/*	3043	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER1   , HARDWARE_MOTOR_TYPE__MOTO_LDANCER1    ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__PULLER_DANCER_MOTOR_STALL                                       },                                           /* 3043 */
-/*	3044	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RDANCER   , HARDWARE_MOTOR_TYPE__MOTO_RDANCER    ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__FEEDER_DANCER_MOTOR_STALL                                        },                                           /* 3044 */
-/*	4019	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID       , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID        ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DRYER_LID_MOTOR_STALL                                  },                                           /* 4019 */
-/*	5033	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_LID          , HARDWARE_MOTOR_TYPE__MOTO_DH_LID           ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_COVER_MOTOR_STALL                         },                                           /* 5033 */
-/*	5037	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH    , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH     ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_MECHANISM_MOTOR_STALL            },                                           /* 5037 */
-/*	5041	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD    , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD     ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_HEAD_MOTOR_STALL                 },                                           /* 5041 */
+//* 3018    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RLOADING        , HARDWARE_MOTOR_TYPE__MOTO_RLOADING         ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LOADING_ARM_MOTOR_STALL                             },                                           //* 3018 */
+//* 3020    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LLOADING        , HARDWARE_MOTOR_TYPE__MOTO_LLOADING         ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__WINDER_DANCER_MOTOR_STALL                              },                                           //* 3020 */
+//* 3023    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM   , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM    ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LOADING_ARM_MOTOR_STALL                             },                                           //* 3023 */
+//* 3042    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER2        , HARDWARE_MOTOR_TYPE__MOTO_LDANCER2         ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__WINDER_DANCER_MOTOR_STALL                              },                                           //* 3042 */
+//* 3043    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER1   , HARDWARE_MOTOR_TYPE__MOTO_LDANCER1    ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__PULLER_DANCER_MOTOR_STALL                                       },                                           //* 3043 */
+//* 3044    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RDANCER   , HARDWARE_MOTOR_TYPE__MOTO_RDANCER    ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__FEEDER_DANCER_MOTOR_STALL                                        },                                           //* 3044 */
+//* 4019    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID       , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID        ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DRYER_LID_MOTOR_STALL                                  },                                           //* 4019 */
+//* 5033    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_LID          , HARDWARE_MOTOR_TYPE__MOTO_DH_LID           ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_COVER_MOTOR_STALL                         },                                           //* 5033 */
+//* 5037    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH    , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH     ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_MECHANISM_MOTOR_STALL            },                                           //* 5037 */
+//* 5041    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD    , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD     ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_HEAD_MOTOR_STALL                 },                                           //* 5041 */
 
-/*	3025	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RLOADING        , HARDWARE_MOTOR_TYPE__MOTO_RLOADING        , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__RIGHT_LOADER_MOTOR_UNDERVOLTAGE                         },                                           /* 3025 */
-/*	3027	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LLOADING        , HARDWARE_MOTOR_TYPE__MOTO_LLOADING        , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LEFT_LOADER_MOTOR_UNDERVOLTAGE                          },                                           /* 3027 */
-/*	3030	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM   , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM   , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LOADING_ARM_MOTOR_UNDERVOLTAGE                         },                                           /* 3030 */
-/*	3045	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER2        , HARDWARE_MOTOR_TYPE__MOTO_LDANCER2        , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__WINDER_DANCER_MOTOR_UNDERVOLTAGE                      },                                           /* 3045 */
-/*	3046	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER1   , HARDWARE_MOTOR_TYPE__MOTO_LDANCER1   , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__PULLER_DANCER_MOTOR_UNDERVOLTAGE                                },                                           /* 3046 */
-/*	3047	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RDANCER   , HARDWARE_MOTOR_TYPE__MOTO_RDANCER   , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__FEEDER_DANCER_MOTOR_UNDERVOLTAGE                                    },                                           /* 3047 */
-/*	4020	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID       , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID       , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DRYER_LID_MOTOR_UNDERVOLTAGE                           },                                           /* 4020 */
-/*	5034	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_LID          , HARDWARE_MOTOR_TYPE__MOTO_DH_LID          , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_COVER_MOTOR_UNDERVOLTAGE                  },                                           /* 5034 */
-/*	5038	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH    , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH    , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_MECHANISM_MOTOR_UNDERVOLTAGE         },                                           /* 5038 */
-/*	5042	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD    , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD    , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_HEAD_MOTOR_UNDERVOLTAGE             },                                           /* 5042 */
+//* 3025    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RLOADING        , HARDWARE_MOTOR_TYPE__MOTO_RLOADING        , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__RIGHT_LOADER_MOTOR_UNDERVOLTAGE                         },                                           //* 3025 */
+//* 3027    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LLOADING        , HARDWARE_MOTOR_TYPE__MOTO_LLOADING        , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LEFT_LOADER_MOTOR_UNDERVOLTAGE                          },                                           //* 3027 */
+//* 3030    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM   , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM   , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LOADING_ARM_MOTOR_UNDERVOLTAGE                         },                                           //* 3030 */
+//* 3045    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER2        , HARDWARE_MOTOR_TYPE__MOTO_LDANCER2        , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__WINDER_DANCER_MOTOR_UNDERVOLTAGE                      },                                           //* 3045 */
+//* 3046    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER1   , HARDWARE_MOTOR_TYPE__MOTO_LDANCER1   , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__PULLER_DANCER_MOTOR_UNDERVOLTAGE                                },                                           //* 3046 */
+//* 3047    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RDANCER   , HARDWARE_MOTOR_TYPE__MOTO_RDANCER   , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__FEEDER_DANCER_MOTOR_UNDERVOLTAGE                                    },                                           //* 3047 */
+//* 4020    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID       , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID       , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DRYER_LID_MOTOR_UNDERVOLTAGE                           },                                           //* 4020 */
+//* 5034    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_LID          , HARDWARE_MOTOR_TYPE__MOTO_DH_LID          , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_COVER_MOTOR_UNDERVOLTAGE                  },                                           //* 5034 */
+//* 5038    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH    , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH    , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_MECHANISM_MOTOR_UNDERVOLTAGE         },                                           //* 5038 */
+//* 5042    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD    , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD    , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_HEAD_MOTOR_UNDERVOLTAGE             },                                           //* 5042 */
 
-/*	5018	*/     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_1  , HEATER_HEAD_CURRENT_ZONE_1  , 125         , TRUE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DYEING_HEAD_ZONE_1_CURRENT_OUT_OF_RANGE              },                                           /* 5018 */
-/*	5019	*/     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_2    , HEATER_HEAD_CURRENT_ZONE_2    , 187         , TRUE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DYEING_HEAD_ZONE_2_CURRENT_OUT_OF_RANGE          },                                           /* 5019 */
-/*	5020	*/     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_3    , HEATER_HEAD_CURRENT_ZONE_3    , 187         , TRUE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DYEING_HEAD_ZONE_3_CURRENT_OUT_OF_RANGE          },                                           /* 5020 */
-/*	5021	*/     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_4    , HEATER_HEAD_CURRENT_ZONE_4    , 312         , TRUE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DYEING_HEAD_ZONE_4_CURRENT_OUT_OF_RANGE          },                                           /* 5021 */
-/*	5022	*/     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_5_6    , HEATER_HEAD_CURRENT_ZONE_5_6    , 500         , TRUE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DYEING_HEAD_ZONE_5_6_CURRENT_OUT_OF_RANGE       },                                           /* 5022 */
-/*	6004	*/     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_MIXCHIP_CURRENT        , HEATER_MIXCHIP_CURRENT        , 187         , TRUE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__MIXER_CURRENT_OUT_OF_RANGE                       },                                       /* 6004 */
-/*	4011	*/     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_DRYER_CURRENT_1, HEATER_DRYER_CURRENT_1, CURRENT4AMP         , TRUE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DRYER_HEATERS_ZONE_1_CURRENT_OUT_OF_RANGE           },                                           /* 6004 */
-/*	4012	*/     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_DRYER_CURRENT_2, HEATER_DRYER_CURRENT_2, CURRENT2AMP         , TRUE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DRYER_HEATERS_ZONE_2_CURRENT_OUT_OF_RANGE           },                                           /* 6004 */
+//* 5018    */     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_1  , HEATER_HEAD_CURRENT_ZONE_1  , 125         , TRUE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DYEING_HEAD_ZONE_1_CURRENT_OUT_OF_RANGE              },                                           //* 5018 */
+//* 5019    */     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_2    , HEATER_HEAD_CURRENT_ZONE_2    , 187         , TRUE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DYEING_HEAD_ZONE_2_CURRENT_OUT_OF_RANGE          },                                           //* 5019 */
+//* 5020    */     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_3    , HEATER_HEAD_CURRENT_ZONE_3    , 187         , TRUE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DYEING_HEAD_ZONE_3_CURRENT_OUT_OF_RANGE          },                                           //* 5020 */
+//* 5021    */     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_4    , HEATER_HEAD_CURRENT_ZONE_4    , 312         , TRUE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DYEING_HEAD_ZONE_4_CURRENT_OUT_OF_RANGE          },                                           //* 5021 */
+//* 5022    */     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_5_6    , HEATER_HEAD_CURRENT_ZONE_5_6    , 500         , TRUE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DYEING_HEAD_ZONE_5_6_CURRENT_OUT_OF_RANGE       },                                           //* 5022 */
+//* 6004    */     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_MIXCHIP_CURRENT        , HEATER_MIXCHIP_CURRENT        , 187         , TRUE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__MIXER_CURRENT_OUT_OF_RANGE                       },                                       //* 6004 */
+//* 4011    */     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_DRYER_CURRENT_1, HEATER_DRYER_CURRENT_1, CURRENT4AMP         , TRUE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DRYER_HEATERS_ZONE_1_CURRENT_OUT_OF_RANGE           },                                           //* 6004 */
+//* 4012    */     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_DRYER_CURRENT_2, HEATER_DRYER_CURRENT_2, CURRENT2AMP         , TRUE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DRYER_HEATERS_ZONE_2_CURRENT_OUT_OF_RANGE           },                                           //* 6004 */
 
-/*	5023	*/     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_1  , HEATER_HEAD_CURRENT_ZONE_1  , 0         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DYEING_HEAD_ZONE_1_CURRENT_LOOP_BREAK              },                                           /* 5018 */
-/*	5024	*/     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_2    , HEATER_HEAD_CURRENT_ZONE_2    , 0         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DYEING_HEAD_ZONE_2_CURRENT_LOOP_BREAK           },                                           /* 5019 */
-/*	5025	*/     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_3    , HEATER_HEAD_CURRENT_ZONE_3    , 0         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DYEING_HEAD_ZONE_3_CURRENT_LOOP_BREAK           },                                           /* 5020 */
-/*	5026	*/     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_4    , HEATER_HEAD_CURRENT_ZONE_4    , 0         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DYEING_HEAD_ZONE_4_CURRENT_LOOP_BREAK           },                                           /* 5021 */
-/*	5027	*/     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_5_6    , HEATER_HEAD_CURRENT_ZONE_5_6    , 0         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DYEING_HEAD_ZONE_5_6_CURRENT_LOOP_BREAK       },                                           /* 5022 */
-/*	6005	*/     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_MIXCHIP_CURRENT        , HEATER_MIXCHIP_CURRENT        , 0         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__MIXER_CURRENT_LOOP_BREAK                       },                                        /* 6004 */
-/*	4013	*/     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_DRYER_CURRENT_1, HEATER_DRYER_CURRENT_1, 0         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DRYER_HEATERS_ZONE_1_CURRENT_LOOP_BREAK          },                                           /* 6004 */
-/*	4014	*/     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_DRYER_CURRENT_2, HEATER_DRYER_CURRENT_2, 0         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DRYER_HEATERS_ZONE_2_CURRENT_LOOP_BREAK          },                                           /* 6004 */
-/*	5028	*/     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DYEING_HEAD_THERMAL_CUTOFF},
+//* 5023    */     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_1  , HEATER_HEAD_CURRENT_ZONE_1  , 0         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DYEING_HEAD_ZONE_1_CURRENT_LOOP_BREAK              },                                           //* 5018 */
+//* 5024    */     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_2    , HEATER_HEAD_CURRENT_ZONE_2    , 0         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DYEING_HEAD_ZONE_2_CURRENT_LOOP_BREAK           },                                           //* 5019 */
+//* 5025    */     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_3    , HEATER_HEAD_CURRENT_ZONE_3    , 0         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DYEING_HEAD_ZONE_3_CURRENT_LOOP_BREAK           },                                           //* 5020 */
+//* 5026    */     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_4    , HEATER_HEAD_CURRENT_ZONE_4    , 0         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DYEING_HEAD_ZONE_4_CURRENT_LOOP_BREAK           },                                           //* 5021 */
+//* 5027    */     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_5_6    , HEATER_HEAD_CURRENT_ZONE_5_6    , 0         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DYEING_HEAD_ZONE_5_6_CURRENT_LOOP_BREAK       },                                           //* 5022 */
+//* 6005    */     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_MIXCHIP_CURRENT        , HEATER_MIXCHIP_CURRENT        , 0         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__MIXER_CURRENT_LOOP_BREAK                       },                                        //* 6004 */
+//* 4013    */     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_DRYER_CURRENT_1, HEATER_DRYER_CURRENT_1, 0         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DRYER_HEATERS_ZONE_1_CURRENT_LOOP_BREAK          },                                           //* 6004 */
+//* 4014    */     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_DRYER_CURRENT_2, HEATER_DRYER_CURRENT_2, 0         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DRYER_HEATERS_ZONE_2_CURRENT_LOOP_BREAK          },                                           //* 6004 */
+//* 5028    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DYEING_HEAD_THERMAL_CUTOFF},
 
-/*	9005	*/     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__VOC_SENSOR_ALARM_TIME},
-/*	9008	*/     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__VOC_SENSOR_ALARM_SLOPE},
+//* 9005    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__VOC_SENSOR_ALARM_TIME},
+//* 9008    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__VOC_SENSOR_ALARM_SLOPE},
 
-/*	3000	*/     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__THREAD_BREAK},
-/*	3001	*/     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_FEEDER_DANCER},
-/*	3048	*/     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_PULLER_DANCER},
-/*	3049	*/     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_WINDER_DANCER},
-/*	3002	*/     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__WINDER_CONE_DOES_NOT_EXIST},
+//* 3000    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__THREAD_BREAK},
+//* 3001    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_FEEDER_DANCER},
+//* 3048    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_PULLER_DANCER},
+//* 3049    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_WINDER_DANCER},
+//* 3002    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__WINDER_CONE_DOES_NOT_EXIST},
 
-/*	4004	*/     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DRYER_DOOR_OPEN},
-/*	9003	*/     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__NO_AIR_PRESSURE},
-/*	9000	*/     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__AIR_FILTER_NOT_INSTALLED},
-/*	9002	*/     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__WASTE_CONTAINER_EMPTYING_TIMEOUT},
+//* 4004    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DRYER_DOOR_OPEN},
+//* 9003    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__NO_AIR_PRESSURE},
+//* 9000    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__AIR_FILTER_NOT_INSTALLED},
+//* 9002    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__WASTE_CONTAINER_EMPTYING_TIMEOUT},
 
-/*	2014	*/     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MACHINE_STATE_HW_CONFIG_FAILED},
+//* 2014    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MACHINE_STATE_HW_CONFIG_FAILED},
 
-/*	2009	*/     {eOneSecond, ALARM_SOURCE_TYPE__TachoAlarm, MACHINE_FANS           , MACHINE_FANS           , MACHINE_FANS_MIN_RPM           , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF, 5, EVENT_TYPE__MACHINE_FANS_RPM_TOO_LOW            }, /*2009*/
-/*	2010	*/     {eOneSecond, ALARM_SOURCE_TYPE__TachoAlarm, MACHINE_FANS           , MACHINE_FANS           , MACHINE_FANS_STOP              , FALSE , DEBUG_LOG_CATEGORY__Critical, 0xFF, 5, EVENT_TYPE__MACHINE_FANS_STOPPED                }, /*2010*/
-/*	2011	*/     {eOneSecond, ALARM_SOURCE_TYPE__TachoAlarm, ELECTRICAL_CABINET_FANS, ELECTRICAL_CABINET_FANS, ELECTRICAL_CABINET_FANS_MIN_RPM, FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF, 5, EVENT_TYPE__ELECTRICAL_CABINET_FANS_RPM_TOO_LOW }, /*2011*/
-/*	2012	*/     {eOneSecond, ALARM_SOURCE_TYPE__TachoAlarm, ELECTRICAL_CABINET_FANS, ELECTRICAL_CABINET_FANS, ELECTRICAL_CABINET_FANS_STOP   , FALSE , DEBUG_LOG_CATEGORY__Critical, 0xFF, 5, EVENT_TYPE__ELECTRICAL_CABINET_FANS_STOPPED     }, /*2012*/
-/*	4015	*/     {eOneSecond, ALARM_SOURCE_TYPE__TachoAlarm, DRYER_FAN              , DRYER_FAN              , DRYER_FAN_MIN_RPM              , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF, 5, EVENT_TYPE__DRYER_FAN_RPM_TOO_LOW               }, /*4015*/
-/*	4016	*/     {eOneSecond, ALARM_SOURCE_TYPE__TachoAlarm, DRYER_FAN              , DRYER_FAN              , DRYER_FAN_STOP                 , FALSE , DEBUG_LOG_CATEGORY__Critical, 0xFF, 5, EVENT_TYPE__DRYER_FAN_STOPPED                   }, /*4016*/
+//* 2009    */     {eOneSecond, ALARM_SOURCE_TYPE__TachoAlarm, MACHINE_FANS           , MACHINE_FANS           , MACHINE_FANS_MIN_RPM           , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF, 5, EVENT_TYPE__MACHINE_FANS_RPM_TOO_LOW            }, //*2009*/
+//* 2010    */     {eOneSecond, ALARM_SOURCE_TYPE__TachoAlarm, MACHINE_FANS           , MACHINE_FANS           , MACHINE_FANS_STOP              , FALSE , DEBUG_LOG_CATEGORY__Critical, 0xFF, 5, EVENT_TYPE__MACHINE_FANS_STOPPED                }, //*2010*/
+//* 2011    */     {eOneSecond, ALARM_SOURCE_TYPE__TachoAlarm, ELECTRICAL_CABINET_FANS, ELECTRICAL_CABINET_FANS, ELECTRICAL_CABINET_FANS_MIN_RPM, FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF, 5, EVENT_TYPE__ELECTRICAL_CABINET_FANS_RPM_TOO_LOW }, //*2011*/
+//* 2012    */     {eOneSecond, ALARM_SOURCE_TYPE__TachoAlarm, ELECTRICAL_CABINET_FANS, ELECTRICAL_CABINET_FANS, ELECTRICAL_CABINET_FANS_STOP   , FALSE , DEBUG_LOG_CATEGORY__Critical, 0xFF, 5, EVENT_TYPE__ELECTRICAL_CABINET_FANS_STOPPED     }, //*2012*/
+//* 4015    */     {eOneSecond, ALARM_SOURCE_TYPE__TachoAlarm, DRYER_FAN              , DRYER_FAN              , DRYER_FAN_MIN_RPM              , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF, 5, EVENT_TYPE__DRYER_FAN_RPM_TOO_LOW               }, //*4015*/
+//* 4016    */     {eOneSecond, ALARM_SOURCE_TYPE__TachoAlarm, DRYER_FAN              , DRYER_FAN              , DRYER_FAN_STOP                 , FALSE , DEBUG_LOG_CATEGORY__Critical, 0xFF, 5, EVENT_TYPE__DRYER_FAN_STOPPED                   }, //*4016*/
 
-/*  8024    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MID_TANK_1_FILL_TIMEOUT},
-/*  8025    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MID_TANK_2_FILL_TIMEOUT},
-/*  8026    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MID_TANK_3_FILL_TIMEOUT},
-/*  8027    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MID_TANK_4_FILL_TIMEOUT},
-/*  8028    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MID_TANK_5_FILL_TIMEOUT},
-/*  8029    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MID_TANK_6_FILL_TIMEOUT},
-/*  8030    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MID_TANK_7_FILL_TIMEOUT},
-/*  8031    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MID_TANK_8_FILL_TIMEOUT},
+//*  8024    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MID_TANK_1_FILL_TIMEOUT},
+//*  8025    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MID_TANK_2_FILL_TIMEOUT},
+//*  8026    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MID_TANK_3_FILL_TIMEOUT},
+//*  8027    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MID_TANK_4_FILL_TIMEOUT},
+//*  8028    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MID_TANK_5_FILL_TIMEOUT},
+//*  8029    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MID_TANK_6_FILL_TIMEOUT},
+//*  8030    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MID_TANK_7_FILL_TIMEOUT},
+//*  8031    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MID_TANK_8_FILL_TIMEOUT},
 
-/*  10002    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__NO_WASTE_CARTRIDGE_AVAILABLE},
-/*  10003    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__ALL_WASTE_CARTRIDGES_FULL}
+//*  10002    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__NO_WASTE_CARTRIDGE_AVAILABLE},
+//*  10003    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__ALL_WASTE_CARTRIDGES_FULL}
 
 };
 
@@ -578,7 +578,6 @@ JobEndReasonEnum getEndReason(uint32_t AlarmId)
         case ALARM_SOURCE_TYPE__HardLimitAlarm:
             usnprintf(AlarmReasonStr, 100, "Dispenser %d hit the hard limit",AlarmItem[AlarmId].DeviceId);
             return JOB_LS_ALARM;
-            break;
         case ALARM_SOURCE_TYPE__DoNotPollAlarm:
             if (AlarmItem[AlarmId].Severity == DEBUG_LOG_CATEGORY__Critical)
             {
@@ -736,12 +735,12 @@ uint32_t AlarmHandlingConsequentActions(uint32_t AlarmId, DebugLogCategory Sever
 JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob)
 {
     //JobTicket* JobTicket = CurrentJob;
-    EventType HeaterEventType[MAX_HEATERS_NUM*2] = {EVENT_TYPE__DRYER_ZONE_1_OVERTEMPERATURE,EVENT_TYPE__DRYER_ZONE_2_OVERTEMPERATURE,EVENT_TYPE__DRYER_ZONE_1_OVERTEMPERATURE,EVENT_TYPE__DYEING_HEAD_ZONE_1_OVERTEMPERATURE,EVENT_TYPE__DYEING_HEAD_ZONE_2_OVERTEMPERATURE,
+    /*EventType HeaterEventType[HEATER_TYPE_MAX_HEATERS] = {EVENT_TYPE__DRYER_ZONE_1_OVERTEMPERATURE,EVENT_TYPE__DRYER_ZONE_2_OVERTEMPERATURE,EVENT_TYPE__DRYER_ZONE_1_OVERTEMPERATURE,EVENT_TYPE__DYEING_HEAD_ZONE_1_OVERTEMPERATURE,EVENT_TYPE__DYEING_HEAD_ZONE_2_OVERTEMPERATURE,
                                                   EVENT_TYPE__DYEING_HEAD_ZONE_3_OVERTEMPERATURE,EVENT_TYPE__DYEING_HEAD_ZONE_4_OVERTEMPERATURE,EVENT_TYPE__DYEING_HEAD_ZONE_5_OVERTEMPERATURE,EVENT_TYPE__DYEING_HEAD_ZONE_6_OVERTEMPERATURE,
                                                   EVENT_TYPE__MIXER_OVERTEMPERATURE};
-    EventType HeaterEventTypeUnder[MAX_HEATERS_NUM*2] = {EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_B,EVENT_TYPE__DRYER_ZONE_2_UNDERTEMPERATURE_B,EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_B,EVENT_TYPE__DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_B,EVENT_TYPE__DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_B,
+    EventType HeaterEventTypeUnder[HEATER_TYPE_MAX_HEATERS] = {EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_B,EVENT_TYPE__DRYER_ZONE_2_UNDERTEMPERATURE_B,EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_B,EVENT_TYPE__DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_B,EVENT_TYPE__DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_B,
                                                   EVENT_TYPE__DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_B,EVENT_TYPE__DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_B,EVENT_TYPE__DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_B,EVENT_TYPE__DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_B,
-                                                  EVENT_TYPE__MIXER_UNDERTEMPERATURE_B};
+                                                  EVENT_TYPE__MIXER_UNDERTEMPERATURE_B};*/
     int Dispenser_i,Alarm_i,Heater_i,AlarmId=0;
     HeaterState HeaterState;
 
@@ -841,7 +840,12 @@ JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob)
     {
         if (HeaterCheckReady()==false)
         {
-            for (Heater_i = 0;Heater_i<MAX_HEATERS_NUM;Heater_i++)
+#warning fit to new head with new alarms
+#ifdef Use_Head_Card
+            for (Heater_i=HEATER_TYPE__DryerAirHeater;Heater_i<HEATER_TYPE_MAX_HEATERS;Heater_i++)
+#else
+            for (Heater_i=HEATER_TYPE__DryerAirHeater;Heater_i<MAX_HEATERS_NUM;Heater_i++)
+#endif
             {
                 LoadHeaterState((HeaterType)Heater_i,&HeaterState);
                 if (HeaterState.setpoint)//temperature is set - heater active
@@ -858,7 +862,7 @@ JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob)
                                 break;
                             }
                         }
-                        if (AlarmItem[Alarm_i].EventType == HeaterEventTypeUnder[Heater_i])
+                        if (AlarmItem[Alarm_i].EventType == HeaterUnderEventType_B[Heater_i])
                         {
                             if (AlarmState[Alarm_i].Status == true)
                             {
diff --git a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
index 2f4a1e2d2..48a28ffe4 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
+++ b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
@@ -50,7 +50,6 @@
 #include "drivers/Flash_Memory/fatfs/ff.h"
 #include "drivers/Flash_ram/FlashProgram.h"
 
-#include "third_party/fatfs/src/ffconf.h"
 #include "Common/SWUpdate/FileSystem.h"
 
 #include "Communication/Connection.h"
@@ -521,9 +520,45 @@ int MillisecCalculateTemperatures (TEMPERATURE_SENSOR_ID_ENUM SensorId)
 }
 int MillisecGetTemperatures (TEMPERATURE_SENSOR_ID_ENUM SensorId)
 {
+    if (SensorId > WHS_PT100_4_0X82_1)
+        return 0;
     return TemperatureCalc[SensorId];
 }
 bool RapidPressureRead = false;
+float PressureSum[MAX_SYSTEM_DISPENSERS];
+float PressureMin[MAX_SYSTEM_DISPENSERS];
+float PressureMax[MAX_SYSTEM_DISPENSERS];
+float PressureCount[MAX_SYSTEM_DISPENSERS];
+float PressureCalc[MAX_SYSTEM_DISPENSERS];
+void MillisecUpdatePressures (int SensorId,float Pressure)
+{
+   //if(PressureCount[SensorId]++>=10)
+   //    PressureCount[SensorId] = 0;
+    PressureCount[SensorId]++;
+    if (PressureMax[SensorId]<Pressure) PressureMax[SensorId]=Pressure;
+    if (PressureMin[SensorId]>Pressure) PressureMin[SensorId]=Pressure;
+    PressureSum[SensorId]+=Pressure;
+}
+float MillisecCalculatePressures (int SensorId)
+{
+    float calc = 0;
+    PressureSum[SensorId]-=PressureMax[SensorId];
+    PressureSum[SensorId]-=PressureMin[SensorId];
+    calc = PressureSum[SensorId] / (PressureCount[SensorId]-2);
+
+    PressureSum[SensorId] = 0;
+    PressureCount[SensorId] = 0;
+    PressureMin[SensorId] = 30000;
+    PressureMax[SensorId] = -30000;
+    return calc;
+}
+float MillisecGetPressures (int SensorId)
+{
+    if (SensorId > MAX_SYSTEM_DISPENSERS)
+        return 0;
+    return PressureCalc[SensorId];
+}
+
 void setRapidPressureRead(bool value)
 {
     RapidPressureRead = value;
@@ -532,18 +567,26 @@ void setRapidPressureRead(bool value)
 uint16_t PumpCounter = 0;
 uint32_t MillisecLowLoop(uint32_t tick)
 {
-    uint8_t Motor_i,Disp_i,Heater_i,temp;
+    uint8_t Motor_i,Disp_i,temp;
     TEMPERATURE_SENSOR_ID_ENUM Sensor_i;
 
     //static int temp=0;
     //call all modules Millisec functions
     //test dancers and speed encoders
     //check all callback units (state machine waiting for completion of a change)
-    bool Ten_msTick, Hundred_msTick , m90msecTick, Onesecond_Tick,O900Millisecond_Tick,OneMinute_Tick,OneHourTick;
+    bool Ten_msTick, Hundred_msTick , m90msecTick, Onesecond_Tick,OneMinute_Tick,OneHourTick;
+    bool O100Millisecond_Tick,O200Millisecond_Tick,O400Millisecond_Tick,O500Millisecond_Tick,O600Millisecond_Tick;
+    //bool O100Millisecond_Tick,O200Millisecond_Tick,O400Millisecond_Tick,O500Millisecond_Tick,O600Millisecond_Tick,O800Millisecond_Tick,O900Millisecond_Tick;
     Ten_msTick      =   (tick%eTenMillisecond == 0)      ?true:false;
     Hundred_msTick  =   (tick%eHundredMillisecond == 0)  ?true:false;
     m90msecTick  =   (tick%eHundredMillisecond == 90)  ?true:false;
-    O900Millisecond_Tick  =   (tick%eOneSecond == 900)           ?true:false;
+    O100Millisecond_Tick  =   (tick%eOneSecond == 100)           ?true:false;
+    O200Millisecond_Tick  =   (tick%eOneSecond == 200)           ?true:false;
+    O400Millisecond_Tick  =   (tick%eOneSecond == 400)           ?true:false;
+    O500Millisecond_Tick  =   (tick%eOneSecond == 500)           ?true:false;
+    O600Millisecond_Tick  =   (tick%eOneSecond == 600)           ?true:false;
+    //O800Millisecond_Tick  =   (tick%eOneSecond == 800)           ?true:false;
+    //O900Millisecond_Tick  =   (tick%eOneSecond == 900)           ?true:false;
     Onesecond_Tick  =   (tick%eOneSecond == 0)           ?true:false;
     OneMinute_Tick  =   (tick%eOneMinute == 0)           ?true:false;
     OneHourTick  =   (tick%eOneHour == 0)           ?true:false;
@@ -562,7 +605,11 @@ uint32_t MillisecLowLoop(uint32_t tick)
     }
     if (m90msecTick)
     {
+#ifdef Use_Head_Card
+        for (Sensor_i = TEMP_SENSE_ANALOG_DRYER_TEMP1;Sensor_i < MAX_MAIN_CARD_TEMP_SENS_ID;Sensor_i++)
+#else
         for (Sensor_i = 0;Sensor_i < MAX_MAIN_CARD_TEMP_SENS_ID;Sensor_i++)
+#endif
         {
             MillisecReadFromTempSensor(Sensor_i, NULL);
         }
@@ -572,7 +619,11 @@ uint32_t MillisecLowLoop(uint32_t tick)
         Speed_Data = Calculate_Speed_Sensor_Velocity();
         Read_Buttons_Reg();
         //Ink_Cart_Led();
+#ifdef Use_Head_Card
+        for (Sensor_i = TEMP_SENSE_ANALOG_DRYER_TEMP1;Sensor_i < MAX_MAIN_CARD_TEMP_SENS_ID;Sensor_i++)
+#else
         for (Sensor_i = 0;Sensor_i < MAX_MAIN_CARD_TEMP_SENS_ID;Sensor_i++)
+#endif
         {
             MillisecUpdateTemperatures (Sensor_i,TemperatureSensorRead(Sensor_i));
         }
@@ -588,33 +639,26 @@ uint32_t MillisecLowLoop(uint32_t tick)
         {
             for (Disp_i = 0;Disp_i < MAX_SYSTEM_DISPENSERS;Disp_i++)
             {
-                CalculateDispenserPressure(Disp_i);
+                MillisecUpdatePressures(Disp_i, CalculateDispenserPressure(Disp_i));
             }
             ADC_TriggerCollection();
         }
         DispensersCollectionCall();
 
     }
-
-    if ((O900Millisecond_Tick)&&(RapidPressureRead == false))
+    if (O100Millisecond_Tick)
     {
-        ADC_TriggerCollection();
+        Trigger_Heater_Current_Read();
     }
-    if (Onesecond_Tick)
+    if (O200Millisecond_Tick)
     {
-        if (RapidPressureRead == false)
-        {
-            for (Disp_i = 0;Disp_i < MAX_SYSTEM_DISPENSERS;Disp_i++)
-            {
-                CalculateDispenserPressure(Disp_i);
-            }
-        }
         FPGA_GetAllDispensersValveBusyOCD();
         temp = Read_Fans_Tacho();
         DrawerFansStatus = temp & 0x1F;
         SystemFansStatus = temp & 0xE0;
-        MachineUpdateResponseFunc();
-        //KeepAliveOneSecondCall();
+    }
+    if (O400Millisecond_Tick)
+    {
         for (Motor_i = 0;Motor_i < NUM_OF_MOTORS;Motor_i++)
         {
             if (Motor_i == HARDWARE_MOTOR_TYPE__MOTO_SCREW)
@@ -622,18 +666,40 @@ uint32_t MillisecLowLoop(uint32_t tick)
             if (isMotorConfigured(Motor_i))
                 MotorGetStatusFromFPGA(Motor_i);
         }
-        if (!(OneMinute_Tick))
+    }
+    if ((O500Millisecond_Tick)&&(RapidPressureRead == false))
+    {
+        ADC_TriggerCollection();
+    }
+    if (O600Millisecond_Tick)
+    {
+        if (RapidPressureRead == false)
         {
-            Trigger_Heater_Current_Read();
-            /*for (Heater_i = 0;Heater_i < NUM_OF_CURRENT_HEATERS;Heater_i++)
+            for (Disp_i = 0;Disp_i < MAX_SYSTEM_DISPENSERS;Disp_i++)
             {
-                Read_Heaters_Current(Heater_i);
-            }*/
+                CalculateDispenserPressure(Disp_i);
+            }
         }
+    }
+    if (Onesecond_Tick)
+    {
+        MachineUpdateResponseFunc();
+        //KeepAliveOneSecondCall();
+#ifdef Use_Head_Card
+        for (Sensor_i = TEMP_SENSE_ANALOG_DRYER_TEMP1;Sensor_i < MAX_MAIN_CARD_TEMP_SENS_ID;Sensor_i++)
+#else
         for (Sensor_i = 0;Sensor_i < MAX_MAIN_CARD_TEMP_SENS_ID;Sensor_i++)
+#endif
         {
             TemperatureCalc[Sensor_i] =  MillisecCalculateTemperatures ( Sensor_i);
         }
+        if (RapidPressureRead == true)
+        {
+            for (Disp_i = 0;Disp_i < MAX_SYSTEM_DISPENSERS;Disp_i++)
+            {
+                PressureCalc[Disp_i] = MillisecCalculatePressures(Disp_i);
+            }
+        }
     }
     if (OneMinute_Tick)
     {
diff --git a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.h b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.h
index 4edc1a8ed..9335a6d08 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.h
+++ b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.h
@@ -34,6 +34,7 @@ uint32_t getDrawerFansStatus(void);
 uint32_t getSystemFansStatus(void);
 uint8_t getGasReading(void);
 int MillisecGetTemperatures (TEMPERATURE_SENSOR_ID_ENUM SensorId);
+float MillisecGetPressures (int SensorId);
 void setRapidPressureRead(bool value);
 
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c
index 9a81854e6..2911c369a 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c
@@ -128,112 +128,58 @@ uint32_t SetDigitalOutRequestRequestFunc(MessageContainer* requestContainer)
                 DeActivateCleanerPump();
             break;
         case INTERFACE_IOS__GPO_DRYER_SSR1_CTRL:
-#ifdef DEMO_TEMPERATURE
-            HeaterTestActive[1] = false;
-#endif
             if (request->value == true)
                 ActivateHeater(1);
             else
                 DeActivateHeater(1);
-#ifdef DEMO_TEMPERATURE
-            HeaterTestActive[1] = true;
-#endif
             break;
         case INTERFACE_IOS__GPO_DRYER_SSR2_CTRL:
-#ifdef DEMO_TEMPERATURE
-            HeaterTestActive[2] = false;
-#endif
             if (request->value == true)
                 ActivateHeater(2);
             else
                 DeActivateHeater(2);
-#ifdef DEMO_TEMPERATURE
-            HeaterTestActive[2] = true;
-#endif
             break;
         case INTERFACE_IOS__GPO_DYEINGH_SSR8_CTRL:
-#ifdef DEMO_TEMPERATURE
-            HeaterTestActive[3] = false;
-#endif
             if (request->value == true)
                 ActivateHeater(3);
             else
                 DeActivateHeater(3);
-#ifdef DEMO_TEMPERATURE
-            HeaterTestActive[3] = true;
-#endif
             break;
         case INTERFACE_IOS__GPO_DYEINGH_SSR7_CTRL:
-#ifdef DEMO_TEMPERATURE
-            HeaterTestActive[4] = false;
-#endif
             if (request->value == true)
                 ActivateHeater(4);
             else
                 DeActivateHeater(4);
-#ifdef DEMO_TEMPERATURE
-            HeaterTestActive[4] = true;
-#endif
             break;
         case INTERFACE_IOS__GPO_DYEINGH_SSR6_CTRL:
-#ifdef DEMO_TEMPERATURE
-            HeaterTestActive[5] = false;
-#endif
             if (request->value == true)
                 ActivateHeater(5);
             else
                 DeActivateHeater(5);
-#ifdef DEMO_TEMPERATURE
-            HeaterTestActive[5] = true;
-#endif
             break;
         case INTERFACE_IOS__GPO_DYEINGH_SSR5_CTRL:
-#ifdef DEMO_TEMPERATURE
-            HeaterTestActive[6] = false;
-#endif
             if (request->value == true)
                 ActivateHeater(6);
             else
                 DeActivateHeater(6);
-#ifdef DEMO_TEMPERATURE
-            HeaterTestActive[6] = true;
-#endif
             break;
         case INTERFACE_IOS__GPO_DILUTORPUMP_SSR10_CTRL:
-#ifdef DEMO_TEMPERATURE
-            HeaterTestActive[7] = false;
-#endif
             if (request->value == true)
                 ActivateHeater(7);
             else
                 DeActivateHeater(7);
-#ifdef DEMO_TEMPERATURE
-            HeaterTestActive[7] = true;
-#endif
             break;
         case INTERFACE_IOS__GPO_EXTWINDER_SSR11_CTRL:
-#ifdef DEMO_TEMPERATURE
-            HeaterTestActive[8] = false;
-#endif
             if (request->value == true)
                 ActivateHeater(8);
             else
                 DeActivateHeater(8);
-#ifdef DEMO_TEMPERATURE
-            HeaterTestActive[8] = true;
-#endif
             break;
         case INTERFACE_IOS__GPO_MIXCHIP_SSR4_CTRL:
-#ifdef DEMO_TEMPERATURE
-            HeaterTestActive[9] = false;
-#endif
             if (request->value == true)
                 ActivateHeater(9);
             else
                 DeActivateHeater(9);
-#ifdef DEMO_TEMPERATURE
-            HeaterTestActive[9] = true;
-#endif
             break;
         case INTERFACE_IOS__GPO_SPARE_SSR13_CTRL:
             if (request->value == true)
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
index 5c0af7589..fff75fd54 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
@@ -87,15 +87,21 @@ double pollermotor[DIAGNOSTICS_LIMIT+1];
 double windermotor[DIAGNOSTICS_LIMIT+1];
 double screwmotor[DIAGNOSTICS_LIMIT+1];
 double mixertemperature[DIAGNOSTICS_LIMIT+1];
-double headzone1temperature[DIAGNOSTICS_LIMIT+1];
+/*double headzone1temperature[DIAGNOSTICS_LIMIT+1];
 double headzone2temperature[DIAGNOSTICS_LIMIT+1];
 double headzone3temperature[DIAGNOSTICS_LIMIT+1];
 double headzone4temperature[DIAGNOSTICS_LIMIT+1];
 double headzone5temperature[DIAGNOSTICS_LIMIT+1];
 double headzone6temperature[DIAGNOSTICS_LIMIT+1];
+double headzone7temperature[DIAGNOSTICS_LIMIT+1];
+double headzone8temperature[DIAGNOSTICS_LIMIT+1];
+double headzone9temperature[DIAGNOSTICS_LIMIT+1];
+double headzone10temperature[DIAGNOSTICS_LIMIT+1];
+double headzone11temperature[DIAGNOSTICS_LIMIT+1];
+double headzone12temperature[DIAGNOSTICS_LIMIT+1];
 double dryerzone1temperature[DIAGNOSTICS_LIMIT+1];
 double dryerzone2temperature[DIAGNOSTICS_LIMIT+1];
-double dryerzone3temperature[DIAGNOSTICS_LIMIT+1];
+double dryerzone3temperature[DIAGNOSTICS_LIMIT+1];*/
 
 
 double dispensermotorfrequency[MAX_SYSTEM_DISPENSERS][DIAGNOSTICS_LIMIT+1];
@@ -105,6 +111,7 @@ double midtankinklevel[MAX_SYSTEM_DISPENSERS][1];
 double MidTankpressure[MAX_SYSTEM_DISPENSERS][1];
 double HeatersCurrent[NUM_OF_CURRENT_HEATERS][1];
 double VOC_Sensor;
+double OverallTemperature;
 
 DoubleArray DispenserFreq[MAX_SYSTEM_DISPENSERS];
 DoubleArray DiagnosticsDispenserPressure[MAX_SYSTEM_DISPENSERS];
@@ -112,7 +119,7 @@ DoubleArray DispenserInkLevel[MAX_SYSTEM_DISPENSERS];
 DoubleArray DiagnosticsMidTankInkLevel[MAX_SYSTEM_DISPENSERS];
 
 HeaterState **heatersstates;
-HeaterState  HeaterInfo[HEATER_TYPE__MixerHeater+1];
+HeaterState  HeaterInfo[HEATER_TYPE_MAX_HEATERS];
 
 #define NUM_OF_INTERFACE_IOS 21
 DigitalInterfaceState **digitalinterfacestates;
@@ -180,8 +187,8 @@ void DiagnosticsInit(void)
         double_array__init(&DiagnosticsMidTankInkLevel[i]);
         double_array__init(&DispenserInkLevel[i]);
     }
-    heatersstates = (HeaterState**)my_malloc(sizeof(HeaterState *)*(HEATER_TYPE__MixerHeater+1));
-    for(i=0;i<=HEATER_TYPE__MixerHeater;i++)
+    heatersstates = (HeaterState**)my_malloc(sizeof(HeaterState *)*(HEATER_TYPE_MAX_HEATERS));
+    for(i=0;i<HEATER_TYPE_MAX_HEATERS;i++)
     {
         heater_state__init(&HeaterInfo[i]);
         heatersstates[i] = &HeaterInfo[i];
@@ -228,8 +235,8 @@ void  SetDiagnosticCollectionLimit(int limit)
     }
 }
 
-uint8_t HeaterCounterIndex[MAX_HEATERS_NUM]= {0,0,0,0,0,0,0,0,0,0};
-double HeaterTemperature[MAX_HEATERS_NUM][DIAGNOSTICS_LIMIT+1];
+uint8_t HeaterCounterIndex[HEATER_TYPE_MAX_HEATERS]= {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+double HeaterTemperature[HEATER_TYPE_MAX_HEATERS][DIAGNOSTICS_LIMIT+1];
 uint8_t  DancerCounterIndex[NUM_OF_DANCERS]= {0,0,0};
 double DancerValue[NUM_OF_DANCERS][DIAGNOSTICS_DANCER_LIMIT+1];
 int8_t  DancerErrorCounterIndex[NUM_OF_DANCERS]= {0,0,0};
@@ -317,7 +324,7 @@ uint32_t DiagnosticsLoadDigitalValues(void)
 void DiagnosticLoadTemperature(int HeaterId, int temperature)
 {
     double temp = temperature;
-    if (HeaterId >= MAX_HEATERS_NUM)
+    if (HeaterId >= HEATER_TYPE_MAX_HEATERS)
     {
         LOG_ERROR(HeaterId,"wrong Heater Id");
         return;
@@ -342,7 +349,7 @@ void DiagnosticLoadSpeedSensor(float value)
 
 void DiagnosticLoadDancer(int DancerId, uint16_t value)
 {
-    if (DancerId >= MAX_HEATERS_NUM)
+    if (DancerId >= NUM_OF_DANCERS)
     {
         LOG_ERROR(DancerId,"wrong Dancer Id");
         return;
@@ -355,7 +362,7 @@ void DiagnosticLoadDancer(int DancerId, uint16_t value)
 }
 void DiagnosticLoadDancerError(int DancerId, double value)
 {
-    if (DancerId >= MAX_HEATERS_NUM)
+    if (DancerId >= NUM_OF_DANCERS)
     {
         LOG_ERROR(DancerId,"wrong Dancer Id");
         return;
@@ -416,7 +423,8 @@ void DiagnosticOneMinuteCollection(void)
 
     }
     DiagnosticsMonitor.n_overalltemperature = 1;
-    DiagnosticsMonitor.overalltemperature = max(MillisecGetTemperatures(TEMP_SENSE_AN_ENCLOSURETEMP1),MillisecGetTemperatures(TEMP_SENSE_AN_ENCLOSURETEMP2));
+    OverallTemperature = max(MillisecGetTemperatures(TEMP_SENSE_AN_ENCLOSURETEMP1),MillisecGetTemperatures(TEMP_SENSE_AN_ENCLOSURETEMP2));
+    DiagnosticsMonitor.overalltemperature = &OverallTemperature;
 
     DiagnosticsMonitor.n_midtank1level = 1;
     DiagnosticsMonitor.midtank1level = MidTankpressure[0];
@@ -673,6 +681,13 @@ void SendDiagnostics(void)
     DiagnosticsMonitor.headzone4temperature = HeaterTemperature[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4];
     DiagnosticsMonitor.headzone5temperature = HeaterTemperature[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5];
     DiagnosticsMonitor.headzone6temperature = HeaterTemperature[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6];
+    DiagnosticsMonitor.headzone7temperature = HeaterTemperature[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ7];
+    DiagnosticsMonitor.headzone8temperature = HeaterTemperature[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ8];
+    DiagnosticsMonitor.headzone9temperature = HeaterTemperature[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ9];
+    DiagnosticsMonitor.headzone10temperature = HeaterTemperature[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ10];
+    DiagnosticsMonitor.headzone11temperature = HeaterTemperature[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ11];
+    DiagnosticsMonitor.headzone12temperature = HeaterTemperature[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ12];
+
     DiagnosticsMonitor.dryerzone1temperature = HeaterTemperature[HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature];
     DiagnosticsMonitor.dryerzone2temperature = HeaterTemperature[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain];
     DiagnosticsMonitor.dryerzone3temperature = HeaterTemperature[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary];
@@ -684,6 +699,12 @@ void SendDiagnostics(void)
     DiagnosticsMonitor.n_headzone4temperature = HeaterCounterIndex[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4];
     DiagnosticsMonitor.n_headzone5temperature = HeaterCounterIndex[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5];
     DiagnosticsMonitor.n_headzone6temperature = HeaterCounterIndex[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6];
+    DiagnosticsMonitor.n_headzone7temperature = HeaterCounterIndex[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ7];
+    DiagnosticsMonitor.n_headzone8temperature = HeaterCounterIndex[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ8];
+    DiagnosticsMonitor.n_headzone9temperature = HeaterCounterIndex[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ9];
+    DiagnosticsMonitor.n_headzone10temperature = HeaterCounterIndex[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ10];
+    DiagnosticsMonitor.n_headzone11temperature = HeaterCounterIndex[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ11];
+    DiagnosticsMonitor.n_headzone12temperature = HeaterCounterIndex[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ12];
     DiagnosticsMonitor.n_dryerzone1temperature = HeaterCounterIndex[HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature];
     DiagnosticsMonitor.n_dryerzone2temperature = HeaterCounterIndex[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain];
     DiagnosticsMonitor.n_dryerzone3temperature = HeaterCounterIndex[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary];
@@ -792,12 +813,20 @@ void SendDiagnostics(void)
     response.n_digitalinterfacestates = DiagnosticsLoadDigitalValues();
     response.digitalinterfacestates = digitalinterfacestates;
 
-    for (i=HEATER_TYPE__DryerAirHeater;i<=HEATER_TYPE__MixerHeater;i++)
+#ifdef Use_Head_Card
+    for (i=HEATER_TYPE__DryerAirHeater;i<HEATER_TYPE_MAX_HEATERS;i++)
+#else
+	for (i=HEATER_TYPE__DryerAirHeater;i<MAX_HEATERS_NUM;i++)
+#endif
     {
         LoadHeaterState((HeaterType)i,&HeaterInfo[i]);
         //heatersstates[i] = &HeaterInfo[i];
     }
-    response.n_heatersstates = HEATER_TYPE__MixerHeater+1;
+#ifdef Use_Head_Card
+    response.n_heatersstates = HEATER_TYPE_MAX_HEATERS;
+#else
+    response.n_heatersstates = MAX_HEATERS_NUM;
+#endif
     response.heatersstates = heatersstates;
 
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsJogging.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsJogging.c
index 4ea029610..e2eb264a7 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsJogging.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsJogging.c
@@ -174,6 +174,9 @@ uint32_t DispenserJoggingRequestFunc(MessageContainer* requestContainer)
             MotorSetDirection(MotorId,direction);
             MotorSetSpeed(MotorId, speed);
             CurrentDispenserSpeed[request->index] = speed;
+            if(request->direction == MOTOR_DIRECTION__Backward)
+                CurrentDispenserSpeed[request->index] *= (-1);
+
         }
         else
         {
diff --git a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
index 46abd923f..b89702668 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
@@ -420,7 +420,7 @@ uint32_t HWConfiguration(UploadHardwareConfigurationRequest* UploadRequest)
 
         for (PID_i = 0; PID_i < request->n_pidcontrols ; PID_i++)
         {
-            if (request->pidcontrols[PID_i]->hardwarepidcontroltype <= HARDWARE_PID_CONTROL_TYPE__MixerHeater)
+            if (isHeater(request->pidcontrols[PID_i]->hardwarepidcontroltype))
                 status += HeaterConfigRequestMessage(request->pidcontrols[PID_i]);
             else if ((request->pidcontrols[PID_i]->hardwarepidcontroltype >= HARDWARE_PID_CONTROL_TYPE__MotorDryer)&&
                     (request->pidcontrols[PID_i]->hardwarepidcontroltype < HARDWARE_PID_CONTROL_TYPE__Dispenser1))
diff --git a/Software/Embedded_SW/Embedded/Modules/General/MachineStatus.c b/Software/Embedded_SW/Embedded/Modules/General/MachineStatus.c
index e1a516e95..157841365 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/MachineStatus.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/MachineStatus.c
@@ -24,7 +24,7 @@
 #include "drivers/Motors/Motor.h"
 
 #include "Modules/General/MachineStatus.h"
-
+#include "Modules/Control/MillisecTask.h"
 #include "modules/ids/ids_ex.h"
 
 MachineState StoredMachineStatus = MACHINE_STATE__Ready;
diff --git a/Software/Embedded_SW/Embedded/Modules/General/buttons.c b/Software/Embedded_SW/Embedded/Modules/General/buttons.c
index bbb8cb880..22af2b07e 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/buttons.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/buttons.c
@@ -297,6 +297,13 @@ uint32_t ButtonJogCBFunction(uint32_t IfIndex, uint32_t ReadValue)
             {
                 ReportWithPackageFilter(GeneralFilter,"------------ joggingMachine: sttJOGGING action->LONGPB-----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);    jog.state = sttJOGGING;
                 jog.state = sttLONG_JOGGING;
+                if (JobIsActive() == false) // added because sometimes the jog stops because of another reason and the button s stucked blinking
+                {
+                    jog.color =  colorON;
+                    Pannel_Leds(THREAD_JOGGING, MODE_ON);
+                    jog.state = sttENABLE;
+                }
+
             }
             break;
         case sttLONG_JOGGING:
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters.h b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters.h
index b25c3e5c7..05425cc45 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters.h
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters.h
@@ -4,6 +4,7 @@
 #include "PMR/Hardware/HardwarePidControl.pb-c.h"
 #include "PMR/Hardware/HardwarePidControlType.pb-c.h"
 #include "heaters_ex.h"
+#include "Drivers/Heater/Heater.h"
 /******************** DEFINITIONS  ********************************************/
 #define MAX_AC_HEATERS (HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary+1)
 #define MAX_TIMESLICES 200
@@ -12,7 +13,7 @@ extern uint32_t OutputProportionalSingleStep;  //A/C Heaters step size from one
 extern uint32_t OutputProportionalCycleTime; //A/C Heaters Cycle time in milliseconds - one for all heaters
 //extern uint32_t Heater_timerBase;        //Timer handle
 extern char     TimeSliceAllocation[MAX_TIMESLICES];
-extern int     DCTimeSliceAllocation[MAX_HEATERS_NUM];
+extern int     DCTimeSliceAllocation[HEATER_TYPE_MAX_HEATERS];
 extern int      NumberOFSlicesInUse;
 extern uint32_t MillisecondsPerChange;
 
@@ -48,13 +49,13 @@ typedef struct  HeaterCommandstruc
 }HeaterCommand;
 
 
-extern HeaterPIDControlConfig HeaterControl[MAX_HEATERS_NUM];
-extern HeaterCommand          HeaterCmd[MAX_HEATERS_NUM];
+extern HeaterPIDControlConfig HeaterControl[HEATER_TYPE_MAX_HEATERS];
+extern HeaterCommand          HeaterCmd[HEATER_TYPE_MAX_HEATERS];
 extern uint32_t  Heater_timerBase;
 
 uint32_t HeaterRecalculateSharedHeatersParams(uint32_t deviceId, uint32_t new_outputproportionalpowerlimit);
 uint32_t HeaterRecalculateHeaterParams(uint32_t deviceId, uint32_t new_outputproportionalpowerlimit);
 
-uint32_t HeatersSingleHeaterEnd(HardwarePidControlType HeaterId);
+uint32_t HeatersSingleHeaterEnd(int HeaterId);
 
 #endif
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h
index 0b65d9e5e..bcc19bd6f 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h
@@ -1,10 +1,17 @@
+#include "Drivers/Heater/Heater.h"
+
 #include "PMR/common/MessageContainer.pb-c.h"
 #include "PMR/Hardware/HardwarePidControl.pb-c.h"
 #include "PMR/Diagnostics/HeaterType.pb-c.h"
 #include "PMR/Diagnostics/HeaterState.pb-c.h"
+#include "PMR/Diagnostics/EventType.pb-c.h"
 
 #define MAX_HEATERS_NUM  HARDWARE_PID_CONTROL_TYPE__MixerHeater+1
 
+extern EventType HeaterEventType[HEATER_TYPE_MAX_HEATERS];
+extern EventType HeaterUnderEventType[HEATER_TYPE_MAX_HEATERS];
+extern EventType HeaterUnderEventType_B[HEATER_TYPE_MAX_HEATERS];
+
 //uint32_t HeaterCommandRequestMessage(MessageContainer* requestContainer);
 uint32_t HeaterConfigRequestMessage(HardwarePidControl* request);
 uint32_t HeaterConfigSetSharedHeatersParams (uint32_t outputproportionalcycletime, uint32_t outputproportionalsinglestep);
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_init.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_init.c
index 273c497bd..d7fc0703a 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_init.c
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_init.c
@@ -45,7 +45,7 @@ typedef enum {
 }HEATERS_EVENTS_ENUM;
 */
 /******************** GLOBAL PARAMETERS  ********************************************/
-HeaterPIDControlConfig HeaterControl[MAX_HEATERS_NUM] = {0,0,0,0,0,0,0,0,0,0,0,0};
+HeaterPIDControlConfig HeaterControl[HEATER_TYPE_MAX_HEATERS] = {0,0,0,0,0,0,0,0,0,0,0,0};
 bool AcHeaterConfigured[MAX_AC_HEATERS] = {0,0,0};
 
 int      NumberOFSlicesInUse = 0;
@@ -69,7 +69,11 @@ uint32_t Heaters_Init(void)
     FPGA_SensorInitConfig();
 
     memset(HeaterControl,0,sizeof(HeaterControl));
+#ifdef Use_Head_Card
+    for (i = 0;i<HEATER_TYPE_MAX_HEATERS; i++)
+#else
     for (i = 0;i<MAX_HEATERS_NUM; i++)
+#endif
         DeActivateHeater(i);
     return OK;
 }
@@ -82,10 +86,10 @@ uint32_t HeaterConfigRequestMessage(HardwarePidControl* request)
     //uint32_t status = OK;
     HardwarePidControlType HeaterId;
 
-    HeaterId = request->hardwarepidcontroltype;
+    HeaterId = getHeaterId(request->hardwarepidcontroltype);
     //int ValidationError = 0;
 
-    if (HeaterId< MAX_HEATERS_NUM)
+    if (HeaterId< HEATER_TYPE_MAX_HEATERS)
     {
         HeaterControl[HeaterId].configured = true;
         HeaterControl[HeaterId].id = HeaterId;
@@ -95,10 +99,10 @@ uint32_t HeaterConfigRequestMessage(HardwarePidControl* request)
         HeaterControl[HeaterId].ProportionalErrorMultiplier = request->outputonoffhysteresisvalue;
         if (HeaterId == HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature)
         {
-            HeaterControl[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain].sensormaxvalue = request->sensormaxvalue*100;
-            HeaterControl[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain].sensorminvalue = request->sensorminvalue*100;
-            HeaterControl[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary].sensormaxvalue = request->sensormaxvalue*100;
-            HeaterControl[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary].sensorminvalue = request->sensorminvalue*100;
+            HeaterControl[HEATER_TYPE__DryerMainHeater].sensormaxvalue = request->sensormaxvalue*100;
+            HeaterControl[HEATER_TYPE__DryerMainHeater].sensorminvalue = request->sensorminvalue*100;
+            HeaterControl[HEATER_TYPE__DryerSecondaryHeater].sensormaxvalue = request->sensormaxvalue*100;
+            HeaterControl[HEATER_TYPE__DryerSecondaryHeater].sensorminvalue = request->sensorminvalue*100;
         }
         HeaterControl[HeaterId].sensormaxvalue = 0;
         HeaterControl[HeaterId].sensorminvalue = 0;
@@ -157,8 +161,8 @@ uint32_t HeaterConfigSetSharedHeatersParams(uint32_t outputproportionalcycletime
    }
 
    // all numbers are rounded down. better to have carefully calculated numbers
-   Heater1000Slices = HeaterControl[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain].outputproportionalpowerlimit * NumberOFSlicesInUse / 100;
-   Heater200aSlices = HeaterControl[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary].outputproportionalpowerlimit * NumberOFSlicesInUse / 100;
+   Heater1000Slices = HeaterControl[HEATER_TYPE__DryerMainHeater].outputproportionalpowerlimit * NumberOFSlicesInUse / 100;
+   Heater200aSlices = HeaterControl[HEATER_TYPE__DryerSecondaryHeater].outputproportionalpowerlimit * NumberOFSlicesInUse / 100;
 
    if ((Heater1000Slices + Heater200aSlices +2)>NumberOFSlicesInUse)
    {
@@ -168,8 +172,8 @@ uint32_t HeaterConfigSetSharedHeatersParams(uint32_t outputproportionalcycletime
 
    //mark the time slices  for heaters operation as empty / Heater1000 / Heater 200
    memset (TimeSliceAllocation,0xFF,sizeof(TimeSliceAllocation));
-   for (Slice_i = 0; Slice_i < Heater1000Slices;Slice_i++ ) TimeSliceAllocation[Slice_i] = HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain;
-   for (Slice_i = Heater1000Slices+1; Slice_i <= Heater1000Slices+Heater200aSlices;Slice_i++ ) TimeSliceAllocation[Slice_i] = HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary;
+   for (Slice_i = 0; Slice_i < Heater1000Slices;Slice_i++ ) TimeSliceAllocation[Slice_i] = HEATER_TYPE__DryerMainHeater;
+   for (Slice_i = Heater1000Slices+1; Slice_i <= Heater1000Slices+Heater200aSlices;Slice_i++ ) TimeSliceAllocation[Slice_i] = HEATER_TYPE__DryerSecondaryHeater;
 
    return OK;
 
@@ -193,8 +197,8 @@ uint32_t HeaterRecalculateSharedHeatersParams(uint32_t deviceId, uint32_t new_ou
 
    // all numbers are rounded down. better to have carefully calculated numbers
    HeaterControl[deviceId].outputproportionalpowerlimit = new_outputproportionalpowerlimit;///100;
-   Heater1000Slices = HeaterControl[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain].outputproportionalpowerlimit * NumberOFSlicesInUse / 100;
-   Heater200aSlices = HeaterControl[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary].outputproportionalpowerlimit * NumberOFSlicesInUse / 100;
+   Heater1000Slices = HeaterControl[HEATER_TYPE__DryerMainHeater].outputproportionalpowerlimit * NumberOFSlicesInUse / 100;
+   Heater200aSlices = HeaterControl[HEATER_TYPE__DryerSecondaryHeater].outputproportionalpowerlimit * NumberOFSlicesInUse / 100;
 
 //#warning temporary disable time slice control as we are working with one heater in run time
 /*   if ((Heater1000Slices + Heater200aSlices +2)>NumberOFSlicesInUse)
@@ -205,8 +209,8 @@ uint32_t HeaterRecalculateSharedHeatersParams(uint32_t deviceId, uint32_t new_ou
 */
    //mark the time slices  for heaters operation as empty / Heater1000 / Heater 200
    memset (TimeSliceAllocation,0xFF,sizeof(TimeSliceAllocation));
-   for (Slice_i = 0; Slice_i < Heater1000Slices;Slice_i++ ) TimeSliceAllocation[Slice_i] = HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain;
-   for (Slice_i = Heater1000Slices+1; Slice_i <= Heater1000Slices+Heater200aSlices;Slice_i++ ) TimeSliceAllocation[Slice_i] = HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary;
+   for (Slice_i = 0; Slice_i < Heater1000Slices;Slice_i++ ) TimeSliceAllocation[Slice_i] = HEATER_TYPE__DryerMainHeater;
+   for (Slice_i = Heater1000Slices+1; Slice_i <= Heater1000Slices+Heater200aSlices;Slice_i++ ) TimeSliceAllocation[Slice_i] = HEATER_TYPE__DryerSecondaryHeater;
 
    return OK;
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
index b023d592b..51498dc04 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
@@ -35,6 +35,7 @@
 #include "Drivers/I2C_Communication/DAC/blower.h"
 #include "drivers/FPGA/FPGA_GPIO/FPGA_GPIO.h"
 #include "drivers/I2C_Communication/ADC_MUX/ADC_MUX.h"
+#include "drivers/I2C_Communication/Head_Card/ADC/Head_ADC.h"
 
 #include "StateMachines/Printing/PrintingSTM.h"
 #include "StateMachines/Initialization/PowerIdle.h"
@@ -73,15 +74,15 @@ typedef struct
     bool                m_isReady;
     PID_Config_Params   m_params;
 }HeaterControlConfig_t;
-HeaterControlConfig_t  HeaterPIDConfig[MAX_HEATERS_NUM] = {0,0,0,0,0,0,0,0,0,0,0,0};
+HeaterControlConfig_t  HeaterPIDConfig[HEATER_TYPE_MAX_HEATERS] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
 //PID_Config_Params   temp_params;
 
 /******************** GLOBAL PARAMETERS  ********************************************/
-HeaterCommand          HeaterCmd[MAX_HEATERS_NUM];
-uint32_t    ControlIdtoHeaterId [MAX_HEATERS_NUM] = {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF};
-uint32_t    ControlIdtoMaxHeaterId [MAX_HEATERS_NUM] = {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF};
-uint32_t    OverHeatCounter [MAX_HEATERS_NUM] = {0,0,0,0,0,0,0,0,0,0};
-uint32_t    UnderHeatCounter [MAX_HEATERS_NUM] = {0,0,0,0,0,0,0,0,0,0};
+HeaterCommand          HeaterCmd[HEATER_TYPE_MAX_HEATERS];
+uint32_t    ControlIdtoHeaterId [HEATER_TYPE_MAX_HEATERS] = {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF};
+uint32_t    ControlIdtoMaxHeaterId [HEATER_TYPE_MAX_HEATERS] = {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF};
+uint32_t    OverHeatCounter [HEATER_TYPE_MAX_HEATERS] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+uint32_t    UnderHeatCounter [HEATER_TYPE_MAX_HEATERS] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
 uint32_t    MainDryerHeaterMaxTempControl = 0xFF;
 uint32_t    SecondDryerHeaterMaxTempControl = 0xFF;
 uint32_t    DisasterControlId = 0xFF;
@@ -91,42 +92,50 @@ uint32_t    DisasterControlId = 0xFF;
 #define MINIMUM_HEATER_READ 9.0
 #define MAXIMUM_HEATER_READ 283
 
-//old uint32_t HeaterId2PT100Id[MAX_HEATERS_NUM] = {DRYER_AIR_PT100,DRYER_MAIN_PT100,DRYER_SECONDARY_PT100,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,TEMP_SENSE_ANALOG_MIXCHIP_TEMP,TEMP_SENSE_AN_ENCLOSURETEMP3};
-uint32_t HeaterId2PT100Id[MAX_HEATERS_NUM] = {DRYER_AIR_PT100,DRYER_MAIN_PT100,DRYER_SECONDARY_PT100,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,HEAD6_PT100,MIXER_PT100};
-HEATERS_CURRENT HeaterId2CurrentId[MAX_HEATERS_NUM] = {NUM_OF_CURRENT_HEATERS,HEATER_DRYER_CURRENT_1,HEATER_DRYER_CURRENT_2,HEATER_HEAD_CURRENT_ZONE_1,HEATER_HEAD_CURRENT_ZONE_2,HEATER_HEAD_CURRENT_ZONE_3,HEATER_HEAD_CURRENT_ZONE_4,HEATER_HEAD_CURRENT_ZONE_5_6,HEATER_HEAD_CURRENT_ZONE_5_6,HEATER_MIXCHIP_CURRENT};
+#ifdef Use_Head_Card
+uint32_t HeaterId2PT100Id[HEATER_TYPE_MAX_HEATERS] = {DRYER_AIR_PT100,DRYER_MAIN_PT100,DRYER_SECONDARY_PT100,HEAD_PT100_ZONE_1_0X80_0, HEAD_PT100_ZONE_2_0X80_1, HEAD_PT100_ZONE_3_0X82_0,
+                                                      HEAD_PT100_ZONE_4_0X82_1, HEAD_PT100_ZONE_5_0X84_0, HEAD_PT100_ZONE_6_0X84_1,HEAD_PT100_MIXER_0X8E_0, HEAD_PT100_ZONE_7_0X86_0, HEAD_PT100_ZONE_8_0X86_1,
+                                                      HEAD_PT100_ZONE_9_0X88_0, HEAD_PT100_ZONE_10_0X88_1, HEAD_PT100_ZONE_11_0X8A_0, HEAD_PT100_ZONE_12_0X8A_1 };
+HEATERS_CURRENT HeaterId2CurrentId[HEATER_TYPE_MAX_HEATERS] = {NUM_OF_CURRENT_HEATERS,HEATER_DRYER_CURRENT_1,HEATER_DRYER_CURRENT_2,HEAD_CURRENT_ZONE_1, HEAD_CURRENT_ZONE_2,
+                                                               HEAD_CURRENT_ZONE_3, HEAD_CURRENT_ZONE_4, HEAD_CURRENT_ZONE_5, HEAD_CURRENT_ZONE_6, HEAD_CURRENT_MIXER, HEAD_CURRENT_ZONE_7,
+                                                               HEAD_CURRENT_ZONE_8, HEAD_CURRENT_ZONE_9, HEAD_CURRENT_ZONE_10, HEAD_CURRENT_ZONE_11, HEAD_CURRENT_ZONE_12};
+#else
+uint32_t HeaterId2PT100Id[HEATER_TYPE_MAX_HEATERS] = {DRYER_AIR_PT100,DRYER_MAIN_PT100,DRYER_SECONDARY_PT100,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,HEAD6_PT100,MIXER_PT100,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF};
+HEATERS_CURRENT HeaterId2CurrentId[HEATER_TYPE_MAX_HEATERS] = {NUM_OF_CURRENT_HEATERS,HEATER_DRYER_CURRENT_1,HEATER_DRYER_CURRENT_2,HEATER_HEAD_CURRENT_ZONE_1,HEATER_HEAD_CURRENT_ZONE_2,HEATER_HEAD_CURRENT_ZONE_3,HEATER_HEAD_CURRENT_ZONE_4,HEATER_HEAD_CURRENT_ZONE_5_6,HEATER_HEAD_CURRENT_ZONE_5_6,HEATER_MIXCHIP_CURRENT};
+#endif
 uint32_t    DryerInternalPT100Id = DRYER_AIR_PT100;
 bool HeatersRestart = false;
 
-bool HeaterMaxTempFlag[MAX_HEATERS_NUM] = {false,false,false,false,false,false,false,false,false,false};
-bool HeaterMinTempFlag[MAX_HEATERS_NUM] = {true,true,true,true,true,true,true,true,true,true};
+bool HeaterMaxTempFlag[HEATER_TYPE_MAX_HEATERS] = {false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false};
+bool HeaterMinTempFlag[HEATER_TYPE_MAX_HEATERS] = {true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true};
 
 uint32_t OutputProportionalSingleStep = 0;  //A/C Heaters step size from one decision point to another - in cpu clocks. 120000 = 1 millisecod
-uint32_t  Heater_timerBase = TIMER2_BASE;        //Timer handle
+uint32_t  Heater_timerBase = TIMER2_BASE;   //Timer handle
 uint32_t OutputProportionalCycleTime = 0; //A/C Heaters Cycle time in milliseconds - one for all heaters
 char     TimeSliceAllocation[MAX_TIMESLICES] = {0xFF};
-int     DCTimeSliceAllocation[MAX_HEATERS_NUM] = {0};
+int     DCTimeSliceAllocation[HEATER_TYPE_MAX_HEATERS] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
 
 bool TimerActivated = false;
 char ACheatstr[100];
 
-Mailbox_Handle          HeatersControlMsgQ = NULL;
+Mailbox_Handle  HeatersControlMsgQ = NULL;
 //bool InitialHeating = true;
-//bool DCInitialHeating[MAX_HEATERS_NUM] = {true};
-bool    HeaterReady[MAX_HEATERS_NUM] = {true};
-bool    HeaterAtTemp[MAX_HEATERS_NUM] = {true};
-uint32_t HeaterPreviousRead[MAX_HEATERS_NUM] = {0,0,0,0,0,0,0,0,0,0}; //A/C Heaters Cycle time in milliseconds - one for all heaters
-EventType HeaterEventType[MAX_HEATERS_NUM] = {EVENT_TYPE__DRYER_ZONE_1_OVERTEMPERATURE,EVENT_TYPE__DRYER_ZONE_2_OVERTEMPERATURE,EVENT_TYPE__DRYER_ZONE_1_OVERTEMPERATURE,EVENT_TYPE__DYEING_HEAD_ZONE_1_OVERTEMPERATURE,EVENT_TYPE__DYEING_HEAD_ZONE_2_OVERTEMPERATURE,
-                                              EVENT_TYPE__DYEING_HEAD_ZONE_3_OVERTEMPERATURE,EVENT_TYPE__DYEING_HEAD_ZONE_4_OVERTEMPERATURE,EVENT_TYPE__DYEING_HEAD_ZONE_5_OVERTEMPERATURE,EVENT_TYPE__DYEING_HEAD_ZONE_6_OVERTEMPERATURE,
-                                              EVENT_TYPE__MIXER_OVERTEMPERATURE};
-EventType HeaterUnderEventType[MAX_HEATERS_NUM] = {EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_A,EVENT_TYPE__DRYER_ZONE_2_UNDERTEMPERATURE_A,EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_A,EVENT_TYPE__DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_A,EVENT_TYPE__DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_A,
+//bool DCInitialHeating[HEATER_TYPE_MAX_HEATERS] = {true};
+bool    HeaterReady[HEATER_TYPE_MAX_HEATERS] = {true};
+bool    HeaterAtTemp[HEATER_TYPE_MAX_HEATERS] = {true};
+uint32_t HeaterPreviousRead[HEATER_TYPE_MAX_HEATERS] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; //A/C Heaters Cycle time in milliseconds - one for all heaters
+EventType HeaterEventType[HEATER_TYPE_MAX_HEATERS] = {EVENT_TYPE__DRYER_ZONE_1_OVERTEMPERATURE,EVENT_TYPE__DRYER_ZONE_2_OVERTEMPERATURE,EVENT_TYPE__DRYER_ZONE_1_OVERTEMPERATURE,EVENT_TYPE__DYEING_HEAD_ZONE_1_OVERTEMPERATURE,EVENT_TYPE__DYEING_HEAD_ZONE_2_OVERTEMPERATURE,
+                                         EVENT_TYPE__DYEING_HEAD_ZONE_3_OVERTEMPERATURE,EVENT_TYPE__DYEING_HEAD_ZONE_4_OVERTEMPERATURE,EVENT_TYPE__DYEING_HEAD_ZONE_5_OVERTEMPERATURE,EVENT_TYPE__DYEING_HEAD_ZONE_6_OVERTEMPERATURE,
+                                              EVENT_TYPE__MIXER_OVERTEMPERATURE,EVENT_TYPE__None,EVENT_TYPE__None,EVENT_TYPE__None,EVENT_TYPE__None,EVENT_TYPE__None,EVENT_TYPE__None,EVENT_TYPE__None,EVENT_TYPE__None};
+EventType HeaterUnderEventType[HEATER_TYPE_MAX_HEATERS] = {EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_A,EVENT_TYPE__DRYER_ZONE_2_UNDERTEMPERATURE_A,EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_A,EVENT_TYPE__DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_A,EVENT_TYPE__DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_A,
                                               EVENT_TYPE__DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_A,EVENT_TYPE__DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_A,EVENT_TYPE__DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_A,EVENT_TYPE__DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_A,
-                                              EVENT_TYPE__MIXER_UNDERTEMPERATURE_A};
+                                              EVENT_TYPE__MIXER_UNDERTEMPERATURE_A,EVENT_TYPE__None,EVENT_TYPE__None,EVENT_TYPE__None,EVENT_TYPE__None,EVENT_TYPE__None,EVENT_TYPE__None,EVENT_TYPE__None,EVENT_TYPE__None};
 
-EventType HeaterUnderEventType_B[MAX_HEATERS_NUM] = {EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_B,EVENT_TYPE__DRYER_ZONE_2_UNDERTEMPERATURE_B,EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_B,EVENT_TYPE__DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_B,EVENT_TYPE__DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_B,
+EventType HeaterUnderEventType_B[HEATER_TYPE_MAX_HEATERS] = {EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_B,EVENT_TYPE__DRYER_ZONE_2_UNDERTEMPERATURE_B,EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_B,EVENT_TYPE__DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_B,EVENT_TYPE__DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_B,
                                               EVENT_TYPE__DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_B,EVENT_TYPE__DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_B,EVENT_TYPE__DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_B,EVENT_TYPE__DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_B,
-                                              EVENT_TYPE__MIXER_UNDERTEMPERATURE_B};
+                                              EVENT_TYPE__MIXER_UNDERTEMPERATURE_B,EVENT_TYPE__None,EVENT_TYPE__None,EVENT_TYPE__None,EVENT_TYPE__None,EVENT_TYPE__None,EVENT_TYPE__None,EVENT_TYPE__None,EVENT_TYPE__None};
 
-int HeaterDisasterCounter[HARDWARE_PID_CONTROL_TYPE__MixerHeater+1] = {0,0,0,0,0,0,0,0,0,0};
+int HeaterDisasterCounter[HEATER_TYPE_MAX_HEATERS] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
 #define DISASTER_COUNTER_LIMIT 10
 
 /******************** FUNCTIONS  ********************************************/
@@ -156,7 +165,7 @@ void HeatersControlInit(void)
     ROM_IntEnable(INT_TIMER2A);
     ROM_TimerIntEnable(Heater_timerBase, TIMER_TIMA_TIMEOUT);
 
-    for (i = 0; i < MAX_HEATERS_NUM; i++)
+    for (i = 0; i < HEATER_TYPE_MAX_HEATERS; i++)
     {
         //DCInitialHeating[i] = true;
         HeaterReady[i] = true;
@@ -209,7 +218,7 @@ bool    InternalAlarmActive[MAX_INTERNAL_ALARMS] = {false,false,false};
 uint32_t ControlIdtoInternalId[MAX_INTERNAL_ALARMS] = {0xFF,0xFF,0xFF};
 uint32_t HeatersTestInternalAlarmsCBFunction(uint32_t IfIndex, uint32_t readValue)
 {
-    int index=MAX_HEATERS_NUM;
+    int index=HEATER_TYPE_MAX_HEATERS;
 
     if (IfIndex>>8 != IfTypeHeaters)
     {
@@ -285,7 +294,7 @@ void HeatersControlStart(void)
 }
 uint32_t LoadHeaterSetPoint(HeaterType HeaterType)
 {
-    if (HeaterType >= MAX_HEATERS_NUM)
+    if (HeaterType >= HEATER_TYPE_MAX_HEATERS)
     {
         ReportWithPackageFilter(HeatersFilter,"Wrong Heater Id",__FILE__,__LINE__,HeaterType,RpError, 0,0);
         return 0;
@@ -311,21 +320,23 @@ void LoadHeaterState(HeaterType HeaterType,HeaterState *HeaterState)
     HeaterState->isrampingup = 1-HeaterAtTemp[HeaterId];
     HeaterState->has_isinsetpoint = true;
     HeaterState->isinsetpoint = HeaterReady[HeaterId];
-    if (HeaterId == HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain)
+    if (HeaterId == HEATER_TYPE__DryerMainHeater)
     {
-        HeaterState->setpoint = HeaterControl[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain].outputproportionalpowerlimit;
+        HeaterState->setpoint = HeaterControl[HEATER_TYPE__DryerMainHeater].outputproportionalpowerlimit;
         //HeaterState->isrampingup = InitialHeating;
     }
-    if (HeaterId == HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary)
+    if (HeaterId == HEATER_TYPE__DryerSecondaryHeater)
     {
-        HeaterState->setpoint = HeaterControl[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary].outputproportionalpowerlimit;
+        HeaterState->setpoint = HeaterControl[HEATER_TYPE__DryerSecondaryHeater].outputproportionalpowerlimit;
         //HeaterState->isrampingup = InitialHeating;
     }
     return;
 }
-uint32_t HeatersSingleHeaterEnd(HardwarePidControlType HeaterId)
+uint32_t HeatersSingleHeaterEnd(int HeaterId)
 {
     int status = OK;
+    assert(HeaterId < HEATER_TYPE_MAX_HEATERS);
+    //HEATER_TYPE_ENUM HeaterId = HeaterPidtoHeaterId(HeaterPID_Id);
     ReportWithPackageFilter(HeatersFilter,"HeatersSingleHeaterEnd ", __FILE__,__LINE__,HeaterId, RpMessage, 0, 0);
         if (HeaterId >= MAX_AC_HEATERS) //DC Heaters
         {
@@ -358,8 +369,8 @@ uint32_t HeatersSingleHeaterEnd(HardwarePidControlType HeaterId)
                 status |= RemoveControlCallback(ControlIdtoMaxHeaterId [HeaterId], DcHeaterMaxTempCBFunction);
                 ControlIdtoMaxHeaterId [HeaterId]=0xFF;
             }
-            HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain,0);
-            HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary,0);
+            HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerMainHeater,0);
+            HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerSecondaryHeater,0);
             if (MainDryerHeaterMaxTempControl)
             {
                 status |=RemoveControlCallback(MainDryerHeaterMaxTempControl ,HeaterMaxTempCBFunction);
@@ -370,10 +381,10 @@ uint32_t HeatersSingleHeaterEnd(HardwarePidControlType HeaterId)
                 status |=RemoveControlCallback(SecondDryerHeaterMaxTempControl ,HeaterMaxTempCBFunction);
                 SecondDryerHeaterMaxTempControl=0xFF;
             }
-            DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
-            DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
-            Disable_Reading_Heaters_Current(HeaterId2CurrentId[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain]);
-            Disable_Reading_Heaters_Current(HeaterId2CurrentId[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]);
+            DeActivateHeater(HEATER_TYPE__DryerMainHeater);
+            DeActivateHeater(HEATER_TYPE__DryerSecondaryHeater);
+            Disable_Reading_Heaters_Current(HeaterId2CurrentId[HEATER_TYPE__DryerMainHeater]);
+            Disable_Reading_Heaters_Current(HeaterId2CurrentId[HEATER_TYPE__DryerSecondaryHeater]);
             HeaterPIDConfig[HeaterId].m_SetParam = 0;
             HeaterReady[HeaterId] = true;
             HeaterAtTemp[HeaterId] = true;
@@ -392,9 +403,10 @@ uint32_t HeatersEnd(void)
     HardwarePidControlType i;
     uint32_t status = OK;
     HeatersControlStop();
-    for (i=0;i<MAX_HEATERS_NUM;i++)
+    for (i=0;i<HEATER_TYPE_MAX_HEATERS;i++)
     {
-        status = HeatersSingleHeaterEnd(i);
+        if(HeaterIdtoHeaterpid[i]!=HEATER_TYPE_MAX_HEATERS)
+            status = HeatersSingleHeaterEnd(i);
     }
     return status;
 
@@ -443,7 +455,7 @@ int GetFilteredHeaterRead(int HeaterId)
  * called by: Communication from host
  * initialized all global data
  *************************************************************************************/
-bool HeaterRestarted[MAX_HEATERS_NUM] = {false,false,false,false,false,false,false,false,false,false};
+bool HeaterRestarted[HEATER_TYPE_MAX_HEATERS] = {false,false,false,false,false,false,false,false,false,false};
 uint32_t  HeaterCommandRequestMessage(int HeaterId, bool OnOff, int Temperature)
 {
     //uint32_t status = NOT_SUPPORTED;
@@ -455,7 +467,7 @@ uint32_t  HeaterCommandRequestMessage(int HeaterId, bool OnOff, int Temperature)
     }
 //    Turn_the_Blower_On();
 
-    if (HeaterId< MAX_HEATERS_NUM)
+    if (HeaterId< HEATER_TYPE_MAX_HEATERS)
     {
         if (HeaterControl[HeaterId].id != HeaterId) // heater configuration missing
         {
@@ -466,10 +478,6 @@ uint32_t  HeaterCommandRequestMessage(int HeaterId, bool OnOff, int Temperature)
         HeaterCmd[HeaterId].command = OnOff;
         HeaterCmd[HeaterId].targettemperatue = Temperature*100;
     }
-#ifdef DEMO_TEMPERATURE
-    if (OnOff == false)
-        HeaterTestActive[HeaterId] = false;
-#endif
     bool HeaterState;
     if ( ControlIdtoHeaterId [HeaterId] == 0xFF)
     {
@@ -540,13 +548,13 @@ void PrepareACHeater(int HeaterId,uint32_t Frequency, uint32_t SetTemperatue)
         //HeaterPreviousRead[HeaterId] = MillisecGetTemperatures(DryerInternalPT100Id);
         HeaterPreviousRead[HeaterId] = MillisecGetTemperatures(HeaterId2PT100Id[HeaterId]);//
         //ReportWithPackageFilter(HeatersFilter,"PrepareHeater AC Read", __FILE__,HeaterId, SetTemperatue, RpWarning,HeaterPreviousRead[HeaterId], 0);
-        HeaterPreviousRead[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] =  MillisecGetTemperatures(HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain]);//MillisecGetTemperatures(HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain]);
-        HeaterPreviousRead[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]  = MillisecGetTemperatures(HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]);// = MillisecGetTemperatures(HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]);
-        if((HeaterPreviousRead[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain]<=MINIMUM_HEATER_READ*100)||(MAXIMUM_HEATER_READ*100<=HeaterPreviousRead[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain])||
-           (HeaterPreviousRead[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]<=MINIMUM_HEATER_READ*100)||(MAXIMUM_HEATER_READ*100<=HeaterPreviousRead[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]))
+        HeaterPreviousRead[HEATER_TYPE__DryerMainHeater] =  MillisecGetTemperatures(HeaterId2PT100Id[HEATER_TYPE__DryerMainHeater]);//MillisecGetTemperatures(HeaterId2PT100Id[HEATER_TYPE__DryerMainHeater]);
+        HeaterPreviousRead[HEATER_TYPE__DryerSecondaryHeater]  = MillisecGetTemperatures(HeaterId2PT100Id[HEATER_TYPE__DryerSecondaryHeater]);// = MillisecGetTemperatures(HeaterId2PT100Id[HEATER_TYPE__DryerSecondaryHeater]);
+        if((HeaterPreviousRead[HEATER_TYPE__DryerMainHeater]<=MINIMUM_HEATER_READ*100)||(MAXIMUM_HEATER_READ*100<=HeaterPreviousRead[HEATER_TYPE__DryerMainHeater])||
+           (HeaterPreviousRead[HEATER_TYPE__DryerSecondaryHeater]<=MINIMUM_HEATER_READ*100)||(MAXIMUM_HEATER_READ*100<=HeaterPreviousRead[HEATER_TYPE__DryerSecondaryHeater]))
         {
-            ReportWithPackageFilter(HeatersFilter,"PT100 not working properly",__FILE__,__LINE__,HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain,RpError, HeaterPreviousRead[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain],0);
-            ReportWithPackageFilter(HeatersFilter,"PT100 not working properly",__FILE__,__LINE__,HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary,RpError, HeaterPreviousRead[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary],0);
+            ReportWithPackageFilter(HeatersFilter,"PT100 not working properly",__FILE__,__LINE__,HEATER_TYPE__DryerMainHeater,RpError, HeaterPreviousRead[HEATER_TYPE__DryerMainHeater],0);
+            ReportWithPackageFilter(HeatersFilter,"PT100 not working properly",__FILE__,__LINE__,HEATER_TYPE__DryerSecondaryHeater,RpError, HeaterPreviousRead[HEATER_TYPE__DryerSecondaryHeater],0);
             if (ControlIdtoMaxHeaterId [HeaterId] != 0xFF)
             {
                 RemoveControlCallback(ControlIdtoMaxHeaterId [HeaterId], DcHeaterMaxTempCBFunction);
@@ -571,8 +579,8 @@ void PrepareACHeater(int HeaterId,uint32_t Frequency, uint32_t SetTemperatue)
         ReportWithPackageFilter(HeatersFilter,"PrepareACHeater control still running",__FILE__,HeaterId,ControlIdtoHeaterId [HeaterId],RpError, HeaterCmd[HeaterId].targettemperatue,0);
         HeaterPreviousRead[HeaterId] = MillisecGetTemperatures(HeaterId2PT100Id[HeaterId]);//
         //ReportWithPackageFilter(HeatersFilter,"PrepareHeater AC Read", __FILE__,HeaterId, SetTemperatue, RpWarning,HeaterPreviousRead[HeaterId], 0);
-        HeaterPreviousRead[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] =  MillisecGetTemperatures(HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain]);//MillisecGetTemperatures(HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain]);
-        HeaterPreviousRead[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]  = MillisecGetTemperatures(HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]);// = MillisecGetTemperatures(HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]);
+        HeaterPreviousRead[HEATER_TYPE__DryerMainHeater] =  MillisecGetTemperatures(HeaterId2PT100Id[HEATER_TYPE__DryerMainHeater]);//MillisecGetTemperatures(HeaterId2PT100Id[HEATER_TYPE__DryerMainHeater]);
+        HeaterPreviousRead[HEATER_TYPE__DryerSecondaryHeater]  = MillisecGetTemperatures(HeaterId2PT100Id[HEATER_TYPE__DryerSecondaryHeater]);// = MillisecGetTemperatures(HeaterId2PT100Id[HEATER_TYPE__DryerSecondaryHeater]);
 
     }
     //turn all alarms off
@@ -583,15 +591,15 @@ void PrepareACHeater(int HeaterId,uint32_t Frequency, uint32_t SetTemperatue)
     if (ControlIdtoMaxHeaterId [HeaterId] == 0xFF)
         ControlIdtoMaxHeaterId [HeaterId] = AddControlCallback("HeatersMax", DcHeaterMaxTempCBFunction, eOneSecond,MillisecGetTemperatures,(IfTypeHeaters*0x100+HeaterId),HeaterId2PT100Id[HeaterId],0);
 
-    Enable_Reading_Heaters_Current(HeaterId2CurrentId[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain]);
-    Enable_Reading_Heaters_Current(HeaterId2CurrentId[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]);
+    Enable_Reading_Heaters_Current(HeaterId2CurrentId[HEATER_TYPE__DryerMainHeater]);
+    Enable_Reading_Heaters_Current(HeaterId2CurrentId[HEATER_TYPE__DryerSecondaryHeater]);
 
-    HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain, 0);
-    HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary, 0);
+    HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerMainHeater, 0);
+    HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerSecondaryHeater, 0);
     if (MainDryerHeaterMaxTempControl == 0xFF)
-        MainDryerHeaterMaxTempControl = AddControlCallback("HeatersMax", HeaterMaxTempCBFunction, eOneSecond,MillisecGetTemperatures,(IfTypeHeaters*0x100+HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain),HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain],0);
+        MainDryerHeaterMaxTempControl = AddControlCallback("HeatersMax", HeaterMaxTempCBFunction, eOneSecond,MillisecGetTemperatures,(IfTypeHeaters*0x100+HEATER_TYPE__DryerMainHeater),HeaterId2PT100Id[HEATER_TYPE__DryerMainHeater],0);
     if (SecondDryerHeaterMaxTempControl == 0xFF)
-        SecondDryerHeaterMaxTempControl = AddControlCallback("HeatersMax", HeaterMaxTempCBFunction, eOneSecond,MillisecGetTemperatures,(IfTypeHeaters*0x100+HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary),HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary],0);
+        SecondDryerHeaterMaxTempControl = AddControlCallback("HeatersMax", HeaterMaxTempCBFunction, eOneSecond,MillisecGetTemperatures,(IfTypeHeaters*0x100+HEATER_TYPE__DryerSecondaryHeater),HeaterId2PT100Id[HEATER_TYPE__DryerSecondaryHeater],0);
     //InitialHeating = true;
     HeaterReady[HeaterId] = false;
     HeaterAtTemp[HeaterId] = false;
@@ -670,7 +678,7 @@ uint32_t PrepareHeater(int HeaterId, uint32_t SetTemperatue)
 {
     double temp ;
     CTRL_TIMING_ENUM Frequency = eOneSecond;
-    if(HeaterId >= MAX_HEATERS_NUM)
+    if(HeaterId >= HEATER_TYPE_MAX_HEATERS)
     {
         ReportWithPackageFilter(HeatersFilter,"HeaterId too high",__FILE__,__LINE__,HeaterId,RpError, 0,0);
         return ERROR;
@@ -720,7 +728,7 @@ uint32_t PrepareHeater(int HeaterId, uint32_t SetTemperatue)
         if (PrepareDCHeater(HeaterId,Frequency,SetTemperatue)!=OK)
             return ERROR;
     }
-    else if (HeaterId == HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature) //AC Heaters
+    else if (HeaterId == HEATER_TYPE__DryerAirHeater) //AC Heaters
     {
         PrepareACHeater(HeaterId,Frequency,SetTemperatue);
     }
@@ -729,7 +737,7 @@ uint32_t PrepareHeater(int HeaterId, uint32_t SetTemperatue)
 bool HeaterCheckReady(void)
 {
     int i;
-    for (i=0;i<MAX_HEATERS_NUM;i++)
+    for (i=0;i<HEATER_TYPE_MAX_HEATERS;i++)
     {
         if (HeaterAtTemp[i] == false)
         {
@@ -745,7 +753,7 @@ void HeaterPrepareReady(void)
     {
         return;
     }
-    for (i=0;i<MAX_HEATERS_NUM;i++)
+    for (i=0;i<HEATER_TYPE_MAX_HEATERS;i++)
     {
         if (HeaterAtTemp[i] == false)
         {
@@ -762,13 +770,13 @@ void HeaterPrepareReady(void)
  */
 bool HeaterGetOverTemperatureState(uint8_t HeaterId)
 {
-    if (HeaterId > MAX_HEATERS_NUM) return false;
+    if (HeaterId > HEATER_TYPE_MAX_HEATERS) return false;
     return HeaterMaxTempFlag[HeaterId];
 }
 uint32_t MainPT100Read = 0,SecondaryPT100Read = 0;
 uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue)
 {
-    int index=MAX_HEATERS_NUM;
+    int index=HEATER_TYPE_MAX_HEATERS;
     int32_t MaxreadValue;
 
     if (IfIndex>>8 != IfTypeHeaters)
@@ -777,7 +785,7 @@ uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue)
         return 0xFFFFFFFF;
     }
     index = IfIndex&0xFF;
-    if ((index != HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain)&&(index != HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary)) //AC Heaters
+    if ((index != HEATER_TYPE__DryerMainHeater)&&(index != HEATER_TYPE__DryerSecondaryHeater)) //AC Heaters
     {
         ReportWithPackageFilter(HeatersFilter, "Wrong  Interface ",__FILE__,__LINE__,IfIndex,RpError, 0,0);
         return 0xFFFFFFFF;
@@ -788,18 +796,18 @@ uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue)
     {
         ReportWithPackageFilter(HeatersFilter,"Temperature Spike",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index);
         HeaterMaxTempFlag[index] = true;
-        DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
-        HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain,0);
-        DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
-        HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary,0);
+        DeActivateHeater(HEATER_TYPE__DryerMainHeater);
+        HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerMainHeater,0);
+        DeActivateHeater(HEATER_TYPE__DryerSecondaryHeater);
+        HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerSecondaryHeater,0);
         return ERROR;
     }
     HeaterPreviousRead[index] = readValue;
-    if (index == HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain)
+    if (index == HEATER_TYPE__DryerMainHeater)
     {
         MainPT100Read = readValue;
     }
-    if (index == HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary)
+    if (index == HEATER_TYPE__DryerSecondaryHeater)
     {
         SecondaryPT100Read = readValue;
     }
@@ -813,12 +821,12 @@ uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue)
             //LOG_ERROR (MaxreadValue/100, "Heater Over the max temperature, turned off");
             //ReportWithPackageFilter(HeatersFilter," AC Heater Over the max temperature, turned off",__FILE__,index,HeaterReady[index],RpWarning,HeaterControl[index].sensormaxvalue, 0);
         }
-        DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
+        DeActivateHeater(HEATER_TYPE__DryerMainHeater);
         HeaterMaxTempFlag[index] = true;
-        //HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain,0);
-        DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
-        //HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary] = true;
-        //HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary,0);
+        //HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerMainHeater,0);
+        DeActivateHeater(HEATER_TYPE__DryerSecondaryHeater);
+        //HeaterMaxTempFlag[HEATER_TYPE__DryerSecondaryHeater] = true;
+        //HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerSecondaryHeater,0);
         return OK;
     }
     if (MaxreadValue <= (HeaterControl[index].sensormaxvalue-HeaterControl[index].sensorminvalue)) //was MinreadValue
@@ -827,15 +835,15 @@ uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue)
         {
             if (HeaterMaxTempFlag[index] == true)
             {
-               /* ActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
-                if (HeaterReady[HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature]==false)
+               /* ActivateHeater(HEATER_TYPE__DryerMainHeater);
+                if (HeaterReady[HEATER_TYPE__DryerAirHeater]==false)
                 {
-                    ActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
+                    ActivateHeater(HEATER_TYPE__DryerSecondaryHeater);
                 }*/
                 //ReportWithPackageFilter(HeatersFilter, "Heater Cooled Off max temperature, turned on",__FILE__,__LINE__,(MinreadValue/100),RpError, 0,0);
             }
-            HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] = false;
-            HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary] = false;
+            HeaterMaxTempFlag[HEATER_TYPE__DryerMainHeater] = false;
+            HeaterMaxTempFlag[HEATER_TYPE__DryerSecondaryHeater] = false;
         }
         return OK;
     }
@@ -843,7 +851,7 @@ uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue)
 }
 uint32_t DcHeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue)
 {
-    int index=MAX_HEATERS_NUM;
+    int index=HEATER_TYPE_MAX_HEATERS;
     if (IfIndex>>8 != IfTypeHeaters)
     {
         ReportWithPackageFilter(HeatersFilter, "Wrong  Interface type",__FILE__,__LINE__,IfIndex,RpError, 0,0);
@@ -936,7 +944,7 @@ uint32_t DcHeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue)
 }
 uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
 {
-    int index=MAX_HEATERS_NUM;
+    int index=HEATER_TYPE_MAX_HEATERS;
     //uint8_t len = 0;
     if (IfIndex>>8 != IfTypeHeaters)
     {
@@ -944,18 +952,18 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
         return ERROR;
     }
     index = IfIndex&0xFF;
-    if (index != HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature) //AC Heaters
+    if (index != HEATER_TYPE__DryerAirHeater) //AC Heaters
     {
         ReportWithPackageFilter(HeatersFilter, "Wrong  Interface ",__FILE__,__LINE__,IfIndex,RpError, 0,0);
         return ERROR;
     }
     if (HeaterCmd[index].targettemperatue == 0)
     {
-        DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
-        DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
+        DeActivateHeater(HEATER_TYPE__DryerSecondaryHeater);
+        DeActivateHeater(HEATER_TYPE__DryerMainHeater);
         //Heaters OFF until coming into the proportional band
-        HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain,0);
-        HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary,0);
+        HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerMainHeater,0);
+        HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerSecondaryHeater,0);
         //ReportWithPackageFilter(HeatersFilter, "unconfigured",__FILE__,__LINE__,0,RpError, 0,0);
         return ERROR;
     }
@@ -964,20 +972,20 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
         ReportWithPackageFilter(HeatersFilter,"AC Temperature Spike",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index);
         if (readValue > HeaterCmd[index].targettemperatue)
         {
-            DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
-            DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
-            HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain,0);
-            HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary,0);
+            DeActivateHeater(HEATER_TYPE__DryerSecondaryHeater);
+            DeActivateHeater(HEATER_TYPE__DryerMainHeater);
+            HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerMainHeater,0);
+            HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerSecondaryHeater,0);
         }
         return ERROR;
     }
     if (HeaterDisasterCounter[index] >= DISASTER_COUNTER_LIMIT)
     {
         ReportWithPackageFilter(HeatersFilter,"AC Temperature disaster",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index);
-        DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
-        DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
-        HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain,0);
-        HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary,0);
+        DeActivateHeater(HEATER_TYPE__DryerSecondaryHeater);
+        DeActivateHeater(HEATER_TYPE__DryerMainHeater);
+        HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerMainHeater,0);
+        HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerSecondaryHeater,0);
         return ERROR;
     }
     HeaterPreviousRead[index] = readValue;
@@ -991,11 +999,11 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
     {
         if (readValue > ((HeaterCmd[index].targettemperatue * (100+HeaterControl[index].outputproportionalband))/100))
                 {
-                    DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
-                    DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
+                    DeActivateHeater(HEATER_TYPE__DryerSecondaryHeater);
+                    DeActivateHeater(HEATER_TYPE__DryerMainHeater);
                     //Heaters OFF until coming into the proportional band
-                    HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain,0);
-                    HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary,0);
+                    HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerMainHeater,0);
+                    HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerSecondaryHeater,0);
                     ReportWithPackageFilter(HeatersFilter, "AC OverHeat - turned off",__FILE__,readValue,HeaterReady[index],RpError, HeaterAtTemp[index],0);
                     return OK;
                 }
@@ -1003,12 +1011,12 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
         //if (readValue < (/*HeaterCmd[index].targettemperatue * AcHeatersLoweroperationLimit/1000*/HeaterCmd[index].targettemperatue-800))
         {
             //ReportWithPackageFilter(HeatersFilter,"AC Activating",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index);
-            if ((HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary] == false)&&(HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] == false))
+            if ((HeaterMaxTempFlag[HEATER_TYPE__DryerSecondaryHeater] == false)&&(HeaterMaxTempFlag[HEATER_TYPE__DryerMainHeater] == false))
             {
-                ActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
-                ActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
-                HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain,100);
-                HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary,100);
+                ActivateHeater(HEATER_TYPE__DryerSecondaryHeater);
+                ActivateHeater(HEATER_TYPE__DryerMainHeater);
+                HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerMainHeater,100);
+                HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerSecondaryHeater,100);
             }
             return OK;
         }
@@ -1018,8 +1026,8 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
 //////////////////
             ReportWithPackageFilter(HeatersFilter,"AC Turn Off secondary",__FILE__,__LINE__,readValue,RpWarning,(HeaterCmd[index].targettemperatue), 0);
             //InitialHeating = false;
-            DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
-            HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary, 0);
+            DeActivateHeater(HEATER_TYPE__DryerSecondaryHeater);
+            HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerSecondaryHeater, 0);
             HeatersControlStart();
 ////////////////////////
 
@@ -1039,8 +1047,8 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
         {
             //InitialHeating = false;
             ReportWithPackageFilter(HeatersFilter,"AC PID Activating",__FILE__,__LINE__,readValue,RpWarning,(HeaterCmd[index].targettemperatue), 0);
-            DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
-            HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary, 0);
+            DeActivateHeater(HEATER_TYPE__DryerSecondaryHeater);
+            HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerSecondaryHeater, 0);
             HeatersControlStart();
             AlarmHandlingSetAlarm(HeaterUnderEventType[index], false);
             if (BlowerCfg.enabled == true)
@@ -1051,8 +1059,8 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
                     Control_Voltage_To_Blower(BlowerCfg.voltage);
             }
             HeaterReady[index] = true;
-            Disable_Reading_Heaters_Current(HeaterId2CurrentId[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain]);
-            Disable_Reading_Heaters_Current(HeaterId2CurrentId[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]);
+            Disable_Reading_Heaters_Current(HeaterId2CurrentId[HEATER_TYPE__DryerMainHeater]);
+            Disable_Reading_Heaters_Current(HeaterId2CurrentId[HEATER_TYPE__DryerSecondaryHeater]);
 
         }
         return OK;
@@ -1074,12 +1082,12 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
         {
             if (readValue < ((HeaterCmd[index].targettemperatue * (100-HeaterControl[index].outputproportionalband))/100)) //below proportional band
             {
-                HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain, 100);
+                HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerMainHeater, 100);
                 //REPORT_MSG (readValue,"AC HEATER Over temperature");
             }
             else if (readValue > ((HeaterCmd[index].targettemperatue * (100+HeaterControl[index].outputproportionalband))/100))
             {
-                HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain, 0);
+                HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerMainHeater, 0);
                 //REPORT_MSG (readValue,"AC HEATER Under temperature");
             }
         }
@@ -1115,12 +1123,12 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
             //        #warning PID is now only proportional (above)
 //             ReportWithPackageFilter(HeatersFilter,ACheatstr,__FILE__,__LINE__,index,RpWarning,readValue,  HeaterPIDConfig[index].m_calculatedError);
             //ReportWithPackageFilter(HeatersFilter,"AC PID",__FILE__,__LINE__,HeaterPIDConfig[index].m_calculatedError/100,RpWarning,readValue, index);
-            if (HeaterRestarted[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] == true)
+            if (HeaterRestarted[HEATER_TYPE__DryerMainHeater] == true)
             {
-                ReportWithPackageFilter(HeatersFilter,"Restarting same temperature Heater Temp",__FILE__,HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain,HeaterPIDConfig[index].m_calculatedError,RpWarning,readValue,  0);
-                HeaterRestarted[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] = false;
+                ReportWithPackageFilter(HeatersFilter,"Restarting same temperature Heater Temp",__FILE__,HEATER_TYPE__DryerMainHeater,HeaterPIDConfig[index].m_calculatedError,RpWarning,readValue,  0);
+                HeaterRestarted[HEATER_TYPE__DryerMainHeater] = false;
             }
-            HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain, (int)(HeaterPIDConfig[index].m_calculatedError/100));
+            HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerMainHeater, (int)(HeaterPIDConfig[index].m_calculatedError/100));
         }
     }
 
@@ -1132,17 +1140,17 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
  * called by: Communication from host
  * initialized all global data
  */
-//float error[HARDWARE_PID_CONTROL_TYPE__MixerHeater][100];
-//float integral[HARDWARE_PID_CONTROL_TYPE__MixerHeater][100];
-//float output[HARDWARE_PID_CONTROL_TYPE__MixerHeater][100];
-//int Counter[HARDWARE_PID_CONTROL_TYPE__MixerHeater] = {0,0,0,0,0,0,0};
-//char logmsg[HARDWARE_PID_CONTROL_TYPE__MixerHeater][254];
+//float error[HEATER_TYPE__HeadCoverHeater2][100];
+//float integral[HEATER_TYPE__HeadCoverHeater2][100];
+//float output[HEATER_TYPE__HeadCoverHeater2][100];
+//int Counter[HEATER_TYPE__HeadCoverHeater2] = {0,0,0,0,0,0,0};
+//char logmsg[HEATER_TYPE__HeadCoverHeater2][254];
 char heatstr[100];
 //float temp_calculatedError=0,temp_preError = 0, temp_integral = 0;
 
 uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
 {
-    int index=MAX_HEATERS_NUM;
+    int index=HEATER_TYPE_MAX_HEATERS;
     //int len;
    //uint8_t len = 0;
     if (IfIndex>>8 != IfTypeHeaters)
@@ -1330,13 +1338,13 @@ void EightMilliSecondHeatersInterrupt(UArg arg0)
     return ;
 }
 
-int HeaterDisasterTemp[HARDWARE_PID_CONTROL_TYPE__MixerHeater+1] = {28000,28000,28000,17000,17000,17000,17000,17000,17000,11000};
-//int HeaterDisasterTemp[HARDWARE_PID_CONTROL_TYPE__MixerHeater+1] = {8100,8100,8200,8100,8100,8100,8100,8100,8100,8100};
+int HeaterDisasterTemp[HEATER_TYPE__HeadCoverHeater2+1] = {28000,28000,28000,17000,17000,17000,17000,17000,17000,11000,17000,17000,17000,17000,17000,17000,17000,17000};
+//int HeaterDisasterTemp[HEATER_TYPE__HeadCoverHeater2+1] = {8100,8100,8200,8100,8100,8100,8100,8100,8100,8100};
 uint32_t HeatersDisasterControl(uint32_t x,uint32_t y)
 {
     int HeaterId,temperature;
 
-    for ( HeaterId = HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature; HeaterId<= HARDWARE_PID_CONTROL_TYPE__MixerHeater;HeaterId++)
+    for ( HeaterId = HEATER_TYPE__DryerAirHeater; HeaterId<= HEATER_TYPE__HeadCoverHeater2;HeaterId++)
     {
         temperature = MillisecGetTemperatures(HeaterId2PT100Id[HeaterId]);
         if (temperature>=HeaterDisasterTemp[HeaterId])
@@ -1370,63 +1378,63 @@ uint32_t HeatersControlLoop(uint32_t tick)
                     ,SliceCounter,TimeSliceAllocation[SliceCounter],HeatersRestart,NumberOFSlicesInUse);
     ReportWithPackageFilter(HeatersFilter,str, __FILE__,__LINE__,0, RpMessage, SliceCounter, TimeSliceAllocation[SliceCounter]);
 */
-    if (HeaterDisasterCounter[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] >= DISASTER_COUNTER_LIMIT)
+    if (HeaterDisasterCounter[HEATER_TYPE__DryerMainHeater] >= DISASTER_COUNTER_LIMIT)
     {
-        DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
-        DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
+        DeActivateHeater (HEATER_TYPE__DryerMainHeater);
+        DeActivateHeater (HEATER_TYPE__DryerSecondaryHeater);
         AcHeaterDisaster = true;
     }
-    if (HeaterDisasterCounter[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary] >= DISASTER_COUNTER_LIMIT)
+    if (HeaterDisasterCounter[HEATER_TYPE__DryerSecondaryHeater] >= DISASTER_COUNTER_LIMIT)
     {
-        DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
-        DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
+        DeActivateHeater (HEATER_TYPE__DryerMainHeater);
+        DeActivateHeater (HEATER_TYPE__DryerSecondaryHeater);
         AcHeaterDisaster = true;
     }
 
 
     if (AcHeaterDisaster == false)
     {
-        if (HeaterReady[HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature] == true)
+        if (HeaterReady[HEATER_TYPE__DryerAirHeater] == true)
         {
-            if (TimeSliceAllocation[SliceCounter] == HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain)
+            if (TimeSliceAllocation[SliceCounter] == HEATER_TYPE__DryerMainHeater)
             {
-                if (HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] == false)
+                if (HeaterMaxTempFlag[HEATER_TYPE__DryerMainHeater] == false)
                 {
-                    //If HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain should be active
-                    //Activate HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain
-                    ActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
-                    //DeActivate HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary
-                    //DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
+                    //If HEATER_TYPE__DryerMainHeater should be active
+                    //Activate HEATER_TYPE__DryerMainHeater
+                    ActivateHeater (HEATER_TYPE__DryerMainHeater);
+                    //DeActivate HEATER_TYPE__DryerSecondaryHeater
+                    //DeActivateHeater (HEATER_TYPE__DryerSecondaryHeater);
                 }
-                if (HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary] == false)
+                if (HeaterMaxTempFlag[HEATER_TYPE__DryerSecondaryHeater] == false)
                 {
 #warning trial use both heaters in drier
-                    ActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
-                    //DeActivate HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary
-                    //DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
+                    ActivateHeater (HEATER_TYPE__DryerSecondaryHeater);
+                    //DeActivate HEATER_TYPE__DryerSecondaryHeater
+                    //DeActivateHeater (HEATER_TYPE__DryerSecondaryHeater);
                 }
             }
-            /*else if (TimeSliceAllocation[SliceCounter] == HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary)
+            /*else if (TimeSliceAllocation[SliceCounter] == HEATER_TYPE__DryerSecondaryHeater)
             {
-                if (HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary] == false)
+                if (HeaterMaxTempFlag[HEATER_TYPE__DryerSecondaryHeater] == false)
                 {
-                    //DeActivate HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain
-                    DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
-                    //If HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary should be active
-                    //Activate HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary
-                    ActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
+                    //DeActivate HEATER_TYPE__DryerMainHeater
+                    DeActivateHeater (HEATER_TYPE__DryerMainHeater);
+                    //If HEATER_TYPE__DryerSecondaryHeater should be active
+                    //Activate HEATER_TYPE__DryerSecondaryHeater
+                    ActivateHeater (HEATER_TYPE__DryerSecondaryHeater);
                 }
             }*/
             else
             {
-                    //DeActivate HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain
-                    DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
-                    //DeActivate HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary
-                    DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
+                    //DeActivate HEATER_TYPE__DryerMainHeater
+                    DeActivateHeater (HEATER_TYPE__DryerMainHeater);
+                    //DeActivate HEATER_TYPE__DryerSecondaryHeater
+                    DeActivateHeater (HEATER_TYPE__DryerSecondaryHeater);
             }
         }
     }
-    for ( DcHeaterId = HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1; DcHeaterId<= HARDWARE_PID_CONTROL_TYPE__MixerHeater;DcHeaterId++)
+    for ( DcHeaterId = HEATER_TYPE__HeaterZone1; DcHeaterId<= HEATER_TYPE__HeaterZone12;DcHeaterId++)
     {
         if (HeaterDisasterCounter[DcHeaterId] >= DISASTER_COUNTER_LIMIT)
         {
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h b/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h
index eba93d445..41e729b9b 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h
@@ -14,11 +14,11 @@ extern uint32_t DispenserPrepareTimeout ;
 extern uint32_t DispenserPrepareTimeLag ;
 extern uint32_t InitialDispenserSpeed;
 
-extern int32_t CurrentDispenserSpeed[MAX_SYSTEM_DISPENSERS];
 extern uint32_t DispenserIdToMotorId[MAX_SYSTEM_DISPENSERS];
 extern float DispenserPressure[MAX_SYSTEM_DISPENSERS];
 uint32_t DispenserConfigMessage(HardwareDispenser * request);
 
+
 extern HardwareDispenser DispensersCfg[ MAX_SYSTEM_DISPENSERS];
 
 extern bool DispensersAlarmState[ MAX_SYSTEM_DISPENSERS];
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h
index 9074f867a..8c0fbba1e 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h
@@ -47,6 +47,8 @@ extern DispenserData IDSDispenserData;
 extern DispenserRunningData **dispenserdata;
 
 extern bool         DispenserUsedInJob[MAX_SYSTEM_DISPENSERS];
+extern int32_t CurrentDispenserSpeed[MAX_SYSTEM_DISPENSERS];
+
 bool IDS_MapDispenserUsedinJob(void *JobDetails);
 
 void IDS_ModuleInit (void);
@@ -102,4 +104,7 @@ float GetDispenserPressure(int DispenserId);
 int32_t IdsGetMotorSpeed(uint32_t DispenserId);
 void DispenserDataRequestFunc(MessageContainer* requestContainer);
 
+void IDS_Start_Pid_Testing(int DispenserId);
+void IDS_Stop_Pid_Testing(int DispenserId);
+
 #endif /* MODULES_IDS_IDS_EX_H_ */
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
index 7815ea847..3b55758e4 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
@@ -41,6 +41,7 @@ typedef struct
     PID_Config_Params   m_params;
 }DispenserControlConfig_t;
 HardwarePidControl *DispensersControl;
+HardwarePidControl DispensersCtrl[MAX_SYSTEM_DISPENSERS];
 #define MAX_DYE_DISPENSERS 6
 int32_t DispenserSamples[MAX_SYSTEM_DISPENSERS][MAX_CONTROL_SAMPLES] = {0};
 int DispenserSamplePointer[MAX_SYSTEM_DISPENSERS] = {0};
@@ -117,6 +118,8 @@ int lInterSegmentLength = 0;
 uint32_t IDS_DispenserControlInit()
 {
     DispensersControl = (void *)(DISPENSERS_MAP_IN_FLASH);
+    DispensersControl = DispensersCtrl;
+
     //EraseFlashSection(DispensersControl,sizeof(HardwarePidControl)*MAX_SYSTEM_DISPENSERS);
     return OK;
 }
@@ -133,20 +136,59 @@ uint32_t IDS_DispenserPidRequestMessage(HardwarePidControl* request)
             break;
         }
     }
-    if (request->pvinputfilterfactormode > MAX_CONTROL_SAMPLES)
-        request->pvinputfilterfactormode = MAX_CONTROL_SAMPLES;
+    memcpy (&DispensersCtrl[Dispenser_i],request,sizeof(HardwarePidControl));
+
     //ReadAppAndProgram(&DispensersControl[Dispenser_i], sizeof(HardwarePidControl), request);
 
     for (i = 0;i < DispensersControl[Dispenser_i].pvinputfilterfactormode; i++)
         DispenserSamples[Dispenser_i][i] = 0;  //reset the samples value for control beginning
-    /*DispenserNormalizedErrorCoEfficient[Dispenser_i] = (2*PI*DancersCfg[ThreadDispenserIdToDancerId[Dispenser_i]].armlength);
-    temp = 1<<(DancersCfg[ThreadDispenserIdToDancerId[Dispenser_i]].resolutionbits);
-    temp=(100*(temp-1)*DancersCfg[ThreadDispenserIdToDancerId[Dispenser_i]].maximalmovementmm);
-    DispenserNormalizedErrorCoEfficient[Dispenser_i] = DispenserNormalizedErrorCoEfficient[Dispenser_i] / temp;*/
+
+    DispenserControlConfig[Dispenser_i].m_params.MAX = 1;
+    DispenserControlConfig[Dispenser_i].m_params.MIN = DispensersCtrl[Dispenser_i].outputproportionalpowerlimit*-1;
+    DispenserControlConfig[Dispenser_i].m_params.Kd = DispensersCtrl[Dispenser_i].derivativetime;
+    DispenserControlConfig[Dispenser_i].m_params.Kp = DispensersCtrl[Dispenser_i].proportionalgain;
+    DispenserControlConfig[Dispenser_i].m_params.Ki = DispensersCtrl[Dispenser_i].integraltime;
+    DispenserControlConfig[Dispenser_i].m_params.IntegralErrorMultiplier = DispensersCtrl[Dispenser_i].setpointramprateorsoftstartramp;
+    DispenserControlConfig[Dispenser_i].m_params.ProportionalErrorMultiplier = DispensersCtrl[Dispenser_i].outputonoffhysteresisvalue;
+    DispenserControlConfig[Dispenser_i].m_params.epsilon = DispensersCtrl[Dispenser_i].epsilon;
+    DispenserControlConfig[Dispenser_i].m_params.dt = DispensersCtrl[Dispenser_i].controloutputtype;
+    //DispenserControlConfig[Dispenser_i].m_ingnoreValue =  DispensersCtrl[Dispenser_i].sensorcorrectionadjustment; // the minimal change required to change the motor speed in pulses
+    DispenserControlConfig[Dispenser_i].m_calculatedError = 0;
+    DispenserControlConfig[Dispenser_i].m_integral = 0;
+    DispenserControlConfig[Dispenser_i].m_isEnabled = true;
+    DispenserControlConfig[Dispenser_i].m_isReady = true;
+    DispenserControlConfig[Dispenser_i].m_mesuredParam = 0;
+    DispenserControlConfig[Dispenser_i].m_preError = 0;
+    DispenserControlConfig[Dispenser_i].m_SetParam = 1.65;//need to update SetParams on presegment stage
+
 
     return OK;
 }
+uint32_t DispenserPidControlId[MAX_SYSTEM_DISPENSERS] = {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF};
+uint32_t IDS_Pid_Testing_Func(uint32_t DispenserId, uint32_t ReadValue)
+{
+    float calculated_speed;
+    DispenserControlConfig[DispenserId].m_mesuredParam = MillisecGetPressures(DispenserId);
+    DispenserControlConfig[DispenserId].m_calculatedError = AdvancedPIDAlgorithmCalculation((float)DispenserControlConfig[DispenserId].m_SetParam , (float)DispenserControlConfig[DispenserId].m_mesuredParam,
+                                                      &DispenserControlConfig[DispenserId].m_params,   &DispenserControlConfig[DispenserId].m_preError, &DispenserControlConfig[DispenserId].m_integral);
+    DispenserControlConfig[DispenserId].m_calculatedError = (-1*DispenserControlConfig[DispenserId].m_calculatedError);
+    calculated_speed = (1-DispenserControlConfig[DispenserId].m_calculatedError)*CurrentDispenserSpeed[DispenserId];
+    Report("IDS_Pid_Testing_Func ",__FILE__,DispenserId,(int)(DispenserControlConfig[DispenserId].m_mesuredParam*1000),RpWarning,(int)calculated_speed,0);
 
+    return OK;
+}
+void IDS_Start_Pid_Testing(int DispenserId)
+{
+    DispenserPidControlId[DispenserId] = AddControlCallback(NULL, IDS_Pid_Testing_Func,eOneSecond , TemplateDataReadCBFunction,DispenserId,DispenserId, DispenserId );
+    Report("IDS_Start_Pid_Testing ",__FILE__,__LINE__,DispenserId,RpWarning,(int)DispenserPidControlId[DispenserId],0);
+}
+void IDS_Stop_Pid_Testing(int DispenserId)
+{
+    //stop this control loop
+    RemoveControlCallback(DispenserPidControlId[DispenserId], IDS_Pid_Testing_Func );
+    DispenserPidControlId[DispenserId] = 0xFF;
+    Report("IDS_Stop_Pid_Testing ",__FILE__,__LINE__,DispenserId,RpWarning,(int)DispenserPidControlId[DispenserId],0);
+}
 /*
  * IDS Printing support
  * Prepare: build pressure in all participating dispensers
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
index b16ba8b9e..77edc45b5 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
@@ -154,6 +154,7 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
     else
     if((request->amount == 0xDD) && (request->delay == 0xDD)) //Read Input Voltage
     {
+        LOG_ERROR(request->delay,"CheckAcInputVoltage");
        CheckAcInputVoltage();
 
        response.progress = (double)Input_Voltage;
@@ -162,6 +163,7 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
     else
     if((request->amount == 0x0CE) && (request->delay == 0x0CE)) //Get Gas Sensor
     {
+        LOG_ERROR(request->delay,"FlashInitAndLoad");
         FlashInitAndLoad();
         response.progress = (double)OK;
         response.has_progress = true;
@@ -170,6 +172,7 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
     else
     if(request->amount == 0x0CC)  //Cùøàøïâò÷ Vùêïâùàïíî ø÷ãôíîã÷
     {
+        LOG_ERROR(request->delay,"ResponseDemo");
 		ResponseDemo(request->delay);
         response.progress = (double)OK;
         response.has_progress = true;
@@ -178,12 +181,32 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
     else
     if(request->amount == 0xE0)  //fast refresh for pressure
     {
+        LOG_ERROR(request->delay,"setRapidPressureRead");
         setRapidPressureRead(request->delay);
         response.progress = (double)OK;
         response.has_progress = true;
 
     }
-    else     if((request->amount == 0xDF) && (request->delay == 0xDF)) //Power off
+    else
+    if(request->amount == 0xE1)  //fast refresh for pressure
+    {
+        LOG_ERROR(request->delay,"Starting Dispenser PID");
+        IDS_Start_Pid_Testing(request->delay);
+        response.progress = (double)OK;
+        response.has_progress = true;
+
+    }
+    else
+    if(request->amount == 0xE2)  //fast refresh for pressure
+    {
+        LOG_ERROR(request->delay,"Stoping Dispenser PID");
+        IDS_Stop_Pid_Testing(request->delay);
+        response.progress = (double)OK;
+        response.has_progress = true;
+
+    }
+    else
+    if((request->amount == 0xDF) && (request->delay == 0xDF)) //Power off
     {
         PowerOffInit();
     }
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Motor.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Motor.c
index 701c7b1fc..2baa6bb2d 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Motor.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Motor.c
@@ -41,6 +41,7 @@
 #include "driverlib/ssi.h"
 #include "drivers/SPI/SPI_Comm.h"
 #include "Modules/Thread/Thread_ex.h"
+#include "Modules/Ids/Ids_ex.h"
 
 
 #include "Modules/thread/thread.h"
@@ -209,6 +210,14 @@ void Stub_MotorRunRequest(MessageContainer* requestContainer)
 
     MotorSetDirection(Motor_Id,Direction);
     MotorSetSpeed(Motor_Id, Run_Value);
+    if ((Motor_Id >= HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1)&&(Motor_Id <= HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8))
+    {
+        CurrentDispenserSpeed[Motor_Id-HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1] = Run_Value;
+        if(request->direction == 0)
+            CurrentDispenserSpeed[Motor_Id-HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1] *= (-1);
+
+    }
+
 #endif
 
 
@@ -278,6 +287,10 @@ void Stub_MotorStopRequest(MessageContainer* requestContainer)
     TimerMotors_t Motor_Id  = (TimerMotors_t)request->motor_id; //to remove warning
     MotorStop(Motor_Id, Stop_Command);
 #endif
+    if ((Motor_Id >= HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1)&&(Motor_Id <= HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8))
+    {
+        CurrentDispenserSpeed[Motor_Id-HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1] = 0;
+    }
 
     //status = FPGA_ReadVersion((unsigned char)request->fpgaid, &Version, &Year, &Month, &Day);
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
index 4de702e14..4c4ab2bcc 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
@@ -62,7 +62,7 @@ static uint32_t WindingConeLocation;
 static uint32_t WinderBackToBaseTime = 800;
 
 InternalWinderConfigStruc InternalWinderCfg = {0};
-#define READ_SCREW_ENCODER
+//#define READ_SCREW_ENCODER
 #ifdef READ_SCREW_ENCODER
 uint32_t ScrewLocationLimitSwitch = 0,ScrewLocationStart = 0;
 uint32_t ScrewLocationRun[3];
@@ -289,8 +289,8 @@ uint32_t Screw100msecDirectionChange(uint32_t deviceID, uint32_t BusyFlag)
 {
     //uint32_t Steps;
     double temp,tempScrewSpeed;
-    double screw_horizontal_speed = 0;
-    double RotationsPerSecond;
+    //double screw_horizontal_speed = 0;
+    //double RotationsPerSecond;
         if (WinderMotorSpeedCounter++>=MAX_WINDER_SPEED_CALCULATION)
         {
             if (WinderMotorSpeedRollOver == false)
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
index 9d408a4a6..c0d571fab 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
@@ -118,7 +118,7 @@ uint32_t Control_Delta_Position_Pass(uint32_t Current_Read,uint32_t Previous_Rea
   if (Current_Read < Previous_Read)
   {
     Time_Pass = (MAX_COUNTER - Previous_Read) + Current_Read + 1;
-    Report("Length rollover",__FILE__,__LINE__,(int)Current_Read,RpWarning,(int)Previous_Read,0);
+    ReportWithPackageFilter(ThreadFilter,"Length rollover",__FILE__,__LINE__,(int)Current_Read,RpWarning,(int)Previous_Read,0);
   }
   else
     Time_Pass = Current_Read - Previous_Read;
@@ -192,7 +192,7 @@ uint32_t ThreadLengthCBFunction(uint32_t IfIndex, uint32_t ReadValue)
         {
             usnprintf(Lenstr, 100, "length huge: length %d, diff 0x%x, pos 0x%x prev 0x%x",(int)length*100,(int)positionDiff,PreviousPosition,prevprev);
             SendJobProgress(0.0,0,false, Lenstr);
-            Report(Lenstr,__FILE__,__LINE__,(int)TotalProcessedLength,RpWarning,(int)PoolerTotalProcessedLength,0);
+            ReportWithPackageFilter(ThreadFilter,Lenstr,__FILE__,__LINE__,(int)TotalProcessedLength,RpWarning,(int)PoolerTotalProcessedLength,0);
             length = 0;
 
         }
@@ -224,7 +224,7 @@ uint32_t ThreadLengthCBFunction(uint32_t IfIndex, uint32_t ReadValue)
     {
         usnprintf(Lenstr, 100, "Total processed length: Feeder: %d Pooler %d",(int)TotalProcessedLength,(int)PoolerTotalProcessedLength);
         SendJobProgress(0.0,0,false, Lenstr);
-        Report(Lenstr,__FILE__,__LINE__,(int)TotalProcessedLength,RpWarning,(int)PoolerTotalProcessedLength,0);
+        ReportWithPackageFilter(ThreadFilter,Lenstr,__FILE__,__LINE__,(int)TotalProcessedLength,RpWarning,(int)PoolerTotalProcessedLength,0);
         // segment/intersegment/distance to spool finished
         if (ProcessedLengthFuncPtr)
             ProcessedLengthFuncPtr();
@@ -282,7 +282,7 @@ uint32_t PoolerThreadLengthCBFunction(uint32_t IfIndex, uint32_t ReadValue)
         {
             usnprintf(Lenstr, 100, "length huge: length %d, diff 0x%x, pos 0x%x prev 0x%x",(int)length*100,(int)positionDiff,PreviousPosition,prevprev);
             SendJobProgress(0.0,0,false, Lenstr);
-            Report(Lenstr,__FILE__,__LINE__,(int)TotalProcessedLength,RpWarning,(int)PoolerTotalProcessedLength,0);
+            ReportWithPackageFilter(ThreadFilter,Lenstr,__FILE__,__LINE__,(int)TotalProcessedLength,RpWarning,(int)PoolerTotalProcessedLength,0);
             length = 0;
 
         }
@@ -315,7 +315,7 @@ uint32_t PoolerThreadLengthCBFunction(uint32_t IfIndex, uint32_t ReadValue)
     {
         usnprintf(Lenstr, 100, "Total processed length: Feeder: %d Pooler %d",(int)TotalProcessedLength,(int)PoolerTotalProcessedLength);
         SendJobProgress(0.0,0,false, Lenstr);
-        Report(Lenstr,__FILE__,__LINE__,(int)TotalProcessedLength,RpWarning,(int)PoolerTotalProcessedLength,0);
+        ReportWithPackageFilter(ThreadFilter,Lenstr,__FILE__,__LINE__,(int)TotalProcessedLength,RpWarning,(int)PoolerTotalProcessedLength,0);
         // segment/intersegment/distance to spool finished
         if (ProcessedLengthFuncPtr)
             ProcessedLengthFuncPtr();
@@ -421,7 +421,7 @@ void testDancersControl()
     len = usnprintf(time, 150, "params: speed 50, divider %d p %d * %d i %d * %d Dt*1000 %d Norm Coef %d initial speed %d",NORMAL_COEF_DIVIDER,(int)MotorsControl[FEEDER_MOTOR].proportionalgain,(int)MotorsControl[FEEDER_MOTOR].outputonoffhysteresisvalue,
                     (int)MotorsControl[FEEDER_MOTOR].integraltime,(int)MotorsControl[FEEDER_MOTOR].setpointramprateorsoftstartramp,(int)(MotorsControl[FEEDER_MOTOR].controloutputtype*1000),
                     (int)(NormalizedErrorCoEfficient[FEEDER_MOTOR]*1000000000),OriginalMotorSpd_2PPS[FEEDER_MOTOR]);
-    Report(time,__FILE__,__LINE__,111,RpError,111,0);
+    ReportWithPackageFilter(ThreadFilter,time,__FILE__,__LINE__,111,RpError,111,0);
     Task_sleep(100);
     ThreadControlCBFunction(IfTypeThread*0x100+FEEDER_MOTOR, DancersCfg[HARDWARE_DANCER_TYPE__RightDancer].zeropoint - mm20);
     ThreadControlCBFunction(IfTypeThread*0x100+FEEDER_MOTOR, DancersCfg[HARDWARE_DANCER_TYPE__RightDancer].zeropoint - mm10);
@@ -478,7 +478,7 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
         if (ReadValue < 10)
         {
             MotorFailedSample[index]++;
-            Report("Dancer value read too small.",__FILE__,__LINE__,DancerId,RpError,ReadValue,0);
+            ReportWithPackageFilter(ThreadFilter,"Dancer value read too small.",__FILE__,__LINE__,DancerId,RpError,ReadValue,0);
             return OK;
         }
         if (ReadValue == 0x3FFF)
@@ -533,7 +533,7 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
                             SendSegmentFail();
                             //AlarmHandlingSetAlarm(EVENT_TYPE__THREAD_BREAK,true);
                             //EndState(CurrentJob,"ReadBreakSensor Error" );
-                            LOG_ERROR(index, "ReadBreakSensor Error");
+                            ReportWithPackageFilter(ThreadFilter,"ReadBreakSensor Error",__FILE__,BreakSensorCounter,(int)index,RpError,(int)JobCounter,0);
                             return OK;
                         } //passed limit
                     }//ReadBreakSensor()==ERROR
@@ -541,7 +541,7 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
                     {
                         if (BreakSensorCounter)
                         {
-                            LOG_ERROR(BreakSensorCounter, "ReadBreakSensor Spike");
+                            ReportWithPackageFilter(ThreadFilter,"ReadBreakSensor Spike",__FILE__,BreakSensorCounter,(int)index,RpError,(int)JobCounter,0);
                         }
                         BreakSensorCounter = 0;
                     }
@@ -559,7 +559,7 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
 	                        SendSegmentFail();
 	                        //AlarmHandlingSetAlarm(EVENT_TYPE__THREAD_BREAK,true);
 	                        //EndState(CurrentJob,"ReadBreakSensor Error" );
-	                        LOG_ERROR(index, "thread speed too low Error");
+                            ReportWithPackageFilter(ThreadFilter,"thread speed too low Error",__FILE__,BreakSensorCounter,(int)index,RpError,(int)JobCounter,0);
 	                        return OK;
 						}
                     }
@@ -573,7 +573,7 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
         {
             keepdata = false;
             usnprintf(TMessage, 60, "Dancer %d limit %d value %d Zero %d",DancerId,DancerStopActivityLimit[index],avreageSampleValue,DancersCfg[DancerId].zeropoint);
-            Report(TMessage,__FILE__,__LINE__,avreageSampleValue,RpWarning,DancerStopActivityLimit[index],0);
+            ReportWithPackageFilter(ThreadFilter,TMessage,__FILE__,__LINE__,avreageSampleValue,RpWarning,DancerStopActivityLimit[index],0);
             //JobAbortedByUser = true;
             ThreadControlActive = false;
             //MotorGetStatusFromFPGA(ThreadMotorIdToMotorId[index]);
@@ -593,7 +593,7 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
                     AlarmHandlingSetAlarm(EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_WINDER_DANCER,true);
                     break;
             }*/
-            LOG_ERROR (DancerId, "Dancer Failure");
+            ReportWithPackageFilter(ThreadFilter,"Dancer Failure",__FILE__,DancerId,(int)avreageSampleValue,RpError,(int)JobCounter,0);
             return OK;
         }
         NormalizedError = avreageSampleValue*NormalizedErrorCoEfficient[index];
@@ -613,7 +613,7 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
         {
             //if (index == WINDER_MOTOR) //feeder unit handles errors opposite to left unit
             //{
-              //  Report("MotorSpeedUpdated",__FILE__,index,OriginalMotorSpd_2PPS[index],RpWarning,CurrentControlledSpeed[index],0);
+              //  ReportWithPackageFilter(ThreadFilter,"MotorSpeedUpdated",__FILE__,index,OriginalMotorSpd_2PPS[index],RpWarning,CurrentControlledSpeed[index],0);
             //}
             /`*if (JobCounter >= 3000)
             {
@@ -624,7 +624,7 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
                 for (i=0;i<MAX_CONTROL_SAMPLES;i++)
                     avreageMotorSampleValue += MotorSpeedSamples[index][i];
                 avreageMotorSampleValue = avreageMotorSampleValue / MAX_CONTROL_SAMPLES;
-                //Report("MotorSpeedUpdated",__FILE__,index,OriginalMotorSpd_2PPS[index],RpWarning,avreageMotorSampleValue,0);
+                //ReportWithPackageFilter(ThreadFilter,"MotorSpeedUpdated",__FILE__,index,OriginalMotorSpd_2PPS[index],RpWarning,avreageMotorSampleValue,0);
                 OriginalMotorSpd_2PPS[index] = avreageMotorSampleValue;
             }*`/
         }*/
@@ -640,7 +640,7 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
             MotorSetSpeed(ThreadMotorIdToMotorId[index], calculated_speed);
             /*if (((JobCounter % 2000) == index*100)&&(index == WINDER_MOTOR)) //feeder unit handles errors opposite to left unit
             {
-                Report("MotorSpeedUpdated",__FILE__,index,(int)OriginalMotorSpd_2PPS[index],RpWarning,(int)CurrentControlledSpeed[index],0);
+                ReportWithPackageFilter(ThreadFilter,"MotorSpeedUpdated",__FILE__,index,(int)OriginalMotorSpd_2PPS[index],RpWarning,(int)CurrentControlledSpeed[index],0);
             }*/
 #ifdef TEST_PID_THREAD
             int len;
@@ -659,7 +659,7 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
                                 ReadValue,avreageSampleValue,(int)(MotorControlConfig[index].m_mesuredParam*1000000),
                                 (int)(MotorControlConfig[index].m_integral*1000000000),(int)((MotorControlConfig[index].m_mesuredParam*MotorControlConfig[index].m_params.dt)*1000000000),
                                 (int)(MotorControlConfig[index].m_calculatedError*1000),(int)calculated_speed);
-                Report(TMessage,__FILE__,__LINE__,DancerId,RpError,ReadValue,0);
+                ReportWithPackageFilter(ThreadFilter,TMessage,__FILE__,__LINE__,DancerId,RpError,ReadValue,0);
                 //Task_sleep(100);
                 //if (controlIndex++>=MAX_THREAD_CONTROL_LOG)
                 //    controlIndex = 0;
@@ -774,7 +774,7 @@ uint32_t ThreadInitialTestStub(HardwareMotor * request)
 
             if (Motor_i == FEEDER_MOTOR) // dryer motor is speed controlled. later a speed sensor will be utilized, but for now it will not be controlled
             {
-                Report("Feeder Control",__FILE__,Motor_i,MotorControlConfig[Motor_i].m_params.Kp,RpWarning,MotorControlConfig[Motor_i].m_params.Ki,0);
+                ReportWithPackageFilter(ThreadFilter,"Feeder Control",__FILE__,Motor_i,MotorControlConfig[Motor_i].m_params.Kp,RpWarning,MotorControlConfig[Motor_i].m_params.Ki,0);
                 if (SpeedControlId != 0xFF)
                 {
                     RemoveControlCallback(SpeedControlId,ThreadLengthCBFunction);
@@ -786,7 +786,7 @@ uint32_t ThreadInitialTestStub(HardwareMotor * request)
             }
             if (Motor_i == POOLER_MOTOR) // dryer motor is speed controlled. later a speed sensor will be utilized, but for now it will not be controlled
             {
-                Report("Puller Control",__FILE__,Motor_i,MotorControlConfig[Motor_i].m_params.Kp,RpWarning,MotorControlConfig[Motor_i].m_params.Ki,0);
+                ReportWithPackageFilter(ThreadFilter,"Puller Control",__FILE__,Motor_i,MotorControlConfig[Motor_i].m_params.Kp,RpWarning,MotorControlConfig[Motor_i].m_params.Ki,0);
                 if (PoolerSpeedControlId != 0xFF)
                 {
                     if (RemoveControlCallback(PoolerSpeedControlId,PoolerThreadLengthCBFunction)!=OK)
@@ -826,7 +826,7 @@ uint32_t ThreadInitialTestStub(HardwareMotor * request)
             }
             if (Motor_i == WINDER_MOTOR) // dryer motor is speed controlled. later a speed sensor will be utilized, but for now it will n//ot be controlled
             {
-                Report("Winder Control",__FILE__,Motor_i,MotorControlConfig[Motor_i].m_params.Kp,RpWarning,MotorControlConfig[Motor_i].m_params.Ki,0);
+                ReportWithPackageFilter(ThreadFilter,"Winder Control",__FILE__,Motor_i,MotorControlConfig[Motor_i].m_params.Kp,RpWarning,MotorControlConfig[Motor_i].m_params.Ki,0);
                 if (ControlIdtoMotorId[Motor_i] != 0xFF)
                 {
                     if(RemoveControlCallback(ControlIdtoMotorId[Motor_i],ThreadControlCBFunction)!=OK)
@@ -869,7 +869,7 @@ void SetOriginMotorSpeed(float process_speed)
         OriginalMotorSpd_2PPS[Motor_i] = (int) motor_speed;
         InitialDryerSpeed = 0.0;
         CurrentControlledSpeed[Motor_i] = (int) motor_speed;
-        //Report("Original Speed",__FILE__,Motor_i,motor_speed,RpWarning,process_speed,0);
+        //ReportWithPackageFilter(ThreadFilter,"Original Speed",__FILE__,Motor_i,motor_speed,RpWarning,process_speed,0);
 
         for (i = 0; i <= MAX_CONTROL_SAMPLES; i++)
             MotorSpeedSamples[Motor_i][i] = motor_speed;
@@ -881,8 +881,6 @@ void ThreadPreSegmentEnded(void)
     REPORT_MSG (0,"First ThreadPreSegmentEnded");
     PreSegmentReady(Module_Thread,ModuleDone);
 }
-#define DRYER_RAMPUP 1
-#ifdef DRYER_RAMPUP
 int DrierDivider = 10;
 uint32_t ThreadDryerRampUp(uint32_t IfIndex, uint32_t BusyFlag)
 {
@@ -895,12 +893,11 @@ uint32_t ThreadDryerRampUp(uint32_t IfIndex, uint32_t BusyFlag)
     }
 
     MotorSetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,InitialDryerSpeed );
-    Report("ThreadDryerRampUp",__FILE__,ControlIdtoMotorId[DRYER_MOTOR],(int)InitialDryerSpeed,RpWarning,(int)OriginalMotorSpd_2PPS[DRYER_MOTOR],0);
+    //ReportWithPackageFilter(ThreadFilter,"ThreadDryerRampUp",__FILE__,ControlIdtoMotorId[DRYER_MOTOR],(int)InitialDryerSpeed,RpWarning,(int)OriginalMotorSpd_2PPS[DRYER_MOTOR],0);
 
 
     return OK;
 }
-#endif
 
 //********************************************************************************************************************
 uint32_t ThreadPreSegmentState(void *SegmentDetails, uint32_t SegmentId)
@@ -922,16 +919,12 @@ uint32_t ThreadPreSegmentState(void *SegmentDetails, uint32_t SegmentId)
         PrepareState = false;
 #ifndef TEST_PID_THREAD
         // set the new speed in the dryer motor to the speed of the new segment
-#ifndef DRYER_RAMPUP
-        MotorSetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING, OriginalMotorSpd_2PPS[DRYER_MOTOR]);
-#else
         DrierDivider = dyeingspeed/5;  //ramp up drier in 5 cm/sec steps
-        Report("Drier ramp up",__FILE__,__LINE__,(int)dyeingspeed,RpWarning,(int)DrierDivider,0);
+        ReportWithPackageFilter(ThreadFilter,"Drier ramp up",__FILE__,__LINE__,(int)dyeingspeed,RpWarning,(int)DrierDivider,0);
         InitialDryerSpeed = OriginalMotorSpd_2PPS[DRYER_MOTOR]/DrierDivider;
         MotorSetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,InitialDryerSpeed );
         ControlIdtoMotorId[DRYER_MOTOR] = AddControlCallback("DryerRampUp",ThreadDryerRampUp, 200,TemplateDataReadCBFunction,0,0,0);
 #endif
-#endif
 #ifdef HUNDRED_MICROSECONDS_DANCER_READ
      MillisecLogInit();
 #endif
@@ -1051,7 +1044,7 @@ char Endstr[150];
 
      usnprintf(Endstr, 100, "Total _processed length: Feeder: %d Pooler %d",(int)TotalProcessedLength,(int)PoolerTotalProcessedLength);
      SendJobProgress(0.0,0,false, Endstr);
-     Report(Endstr,__FILE__,__LINE__,(int)TotalProcessedLength,RpWarning,(int)PoolerTotalProcessedLength,0);
+     ReportWithPackageFilter(ThreadFilter,Endstr,__FILE__,__LINE__,(int)TotalProcessedLength,RpWarning,(int)PoolerTotalProcessedLength,0);
 
      ThreadUpdateProcessLength (0.0,(void *)NULL);
      //TotalProcessedLength = 0.0;
diff --git a/Software/Embedded_SW/Embedded/StateMachines/Printing/PrintingSTM.c b/Software/Embedded_SW/Embedded/StateMachines/Printing/PrintingSTM.c
index 710876e4a..671ab1dd8 100644
--- a/Software/Embedded_SW/Embedded/StateMachines/Printing/PrintingSTM.c
+++ b/Software/Embedded_SW/Embedded/StateMachines/Printing/PrintingSTM.c
@@ -19,6 +19,8 @@
 #include "include.h"
 #include "./printingSTM.h"
 
+#include "Drivers/Heater/Heater.h"
+
 #include "Modules/General/MachineStatus.h"
 #include "modules/General/process.h"
 #include "modules/thread/thread_ex.h"
@@ -335,7 +337,7 @@ uint32_t PrintingHWConfiguration(void *Configuration)
     {
         for (i = 0; i < request->n_pidcontrols ; i++)
         {
-            if (request->pidcontrols[i]->hardwarepidcontroltype <= HARDWARE_PID_CONTROL_TYPE__MixerHeater)
+            if (isHeater(request->pidcontrols[i]->hardwarepidcontroltype))
             {
                 Configured[Module_Heaters] = true;
                 break;