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

30 files changed, 592 insertions, 152 deletions

diff --git a/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c b/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c
index 16ab68ae7..c0b0493fc 100644
--- a/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c
+++ b/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c
@@ -20,7 +20,7 @@ typedef struct
 } TangoVersion_t;
 
 
-TangoVersion_t _gTangoVersion = {1,3,7,0};
+TangoVersion_t _gTangoVersion = {1,3,7,1};
 #define BUILD_DATE __DATE__
 char Dat[50] = BUILD_DATE; 
  char _gTangoName [MAX_STRING_LEN] = "Tango01 ";//d
diff --git a/Software/Embedded_SW/Embedded/DataDef.h b/Software/Embedded_SW/Embedded/DataDef.h
index 041240264..2c78e1b1c 100644
--- a/Software/Embedded_SW/Embedded/DataDef.h
+++ b/Software/Embedded_SW/Embedded/DataDef.h
@@ -121,6 +121,9 @@ enum
 #define CLOSE 0
 #define OPEN  1
 
+#define DRIER_LID_OPEN 0
+#define DRIER_LID_CLOSE 2
+
 #define DOUBLE_BUFFER 2
 
 #define CurrentMotDriver 0x08
@@ -210,7 +213,7 @@ typedef enum
     POWER_ON_OFF,
     THREAD_JOGGING ,
     THREAD_LOAD ,
-}PANEL_BUTTONS_LEDS_ID;
+}PANEL_BUTTON_OR_CRAT_ID;
 
 typedef enum
 {
@@ -349,7 +352,12 @@ Supports diagnostic <id> (--diag_suppress, - pds)
 
 //Project Properties->Build->Compiler->Include Options
 //There may be paths there relative to a build variable, rather than hard-coded paths, that may be triggering the error.
-
+//machine 2 only!!!!!!!!!!!
+//#define HEAD6_PT100 TEMP_SENSE_ANALOG_MIXCHIP_TEMP
+//#define MIXER_PT100 TEMP_SENSE_AN_ENCLOSURETEMP3
+//machine 2 only!!!!!!!!!!!
+#define HEAD6_PT100 TEMP_SENSE_AN_ENCLOSURETEMP3
+#define MIXER_PT100 TEMP_SENSE_ANALOG_MIXCHIP_TEMP
 
 
 #endif /* DATADEF_H */
diff --git a/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_Comm.h b/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_Comm.h
index 942846679..1196356a7 100644
--- a/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_Comm.h
+++ b/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_Comm.h
@@ -1601,6 +1601,22 @@ typedef union
     }bits;
     unsigned short ushort;
 }F3_GPI_01;
+
+//F1_GPO_02_bus
+typedef union
+{
+    struct
+    {
+        bool F1_CART1_RST       : 1; //0 F1_FAN1_PWMCTRL
+        bool F1_CART2_RST       : 1; //1 F1_FAN2_PWMCTRL
+        bool F1_CART3_RST       : 1; //2 F1_FAN3_PWMCTRL
+        bool F1_FAN4_PWMCTRL    : 1; //3
+        bool F1_FAN5_PWMCTRL    : 1; //4
+        unsigned short RESERVE  :11; //5-15
+    }bits;
+    unsigned short ushort;
+}F1_GPO_REG2;
+
 //  ----------------------------------
 
 //L6470_MOSI = 0x00;
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 49b1ce649..82e96a3f8 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
@@ -552,7 +552,7 @@ bool WHS_GPI_CHILLER_FAULT()
     return F2_GPI_Reg.bits.F2_GPI_CHILLER_FAULT;
 }
 
-bool WHS_GPI_WASTE_OVERFULL()
+bool WHS_GPI_WASTE_OVERFULL()//waste tank overflow
 {
     return F2_GPI_Reg.bits.F2_WASTE_OVERFULL_NO;
 }
@@ -562,12 +562,12 @@ bool WHS_GPI_SW_FILTER_PRES()
     return F3_GPI_01_Reg.bits.F3_GPI_SW_FILTER_PRES;
 }
 
-bool WHS_GPI_WCONTAINER_FULL()
+bool WHS_GPI_WCONTAINER_FULL()//waste tank full
 {
     return F3_GPI_01_Reg.bits.F3_GPI_WCONTAINER_FULL;
 }
 
-bool WHS_GPI_WCONTAINER_WARN()
+bool WHS_GPI_WCONTAINER_WARN()//waste tank empty
 {
     return F3_GPI_01_Reg.bits.F3_GPI_WCONTAINER_WARN;
 }
@@ -720,7 +720,7 @@ uint8_t Cartridges_LEDS(CARTREGE Cartridge, OPERATION_MODE LED_Mode) // CART1_LA
     return Status;
 }
 */
-uint8_t Pannel_Leds(PANEL_BUTTONS_LEDS_ID Pannel_Led_Id, OPERATION_MODE LED_Mode)
+uint8_t Pannel_Leds(PANEL_BUTTON_OR_CRAT_ID Pannel_Led_Id, OPERATION_MODE LED_Mode)
 {
     uint8_t Status = OK;
 
@@ -798,20 +798,20 @@ uint8_t Init_Machine_Leds()
 }
 
 
-bool Read_Cartridge_Button(PANEL_BUTTONS_LEDS_ID Cartridge)//TODO Update the polarity!!!
+bool Is_Cartridge_Present(PANEL_BUTTON_OR_CRAT_ID Cartridge)//TODO Update the polarity!!!
 {
-    bool IsCartPressed = false;
+    bool IsCartPresent = false;
 
         if((Cartridge == CART_1) && (F3_CARTx_PRES_02_Direct & BIT7))
-            IsCartPressed = true;
+            IsCartPresent = true;
         else
         if((Cartridge == CART_2) && (F3_CARTx_PRES_02_Direct & BIT6))
-            IsCartPressed = true;
+            IsCartPresent = true;
         else
         if((Cartridge == CART_3) && (F3_CARTx_PRES_02_Direct & BIT5))
-            IsCartPressed = true;
+            IsCartPresent = true;
 
-        return IsCartPressed;
+        return IsCartPresent;
 }
 
 uint32_t Control_Dryer_Fan(bool StartStop, uint8_t PWM_Command_Precent)//use START or STOP,  0 - 100%
@@ -819,7 +819,7 @@ uint32_t Control_Dryer_Fan(bool StartStop, uint8_t PWM_Command_Precent)//use STA
     uint32_t status = OK;
 
     F1_GPO_Reg.bits.DRYER_FAN_ON = StartStop;//0 - to turn on Blower
-    F1_GPO_Reg.bits.DRYER_FAN_DIRECT = CW;//Set Direction - TODO: Verify the correct direction
+    F1_GPO_Reg.bits.DRYER_FAN_DIRECT = CCW;//Set Direction - TODO: Verify the correct direction
     F1_GPO_Reg.bits.DRYER_FAN_TORQUE_PWM = HIGH;//Torqer High
 
     F1_gpo_01 = F1_GPO_Reg.ushort;
diff --git a/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_GPIO/FPGA_GPIO.h b/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_GPIO/FPGA_GPIO.h
index 1def86036..b7d2ce549 100644
--- a/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_GPIO/FPGA_GPIO.h
+++ b/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_GPIO/FPGA_GPIO.h
@@ -234,7 +234,9 @@ uint32_t Control_Dryer_Fan(bool StartStop, uint8_t PWM_Command_Precent);
 bool Check_Disp_Sfaty_Stop_Indication(uint8_t Dispenser_ID);
 bool Emergency_Push_Button_Report();
 bool Dryer_Door_Switch();
-uint8_t Pannel_Leds(PANEL_BUTTONS_LEDS_ID Pannel_Led_Id, OPERATION_MODE LED_Mode);
+uint8_t Pannel_Leds(PANEL_BUTTON_OR_CRAT_ID Pannel_Led_Id, OPERATION_MODE LED_Mode);
 uint8_t Init_Machine_Leds();
 
+bool Is_Cartridge_Present(PANEL_BUTTON_OR_CRAT_ID Cartridge);
+
 #endif /* DRIVERS_FPGA_FPGA_GPIO_FPGA_GPIO_H_ */
diff --git a/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_SPI_Comm.c b/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_SPI_Comm.c
index f2026b611..594b3d1a4 100644
--- a/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_SPI_Comm.c
+++ b/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_SPI_Comm.c
@@ -803,6 +803,25 @@ void FPGA_SetMotMicroStep(TimerMotors_t _motorId)//
     }
 }
 
