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

10 files changed, 60 insertions, 37 deletions

diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
index cf8684ddb..518100ae0 100644
--- a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
+++ b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
@@ -265,7 +265,8 @@ const AlarmHandlingItemStruc  AlarmItem[MAX_SYSTEM_ALARMS]={
  {eOneSecond,DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__WINDER_CONE_DOES_NOT_EXIST,"No cone in winder"}
 };
 
-char TestMessage[5]="Test";
+char AlarmStorePath[50] = "0://SWInfo//AlarmPrm.msg";
+
 bool DispenserInUse[MAX_SYSTEM_DISPENSERS] = {false,false,false,false,false,false,false,false};
 bool EventsNotificationRequestAccepted = false;
 //read dispensers limit switches. 25 - send warning. up - stop job and send alarm
@@ -576,10 +577,6 @@ void AlarmHandlingSetAlarm(uint32_t AlarmId, bool value)
         }
     }
 }
-uint32_t AlarmHandlingEmptyCBFunction(uint32_t IfIndex, uint32_t ReadValue)
-{
-    return OK;
-}
 
 uint32_t AlarmHandlingStart(void)
 {
@@ -590,7 +587,7 @@ uint32_t AlarmHandlingStart(void)
     if ( AlarmHandlingActive == false)
     {
             AlarmHandlingActive = true;
-            AlarmHandlingControlId = AddControlCallback(AlarmHandling_ControlTrigger,eTenMillisecond,AlarmHandlingEmptyCBFunction,0,0,0);
+            AlarmHandlingControlId = AddControlCallback(AlarmHandling_ControlTrigger,eTenMillisecond,TemplateDataReadCBFunction,0,0,0);
     }
     return OK;
 }
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c
index ae362d189..42bf19b96 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c
@@ -101,6 +101,10 @@ uint32_t SetDigitalOutRequestRequestFunc(MessageContainer* requestContainer)
         case INTERFACE_IOS__Midtank7Air:
         case INTERFACE_IOS__Midtank8Air:
             portId = (request->interfaceio - INTERFACE_IOS__Midtank1Air) ; //0-7
+            if (request->value == Atm_MidTank_OFF)
+                Disable_MidTank_Pressure_Reading(portId);
+            else
+                Enable_MidTank_Pressure_Reading(portId);
             Valve_Set(IDS_Id_to_AirValve[portId], request->value );   //Atm_MidTank_OFF/ON
             break;
         case INTERFACE_IOS__Midtank1Cartridge:
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
index f93bf8f60..e3cec605d 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
@@ -624,10 +624,6 @@ uint32_t DiagnosticsControlId = 0xff;
 uint32_t Diagnostics10MSControlId = 0xff;
 uint32_t DispensersControlId = 0xff;
 bool DiagnosticRequestAccepted = false;
-uint32_t DiagnosticsEmptyCBFunction(uint32_t IfIndex, uint32_t ReadValue)
-{
-    return OK;
-}
 uint32_t DiagnosticsStart(void)
 {
 
@@ -637,16 +633,16 @@ uint32_t DiagnosticsStart(void)
         {
             DiagnosticsActive = true;
             if (DiagnosticsControlId == 0xFF)
-                DiagnosticsControlId = AddControlCallback(Diagnostics_ControlTrigger,DiagnosticLimit,DiagnosticsEmptyCBFunction,0,0,0);
+                DiagnosticsControlId = AddControlCallback(Diagnostics_ControlTrigger,DiagnosticLimit,TemplateDataReadCBFunction,0,0,0);
             else
                 LOG_ERROR(DiagnosticsControlId,"Diagnostics restarted");
             if (Diagnostics10MSControlId == 0xFF)
-                Diagnostics10MSControlId = AddControlCallback(Diagnostics_TenMiliControlTrigger,DiagnosticFastLimit,DiagnosticsEmptyCBFunction,0,0,0);
+                Diagnostics10MSControlId = AddControlCallback(Diagnostics_TenMiliControlTrigger,DiagnosticFastLimit,TemplateDataReadCBFunction,0,0,0);
             else
                 LOG_ERROR(DiagnosticsControlId,"Diagnostics restarted");
 
             if (DispensersControlId == 0xFF)
-                DispensersControlId = AddControlCallback(DispensersCollection,eOneSecond,DiagnosticsEmptyCBFunction,0,0,0);
+                DispensersControlId = AddControlCallback(DispensersCollection,eOneSecond,TemplateDataReadCBFunction,0,0,0);
             else
                 LOG_ERROR(DispensersControlId,"Diagnostics restarted");
        }
diff --git a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
index 6d64bdf66..789ac459e 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
@@ -34,6 +34,8 @@
 #include "PMR/Hardware/SystemResetResponse.pb-c.h"
 
 #include "drivers/I2C_Communication/DAC/Blower.h"
+#include "drivers/Valves/Valve.h"
+#include "drivers/I2C_Communication/ADC_MUX/ADC_MUX.h"
 
 uint32_t EmbeddedParametersInit(void);
 uint32_t EmbeddedParametersWrite(void * buffer, uint16_t size);
@@ -160,6 +162,20 @@ uint32_t EmbeddedParametersInit(void)
 
     return Fresult;
 }
