fix first dispenser not moving bug

7 files changed, 88 insertions, 70 deletions

diff --git a/Software/Embedded_SW/Embedded/Communication/Container.c b/Software/Embedded_SW/Embedded/Communication/Container.c
index b0c063a5e..70f910efb 100644
--- a/Software/Embedded_SW/Embedded/Communication/Container.c
+++ b/Software/Embedded_SW/Embedded/Communication/Container.c
@@ -132,14 +132,15 @@ void receive_callback(char* buffer, size_t length)
          return;
    //  HeatingTestSendResonse(0, false,true,true, /*OriginalMotorSpd_2PPS[index]*/length,requestContainer->type,0,0, "Container");
     if (requestContainer->type != MESSAGE_TYPE__KeepAliveRequest) //user action resets the idle counter
+    {
         resetIdleCounter();
-
+        REPORT_MSG(requestContainer->type,"Message received");
+    }
      msgId[index] = requestContainer->type;
      Length[index] = length;
      DataLength[index] = requestContainer->data.len;
      if (index++>=MAX_CONT_LOG)
          index = 0;
-     //REPORT_MSG(requestContainer->type,"Message received");
      switch(requestContainer->type)
      {
          case MESSAGE_TYPE__CalculateRequest:
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h b/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h
index 80a55d63e..3d2bcf9ff 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h
@@ -5,7 +5,7 @@
 #include "drivers/motors/motor.h"
 #include "ids_ex.h"
 
-extern uint32_t CurrentDispenserSpeed[MAX_SYSTEM_DISPENSERS];
+extern int32_t CurrentDispenserSpeed[MAX_SYSTEM_DISPENSERS];
 extern uint32_t DispenserIdToMotorId[MAX_SYSTEM_DISPENSERS];
 extern float DispenserPressure[MAX_SYSTEM_DISPENSERS];
 uint32_t DispenserConfigMessage(HardwareDispenser * request);
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
index b33b531a3..868ddca9c 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
@@ -33,7 +33,8 @@ double   DispenserPreparePressure = DISPENSER_BUILD_PRESSURE_LIMIT;
 uint32_t DispenserPrepareTimeout = DISPENSER_BUILD_PRESSURE_TIMEOUT;
 uint32_t DispenserPrepareTimeLag = DISPENSER_BUILD_PRESSURE_LAG;
 uint32_t DispenserPrepareTime[MAX_SYSTEM_DISPENSERS] = {0,0,0,0,0,0,0,0};
-uint32_t CurrentDispenserSpeed[MAX_SYSTEM_DISPENSERS] = {0, 0, 0, 0, 0, 0, 0, 0,};
+
+int32_t CurrentDispenserSpeed[MAX_SYSTEM_DISPENSERS] = {0, 0, 0, 0, 0, 0, 0, 0,};
 
 callback_fptr DispenserCallback[MAX_SYSTEM_DISPENSERS] = {0, 0, 0, 0, 0, 0, 0, 0,};
 uint32_t DispenserControlId[MAX_SYSTEM_DISPENSERS] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
@@ -55,7 +56,7 @@ void IDS_Dispenser_SetTimeOutValues(uint32_t CloseTimeout, uint32_t OpenTimeout)
 }
 
 //********************************************************************************************************************
-uint32_t IdsGetMotorSpeed(uint32_t DispenserId)
+int32_t IdsGetMotorSpeed(uint32_t DispenserId)
 {
     return  CurrentDispenserSpeed[DispenserId];
 }
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h
index 9b2442698..350e553b6 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h
@@ -75,6 +75,6 @@ uint32_t IDS_MapDispenserUsedinFileJob(void *JobDetails);
 
 float CalculateDispenserPressure (int DispenserId);
 float GetDispenserPressure(int DispenserId);
-uint32_t IdsGetMotorSpeed(uint32_t DispenserId);
+int32_t IdsGetMotorSpeed(uint32_t DispenserId);
 
 #endif /* MODULES_IDS_IDS_EX_H_ */
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
index 1bdf15b29..215fab544 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
@@ -78,13 +78,14 @@ void IDS_Dispenser_SetBackLashValues(double   initialdispenserpressure,   uint32
 
     Report("IDS_Dispenser_SetBackLashValues ",__FILE__,InitialDispenserPressure,InitialDispenserTimeout,RpWarning,(int)InitialDispenserTimeLag,0);
 }