+
+void FPGA_SetGoToPosition(TimerMotors_t _motorId)//GoTo
+{
+    uint32_t temp;
+
+    temp = x_GOTO;
+    temp = temp << 24;
+
+    if (MotorDriverRequest[_motorId].Position > 0x3FFFFF) //TODO to check if it is needed here
+        MotorDriverRequest[_motorId].Position = 0x3FFFFF;
+
+    temp |= (MotorDriverRequest[_motorId].Position);;
+    Fpga_Spi[_motorId].TX_MOSI = temp;
+
+    //MillisecWriteToMotor(_motorId, temp, 4, NULL);
+    FPGA_SPI_Transnit(_motorId);
+
+}
+
 void FPGA_SetMotPosition(TimerMotors_t _motorId)//Mov
 {
     uint32_t temp;
diff --git a/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_SPI_Comm.h b/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_SPI_Comm.h
index e3ea0babe..cc9d85cca 100644
--- a/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_SPI_Comm.h
+++ b/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_SPI_Comm.h
@@ -34,5 +34,6 @@ int SPISendFPGARequest(TEMPERATURE_SENSOR_ID_ENUM SensorId,uint32_t Data, uint32
 int SPIGetFPGAResponse(TEMPERATURE_SENSOR_ID_ENUM SensorId,uint32_t *Data);
 void FPGA_SetMotHome(TimerMotors_t  _motorId);
 extern SPI Fpga_Spi[NUM_OF_MOTORS];
+void FPGA_SetGoToPosition(TimerMotors_t _motorId);//GoTo
 
 
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/RFID_NFC/NFC_I2C/NFC_I2C.c b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/RFID_NFC/NFC_I2C/NFC_I2C.c
new file mode 100644
index 000000000..931cc9e9e
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/RFID_NFC/NFC_I2C/NFC_I2C.c
@@ -0,0 +1,71 @@
+/*
+ * NFC_I2C.c
+ *
+ *  Created on: Feb 13, 2019
+ *      Author: avi
+ */
+#include <stdint.h>
+#include <stdbool.h>
+#include <string.h> //memset
+#include <DataDef.h>
+#include <Drivers/I2C_Communication/I2C.h>
+
+#define MUX_I2C_BASE  4
+#define I2C_MUX_Slave_Add  0xE0//Mux I2C address
+#define I2C_NFC_Slave_Add  0x28//The OM5578/PN7150S kit comes with default 0x28 (7 bits) I2C address.
+
+#define MaxNoBytesToRead  7//
+uint8_t I2C_Read_buf[MaxNoBytesToRead];
+
+uint32_t I2C_NFC_Config(uint32_t channel)
+{
+    uint32_t Status = OK;
+
+    uint8_t NFC_Config_Buf[3];
+
+    NFC_Config_Buf[0] = 0x00;
+    NFC_Config_Buf[1] = channel;
+    NFC_Config_Buf[2] = 0x80;
+
+    Status = I2C_Write(MUX_I2C_BASE, I2C_MUX_Slave_Add, NFC_Config_Buf, 3);
+
+    return Status;
+}
+
+uint32_t Enable_I2C_NFC_Channel(PANEL_BUTTON_OR_CRAT_ID Cart_ID)
+{
+    uint32_t Status = OK;
+
+    uint32_t Channel;
+
+    Channel = 0x01 << (Cart_ID - 1);
+
+    Status = I2C_NFC_Config(Channel);
+
+    return Status;
+}
+
+
+uint32_t I2C_NFC_Set_For_Read_Ch()
+{
+    uint32_t Status = OK;
+
+    const uint8_t SetRead = 0x01;
+
+    Status = I2C_Write(MUX_I2C_BASE, I2C_NFC_Slave_Add, &SetRead, 1);
+
+    return Status;
+}
+
+
+uint32_t I2C_NFC_Read_Ch(uint8_t No_BytesToRead )
+{
+    uint32_t Status = OK;
+
+    memset(I2C_Read_buf,0,sizeof(MaxNoBytesToRead));
+
+    I2C_Read(MUX_I2C_BASE, I2C_NFC_Slave_Add, I2C_Read_buf,  No_BytesToRead );
+
+    return Status;
+}
+
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/RFID_NFC/PN7150/PN7150.c b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/RFID_NFC/PN7150/PN7150.c
new file mode 100644
index 000000000..afb151a61
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/RFID_NFC/PN7150/PN7150.c
@@ -0,0 +1,38 @@
+/*
+ * PN7150.c
+ *
+ *  Created on: Feb 13, 2019
+ *      Author: avi
+ */
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <DataDef.h>
+#include "include.h"
+#include "drivers/FPGA/FPGA_Comm.h"
+
+#define NFC_HARDWARE_RESET 0x01
+
+F1_GPO_REG2 Reset_NFC;
+
+void Reset_NFC_Device(PANEL_BUTTON_OR_CRAT_ID Cart_ID)//reset pin. Set the device in Hard Power Down
+{
+    assert (Cart_ID<=CART_3);
+
+    switch(Cart_ID)
+    {
+        case CART_1:
+                Reset_NFC.bits.F1_CART1_RST = NFC_HARDWARE_RESET;
+            break;
+        case CART_2:
+                Reset_NFC.bits.F1_CART2_RST = NFC_HARDWARE_RESET;
+            break;
+        case CART_3:
+                Reset_NFC.bits.F1_CART3_RST = NFC_HARDWARE_RESET;
+            break;
+        default:
+            break;
+    }
+
+    F1_GPO_02_bus = Reset_NFC.ushort;
+}
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/RFID_NFC/PN7150/PN7150.h b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/RFID_NFC/PN7150/PN7150.h
new file mode 100644
index 000000000..61c3beb31
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/RFID_NFC/PN7150/PN7150.h
@@ -0,0 +1,15 @@
+/*
+ * PN7150.h
+ *
+ *  Created on: Feb 13, 2019
+ *      Author: avi
+ */
+
+#ifndef DRIVERS_RFID_NFC_PN7150_PN7150_H_
+#define DRIVERS_RFID_NFC_PN7150_PN7150_H_
+
+void Reset_NFC_Device(PANEL_BUTTON_OR_CRAT_ID Cart_ID);
+
+
+
+#endif /* DRIVERS_RFID_NFC_PN7150_PN7150_H_ */
diff --git a/Software/Embedded_SW/Embedded/Drivers/Motors/Motor.c b/Software/Embedded_SW/Embedded/Drivers/Motors/Motor.c
index 5fc5b71a4..aa633483c 100644
--- a/Software/Embedded_SW/Embedded/Drivers/Motors/Motor.c
+++ b/Software/Embedded_SW/Embedded/Drivers/Motors/Motor.c
@@ -352,22 +352,7 @@ uint32_t MotorSetMicroStep(TimerMotors_t _motorId, uint32_t microstep)
     return OK;
 }
 
-void FPGA_SetGoToPosition(TimerMotors_t _motorId)//GoTo
-{
-    uint32_t temp;
-
-    temp = x_GOTO;
-    temp = temp << 24;
-
-    if (MotorDriverRequest[_motorId].Position > 0x3FFFFF) //TODO to check if it is needed here
-        MotorDriverRequest[_motorId].Position = 0x3FFFFF;
-
-    temp |= MotorDriverRequest[_motorId].Position;
-    Fpga_Spi[_motorId].TX_MOSI = temp;
 
-    MillisecWriteToMotor(_motorId, temp, 4, NULL);
-
-}
 
 uint32_t MotorMove(TimerMotors_t _motorId,bool direction, uint32_t Steps)
 {
@@ -390,7 +375,7 @@ uint32_t MotorGoTo(TimerMotors_t _motorId, uint32_t Steps)
             MotorDriverRequest[_motorId].Position = Steps;
             FPGA_SetGoToPosition(_motorId);
     #endif
-
+    Report("MotorGoTo",__FILE__,__LINE__, _motorId,RpMessage,Steps,0);
     return OK;
 }
 
diff --git a/Software/Embedded_SW/Embedded/Drivers/Motors/Motor.h b/Software/Embedded_SW/Embedded/Drivers/Motors/Motor.h
index cb108e79d..7599c10db 100644
--- a/Software/Embedded_SW/Embedded/Drivers/Motors/Motor.h
+++ b/Software/Embedded_SW/Embedded/Drivers/Motors/Motor.h
@@ -174,7 +174,7 @@ uint32_t MotorStop(TimerMotors_t _motorId, STOP_TYPE_ENUM StopType);
 uint32_t MotorMove(TimerMotors_t _motorId,bool direction, uint32_t Steps);
 
 uint32_t MotorMoveWithCallback (TimerMotors_t _motorId,bool direction, uint32_t Steps, callback_fptr callback,uint32_t timeout);
-uint32_t MotorGotoWithCallback (TimerMotors_t MotorId, uint32_t Steps, callback_fptr callback,uint32_t timeout); //TODO
+uint32_t MotorGotoWithCallback (TimerMotors_t MotorId, uint32_t Steps,  uint32_t LimitSwitchId,callback_fptr callback,uint32_t timeout); //TODO
 
 bool     MotorControlGetnBusyState(uint32_t _motorId, uint32_t parameter);
 
diff --git a/Software/Embedded_SW/Embedded/Drivers/Motors/MotorActions.c b/Software/Embedded_SW/Embedded/Drivers/Motors/MotorActions.c
index 1f107ca88..158d90584 100644
--- a/Software/Embedded_SW/Embedded/Drivers/Motors/MotorActions.c
+++ b/Software/Embedded_SW/Embedded/Drivers/Motors/MotorActions.c
@@ -40,6 +40,7 @@ ControlCBFunction MotorControlCallback[NUM_OF_MOTORS];
 uint32_t MotorMoveCallBackFunction(uint32_t deviceId, uint32_t BusyFlag);
 uint32_t MotorSetSpeedCallBackFunction(uint32_t deviceId, uint32_t BusyFlag);
 uint32_t MotorVerifiedCallBackFunction(uint32_t IfIndex, uint32_t BusyFlag);
+uint32_t MotorMoveToLimitSwitchCallBackFunction(uint32_t IfIndex, uint32_t LimitSwitch);
 //uint32_t MotorMoveControlId[NUM_OF_MOTORS];
 //uint32_t MotorSetSpeedControlId[NUM_OF_MOTORS];
 //uint32_t MotorMovetoLimitSwitchControlId[NUM_OF_MOTORS];
@@ -127,7 +128,7 @@ MotorHomingDirectionEnum     Motor_Id_to_LS_Direction[NUM_OF_MOTORS] = {
       MotorHomingDirectionUp, //MOTO_RLOADARM = 23,
       MotorHomingDirectionDown, //MOTO_RLOADING = 24,
 };
-uint32_t MotorGotoWithCallback (TimerMotors_t MotorId, uint32_t Steps, callback_fptr callback,uint32_t timeout) //TODO
+uint32_t MotorGotoWithCallback (TimerMotors_t MotorId, uint32_t Steps,  uint32_t LimitSwitchId,callback_fptr callback,uint32_t timeout) //TODO
 {
     assert (callback);
     //assert (isValid(deviceId));
@@ -136,9 +137,9 @@ uint32_t MotorGotoWithCallback (TimerMotors_t MotorId, uint32_t Steps, callback_
     //SetMotorSpeed (deviceId, parameter);
     MotorCallback[MotorId] = callback;
 
-    MotorStop(MotorId,Hard_Hiz );
+    //MotorStop(MotorId,Hard_Hiz );
     MotorGoTo(MotorId,Steps );
-    MotorControlId[MotorId] = AddControlCallback( MotorMoveCallBackFunction,  /*eTenMillisecond*/20, MotorControlGetnBusyState,(IfTypeMotors*0x100+MotorId), MotorId, 0 );
+    MotorControlId[MotorId] = AddControlCallback( MotorMoveToLimitSwitchCallBackFunction,  /*eTenMillisecond*/20, FPGA_Read_limit_Switches,(IfTypeMotors*0x100+MotorId), LimitSwitchId, 0 );
     MotorControlCallback[MotorId] = MotorMoveCallBackFunction;
     return MotorControlId[MotorId];
 }
@@ -152,7 +153,7 @@ uint32_t MotorMoveWithCallback (TimerMotors_t MotorId,bool direction, uint32_t S
     //SetMotorSpeed (deviceId, parameter);
     MotorCallback[MotorId] = callback;
 
-    MotorStop(MotorId,Hard_Hiz );
+    //MotorStop(MotorId,Hard_Hiz );
     MotorMove(MotorId,direction,Steps );
     MotorControlId[MotorId] = AddControlCallback( MotorMoveCallBackFunction,  /*eTenMillisecond*/20, MotorControlGetnBusyState,(IfTypeMotors*0x100+MotorId), MotorId, 0 );
     MotorControlCallback[MotorId] = MotorMoveCallBackFunction;
@@ -423,7 +424,6 @@ uint32_t MotorMoveToDancerPositionCallBackFunction(uint32_t IfIndex, uint32_t Re
    if (Condition == true) //thread running identified
    {
        //stop this control loop
-       //RemoveControlCallback(MotorControlId[MotorId], MotorMoveToBreakSensorCallBackFunction );
        DancerValueDirection = false;
        DancerId = 0xFF;
        RemoveControlCallback(MotorControlId[MotorId], MotorControlCallback[MotorId] );
@@ -467,7 +467,6 @@ uint32_t MotorAbortMovetoLimitSwitch (TimerMotors_t MotorId)
 {
     if (MotorControlId[MotorId] != 0xFF)
     {
-        //RemoveControlCallback(MotorControlId[MotorId], MotorMoveToLimitSwitchCallBackFunction );
         RemoveControlCallback(MotorControlId[MotorId], MotorControlCallback[MotorId] );
         MotorControlCallback[MotorId] = 0;
         MotorControlId[MotorId] = 0xFF;
diff --git a/Software/Embedded_SW/Embedded/Main.c b/Software/Embedded_SW/Embedded/Main.c
index 252b7e90e..9af3b7227 100644
--- a/Software/Embedded_SW/Embedded/Main.c
+++ b/Software/Embedded_SW/Embedded/Main.c
@@ -41,9 +41,9 @@
 #include "Modules/Control/MillisecTask.h"
 #include "Modules/Heaters/Heaters_ex.h"
 #include "Modules/Ids/Ids_ex.h"
-#include "StateMachines/Printing/PrintingSTM.h"
-extern Semaphore_Handle sdCardSem;
 
+#include "StateMachines/Printing/PrintingSTM.h"
+//#include "StateMachines/Initialization/InitSequence.h"
 
 #include <Drivers/SSI_Comm/SSI_Comm.h>
 #include "drivers/SPI/SPI_Comm.h"
@@ -60,7 +60,6 @@ extern Semaphore_Handle sdCardSem;
 
 #include "drivers/FPGA/FPGA_GPIO/FPGA_GPIO.h"
 
-#include "drivers/I2C_Communication/DAC/Blower.h"
 #include "drivers/Flash_Memory/FATFS/ff.h"
 #include "drivers/Flash_Memory/FATFS/Control_File_System.h"
 
@@ -86,6 +85,10 @@ static volatile uint32_t g_ui32Flags;
 bool Machine_Idle_Mode = false;
 
 //MessageContainer createContainer(MessageType type, char* token, protobuf_c_boolean completed, void* response, size_t (*packPtr)(void*, uint8_t*), size_t (*sizePtr)(void*));
+uint32_t MainDummyFunction(uint32_t IfIndex, uint32_t ReadValue)
+{
+    return OK;
+}
 uint32_t HWControlId;
 
 uint32_t MainHWInitCallBackFunction(uint32_t IfIndex, uint32_t BusyFlag)
@@ -218,7 +221,7 @@ int main(void)
 
     IDLE_TASK_package_init();
 
-    HWControlId = AddControlCallback( MainHWInitCallBackFunction, 4* eOneSecond/*eHundredMillisecond*/, TemplateDataReadCBFunction,0,0, 0 );
+    HWControlId = AddControlCallback( MainHWInitCallBackFunction, 4* eOneSecond/*eHundredMillisecond*/, MainDummyFunction,0,0, 0 );
 
     BIOS_start();
 
diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
index 518100ae0..c046aa4ea 100644
--- a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
+++ b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
@@ -48,7 +48,7 @@
 #include "drivers/FPGA/Moters_Driver/L6470.h"
 #include "drivers/Motors/Motor.h"
 #include "drivers/Heater/TemperatureSensor.h"
-
+#include "drivers/Flash_ram/FlashProgram.h"
 
 Task_Handle AlarmHandling_Task_Handle;
 Mailbox_Handle          AlarmHandlingMsgQ = NULL;
@@ -114,7 +114,13 @@ typedef struct
 }AlarmStatusItem;
 AlarmStatusItem  AlarmState[MAX_SYSTEM_ALARMS];
 
-const AlarmHandlingItemStruc  AlarmItem[MAX_SYSTEM_ALARMS]={
+#define FLASH_MAP _Pragma("location = MOTOR_MAP_IN_FLASH")
+/*
+* Use this pragma directive to specify the location—the absolute address—of the global
+* or static variable whose declaration follows the pragma directive (only if using it without #define for example: #pragma location = MOTOR_MAP_IN_FLASH)
+* The variables must be declared either __no_init or const!
+*/
+FLASH_MAP const AlarmHandlingItemStruc  AlarmItem[MAX_SYSTEM_ALARMS]={
  {eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_1,0,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_1_EMPTY,"Dispenser 1 Empty"},
  {eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_2,1,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_2_EMPTY,"Dispenser 2 Empty"},
  {eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_3,2,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_3_EMPTY,"Dispenser 3 Empty"},
@@ -183,13 +189,13 @@ const AlarmHandlingItemStruc  AlarmItem[MAX_SYSTEM_ALARMS]={
  {eOneSecond,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,"MotorDispenser6Stall"},
  {eOneSecond,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,"MotorDispenser7Stall"},
  {eOneSecond,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,"MotorDispenser8Stall"},
- {eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_MIXCHIP_TEMP,   HARDWARE_PID_CONTROL_TYPE__MixerHeater        ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MIXER_OVERTEMPERATURE,"Mixer Over Temperature"},
+ {eHundredMillisecond,TemperatureAlarm,MIXER_PT100,   HARDWARE_PID_CONTROL_TYPE__MixerHeater        ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MIXER_OVERTEMPERATURE,"Mixer Over Temperature"},
  {eHundredMillisecond,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,"DyeingHead1 Over Temperature"},
  {eHundredMillisecond,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,"DyeingHead2 Over Temperature"},
  {eHundredMillisecond,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,"DyeingHead3 Over Temperature"},
  {eHundredMillisecond,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,"DyeingHead4 Over Temperature"},
  {eHundredMillisecond,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,"DyeingHead5 Over Temperature"},
- {eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_AN_ENCLOSURETEMP3, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6       ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_6_OVERTEMPERATURE,"DyeingHead6 Over Temperature"},
+ {eHundredMillisecond,TemperatureAlarm,HEAD6_PT100, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6       ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_6_OVERTEMPERATURE,"DyeingHead6 Over Temperature"},
  {eHundredMillisecond,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,"Dryer Over Temperature"},
 
  /*{eHundredMillisecond,CoversAlarm,FrontDoor1    ,1,false,true,DEBUG_LOG_CATEGORY__Error,  0xFF,5,EVENT_TYPE__FRONT_COVER_1_OPEN,"Front door #1 Open"},
@@ -199,21 +205,21 @@ const AlarmHandlingItemStruc  AlarmItem[MAX_SYSTEM_ALARMS]={
  {eHundredMillisecond,CoversAlarm,RearDoor      ,1,false,true,DEBUG_LOG_CATEGORY__Error,  0xFF,5,EVENT_TYPE__REAR_COVER_OPEN,"Rear door Open"},
  {eHundredMillisecond,CoversAlarm,CartridgesDoor,1,false,true,DEBUG_LOG_CATEGORY__Warning,0xFF,5,EVENT_TYPE__CARTRIDGES_COVER_OPEN,"Cartridges door Open"},*/
 
- {eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_MIXCHIP_TEMP,   HARDWARE_PID_CONTROL_TYPE__MixerHeater        ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MIXER_UNDERTEMPERATURE_A,"Mixer PT100 Not Heating"},
+ {eOneSecond,TemperatureAlarm,MIXER_PT100,   HARDWARE_PID_CONTROL_TYPE__MixerHeater        ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MIXER_UNDERTEMPERATURE_A,"Mixer PT100 Not Heating"},
  {eOneSecond,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_A,"DyeingHead 1 PT100 Not Heating"},
  {eOneSecond,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_A,"DyeingHead 2 PT100 Not Heating"},
  {eOneSecond,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_A,"DyeingHead 3 PT100 Not Heating"},
  {eOneSecond,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_A,"DyeingHead 4 PT100 Not Heating"},
  {eOneSecond,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_A,"DyeingHead 5 PT100 Not Heating"},
- {eOneSecond,TemperatureAlarm,TEMP_SENSE_AN_ENCLOSURETEMP3, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_A,"DyeingHead 6 PT100 Not Heating"},
+ {eOneSecond,TemperatureAlarm,HEAD6_PT100, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_A,"DyeingHead 6 PT100 Not Heating"},
  {eOneSecond,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_A,"Dryer PT100 Not Heating"},
- {eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_MIXCHIP_TEMP,   HARDWARE_PID_CONTROL_TYPE__MixerHeater        ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MIXER_UNDERTEMPERATURE_B,"Mixer PT100 Heating Failure"},
+ {eOneSecond,TemperatureAlarm,MIXER_PT100,   HARDWARE_PID_CONTROL_TYPE__MixerHeater        ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MIXER_UNDERTEMPERATURE_B,"Mixer PT100 Heating Failure"},
  {eOneSecond,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,"DyeingHead 1 PT100 Heating Failure"},
  {eOneSecond,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,"DyeingHead 2 PT100 Heating Failure"},
  {eOneSecond,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,"DyeingHead 3 PT100 Heating Failure"},
  {eOneSecond,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,"DyeingHead 4 PT100 Heating Failure"},
  {eOneSecond,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,"DyeingHead 5 PT100 Heating Failure"},
- {eOneSecond,TemperatureAlarm,TEMP_SENSE_AN_ENCLOSURETEMP3, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_B,"DyeingHead 6 PT100 Heating Failure"},
+ {eOneSecond,TemperatureAlarm,HEAD6_PT100, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_B,"DyeingHead 6 PT100 Heating Failure"},
  {eOneSecond,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,"Dryer PT100 Heating Failure"},
  { eOneSecond, 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                         ," MotorRightLoaderOverCurrent "                },                                           /* 3004 */
  { eOneSecond, 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                          ," MotorLeftLoaderOverCurrent  "                },                                           /* 3006 */
@@ -487,32 +493,47 @@ JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob)
                 break;
             }
         }
+        if (AlarmItem[Alarm_i].AlarmSource == MotorAlarm)
+        {
+            if (AlarmState[Alarm_i].Status == true)
+            {
+                if(AlarmItem[Alarm_i].Severity>=DEBUG_LOG_CATEGORY__Error)
+				{
+	                status = ERROR;
+    	            AlarmId = Alarm_i;
+        	        break;
+				}
+            }
+        }
     }
     if (Configured[Module_Heaters])
     {
-        for (Heater_i = 0;Heater_i<MAX_HEATERS_NUM;Heater_i++)
+        if (HeaterCheckReady()==false)
         {
-            LoadHeaterState((HeaterType)Heater_i,&HeaterState);
-            if (HeaterState.setpoint)//temperature is set - heater active
+            for (Heater_i = 0;Heater_i<MAX_HEATERS_NUM;Heater_i++)
             {
-                for (Alarm_i = 0;Alarm_i<MAX_SYSTEM_ALARMS;Alarm_i++)
+                LoadHeaterState((HeaterType)Heater_i,&HeaterState);
+                if (HeaterState.setpoint)//temperature is set - heater active
                 {
-                    if (AlarmItem[Alarm_i].EventType == HeaterEventType[Heater_i])
+                    for (Alarm_i = 0;Alarm_i<MAX_SYSTEM_ALARMS;Alarm_i++)
                     {
-                        if (AlarmState[Alarm_i].Status == true)
+                        if (AlarmItem[Alarm_i].EventType == HeaterEventType[Heater_i])
                         {
-                            status = ERROR;
-                            AlarmId = Alarm_i;
-                            break;
+                            if (AlarmState[Alarm_i].Status == true)
+                            {
+                                status = ERROR;
+                                AlarmId = Alarm_i;
+                                break;
+                            }
                         }
-                    }
-                    if (AlarmItem[Alarm_i].EventType == HeaterEventTypeUnder[Heater_i])
-                    {
-                        if (AlarmState[Alarm_i].Status == true)
+                        if (AlarmItem[Alarm_i].EventType == HeaterEventTypeUnder[Heater_i])
                         {
-                            status = ERROR;
-                            AlarmId = Alarm_i;
-                            break;
+                            if (AlarmState[Alarm_i].Status == true)
+                            {
+                                status = ERROR;
+                                AlarmId = Alarm_i;
+                                break;
+                            }
                         }
                     }
                 }
diff --git a/Software/Embedded_SW/Embedded/Modules/Control/control.h b/Software/Embedded_SW/Embedded/Modules/Control/control.h
index d50868064..0bcaecb03 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/control.h
+++ b/Software/Embedded_SW/Embedded/Modules/Control/control.h
@@ -40,8 +40,8 @@ void        ControlStart(void);
 uint32_t    AddControlCallback( ControlCBFunction Callback, CTRL_TIMING_ENUM CtrlFrequency, DataReadCBFunction DriverfPtr, uint16_t IfIndex, uint32_t Parameter1, uint32_t Parameter2 );
 int         RemoveControlCallback(uint32_t deviceId, ControlCBFunction Callback );
 uint32_t    TemplateDataReadCBFunction (uint32_t deviceId, uint32_t Parameter1);
-uint32_t GetControlDevice_i(void);
-uint32_t GetControlLowDevice_i(void);
+uint32_t    GetControlDevice_i(void);
+uint32_t    GetControlLowDevice_i(void);
 
 extern Task_Handle Control_Task_Handle;
 extern uint32_t millisecondCounter;
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c
index 42bf19b96..160119d26 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c
@@ -23,6 +23,7 @@
 
 #include "drivers/FPGA/FPGA_GPIO/FPGA_GPIO.h"
 #include "drivers/I2C_Communication/DAC/blower.h"
+#include "drivers/I2C_Communication/ADC_MUX/ADC_MUX.h"
 #include "drivers/Valves/Valve.h"
 #include "drivers/Heater/Heater.h"
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
index e3cec605d..603de30d4 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
@@ -327,13 +327,13 @@ void Diagnostic100msecCollection(void)
         DiagnosticLoadMotor(WINDER_MOTOR, ThreadGetMotorSpeed (WINDER_MOTOR));
         DiagnosticLoadMotor(SCREW_MOTOR, ThreadGetMotorSpeed (SCREW_MOTOR));
     }
-    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__MixerHeater, TemperatureSensorRead( TEMP_SENSE_ANALOG_MIXCHIP_TEMP));
+    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__MixerHeater, TemperatureSensorRead( MIXER_PT100));
     DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1, TemperatureSensorRead(TEMP_SENSE_ANALOG_DYEINGH_TEMP1));
     DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2, TemperatureSensorRead(TEMP_SENSE_ANALOG_DYEINGH_TEMP2));
     DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3, TemperatureSensorRead(TEMP_SENSE_ANALOG_DYEINGH_TEMP3));
     DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4, TemperatureSensorRead(TEMP_SENSE_ANALOG_DYEINGH_TEMP4));
     DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5, TemperatureSensorRead(TEMP_SENSE_ANALOG_DYEINGH_TEMP5));
