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

20 files changed, 352 insertions, 101 deletions

diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
index add3a3800..25022ab67 100644
--- a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
+++ b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
@@ -584,7 +584,7 @@ void     AlarmHandlingSetCurrentLimits(double currentalarmhighlimit,double curre
 uint32_t AlarmhandlingFlags = 0;
 void     AlarmHandlingLoadFlags(void)
 {
-    MCU_E2PromRead(ALARM_SUPPORT_ADDR,&AlarmhandlingFlags);
+    MCU_E2PromRead(EEPROM_ALARM_SUPPORT,&AlarmhandlingFlags);
 
     CheckHardLimitAlarms = (AlarmhandlingFlags && 0x0001);
     CheckCurrentAlarms = (AlarmhandlingFlags && 0x0002);
@@ -607,7 +607,7 @@ void     AlarmHandlingSetFlags(bool checkHardLimitAlarms,bool checkCurrentAlarms
     if (CheckMotorAlarms) flags |= 0x8;
     if (AlarmhandlingFlags != flags)
     {
-        MCU_E2PromProgram(ALARM_SUPPORT_ADDR,flags);
+        MCU_E2PromProgram(EEPROM_ALARM_SUPPORT,flags);
         AlarmhandlingFlags = flags;
     }
 }
@@ -1189,7 +1189,13 @@ uint32_t AlarmHandlingLoop(uint32_t tick)
                             {
                                 if (AlarmItem[Alarm_i].AlarmDirection == true)
                                 {
-                                    if ((doubleValue >= (float)(AlarmItem[Alarm_i].AlarmValue*CurrentAlarmHighLimit)) || (doubleValue <= (float)(AlarmItem[Alarm_i].AlarmValue*CurrentAlarmLowLimit)))
+                                    if (doubleValue >= (float)(AlarmItem[Alarm_i].AlarmValue*CurrentAlarmHighLimit))
+                                    {
+                                        Status = true;
+                                        if (AlarmState[Alarm_i].Status == false)
+                                            ReportWithPackageFilter(AlarmFilter,"OverCurrent Alarm ON ", __FILE__,AlarmItem[Alarm_i].DeviceId,(int)(AlarmItem[Alarm_i].AlarmValue*100), RpMessage, (int)(doubleValue*100), 0);
+                                    }
+                                    if ((doubleValue <= (float)(AlarmItem[Alarm_i].AlarmValue*CurrentAlarmLowLimit))&&(isHeaterReady(AlarmItem[Alarm_i].DeviceId)==false))
                                     {
                                         Status = true;
                                         if (AlarmState[Alarm_i].Status == false)
diff --git a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
index 1cc8e766b..0e95f4053 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
+++ b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
@@ -59,6 +59,8 @@
 #include <Drivers/I2C_Communication/WHS_Card/D_ADS122_PT100/WHS_PT100_ADC.h>
 #include <Drivers/I2C_Communication/I2C_Task.h>
 #include <Drivers/I2C_Communication/WHS_Card/D_Max5805_ADC_Blower/WHS_Blower.h>
+#include "Modules/Heaters/Heaters_ex.h"
+#include <Drivers/I2C_Communication/WHS_Card/D_EMC2302_Fan/WHS_Fan.h>
 Task_Handle Millisecond_Task_Handle;
 /******************** Definitions  ********************************************/
 
@@ -694,6 +696,7 @@ uint32_t MillisecLowLoop(uint32_t tick)
     if (O600Millisecond_Tick)
     {
         Trigger_WHSReadAllFanTacho ();
+        DrierHeaterVoltageSetup();
         if (RapidPressureRead == false)
         {
             for (Disp_i = 0;Disp_i < MAX_SYSTEM_DISPENSERS;Disp_i++)
@@ -704,8 +707,8 @@ uint32_t MillisecLowLoop(uint32_t tick)
     }
     if (Onesecond_Tick)
     {
-        char Lenstr[160];
-        static int Counter = 0;
+        //char Lenstr[160];
+        //static int Counter = 0;
         MachineUpdateResponseFunc();
         //KeepAliveOneSecondCall();
 
@@ -725,8 +728,8 @@ uint32_t MillisecLowLoop(uint32_t tick)
         if (WHS_Type == WHS_TYPE_NEW)
         {
             Trigger_WHS_PT100_Read_All();
-            WHS_Blower_Avarege_ORF1(); //drier
-            WHS_Blower_Avarege_ORF3(); //head
+            WHS_Blower_Avarege(HEAD_FLOW_METER);
+            WHS_Blower_Avarege(DRIER_FLOW_METER);
             WHS_Start_Blower_Control_Closed_Loop ();
         }
     }
@@ -928,7 +931,7 @@ void HundredMicroTimerInterrupt(int ARG0)
     StoreBuffer[StoreBufferId][StoreBufferCounter++] = dancer2;
     StoreBuffer[StoreBufferId][StoreBufferCounter++] = dancer3;
     /*-----------------------*/
-    //len = usprintf(&StoreBuffer[StoreBufferId][StoreBufferCounter], "\r\n%d %d %d", dancer1[dancer_count],dancer2[dancer_count],dancer3[dancer_count]);
+    //len = usprintf(&StoreBuffer[StoreBufferId][StoreBufferCounter], "%d %d %d", dancer1[dancer_count],dancer2[dancer_count],dancer3[dancer_count]);
     //StoreBufferCounter+=(len+1);
     /*-----------------------*/
     dancer1sum+=dancer1;
@@ -977,7 +980,7 @@ void MillisecLogInit(void)
     if (FileHandle == 0)
         Fresult = FR_DENIED;
     else
-        Fresult = f_open(FileHandle,MillisecPath,FA_WRITE |  FA_OPEN_ALWAYS);
+        Fresult = f_open(FileHandle,MillisecPath,FA_WRITE |  FA_OPEN_ALWAYS|FA_CREATE_ALWAYS);
     ROM_IntMasterEnable();
     return ;
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Control/control.c b/Software/Embedded_SW/Embedded/Modules/Control/control.c
index bea68e314..0f9848ba1 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/control.c
+++ b/Software/Embedded_SW/Embedded/Modules/Control/control.c
@@ -51,6 +51,7 @@
 
 #include  <PMR/Diagnostics/EventType.pb-c.h>
 
+#include "drivers/FPGA/Full_Vme/FPGA_Programming_Up.h"
 #include "drivers/adc_sampling/adc.h"
 #include "drivers/FPGA/FPGA_GPIO/FPGA_GPIO.h"
 #include "drivers/FPGA/FPGA_SPI_Comm.h"
@@ -181,19 +182,22 @@ uint32_t ControlActivityLed( uint32_t Parameter1)
         ACTIVITY_RED_LED_OFF; // Heaters indication - all the Heaters OFF
         if(FPGA_WD_Occurred == true)
         {
-            FPGA_WD_Occurred = false;
-            AlarmHandlingSetAlarm(EVENT_TYPE__FPGA_WATCHDOG_ACTIVATED,true);
-            if (JobIsActive())
+            if (FPGABurningActive == false)
             {
-                JobEndReason = JOB_MOTOR_ALARM;
-                SendJobProgress(0.0,0,false, "Hardware Failure Error");
-                AbortJob("FPGA Watchdog Error");
-            }
-            ReportWithPackageFilter(FPGAFilter, "FPGA Watchdog Error",__FILE__,__LINE__,0,RpError, 0,0);
+                FPGA_WD_Occurred = false;
+                AlarmHandlingSetAlarm(EVENT_TYPE__FPGA_WATCHDOG_ACTIVATED,true);
+                if (JobIsActive())
+                {
+                    JobEndReason = JOB_MOTOR_ALARM;
+                    SendJobProgress(0.0,0,false, "Hardware Failure Error");
+                    AbortJob("FPGA Watchdog Error");
+                }
+                ReportWithPackageFilter(FPGAFilter, "FPGA Watchdog Error",__FILE__,__LINE__,0,RpError, 0,0);
 
-            ACTIVITY_GREEN_LED_ON;
-            FPGA_SetMotorsInit();
-            Motor_ReconfigAllMotors();
+                ACTIVITY_GREEN_LED_ON;
+                FPGA_SetMotorsInit();
+                Motor_ReconfigAllMotors();
+            }
         }
 		else
             ACTIVITY_GREEN_LED_OFF;
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c
index 41f6b2334..42739f20f 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c
@@ -371,9 +371,9 @@ uint32_t SetBlowerStateRequestFunc(MessageContainer* requestContainer)
             if (Head_Type == HEAD_TYPE_STAPLE_SPUN)
             {
                 if ((request->has_voltage)&&(request->isactive == true))
-                    status = Head_Fan_PWM_Control(0,request->voltage);
+                    Trigger_Head_Fan_Control(HEAD_FAN_RIGHT,request->voltage);
                 else if (request->isactive == false)
-                    status = Head_Fan_PWM_Control(0,0);
+                    Trigger_Head_Fan_Control(HEAD_FAN_RIGHT,0);
             }
             else
                 status = NOT_SUPPORTED;
@@ -383,9 +383,9 @@ uint32_t SetBlowerStateRequestFunc(MessageContainer* requestContainer)
             if (Head_Type == HEAD_TYPE_STAPLE_SPUN)
             {
                 if ((request->has_voltage)&&(request->isactive == true))
-                    status = Head_Fan_PWM_Control(1,request->voltage);
+                    Trigger_Head_Fan_Control(HEAD_FAN_LEFT,request->voltage);
                 else if (request->isactive == false)
-                    status = Head_Fan_PWM_Control(1,0);
+                    Trigger_Head_Fan_Control(HEAD_FAN_LEFT,0);
             }
             else
                 status = NOT_SUPPORTED;
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
index 8ee9b06ae..bfcf379d0 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
@@ -314,6 +314,7 @@ uint32_t DiagnosticsLoadDigitalValues(void)
     DigitalOutputState[index].interfaceio = INTERFACE_IOS__GPO_SPARE_SSR13_CTRL;
     DigitalOutputState[index++].value = ReadHeadMagnetBit();
 
+    //  indication of movement cause the switch in the tech board to change, also doesn't go through the task
     /*if (Head_Type == HEAD_TYPE_SYLKO) //rapid/pp machines
     {
         DigitalOutputState[index].interfaceio = INTERFACE_IOS__GPO_LED3;
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c
index be8e84f3e..bdbf1b33e 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c
@@ -39,11 +39,21 @@ char HomingToken[NUM_OF_MOTORS][36+1]={0};
 /********************************************************************************
  * Motor Homing
  ********************************************************************************/
+//int32_t keepkvalright,keepkvalleft;
+
 uint32_t MotorHomingRequestCallback(uint32_t deviceID, uint32_t ReadValue)
 {
     MessageContainer responseContainer;
     MotorHomingResponse response = MOTOR_HOMING_RESPONSE__INIT;
 
+    if(deviceID == HARDWARE_MOTOR_TYPE__MOTO_RLOADING)
+    {
+        MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_RLOADING, 24);
+    }
+    if(deviceID == HARDWARE_MOTOR_TYPE__MOTO_LLOADING)
+    {
+        MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_LLOADING, 24);
+    }
     responseContainer = createContainer(MESSAGE_TYPE__MotorHomingResponse, HomingToken[deviceID], true, &response, &motor_homing_response__pack, &motor_homing_response__get_packed_size);
     responseContainer.has_continuous = true;
     responseContainer.continuous = true;
@@ -82,7 +92,14 @@ uint32_t MotorHomingRequestFunc(MessageContainer* requestContainer)
             {
                 if(MotorId == HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID)
                 {
-                    MotorGotoWithCallback(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID, DRIER_LID_OPEN, GPI_LS_DRYER_LID_OPEN, MotorHomingRequestCallback,10000);
+                    if (MotorDriverResponse[HARDWARE_MOTOR_TYPE__MOTO_RLOADARM].DriverType == CombinrdMotDriver)
+                    {
+                        MotorGotoWithCallback(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID, DRIER_LID_CLOSE, GPI_LS_DRYER_LID_CLOSED, MotorHomingRequestCallback,4000);
+                    }
+                    else
+                    {
+                        MotorGotoWithCallback(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID, DRIER_LID_OPEN, GPI_LS_DRYER_LID_OPEN, MotorHomingRequestCallback,4000);
+                    }
                     return OK;
                 }
                 else
@@ -100,6 +117,16 @@ uint32_t MotorHomingRequestFunc(MessageContainer* requestContainer)
                     }
                     if ( Motor_Id_to_LS_IdDown[MotorId] != MAX_GPI)
                     {
+                        if(MotorId == HARDWARE_MOTOR_TYPE__MOTO_RLOADING)
+                        {
+                            //keepkvalright = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].kvalrun;
+                            MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_RLOADING, 70);
+                        }
+                        if(MotorId == HARDWARE_MOTOR_TYPE__MOTO_LLOADING)
+                        {
+                            //keepkvalleft = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LLOADING].kvalrun;
+                            MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_LLOADING, 70);
+                        }
                         MotorMovetoLimitSwitch (MotorId,1-MotorsCfg[MotorId].directionthreadwize, speed,  Motor_Id_to_LS_IdUp[MotorId], MotorHomingRequestCallback,30000);
                         return OK;
                     }
@@ -110,7 +137,14 @@ uint32_t MotorHomingRequestFunc(MessageContainer* requestContainer)
             {
                 if(MotorId == HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID)
                 {
-                    MotorGotoWithCallback(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID, DRIER_LID_CLOSE, GPI_LS_DRYER_LID_CLOSED, MotorHomingRequestCallback,4000);
+                    if (MotorDriverResponse[HARDWARE_MOTOR_TYPE__MOTO_RLOADARM].DriverType == CombinrdMotDriver)
+                    {
+                        MotorGotoWithCallback(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID, DRIER_LID_OPEN, GPI_LS_DRYER_LID_OPEN, MotorHomingRequestCallback,4000);
+                    }
+                    else
+                    {
+                        MotorGotoWithCallback(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID, DRIER_LID_CLOSE, GPI_LS_DRYER_LID_CLOSED, MotorHomingRequestCallback,4000);
+                    }
                     return OK;
                 }
                 else
@@ -132,6 +166,16 @@ uint32_t MotorHomingRequestFunc(MessageContainer* requestContainer)
                     }
                     if ( Motor_Id_to_LS_IdUp[MotorId] != MAX_GPI)
                     {
+                        if(MotorId == HARDWARE_MOTOR_TYPE__MOTO_RLOADING)
+                        {
+                            keepkvalright = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].kvalrun;
+                            MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_RLOADING, 70);
+                        }
+                        if(MotorId == HARDWARE_MOTOR_TYPE__MOTO_LLOADING)
+                        {
+                            keepkvalleft = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LLOADING].kvalrun;
+                            MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_LLOADING, 70);
+                        }
                         MotorMovetoLimitSwitch (MotorId,MotorsCfg[MotorId].directionthreadwize, speed,  Motor_Id_to_LS_IdDown[MotorId], MotorHomingRequestCallback,10000);
                         return OK;
                     }