+uint32_t GenHWControlId;
+
+uint32_t GenHWInitCallBackFunction(uint32_t IfIndex, uint32_t BusyFlag)
+{
+    int   Dispenser_i;
+    RemoveControlCallback(GenHWControlId, GenHWInitCallBackFunction );
+    for (Dispenser_i = 0;Dispenser_i < MAX_SYSTEM_DISPENSERS;Dispenser_i++)
+    {
+        Read_MidTank_Pressure_Sensor(Dispenser_i);
+        Valve_Set(IDS_Id_to_AirValve[Dispenser_i], Atm_MidTank_OFF );   //Atm_MidTank_OFF/ON
+            Disable_MidTank_Pressure_Reading(Dispenser_i);
+    }
+    return OK;
+}
 
 uint32_t HWConfiguration(UploadHardwareConfigurationRequest* UploadRequest)
 {
@@ -252,14 +268,18 @@ uint32_t HWConfiguration(UploadHardwareConfigurationRequest* UploadRequest)
         BlowerCfg.enabled = false;
     }
 
+    for (Dispenser_i = 0;Dispenser_i < MAX_SYSTEM_DISPENSERS;Dispenser_i++)
+    {
+        Enable_MidTank_Pressure_Reading(Dispenser_i);
+        Valve_Set(IDS_Id_to_AirValve[Dispenser_i], Atm_MidTank_ON );   //Atm_MidTank_OFF/ON
+    }
+    GenHWControlId = AddControlCallback( GenHWInitCallBackFunction, 2* eOneSecond/*eHundredMillisecond*/, TemplateDataReadCBFunction,0,0, 0 );
+
     ControlStart();
     AlarmHandlingStart();
     //ThreadInitialTestStub(request);
 
     return OK;
-
-
-
 }
 uint32_t HWConfigurationFunc(MessageContainer* requestContainer)
 {
diff --git a/Software/Embedded_SW/Embedded/Modules/General/process.c b/Software/Embedded_SW/Embedded/Modules/General/process.c
index a918f6574..6eef03bb4 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/process.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/process.c
@@ -145,12 +145,6 @@ uint32_t HandleProcessParameters(ProcessParameters* ProcessParams)
     headairflow = ProcessParams->headairflow;
     dryerairflow = ProcessParams->dryerairflow;
 
-    for (Disp_i = 0;Disp_i < MAX_SYSTEM_DISPENSERS;Disp_i++)
-    {
-        Valve_Set(IDS_Id_to_AirValve[Disp_i], Atm_MidTank_ON );   //Atm_MidTank_OFF/ON
-        Read_MidTank_Pressure_Sensor(Disp_i);
-        Valve_Set(IDS_Id_to_AirValve[Disp_i], Atm_MidTank_OFF );   //Atm_MidTank_OFF/ON
-    }
    return status;//status;
 }
 
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
index e748ea631..5f733762c 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
@@ -57,11 +57,6 @@ uint32_t IdsGetMotorSpeed(uint32_t DispenserId)
     return  CurrentDispenserSpeed[DispenserId];
 }
 
