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

6 files changed, 146 insertions, 36 deletions

diff --git a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
index d31ea3c05..ab605bccb 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
+++ b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
@@ -767,8 +767,8 @@ uint32_t MillisecLowLoop(uint32_t tick)
                 MotorGetStatusFromFPGA(Motor_i);
         }*/
         midtankDisplay = 1-midtankDisplay;
-        if (WHS_Type == WHS_TYPE_UNKNOWN)
-            Gas_PPM_Info = Calculate_Gas_Power_Consumption();
+        /*if (WHS_Type == WHS_TYPE_UNKNOWN)
+            Gas_PPM_Info = Calculate_Gas_Power_Consumption();*/
         //Trigger_WHS_MAX11614_Read_allADC();
 #ifdef CONTROL_DEBUG
         ResetControlTime();
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c
index 6c2db3da9..cbb9a34c3 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c
@@ -24,6 +24,8 @@
 #include  <PMR/Diagnostics/MotorAbortHomingRequest.pb-c.h>
 #include  <PMR/Diagnostics/MotorAbortHomingResponse.pb-c.h>
 
+#include "Modules/Control/control.h"
+
 #include "drivers/Motors/Motor.h"
 #include "drivers/Valves/Valve.h"
 #include "Drivers/I2C_Communication/DAC/blower.h"
@@ -35,11 +37,41 @@
 #include "StateMachines/Printing/PrintingSTM.h"
 
 char HomingToken[NUM_OF_MOTORS][36+1]={0};
+int HomingCounter[NUM_OF_MOTORS];
+uint32_t HomingControlId[NUM_OF_MOTORS];
 
 /********************************************************************************
  * Motor Homing
  ********************************************************************************/
 //int32_t keepkvalright,keepkvalleft;
+uint32_t MotorHomingProgressReport(uint32_t deviceID, uint32_t ReadValue)
+{
+    MessageContainer responseContainer;
+    MotorHomingResponse response = MOTOR_HOMING_RESPONSE__INIT;
+    bool last = false;
+    response.has_progress = true;
+    response.has_maxprogress = true;
+    response.maxprogress = 1000;
+    if (HomingCounter[deviceID]>=1000)
+    {
+        last = true;
+        SafeRemoveControlCallback(HomingControlId[deviceID],MotorHomingProgressReport);
+        Report("MotorHomingProgressReport stopped 1000",__FILE__,__LINE__,deviceID,RpMessage,HomingCounter[deviceID],0);
+        HomingControlId[deviceID] = 0xff;
+    }
+    response.progress = HomingCounter[deviceID]++;
+    Report("MotorHomingProgressReport",__FILE__,__LINE__,deviceID,RpMessage,HomingCounter[deviceID],0);
+    responseContainer = createContainer(MESSAGE_TYPE__MotorHomingResponse, HomingToken[deviceID], last, &response, &motor_homing_response__pack, &motor_homing_response__get_packed_size);
+    responseContainer.has_continuous = true;
+    responseContainer.continuous = true;
+    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);
+    SendChars(container_buffer, container_size);
+
+    return OK;
+
+}
 
 uint32_t MotorHomingRequestCallback(uint32_t deviceID, uint32_t ReadValue)
 {
@@ -54,6 +86,12 @@ uint32_t MotorHomingRequestCallback(uint32_t deviceID, uint32_t ReadValue)
     {
         MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_LLOADING, 24);
     }
+    if (HomingControlId[deviceID] != 0xff)
+    {
+        Report("MotorHomingProgressReport stopped",__FILE__,__LINE__,deviceID,RpMessage,HomingCounter[deviceID],0);
+        RemoveControlCallback(HomingControlId[deviceID],MotorHomingProgressReport);
+        HomingControlId[deviceID] = 0xff;
+    }
     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;
@@ -70,7 +108,7 @@ uint32_t MotorHomingRequestFunc(MessageContainer* requestContainer)
 {
     uint32_t numberOfSteps = 0;
     uint32_t LoadArmRounds = (int)dryerbufferlength;
-
+    uint32_t status = FAILED;
     MessageContainer responseContainer;
 
     MotorHomingRequest* request = motor_homing_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
@@ -103,7 +141,7 @@ uint32_t MotorHomingRequestFunc(MessageContainer* requestContainer)
                     }
                     Report("MotorHomingRequestFunc Dryer lid open",__FILE__,MotorDriverResponse[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID].DriverType,DRIER_LID_OPEN,RpMessage,GPI_LS_DRYER_LID_OPEN,0);
                     MotorGotoWithCallback(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID, direction, GPI_LS_DRYER_LID_OPEN, MotorHomingRequestCallback,4000);