@@ -139,6 +183,7 @@ uint32_t MotorHomingRequestFunc(MessageContainer* requestContainer)
             }
         }
     }
+    responseContainer.has_error = true;
     responseContainer.error = ERROR_CODE__INVALID_PROCESS_ID;
     responseContainer.errormessage = "Job Active or incorrect motor ID";
     responseContainer = createContainer(MESSAGE_TYPE__MotorHomingResponse,  requestContainer->token, true, &response, &motor_homing_response__pack, &motor_homing_response__get_packed_size);
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsJogging.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsJogging.c
index e2eb264a7..a1a0c96c1 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsJogging.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsJogging.c
@@ -90,6 +90,7 @@ uint32_t MotorJoggingRequestFunc(MessageContainer* requestContainer)
     responseContainer = createContainer(MESSAGE_TYPE__MotorJoggingResponse,  requestContainer->token, false, &response, &motor_jogging_response__pack, &motor_jogging_response__get_packed_size);
     if (status!= OK)
     {
+        responseContainer.has_error = true;
         responseContainer.error = ERROR_CODE__INVALID_PROCESS_ID;
         responseContainer.errormessage = "JOb Active or incorrect parameters";
     }
@@ -191,6 +192,7 @@ uint32_t DispenserJoggingRequestFunc(MessageContainer* requestContainer)
     responseContainer = createContainer(MESSAGE_TYPE__DispenserJoggingResponse,  requestContainer->token, false, &response, &dispenser_jogging_response__pack, &dispenser_jogging_response__get_packed_size);
     if (status!= OK)
     {
+        responseContainer.has_error = true;
         responseContainer.error = ERROR_CODE__INVALID_PROCESS_ID;
         responseContainer.errormessage = "JOb Active or incorrect parameters";
     }
