thread loading, mostly

11 files changed, 188 insertions, 99 deletions

diff --git a/Software/Embedded_SW/Embedded/Drivers/Motors/MotorActions.c b/Software/Embedded_SW/Embedded/Drivers/Motors/MotorActions.c
index 4722bfe2f..75f68d00c 100644
--- a/Software/Embedded_SW/Embedded/Drivers/Motors/MotorActions.c
+++ b/Software/Embedded_SW/Embedded/Drivers/Motors/MotorActions.c
@@ -44,9 +44,6 @@ uint32_t DrierZeroPosition = 0;
 //bool     DrierBackLashDirection = false;
 uint32_t Arm_Drier_Center = 0;
 callback_fptr UnloadingReset = NULL;
-/*int CallbackCalls=0;
-int FirstCall = 0;
-#define MAX_CONTROL_SAMPLES 10*/
 int32_t ArmSamples[MAX_CONTROL_SAMPLES] = {0};
 int ArmSamplePointer = {0};
 int StoredavreageSampleValue = 0;
@@ -214,6 +211,7 @@ uint32_t MotorGotoWithBusyCallback (TimerMotors_t MotorId,bool direction, uint32
     //MotorStop(MotorId,Hard_Hiz );
     int sign = direction?1:-1;
     MotorGoTo(MotorId,Steps*sign );
+    CallbackCalls = 0;
     MotorControlId[MotorId] = AddControlCallback(NULL, MotorMoveCallBackFunction,  /*eTenMillisecond*/20, MotorControlGetnBusyState,(IfTypeMotors*0x100+MotorId), MotorId, 0 );
     MotorControlCallback[MotorId] = MotorMoveCallBackFunction;
     return MotorControlId[MotorId];
@@ -232,6 +230,7 @@ uint32_t MotorRunWithCallback (TimerMotors_t MotorId,bool direction, uint32_t Fr
     MotorTimeout[MotorId] = 0;
     MotorTimeLag[MotorId] = 20;
     MotorTimeLimit[MotorId] = timeout;
+    CallbackCalls = 0;
     if (MotorId ==HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM)
     {
         InitialArmLocation = Read_Dryer_ENC_Position(0,0);
@@ -250,10 +249,10 @@ uint32_t MotorRunWithCallback (TimerMotors_t MotorId,bool direction, uint32_t Fr
     MotorControlCallback[MotorId] = MotorMoveCallBackFunction;
     return MotorControlId[MotorId];
 }
-uint32_t MotorRunCallBackFunction(uint32_t IfIndex, uint32_t BusyFlag) //TODO
+uint32_t MotorRunCallBackFunction(uint32_t IfIndex, uint32_t ReadValue) //TODO
 {
     uint32_t MotorId,encoder,temp = 0;
-    uint32_t Busy = BUSY;
+    uint32_t RunningContinues = true;
     int     angle;
 
     if (IfIndex>>8 != IfTypeMotors)
@@ -289,7 +288,7 @@ uint32_t MotorRunCallBackFunction(uint32_t IfIndex, uint32_t BusyFlag) //TODO
                 }
             }
         }
-        else //loading - going up
+        /*else //loading - going up
         {
             //previous number is smaller than current
             if (InitialArmLocation<encoder)
@@ -310,32 +309,32 @@ uint32_t MotorRunCallBackFunction(uint32_t IfIndex, uint32_t BusyFlag) //TODO
                     InitialArmLocation=encoder;
                 }
             }
-        }
+        }*/
         if (((temp>1000)||(temp<20))&&(CallbackCalls>10))
         {
-            Report("MotorRunCallBackFunctionMotorRunCallBackFunction temp curr prev small",__FILE__,encoder,InitialArmLocation,RpWarning,temp,0);
+            Report("MotorRunCallBackFunction temp curr prev small",__FILE__,encoder,InitialArmLocation,RpWarning,temp,0);
             failCounter++;
-            if (failCounter>=20)
+            if (failCounter>=5)
             {
                 Report("arm stopped",__FILE__,failCounter,encoder,RpWarning,temp,0);
                 MotorStop(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM,Hard_Hiz);
-                BusyFlag = NOTBUSY;
+                RunningContinues = false;
             }
         }
         else
         {
             failCounter = 0;
-            BusyFlag = BUSY;
+            RunningContinues = true;
         }
         if (CallbackCalls%50 == 0)
         {
             //encoder = Read_Dryer_ENC_Position(0,0);
-            Report("MotorRunCallBackFunctionMotorRunCallBackFunction periodic curr prev total",__FILE__,encoder,temp,RpWarning,AccumulatedArmMovement,0);
+            Report("MotorRunCallBackFunction periodic curr prev total",__FILE__,encoder,temp,RpWarning,AccumulatedArmMovement,0);
         }
         if (CallbackCalls%200 == 0)
         {
             //encoder = Read_Dryer_ENC_Position(0,0);
-            Report("MotorRunCallBackFunctionMotorRunCallBackFunction",__FILE__,__LINE__,encoder,RpWarning,CallbackCalls,0);
+            Report("MotorRunCallBackFunction",__FILE__,__LINE__,encoder,RpWarning,CallbackCalls,0);
         }
     }
     else