-    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6, TemperatureSensorRead(TEMP_SENSE_AN_ENCLOSURETEMP3));
+    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6, TemperatureSensorRead(HEAD6_PT100));
 
     DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature, TemperatureSensorRead(TEMP_SENSE_ANALOG_DRYER_TEMP1));
     DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain, TemperatureSensorRead(TEMP_SENSE_ANALOG_DRYER_TEMP2));
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c
index 3592122cc..bfc469093 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c
@@ -71,21 +71,39 @@ uint32_t MotorHomingRequestFunc(MessageContainer* requestContainer)
         {
             if (request->direction == MOTOR_DIRECTION__Backward) //opening the loading system
             {
-                if ( Motor_Id_to_LS_IdUp[MotorId] != MAX_GPI)
+                if(MotorId == HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID)
                 {
-                    MotorMovetoLimitSwitch (MotorId,MotorsCfg[MotorId].directionthreadwize, speed,  Motor_Id_to_LS_IdDown[MotorId], MotorHomingRequestCallback,10000);
+                    MotorGotoWithCallback(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID, DRIER_LID_OPEN, GPI_LS_DRYER_LID_OPEN, MotorHomingRequestCallback,4000);
                     ustrncpy (HomingToken[MotorId], requestContainer->token,36);
                     return OK;
                 }
+                else
+                {
+                    if ( Motor_Id_to_LS_IdDown[MotorId] != MAX_GPI)
+                    {
+                        MotorMovetoLimitSwitch (MotorId,1-MotorsCfg[MotorId].directionthreadwize, speed,  Motor_Id_to_LS_IdUp[MotorId], MotorHomingRequestCallback,10000);
+                        ustrncpy (HomingToken[MotorId], requestContainer->token,36);
+                        return OK;
+                    }
+                }
             }
             else // closing the system into normal work
             {
-                if ( Motor_Id_to_LS_IdDown[MotorId] != MAX_GPI)
+                if(MotorId == HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID)
                 {
-                    MotorMovetoLimitSwitch (MotorId,1-MotorsCfg[MotorId].directionthreadwize, speed,  Motor_Id_to_LS_IdUp[MotorId], MotorHomingRequestCallback,10000);
+                    MotorGotoWithCallback(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID, DRIER_LID_CLOSE, GPI_LS_DRYER_LID_CLOSED, MotorHomingRequestCallback,4000);
                     ustrncpy (HomingToken[MotorId], requestContainer->token,36);
                     return OK;
                 }
+                else
+                {
+                    if ( Motor_Id_to_LS_IdUp[MotorId] != MAX_GPI)
+                    {
+                        MotorMovetoLimitSwitch (MotorId,MotorsCfg[MotorId].directionthreadwize, speed,  Motor_Id_to_LS_IdDown[MotorId], MotorHomingRequestCallback,10000);
+                        ustrncpy (HomingToken[MotorId], requestContainer->token,36);
+                        return OK;
+                    }
+                }
             }
         }
     }
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsJogging.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsJogging.c
index 48f2e1e20..d180fb96e 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsJogging.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsJogging.c
@@ -58,14 +58,22 @@ uint32_t MotorJoggingRequestFunc(MessageContainer* requestContainer)
                 switch (request->direction)
                 {
                     case MOTOR_DIRECTION__Forward:
-                        direction = 1-MotorsCfg[MotorId].directionthreadwize;
+                        direction = MotorsCfg[MotorId].directionthreadwize;
                         break;
                     case MOTOR_DIRECTION__Backward:
-                        direction = MotorsCfg[MotorId].directionthreadwize;
+                        direction = 1-MotorsCfg[MotorId].directionthreadwize;
                         break;
                 }