-uint32_t IDS_Dispenser_EmptyCBFunction(uint32_t IfIndex, uint32_t ReadValue)
-{
-    return OK;
-}
-
 uint32_t IDS_Dispenser_Build_Pressure_Callback(uint32_t DispenserId, uint32_t ReadValue)
  {
     DispenserPrepareTime[DispenserId]+=DispenserPrepareTimeLag;
@@ -107,7 +102,7 @@ uint32_t IDS_Dispenser_Build_Pressure_Callback(uint32_t DispenserId, uint32_t Re
     if (DispenserControlId[DispenserId] != 0xFF)
         Report("Cannot Add control callback",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0);
 
-    DispenserControlId[DispenserId] = AddControlCallback( IDS_Dispenser_Build_Pressure_Callback, DispenserPrepareTimeLag,IDS_Dispenser_EmptyCBFunction ,DispenserId, DispenserId, 0 );
+    DispenserControlId[DispenserId] = AddControlCallback( IDS_Dispenser_Build_Pressure_Callback, DispenserPrepareTimeLag,TemplateDataReadCBFunction ,DispenserId, DispenserId, 0 );
     if (DispenserControlId[DispenserId] == 0xFF)
         Report("Add control callback failed",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0);
     else
@@ -165,7 +160,7 @@ uint32_t IDS_Dispenser_Build_Pressure_Callback(uint32_t DispenserId, uint32_t Re
     if (DispenserControlId[DispenserId] != 0xFF)
         Report("Cannot Add control callback",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0);
 
-    DispenserControlId[DispenserId] = AddControlCallback( IDS_Dispenser_StopMotorCallback, CloseValveTimeout, IDS_Dispenser_EmptyCBFunction,DispenserId, DispenserId, 0 );
+    DispenserControlId[DispenserId] = AddControlCallback( IDS_Dispenser_StopMotorCallback, CloseValveTimeout, TemplateDataReadCBFunction,DispenserId, DispenserId, 0 );
     if (DispenserControlId[DispenserId] == 0xFF)
         Report("Add control callback failed",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0);
     else
@@ -216,7 +211,7 @@ uint32_t IDS_Dispenser_Start_Motor_and_Open_Valve(int DispenserId, int MotorSpee
         Report("Cannot Add control callback",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0);
     Report("IDS_Dispenser_Start_Motor_and_Open_Valve",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)msec_millisecondCounter,0);
 
-    DispenserControlId[DispenserId] = AddControlCallback( IDS_Dispenser_OpenValveCallback, OpenValveTimeout, IDS_Dispenser_EmptyCBFunction,DispenserId, DispenserId, 0 );
+    DispenserControlId[DispenserId] = AddControlCallback( IDS_Dispenser_OpenValveCallback, OpenValveTimeout, TemplateDataReadCBFunction,DispenserId, DispenserId, 0 );
     if (DispenserControlId[DispenserId] == 0xFF)
         Report("Add control callback failed",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0);
     else
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
index f71cdc71f..8277c9cd9 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
@@ -110,8 +110,10 @@ uint32_t IDS_HomeDispenserCallback(uint32_t deviceID, uint32_t ReadValue)
 {
     uint8_t DispenserId = deviceID-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);
     if (HomingRequestCallback[DispenserId])
     {
@@ -170,6 +172,7 @@ uint32_t IDS_Dispenser_Alarm_On (uint8_t deviceID)
     TimerMotors_t MotorId = HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1 + deviceID;
     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);
     return status;
@@ -193,6 +196,7 @@ uint32_t IDS_StopHomeDispenser (uint32_t deviceID)
     TimerMotors_t MotorId = (deviceID)+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);
     MotorSetMicroStep(deviceID, MotorsCfg[deviceID].microstep);
     return OK;
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Motor.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Motor.c
index c0f0954ed..319f85454 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Motor.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Motor.c
@@ -513,6 +513,9 @@ void Stub_MotorPositionRequest(MessageContainer* requestContainer)
 
 void Stub_MotorMovRequest(MessageContainer* requestContainer)
 {
+
+    bool GoTo_Flag = false;
+
 #ifdef EVALUATION_BOARD
     uint32_t read_status;
 #endif
@@ -520,6 +523,12 @@ void Stub_MotorMovRequest(MessageContainer* requestContainer)
 
     StubMotorMovRequest* request = stub_motor_mov_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
 
+    if(request->position & 0x800000)
+    {
+        request->position =  request->position & ~0x800000;
+        GoTo_Flag = true;
+    }
+
     Pos_Value = request->position;
     Direction = request->direction;
 
@@ -531,6 +540,14 @@ void Stub_MotorMovRequest(MessageContainer* requestContainer)
         TimerMotors_t Motor_Id  = (TimerMotors_t)request->motor_id; //to remove warning
 
         MotorMove(Motor_Id, Direction, Pos_Value );
+        if(GoTo_Flag)
+        {
+            MotorGoTo(Motor_Id, Pos_Value );
+        }
+        else
+        {
+            MotorMove(Motor_Id, Direction, Pos_Value );
+        }
     #endif
 
     StubMotorMovResponse response =   STUB_MOTOR_MOV_RESPONSE__INIT;
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
index 3af29a043..cc9bb099f 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
@@ -220,7 +220,7 @@
         MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_DH_LID,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DH_LID].directionthreadwize, 200,  Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_DH_LID], Thread_Load_HomingCallback,10000);
         CallbackCounter++;
         //MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID].directionthreadwize, 200,  Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID], Thread_Load_HomingCallback,10000);