-uint32_t IDS_HomeDispenserBackMoveCallback(uint32_t deviceID, uint32_t ReadValue)
+uint32_t IDS_HomeDispenserBackMoveCallback(uint32_t motorId, uint32_t ReadValue)
 {
-    uint8_t DispenserId = deviceID-HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1;
+    uint8_t DispenserId = motorId-HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1;
     if ((GetDispenserPressure(DispenserId)>=InitialDispenserPressure)||(DispenserHomingTime[DispenserId]>InitialDispenserTimeout))
     {
-        MotorStop(deviceID,Hard_Hiz);
-        MotorSetMicroStep(deviceID, MotorsCfg[deviceID].microstep);
+        MotorStop(motorId,Hard_Hiz);
+        CurrentDispenserSpeed[DispenserId] = 0;
+        MotorSetMicroStep(motorId, MotorsCfg[motorId].microstep);
         HomingActive[DispenserId]= false;
         Report("End backlash",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,(int)DispenserHomingTime[DispenserId],0);
         if (SafeRemoveControlCallback(DispenserHomingControlId[DispenserId], IDS_HomeDispenserBackMoveCallback )==OK)
@@ -99,15 +100,15 @@ uint32_t IDS_HomeDispenserBackMoveCallback(uint32_t deviceID, uint32_t ReadValue
     }
     return OK;
 }
-uint32_t IDS_HomeDispenserCallback(uint32_t deviceID, uint32_t ReadValue)
+uint32_t IDS_HomeDispenserCallback(uint32_t motorId, uint32_t ReadValue)
 {
-    uint8_t DispenserId = deviceID-HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1;
+    uint8_t DispenserId = motorId-HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1;
 
     Read_MidTank_Pressure_Sensor(DispenserId);
     //close dry air valve in the dispenser
     Valve_Set(IDS_Id_to_AirValve[DispenserId], Atm_MidTank_OFF);
     Disable_MidTank_Pressure_Reading(DispenserId);
-    //MotorSetMicroStep(deviceID, MotorsCfg[deviceID].microstep);
+    //MotorSetMicroStep(motorId, MotorsCfg[motorId].microstep);
     if (HomingRequestCallback[DispenserId])
     {
         HomingRequestCallback[DispenserId](DispenserId,0);
@@ -115,11 +116,12 @@ uint32_t IDS_HomeDispenserCallback(uint32_t deviceID, uint32_t ReadValue)
     }
 //    HomingActive[DispenserId]= false;
     Report("Start backlash",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,(int)DispenserHomingTime[DispenserId],0);
-    DispenserHomingControlId[DispenserId] = AddControlCallback( IDS_HomeDispenserBackMoveCallback, InitialDispenserTimeLag, GetDispenserPressure,deviceID, deviceID, 0 );
+    DispenserHomingControlId[DispenserId] = AddControlCallback( IDS_HomeDispenserBackMoveCallback, InitialDispenserTimeLag, GetDispenserPressure,motorId, motorId, 0 );
 
-    MotorSetDirection(deviceID,MotorsCfg[deviceID].directionthreadwize);
+    MotorSetDirection(motorId,MotorsCfg[motorId].directionthreadwize);
 
-    MotorSetSpeed(deviceID, 1000);
+    MotorSetSpeed(motorId, 1000);
+    CurrentDispenserSpeed[DispenserId] = 1000;
     IDS_Dispenser_RefillEnded ( DispenserId);
 
 
@@ -127,74 +129,84 @@ return OK;
 
 }
 
-uint32_t IDS_HomeDispenser (uint32_t deviceID, uint32_t speed , callback_fptr callback)
+uint32_t IDS_HomeDispenser (uint32_t DispenserId, uint32_t speed , callback_fptr callback)
 {
-    assert(deviceID < MAX_SYSTEM_DISPENSERS);
+    assert(DispenserId < MAX_SYSTEM_DISPENSERS);
 
-    //if (DispensersAlarmState[deviceID] == true)
+    //if (DispensersAlarmState[DispenserId] == true)
     //    return ERROR;
 
-    if (HomingActive[deviceID] == true)
+    if (HomingActive[DispenserId] == true)
+    {
+        LOG_ERROR (DispenserId,"Homing already active");
         return ERROR;
+    }
     else
-        HomingActive[deviceID] = true;
+        HomingActive[DispenserId] = true;
 
-    HomingRequestCallback[deviceID] = callback;
+    HomingRequestCallback[DispenserId] = callback;
 
-    TimerMotors_t MotorId = HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1 + deviceID;
-    if ( Dispenser_Id_to_LS_Id[deviceID] != MAX_GPI)
+    TimerMotors_t MotorId = HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1 + DispenserId;
+    if ( Dispenser_Id_to_LS_Id[DispenserId] != MAX_GPI)
     {
         //open dispenser valve dispenser to midtank direction
-        Control3WayValvesWithCallback ((Valves_t)deviceID, MidTank_Dispenser, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
+        Control3WayValvesWithCallback ((Valves_t)DispenserId, MidTank_Dispenser, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
         //Valve_Set((Valves_t) request->index, MidTank_Dispenser);
         MotorSetMicroStep(MotorId, 1);
         SysCtlDelay(180000);
         //open dry air valve in the dispenser
-        Valve_Set(IDS_Id_to_AirValve[deviceID], Atm_MidTank_ON);
+        Valve_Set(IDS_Id_to_AirValve[DispenserId], Atm_MidTank_ON);
 
-        IDS_Dispenser_RefillStarted(deviceID);
-        MotorMovetoLimitSwitch (MotorId,1-MotorsCfg[MotorId].directionthreadwize, speed,  Dispenser_Id_to_LS_Id[deviceID], IDS_HomeDispenserCallback,0);
+        IDS_Dispenser_RefillStarted(DispenserId);
+        MotorMovetoLimitSwitch (MotorId,1-MotorsCfg[MotorId].directionthreadwize, speed,  Dispenser_Id_to_LS_Id[DispenserId], IDS_HomeDispenserCallback,0);
+        CurrentDispenserSpeed[DispenserId] = (-1*speed);
         return OK;
     }
     return ERROR;
 }
-uint32_t IDS_Dispenser_Alarm_On (uint8_t deviceID)
+uint32_t IDS_Dispenser_Alarm_On (uint8_t DispenserId)
 {
     uint32_t status = OK;
-    DispensersAlarmState[deviceID] = true;
-    TimerMotors_t MotorId = HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1 + deviceID;
+    DispensersAlarmState[DispenserId] = true;
+    TimerMotors_t MotorId = HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1 + DispenserId;
     status |= MotorAbortMovetoLimitSwitch(MotorId);
-    Valve_Set(IDS_Id_to_AirValve[deviceID], Atm_MidTank_OFF);
-    Enable_MidTank_Pressure_Reading(deviceID);
-    status |= MotorSetMicroStep(deviceID, MotorsCfg[deviceID].microstep);
-    status |= MotorStop(deviceID, Hard_Hiz);
+    Valve_Set(IDS_Id_to_AirValve[DispenserId], Atm_MidTank_OFF);
+    Enable_MidTank_Pressure_Reading(DispenserId);
+    status |= MotorSetMicroStep(DispenserId, MotorsCfg[DispenserId].microstep);
+    status |= MotorStop(DispenserId, Hard_Hiz);
+    CurrentDispenserSpeed[DispenserId] = 0;
     JobEndReason = JOB_OUT_OF_DYE;
     return status;
 }
-uint32_t IDS_Dispenser_Alarm_Off (uint8_t deviceID)
+uint32_t IDS_Dispenser_Alarm_Off (uint8_t DispenserId)
 {
     uint32_t status = OK;
-    DispensersAlarmState[deviceID] = false;
+    DispensersAlarmState[DispenserId] = false;
     return status;
 }
 
-uint32_t IDS_StopHomeDispenser (uint32_t deviceID)
+uint32_t IDS_StopHomeDispenser (uint32_t DispenserId)
 {
-    assert(deviceID < MAX_SYSTEM_DISPENSERS);
+    assert(DispenserId < MAX_SYSTEM_DISPENSERS);
 
-    if (HomingActive[deviceID] != true)
+    Report("IDS_StopHomeDispenser",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,(int)HomingActive[DispenserId],0);
+    if (HomingActive[DispenserId] != true)
+    {
+        LOG_ERROR (DispenserId,"Homing not active");
         return ERROR;
+    }
     else
-        HomingActive[deviceID] = false;
+        HomingActive[DispenserId] = false;
 
-    TimerMotors_t MotorId = (deviceID)+HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1;
+    TimerMotors_t MotorId = (DispenserId)+HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1;
     MotorAbortMovetoLimitSwitch(MotorId);
     //close dry air valve in the dispenser
-    Disable_MidTank_Pressure_Reading(deviceID);
-    Valve_Set(IDS_Id_to_AirValve[deviceID], Atm_MidTank_OFF);
-    Control3WayValvesWithCallback ((Valves_t)deviceID, MidTank_Dispenser, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
+    Disable_MidTank_Pressure_Reading(DispenserId);
+    Valve_Set(IDS_Id_to_AirValve[DispenserId], Atm_MidTank_OFF);
+    Control3WayValvesWithCallback ((Valves_t)DispenserId, MidTank_Dispenser, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
 
     MotorSetMicroStep(MotorId, MotorsCfg[MotorId].microstep);
+    CurrentDispenserSpeed[DispenserId] = 0;
     return OK;
 }
 
@@ -215,34 +227,35 @@ uint32_t IDS_CheckDispenserLimitSwitch (LimitSwitchAlarms LS_Id)
         return FPGA_Read_limit_Switches(Dispenser_Id_to_Alarm_LS_Id[LS_Id]);
 }
 
-uint32_t IDS_EmptyDispenser (uint32_t deviceID, uint32_t speed , callback_fptr callback)
+uint32_t IDS_EmptyDispenser (uint32_t DispenserId, uint32_t speed , callback_fptr callback)
 {
-    assert(deviceID < MAX_SYSTEM_DISPENSERS);
+    assert(DispenserId < MAX_SYSTEM_DISPENSERS);
 
-    //if (DispensersAlarmState[deviceID] == true)
+    //if (DispensersAlarmState[DispenserId] == true)
     //    return ERROR;
 
-    if (HomingActive[deviceID] == true)
+    if (HomingActive[DispenserId] == true)
         return ERROR;
     else
-        HomingActive[deviceID] = true;
-    HomingRequestCallback[deviceID] = callback;
+        HomingActive[DispenserId] = true;
+    HomingRequestCallback[DispenserId] = callback;
 
-    TimerMotors_t MotorId = HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1 + deviceID;
-    if ( Dispenser_Id_to_LS_Empty_Id[deviceID] != MAX_GPI)
+    TimerMotors_t MotorId = HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1 + DispenserId;
+    if ( Dispenser_Id_to_LS_Empty_Id[DispenserId] != MAX_GPI)
     {
         //open dispenser valve dispenser to midtank direction
-        Control3WayValvesWithCallback ((Valves_t)deviceID, Dispenser_Mixer, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
+        Control3WayValvesWithCallback ((Valves_t)DispenserId, Dispenser_Mixer, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
         //Valve_Set((Valves_t) request->index, Dispenser_Mixer);
         MotorSetMicroStep(MotorId, 1);
         SysCtlDelay(180000);
         //open dry air valve in the dispenser
-        //Valve_Set(IDS_Id_to_AirValve[deviceID], Atm_MidTank_ON);
-        IDS_Dispenser_RefillStarted(deviceID);
-        IDS_Dispenser_MovingDirection(deviceID,UP);
+        //Valve_Set(IDS_Id_to_AirValve[DispenserId], Atm_MidTank_ON);
+        IDS_Dispenser_RefillStarted(DispenserId);
+        IDS_Dispenser_MovingDirection(DispenserId,UP);
 
 
-        MotorMovetoLimitSwitch (MotorId,MotorsCfg[MotorId].directionthreadwize, speed,  Dispenser_Id_to_LS_Empty_Id[deviceID], IDS_HomeDispenserCallback,0);
+        MotorMovetoLimitSwitch (MotorId,MotorsCfg[MotorId].directionthreadwize, speed,  Dispenser_Id_to_LS_Empty_Id[DispenserId], IDS_HomeDispenserCallback,0);
+        CurrentDispenserSpeed[DispenserId] = speed;
         return OK;
     }
     return ERROR;
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
index 2a8cac415..9d3a85ad0 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
@@ -781,10 +781,13 @@ uint32_t IDSPreSegmentState(void *SegmentDetails, int SegmentId)
             {
                 MotorSetMicroStep(HW_Motor_Id, MotorsCfg[HW_Motor_Id].microstep);
             }
-            MotorStop(HW_Motor_Id,Hard_Hiz); //26/03/19 test  without valves
-            CurrentDispenserSpeed[DispenserId] = 0;
+            if ((EnableIntersegment == true)&&(IntersegmentLength>0))
+            {
+                MotorStop(HW_Motor_Id,Hard_Hiz); //26/03/19 test  without valves
+                CurrentDispenserSpeed[DispenserId] = 0;
+                REPORT_MSG(DispenserId,"Dispenser stopped pre Segment");
+            }
             IDS_Valve_PresegmentReady(DispenserId,0); //27/03/19 to be removed when the presegment handler will be added
-            //REPORT_MSG(DispenserId,"Dispenser stopped pre Segment");
         }
     }
 
@@ -1012,7 +1015,7 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId)
      //TimerMotors_t  HW_Motor_Id = DispenserIdToMotorId[deviceID];
      //REPORT_MSG(deviceID,"Dispenser End called");
      //MotorStop(HW_Motor_Id,Hard_Hiz);
-     IDS_HomeDispenser (deviceID, 1000 , NULL);
+     IDS_HomeDispenser (deviceID, 800 , NULL);
 
      return OK;
  }
diff --git a/Software/Stubs Collection/stubs/embeddedparametersbuild.cs b/Software/Stubs Collection/stubs/embeddedparametersbuild.cs
index f23dd380f..3ad7c1da8 100644
--- a/Software/Stubs Collection/stubs/embeddedparametersbuild.cs
+++ b/Software/Stubs Collection/stubs/embeddedparametersbuild.cs
@@ -33,8 +33,8 @@ configurationParameters.CloseValveTimeout = 252;
 configurationParameters.OpenValveTimeout = 252;
 
 //backlash after filling - 
-configurationParameters.InitialDispenserPressure = 0.5; 
-configurationParameters.InitialDispenserTimeout = 20000; //20 seconds
+configurationParameters.InitialDispenserPressure = 1.5; 
+configurationParameters.InitialDispenserTimeout = 60000; //20 seconds
 configurationParameters.InitialDispenserTimeLag = 100;
 
 //job prepare - build pressure in dispensers
@@ -50,24 +50,24 @@ configurationParameters.ACHeatersUpperOperationLimit = 1005;
 configurationParameters.DCHeatersLowerOperationLimit = 978;
 configurationParameters.DCHeatersUpperOperationLimit = 1005;
 
-configurationParameters.MidTankPressureCorrection = 0.5;
+configurationParameters.MidTankPressureCorrection = 0.2;
  
-File.WriteAllBytes("C:/temp/EmbParam.msg",configurationParameters.ToBytes());
+File.WriteAllBytes("C:/temp/EmbParam.cfg",configurationParameters.ToBytes());
 
-byte[] fileBytes = File.ReadAllBytes("C:/temp/EmbParam.msg");
+byte[] fileBytes = File.ReadAllBytes("C:/temp/EmbParam.cfg");
 
 DeleteRequest deleteRequest = new DeleteRequest();
-deleteRequest.Path = "0://SysInfo//EmbParam.msg";
+deleteRequest.Path = "0://SysInfo//EmbParam.cfg";
 	var response5 = stubManager.Run<DeleteResponse>(deleteRequest);
 
 FileUploadRequest fileUploadRequest = new FileUploadRequest();
-fileUploadRequest.Path = "0://SysInfo//EmbParam.msg";
+fileUploadRequest.Path = "0://SysInfo//EmbParam.cfg";
 fileUploadRequest.Length = (int)fileBytes.Length;
 FileUploadResponse response2 = stubManager.Run<FileUploadResponse>(fileUploadRequest);
 
 long chunk_size = response2.MaxChunkLength;
 
-FileStream fs = new FileStream("C:/temp/EmbParam.msg",FileMode.Open);
+FileStream fs = new FileStream("C:/temp/EmbParam.cfg",FileMode.Open);
 
 while (fs.Position < fs.Length)
 {