-                MotorSetDirection(MotorId,direction);
-                MotorSetSpeed(MotorId, speed);
+                if(MotorId == HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID)
+                {
+                    int Pos_Value = (direction == 1)?0:2;
+                    MotorGoTo(MotorId, Pos_Value );
+                }
+                else
+                {
+                    MotorSetDirection(MotorId,direction);
+                    MotorSetSpeed(MotorId, speed);
+                }
             }
         }
         else
diff --git a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
index 789ac459e..7ac9340f2 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
@@ -10,6 +10,7 @@
 #include "thread/thread.h"
 #include "ids/ids.h"
 #include "control/control.h"
+#include "Control/MillisecTask.h"
 #include "AlarmHandling/AlarmHandling.h"
 #include "heaters/heaters_ex.h"
 #include "StateMachines/Printing/PrintingSTM.h"
@@ -84,6 +85,7 @@ uint32_t HWConfigurationInit(void)
     }
     EmbeddedParametersInit();
     IDS_Dispenser_Content_Init();
+    //ProcessParamsInit();
     return Fresult;
 }
 
@@ -167,7 +169,7 @@ uint32_t GenHWControlId;
 uint32_t GenHWInitCallBackFunction(uint32_t IfIndex, uint32_t BusyFlag)
 {
     int   Dispenser_i;
-    RemoveControlCallback(GenHWControlId, GenHWInitCallBackFunction );
+    /*Safe*/RemoveControlCallback(GenHWControlId, GenHWInitCallBackFunction );
     for (Dispenser_i = 0;Dispenser_i < MAX_SYSTEM_DISPENSERS;Dispenser_i++)
     {
         Read_MidTank_Pressure_Sensor(Dispenser_i);
@@ -220,7 +222,7 @@ uint32_t HWConfiguration(UploadHardwareConfigurationRequest* UploadRequest)
         upload_hardware_configuration_request__free_unpacked(UploadRequest,NULL);
         return ERROR;
     }
-   // LoadDancerConfigMessage();
+    LoadDancerConfigMessage();
     //StoreDancerConfigMessage();
     if (request->n_pidcontrols <= HARDWARE_PID_CONTROL_TYPE__Dispenser8)
     {
@@ -267,14 +269,14 @@ uint32_t HWConfiguration(UploadHardwareConfigurationRequest* UploadRequest)
     {
         BlowerCfg.enabled = false;
     }
-
+/*
     for (Dispenser_i = 0;Dispenser_i < MAX_SYSTEM_DISPENSERS;Dispenser_i++)
     {
         Enable_MidTank_Pressure_Reading(Dispenser_i);
         Valve_Set(IDS_Id_to_AirValve[Dispenser_i], Atm_MidTank_ON );   //Atm_MidTank_OFF/ON
     }
-    GenHWControlId = AddControlCallback( GenHWInitCallBackFunction, 2* eOneSecond/*eHundredMillisecond*/, TemplateDataReadCBFunction,0,0, 0 );
-
+    GenHWControlId = AddControlCallback( GenHWInitCallBackFunction, 2* eOneSecond, TemplateDataReadCBFunction,0,0, 0 );
+*/
     ControlStart();
     AlarmHandlingStart();
     //ThreadInitialTestStub(request);
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
index 50b4658c1..53d5095c8 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
@@ -84,7 +84,7 @@ uint32_t    SecondDryerHeaterMaxTempControl = 0xFF;
 #define DRYER_SECONDARY_PT100 TEMP_SENSE_ANALOG_DRYER_TEMP3
 
 //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,TEMP_SENSE_AN_ENCLOSURETEMP3,TEMP_SENSE_ANALOG_MIXCHIP_TEMP};
+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};
 uint32_t    DryerInternalPT100Id = DRYER_AIR_PT100;
 bool HeatersRestart = false;
 