@@ -348,24 +347,25 @@ uint32_t MotorRunCallBackFunction(uint32_t IfIndex, uint32_t BusyFlag) //TODO
     }
     MotorTimeout[MotorId]+=MotorTimeLag[MotorId];
 
-    if ((BusyFlag == NOTBUSY)||((MotorTimeout[MotorId]>=MotorTimeLimit[MotorId])&&(MotorTimeLimit[MotorId]>0)))
+    if ((RunningContinues == false)||((MotorTimeout[MotorId]>=MotorTimeLimit[MotorId])&&(MotorTimeLimit[MotorId]>0)))
        {
         if (MotorId == HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM)
         {
-            angle = Calculate_Arm_Distance(Arm_Drier_Center,temp);
+            angle = Calculate_Arm_Distance(Arm_Drier_Center,encoder);
 
             if (abs(angle)<400)
             {
-                BusyFlag = NOTBUSY;
+                RunningContinues = false;
             }
             else
             {
-                BusyFlag = BUSY;
+                RunningContinues = true;
             }
             Report("arm stopped call",__FILE__,failCounter,encoder,RpWarning,abs(DrierZeroPosition-encoder),0);
+            Report("arm stopped call 2",__FILE__,MotorTimeout[MotorId],RunningContinues,RpWarning,angle,0);
         }
            //stop this control loop
-        Report("MotorControlGetnBusyState stop",__FILE__,MotorId,BusyFlag,RpMessage,MotorCallback[MotorId],0);
+        Report("MotorControlGetnBusyState stop",__FILE__,MotorId,RunningContinues,RpMessage,MotorCallback[MotorId],0);
            SafeRemoveControlCallback(MotorControlId[MotorId], MotorRunCallBackFunction );
            MotorControlCallback[MotorId] = 0;
            MotorControlId[MotorId] = 0xFF;
@@ -374,13 +374,13 @@ uint32_t MotorRunCallBackFunction(uint32_t IfIndex, uint32_t BusyFlag) //TODO
             if ((MotorTimeout[MotorId]>=MotorTimeLimit[MotorId])&&(MotorTimeLimit[MotorId]>0))
             {
                Report("motor timeout",__FILE__,__LINE__,MotorId,RpMessage,MotorTimeout[MotorId],0);
-               Busy = BUSY;
+               RunningContinues = true;
             }
             Report("MotorRunCallBackFunction curr prev return",__FILE__,encoder,temp,RpWarning,AccumulatedArmMovement,0);
            //call the module callback
            if (MotorCallback[MotorId])
            {
-               MotorCallback[MotorId](MotorId,Busy);
+               MotorCallback[MotorId](MotorId,RunningContinues);
            }
 
        }
@@ -398,7 +398,7 @@ uint32_t MotorMoveWithCallback (TimerMotors_t MotorId,bool direction, uint32_t S
         Report("MotorControlGetnBusyState print",__FILE__,__LINE__,MotorDriverResponse[MotorId].Busy,RpMessage,0,0);
     }*/
     ReportWithPackageFilter(GeneralFilter,"MotorMoveWithCallback",__FILE__,direction,MotorId,RpMessage,Steps,0);
-
+    CallbackCalls = 0;
     //call driver action to device id with the parameter
     //SetMotorSpeed (deviceId, parameter);
     MotorCallback[MotorId] = callback;