diff --git a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
index ec59385ab..618d4569c 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
@@ -53,6 +53,7 @@
 #include "Modules/Waste/Waste.h"
 #include "Drivers/I2C_Communication/Main_Board_EEPROM/Main_EEPROM.h"
 #include <Modules/Waste/newWHS_init.h>
+#include <Drivers/I2C_Communication/I2C_Task.h>
 
 uint32_t EmbeddedParametersInit(void);
 uint32_t EmbeddedParametersWrite(void * buffer, uint16_t size);
@@ -367,7 +368,7 @@ uint32_t EmbeddedParametersInit(void)
 
     return Fresult;
 }
-uint32_t GenHWControlId;
+/*uint32_t GenHWControlId;
 
 uint32_t GenHWInitCallBackFunction(uint32_t IfIndex, uint32_t BusyFlag)
 {
@@ -380,7 +381,7 @@ uint32_t GenHWInitCallBackFunction(uint32_t IfIndex, uint32_t BusyFlag)
             Disable_MidTank_Pressure_Reading(Dispenser_i);
     }
     return OK;
-}
+}*/
 
 uint32_t HWConfiguration(UploadHardwareConfigurationRequest* UploadRequest)
 {
@@ -556,8 +557,8 @@ uint32_t MachineCalibrationDataRequestFunc(MessageContainer* requestContainer)
         MidTankInfo[i].has_slopeb = true;
         MidTankInfo[i].slopeb = MCU_E2PromReadMidtank_B(i);
     }
-    memset (Serial,0,20);
-    MCU_E2PromSerialNumRead(&Serial);
+    //memset (Serial,0,20);
+    //MCU_E2PromSerialNumRead(&Serial);
 
     MachineCalibrationDataResponse response = MACHINE_CALIBRATION_DATA_RESPONSE__INIT;
     machine_calibration_data__init(&response.machinecalibrationdata);
@@ -648,6 +649,7 @@ uint32_t HWConfigurationFunc(MessageContainer* requestContainer)
     responseContainer = createContainer(MESSAGE_TYPE__UploadHardwareConfigurationResponse, requestContainer->token, true, &response, &upload_hardware_configuration_response__pack, &upload_hardware_configuration_response__get_packed_size);
     if (status!= OK)
     {
+        responseContainer.has_error = true;
         responseContainer.error = ERROR_CODE__INVALID_PARAMETER;
         responseContainer.errormessage = "JOb Active or incorrect parameters";
     }
@@ -726,7 +728,6 @@ uint32_t LoadConfigurationParamsFromFile(bool Initialize)
 }
 void HWConfigurationLoadFile(void)
 {
-    FRESULT Fresult = FR_OK;
     uint8_t* buffer = NULL;
     uint32_t Bytes = 0;
     buffer = HWConfigurationLoadFromFile(&Bytes); //load hardware config
diff --git a/Software/Embedded_SW/Embedded/Modules/General/MachineStatus.c b/Software/Embedded_SW/Embedded/Modules/General/MachineStatus.c
index 3f557496c..146c62bb6 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/MachineStatus.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/MachineStatus.c
@@ -27,7 +27,7 @@
 #include "Modules/Control/MillisecTask.h"
 #include "modules/ids/ids_ex.h"
 
-MachineState StoredMachineStatus = MACHINE_STATE__Ready;
+MachineState StoredMachineStatus = MACHINE_STATE__PowerUp;
 
 void SetMachineStatus (MachineState State)
 {
diff --git a/Software/Embedded_SW/Embedded/Modules/General/Safety.c b/Software/Embedded_SW/Embedded/Modules/General/Safety.c
index 139763c75..9680e11d0 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/Safety.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/Safety.c
@@ -47,6 +47,11 @@ uint32_t Safety_Main_State(uint32_t IfIndex, uint32_t BusyFlag)
    bool mAirFlowAlarmState = false;
    bool mAirFilterAlarmState = false;
    bool mWasteOverflowAlarmState = false;
+#ifdef CONTROL_DEBUG
+    uint32_t tempp,tempq,delta;
+    uint32_t sys_ticks_start = msec_millisecondCounter,sys_ticks_end,max = 0,dev = 0;
+    tempp = HibernateRTCSSGet();
+#endif
    for (Disp_i = 0;Disp_i < MAX_SYSTEM_DISPENSERS;Disp_i++)
    {
        if (isMotorConfigured(Disp_i + HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1)==true)
@@ -194,6 +199,19 @@ uint32_t Safety_Main_State(uint32_t IfIndex, uint32_t BusyFlag)
        AlarmHandlingSetAlarm(EVENT_TYPE__WASTE_CONTAINER_OVERFLOW, false);
        WasteOverflowAlarmState = mWasteOverflowAlarmState;
    }
+#ifdef CONTROL_DEBUG
+                tempq = HibernateRTCSSGet();
+                if (tempq < tempp)
+                {
+                  delta = (32768 - tempp) + tempq + 1;
+                }
+                else
+                  delta = tempq - tempp;
+                if (delta>1000)
+                {
+                    ReportWithPackageFilter(GeneralFilter,"------ Safety Delta  ------------", __FILE__,delta,tempq, RpMessage,tempp, 0);
+                }
+#endif
 
     return OK;
 }
diff --git a/Software/Embedded_SW/Embedded/Modules/General/process.c b/Software/Embedded_SW/Embedded/Modules/General/process.c
index c270c9828..4cb35d488 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/process.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/process.c
@@ -25,7 +25,7 @@
 #include "StateMachines/Initialization/InitSequence.h"
 
 #include "drivers/Flash_ram/FlashProgram.h"
-
+#include <Drivers/I2C_Communication/I2C_Task.h>
 
 double dyeingspeed = 0;
 double dryerbufferlength = 0;
@@ -81,6 +81,7 @@ uint32_t HandleProcessParameters(ProcessParameters* ProcessParams,bool saveData)
     if (ProcessParams==NULL)
         {
             status = ERROR_CODE__INVALID_PARAMETER;
+            ReportWithPackageFilter(InitFilter,"HandleProcessParameters NULL",__FILE__,(int)__LINE__,(int)0,RpWarning,(int)0,0);
             return status;
         }
     if (ProcessParams->dryerzone1temp > MAX_ALLOWED_TEMPERATURE) status = ERROR_CODE__INVALID_PARAMETER;
@@ -94,9 +95,13 @@ uint32_t HandleProcessParameters(ProcessParameters* ProcessParams,bool saveData)
     if (ProcessParams->headzone5temp > MAX_ALLOWED_TEMPERATURE) status = ERROR_CODE__INVALID_PARAMETER;
     if (ProcessParams->headzone6temp > MAX_ALLOWED_TEMPERATURE) status = ERROR_CODE__INVALID_PARAMETER;
     if (status != 0)
+    {
+        ReportWithPackageFilter(InitFilter,"HandleProcessParameters Temperature too high",__FILE__,(int)__LINE__,(int)status,RpWarning,(int)0,0);
         return status;
+    }
     if (GetMachineState()<MACHINE_STATE_NO_PROCESS_PARAMS)
     {
+        ReportWithPackageFilter(InitFilter,"HandleProcessParameters Init not ready",__FILE__,(int)__LINE__,(int)status,RpWarning,(int)GetMachineState(),0);
         status = ERROR_CODE__GENERAL_ERROR;
         return status;
     }
@@ -116,6 +121,7 @@ uint32_t HandleProcessParameters(ProcessParameters* ProcessParams,bool saveData)
             REPORT_MSG(Bytes,"Bytes write to flash");
         }
     }