@@ -437,6 +437,7 @@ uint32_t PrepareHeater(int HeaterId, uint32_t SetTemperatue)
         //DCInitialHeating[HeaterId] = true;
         HeaterReady[HeaterId] = false;
         HeaterPreviousRead[HeaterId] = TemperatureSensorRead(HeaterId2PT100Id[HeaterId]);
+        Report("PrepareHeater Read", __FILE__,__LINE__,HeaterId, SetTemperatue, HeaterPreviousRead[HeaterId], 0);
         if (ControlIdtoMaxHeaterId [HeaterId] == 0xFF)
             ControlIdtoMaxHeaterId [HeaterId] = AddControlCallback( DcHeaterMaxTempCBFunction, eOneSecond,TemperatureSensorRead,(IfTypeHeaters*0x100+HeaterId),HeaterId2PT100Id[HeaterId],0);
 
@@ -447,6 +448,7 @@ uint32_t PrepareHeater(int HeaterId, uint32_t SetTemperatue)
 		{
 	        ControlIdtoHeaterId [HeaterId] = AddControlCallback( HeaterControlCBFunction, Frequency/*eOneSecond*/,TemperatureSensorRead,(IfTypeHeaters*0x100+HeaterId),DryerInternalPT100Id,0);
             HeaterPreviousRead[HeaterId] = TemperatureSensorRead(DryerInternalPT100Id);
+            Report("PrepareHeater Read", __FILE__,__LINE__,HeaterId, SetTemperatue, HeaterPreviousRead[HeaterId], 0);
             HeaterPreviousRead[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] = TemperatureSensorRead(HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain]);
             HeaterPreviousRead[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary] = TemperatureSensorRead(HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]);
 		}
@@ -540,7 +542,7 @@ uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue)
     }
     if (abs(readValue - HeaterPreviousRead[index])>2000)
     {
-        Report("Temperature Spike",__FILE__,__LINE__,HeaterPreviousRead[index],RpWarning,readValue, index);
+        Report("Temperature Spike",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index);
         return ERROR;
     }
     HeaterPreviousRead[index] = readValue;
@@ -689,7 +691,7 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
     }
     if (abs(readValue - HeaterPreviousRead[index])>2000)
     {
-        Report("Temperature Spike",__FILE__,__LINE__,HeaterPreviousRead[index],RpWarning,readValue, index);
+        Report("Temperature Spike",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index);
         return ERROR;
     }
     HeaterPreviousRead[index] = readValue;