-                    return OK;
+                    status = OK;
                 }
                 else
                 {
@@ -116,7 +154,7 @@ uint32_t MotorHomingRequestFunc(MessageContainer* requestContainer)
 
                         //MotorMoveWithCallback(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, (1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize),
                         //                                numberOfSteps, MotorHomingRequestCallback,1000);
-                        return OK;
+                        status = OK;
                     }
                     if ( Motor_Id_to_LS_IdDown[MotorId] != MAX_GPI)
                     {
@@ -131,7 +169,7 @@ uint32_t MotorHomingRequestFunc(MessageContainer* requestContainer)
                             MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_LLOADING, 70);
                         }
                         MotorMovetoLimitSwitch (MotorId,1-MotorsCfg[MotorId].directionthreadwize, speed,  Motor_Id_to_LS_IdUp[MotorId], MotorHomingRequestCallback,30000);
-                        return OK;
+                        status = OK;
                     }
 
                 }
@@ -150,7 +188,7 @@ uint32_t MotorHomingRequestFunc(MessageContainer* requestContainer)
                     }
                     Report("MotorHomingRequestFunc Dryer lid close",__FILE__,MotorDriverResponse[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID].DriverType,DRIER_LID_CLOSE,RpMessage,GPI_LS_DRYER_LID_CLOSED,0);
                     MotorGotoWithCallback(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID, direction, GPI_LS_DRYER_LID_CLOSED, MotorHomingRequestCallback,4000);
-                    return OK;
+                    status = OK;
                 }
                 else
                 {
@@ -167,7 +205,7 @@ uint32_t MotorHomingRequestFunc(MessageContainer* requestContainer)
 
                         MotorMoveWithCallback (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize,
                                                numberOfSteps,    MotorHomingRequestCallback, 100000);
-                        return OK;
+                        status = OK;
                     }
                     if ( Motor_Id_to_LS_IdUp[MotorId] != MAX_GPI)
                     {
@@ -182,22 +220,31 @@ uint32_t MotorHomingRequestFunc(MessageContainer* requestContainer)
                             MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_LLOADING, 70);
                         }
                         MotorMovetoLimitSwitch (MotorId,MotorsCfg[MotorId].directionthreadwize, speed,  Motor_Id_to_LS_IdDown[MotorId], MotorHomingRequestCallback,30000);
-                        return OK;
+                        status = OK;
                     }
                 }
             }
         }
     }
-    responseContainer.has_error = true;
-    responseContainer.error = ERROR_CODE__INVALID_PROCESS_ID;
-    responseContainer.errormessage = "Job Active or incorrect motor ID";
-    responseContainer = createContainer(MESSAGE_TYPE__MotorHomingResponse,  requestContainer->token, true, &response, &motor_homing_response__pack, &motor_homing_response__get_packed_size);
-    responseContainer.has_continuous = true;
-    responseContainer.continuous = true;
-    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);
-    SendChars(container_buffer, container_size);
+    if (status == OK)
+    {
+        HomingControlId[MotorId] = AddControlCallback(NULL, MotorHomingProgressReport,  2*eOneSecond, TemplateDataReadCBFunction,MotorId, 0, 0 );
+        HomingCounter[MotorId] = 0;
+        Report("MotorHomingProgressReport started",__FILE__,__LINE__,MotorId,RpMessage,HomingControlId[MotorId],0);
+    }
+    else
+    {
+        responseContainer.has_error = true;
+        responseContainer.error = ERROR_CODE__INVALID_PROCESS_ID;
+        responseContainer.errormessage = "Job Active or incorrect motor ID";
+        responseContainer = createContainer(MESSAGE_TYPE__MotorHomingResponse,  requestContainer->token, true, &response, &motor_homing_response__pack, &motor_homing_response__get_packed_size);
+        responseContainer.has_continuous = true;
+        responseContainer.continuous = true;
+        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);
+        SendChars(container_buffer, container_size);
+    }
 
 return OK;
 }