+
     if (ProcessParams->mixertemp>1)
         status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__MixerHeater, true,ProcessParams->mixertemp);
     else
@@ -228,31 +234,38 @@ uint32_t HandleProcessParameters(ProcessParameters* ProcessParams,bool saveData)
     }
     if(Head_Type == HEAD_TYPE_STAPLE_SPUN)
     {
-        if (ProcessParams->stspzone1temp>1)
+        if (ProcessParams->rblowertemp>1)
         {
-            status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadCoverHeater1, true,ProcessParams->stspzone1temp);
+            status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadCoverHeater1, true,ProcessParams->rblowertemp);
         }
         else
         {
-            status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadCoverHeater1, false,ProcessParams->stspzone1temp);
+            status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadCoverHeater1, false,ProcessParams->rblowertemp);
         }
-        if (ProcessParams->stspzone2temp>1)
+        if (ProcessParams->lblowertemp>1)
         {
-            status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadCoverHeater2, true,ProcessParams->stspzone2temp);
+            status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadCoverHeater2, true,ProcessParams->lblowertemp);
         }
         else
         {
-            status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadCoverHeater2, false,ProcessParams->stspzone2temp);
+            status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadCoverHeater2, false,ProcessParams->lblowertemp);
         }
+        Trigger_Head_Fan_Control(HEAD_FAN_RIGHT,ProcessParams->rblowerflow);
+        Trigger_Head_Fan_Control(HEAD_FAN_LEFT,ProcessParams->lblowerflow);
     }
 
+    if (status)
+    {
+        ReportWithPackageFilter(InitFilter,"HandleProcessParameters start heaters error",__FILE__,(int)__LINE__,(int)status,RpWarning,(int)GetMachineState(),0);
+    }
     HeatersStopControlOnHeatersOff(ProcessParams);
     dyeingspeed = ProcessParams->dyeingspeed;
     dryerbufferlength = ProcessParams->dryerbufferlength;
     dryerbufferMeters = dryerbufferlength*0.76+0.9;
     dryerbufferCentimeters = dryerbufferlength*76+90;
 
-    Report("drier buffer length",__FILE__,(int)dryerbufferlength,(int)dryerbufferMeters*100,RpWarning,(int)dryerbufferCentimeters,0);
+    //Report("drier buffer length",__FILE__,(int)dryerbufferlength,(int)dryerbufferMeters*100,RpWarning,(int)dryerbufferCentimeters,0);
+    ReportWithPackageFilter(InitFilter,"HandleProcessParameters Head type",__FILE__,(int)__LINE__,(int)Head_Type,RpWarning,(int)dryerbufferCentimeters,0);
 
     mininkuptake = ProcessParams->mininkuptake;
     feedertension = ProcessParams->feedertension;
diff --git a/Software/Embedded_SW/Embedded/Modules/General/process.h b/Software/Embedded_SW/Embedded/Modules/General/process.h
index 97d28f1ef..a546ffdbe 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/process.h
+++ b/Software/Embedded_SW/Embedded/Modules/General/process.h
@@ -26,6 +26,7 @@ extern ProcessParameters ProcessParametersKeep;
 
 extern void ProcessRequestFunc(MessageContainer* requestContainer);
 extern uint32_t HandleProcessParameters(ProcessParameters* ProcessParams,bool saveData);
+uint32_t LoadProcessParamsFromFile(void);
 uint32_t ProcessParamsInit(void);
 
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h
index 0c6ee94ee..aeec7d696 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h
@@ -23,6 +23,7 @@ void HeatingTestRequest(MessageContainer* requestContainer);
 void HeatingTestPollRequest(MessageContainer* requestContainer);
 
 bool HeaterCheckReady(void);
+bool isHeaterReady(uint8_t HeaterId);
 
 bool HeaterGetOverTemperatureState(uint8_t HeaterId);
 
@@ -33,7 +34,9 @@ uint32_t LoadHeaterSetPoint(HeaterType HeaterType);
 void Heaters_SetOverHeatTimeOutValues(uint32_t OverHeatTimeout, uint32_t UnderHeatTimeout);
 void  Heaters_SetOperationLimits(int acheatersloweroperationlimit,int acheatersupperoperationlimit,int dcheatersloweroperationlimit,int dcheatersupperoperationlimit);
 
+uint32_t DrierHeaterVoltageSetup(void);
 
 uint32_t HeatersEnd(void);
+void HeatersControlStart(void);
 void HeatersControlStop(void);
 uint32_t Heaters_Init(void);
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
index 06da53823..ca4255a95 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
@@ -24,6 +24,7 @@
 #include "../control/pidalgo.h"
 #include "../control/MillisecTask.h"
 #include "../Ids/Ids_ex.h"
+#include "../General/process.h"
 
 #include <ti/sysbios/knl/Task.h>
 #include <driverlib/timer.h>
@@ -37,6 +38,7 @@
 #include "drivers/I2C_Communication/ADC_MUX/ADC_MUX.h"
 #include "drivers/I2C_Communication/Head_Card/ADC/Head_ADC.h"
 #include "Drivers/I2C_Communication/I2C.h"
+#include <Drivers/I2C_Communication/WHS_Card/D_Max5805_ADC_Blower/WHS_Blower.h>
 
 #include "StateMachines/Printing/PrintingSTM.h"
 #include "StateMachines/Initialization/PowerIdle.h"
@@ -320,7 +322,7 @@ uint32_t HeatersTestInternalAlarmsCBFunction(uint32_t IfIndex, uint32_t readValu
     }
 
     readValue = MillisecGetTemperatures(InternalId2PT100Id[index]);
-    if((MINIMUM_HEATER_READ*100>=readValue)||(270.00*100 < readValue))
+    if((MINIMUM_HEATER_READ*100>=readValue)||(200.00*100 < readValue))
     {
         //ReportWithPackageFilter(HeatersFilter,"PT100 not working properly",__FILE__,__LINE__,HeaterId,RpError, 0,0);
         return ERROR;
@@ -662,7 +664,7 @@ void PrepareACHeater(int HeaterId,uint32_t Frequency, uint32_t SetTemperatue)
             DeActivateHeater(HeaterId);
             HeaterCmd[HeaterId].targettemperatue = 0;
 #warning PT100 error is misidentified as overheat in alarms
-            AlarmHandlingSetAlarm(HeaterEventType[HeaterId], true);
+            AlarmHandlingSetAlarm(EVENT_TYPE__POWER_UP_BIT_FAILURE, true);
 
             return;
         }
