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

21 files changed, 271 insertions, 145 deletions

diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
index 059b8fc4c..07ebfa747 100644
--- a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
+++ b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
@@ -154,14 +154,14 @@ typedef enum
 
 typedef struct
 {
-    uint16_t Frequency;  //1/10/100/1000
+    //uint16_t Frequency;  //1/10/100/1000
     AlarmSourceType AlarmSource;
     uint16_t DeviceId;
     uint8_t ModuleDeviceId;
     uint16_t AlarmValue;
     bool AlarmDirection;
     DebugLogCategory Severity;
-    uint16_t Predecessor;
+    //uint16_t Predecessor;
     uint8_t DebounceValue;
     EventType EventType;
     bool isPersistent;
@@ -490,16 +490,12 @@ uint32_t AlarmHandlingLoadFile(void)
                 F_count = 0;
                 for (i = 0; i < AlarmParametersTable->n_alarmitem ;i++)
                 {
-                    FileAlarmItem[F_count].AlarmDirection = AlarmParametersTable->alarmitem[i]->alarmdirection;
                     FileAlarmItem[F_count].AlarmDirection =  AlarmParametersTable->alarmitem[i]->alarmdirection;
-                    //FileAlarmItem[F_count].Frequency =       AlarmParametersTable->alarmitem[i]->frequency;  //1/10/100/1000
                     FileAlarmItem[F_count].AlarmSource =     AlarmParametersTable->alarmitem[i]->alarmsource;
                     FileAlarmItem[F_count].DeviceId =        AlarmParametersTable->alarmitem[i]->deviceid;
                     FileAlarmItem[F_count].ModuleDeviceId =  AlarmParametersTable->alarmitem[i]->moduledeviceid;
                     FileAlarmItem[F_count].AlarmValue =      AlarmParametersTable->alarmitem[i]->alarmvalue;
-                    FileAlarmItem[F_count].AlarmDirection =  AlarmParametersTable->alarmitem[i]->alarmdirection;
                     FileAlarmItem[F_count].Severity =        AlarmParametersTable->alarmitem[i]->severity;
-                    //FileAlarmItem[F_count].Predecessor =     AlarmParametersTable->alarmitem[i]->predecessor;
                     FileAlarmItem[F_count].DebounceValue =   AlarmParametersTable->alarmitem[i]->debouncevalue;
                     FileAlarmItem[F_count].EventType =       AlarmParametersTable->alarmitem[i]->eventtype;
                     FileAlarmItem[F_count].isPersistent =    AlarmParametersTable->alarmitem[i]->ispersistent;
@@ -642,10 +638,10 @@ JobEndReasonEnum getEndReason(uint32_t AlarmId)
                 return JOB_TEMPERATURE_ALARM;
             }
         case ALARM_SOURCE_TYPE__LimitSwitchAlarm:
-            usnprintf(AlarmReasonStr, 100, "Dispenser %d empty",AlarmItem[AlarmId].DeviceId);
+            usnprintf(AlarmReasonStr, 100, "Dispenser %d empty",AlarmItem[AlarmId].DeviceId+1);
             return JOB_OUT_OF_DYE;
         case ALARM_SOURCE_TYPE__PressureAlarm:
-            usnprintf(AlarmReasonStr, 100, "Over pressure in dispenser %d",AlarmItem[AlarmId].DeviceId);
+            usnprintf(AlarmReasonStr, 100, "Over pressure in dispenser %d",AlarmItem[AlarmId].DeviceId+1);
             return JOB_PRESSURE_ALARM;
         case ALARM_SOURCE_TYPE__CurrentAlarm:
             usnprintf(AlarmReasonStr, 100, "over/under current (%d) in %d",AlarmId,AlarmItem[AlarmId].DeviceId);
@@ -657,7 +653,7 @@ JobEndReasonEnum getEndReason(uint32_t AlarmId)
             usnprintf(AlarmReasonStr, 100, "Machine door %d removed during a run",AlarmItem[AlarmId].DeviceId);
             return JOB_TAMPER_ALARM;
         case ALARM_SOURCE_TYPE__HardLimitAlarm:
-            usnprintf(AlarmReasonStr, 100, "Dispenser %d hit the hard limit",AlarmItem[AlarmId].DeviceId);
+            usnprintf(AlarmReasonStr, 100, "Dispenser %d hit the hard limit",AlarmItem[AlarmId].DeviceId+1);
             return JOB_LS_ALARM;
         case ALARM_SOURCE_TYPE__DoNotPollAlarm:
             if (AlarmItem[AlarmId].Severity == DEBUG_LOG_CATEGORY__Critical)
@@ -1010,30 +1006,33 @@ JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob)
                 }
             }
     }
-    if ((AlarmState[Alarm_i].Status == true)&&(FoundReason == JOB_OK))
+    for (Alarm_i = 0;Alarm_i<NumOfSystemAlarms;Alarm_i++)
     {
-        if(AlarmItem[Alarm_i].Severity>=DEBUG_LOG_CATEGORY__Error)
+        if ((AlarmState[Alarm_i].Status == true)&&(FoundReason == JOB_OK))
         {
-            ReportWithPackageFilter(AlarmFilter,"an alarm existing before job", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, AlarmItem[Alarm_i].Severity, AlarmItem[Alarm_i].DeviceId, 0);
-            switch (AlarmItem[Alarm_i].EventType )
+            if(AlarmItem[Alarm_i].Severity>=DEBUG_LOG_CATEGORY__Error)
             {
-                case EVENT_TYPE__INSUFFICIENT_AIR_FLOW:
-                case EVENT_TYPE__VOC_SENSOR_ALARM_TIME:
-#warning unmark to prevent job on voc alarm//case EVENT_TYPE__VOC_SENSOR_ALARM_SLOPE:
-                //case EVENT_TYPE__POWER_UP_BIT_FAILURE:
-                    FoundReason = JOB_WASTE_HANDLING_PROBLEM;
-                    AlarmId = Alarm_i;
-                    ReportWithPackageFilter(AlarmFilter,"an alarm preventing job", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, AlarmItem[Alarm_i].Severity, AlarmItem[Alarm_i].DeviceId, 0);
-                    break;
-                case EVENT_TYPE__ELECTRICAL_CABINET_OVERTEMPERATURE:
-                case EVENT_TYPE__MACHINE_INTERNAL_OVERTEMPERATURE:
-                case EVENT_TYPE__MACHINE_INTERNAL_OVERTEMPERATURE_2:
-                    FoundReason = JOB_TEMPERATURE_ALARM;
-                    AlarmId = Alarm_i;
-                    ReportWithPackageFilter(AlarmFilter,"machine internal over-temperature is preventing job", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, AlarmItem[Alarm_i].Severity, AlarmItem[Alarm_i].DeviceId, 0);
-                    break;
-                default:
-                    break;
+                ReportWithPackageFilter(AlarmFilter,"an alarm existing before job", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, AlarmItem[Alarm_i].Severity, AlarmItem[Alarm_i].DeviceId, 0);
+                switch (AlarmItem[Alarm_i].EventType )
+                {
+                    case EVENT_TYPE__INSUFFICIENT_AIR_FLOW:
+                    case EVENT_TYPE__VOC_SENSOR_ALARM_TIME:
+                    //case EVENT_TYPE__VOC_SENSOR_ALARM_SLOPE:
+                    //case EVENT_TYPE__POWER_UP_BIT_FAILURE:
+                        FoundReason = JOB_WASTE_HANDLING_PROBLEM;
+                        AlarmId = Alarm_i;
+                        ReportWithPackageFilter(AlarmFilter,"an alarm preventing job", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, AlarmItem[Alarm_i].Severity, AlarmItem[Alarm_i].DeviceId, 0);
+                        break;
+                    case EVENT_TYPE__ELECTRICAL_CABINET_OVERTEMPERATURE:
+                    case EVENT_TYPE__MACHINE_INTERNAL_OVERTEMPERATURE:
+                    case EVENT_TYPE__MACHINE_INTERNAL_OVERTEMPERATURE_2:
+                        FoundReason = JOB_TEMPERATURE_ALARM;
+                        AlarmId = Alarm_i;
+                        ReportWithPackageFilter(AlarmFilter,"machine internal over-temperature is preventing job", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, AlarmItem[Alarm_i].Severity, AlarmItem[Alarm_i].DeviceId, 0);
+                        break;
+                    default:
+                        break;
+                }
             }
         }
     }