@@ -212,6 +259,7 @@ uint32_t MotorAbortHomingRequestFunc(MessageContainer* requestContainer)
 
     TimerMotors_t MotorId = (TimerMotors_t)request->motortype;
     MotorAbortMovetoLimitSwitch(MotorId);
+    MotorHomingRequestCallback(MotorId,0);
 
     responseContainer = createContainer(MESSAGE_TYPE__MotorAbortHomingResponse,  requestContainer->token, false, &response, &motor_abort_homing_response__pack, &motor_abort_homing_response__get_packed_size);
     responseContainer.continuous = false;
@@ -226,18 +274,48 @@ return OK;
 /********************************************************************************
  * Dispenser Homing
  ********************************************************************************/
+uint32_t DispenserHomingProgressReport(uint32_t deviceID, uint32_t ReadValue)
+{
+    MessageContainer responseContainer;
+    DispenserHomingResponse response = DISPENSER_HOMING_RESPONSE__INIT;
+
+    bool last = false;
+    response.has_progress = true;
+    response.has_maxprogress = true;
+    response.maxprogress = 5800000;
+    response.progress = IDS_Dispenser_Data[deviceID].consumedinnanolitter;
+    uint8_t MotorId = deviceID+HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1;
+
+    responseContainer = createContainer(MESSAGE_TYPE__DispenserHomingResponse, HomingToken[MotorId], last, &response, &dispenser_homing_response__pack, &dispenser_homing_response__get_packed_size);
+    Report("DispenserHomingProgressReport",__FILE__,__LINE__,deviceID,RpMessage,IDS_Dispenser_Data[deviceID].consumedinnanolitter,0);
+    responseContainer.has_continuous = true;
+    responseContainer.continuous = true;
+    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);
+    SendChars(container_buffer, container_size);
+
+    return OK;
+
+}
 uint32_t DispenserHomingRequestCallback(uint32_t deviceID, uint32_t ReadValue)
 {
     MessageContainer responseContainer;
-    MotorHomingResponse response = MOTOR_HOMING_RESPONSE__INIT;
+    DispenserHomingResponse response = DISPENSER_HOMING_RESPONSE__INIT;
 
     uint8_t MotorId = deviceID+HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1;
+    if (HomingControlId[MotorId] != 0xff)
+    {
+        RemoveControlCallback(HomingControlId[MotorId],DispenserHomingProgressReport);
+        HomingControlId[MotorId] = 0xff;
+        Report("DispenserHomingProgressReport stopped",__FILE__,__LINE__,deviceID,RpMessage,HomingControlId[MotorId],0);
+    }
 
     //close dry air valve in the dispenser
     //Valve_Set((Valves_t) (DispenserId+VALVE_2W_MID_AIR_8), Atm_MidTank_OFF);
     //MotorSetMicroStep(deviceID, MotorsCfg[deviceID].microstep);
 
-    responseContainer = createContainer(MESSAGE_TYPE__DispenserHomingResponse, HomingToken[MotorId], true, &response, &motor_homing_response__pack, &motor_homing_response__get_packed_size);
+    responseContainer = createContainer(MESSAGE_TYPE__DispenserHomingResponse, HomingToken[MotorId], true, &response, &dispenser_homing_response__pack, &dispenser_homing_response__get_packed_size);
     responseContainer.has_continuous = true;
     responseContainer.continuous = true;
     uint8_t* container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
@@ -252,6 +330,8 @@ return OK;
 uint32_t DispenserHomingRequestFunc(MessageContainer* requestContainer)
 {
 
+    uint32_t status = OK;
+
     MessageContainer responseContainer;
 
     DispenserHomingRequest* request = dispenser_homing_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
@@ -262,27 +342,37 @@ uint32_t DispenserHomingRequestFunc(MessageContainer* requestContainer)
 
     ustrncpy (HomingToken[MotorId], requestContainer->token,36);
     int speed = request->speed;
-    if (speed == 0) speed = 150;
+    if (speed == 0) speed = 500;
 
     responseContainer = createContainer(MESSAGE_TYPE__DispenserHomingResponse,  requestContainer->token, false, &response, &dispenser_homing_response__pack, &dispenser_homing_response__get_packed_size);
     responseContainer.has_continuous = true;
     responseContainer.continuous = true;
-    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);
-    //USBCDCD_sendData(container_buffer, container_size,10);
-    SendChars(container_buffer, container_size);
     if (MotorId <= NUM_OF_MOTORS)
     {
         //if ((JobIsActive() == false)&&(isMotorConfigured(MotorId) == true))
         if (isMotorConfigured(MotorId) == true)
         {
             if (request->direction == MOTOR_DIRECTION__Backward) //dispenser homing
-                IDS_HomeDispenser(request->index,speed,DispenserHomingRequestCallback);
+                status = IDS_HomeDispenser(request->index,speed,DispenserHomingRequestCallback);
             else //empty dispenser -
-                IDS_EmptyDispenser(request->index,speed,DispenserHomingRequestCallback);//return ERROR;
+                status = IDS_EmptyDispenser(request->index,speed,DispenserHomingRequestCallback);//return ERROR;
+            if (status == OK)
+            {
+                HomingControlId[MotorId] = AddControlCallback(NULL, DispenserHomingProgressReport,  2*eOneSecond, TemplateDataReadCBFunction,request->index, 0, 0 );
+                Report("DispenserHomingProgressReport started",__FILE__,__LINE__,request->index,RpMessage,HomingControlId[MotorId],0);
+            }
+        }
+        else
+        {
+            responseContainer.error = ERROR_CODE__GENERAL_ERROR;
+            responseContainer.errormessage = "Invalid Id or dispenser not configured";
         }
     }
+    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);
+    //USBCDCD_sendData(container_buffer, container_size,10);
+    SendChars(container_buffer, container_size);
 
 return OK;
 }