@@ -699,13 +701,12 @@ void PrepareACHeater(int HeaterId,uint32_t Frequency, uint32_t SetTemperatue)
     HeaterAtTemp[HeaterId] = false;
     if (BlowerCfg.enabled == true)
     {
-        //WHS_Start_Blower_Control_Closed_Loop(2.5);
         Turn_the_Blower_On();//Turn on with the Default_Voltage
         if (BlowerCfg.heatingvoltage)
             Control_Voltage_To_Blower(BlowerCfg.heatingvoltage);
         else
             Control_Voltage_To_Blower(BlowerCfg.voltage-500);
-
+        WHS_Set_SetPoint_Q_value(headairflow/2);
     }
     if (SetTemperatue)
     {
@@ -738,7 +739,7 @@ int PrepareDCHeater(int HeaterId, uint32_t Frequency, uint32_t SetTemperatue)
             ControlIdtoHeaterId [HeaterId] = 0xFF;
         }
         DeActivateHeater(HeaterId);
-        AlarmHandlingSetAlarm(HeaterEventType[HeaterId], true);
+        AlarmHandlingSetAlarm(EVENT_TYPE__POWER_UP_BIT_FAILURE, true);
         HeaterCmd[HeaterId].targettemperatue = 0;
 
         return ERROR;
@@ -833,6 +834,13 @@ uint32_t PrepareHeater(int HeaterId, uint32_t SetTemperatue)
     }
     return OK;
 }
+bool isHeaterReady(uint8_t HeaterId)
+{
+    if (HeaterId<HEATER_TYPE_MAX_HEATERS)
+        return HeaterReady[HeaterId];
+    else
+        return false;
+}
 bool HeaterCheckReady(void)
 {
     int i;
@@ -900,6 +908,7 @@ uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue)
         }
         else
         {
+            ReportWithPackageFilter(HeatersFilter,"restoring read Temperature Spike",__FILE__,index,HeaterPreviousRead[index],RpWarning,HeaterSpikeRead[index], index);
             HeaterPreviousRead[index] = HeaterSpikeRead[index];
             HeaterSpikeRead[index] = 0;
         }
@@ -1080,7 +1089,7 @@ 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)
         {
-            if (HeaterSpikeRead[index] == 0)
+            /*if (HeaterSpikeRead[index] == 0)
             {
                 HeaterSpikeRead[index] = readValue;
             }
@@ -1088,7 +1097,7 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
             {
                 HeaterPreviousRead[index] = HeaterSpikeRead[index];
                 HeaterSpikeRead[index] = 0;
-            }
+            }*/
             DeActivateHeater(HEATER_TYPE__DryerSecondaryHeater);
             DeActivateHeater(HEATER_TYPE__DryerMainHeater);
             HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerMainHeater,0);
@@ -1170,11 +1179,11 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
             AlarmHandlingSetAlarm(HeaterUnderEventType[index], false);
             if (BlowerCfg.enabled == true)
             {
-                //WHS_Start_Blower_Control_Closed_Loop(5.0);
                 Turn_the_Blower_On();//Turn on with the Default_Voltage
                 if (BlowerCfg.voltage)
                     //Gradual_Increase_Blower(BlowerCfg.heatingvoltage,BlowerCfg.voltage);
                     Control_Voltage_To_Blower(BlowerCfg.voltage);
+                WHS_Set_SetPoint_Q_value(headairflow);
             }
             HeaterReady[index] = true;
             //Disable_Reading_Heaters_Current(HeaterId2CurrentId[HEATER_TYPE__DryerMainHeater]);
@@ -1294,6 +1303,7 @@ uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
             }
             else
             {
+                ReportWithPackageFilter(HeatersFilter,"restoring read Temperature Spike",__FILE__,index,HeaterPreviousRead[index],RpWarning,HeaterSpikeRead[index], index);
                 HeaterPreviousRead[index] = HeaterSpikeRead[index];
                 HeaterSpikeRead[index] = 0;
             }
@@ -1503,13 +1513,16 @@ double TotalCurrentLimit(double VAC)
     }
 
 }
-uint32_t DrierHeaterVoltageSetup(double voltage)
+uint32_t DrierHeaterVoltageSetup(void)
 {
     double DrierAcVoltage = 0.0;
     char str[100];
     bool tempDrier2 = UseSecondaryDrierHeater;
+    double Z1Current,Z2AssumedCurrent,LimitCurrent;
 
+#ifndef VAC_TEST
     if (Head_Type > HEAD_TYPE_SYLKO_WITHOUT_CARD) //rapid/pp machines
+#endif
     {
         DrierAcVoltage = ReadVAC();
         if (DrierAcVoltage<=180)
@@ -1536,7 +1549,10 @@ uint32_t DrierHeaterVoltageSetup(double voltage)
         }
         else
         {
-            if ((GetZone2RMSCurrent(DrierAcVoltage)+Get_Heaters_Current(HEATER_DRYER_CURRENT_1))>TotalCurrentLimit(DrierAcVoltage))
+            Z1Current = Get_Heaters_Current(HEATER_DRYER_CURRENT_1);
+            Z2AssumedCurrent = GetZone2RMSCurrent(DrierAcVoltage);
+            LimitCurrent = TotalCurrentLimit(DrierAcVoltage);
+            if ((Z2AssumedCurrent+Z1Current)>LimitCurrent)
             {
                 UseSecondaryDrierHeater = false;
             }
@@ -1546,15 +1562,22 @@ uint32_t DrierHeaterVoltageSetup(double voltage)
             }
         }
     }
+#ifndef VAC_TEST
     else
     {
         UseSecondaryDrierHeater = true;
     }
+#endif
     if (tempDrier2 != UseSecondaryDrierHeater)
     {
-        usnprintf(str, 100, "\r\n Changing Drier 2 setting VAC %d D1 Current %d D2 assumed current %d limit %d"
-                        ,DrierAcVoltage,(int)(GetZone2RMSCurrent(DrierAcVoltage)*100),(int)(Get_Heaters_Current(HEATER_DRYER_CURRENT_1)*100),(int)(TotalCurrentLimit(DrierAcVoltage)*100));
+        usnprintf(str, 100, "Changing Drier 2 from %d to %d  VAC %d D1 Current %d D2 assumed current %d limit %d" ,tempDrier2,UseSecondaryDrierHeater
+                        ,(int)DrierAcVoltage,(int)(Z1Current*100),(int)(Z2AssumedCurrent*100),(int)(LimitCurrent*100));
         ReportWithPackageFilter(HeatersFilter,str, __FILE__,__LINE__,DrierAcVoltage, RpMessage, UseSecondaryDrierHeater, 0);
+        if (UseSecondaryDrierHeater == false)
+        {
+            DeActivateHeater (HEATER_TYPE__DryerSecondaryHeater);
+        }
+
     }
 return OK;
 }
@@ -1565,7 +1588,7 @@ uint32_t HeatersControlLoop(uint32_t tick)
     int DcHeaterId;
     bool AcHeaterDisaster = false;
 
-    /*len = usnprintf(str, 100, "\r\n EightMilliSecondHeatersInterrupt SliceCounter %d Owner %d H1000 %d  H2000 %d"
+    /*len = usnprintf(str, 100, " EightMilliSecondHeatersInterrupt SliceCounter %d Owner %d H1000 %d  H2000 %d"
                     ,SliceCounter,TimeSliceAllocation[SliceCounter],HeatersRestart,NumberOFSlicesInUse);
     ReportWithPackageFilter(HeatersFilter,str, __FILE__,__LINE__,0, RpMessage, SliceCounter, TimeSliceAllocation[SliceCounter]);
 */
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
index ccd051c71..76a92bd89 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
@@ -33,7 +33,7 @@
 #include "modules/heaters/heaters_ex.h"
 #include <Drivers/I2C_Communication/I2C.h>
 #include <Drivers/I2C_Communication/Head_Card/I2C_Head_Mux.h>