@@ -866,20 +868,8 @@ uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
             }
             else
             {
-                /*if (index == HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3)
-                {
-                    //temp_preError = HeaterPIDConfig[index].m_preError; temp_integral = HeaterPIDConfig[index].m_integral;
-                    temp_calculatedError =  PIDAlgorithmCalculation(HeaterPIDConfig[index].m_SetParam , HeaterPIDConfig[index].m_mesuredParam,
-                                                      &temp_params,   &temp_preError, &temp_integral);
-                }*/
                 HeaterPIDConfig[index].m_calculatedError = AdvancedPIDAlgorithmCalculation(HeaterPIDConfig[index].m_SetParam , HeaterPIDConfig[index].m_mesuredParam,
                                                       &HeaterPIDConfig[index].m_params,   &HeaterPIDConfig[index].m_preError, &HeaterPIDConfig[index].m_integral);
-                /*if (index == HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3)
-                {
-                    len = usnprintf(heatstr, 100, "ACD Id, Temp , Integral, Output,AdvIntegral, AdvOutput{ %d, %d ,%d, %d,%d, %d} ",index,(int)HeaterPIDConfig[index].m_mesuredParam ,
-                                    (int)HeaterPIDConfig[index].m_integral,(int)HeaterPIDConfig[index].m_calculatedError,(int)temp_integral,(int)temp_calculatedError);
-                    Report(heatstr,__FILE__,__LINE__,index,RpWarning,index,  readValue);
-                }*/
             }
             //        error[index][Counter[index]]    = HeaterPIDConfig[index].m_preError;
             //        integral[index][Counter[index]] = HeaterPIDConfig[index].m_integral;
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
index 8277c9cd9..0262db6ff 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
@@ -13,6 +13,8 @@
 #include "PMR/Hardware/HardwareDispenser.pb-c.h"
 #include "StateMachines/Printing/printingSTM.h"
 
+#include "drivers/I2C_Communication/ADC_MUX/ADC_MUX.h"
+
 #include "drivers/FPGA/FPGA_GPIO/FPGA_GPIO.h"
 #include "drivers/Motors/Motor.h"
 #include "drivers/Valves/Valve.h"
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
index 5ee8a150d..9dd2822d6 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
@@ -319,9 +319,9 @@ uint32_t IDSPreSegmentState(void *JobDetails, int SegmentId)
             DispenserPreSegmentReady[DispenserId] = false;
             REPORT_MSG(DispenserId,"IDS_Valve_Presegment start");
             IDS_Dispenser_Set_Flow_Params(DispenserId,0,0);
-            if (JobTicket->segments[DispenserId]->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->dispenserstepdivision != DISPENSER_STEP_DIVISION__Auto)
+            if (JobTicket->segments[SegmentId]->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->dispenserstepdivision != DISPENSER_STEP_DIVISION__Auto)
             {
-                MotorSetMicroStep(HW_Motor_Id, JobTicket->segments[DispenserId]->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->dispenserstepdivision);
+                MotorSetMicroStep(HW_Motor_Id, JobTicket->segments[SegmentId]->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->dispenserstepdivision);
             }
             else
             {
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 319f85454..65ede8fac 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Motor.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Motor.c
@@ -539,7 +539,7 @@ void Stub_MotorMovRequest(MessageContainer* requestContainer)
     #else
         TimerMotors_t Motor_Id  = (TimerMotors_t)request->motor_id; //to remove warning
 
-        MotorMove(Motor_Id, Direction, Pos_Value );
+
         if(GoTo_Flag)
         {
             MotorGoTo(Motor_Id, Pos_Value );
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
index cc9bb099f..53bac3004 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
@@ -83,6 +83,7 @@
         void* buffer = NULL;
         uint32_t Bytes = 0;
         FRESULT Fresult = FR_OK;
+        REPORT_MSG(LoadStages, "Thread Load State Machine step");
 
         LoadArmInfo.LoadArmBackLash = 0;
         LoadArmInfo.LoadArmRounds = 0xFF;
@@ -109,6 +110,7 @@
     uint32_t Thread_Load_Reduce_Heat(void)
     {
         //Heaters Off, Dryer Blower Off, Blower Low,
+        REPORT_MSG(LoadStages, "Thread Load State Machine step");
         memcpy (&ProcessParametersClear,&ProcessParametersKeep,sizeof(ProcessParameters));
         ProcessParametersClear.dryerzone1temp = 0;
         ProcessParametersClear.dryerzone2temp = 0;
@@ -140,6 +142,7 @@
     }
     uint32_t Thread_Load_Set_Load_Arm_To_Start_Position_Callback(uint32_t deviceID, uint32_t BusyFlag)
     {
+        REPORT_MSG(LoadStages, "Thread Load State Machine Callback");
 
         NumberOfDrierLoaderCycles--;
         if (NumberOfDrierLoaderCycles)
@@ -157,6 +160,7 @@
     }
     uint32_t Thread_Load_Set_Load_Arm_To_Stopper_Callback(uint32_t deviceID, uint32_t BusyFlag)
     {
+        REPORT_MSG(LoadStages, "Thread Load State Machine Callback");
         NumberOfDrierLoaderCycles=0;
         //storeLoadArmParameters();
         LoadStages++;
@@ -165,6 +169,7 @@
     }
     uint32_t Thread_Load_Set_Load_Arm_To_Start_Position(void)
     {
+        REPORT_MSG(LoadStages, "Thread Load State Machine step");
         if (LoadArmInfo.LoadArmRounds != 0xFF)
         {
             NumberOfDrierLoaderCycles = LoadArmInfo.LoadArmRounds;
@@ -183,6 +188,7 @@
     uint8_t CallbackCounter = 0;
     uint32_t Thread_Load_HomingCallback(uint32_t MotorId, uint32_t ReadValue)
     {
+        REPORT_MSG(LoadStages, "Thread Load State Machine Callback");
         REPORT_MSG(MotorId, "Thread_Load_HomingCallback Motor Id");
         if(ControlId != 0xFF)
         {
@@ -204,6 +210,7 @@
     }
     uint32_t Thread_Load_Center_Head_Rockers(void)
     {
+        REPORT_MSG(LoadStages, "Thread Load State Machine step");
         CallbackCounter++;
         MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD].directionthreadwize, 200,  Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD], Thread_Load_HomingCallback,10000);
         CallbackCounter++;
@@ -212,6 +219,7 @@
     }
     uint32_t Thread_Load_Open_Covers(void)
     {
+        REPORT_MSG(LoadStages, "Thread Load State Machine step");
         //Open Dyeing Head Cover And Dryer Lid
         //HARDWARE_MOTOR_TYPE__MOTO_DH_LID = 2,
         //HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID = 4,
@@ -220,11 +228,12 @@
         MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_DH_LID,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DH_LID].directionthreadwize, 200,  Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_DH_LID], Thread_Load_HomingCallback,10000);
         CallbackCounter++;
         //MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID].directionthreadwize, 200,  Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID], Thread_Load_HomingCallback,10000);
-        MotorGotoWithCallback(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID, 2,  Thread_Load_HomingCallback,4000);
+        MotorGotoWithCallback(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID, 0, Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID], Thread_Load_HomingCallback,4000);
         return OK;
     }
     uint32_t Thread_Load_Lift_Dancers(void)
     {
+        REPORT_MSG(LoadStages, "Thread Load State Machine step");
         CallbackCounter++;
         MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_RDANCER,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDANCER].directionthreadwize, 200,  Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_RDANCER], Thread_Load_HomingCallback,10000);
         CallbackCounter++;
@@ -235,6 +244,7 @@
     uint32_t Thread_Load_Lift_Rockers(void)
     //Machine Is Ready. Send Message, Start Timer To Close Lids, Wait For Operator Response
     {
+        REPORT_MSG(LoadStages, "Thread Load State Machine step");
         CallbackCounter++;
         MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_RLOADING,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].directionthreadwize, 200,  Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_RLOADING], Thread_Load_HomingCallback,10000);
         CallbackCounter++;
@@ -244,6 +254,7 @@
     }
     uint32_t Thread_Load_Initial_Tension(void) //Check Spool Presence, run Winder Until Break Sensor Is Identifieing Movement For A Second
     {
+        REPORT_MSG(LoadStages, "Thread Load State Machine step");
         if (FPGA_Read_limit_Switches(GPI_SW_SPOOL_EXISTS)==LIMIT)
         {
             REPORT_MSG(LIMIT, "No cone in winder");
@@ -257,6 +268,7 @@
     }
     uint32_t Thread_Load_Close_Rockers(void)
     {
+        REPORT_MSG(LoadStages, "Thread Load State Machine step");
         CallbackCounter++;
         MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_RLOADING,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].directionthreadwize, 200,  Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_RLOADING], Thread_Load_HomingCallback,10000);
         CallbackCounter++;
@@ -268,6 +280,7 @@
     uint32_t Thread_Load_Close_Dancers(void)
     //Send Dancer Motors To Preset Location, Check That The Dancers Are On The Thread
     {
+        REPORT_MSG(LoadStages, "Thread Load State Machine step");
         CallbackCounter++;
         MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_RDANCER,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDANCER].directionthreadwize, 200,  Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_RDANCER], Thread_Load_HomingCallback,10000);
         CallbackCounter++;
@@ -277,6 +290,7 @@
     }
     uint32_t Thread_Load_Close_Lids(void)
     {
+        REPORT_MSG(LoadStages, "Thread Load State Machine step");
         //Close Dyeing Head Cover And Dryer Lid
         //HARDWARE_MOTOR_TYPE__MOTO_DH_LID = 2,
         //HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID = 4,
@@ -284,12 +298,13 @@
         MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_DH_LID,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DH_LID].directionthreadwize, 200,  Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_DH_LID], Thread_Load_HomingCallback,10000);
         CallbackCounter++;
 //        MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID].directionthreadwize, 200,  Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID], Thread_Load_HomingCallback,10000);