@@ -542,6 +542,7 @@ uint32_t MotorMoveToStopper (TimerMotors_t MotorId,bool direction, uint32_t Spee
     Task_sleep(10);
     Initialcurrentposition = Read_Dryer_ENC_Position();
     cycles = 0;
+    CallbackCalls = 0;
     StoredMotorPosition[MotorId] = Read_Dryer_ENC_Position();
     Report("MotorMoveToStopper initial position",__FILE__,__LINE__,StoredMotorPosition[MotorId],RpWarning,Initialcurrentposition,0);
     MotorSetSpeed (MotorId, Speed);
@@ -619,8 +620,8 @@ uint32_t MotorMovetoEncoderPosition (TimerMotors_t MotorId,  callback_fptr callb
     currentposition = Control_Read_Dryer_Position(0,0);
     MCU_E2PromRead(EEPROM_STORAGE_DRYER_CENTER,&DrierZeroPosition);
     Report("MotorMovetoEncoderPosition",__FILE__,__LINE__,DrierZeroPosition,RpWarning,currentposition,0);
-    Report("MotorMovetoEncoderPosition callback",__FILE__,__LINE__,callback,RpWarning,speed,0);
-    if (abs(currentposition - DrierZeroPosition)<5)
+    Report("MotorMovetoEncoderPosition callback",__FILE__,__LINE__,direction,RpWarning,speed,0);
+    if (abs(currentposition - DrierZeroPosition)<2)
     {
         if (callback)
             callback(MotorId,0);
@@ -664,9 +665,11 @@ uint32_t MotorMoveCallBackFunction(uint32_t IfIndex, uint32_t BusyFlag) //TODO
     }
     MotorId = IfIndex&0xFF;
     CallbackCalls++;
-
     if (MotorId ==HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM)
     {
+        Read_Dryer_ENC_Position();
+        if (CallbackCalls<50)
+            return OK;
         if (CallbackCalls%200 == 0)
         {
             Report("MotorMoveCallBackFunction",__FILE__,__LINE__,MotorId,RpWarning,Read_Dryer_ENC_Position(0,0),0);
@@ -1157,7 +1160,7 @@ uint32_t LoadingArmReset_Callback(uint32_t MotorId, uint32_t ReadValue)
     uint32_t temp = Read_Dryer_ENC_Position();
     angle = Calculate_Arm_Distance(Arm_Drier_Center,temp);
     ReportWithPackageFilter(DiagnosticsFilter,"LoadingArmReset_Callback",__FILE__,angle,temp,RpMessage,Arm_Drier_Center,0);
-    //ReportWithPackageFilter(DiagnosticsFilter,"Diagnostics_Dryer_UnLoading_Callback details",__FILE__,(int)(TotalLoadedLen),D_numberOfCycles,RpMessage,CallbackCounter,0);
+    //ReportWithPackageFilter(DiagnosticsFilter,"Diagnostics_Dryer_UnLoading_Callback details",__FILE__,__LINE__,ReadValue,RpMessage,0,0);
     //if ((AccumulatedArmMovement>8000  )&&(ReadValue == NOTBUSY)) // OK - take another round
     if (ReadValue == NOTBUSY) // OK - take another round
     {
@@ -1167,11 +1170,11 @@ uint32_t LoadingArmReset_Callback(uint32_t MotorId, uint32_t ReadValue)
         //if (fabs(angle)<0.2)
         {
             ReportWithPackageFilter(DiagnosticsFilter,"drier center proximity",__FILE__,temp,Arm_Drier_Center,RpMessage,angle,0);
-            if (angle<400)
+            if (angle>0)
                 direction = 1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize;
             else
                 direction = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize;
-            MotorMovetoEncoderPosition(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM,LoadingArmReset_Callback_Stopper_Callback,/*3000*/16000,direction,10);
+            MotorMovetoEncoderPosition(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM,LoadingArmReset_Callback_Stopper_Callback,/*3000*/16000,direction,5);
 
         }
         else
@@ -1189,6 +1192,7 @@ uint32_t LoadingArmReset_Callback(uint32_t MotorId, uint32_t ReadValue)
     else  //timeout or no movement
     {
         ReportWithPackageFilter(DiagnosticsFilter,"Unloading drier - halted",__FILE__,__LINE__,Arm_Drier_Center,RpMessage,0,0);
+        MotorStop(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM,Hard_Stop);
         //MCU_E2PromProgram(EEPROM_STORAGE_DRYER_CYCLES,LoadArmRounds-(D_numberOfCycles-2));//it takes two cycles to identify a stop of the arm
 
         ReportWithPackageFilter(DiagnosticsFilter,"Dryer unloading timeout(1) or no movement",__FILE__,temp,Arm_Drier_Center,RpWarning,ReadValue,0);
@@ -1217,7 +1221,8 @@ uint32_t LoadingArmReset (callback_fptr callback,uint32_t timeout) //TODO
     ReportWithPackageFilter(DiagnosticsFilter,"LoadingArmReset",__FILE__,__LINE__,timeout,RpMessage, 0,0);
 
     MotorRunWithCallback (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, 1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize,
-                          MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround/4*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulleyradius,    LoadingArmReset_Callback, 300000);
+                          MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround/4*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulleyradius,
+                          LoadingArmReset_Callback, 300000);
 
     return OK;
 
diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
index 059b8fc4c..829261533 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;
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c
index 7e1424b8a..0e235e043 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c
@@ -481,17 +481,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();
+    uint32_t temp = Read_Dryer_ENC_Position();
+    int angle;
 
-    angle = Calculate_Arm_Distance(D_DrierPrevLocation,temp);
+    angle = Calculate_Arm_Distance(Drier_Center_read,temp);
 
-    if ((abs (angle)<14000  )||(BusyFlag == BUSY)) // OK - take another round
-    {
-        responseContainer.has_error = true;
-        responseContainer.error = ERROR_CODE__GENERAL_ERROR;
-
-    }
-    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 +501,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 +556,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,13 +615,14 @@ 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__,ReadValue,temp,RpMessage,angle,0);
@@ -653,6 +654,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/General/GeneralHardware.c b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
index 3fbb4e70c..c572d29e6 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
@@ -217,6 +217,13 @@ 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=120000.0 ;
+            EmbeddedParameters->has_initialdispensertimelag = true;
+            EmbeddedParameters->initialdispensertimelag=100.0 ;
+
             EmbeddedParameters->has_dispenserbuildpressurespeed = true;
             EmbeddedParameters->dispenserbuildpressurespeed=500;
             EmbeddedParameters->has_dispenserbuildpressurelimit = true;
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_Blowers.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_Blowers.c
index eefd42d75..2f8de1643 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_Blowers.c
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_Blowers.c
@@ -260,7 +260,7 @@ 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 (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);
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
index 750dc81af..73282fa97 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
@@ -1033,7 +1033,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
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_print.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
index ba505493d..c3fb17460 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
@@ -1061,7 +1061,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;
diff --git a/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c b/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c
index 21bf400de..dedf8ba98 100644
--- a/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c
+++ b/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c
@@ -109,6 +109,7 @@ HeadCleaningParameters *CleaningParameters = NULL;
 bool CopyConfigured[MAX_SYSTEM_MODULES];
 bool CleaningJobActive = false, JoggingJobActive = false;
 char ErrorMsg[100];
+uint32_t JobEndTimeMillisec = 0;
 ModuleStateEnum PrepareWaiting[MAX_SYSTEM_MODULES] = {ModuleIdle,ModuleIdle,ModuleIdle,ModuleIdle,ModuleIdle};
 
 double job_length = 0.0;
@@ -396,58 +397,77 @@ uint32_t ThreadJoggingFunc(int speed)
 {
     ProcessParameters ProcessParametersCopy;
     uint32_t status = OK;
-    if ((JobIsActive() == true)||(JoggingJobActive == true)||(MachineReadyForHeating == false)||(FPGABurningActive==true))
+//    JobEndTimeMillisec = msec_millisecondCounter;
+
+    if (JobIsActive() == true)
     {
-        status = ERROR;
-        Report("Jog JobIsActive or machine initialisation", __FILE__, __LINE__, JobIsActive(), RpWarning,   JoggingJobActive, 0);
+        Report("cannot jog while JobIsActive", __FILE__, __LINE__, JobIsActive(), RpWarning,   JoggingJobActive, 0);
+        return ERROR;
     }
-    else
+    if (JoggingJobActive == true)
     {
-        //memcpy(&CopyConfigured,&Configured,sizeof(CopyConfigured));
-        //usnprintf(ErrorMsg, 80,"Copy Configured T %d W %d I %d H %d W %d",CopyConfigured[Module_Thread],CopyConfigured[Module_Winder],CopyConfigured[Module_IDS],CopyConfigured[Module_Heaters],CopyConfigured[Module_Waste]);
-        //Report(ErrorMsg, __FILE__, __LINE__, 0, RpWarning,   0, 0);
+        Report("cannot jog while JoggingJobActive", __FILE__, __LINE__, JoggingJobActive, RpWarning,   JoggingJobActive, 0);
+        return ERROR;
+    }
+    if (MachineReadyForHeating == false)
+    {
+        Report("cannot jog while Machine not ReadyForHeating", __FILE__, __LINE__, MachineReadyForHeating, RpWarning,   JoggingJobActive, 0);
+        return ERROR;
+    }
+    if (FPGABurningActive==true)
+    {
+        Report("cannot jog while FPGABurningActive", __FILE__, __LINE__, FPGABurningActive, RpWarning,   JoggingJobActive, 0);
+        return ERROR;
+    }
+    if ((msec_millisecondCounter - JobEndTimeMillisec) <2000)
+    {
+        Report("cannot jog while Job Is ending", __FILE__, __LINE__, msec_millisecondCounter, RpWarning,   JobEndTimeMillisec, 0);
+        return ERROR;
+    }
+    //memcpy(&CopyConfigured,&Configured,sizeof(CopyConfigured));
+    //usnprintf(ErrorMsg, 80,"Copy Configured T %d W %d I %d H %d W %d",CopyConfigured[Module_Thread],CopyConfigured[Module_Winder],CopyConfigured[Module_IDS],CopyConfigured[Module_Heaters],CopyConfigured[Module_Waste]);
+    //Report(ErrorMsg, __FILE__, __LINE__, 0, RpWarning,   0, 0);
 
-        //set the job handler to ignore heaters, ids and waste in the state machine
-        Configured[Module_Thread] = true;
-        Configured[Module_Winder] = true;
-        Configured[Module_IDS] = false;
-        Configured[Module_Heaters] = false;
-        Configured[Module_Waste] = false;
-        //set the requested speed without changing other process parameters
-        memcpy (&ProcessParametersCopy,&ProcessParametersKeep,sizeof(ProcessParameters));
-        if(speed)
-            ProcessParametersCopy.dyeingspeed = speed;
-        else
-            ProcessParametersCopy.dyeingspeed = 40;
-        if (HandleProcessParameters(&ProcessParametersCopy,false)!= OK)
-        {
-            Report("Process parameters handling failed", __FILE__, __LINE__, 0, RpWarning,   0, 0);
-            status = FAILED;
-        }
-        else
-        {
-        //load essential job prameters to enable thread running
-            Ticket.n_segments = 1;
-            n_segments = 1;
-            Ticket.segments = my_malloc(sizeof(Ticket.segments));
-            TSegment = my_malloc(sizeof(JobSegment));
-            Tspool = my_malloc(sizeof(JobSpool));
-            TSegment->length = 200.0;
-            TSegment->n_brushstops = 0;
-            Ticket.segments[0] = TSegment;
-            Tspool->backingrate = 32;
-            Tspool->bottombackingrate = 32;
-            Tspool->segmentoffsetpulses = 1000;
-            Tspool->startoffsetpulses = 220;
-            Tspool->rotationsperpassage = 3.1415926*2;
-            Tspool->has_limitswitchstartpointoffset = false;
-            Ticket.spool = Tspool;
-            Ticket.threadparameters = &SavedThreadParameters;
-            CurrentJob = &Ticket;
-            InternalWindingConfigMessage(Tspool);
-            JoggingJobActive = true;
-            StartJob(&Ticket);
-        }
+    //set the job handler to ignore heaters, ids and waste in the state machine
+    Configured[Module_Thread] = true;
+    Configured[Module_Winder] = true;
+    Configured[Module_IDS] = false;
+    Configured[Module_Heaters] = false;
+    Configured[Module_Waste] = false;
+    //set the requested speed without changing other process parameters
+    memcpy (&ProcessParametersCopy,&ProcessParametersKeep,sizeof(ProcessParameters));
+    if(speed)
+        ProcessParametersCopy.dyeingspeed = speed;
+    else
+        ProcessParametersCopy.dyeingspeed = 40;
+    if (HandleProcessParameters(&ProcessParametersCopy,false)!= OK)
+    {
+        Report("Process parameters handling failed", __FILE__, __LINE__, 0, RpWarning,   0, 0);
+        status = FAILED;
+    }
+    else
+    {
+    //load essential job prameters to enable thread running
+        Ticket.n_segments = 1;
+        n_segments = 1;
+        Ticket.segments = my_malloc(sizeof(Ticket.segments));
+        TSegment = my_malloc(sizeof(JobSegment));
+        Tspool = my_malloc(sizeof(JobSpool));
+        TSegment->length = 200.0;
+        TSegment->n_brushstops = 0;
+        Ticket.segments[0] = TSegment;
+        Tspool->backingrate = 32;
+        Tspool->bottombackingrate = 32;
+        Tspool->segmentoffsetpulses = 1000;
+        Tspool->startoffsetpulses = 220;
+        Tspool->rotationsperpassage = 3.1415926*2;
+        Tspool->has_limitswitchstartpointoffset = false;
+        Ticket.spool = Tspool;
+        Ticket.threadparameters = &SavedThreadParameters;
+        CurrentJob = &Ticket;
+        InternalWindingConfigMessage(Tspool);
+        JoggingJobActive = true;
+        StartJob(&Ticket);
     }
     return status;
 }
diff --git a/Software/Embedded_SW/Embedded/StateMachines/Printing/PrintingSTM.c b/Software/Embedded_SW/Embedded/StateMachines/Printing/PrintingSTM.c
index 7db59946e..3e790eabe 100644
--- a/Software/Embedded_SW/Embedded/StateMachines/Printing/PrintingSTM.c
+++ b/Software/Embedded_SW/Embedded/StateMachines/Printing/PrintingSTM.c
@@ -59,6 +59,7 @@ uint16_t n_units = 1;
 uint16_t n_unit_segments = 0;
 
 extern bool JobActive;
+extern uint32_t JobEndTimeMillisec;
 /**********************************************************************
 * the array and enum of PrintingState_t below must be in sync order
 ***********************************************************************/
@@ -656,6 +657,7 @@ uint32_t EndState(void *JobDetails, char *Message)
     CloseJobFile();
     //ROM_IntMasterEnable();
     JobActive = false; //bug 4162 - test carefully
+    JobEndTimeMillisec = msec_millisecondCounter; //#4027
     SendJobProgress(0.0,0,true,Message);
     if ((JoggingJobActive==false)&&(CleaningJobActive == false))
     {
diff --git a/Software/Stubs Collection/stubs/read WHS V0.cs b/Software/Stubs Collection/stubs/read WHS V0.cs
new file mode 100644
index 000000000..fb67ba2cc
--- /dev/null
+++ b/Software/Stubs Collection/stubs/read WHS V0.cs
@@ -0,0 +1,33 @@
+using System;
+using System.Text;
+using System.Linq;
+using System.Drawing;
+using System.Diagnostics;
+using System.Windows.Forms;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Collections.Generic;
+using Tango.PMR.Stubs;
+using Tango.Stubs;
+
+public void OnExecute(StubManager stubManager)
+{
+
+	ProgressRequest progressRequest = new ProgressRequest();
+	progressRequest.Amount = 0xD11; //turn off blower and PID
+	progressRequest.Delay = 0;
+
+	var response = stubManager.Run<ProgressResponse>(progressRequest);
+	
+	Thread.Sleep(3000);
+
+	progressRequest.Amount = 0xD12;  //run V0 recalculation
+	response = stubManager.Run<ProgressResponse>(progressRequest);
+
+	
+	Thread.Sleep(20000);
+
+	progressRequest.Amount = 0xD11; //turn on blower and PID
+	progressRequest.Delay = 1;
+	response = stubManager.Run<ProgressResponse>(progressRequest);
+}
\ No newline at end of file