-#include <Drivers/I2C_Communication/Head_Card/IO_Ports/Head_IO.h>
+#include "Drivers/I2C_Communication/Head_Card/IO_Ports/Head_IO.h"
 #include "drivers/adc_sampling/adc.h"
 #include <Drivers/I2C_Communication/WHS_Card/D_EMC2302_Fan/WHS_Fan.h>
 #include <Drivers/I2C_Communication/WHS_Card/WHS_data.h>
@@ -43,7 +43,10 @@
 #include <Drivers/I2C_Communication/WHS_Card/D_MAX11614_ADC/WHS_MAX11614_A2D.h>
 #include <Drivers/I2C_Communication/WHS_Card/IO_Extender_Ports_TCA9555/WHS_IO.h>
 
-#include "Drivers/I2C_Communication/Head_Card/IO_Ports/Head_IO.h"
+
+#include "Drivers/I2C_Communication/Dispenser_Card/EEPROM/Dispenser_EEPROM.h"
+
+
 
 extern float NumberOfRotationPerPassage;  // how many rotations per spool passage
 
@@ -109,11 +112,12 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
         }
     }
     else
-        if((request->amount == 0x3E8) && (request->delay <= 0x0fff))// set WHS Blower speed 0x00-0xfff
+        if(request->amount == 0x3E8) //&& (request->delay <= 0x0fff))// set WHS Blower speed 0x00-0xfff
         {
             if (WHS_Type == WHS_TYPE_NEW)
             {
-                Trigger_SetWHSBlowerVoltage (request->delay);
+                WHS_enable_control_loop( request->delay & 0x1000);//disable control loop: 0=disable 1= enable
+                Trigger_SetWHSBlowerVoltage (request->delay & 0x0FFF);
                 response.progress = 0;
                 response.has_progress = false;
             }
@@ -144,9 +148,38 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
         {
             uint16_t tempu16 = 0;
             double temp_double = 0.0;
+            uint8_t display_byte = 0;
+            uint16_t A2D_data = 0;
+
             if (WHS_Type == WHS_TYPE_NEW)
             {
-                switch(request->delay )// get A2D
+                display_byte = ((request->delay & 0x3000)>>12);
+                switch (display_byte)
+                {
+                case 0:
+                    //stubManager.Run<ProgressResponse>("ProgressRequest" ,0x3EA, /*DisplayView =*/0x0000); //
+                    SetLeftDisplayView (HeadAVERAGE);
+                    SetWriteDisplayView(DrierAVERAGE);
+                    break;
+                case 1:
+                    //stubManager.Run<ProgressResponse>("ProgressRequest" ,0x3EA, /*DisplayView =*/0x1000); //
+                    SetLeftDisplayView (HeadAVERAGE);
+                    SetWriteDisplayView(HeadCURRENT);
+                    break;
+                case 2:
+                    //stubManager.Run<ProgressResponse>("ProgressRequest" ,0x3EA, /*DisplayView =*/0x2000); //
+                    SetLeftDisplayView (DrierAVERAGE);
+                    SetWriteDisplayView(DrierCURRENT);
+                    break;
+                case 3:
+                    //stubManager.Run<ProgressResponse>("ProgressRequest" ,0x3EA, /*DisplayView =*/0x3000); //
+                    SetLeftDisplayView (HeadCURRENT);
+                    SetWriteDisplayView(DrierCURRENT);
+                    break;
+                }
+
+                A2D_data = (request->delay & 0x0FFF);
+                switch(A2D_data )// get A2D
                 {
                     case 0:
                         get_orf_1(&tempu16);
@@ -176,16 +209,16 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
                         tempu16 = 0;  //get_cur_vlv2(&tempu16);
                         break;
                     case 10:
-                        temp_double = get_ORF1_Q();
+                        temp_double = get_Q(HEAD_FLOW_METER);
                         break;
                     case 12:
-                        temp_double = get_ORF3_Q();
+                        temp_double = get_Q(DRIER_FLOW_METER);
                         break;
                     case 20:
-                        temp_double = get_average_ORF1_Q();
+                        temp_double = get_average_Q(HEAD_FLOW_METER); //HEAD
                         break;
                     case 22:
-                        temp_double = get_average_ORF3_Q();
+                        temp_double = get_average_Q(DRIER_FLOW_METER); //Drier
                         break;
 
                     case 11:
@@ -236,7 +269,7 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
             }
             else
             {
-                Trigger_WHS_set_Rheostat_to_CLEAN_AIR();
+                //Trigger_WHS_set_Rheostat_to_CLEAN_AIR();
             }
             get_gas_out(&tempu16);
         }
@@ -464,6 +497,12 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
             else
                 HeadCard_Control_Heaters((request -> delay & 0xFF00)>>8, FALSE);
         }
+        else
+        if(request -> delay == 0x0)//return head type
+        {
+            response.progress = Head_Type;
+            response.has_progress = true;
+        }
 
     }
     else
@@ -472,7 +511,7 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
         //Head_Fan_PWM_Command[0] = (request->delay & 0xFF) ;
         //Test_Head_fan_Click();
 
-        Head_Fan_PWM_Control(0, request->delay & 0xFF);
+        Trigger_Head_Fan_Control(HEAD_FAN_RIGHT, request->delay & 0xFF);
         Task_sleep(2000);
 
         //response.progress = Fan_Click_Info.Product_ID;
@@ -483,7 +522,7 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
     else
     if((request->amount == 0xFAC1) /*&& (request->delay == 0xFAC)*/) //Head Fan control
     {
-        Head_Fan_PWM_Control(1, request->delay & 0xFF);
+        Trigger_Head_Fan_Control(HEAD_FAN_LEFT, request->delay & 0xFF);
         Task_sleep(2000);
         response.progress = Head_Fan_Tach[1];
         response.has_progress = true;
@@ -528,6 +567,13 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
         response.has_progress = true;
     }
     else
+    if((request->amount == 0x0D) && (request->delay == 0xEE)) //Dispenser EEprom
+    {
+        test_disp_eeprom(0x01,0xA0);
+        response.progress = OK;
+        response.has_progress = true;
+    }
+    else
     if((request->amount == 0xCF) && (request->delay == 0xCF)) //Create File System on the Drive
     {
 #ifdef WATCHDOG
@@ -654,6 +700,18 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
         response.has_progress = true;
 
     }
+#ifdef VAC_TEST
+    else
+    if(request->amount == 0xB6)  //fast refresh for pressure
+    {
+        LOG_ERROR(request->delay,"set vac read test");
+        VAC_Test = (double)request->delay;
+        response.progress = request->delay;
+        response.has_progress = true;
+
+    }
+#endif
+
     else
     if(request->amount == 0xC3)  //suspend I2C task
     {
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_MidTankPressureSensor.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_MidTankPressureSensor.c
index 0fab4fdec..aa7e2b6cc 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_MidTankPressureSensor.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_MidTankPressureSensor.c
@@ -40,7 +40,7 @@ void Stub_MidTankPressureSensorRequest(MessageContainer* requestContainer)
 
 
 
-    if((MidTank_t)request->midtankid < NUM_OF_MIDTANKS)
+    if(/*(MidTank_t)*/request->midtankid < NUM_OF_MIDTANKS)
     {
         response.midtankid = request->midtankid;
         response.has_midtankid = true;
@@ -50,7 +50,7 @@ void Stub_MidTankPressureSensorRequest(MessageContainer* requestContainer)
     {
         response.midtankid = request->midtankid - 0x8000;
         response.has_midtankid = true;
-        response.pressure = Read_Head_ADC(response.midtankid); // Head Current
+        response.pressure = Head_ADC[response.midtankid];//Read_Head_ADC(response.midtankid); // Head Current
     }
 
     response.has_pressure = true;
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 2baa6bb2d..1c39385d4 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Motor.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Motor.c
@@ -190,9 +190,9 @@ void Stub_MotorRunRequest(MessageContainer* requestContainer)
     Run_Value = /*SpdCalc*/(temp);
     Direction = request->direction;
 
-    #ifdef TEST_POWERSTEP01
+    /*#ifdef TEST_POWERSTEP01
         Direction = Direction^1;
-    #endif
+    #endif*/
 
 #ifdef EVALUATION_BOARD
     //SPI_Control(SKIP_INIT);
@@ -208,6 +208,11 @@ void Stub_MotorRunRequest(MessageContainer* requestContainer)
 
     //FPGA_GetBusy();
 
+    if (MotorDriverResponse[Motor_Id].DriverType == CombinrdMotDriver)
+    {
+        Direction = Direction^1;
+    }
+
     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))