-        MotorMoveWithCallback(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID].directionthreadwize, 2,  Thread_Load_HomingCallback,10000);
+        MotorGotoWithCallback(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID, 2,  Thread_Load_HomingCallback,4000);
         return OK;
     }
     uint32_t Thread_Load_Lift_Dancers(void)
@@ -284,7 +284,7 @@
         MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_DH_LID,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DH_LID].directionthreadwize, 200,  Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_DH_LID], Thread_Load_HomingCallback,10000);
         CallbackCounter++;
 //        MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID].directionthreadwize, 200,  Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID], Thread_Load_HomingCallback,10000);
-        MotorMoveWithCallback(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID].directionthreadwize, 0,  Thread_Load_HomingCallback,10000);
+        MotorGotoWithCallback(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID, 0,  Thread_Load_HomingCallback,4000);
 
         return OK;
     }
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
index 76d4b090a..34387785c 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
@@ -546,10 +546,6 @@ uint32_t ThreadInitialTestStub(HardwareMotor * request)
     return OK;
 }
 bool InitialProcess = false;
-uint32_t ThreadEmptyCBFunction(uint32_t IfIndex, uint32_t ReadValue)
-{
-    return OK;
-}
 
 //********************************************************************************************************************
  uint32_t ThreadPrepareState(void *JobDetails)
@@ -650,7 +646,7 @@ uint32_t ThreadEmptyCBFunction(uint32_t IfIndex, uint32_t ReadValue)
                 ControlIdtoMotorId[Motor_i] = AddControlCallback(ThreadControlCBFunction, eOneMillisecond,Control_Read_Dancer_Position,(IfTypeThread*0x100+Motor_i),ThreadMotorIdToDancerId[Motor_i],Motor_i);
             }
 //            if (HW_Motor_Id == HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING) // dryer motor is speed controlled. later a speed sensor will be utilized, but for now it will not be controlled
-//                AddControlCallback(ThreadSpeedControlCBFunction, eOneMillisecond,ThreadEmptyCBFunction,(IfTypeThread*0x100+Motor_i),ThreadMotorIdToMotorId[Motor_i],0);
+//                AddControlCallback(ThreadSpeedControlCBFunction, eOneMillisecond,TemplateDataReadCBFunction,(IfTypeThread*0x100+Motor_i),ThreadMotorIdToMotorId[Motor_i],0);
             if (Motor_i == HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING) // dryer motor is speed controlled. later a speed sensor will be utilized, but for now it will not be controlled
                 continue;
     }