diff --git a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
index d366e8832..ad5a1d5ca 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
+++ b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
@@ -544,8 +544,12 @@ int MillisecCalculateTemperatures (TEMPERATURE_SENSOR_ID_ENUM SensorId)
     calc = TemperatureSum[SensorId] / (TemperatureCount[SensorId]-2);
     if (TemperatureSum[SensorId]>10)
     {
+
         if(abs(TemperatureMax[SensorId]-TemperatureMin[SensorId])>2000)
+        {
+            if ((Head_Type == HEAD_TYPE_FLAT_WITHOUT_CARD)||(SensorId!=TEMP_SENSE_AN_ENCLOSURETEMP3))
                 Report("Millisec Temp spike",__FILE__,SensorId,(int)TemperatureMax[SensorId],RpWarning,(int) TemperatureMin[SensorId],0);
+        }
     }
     TemperatureSum[SensorId] = 0;
     TemperatureCount[SensorId] = 0;
@@ -645,7 +649,6 @@ uint32_t MillisecLowLoop(uint32_t tick)
     //Screw_ENC_Velocity_to_DAC(); - for testing the screw enc
     if (Head_Type > HEAD_TYPE_FLAT_WITHOUT_CARD)
         StartPT100 = TEMP_SENSE_ANALOG_DRYER_TEMP1;
-
     if (Ten_msTick)
     {
         //Speed_Data = Read_Speed_Sensor_TypeII();
@@ -821,6 +824,10 @@ uint32_t MillisecLowLoop(uint32_t tick)
         if (Head_Type == HEAD_TYPE_ARC) {
             HeadBlowersControlLoop();
         }
+        else
+        {
+            FlatHeadAlarms();
+        }
 
         //call waste state machine
         Waste_StateMachine_OneSecond_Call();
diff --git a/Software/Embedded_SW/Embedded/Modules/Control/control.c b/Software/Embedded_SW/Embedded/Modules/Control/control.c
index e02bd8191..e6da43178 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/control.c
+++ b/Software/Embedded_SW/Embedded/Modules/Control/control.c
@@ -83,6 +83,7 @@ typedef struct
   DataReadCBFunction ControlDataReadPtr;
   ControlCBFunction ControlCallbackPtr;
   uint32_t ControlTiming;
+  uint32_t LastCalled;
   char *Name;
 }ControlDeviceStruc;
 