@@ -549,9 +554,9 @@ void Stub_MotorMovRequest(MessageContainer* requestContainer)
     Pos_Value = request->position;
     Direction = request->direction;
 
-    #ifdef TEST_POWERSTEP01
+/*    #ifdef TEST_POWERSTEP01
         Direction = Direction^1;
-    #endif
+    #endif*/
 
     MotorGetnBusyFromFPGA(); //temporary -
 
@@ -560,15 +565,19 @@ void Stub_MotorMovRequest(MessageContainer* requestContainer)
     #else
         TimerMotors_t Motor_Id  = (TimerMotors_t)request->motor_id; //to remove warning
 
+    if (MotorDriverResponse[Motor_Id].DriverType == CombinrdMotDriver)
+    {
+       Direction = Direction^1;
+    }
 
-        if(GoTo_Flag)
-        {
-            MotorGoTo(Motor_Id, Pos_Value );
-        }
-        else
-        {
-            MotorMove(Motor_Id, Direction, Pos_Value );
-        }
+    if(GoTo_Flag)
+    {
+       MotorGoTo(Motor_Id, Pos_Value );
+    }
+    else
+    {
+        MotorMove(Motor_Id, Direction, Pos_Value );
+    }
     #endif
 
     StubMotorMovResponse response =   STUB_MOTOR_MOV_RESPONSE__INIT;
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
index 128564586..698852f00 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
@@ -32,6 +32,9 @@
 #include "drivers/motors/motor.h"
 #include "drivers/Flash_ram/MCU_E2Prom.h"
 #include "Drivers/I2C_Communication/I2C.h"
+#include <Drivers/I2C_Communication/WHS_Card/D_Max5805_ADC_Blower/WHS_Blower.h>
+#include <Drivers/I2C_Communication/I2C_Task.h>
+
 #include "PMR/Stubs/StubHeatingTestRequest.pb-c.h"
 #include "PMR/Stubs/StubHeatingTestResponse.pb-c.h"
 #include "PMR/Stubs/StubHeatingTestPollRequest.pb-c.h"
@@ -186,8 +189,10 @@
         ProcessParametersClear.headzone10temp  = 0;
         ProcessParametersClear.headzone11temp  = 0;
         ProcessParametersClear.headzone12temp  = 0;
-        ProcessParametersClear.stspzone1temp  = 0;
-        ProcessParametersClear.stspzone2temp  = 0;
+        ProcessParametersClear.rblowertemp  = 0;
+        ProcessParametersClear.lblowertemp  = 0;
+        ProcessParametersClear.rblowerflow  = 0;
+        ProcessParametersClear.lblowerflow  = 0;
         ProcessParametersClear.dyeingspeed = 40;
         ProcessParametersClear.dryerbufferlength = ProcessParametersKeep.dryerbufferlength;
         if (HandleProcessParameters(&ProcessParametersClear,false)!= OK)
@@ -199,7 +204,7 @@
         }
         else
         {
-            //WHS_Start_Blower_Control_Closed_Loop(2.5);
+            WHS_Set_SetPoint_Q_value(headairflow/2);
             Turn_the_Blower_On();//Turn on with the Default_Voltage
             if (BlowerCfg.heatingvoltage)
                 Control_Voltage_To_Blower(BlowerCfg.heatingvoltage);
@@ -410,7 +415,8 @@
         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, 0, Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID], Thread_Load_HomingCallback,10000);
-        Trigger_Head_Actuators_Control(ACTOT, LOW,true);
+        Trigger_Head_Actuators_Control(ACTOT, LOW,false);
+        Trigger_Head_Actuators_Control(ACTIN, LOW,false);
         return OK;
     }
     uint32_t Thread_Load_Lift_Dancers(void)
@@ -422,6 +428,8 @@
         MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_RDANCER,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDANCER].directionthreadwize, 15,  Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_RDANCER], Thread_Load_HomingCallback,15000);*/
         CallbackCounter++;
         MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_LDANCER1,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LDANCER1].directionthreadwize, 500,  Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_LDANCER1], Thread_Load_HomingCallback,25000);
+        CallbackCounter++;
+        MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_LDANCER2,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LDANCER2].directionthreadwize, 500,  Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_LDANCER2], Thread_Load_HomingCallback,25000);
 
         return OK;
     }
@@ -504,6 +512,11 @@
 
 //        MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_LDANCER1,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LDANCER1].directionthreadwize, 500,  Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_LDANCER1], Thread_Load_HomingCallback,25000);
         MotorMoveWithCallback (HARDWARE_MOTOR_TYPE__MOTO_LDANCER1, MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LDANCER1].directionthreadwize, (5000*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LDANCER1].microstep), Thread_Load_HomingCallback,20000);
+        CallbackCounter++;
+        MotorSetMaxSpeed (HARDWARE_MOTOR_TYPE__MOTO_LDANCER2, 500);
+
+//        MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_LDANCER1,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LDANCER1].directionthreadwize, 500,  Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_LDANCER1], Thread_Load_HomingCallback,25000);
+        MotorMoveWithCallback (HARDWARE_MOTOR_TYPE__MOTO_LDANCER2, MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LDANCER2].directionthreadwize, (5000*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LDANCER2].microstep), Thread_Load_HomingCallback,20000);
 
         return OK;
     }
@@ -518,7 +531,8 @@
         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, 2, Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID], Thread_Load_HomingCallback,10000);
-        Trigger_Head_Actuators_Control(ACTOT, LOW,false);
+        Trigger_Head_Actuators_Control(ACTOT, LOW,true);
+        Trigger_Head_Actuators_Control(ACTIN, LOW,true);
         return OK;
     }
     uint32_t Thread_Load_Resume_Heating(void)
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
index 78092ae2b..78150e9f9 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
@@ -213,9 +213,16 @@ uint32_t Winder_PrepareStage2(uint32_t deviceID, uint32_t ReadValue)
     REPORT_MSG(millisecondCounter/*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].maxfrequency*/, "Winder_PrepareStage2");
     if (ReadValue != LIMIT)
     {
-        LOG_ERROR(ReadValue,"Screw failed to reach the limit switch!!");
-        //returned with a timeout
-        Winder_ScrewAtOffsetCallback(0,0);
+        if (JobIsActive()==true)
+        {
+            LOG_ERROR(ReadValue,"Screw failed to reach the limit switch!!");
+            //returned with a timeout
+            Winder_ScrewAtOffsetCallback(0,0);
+        }
+        else //short jog, etc
+        {
+            AlarmHandlingSetAlarm (EVENT_TYPE__SCREW_MOTOR_LIMIT_TIMEOUT,OFF);  //on a short jog, this callback will be called without need
+        }
     }
     else
     {
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
index 1dd101f82..be6644067 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
@@ -15,6 +15,7 @@
 #include "PMR/Hardware/HardwareDancerType.pb-c.h"
 #include "PMR/Printing/JobSegment.pb-c.h"
 #include "PMR/Printing/JobTicket.pb-c.h"
+#include "PMR/Printing/ThreadParameters.pb-c.h"
 #include  <PMR/Diagnostics/EventType.pb-c.h>
 
 #include <utils/ustdlib.h>
@@ -71,10 +72,12 @@ double TempTotalProcessedLength = 0.0;
 
 bool InitialProcess = false;
 bool PrepareState = false;
+
 // job parameters
 bool EnableLubrication = false;
 bool EnableIntersegment = false;
 double IntersegmentLength = 0;
+bool Thread_Rockers_Bypass = false;
 
 
 int CurrentSegmentId = 0;
@@ -442,7 +445,6 @@ void testDancersControl()
     ThreadControlActive = false;
 }
 #endif