@@ -296,7 +386,15 @@ uint32_t DispenserAbortHomingRequestFunc(MessageContainer* requestContainer)
     DispenserAbortHomingResponse response = DISPENSER_ABORT_HOMING_RESPONSE__INIT;
 
     IDS_StopHomeDispenser(request->index);
-/*
+
+    TimerMotors_t MotorId = (request->index)+HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1;
+    if (HomingControlId[MotorId] != 0xff)
+    {
+        RemoveControlCallback(HomingControlId[MotorId],DispenserHomingProgressReport);
+        HomingControlId[MotorId] = 0xff;
+        Report("DispenserHomingProgressReport stopped",__FILE__,__LINE__,request->index,RpMessage,HomingControlId[MotorId],0);
+    }
+    /*
     TimerMotors_t MotorId = (request->index)+HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1;
     MotorAbortMovetoLimitSwitch(MotorId);
     //close dry air valve in the dispenser
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
index 1fe5968e6..2ffce8e46 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
@@ -284,13 +284,13 @@ uint32_t IDS_HomeDispenser (uint32_t DispenserId, uint32_t speed , callback_fptr
         {
             MotorMovetoLimitSwitch (MotorId,1-MotorsCfg[MotorId].directionthreadwize, speed/4,  Dispenser_Id_to_LS_Id[DispenserId], IDS_HomeDispenserCallback,0);
             CurrentDispenserSpeed[DispenserId] = speed/4;
-            Report("IDS_HomeDispenser ",__FILE__,(int)midTankContent*1000,(int)DispenserId,RpWarning,speed/4,0);
+            Report("IDS_HomeDispenser ",__FILE__,(int)(midTankContent*1000),(int)DispenserId,RpWarning,speed/4,0);
         }
         else
         {
             MotorMovetoLimitSwitch (MotorId,1-MotorsCfg[MotorId].directionthreadwize, speed,  Dispenser_Id_to_LS_Id[DispenserId], IDS_HomeDispenserCallback,0);
             CurrentDispenserSpeed[DispenserId] = speed;
-            Report("IDS_HomeDispenser ",__FILE__,(int)midTankContent*1000,(int)DispenserId,RpWarning,speed,0);
+            Report("IDS_HomeDispenser ",__FILE__,(int)(midTankContent*1000),(int)DispenserId,RpWarning,speed,0);
         }
         CurrentDispenserSpeed[DispenserId] = (-1*CurrentDispenserSpeed[DispenserId]);
         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 5be960d0f..5ca59a434 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
@@ -1383,6 +1383,7 @@ uint32_t IDSPreSegmentState(void *SegmentDetails, int SegmentId)
 uint32_t SegmentNumOfBrushStops = 0;
 double BrushStopTime = 0;
 uint32_t BrushStopCounter = 0;
+uint32_t BrushStopStartTime = 0,BrushStopLength = 0;
 
 void IDS_StartBrushStop(int n_dispensers,  JobDispenser** Dispensers)
 {
@@ -1472,11 +1473,17 @@ uint32_t IDSBrushStopRestartCallback(uint32_t IfIndex, uint32_t readValue)
     int n_dispensers = 0;
     JobSegment* Segment = (void *)IfIndex;
     Task_Stat statbuf;
+    if(BrushStopStartTime+BrushStopLength+100 < msec_millisecondCounter   )
+    {
+        Report("!!!!!!!!!!!!Overtime!",__FILE__,msec_millisecondCounter,(int)BrushStopStartTime,RpWarning,(int)BrushStopLength,0);
+    }
+
     if(BrushStopCounter++ <  BrushStopTime)
     {
         return OK;
     }
     BrushStopCounter = 0;
+    BrushStopStartTime = msec_millisecondCounter;
 
 
     if (JobEndSequence == true)
@@ -1553,7 +1560,7 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId)
      BrushStopTime = Segment->length*1000/(double)SegmentNumOfBrushStops;  //brushstop in meters //brushstop in millisecond
      BrushStopTime = ((BrushStopTime*100)/dyeingspeed);//brushstop in seconds
      //BrushStopTime *= 1000;
-     Report("IDSSegmentState",__FILE__,__LINE__,(int)(BrushStopTime*1000),RpWarning,(int)SegmentNumOfBrushStops,0);
+     Report("IDSSegmentState bss time, num of bss",__FILE__,__LINE__,(int)(BrushStopTime),RpWarning,(int)SegmentNumOfBrushStops,0);
      if (uploadstrategy == JOB_UPLOAD_STRATEGY__Default)
      {
          Dispensers = Segment->brushstops[JobBrushStopId]->dispensers;
@@ -1584,8 +1591,10 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId)
     JobBrushStopId++;
     if ((BrushStopTime)&&(SegmentNumOfBrushStops > 1))
     {
-        BrushStopCounter = BrushStopTime+10; //move the IDS brush stop handling to highest priority in timing
+        BrushStopCounter = BrushStopTime+3; //move the IDS brush stop handling to highest priority in timing
         BrushStopControlId = AddControlCallback(NULL, IDSBrushStopRestartCallback, eOneMillisecond,TemplateDataReadCBFunction ,SegmentDetails, 0, 0 );
+        BrushStopStartTime = msec_millisecondCounter;
+        BrushStopLength = BrushStopTime;
         if (BrushStopControlId == 0xFF)
         {
             Report("Add control callback failed",__FILE__,__LINE__,(int)BrushStopTime,RpWarning,(int)0,0);
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
index be91c17e6..869aac2c1 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
@@ -169,6 +169,7 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
                     //stubManager.Run<ProgressResponse>("ProgressRequest" ,0x3EA, /*DisplayView =*/0x0000); //
                     SetLeftDisplayView (HeadAVERAGE);
                     SetWriteDisplayView(DrierAVERAGE);