-        MotorGotoWithCallback(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID, 0,  Thread_Load_HomingCallback,4000);
+        MotorGotoWithCallback(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID, 2, Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID], Thread_Load_HomingCallback,4000);
 
         return OK;
     }
     uint32_t Thread_Load_Resume_Heating(void)
     {
+        REPORT_MSG(LoadStages, "Thread Load State Machine step");
         ActivateHeadMagnet();
 
         if (HandleProcessParameters(&ProcessParametersRecover)!= OK)
@@ -307,12 +322,14 @@
     uint32_t Thread_Load_Jog_Feeder_To_Middle_Point(void)
     //Jog The Feeder Motor Until The Feeder Dancer Is At Middle Position
     {
+        REPORT_MSG(LoadStages, "Thread Load State Machine step");
         CallbackCounter++;
         MotorMovetoDancerPosition (HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDRIVING].directionthreadwize, 200, FEEDER_DANCER ,true, Thread_Load_HomingCallback,10000);
         return OK;
     }
     uint32_t Thread_Load_Dryer_Loading(void)
     {
+        REPORT_MSG(LoadStages, "Thread Load State Machine step");
         LoadArmInfo.LoadArmRounds = 20;
         //Start Feeder Pid, Rotate Loading Arm Counter Thread Direction X Circles According To Rml. Feeder Speed Is 40
         OriginalMotorSpd_2PPS[FEEDER_MOTOR] = 1000;
@@ -328,6 +345,7 @@
     }
     uint32_t Thread_Load_Jog_ThreadStop(uint32_t index, uint32_t ReadValue)
     {
+        REPORT_MSG(LoadStages, "Thread Load State Machine step");
         RemoveControlCallback(ControlId, Thread_Load_Jog_ThreadStop );
         ControlId = 0xFF;
         ThreadAbortJoggingFunc();
@@ -338,6 +356,7 @@
     uint32_t Thread_Load_Jog_Thread(void)
     //Jog Thread Shortly To Make Sure Spool Is Running. Report End Of Loading
     {
+        REPORT_MSG(LoadStages, "Thread Load State Machine step");
         ThreadJoggingFunc(40);
         ControlId = AddControlCallback(Thread_Load_Jog_ThreadStop, eOneSecond*5,Control_Read_Dancer_Position,(IfTypeThread*0x100+FEEDER_MOTOR),FEEDER_DANCER,FEEDER_MOTOR);
         return OK;
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
index becdf054a..9b95ab52c 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
@@ -100,14 +100,13 @@ uint32_t Winder_Prepare(void)
      * report ready to the job STM
      */
 
-    if (FPGA_Read_limit_Switches(GPI_SW_SPOOL_EXISTS)==LIMIT)
+    /*if (FPGA_Read_limit_Switches(GPI_SW_SPOOL_EXISTS)==LIMIT)
     {
         REPORT_MSG(LIMIT, "No cone in winder");
         PrepareReady(Module_Winder,ModuleFail);
         AlarmHandlingSetAlarm(EVENT_TYPE__WINDER_CONE_DOES_NOT_EXIST,true);
         return ERROR;
-        //Winder_PrepareStage2(0,0);
-    }
+    }*/
     if (FPGA_Read_limit_Switches(GPI_LS_SCREW_RIGHT)==LIMIT)
     {
         //REPORT_MSG(LIMIT, "Winder_Prepare at limit");
diff --git a/Software/Embedded_SW/Embedded/StateMachines/Initialization/InitSequence.c b/Software/Embedded_SW/Embedded/StateMachines/Initialization/InitSequence.c
new file mode 100644
index 000000000..9add5438d
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/StateMachines/Initialization/InitSequence.c
@@ -0,0 +1,207 @@
+/*
+ * InitSequence.c
+ *
+ *  Created on: Feb 12, 2019
+ *      Author: shlomo
+ */
+#include <Container.h>
+#include <DataDef.h>
+#include "include.h"
+
+
+#include "modules/General/GeneralHardware.h"
+#include "modules/thread/thread.h"
+#include "modules/ids/ids.h"
+#include "modules/control/control.h"
+#include "modules/AlarmHandling/AlarmHandling.h"
+#include "modules/heaters/heaters_ex.h"
+#include "modules/Diagnostics/Diagnostics.h"
+#include "Modules/General/process.h"
+
+#include "StateMachines/Printing/PrintingSTM.h"
+#include "InitSequence.h"
+
+#include "drivers/I2C_Communication/DAC/Blower.h"
+
+#include "heaters/heaters_ex.h"
+
+    typedef enum
+    {
+        INIT_SEQUENCE_INIT,
+        INIT_SEQUENCE_RESET_REASON,
+        INIT_SEQUENCE_BUILT_IN_TEST,
+        INIT_SEQUENCE_INITIAL_BLOWER_ACTIVATION,
+        INIT_SEQUENCE_DISPENSER_PRESSURE_BIULDUP_TEST,
+        INIT_SEQUENCE_THREAD_DETECTION,
+        INIT_SEQUENCE_START_HEATING,
+        INIT_SEQUENCE_MACHINE_READY_TO_DYE,
+        INIT_SEQUENCE_END,
+    }INIT_SEQUENCE_STAGES_ENUM;
+    INIT_SEQUENCE_STAGES_ENUM InitStages = INIT_SEQUENCE_INIT;
+
+uint32_t HWControlId;
+uint32_t RESET_Cause = 0;
+
+void InitSequenceResetReason(void);
+uint32_t InitSequenceBuiltInTest(void);
+uint32_t InitSequenceInitialBlowerActivation(void);
+uint32_t InitSequenceDispenserPressureBuildupTest(void);
+uint32_t InitSequenceThreadDetection(void);
+uint32_t InitSequenceStartHeating(void);
+uint32_t InitSequenceMachineReadyToDye(void);
+
+uint32_t InitSequenceStateMachine( INIT_SEQUENCE_STAGES_ENUM ReadValue);
+
+uint32_t InitSequenceCallBackFunction(uint32_t IfIndex, uint32_t BusyFlag)
+{
+    if (SafeRemoveControlCallback(HWControlId, InitSequenceCallBackFunction )==OK)
+        HWControlId = 0xFF;
+    else
+        Report("Remove control callback failed",__FILE__,__LINE__,(int)HWControlId,RpWarning,(int)InitSequenceCallBackFunction,0);
+    HWConfigurationInit();
+    InitStages++;
+    InitSequenceStateMachine(InitStages);
+    return OK;
+}
+
+uint32_t Start_InitSequence(void)
+{
+    HWControlId = AddControlCallback( InitSequenceCallBackFunction, 4* eOneSecond/*eHundredMillisecond*/, TemplateDataReadCBFunction,0,0, 0 );
+    return OK;
+}
+void InitSequenceResetReason(void)
+{
+    /*
+        #define SYSCTL_CAUSE_HSRVREQ    0x00001000  // Hardware System Service Request
+        #define SYSCTL_CAUSE_HIB        0x00000040  // Hibernate reset
+        #define SYSCTL_CAUSE_WDOG1      0x00000020  // Watchdog 1 reset
+        #define SYSCTL_CAUSE_SW         0x00000010  // Software reset
+        #define SYSCTL_CAUSE_WDOG0      0x00000008  // Watchdog 0 reset
+        #define SYSCTL_CAUSE_BOR        0x00000004  // Brown-out reset
+        #define SYSCTL_CAUSE_POR        0x00000002  // Power on reset
+        #define SYSCTL_CAUSE_EXT        0x00000001  // External reset
+     */
+    RESET_Cause = SysCtlResetCauseGet ();
+    LOG_ERROR(RESET_Cause,"Reset Reason Register");
+    SysCtlResetCauseClear(RESET_Cause);
+    InitStages++;
+    InitSequenceStateMachine(InitStages);
+
+    //return OK;
+}
+void InitSequenceBuiltInTestCallBack(uint32_t IfIndex, uint32_t BusyFlag)
+{
+    InitStages++;
+    InitSequenceStateMachine(InitStages);
+    //return OK;
+}
+uint32_t InitSequenceBuiltInTest(void)
+{
+    InitSequenceBuiltInTestCallBack(0,0);
+    return OK;
+}
+uint32_t InitSequenceBlowerCallBackFunction(uint32_t IfIndex, uint32_t BusyFlag)
+{
+    if (SafeRemoveControlCallback(HWControlId, InitSequenceBlowerCallBackFunction )==OK)
+        HWControlId = 0xFF;
+    else
+        Report("Remove control callback failed",__FILE__,__LINE__,(int)HWControlId,RpWarning,(int)InitSequenceBlowerCallBackFunction,0);
+    if (BlowerCfg.voltage)
+        Control_Voltage_To_Blower(BlowerCfg.heatingvoltage);
+    InitStages++;
+    InitSequenceStateMachine(InitStages);
+    return OK;
+}
+uint32_t InitSequenceInitialBlowerActivation(void)
+{
+    if (BlowerCfg.enabled == true)
+    {
+        Turn_the_Blower_On();//Turn on with the Default_Voltage
+        if (BlowerCfg.voltage)
+            Control_Voltage_To_Blower(BlowerCfg.voltage);
+        HWControlId = AddControlCallback( InitSequenceBlowerCallBackFunction, 5* eOneSecond/*eHundredMillisecond*/, TemplateDataReadCBFunction,0,0, 0 );
+    }
+    return OK;
+}
+uint32_t InitSequenceDispenserPressureBuildupTest(void)
+{
+    InitStages++;
+    InitSequenceStateMachine(InitStages);
+    return OK;
+}
+uint32_t InitSequenceThreadDetection(void)
+{
+    InitStages++;
+    InitSequenceStateMachine(InitStages);
+    return OK;
+}
+
+uint32_t InitSequenceStartHeatingCallBackFunction(uint32_t IfIndex, uint32_t BusyFlag)
+{
+    if (HeaterCheckReady()==true)
+    {
+        if (SafeRemoveControlCallback(HWControlId, InitSequenceStartHeatingCallBackFunction )==OK)
+            HWControlId = 0xFF;
+        else
+            Report("Remove control callback failed",__FILE__,__LINE__,(int)HWControlId,RpWarning,(int)InitSequenceStartHeatingCallBackFunction,0);
+        InitStages++;
+        InitSequenceStateMachine(InitStages);
+    }
+    return OK;
+}
+uint32_t InitSequenceStartHeating(void)
+{
+    if (ProcessParamsInit() ==OK)
+    {
+        HWControlId = AddControlCallback( InitSequenceStartHeatingCallBackFunction, 2*eOneSecond/*eHundredMillisecond*/, TemplateDataReadCBFunction,0,0, 0 );
+        //start heaters with predefined / store process parameters
+    }
+    return OK;
+}
+uint32_t InitSequenceMachineReadyToDye(void)
+{
+    return OK;
+}
+uint32_t InitSequenceInitEnd(void)
+{
+    return OK;
+}
+
+uint32_t InitSequenceStateMachine( INIT_SEQUENCE_STAGES_ENUM ReadValue)
+{
+    REPORT_MSG(ReadValue,"InitSequenceStateMachine");
+    switch (ReadValue)
+    {
+        case INIT_SEQUENCE_INIT:
+            Start_InitSequence();
+            break;
+        case INIT_SEQUENCE_RESET_REASON:
+            InitSequenceResetReason();
+            break;
+        case INIT_SEQUENCE_BUILT_IN_TEST:
+            InitSequenceBuiltInTest();
+            break;
+        case INIT_SEQUENCE_INITIAL_BLOWER_ACTIVATION:
+            InitSequenceInitialBlowerActivation();
+            break;
+        case INIT_SEQUENCE_DISPENSER_PRESSURE_BIULDUP_TEST:
+            InitSequenceDispenserPressureBuildupTest();
+            break;
+        case INIT_SEQUENCE_THREAD_DETECTION:
+            InitSequenceThreadDetection();
+            break;
+        case INIT_SEQUENCE_START_HEATING:
+            InitSequenceStartHeating();
+            break;
+        case INIT_SEQUENCE_MACHINE_READY_TO_DYE:
+            InitSequenceMachineReadyToDye();
+            break;
+        case INIT_SEQUENCE_END:
+            InitSequenceInitEnd();
+            break;
+        default:
+            LOG_ERROR(ReadValue,"ERROR IN INIT STATE MACHINE");
+            break;
+    }
+return OK;
+}
diff --git a/Software/Embedded_SW/Embedded/StateMachines/Initialization/InitSequence.h b/Software/Embedded_SW/Embedded/StateMachines/Initialization/InitSequence.h
new file mode 100644
index 000000000..993df3912
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/StateMachines/Initialization/InitSequence.h
@@ -0,0 +1,16 @@
+/*
+ * InitSequence.h
+ *
+ *  Created on: Feb 12, 2019
+ *      Author: shlomo
+ */
+
+#ifndef STATEMACHINES_INITIALIZATION_INITSEQUENCE_H_
+#define STATEMACHINES_INITIALIZATION_INITSEQUENCE_H_
+
+
+uint32_t Start_InitSequence(void);
+
+
+
+#endif /* STATEMACHINES_INITIALIZATION_INITSEQUENCE_H_ */
diff --git a/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c b/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c
index fd7500606..cffe77000 100644
--- a/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c
+++ b/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c
@@ -719,62 +719,62 @@ void SendJobProgress(double ProcessedLength, int SegmentId, bool done, char *Mes
         Report(infomsg,__FILE__,__LINE__,55,RpWarning,33,  44);
     }*/
 
-    if (JobToken[0] == 0)
-        return;
-
-
-    ResumeCurrentJobResponse resumeresponse = RESUME_CURRENT_JOB_RESPONSE__INIT;
-    JobResponse response = JOB_RESPONSE__INIT;
-    JobStatus jobStatus = JOB_STATUS__INIT;
-
-    if (Message)
+    if (JobToken[0] != 0)
     {
-        jobStatus.message = Message;
-    }
-    //previousJobLength =  ProcessedLength;
-    jobStatus.has_progress = true;
-    jobStatus.progress = TotalProcessedLength;
-    jobStatus.has_currentsegmentindex = true;
-    jobStatus.currentsegmentindex = SegmentId;
+        ResumeCurrentJobResponse resumeresponse = RESUME_CURRENT_JOB_RESPONSE__INIT;
+        JobResponse response = JOB_RESPONSE__INIT;
+        JobStatus jobStatus = JOB_STATUS__INIT;
 
-    if (JobResumed == true)
-    {
-        resumeresponse.status = &jobStatus;
-        //responseContainer = createContainer(MESSAGE_TYPE__ResumeCurrentJobResponse,  JobToken, done, &resumeresponse, &resume_current_job_response__pack, &resume_current_job_response__get_packed_size);
-        responseContainer = createAllocatedContainer(MESSAGE_TYPE__ResumeCurrentJobResponse,  JobToken, done, &resumeresponse, &resume_current_job_response__pack, &resume_current_job_response__get_packed_size,&JobStatusBuffer);
-    }
-    else
-    {
-        response.status = &jobStatus;
-        //responseContainer = createContainer(MESSAGE_TYPE__JobResponse, JobToken, done, &response, &job_response__pack, &job_response__get_packed_size);
-        responseContainer = createAllocatedContainer(MESSAGE_TYPE__JobResponse, JobToken, done, &response, &job_response__pack, &job_response__get_packed_size,&JobStatusBuffer);
-    }
+        if (Message)
+        {
+            jobStatus.message = Message;
+        }
+        //previousJobLength =  ProcessedLength;
+        jobStatus.has_progress = true;
+        jobStatus.progress = TotalProcessedLength;
+        jobStatus.has_currentsegmentindex = true;
+        jobStatus.currentsegmentindex = SegmentId;
 
-    container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
-    if (done == true)
-    {
-        if(JobEndReason != JOB_OK)
+        if (JobResumed == true)
         {
-            responseContainer.has_error = true;
-            responseContainer.error = JobError_to_ErrorCode[JobEndReason];
+            resumeresponse.status = &jobStatus;
+            //responseContainer = createContainer(MESSAGE_TYPE__ResumeCurrentJobResponse,  JobToken, done, &resumeresponse, &resume_current_job_response__pack, &resume_current_job_response__get_packed_size);
+            responseContainer = createAllocatedContainer(MESSAGE_TYPE__ResumeCurrentJobResponse,  JobToken, done, &resumeresponse, &resume_current_job_response__pack, &resume_current_job_response__get_packed_size,&JobStatusBuffer);
         }
-        if (JobAbortedByUser == true)
+        else
         {
-            JobAbortedByUser = false;
-            responseContainer.has_error = true;
-            responseContainer.error = ERROR_CODE__CONTINUOUS_RESPONSE_ABORTED;
+            response.status = &jobStatus;
+            //responseContainer = createContainer(MESSAGE_TYPE__JobResponse, JobToken, done, &response, &job_response__pack, &job_response__get_packed_size);
+            responseContainer = createAllocatedContainer(MESSAGE_TYPE__JobResponse, JobToken, done, &response, &job_response__pack, &job_response__get_packed_size,&JobStatusBuffer);
         }
-    }
-    if (container_buffer)
-    {
-        size_t container_size = message_container__pack(&responseContainer, container_buffer);
-        //        if (SendChars(container_buffer, container_size) == false) //comm tx mailbox full
-        if (SendCharsWithType(container_buffer, container_size,MESSAGE_TYPE__JobResponse) == false) //comm tx mailbox full
+
+        container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
+        if (done == true)
         {
-            //AlarmHandlingToken[0] = 0;
-            my_free(container_buffer);
+            if(JobEndReason != JOB_OK)
+            {
+                responseContainer.has_error = true;
+                responseContainer.error = JobError_to_ErrorCode[JobEndReason];
+            }
+            if (JobAbortedByUser == true)
+            {
+                JobAbortedByUser = false;
+                responseContainer.has_error = true;
+                responseContainer.error = ERROR_CODE__CONTINUOUS_RESPONSE_ABORTED;
+            }
+        }
+        if (container_buffer)
+        {
+            size_t container_size = message_container__pack(&responseContainer, container_buffer);
+            //        if (SendChars(container_buffer, container_size) == false) //comm tx mailbox full
+            if (SendCharsWithType(container_buffer, container_size,MESSAGE_TYPE__JobResponse) == false) //comm tx mailbox full
+            {
+                //AlarmHandlingToken[0] = 0;
+                my_free(container_buffer);
+            }
         }
     }
+
     if (done == true)
     {
         if (CurrentRequest!= NULL)