-bool dancerinvalid = false;
 int MotorFailedSample[MAX_THREAD_MOTORS_NUM] = {0,0,0,0,0};
 char TMessage[150];
 //char time[150];
@@ -456,7 +458,8 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
 //extern int MotorSamplePointer[MAX_THREAD_MOTORS_NUM];
 
     //read value is the dancer angle
-    int i,index=MAX_THREAD_MOTORS_NUM,len;
+    int i,index=MAX_THREAD_MOTORS_NUM;
+    int len;
     int DancerId;
     int32_t TranslatedReadValue, avreageSampleValue = 0;//,avreageMotorSampleValue = 0;
     //double tempcalcspeed = 0;
@@ -481,21 +484,20 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
         //if (MotorDriverResponse[ThreadMotorIdToMotorId[index]].Busy == true)
         //    return OK;
         DancerId = ThreadMotorIdToDancerId[index];
-        if (ReadValue < 10)
+/*        if (ReadValue < 10)
         {
             MotorFailedSample[index]++;
             ReportWithPackageFilter(ThreadFilter,"Dancer value read too small.",__FILE__,__LINE__,DancerId,RpError,ReadValue,0);
             return OK;
-        }
+        }*/
         if (ReadValue == 0x3FFF)
         {
-            MotorFailedSample[index]++;
-            if (dancerinvalid == false)
+            if (Read_Dryer_Status(DancerId) != OK)
             {
-                dancerinvalid = true;
-                ReportWithPackageFilter(ThreadFilter,"Dancer value invalid.",__FILE__,__LINE__,(int)IfIndex,RpError,(int)ReadValue,0);
+                ReportWithPackageFilter(ThreadFilter,"Dancer value invalid.",__FILE__,ReadValue,(int)DancerId,RpError,(int)Read_Dryer_Status(DancerId),0);
+                MotorFailedSample[index]++;
+                return OK;
             }
-            return OK;
         }
         KeepReadValue = ReadValue;
         TranslatedReadValue = ReadValue - DancersCfg[DancerId].zeropoint;
@@ -746,7 +748,47 @@ uint32_t ThreadInitialTestStub(HardwareMotor * request)
      ThreadPreSegmentState(request,0);
     return OK;
 }
+uint32_t HandleJobThreadControlParameters(ThreadParameters* ThreadParams)
+{
+    /*
+         FEEDER_MOTOR,
+    DRYER_MOTOR,
+    POOLER_MOTOR,
+    WINDER_MOTOR,
+    MotorControlConfig[Motor_i].m_params.Kd = MotorsControl[Pid_Id].derivativetime;
+    MotorControlConfig[Motor_i].m_params.Kp = MotorsControl[Pid_Id].proportionalgain;
+    MotorControlConfig[Motor_i].m_params.Ki = MotorsControl[Pid_Id].integraltime;
 
+     */
+    if (ThreadParams == NULL)
+    {
+        return OK;
+    }
+    if(ThreadParams->feederp)
+        MotorControlConfig[FEEDER_MOTOR].m_params.Kd = ThreadParams->feederp;
+    if(ThreadParams->feederi)
+        MotorControlConfig[FEEDER_MOTOR].m_params.Ki = ThreadParams->feederi;
+    if(ThreadParams->feederd)
+        MotorControlConfig[FEEDER_MOTOR].m_params.Kd = ThreadParams->feederd;
+
+    if(ThreadParams->pullerp)
+        MotorControlConfig[POOLER_MOTOR].m_params.Kd = ThreadParams->pullerp;
+    if(ThreadParams->pulleri)
+        MotorControlConfig[POOLER_MOTOR].m_params.Ki = ThreadParams->pulleri;
+    if(ThreadParams->pullerd)
+        MotorControlConfig[POOLER_MOTOR].m_params.Kd = ThreadParams->pullerd;
+
+    if(ThreadParams->winderp)
+        MotorControlConfig[WINDER_MOTOR].m_params.Kd = ThreadParams->winderp;
+    if(ThreadParams->winderi)
+        MotorControlConfig[WINDER_MOTOR].m_params.Ki = ThreadParams->winderi;
+    if(ThreadParams->winderd)
+        MotorControlConfig[WINDER_MOTOR].m_params.Kd = ThreadParams->winderd;
+    if(ThreadParams->bypassrockers)
+        Thread_Rockers_Bypass = true;
+
+    return OK;
+}
 //********************************************************************************************************************
  uint32_t ThreadPrepareState(void *JobDetails)
 {
@@ -826,10 +868,10 @@ uint32_t ThreadInitialTestStub(HardwareMotor * request)
 //////////////////////////////////////////////////
             for (i = 0;i < (int)MotorsControl[Motor_i].pvinputfilterfactormode; i++)
             {
-                if (Motor_i == DRYER_MOTOR) // dryer motor is speed controlled. later a speed sensor will be utilized, but for now it will not be controlled
+                //if (Motor_i == DRYER_MOTOR) // dryer motor is speed controlled. later a speed sensor will be utilized, but for now it will not be controlled
                     MotorSamples[Motor_i][i] = Control_Read_Dancer_Position(ThreadMotorIdToDancerId[Motor_i],0);  //reset the samples value for control beginning
-                else if ((Motor_i == POOLER_MOTOR)||(Motor_i == FEEDER_MOTOR))
-                    MotorSamples[Motor_i][i] = DancersCfg[ThreadMotorIdToDancerId[Motor_i]].zeropoint;
+               // else if ((Motor_i == POOLER_MOTOR)||(Motor_i == FEEDER_MOTOR))
+                //    MotorSamples[Motor_i][i] = DancersCfg[ThreadMotorIdToDancerId[Motor_i]].zeropoint;
                 //MotorSpeedSamples[Motor_i][i] = 0;
             }
             MotorSamplePointer[Motor_i] = 0;
@@ -907,6 +949,8 @@ uint32_t ThreadInitialTestStub(HardwareMotor * request)
             if (Motor_i == ThreadMotorIdToMotorId[DRYER_MOTOR]) // dryer motor is speed controlled. later a speed sensor will be utilized, but for now it will not be controlled
                 continue;
     }
+    HandleJobThreadControlParameters(JobTicket->threadparameters);  //OVERRIDES CONFIGURATION PARAMETERS!!!
+
 #ifdef TEST_PID_THREAD
     testDancersControl();
 #endif
@@ -965,7 +1009,6 @@ uint32_t ThreadDryerRampUp(uint32_t IfIndex, uint32_t BusyFlag)
 
     return OK;
 }
-bool Thread_Rockers_Bypass = false;
 bool Set_Thread_Rockers_Bypass (int value)
 {
     if (value == 0)
@@ -1146,7 +1189,7 @@ char Endstr[150];
      if (PoolerSpeedControlId != 0xFF)
      {
          if(RemoveControlCallback(PoolerSpeedControlId,PoolerThreadLengthCBFunction)!=OK)
-             ReportWithPackageFilter(ThreadFilter,"Remove Control Failed.",__FILE__,__LINE__,(int)Motor_i,RpError,(int)PoolerSpeedControlId,0);
+             ReportWithPackageFilter(ThreadFilter,"Remove Control Failed.",__FILE__,__LINE__,(int)PoolerThreadLengthCBFunction,RpError,(int)PoolerSpeedControlId,0);
          PoolerSpeedControlId = 0xFF;
      }