+                    SetDisplayView (AVERAGE);
                     break;
                 case 1:
                     //stubManager.Run<ProgressResponse>("ProgressRequest" ,0x3EA, /*DisplayView =*/0x1000); //
@@ -184,6 +185,7 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
                     //stubManager.Run<ProgressResponse>("ProgressRequest" ,0x3EA, /*DisplayView =*/0x3000); //
                     SetLeftDisplayView (HeadCURRENT);
                     SetWriteDisplayView(DrierCURRENT);
+                    SetDisplayView (CURRENT);
                     break;
                 }
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
index 3b97e9eb7..9698f1ea3 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
@@ -59,7 +59,7 @@ uint32_t ScrewControlId = 0xFF;
 
 static bool KeepWindingCone = false;
 static uint32_t WindingConeLocation;
-static uint32_t WinderBackToBaseTime = 800;
+static uint32_t WinderBackToBaseTime = 1500;
 
 float NumberOfRotationPerPassage = 0.0;
 InternalWinderConfigStruc InternalWinderCfg = {0};
@@ -580,7 +580,8 @@ uint32_t Winder_End(void)
     ScrewsStopControlTimer();
     //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);
+    //MotorStop(HARDWARE_MOTOR_TYPE__MOTO_SCREW,Hard_Hiz);
+    MotorAbortMovetoLimitSwitch(HARDWARE_MOTOR_TYPE__MOTO_SCREW); //bug #2709
     return OK;
 }
 void Winder_ScrewHomeLimitSwitchInterrupt(void)