@@ -613,10 +614,13 @@ uint32_t ControlLowLoop(uint32_t tick)
         {
             if (tick - ControlArray[ControlLowDevice_i].StartTick<=skipped_ticks)
                 continue;
+            if (tick - ControlArray[ControlLowDevice_i].LastCalled<=skipped_ticks)
+                continue;
             if (ControlArray[ControlLowDevice_i].ControlTiming == eOneMillisecond)
                 continue;
             if (ControlArray[ControlLowDevice_i].StartTick == tick)
                 continue;
+            ControlArray[ControlLowDevice_i].LastCalled = tick;
 
             if (((tick - ControlArray[ControlLowDevice_i].StartTick)%ControlArray[ControlLowDevice_i].ControlTiming)<=skipped_ticks) // run the control on exact intervals
             {
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
index 11a48b587..9cad274b9 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
@@ -78,7 +78,7 @@ DiagnosticsMonitors DiagnosticsMonitor = DIAGNOSTICS_MONITORS__INIT;
 #define DIAGNOSTICS_LIMIT 3
 #define DIAGNOSTICS_DANCER_LIMIT 30
 int DiagnosticsIndex = 0;
-int DiagnosticCollectionLimit = 3;  //number of data samples to collect before sending to the host
+int DiagnosticCollectionLimit = 1;  //number of data samples to collect before sending to the host
 //int DiagnosticLimit = eHundredMillisecond; //frequency of data collection
 //int DiagnosticFastLimit = eTenMillisecond; //frequency of data collection
 int DiagnosticLimit =eHundredMillisecond; //frequency of data collection
@@ -135,7 +135,7 @@ DoubleArray DiagnosticsDispenserPressure[MAX_SYSTEM_DISPENSERS];
 HeaterState **heatersstates;
 HeaterState  HeaterInfo[HEATER_TYPE_MAX_HEATERS];
 
-#define NUM_OF_INTERFACE_IOS 26
+#define NUM_OF_INTERFACE_IOS 27
 DigitalInterfaceState **digitalinterfacestates;
 DigitalInterfaceState DigitalOutputState[NUM_OF_INTERFACE_IOS];
 /*double dispenser1motorfrequency[DIAGNOSTICS_LIMIT+1];
@@ -320,15 +320,12 @@ 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;
-        DigitalOutputState[index++].value = HeadCard_Actuators_Status(ACTIN);
 
-        DigitalOutputState[index].interfaceio = INTERFACE_IOS__GPO_LED4;
-        DigitalOutputState[index++].value = HeadCard_Actuators_Status(ACTOT);
-    }*/
+    DigitalOutputState[index].interfaceio = INTERFACE_IOS__LS_DH_LID_OPEN;
+    if(Head_Type == HEAD_TYPE_ARC)
+        DigitalOutputState[index++].value = FPGA_Read_limit_Switches(I2C_HEADCARD_COVER_LS_ARC);
+    else
+        DigitalOutputState[index++].value = FPGA_Read_limit_Switches(Motor_Id_to_LS_IdUp  [HARDWARE_MOTOR_TYPE__MOTO_DH_LID]);
 
     #ifdef USE_VOC_BUZZER_ALARM
         if (WHS_Type == WHS_TYPE_NEW)
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c
index 086525bc1..12842177c 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c
@@ -51,7 +51,7 @@ void HomingStopReporting(void)
     int i;
     for (i = 0; i< NUM_OF_MOTORS;i++)
     {
-        HomingToken[i][0] == 0;
+        HomingToken[i][0] = 0;
     }
     LOG_ERROR(0,"HomingStopReporting");
 }
@@ -413,8 +413,12 @@ uint32_t DispenserHomingRequestFunc(MessageContainer* requestContainer)
     responseContainer.continuous = true;
     if (MotorId <= NUM_OF_MOTORS)
     {
-        //if ((JobIsActive() == false)&&(isMotorConfigured(MotorId) == true))
-        if (isMotorConfigured(MotorId) == true)
+        if ((JobIsActive())&&(DispenserUsedInJob[request->index] == true))
+        {
+            responseContainer.error = ERROR_CODE__GENERAL_ERROR;
+            responseContainer.errormessage = "Dispenser active in job";
+        }
+        else if (isMotorConfigured(MotorId) == true)
         {
             if (request->direction == MOTOR_DIRECTION__Backward) //dispenser homing
                 status = IDS_HomeDispenser(request->index,speed,DispenserHomingRequestCallback);
@@ -481,17 +485,12 @@ uint32_t Diagnostics_Set_Load_Arm_To_Stopper_Callback(uint32_t deviceID, uint32_
 {
     MessageContainer responseContainer;
     MotorHomingResponse response = MOTOR_HOMING_RESPONSE__INIT;
-    uint32_t angle, temp = Read_Dryer_ENC_Position();
-
-    angle = Calculate_Arm_Distance(D_DrierPrevLocation,temp);
+    uint32_t temp = Read_Dryer_ENC_Position();
+    int angle;
 
-    if ((abs (angle)<14000  )||(BusyFlag == BUSY)) // OK - take another round
-    {
-        responseContainer.has_error = true;
-        responseContainer.error = ERROR_CODE__GENERAL_ERROR;
+    angle = Calculate_Arm_Distance(Drier_Center_read,temp);
 
-    }
-    ReportWithPackageFilter(DiagnosticsFilter,"Diagnostics_Set_Load_Arm_To_Stopper time",__FILE__,__LINE__,msec_millisecondCounter,RpMessage,0,0);
+    ReportWithPackageFilter(DiagnosticsFilter,"Diagnostics_Set_Load_Arm_To_Stopper time",__FILE__,__LINE__,msec_millisecondCounter,RpMessage,angle,0);
     if (HomingControlId[deviceID] != 0xff)
     {
         ReportWithPackageFilter(DiagnosticsFilter,"MotorHomingProgressReport stopped",__FILE__,__LINE__,deviceID,RpMessage,HomingCounter[deviceID],0);
@@ -506,6 +505,11 @@ uint32_t Diagnostics_Set_Load_Arm_To_Stopper_Callback(uint32_t deviceID, uint32_
     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;
+    if (abs (angle)>20) // arm not at center position
+    {
+        responseContainer.has_error = true;
+        responseContainer.error = ERROR_CODE__GENERAL_ERROR;
+    }
     uint8_t* container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
     size_t container_size = message_container__pack(&responseContainer, container_buffer);
     my_free(responseContainer.data.data);
@@ -556,7 +560,7 @@ uint32_t Diagnostics_Set_Load_Arm_To_Stopper_Callback(uint32_t deviceID, uint32_
 uint32_t Diagnostics_Dryer_UnLoading(void)
 {
     D_DrierPrevLocation = Read_Dryer_ENC_Position();
-
+    MCU_E2PromRead(EEPROM_STORAGE_DRYER_CENTER,&Drier_Center_read);
     LoadingArmReset(Diagnostics_Set_Load_Arm_To_Stopper_Callback,300000);
     /*uint32_t temp;
 
@@ -615,16 +619,17 @@ uint32_t Diagnostics_Dryer_MovetoEncoderPosition_Callback(uint32_t MotorId, uint
 uint32_t Diagnostics_Dryer_Loading_Callback(uint32_t MotorId, uint32_t ReadValue)
 {
     D_numberOfCycles++;
-    uint32_t angle, temp = Read_Dryer_ENC_Position();
+    int angle;
+    uint32_t temp = Read_Dryer_ENC_Position();
 
     angle = Calculate_Arm_Distance(D_DrierPrevLocation,temp);
     ReportWithPackageFilter(DiagnosticsFilter,"Diagnostics_Dryer_Loading_Callback",__FILE__,(int)angle,(int)ReadValue,RpMessage,temp,0);
 
     MCU_E2PromProgram(EEPROM_STORAGE_DRYER_CYCLES,D_numberOfCycles);
-    if ((abs(angle)>14000  )&&(ReadValue == NOTBUSY)) // OK - take another round
+    if ((abs(angle)<400  )&&(ReadValue == NOTBUSY)) // OK - take another round
     {
         D_DrierPrevLocation = temp;
-        //ReportWithPackageFilter(DiagnosticsFilter,"Diagnostics_Dryer_Loading_Callback",__FILE__,__LINE__,LoadStages,RpMessage,NumberOfDrierLoaderCycles,0);
+        ReportWithPackageFilter(DiagnosticsFilter,"Diagnostics_Dryer_Loading_Callback",__FILE__,ReadValue,temp,RpMessage,angle,0);
         //ReportWithPackageFilter(DiagnosticsFilter,"Diagnostics_Dryer_Loading_Callback details",__FILE__,(int)(TotalLoadedLen),numberOfCycles,RpMessage,CallbackCounter,0);
         if (D_numberOfCycles<LoadArmRounds)
         {
@@ -653,6 +658,7 @@ uint32_t Diagnostics_Dryer_Loading(void)
     if (dryerbufferlength)
         LoadArmRounds = (int)dryerbufferlength;
     MCU_E2PromRead(EEPROM_STORAGE_DRYER_CENTER,&D_DrierPrevLocation);
+
     //MCU_E2PromProgram(EEPROM_DRIER_LOADING_ARM_ANGLE,Calc_angle);
     ReportWithPackageFilter(DiagnosticsFilter,"Diagnostics_Dryer_Loading request: current ",__FILE__,D_DrierPrevLocation,D_numberOfCycles,RpMessage,LoadArmRounds,0);
     Drier_Center_read = D_DrierPrevLocation;
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsJogging.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsJogging.c
index 6d09e9f9e..c023a211c 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsJogging.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsJogging.c
@@ -168,7 +168,12 @@ uint32_t DispenserJoggingRequestFunc(MessageContainer* requestContainer)
     if (MotorId <= NUM_OF_MOTORS)
     {
 //        if ((JobIsActive() == false)&&(isMotorConfigured(MotorId) == true))
-        if (isMotorConfigured(MotorId) == true)
+        if ((JobIsActive())&&(DispenserUsedInJob[request->index] == true))
+        {
+            responseContainer.error = ERROR_CODE__GENERAL_ERROR;
+            responseContainer.errormessage = "Dispenser active in job";
+        }
+        else if (isMotorConfigured(MotorId) == true)
         {
             switch (request->direction)
             {
diff --git a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
index 0726225df..010fc9607 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
@@ -44,6 +44,7 @@
 #include "drivers/Flash_ram/MCU_E2Prom.h"
 #include <Drivers/I2C_Communication/WHS_Card/D_Max5805_ADC_Blower/WHS_Blower.h>
 #include "drivers/FPGA/Full_Vme/FPGA_Programming_Up.h"
+#include <Drivers/I2C_Communication/I2C_RFID_Dispenser_Task/I2C_RFID_Disp_Task.h>
 
 #include "StateMachines/Printing/PrintingSTM.h"
 #include "StateMachines/Initialization/InitSequence.h"
@@ -216,12 +217,19 @@ void LoadConfigurationParameters(ConfigurationParameters *Params)
             EmbeddedParameters->has_openvalvetimeout = true;
             EmbeddedParameters->openvalvetimeout = 52;
 
+            EmbeddedParameters->has_initialdispenserpressure = true;
+            EmbeddedParameters->initialdispenserpressure=3.85;
+            EmbeddedParameters->has_initialdispensertimeout = true;
+            EmbeddedParameters->initialdispensertimeout=119999.0 ;
+            EmbeddedParameters->has_initialdispensertimelag = true;
+            EmbeddedParameters->initialdispensertimelag=100.0 ;
+
             EmbeddedParameters->has_dispenserbuildpressurespeed = true;
             EmbeddedParameters->dispenserbuildpressurespeed=500;
             EmbeddedParameters->has_dispenserbuildpressurelimit = true;
             EmbeddedParameters->dispenserbuildpressurelimit=1.0 ;
             EmbeddedParameters->has_dispenserbuildpressuretimeout = true;
-            EmbeddedParameters->dispenserbuildpressuretimeout=150000;
+            EmbeddedParameters->dispenserbuildpressuretimeout=419999.0;
             EmbeddedParameters->has_dispenserbuildpressurelag = true;
             EmbeddedParameters->dispenserbuildpressurelag=50;
 
@@ -289,6 +297,7 @@ void LoadConfigurationParameters(ConfigurationParameters *Params)
             EmbeddedParameters->powerofftemperaturelimit = 90;
             EmbeddedParameters->has_ids_presegment_wfcf_timebeforesegment = true;
             EmbeddedParameters->ids_presegment_wfcf_timebeforesegment = 20000;
+            EmbeddedParameters->description = "default embedded parameters";
             uint8_t* response_buffer = my_malloc(configuration_parameters__get_packed_size(EmbeddedParameters));
 
             if (response_buffer)
@@ -416,6 +425,10 @@ uint32_t EmbeddedParametersInit(void)
     {
         Set_Voltage_Hysteresis (EmbeddedParameters->generalparameters[12]);
     }
+    if (EmbeddedParameters->n_generalparameters >= 15)
+    {
+        Set_Head_Blowers_Parameters(EmbeddedParameters->generalparameters[13],EmbeddedParameters->generalparameters[14]);
+    }
     PowerIdleSetParameters(EmbeddedParameters->switchtoidletimeinseconds,EmbeddedParameters->idledriertemperature,EmbeddedParameters->idleheadtemperature,EmbeddedParameters->idlemixertemperature);
 
     return Fresult;
@@ -446,10 +459,10 @@ uint32_t HWConfiguration(UploadHardwareConfigurationRequest* UploadRequest)
         LOG_ERROR (0, "Wrong Data Allocation");
         return ERROR;
     }
-    if (InitFailures > REPEATED_INIT_FAILURE_LIMIT)
+    /*if (InitFailures > REPEATED_INIT_FAILURE_LIMIT)
     {
         Report("HWConfigurationInit repeated failure",__FILE__,__LINE__,(int)InitFailures,RpWarning,(int)EEPROM_INIT_FAILURE_COUNTER,0);
-        AlarmHandlingSetAlarm (EVENT_TYPE__POWER_UP_BIT_FAILURE,ON);
+        //AlarmHandlingSetAlarm (EVENT_TYPE__POWER_UP_BIT_FAILURE,ON);
         //return ERROR;
     }
     else
@@ -458,7 +471,7 @@ uint32_t HWConfiguration(UploadHardwareConfigurationRequest* UploadRequest)
         {
             Report("HWConfigurationInit repeated failure going up",__FILE__,__LINE__,(int)InitFailures,RpWarning,(int)EEPROM_INIT_FAILURE_COUNTER,0);
         }
-    }
+    }*/
 
     HardwareConfiguration *request =    UploadRequest->hardwareconfiguration;
 
diff --git a/Software/Embedded_SW/Embedded/Modules/General/Safety.c b/Software/Embedded_SW/Embedded/Modules/General/Safety.c
index ebbc3d326..a70866fd6 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/Safety.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/Safety.c
@@ -205,10 +205,10 @@ uint32_t Safety_Main_State(uint32_t IfIndex, uint32_t BusyFlag)
            {
                if (Check_Disp_Safety_Stop_Indication(Disp_i) == false)
                {
-                   AlarmHandlingSetAlarm(DispenserAlarm[Disp_i], false);
                    if (DispenserAlarm[Disp_i] == true)
                    {
                        IDS_Dispenser_Alarm_Off(Disp_i);
+                       AlarmHandlingSetAlarm(DispenserAlarm[Disp_i], false);
                    }
                    DispenserAlarm[Disp_i] = 0;
                    DispenserOverPressure[Disp_i] = false;
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_Blowers.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_Blowers.c
index 63118221b..76c679d80 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_Blowers.c
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_Blowers.c
@@ -52,8 +52,8 @@
 #define ARC_ALARM_LIMIT 3
 #define V0_INIT_STOP_FAN_TIME 5
 
-#define PRESSURE_SENSOR_CP      0.269
-#define PRESSURE_SENSOR_B       0.45
+#define PRESSURE_SENSOR_CP      (0.242)
+#define PRESSURE_SENSOR_B       (-0.134)
 #define V0_DEFAULT_VALUE        1050
 #define FAN_MIN_RPM_THRESHOLD   4000
 extern uint16_t Head_Fan_Tach[2];
@@ -65,6 +65,9 @@ uint8_t     HeadBlowersEnable = 1;
 uint8_t     BlowerIdToSensorId[2] = {HEAD_PT100_ZONE_7_0X86_0, HEAD_PT100_ZONE_5_0X84_0}; //HEAD_FAN_RIGHT, HEAD_FAN_LEFT
 uint32_t HeadBlowersInitControlId = 0xFF;
 uint32_t HeadBlowersV0InitCount = 0;
+uint32_t HeadBlowersV0InitInProgress = 0;
+float PressureSensor_CP = PRESSURE_SENSOR_CP;
+float PressureSensor_B = PRESSURE_SENSOR_B;
 
 typedef struct
 {
@@ -225,6 +228,9 @@ void setArcHeadAlarms(uint32_t AlarmId, bool value)
     {
         switch(AlarmId)
         {
+            case EVENT_TYPE__DYEING_HEAD_COVER_IS_OPEN:
+                ReportWithPackageFilter(HeatersFilter,"FlatHeadAlarms on",__FILE__,AlarmId,count9,RpError, 0,0);
+                break;
             /*case EVENT_TYPE__DYEING_HEAD_ARC_LID_IS_OPEN:
                 ReportWithPackageFilter(HeatersFilter,"ArcHeadAlarms on",__FILE__,AlarmId,count9,RpError, 0,0);
                 break;
@@ -258,7 +264,19 @@ void setArcHeadAlarms(uint32_t AlarmId, bool value)
         }
     }
 }
+void FlatHeadAlarms(void)
+{
+    if (FPGA_Read_limit_Switches(Motor_Id_to_LS_IdUp  [HARDWARE_MOTOR_TYPE__MOTO_DH_LID]) == LIMIT) {
+        if (++count9 == ARC_ALARM_LIMIT)
+            setArcHeadAlarms(EVENT_TYPE__DYEING_HEAD_COVER_IS_OPEN, true);
+        count9 = (count9 > ARC_ALARM_LIMIT)?(ARC_ALARM_LIMIT):(count9);
+    } else {
+        if (--count9 == 0)
+            setArcHeadAlarms(EVENT_TYPE__DYEING_HEAD_COVER_IS_OPEN, false);
+        count9 = (count9 < 0)?(0):(count9);
+    }
 
+}
 void ArcHeadAlarms(void)
 {
     double currentFlow = 0.0;
@@ -332,9 +350,11 @@ void ArcHeadAlarms(void)
         count5 = (count5 < 0)?(0):(count5);
     }
     if (currentFlow < 1.0) {
-        if (++count6 == ARC_ALARM_LIMIT)
-            setArcHeadAlarms(EVENT_TYPE__DYEING_HEAD_BLOWER_1_FLOW_TOO_LOW, true);
-        count6 = (count6 > ARC_ALARM_LIMIT)?(ARC_ALARM_LIMIT):(count6);
+        if (!HeadBlowersV0InitInProgress) {
+            if (++count6 == ARC_ALARM_LIMIT)
+                setArcHeadAlarms(EVENT_TYPE__DYEING_HEAD_BLOWER_1_FLOW_TOO_LOW, true);
+            count6 = (count6 > ARC_ALARM_LIMIT)?(ARC_ALARM_LIMIT):(count6);
+        }
     } else {
         if (--count6 == 0)
             setArcHeadAlarms(EVENT_TYPE__DYEING_HEAD_BLOWER_1_FLOW_TOO_LOW, false);
@@ -352,9 +372,11 @@ void ArcHeadAlarms(void)
         count7 = (count7 < 0)?(0):(count7);
     }
     if (currentFlow < 1.0) {
-        if (++count8 == ARC_ALARM_LIMIT)
-            setArcHeadAlarms(EVENT_TYPE__DYEING_HEAD_BLOWER_2_FLOW_TOO_LOW, true);
-        count8 = (count8 > ARC_ALARM_LIMIT)?(ARC_ALARM_LIMIT):(count8);
+        if (!HeadBlowersV0InitInProgress) {
+            if (++count8 == ARC_ALARM_LIMIT)
+                setArcHeadAlarms(EVENT_TYPE__DYEING_HEAD_BLOWER_2_FLOW_TOO_LOW, true);
+            count8 = (count8 > ARC_ALARM_LIMIT)?(ARC_ALARM_LIMIT):(count8);
+        }
     } else {
         if (--count8 == 0)
             setArcHeadAlarms(EVENT_TYPE__DYEING_HEAD_BLOWER_2_FLOW_TOO_LOW, false);
@@ -435,7 +457,7 @@ double PressureSensorGetPressure(uint8_t FanId)
     Vm /= 10.0;
     if ((Vm - V0 + 22)<0)
         return 0.0;
-    Q = sqrt(Vm - V0 + 22) * PRESSURE_SENSOR_CP - PRESSURE_SENSOR_B;
+    Q = sqrt(Vm - V0 + 22) * PressureSensor_CP + PressureSensor_B;
     return Q;
 }
 
@@ -500,6 +522,7 @@ uint32_t HeadBlowersInitCallbak(uint32_t IfIndex, uint32_t ReadValue)
         HeadBlowersInitControlId = 0xFF;
         HeadBlowerAirflowCalibration();
         HeadBlowersOff(0);
+        HeadBlowersV0InitInProgress = 0;
         Report("Head Blowers V0 calculated", __FILE__, __LINE__, PressureSensorV0[0], RpMessage, PressureSensorV0[1], 0);
         Waste_Check_Flows();
     }
@@ -524,7 +547,23 @@ uint32_t HeadBlowersV0Init(void)
 
     //init Head Blowers V0
     HeadBlowersV0InitCount = 0;
+    HeadBlowersV0InitInProgress = 1;
     HeadBlowersInitControlId = AddControlCallback("Head Blowers V0 init", HeadBlowersInitCallbak, eOneSecond,  TemplateDataReadCBFunction, 0, 0, 0);
     Report("Head Blowers V0 init", __FILE__, __LINE__, Head_Type, RpMessage, 0, 0);
     return OK;
 }
+
+void Set_Head_Blowers_Parameters(float cp,float b)
+{
+    if (cp)
+    {
+        PressureSensor_CP = cp;
+        Report("Head Blowers CP Coefficient", __FILE__, __LINE__, (int)(PressureSensor_CP * 1000), RpMessage, 0, 0);
+    }
+    if (b)
+    {
+        PressureSensor_B = b;
+        Report("Head Blowers B Coefficient", __FILE__, __LINE__, (int)(PressureSensor_B * 1000), RpMessage, 0, 0);
+    }
+}
+
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h
index cac543647..7c11b12bf 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h
@@ -52,8 +52,10 @@ void HeadBlowersInit();
 uint32_t HeadBlowerPidRequestMessage(void* request, int BlowerId);
 void HeadBlowersCfg();
 void HeadBlowersControlLoop ();
+void FlatHeadAlarms(void);
 uint32_t  HeadBlowerCommandRequestMessage(int blowerId, float flow);
 void HeadBlowersOff(int off);
 uint32_t HeadBlowersOffGet();
 uint32_t HeadBlowersV0Init(void);
+void Set_Head_Blowers_Parameters(float cp,float b);
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
index 2f72c9cb0..db7261090 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
@@ -1006,18 +1006,25 @@ uint32_t HeaterPrepareFailureCheckTemperatures[HEATER_TYPE_MAX_HEATERS] = {0,0,0
 void HeaterPrepareFailureCheck(void)
 {
     int i;
+    int band = 200;
     if (GetHeatersPrepareWaiting() == false)
     {
         HeaterPrepareFailureCheckCounter = 0;
         return;
     }
+    if (HeaterPrepareFailureCheckCounter%60 == 0)
+        ReportWithPackageFilter(HeatersFilter,"HeaterPrepareFailureCheck",__FILE__,HeaterPrepareFailureCheckCounter,GetHeatersPrepareWaiting(),RpWarning,HeaterCheckReady(), 0);
     if ((HeaterPrepareFailureCheckCounter>=300)&&(HeaterPrepareFailureCheckCounter%60 == 0))
     {
         for (i = 0; i<HEATER_TYPE_MAX_HEATERS; i++)
         {
             if(HeaterReady[i] == false)
             {
-                if (abs (HeaterPrepareFailureCheckTemperatures[i] - HeaterPreviousRead[i])<200) // no temperature move in the last 5 minutes
+                if ((i == HEATER_TYPE__DryerAirHeater)||(i == HEATER_TYPE__HeadCoverHeater1)||(i == HEATER_TYPE__HeadCoverHeater2))
+                    band = 50;
+                else
+                    band = 200;
+                if (abs (HeaterPrepareFailureCheckTemperatures[i] - HeaterPreviousRead[i])<band) // no temperature move in the last 5 minutes
                 {
                     ReportWithPackageFilter(HeatersFilter,"HeaterPrepareFailureCheck",__FILE__,i,HeaterPrepareFailureCheckTemperatures[i],RpWarning,HeaterPreviousRead[i], 0);
                     JobEndReason = JOB_TEMPERATURE_ALARM;
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h b/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h
index 0f8108dad..e570a27f6 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h
@@ -30,6 +30,8 @@ extern uint32_t DispenserIdToMotorId[MAX_SYSTEM_DISPENSERS];
 extern bool HomingActive[MAX_SYSTEM_DISPENSERS];
 extern bool PrimingActive[MAX_SYSTEM_DISPENSERS];
 
+extern  uint32_t DispenserPreSegmentControlId;
+
 extern uint32_t LeftRockerSpeed;
 extern uint32_t RightRockerSpeed;
 
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
index 400eab33e..a1aa37c07 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
@@ -540,10 +540,22 @@ uint32_t IDS_Check_Pressure_Callback(uint32_t DispenserId, uint32_t ReadValue)
     TimerMotors_t  HW_Motor_Id = DispenserIdToMotorId[DispenserId];
     if (JobIsActive())
     {
-        if (DispenserUsedInJob[DispenserId] == true)
-        {
-            return ERROR;
-        }
+#ifndef LIGHT_COLORS
+            if ((DispenserId == CLEANER_DISPENSER)&&(DispenserPreSegmentControlId != 0xFF)) //not in presegment
+            {
+                return ERROR;
+            }
+            else if ((DispenserUsedInJob[DispenserId] == true)&&(DispenserId != CLEANER_DISPENSER))
+            {
+                return ERROR;
+            }
+
+#else
+            if (DispenserUsedInJob[DispenserId] == true)
+            {
+                return ERROR;
+            }
+#endif
     }
     if (Check_Pressure_Bypass == true)
         return OK;
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
index d567f8ad9..559ffdecc 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
@@ -701,6 +701,8 @@ bool AdjustDispenserSpeedToPressure(int DispenserId, double RefMaxPressure,doubl
                          {
                              continue;
                          }
+                         if (DispenserId!=Dispenser_i)
+                             ReportWithPackageFilter(IDSFilter,"DispenserId!=Dispenser_i",__FILE__,__LINE__,DispenserId,RpWarning,(int)Dispenser_i,0);
                          //(Speed*uStep*PPR)/((2*PI*Dispenser_Radius)
                          segmentfirst_speed = Dispensers[Dispenser_i]->nanolitterpersecond
                                  / Dispensers[Dispenser_i]->nanoliterperpulse;
@@ -729,7 +731,7 @@ bool AdjustDispenserSpeedToPressure(int DispenserId, double RefMaxPressure,doubl
                              {
                                  MotorSetSpeed(HW_Motor_Id, segmentfirst_speed);
                              }
-                             CurrentDispenserSpeed[Dispenser_i] = segmentfirst_speed;
+                             CurrentDispenserSpeed[DispenserId] = segmentfirst_speed;
 
                              /*usnprintf(IdMessage, 80,
                                        "WFCF Dispenser %d nl/sec %d nl/pulse %d Pulse/sec %d speed %d",
@@ -747,7 +749,7 @@ bool AdjustDispenserSpeedToPressure(int DispenserId, double RefMaxPressure,doubl
                              if (DispenserUsedInJob[DispenserId] == true)
                              {
                                  MotorStop(HW_Motor_Id, Hard_Hiz);
-                                 CurrentDispenserSpeed[Dispenser_i] = 0;
+                                 CurrentDispenserSpeed[DispenserId] = 0;
                                  //usnprintf(IdsMessage, 80,"WFCF Prepare Dispenser %d stopped",DispenserId,(int) segmentfirst_speed);
                                  //ReportWithPackageFilter(IDSFilter,IdsMessage, __FILE__, __LINE__, Dispenser_i, RpWarning,   segmentfirst_speed, 0);
                              }
@@ -964,9 +966,12 @@ bool AdjustDispenserSpeedToPressure(int DispenserId, double RefMaxPressure,doubl
              }
          }
 #ifndef LIGHT_COLORS
-         TimerMotors_t  HW_Motor_Id = DispenserIdToMotorId[CLEANER_DISPENSER];
-         MotorSetSpeed((TimerMotors_t)HW_Motor_Id,INITIAL_CLEANER_SPEED ); //set the dispenser to the
-         CurrentDispenserSpeed[CLEANER_DISPENSER] = INITIAL_CLEANER_SPEED;
+         if (GetDispenserPressure(CLEANER_DISPENSER) < 0.01)
+         {
+             TimerMotors_t  HW_Motor_Id = DispenserIdToMotorId[CLEANER_DISPENSER];
+             MotorSetSpeed((TimerMotors_t)HW_Motor_Id,INITIAL_CLEANER_SPEED ); //set the dispenser to the
+             CurrentDispenserSpeed[CLEANER_DISPENSER] = INITIAL_CLEANER_SPEED;
+         }
          ReportWithPackageFilter(IDSFilter,"IDS start cleaner",__FILE__,CLEANER_DISPENSER,(int)(GetDispenserPressure(CLEANER_DISPENSER)*100),RpWarning,(int)CurrentDispenserSpeed[CLEANER_DISPENSER] ,0);
 #endif
 
@@ -1085,9 +1090,9 @@ bool AdjustDispenserSpeedToPressure(int DispenserId, double RefMaxPressure,doubl
                          / Dispensers[Dispenser_i]->nanoliterperpulse;
                  if (segmentfirst_speed > MINIMAL_MOTOR_SPEED)
                  {
-                     DispenserUsedInSegment[Dispenser_i] = true;
+                     DispenserUsedInSegment[DispenserId] = true;
                      MotorSetSpeed(HW_Motor_Id, DispenserPrepareSpeed);
-                     CurrentDispenserSpeed[Dispenser_i] = DispenserPrepareSpeed;
+                     CurrentDispenserSpeed[DispenserId] = DispenserPrepareSpeed;
                      //usnprintf(IdsMessage, 80,"Presegment Prepare Dispenser %d speed %d",DispenserId,(int) DispenserPrepareSpeed);
                      //REPORT_MSG(segmentfirst_speed,IdsMessage);
                      //ReportWithPackageFilter(IDSFilter,IdsMessage, __FILE__, __LINE__, Dispenser_i, RpWarning,   DispenserPrepareSpeed, 0);
@@ -1105,7 +1110,7 @@ bool AdjustDispenserSpeedToPressure(int DispenserId, double RefMaxPressure,doubl
                          {
                              MotorStop(HW_Motor_Id, Hard_Hiz);
                          }
-                         CurrentDispenserSpeed[Dispenser_i] = 0;
+                         CurrentDispenserSpeed[DispenserId] = 0;
                          //usnprintf(IdsMessage, 80,"Presegment Prepare Dispenser %d stopped",DispenserId,(int) segmentfirst_speed);
                          //ReportWithPackageFilter(IDSFilter,IdsMessage, __FILE__, __LINE__, Dispenser_i, RpWarning,   segmentfirst_speed, 0);
                      }
@@ -1302,7 +1307,7 @@ uint32_t IDS_Cleaning_Stop_Cleaning_Solution (callback_fptr callback);
                          //Control3WayValvesWithCallback (DispenserId, Dispenser_Mixer, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
                          //IDS_Dispenser_Start_Motor_and_Open_Valve(DispenserId,segmentfirst_speed,NULL);
                          MotorSetSpeed(HW_Motor_Id, segmentfirst_speed);
-                         CurrentDispenserSpeed[Dispenser_i] = segmentfirst_speed;
+                         CurrentDispenserSpeed[DispenserId] = segmentfirst_speed;
 
                          /*usnprintf(IdMessage, 80,
                                    "WFCF Dispenser %d nl/sec %d nl/pulse %d Pulse/sec %d speed %d",
@@ -1422,47 +1427,8 @@ uint32_t IDSPreSegmentState(void *SegmentDetails, int SegmentId)
                 }
                 ReportWithPackageFilter(IDSFilter,"Add control callback ",__FILE__,__LINE__,(int)100,RpWarning,(int)lInterSegmentLength,0);
             }
-            /*if (EnableCleaning == true)
-            {
-                InterSegmentStartSprayCleaner = 500;
-                InterSegmentStartRocking = 1000;
-                InterSegmentCenterRockers = 3000;
-            }*/
-
-            //InterSegmentStartWFCFDispensers = (lInterSegmentLength>5000)?lInterSegmentLength-5000:lInterSegmentLength;
         }
     }
-    /*if (SegmentId == 0)//first segment - running the DTS out of the drier
-    {
-        Valve_Set(VALVE_MIXCHIP_WASTECH, Mixer_Waste); //if intersegment is defined throw the ink away
-        for (Dispenser_i = 0; Dispenser_i < MAX_SYSTEM_DISPENSERS; Dispenser_i++)
-        {
-            HW_Motor_Id = DispenserIdToMotorId[Dispenser_i];
-            //MotorStop(HW_Motor_Id,Hard_Hiz); //26/03/19 test  without valves
-            if (DispenserUsedInJob[Dispenser_i]==true)//unconfigured dispenser
-            {
-                MotorStop(HW_Motor_Id, Soft_Hiz);
-                CurrentDispenserSpeed[Dispenser_i] = 0;
-            }
-        }
-        lInterSegmentLength = (dryerbufferCentimeters*1000/dyeingspeed);
-        lInterSegmentLength-=(lInterSegmentLength%100);   //round to a 100 multiplication
-        InterSegmentStepsCount = 0;
-        DispenserPreSegmentControlId = AddControlCallback( IDSPreSegmentStateCallbackRunner, IDS_PRESEGMENT_TIME_STEP,TemplateDataReadCBFunction ,0, 0, 0 );
-        if (DispenserPreSegmentControlId == 0xFF)
-        {
-            ReportWithPackageFilter(IDSFilter,"Add control callback failed",__FILE__,__LINE__,(int)100,RpWarning,(int)0,0);
-            return ERROR;
-        }
-        ReportWithPackageFilter(IDSFilter,"Add control callback ",__FILE__,__LINE__,(int)100,RpWarning,(int)lInterSegmentLength,0);
-        if (EnableCleaning == true)
-        {
-            InterSegmentStartSprayCleaner = 500;
-            InterSegmentStartRocking = 1000;
-            InterSegmentCenterRockers = 3000;
-        }
-        InterSegmentStartWFCFDispensers = lInterSegmentLength-5000;
-    }*/
 
     if (uploadstrategy == JOB_UPLOAD_STRATEGY__Default)
     {
@@ -1539,8 +1505,6 @@ uint32_t IDSPreSegmentState(void *SegmentDetails, int SegmentId)
                         MotorStop(HW_Motor_Id,Soft_Hiz); //26/03/19 test  without valves
                     }
                     CurrentDispenserSpeed[DispenserId] = 0;
-                    //MotorSetSpeed(HW_Motor_Id, 5);
-                    //CurrentDispenserSpeed[Dispenser_i] = 5;
                     DispenserPreSegmentReady[DispenserId] = true; //27/03/19 check if job should be stopped
                     REPORT_MSG(DispenserId,"Dispenser stopped pre Segment");
                 }
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Calculate.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Calculate.c
index d26b3d814..3f1ceeabb 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Calculate.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Calculate.c
@@ -47,7 +47,7 @@ uint32_t CalculateRpeat(uint32_t IfIndex, uint32_t BusyFlag)
 
 void Stub_CalculateRequest(MessageContainer* requestContainer)
 {
-    MessageContainer responseContainer;
+    //MessageContainer responseContainer;
 
     CalculateRequest* request = calculate_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
     ustrncpy (CalculateToken, requestContainer->token,36);
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Procedure.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Procedure.c
index c2871869d..c84dc5fb5 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Procedure.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Procedure.c
@@ -93,7 +93,7 @@ void Stub_ProcedureRequest(MessageContainer* requestContainer)
                 response.replymessage = request->testname;
                 if (n_param)
                 {
-                    response.replyvalue = (float**)my_malloc(sizeof(float *)*(request->n_param));
+                    response.replyvalue = (float*)my_malloc(sizeof(float *)*(request->n_param));
                     response.n_replyvalue = request->n_param;
                     for(i=0;i<n_param;i++)
                     {
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
index 096876cf1..659a308db 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
@@ -39,6 +39,7 @@
 #include <Drivers/I2C_Communication/WHS_Card/IO_Extender_Ports_TCA9555/WHS_IO.h>
 #include "drivers/Heater/TemperatureSensor.h"
 #include "Drivers/I2C_Communication/Head_Card/PT100/ADS122X04.h"
+#include "drivers/I2C_Communication/DAC/Blower.h"
 
 #include "Modules/IFS/ifs.h"
 #include "Modules/IDS/ids_ex.h"
@@ -56,6 +57,7 @@
 extern HeadBoardTempSensConfigStruc  HeadTempSensConfig[MAX_HEAD_CARD_TEMP_SENS_ID];
 extern float NumberOfRotationPerPassage;  // how many rotations per spool passage
 extern void HeaterSafetyTestSetLimits(int limit);
+extern uint32_t InitSequenceWHSAirFlowCalibration(void);
 
 //#include "graphics_adapter.h"
 extern uint8_t Input_Voltage;
@@ -1044,7 +1046,9 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
         Read_Dryer_ENC_Position();
         Task_sleep(500);
 
-        response.progress = (double)MCU_E2PromProgram(EEPROM_STORAGE_DRYER_CENTER,Read_Dryer_ENC_Position(0,0));
+        (double)MCU_E2PromProgram(EEPROM_STORAGE_DRYER_CENTER,Read_Dryer_ENC_Position(0,0));
+
+        response.progress = (double)Read_Dryer_ENC_Position(0,0);
         response.has_progress = true;
     }
     else
@@ -1340,6 +1344,35 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
         response.has_progress = true;
     }
 #endif
+    else
+    if(request->amount == 0xD11)
+    {
+        REPORT_MSG(request->delay, "stop/start blower control and blower");
+        if (request->delay == 0)
+        {
+            WHS_enable_control_loop(false);
+            Turn_the_Blower_On();//Turn on with the Default_Voltage
+            Control_Voltage_To_Blower(1); //stop the blower
+        }
+        else
+        {
+            Turn_the_Blower_On();//Turn on with the Default_Voltage
+            Control_Voltage_To_Blower(2400); //stop the blower
+            WHS_enable_control_loop(true);
+        }
+
+        response.progress = request->delay;
+        response.has_progress = true;
+    }
+    else
+    if(request->amount == 0xD12)
+    {
+        REPORT_MSG(request->delay, "stop/start blower control and blower");
+        InitSequenceWHSAirFlowCalibration();
+
+        response.progress = request->delay;
+        response.has_progress = true;
+    }
     else     
 	if((request->amount == 0xDF) && (request->delay == 0xDF)) //Power off
     {
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
index f2ca4e8d7..ffbb504db 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
@@ -247,7 +247,8 @@
     }
     uint32_t Thread_Load_Set_Load_Arm_To_Stopper_Callback(uint32_t deviceID, uint32_t BusyFlag)
     {
-        uint32_t angle, temp = Read_Dryer_ENC_Position();
+        uint32_t temp = Read_Dryer_ENC_Position();
+        int angle;
 
         ReportWithPackageFilter(DiagnosticsFilter,"Thread_Load_Set_Load_Arm_To_Stopper_Callback",__FILE__,(int)numberOfCycles,(int)DrierPrevLocation,RpMessage,temp,0);
 
@@ -258,12 +259,14 @@
         {
             CallbackCounter--;
         }
-        if ((abs(angle)>14000  )&&(BusyFlag == NOTBUSY)) // OK - take another round
+        if (abs(angle)<10  ) // OK
         {
             Report("Thread_Load_Set_Load_Arm_To_Stopper time",__FILE__,msec_millisecondCounter - UnloadingStart,msec_millisecondCounter,RpMessage,UnloadingStart,0);
 
             Report("Thread_Load_Set_Load_Arm_To_Stopper_Callback",__FILE__,__LINE__,LoadStages,RpMessage,CallbackCounter,0);
             NumberOfDrierLoaderCycles=0;
+            MCU_E2PromProgram(EEPROM_STORAGE_DRYER_CYCLES,0);
+
             //storeLoadArmParameters();
             LoadStages++;
 
@@ -272,7 +275,7 @@
         else
         {
             load.color = fastBILNK;
-            usnprintf(LoadErrorMsg, 100, "Stage %s - %s timeout",LoadStagesStr[LoadStages], MotorStr[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM]);
+            usnprintf(LoadErrorMsg, 100, "^Stage %s - %s timeout",LoadStagesStr[LoadStages], MotorStr[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM]);
             Report(LoadErrorMsg,__FILE__,__LINE__,LoadStages,RpWarning,TimeoutsCounter,0);
 
             LoadStatus = ERROR;
@@ -317,7 +320,7 @@
                 {
                     TimeoutsCounter = 0;
                     load.color = fastBILNK;
-                    usnprintf(LoadErrorMsg, 100, "Stage %s - %s timeout",LoadStagesStr[LoadStages], MotorStr[MotorId]);
+                    usnprintf(LoadErrorMsg, 100, "/Stage %s - %s timeout",LoadStagesStr[LoadStages], MotorStr[MotorId]);
                     Report(LoadErrorMsg,__FILE__,__LINE__,LoadStages,RpWarning,TimeoutsCounter,0);
 
                     LoadStatus = ERROR;
@@ -687,7 +690,7 @@
             TimeoutsCounter = 0;
             CallbackCounter = 0;
             load.color = fastBILNK;
-            usnprintf(LoadErrorMsg, 100, "Stage %s - Dryer load arm timeout",LoadStagesStr[LoadStages]);
+            usnprintf(LoadErrorMsg, 100, "$Stage %s - Dryer load arm timeout",LoadStagesStr[LoadStages]);
             Report(LoadErrorMsg,__FILE__,__LINE__,LoadStages,RpWarning,TimeoutsCounter,0);
             LoadStatus = ERROR;
             MotorSetMaxSpeed (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, 200);
@@ -729,6 +732,13 @@
         {
             LoadArmRounds -= CurrentlyLoaded;
         }
+        if (LoadArmRounds == CurrentlyLoaded)
+        {
+            Report("Thread_Load_Dryer_Loading no need for cycles",__FILE__,__LINE__,LoadStages,RpMessage,CallbackCounter,0);
+            LoadStages++;
+            ThreadLoadStateMachine(LoadStages);
+            return OK;
+        }
         ThreadMotorIdToMotorId[FEEDER_MOTOR] = HARDWARE_MOTOR_TYPE__MOTO_RDRIVING ;
         ThreadMotorIdToMotorId[DRYER_MOTOR] = HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING;
 
@@ -932,7 +942,7 @@
 
             MotorStop(HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,Hard_Hiz);
             load.color = fastBILNK;
-            usnprintf(LoadErrorMsg, 100, "Stage %s - Dryer load arm timeout",LoadStagesStr[LoadStages]);
+            usnprintf(LoadErrorMsg, 100, "&Stage %s - Dryer load arm timeout",LoadStagesStr[LoadStages]);
             Report(LoadErrorMsg,__FILE__,__LINE__,LoadStages,RpWarning,TimeoutsCounter,0);
             Report("Dryer unloading timeout(1) or no movement",__FILE__,temp,DrierPrevLocation,RpWarning,ReadValue,0);
             LoadStatus = ERROR;
@@ -1489,6 +1499,8 @@ uint32_t ThreadLoadingRestartReport(void) //sending after a failure in the final
 
     if (ThreadLoadingToken[0] == 0)
         return OK;
+    if (LoadStages == THREAD_LOAD_INIT)
+        return OK;
     ThreadLoadingRestartFlag = true;
 
     response.has_state = true;
@@ -1520,6 +1532,12 @@ uint32_t TryThreadLoadingFunc(MessageContainer* requestContainer)
     {
         responseContainer = createContainer(MESSAGE_TYPE__TryThreadLoadingResponse, requestContainer->token, true, &Cresponse, &try_thread_loading_response__pack, &try_thread_loading_response__get_packed_size);
         responseContainer.continuous = false;
+        if (JobIsActive()||(MachineReadyForHeating == false)||(FPGABurningActive==true))
+        {
+            responseContainer.has_error = true;
+            responseContainer.error = ERROR_CODE__GENERAL_ERROR;
+            responseContainer.errormessage = "The machine is not ready for loading";
+        }
         uint8_t* container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
         size_t container_size = message_container__pack(&responseContainer, container_buffer);
         my_free(responseContainer.data.data);
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
index a75241671..03bc9d24d 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
@@ -50,6 +50,7 @@ bool     WinderMotorSpeedRollOver = false;
 int StartWinderCalculation = 0;
 #define DEFAULT_SCREW_SPEED 1200
 double   ScrewSpeed = DEFAULT_SCREW_SPEED;
+double RetreatTime = 0;
 double   ScrewRunningTime = 0;
 uint32_t ScrewNumberOfSteps = 0;     //holds the current number of steps for the next screw run - will be used to build the cone
 bool     SCREW_TimerActivated = false;
@@ -635,6 +636,7 @@ uint32_t Winder_Presegment(void *SegmentDetails, uint32_t SegmentId)
         temp *= ScrewNumberOfSteps;
         temp /= ScrewSpeed;
         ScrewRunningTime = temp;//(SYS_CLK_FREQ*InternalWinderCfg.segmentoffsetpulses)/ScrewSpeed;
+        RetreatTime = ScrewNumberOfSteps*1000/ScrewSpeed;
         REPORT_MSG((int)ScrewNumberOfSteps,"Winder pre segment - ScrewNumberOfSteps");
         REPORT_MSG((int)ScrewRunningTime,"Winder pre segment - ScrewRunningTime");
         //MotorSetDirection (HARDWARE_MOTOR_TYPE__MOTO_SCREW, ScrewCurrentDirection);
@@ -673,11 +675,11 @@ uint32_t ScrewDTSCallback(uint32_t deviceID, uint32_t BusyFlag)
     //move the cart to the edge so the spool can be easily replaced
     //MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_SCREW,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].directionthreadwize, 1000, GPI_LS_SCREW_RIGHT, NULL,0);
     //MotorStop(HARDWARE_MOTOR_TYPE__MOTO_SCREW,Hard_Hiz);
-    MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_SCREW,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].directionthreadwize, ScrewSpeed, GPI_LS_SCREW_RIGHT, WinderDistanceToSpoolEnded,2000);
+    MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_SCREW,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].directionthreadwize, ScrewSpeed, GPI_LS_SCREW_RIGHT, WinderDistanceToSpoolEnded,RetreatTime*2);
 #ifdef FOUR_WINDERS
-    MotorMovetoLimitSwitch (SCREW_2_Motor,MotorsCfg[SCREW_2_Motor].directionthreadwize, ScrewSpeed, GPI_LS_SPARE2_2, NULL,2000);
-    MotorMovetoLimitSwitch (SCREW_3_Motor,MotorsCfg[SCREW_3_Motor].directionthreadwize, ScrewSpeed, GPI_LS_SPARE1_2, NULL,2000);
-    MotorMovetoLimitSwitch (SCREW_4_Motor,MotorsCfg[SCREW_4_Motor].directionthreadwize, ScrewSpeed, GPI_LS_RDANCER_UP, NULL,2000);
+    MotorMovetoLimitSwitch (SCREW_2_Motor,MotorsCfg[SCREW_2_Motor].directionthreadwize, ScrewSpeed, GPI_LS_SPARE2_2, NULL,RetreatTime*2);
+    MotorMovetoLimitSwitch (SCREW_3_Motor,MotorsCfg[SCREW_3_Motor].directionthreadwize, ScrewSpeed, GPI_LS_SPARE1_2, NULL,RetreatTime*2);
+    MotorMovetoLimitSwitch (SCREW_4_Motor,MotorsCfg[SCREW_4_Motor].directionthreadwize, ScrewSpeed, GPI_LS_RDANCER_UP, NULL,RetreatTime*2);
 #endif
 
     return OK;
@@ -685,10 +687,14 @@ uint32_t ScrewDTSCallback(uint32_t deviceID, uint32_t BusyFlag)
 uint32_t WinderDistanceToSpoolState(void )
 {
     double DTS_Time = (dryerbufferCentimeters/dyeingspeed)*1000;//distance to spool time in milliseconds
-    REPORT_MSG ((int)DTS_Time,"WinderDistanceToSpoolState");
+    double WinderBackTimeBySpeed = WinderBackToBaseTime;
+    WinderBackTimeBySpeed *= 50;
+    WinderBackTimeBySpeed /= dyeingspeed;
+    Report("WinderDistanceToSpoolState start", __FILE__,DTS_Time,RetreatTime, RpMessage, (int)WinderBackTimeBySpeed, 0);
+    //REPORT_MSG ((int)DTS_Time,"WinderDistanceToSpoolState");
 
-    ScrewDTSControlId = AddControlCallback("screw DTS",ScrewDTSCallback, DTS_Time-WinderBackToBaseTime,TemplateDataReadCBFunction,0,0,0);
-    Report("ScrewDTSCallback start", __FILE__,DTS_Time,msec_millisecondCounter, RpMessage, WinderBackToBaseTime, 0);
+    ScrewDTSControlId = AddControlCallback("screw DTS",ScrewDTSCallback, DTS_Time-RetreatTime,TemplateDataReadCBFunction,0,0,0);
+    Report("ScrewDTSCallback start", __FILE__,DTS_Time,msec_millisecondCounter, RpMessage, (int)WinderBackTimeBySpeed, 0);
 
     return OK;
 }
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h
index 11a92ab63..4ce48a639 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h
@@ -9,6 +9,10 @@
 #define WINDER_DANCER HARDWARE_DANCER_TYPE__LeftDancer
 #define POOLER_DANCER HARDWARE_DANCER_TYPE__MiddleDancer
 #define FEEDER_DANCER HARDWARE_DANCER_TYPE__RightDancer
+#define WINDER_2_DANCER HARDWARE_DANCER_TYPE__FourthDancer
+#define WINDER_3_DANCER HARDWARE_DANCER_TYPE__ThirdDancer
+#define WINDER_4_DANCER HARDWARE_DANCER_TYPE__RightDancer
+
 #define NUM_OF_DANCERS NUM_OF_ROTENC
 //} DANCER_ENUM;
 typedef enum threadMotorsEnum
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
index ba505493d..4ced1e5fe 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
@@ -629,6 +629,10 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
 			//pooler dancer is right sided: data is opposite
             TranslatedReadValue = (-1*TranslatedReadValue);
         }
+#ifdef BTSR_ROTATED_WINDER_TFU
+        if (index == WINDER_MOTOR)
+                TranslatedReadValue = (-1*TranslatedReadValue);
+#endif
 #ifdef FOUR_WINDERS
         if (index == WINDER_MOTOR)
         {
@@ -653,7 +657,7 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
             TranslatedReadValue = (-1*TranslatedReadValue);
         }*/
 #endif
-        if (index == POOLER_MOTOR)
+        if (index == WINDER_MOTOR)
         {
             //pooler dancer is right sided: data is opposite
             JobCounter++;
@@ -710,6 +714,10 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
         {
             NormalizedError = (-1*NormalizedError);
         }
+/*#ifdef BTSR_ROTATED_WINDER_TFU
+        if (index == WINDER_MOTOR)
+                TranslatedReadValue = (-1*TranslatedReadValue);
+#endif*/
 
         MotorControlConfig[index].m_mesuredParam = NormalizedError;
         DancerError[DancerId] = NormalizedError;
@@ -1061,7 +1069,7 @@ uint32_t ThreadPrepare_Tension (int DancerId, double tension)
     return status;
 }
 //********************************************************************************************************************
-bool SkipOpenLids = true;
+bool SkipOpenLids = false;
 uint32_t ThreadPrepareState(void *JobDetails)
 {
     int Motor_i,i, HW_Motor_Id, Pid_Id;