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

25 files changed, 1113 insertions, 248 deletions

diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
index 6f80fdffb..a6075ac09 100644
--- a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
+++ b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
@@ -260,13 +260,14 @@ AlarmHandlingItemStruc  HardCodedAlarmItem[MAX_SYSTEM_ALARMS]={
 
      {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_AN_ENCLOSURETEMP1,  0,40,true,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__MACHINE_INTERNAL_OVERTEMPERATURE      },
      {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_AN_ENCLOSURETEMP2,  1,40,true,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__MACHINE_INTERNAL_OVERTEMPERATURE      },
-
-     {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,FrontDoor1_EC    ,1,false,true,DEBUG_LOG_CATEGORY__Error,  0xFF,5,EVENT_TYPE__FRONT_COVER_1_OPEN},
-     {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,FrontDoor2_PPC    ,1,false,true,DEBUG_LOG_CATEGORY__Error,  0xFF,5,EVENT_TYPE__FRONT_COVER_2_OPEN},
-     {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,FrontDoor3_DH_DRYER    ,1,false,true,DEBUG_LOG_CATEGORY__Error,  0xFF,5,EVENT_TYPE__FRONT_COVER_3_OPEN},
-     {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,FrontDoor4_MIDTANKS    ,1,false,true,DEBUG_LOG_CATEGORY__Error,  0xFF,5,EVENT_TYPE__FRONT_COVER_4_OPEN},
-     {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,RearDoor      ,1,false,true,DEBUG_LOG_CATEGORY__Error,  0xFF,5,EVENT_TYPE__REAR_COVER_OPEN     },
-     {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,CartridgesDoor,1,false,true,DEBUG_LOG_CATEGORY__Warning,0xFF,5,EVENT_TYPE__CARTRIDGES_COVER_OPEN},
+/*
+     {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,FrontDoor1_EC      ,1,true,true,DEBUG_LOG_CATEGORY__Error,  0xFF,5,EVENT_TYPE__FRONT_COVER_1_OPEN},
+     {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,FrontDoor2_PPC     ,1,true,true,DEBUG_LOG_CATEGORY__Error,  0xFF,5,EVENT_TYPE__FRONT_COVER_2_OPEN},
+     {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,FrontDoor3_DH_DRYER,1,true,true,DEBUG_LOG_CATEGORY__Error,  0xFF,5,EVENT_TYPE__FRONT_COVER_3_OPEN},
+     {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,FrontDoor4_MIDTANKS,1,true,true,DEBUG_LOG_CATEGORY__Error,  0xFF,5,EVENT_TYPE__FRONT_COVER_4_OPEN},
+     {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,RearDoor           ,1,true,true,DEBUG_LOG_CATEGORY__Error,  0xFF,5,EVENT_TYPE__REAR_COVER_OPEN     },
+*/
+     {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,CartridgesDoor     ,1,true,true,DEBUG_LOG_CATEGORY__Warning,0xFF,5,EVENT_TYPE__CARTRIDGES_COVER_OPEN},
 
 
      {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,MIXER_PT100,   HARDWARE_PID_CONTROL_TYPE__MixerHeater        ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__MIXER_UNDERTEMPERATURE_A},
@@ -926,11 +927,11 @@ uint32_t AlarmHandlingLoop(uint32_t tick)
                 {
                     if (AlarmItem[Alarm_i].AlarmDirection == true)
                     {
-                        value = Read_Notification_Disp_UP(AlarmItem[Alarm_i].DeviceId,NULL);
+                        value = Get_Notification_Disp_UP(AlarmItem[Alarm_i].DeviceId/*,NULL*/);
                     }
                     else
                     {
-                        value = Read_Notification_Disp_Down(AlarmItem[Alarm_i].DeviceId,NULL);
+                        value = Get_Notification_Disp_Down(AlarmItem[Alarm_i].DeviceId/*,NULL*/);
                     }
                 }
                 else
diff --git a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
index fa94614fd..8e67de0f1 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
+++ b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
@@ -16,7 +16,9 @@
 ///////////////////////////////////////////////////////////////////////////////////////////
 #include "include.h"
 #include "Modules/General/GeneralHardware.h"
+
 #include "Modules/AlarmHandling/AlarmHandling.h"
+#include "Modules/General/MachineStatus.h"
 
 #include "MillisecTask.h"
 #include <driverlib/timer.h>
@@ -40,6 +42,7 @@
 #include "modules/thread/thread_ex.h"
 #include "modules/ids/ids_ex.h"
 #include "modules/Diagnostics/Diagnostics.h"
+#include "Modules/General/MachineStatus.h"
 
 #include "drivers/Flash_Memory/Flash_Memory.h"
 #include "drivers/Flash_Memory/fatfs/ff.h"
@@ -536,7 +539,7 @@ uint32_t MillisecLowLoop(uint32_t tick)
     {
         Speed_Data = Calculate_Speed_Sensor_Velocity();
         Read_Buttons_Reg();
-        Ink_Cart_Led();
+        //Ink_Cart_Led();
         for (Sensor_i = 0;Sensor_i < MAX_TEMPERATURE_SENSOR_ID;Sensor_i++)
         {
             MillisecUpdateTemperatures (Sensor_i,TemperatureSensorRead(Sensor_i));
@@ -606,7 +609,8 @@ uint32_t MillisecLowLoop(uint32_t tick)
         {
             Read_MidTank_Pressure_Sensor(Disp_i);
         }
-/*        for (Motor_i = 0;Motor_i < NUM_OF_MOTORS;Motor_i++)
+        MachineUpdateResponseFunc();
+        /*        for (Motor_i = 0;Motor_i < NUM_OF_MOTORS;Motor_i++)
         {
             if (Motor_i == HARDWARE_MOTOR_TYPE__MOTO_SCREW)
                 continue;  //
diff --git a/Software/Embedded_SW/Embedded/Modules/Control/control.c b/Software/Embedded_SW/Embedded/Modules/Control/control.c
index f1e19d851..07214d240 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/control.c
+++ b/Software/Embedded_SW/Embedded/Modules/Control/control.c
@@ -158,7 +158,7 @@ uint32_t ControlActivityLed( uint32_t Parameter1)
 {
     static bool flag = false;
     static uint8_t counter;
-    const uint8_t Blink_Freq = 3;//odd number
+    const uint8_t Blink_Freq = 7;//odd number
 
     if (flag==true)
     {
@@ -479,6 +479,14 @@ uint32_t GetControlLowDevice_i(void)
 {
     return ControlLowDevice_i;
 }
+ControlCBFunction GetControlCallbackFuncPtr(uint32_t ControlId)
+{
+    if (ControlArray[ControlId].ControlActive)
+        return ControlArray[ControlId].ControlCallbackPtr;
+    else
+        return NULL;
+
+}
 uint32_t ControlLoop(uint32_t tick)
 {
     if (MaxHighDevices == 0xFF)
diff --git a/Software/Embedded_SW/Embedded/Modules/Control/control.h b/Software/Embedded_SW/Embedded/Modules/Control/control.h
index 380040e34..450646a68 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/control.h
+++ b/Software/Embedded_SW/Embedded/Modules/Control/control.h
@@ -48,6 +48,8 @@ uint32_t    TemplateDataReadCBFunction (uint32_t deviceId, uint32_t Parameter1);
 uint32_t    GetControlDevice_i(void);
 uint32_t    GetControlLowDevice_i(void);
 
+ControlCBFunction GetControlCallbackFuncPtr(uint32_t ControlId);
+
 extern Task_Handle Control_Task_Handle;
 extern uint32_t millisecondCounter;
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
index 8956f417d..aaa6f9a50 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
@@ -49,6 +49,8 @@
 
 #include <drivers/FPGA/FPGA_Comm.h>
 
+#include "diagnostics.h"
+
 extern F2_CTRL_REG F2_CTRL_Reg;
 
 char DiagnosticsToken[36+1] = {0};
@@ -63,26 +65,17 @@ uint32_t Diagnostics_TenMiliControlTrigger(uint32_t IfIndex, uint32_t ReadValue)
 uint32_t Diagnostics_OneSecControlTrigger(uint32_t IfIndex, uint32_t ReadValue);
 uint32_t DispensersCollection(uint32_t IfIndex, uint32_t ReadValue);
 
-//#define REDUCED_DIAGNOSTICS
 
 DiagnosticsMonitors DiagnosticsMonitor = DIAGNOSTICS_MONITORS__INIT;
 #define DIAGNOSTICS_LIMIT 3
 #define DIAGNOSTICS_DANCER_LIMIT 30
 int DiagnosticsIndex = 0;
-#ifdef REDUCED_DIAGNOSTICS
-int DiagnosticCollectionLimit = 1;  //number of data samples to collect before sending to the host
-#else
 int DiagnosticCollectionLimit = 2;  //number of data samples to collect before sending to the host
-#endif
 //int DiagnosticLimit = eHundredMillisecond; //frequency of data collection
 //int DiagnosticFastLimit = eTenMillisecond; //frequency of data collection
-#ifdef REDUCED_DIAGNOSTICS
-int DiagnosticLimit =eOneSecond; //frequency of data collection
-#else
 int DiagnosticLimit =eHundredMillisecond; //frequency of data collection
-#endif
+
 int DiagnosticFastLimit = eTenMillisecond; //frequency of data collection
-//#define TEN_MSEC_COLLECTION
 //DigitalPin DigitalPinArray[1][DIAGNOSTICS_LIMIT+1];
 double dancer1angle[DIAGNOSTICS_LIMIT+1];
 double dancer2angle[DIAGNOSTICS_LIMIT+1];
@@ -109,6 +102,7 @@ double dispensermotorfrequency[MAX_SYSTEM_DISPENSERS][DIAGNOSTICS_LIMIT+1];
 double dispenserspressure[MAX_SYSTEM_DISPENSERS][DIAGNOSTICS_LIMIT+1];
 double MidTankpressure[MAX_SYSTEM_DISPENSERS][1];
 double HeatersCurrent[NUM_OF_CURRENT_HEATERS][1];
+double VOC_Sensor;
 
 DoubleArray DispenserFreq[MAX_SYSTEM_DISPENSERS];
 DoubleArray DiagnosticsDispenserPressure[MAX_SYSTEM_DISPENSERS];
@@ -154,6 +148,8 @@ int diag_index=0;
 uint32_t diag_size[MAX_DIAG_LOG];
 uint32_t diag_time[MAX_DIAG_LOG];
 
+Diagnostic_Mode DiagnosticMode = Diagnostic_Normal_Mode;
+
 /******************** CODE  ********************************************/
 //**********************************************************************
 
@@ -192,14 +188,35 @@ void DiagnosticsInit(void)
 
     return;
 }
+/*typedef enum
+{
+    Diagnostic_Minimal_Mode,
+    Diagnostic_Normal_Mode,
+    Diagnostic_Extended_Mode,
+    Diagnostic_Extreme_Mode
+}Diagnostic_Mode;
+if (DiagnosticMode == Diagnostic_Minimal_Mode)
+if (DiagnosticMode == Diagnostic_Normal_Mode)
+if (DiagnosticMode == Diagnostic_Extended_Mode)
+if (DiagnosticMode == Diagnostic_Extreme_Mode)
+*/
+void SetDiagnosticMode(Diagnostic_Mode Mode)
+{
+    DiagnosticMode = Mode;
+    REPORT_MSG(Mode,"Diagnostic Mode set");
+}
 
 void  SetDiagnosticCollectionLimit(int limit)
 {
     if ((limit)&&(limit<= DIAGNOSTICS_LIMIT))
         DiagnosticCollectionLimit = limit;
-#ifdef REDUCED_DIAGNOSTICS
+    DiagnosticLimit =eHundredMillisecond; //frequency of data collection
+
+    if (DiagnosticMode <= Diagnostic_Normal_Mode)
+    {
         DiagnosticCollectionLimit = 1;  //overrule - send at least once every second
-#endif
+        DiagnosticLimit =eOneSecond; //frequency of data collection
+    }
 }
 
 uint8_t HeaterCounterIndex[MAX_HEATERS_NUM]= {0,0,0,0,0,0,0,0,0,0};
@@ -340,7 +357,6 @@ void DiagnosticTenMsecCollection(void)
 {
     if (DiagnosticsActive == false)
         return;
-//#ifdef TEN_MSEC_COLLECTION
     /*if (JobIsActive()== false)
         return;*/
     DiagnosticLoadDancer(WINDER_DANCER,Control_Read_Dancer_Position(WINDER_DANCER, 0,0));
@@ -352,7 +368,6 @@ void DiagnosticTenMsecCollection(void)
     DiagnosticLoadDancerError(FEEDER_DANCER,ThreadGetMotorCalculatedError(FEEDER_DANCER));
 
     //DiagnosticLoadSpeedSensor(getSensorSpeedData());
-//#endif
 }
 void DiagnosticOneSecCollection(void)
 {
@@ -378,6 +393,7 @@ void DiagnosticOneSecCollection(void)
             MidTankpressure[i][0] = Get_MidTank_Pressure_Sensor(i);
         else
             MidTankpressure[i][0] = 1.00-(IDS_Dispenser_Data[i].consumedinnanolitter/5800000);
+        //double dispcapacity = (1.00-(IDS_Dispenser_Data[i].consumedinnanolitter/5800000))*130*1000*1000;
     }
 }
 void Diagnostic100msecCollection(void)
@@ -387,19 +403,20 @@ void Diagnostic100msecCollection(void)
         return;
 
     //DiagnosticLoadSpeedSensor(getSensorSpeedData());
-#ifndef REDUCED_DIAGNOSTICS
-#ifndef TEN_MSEC_COLLECTION
-    DiagnosticTenMsecCollection(); //call the 10msec function every 100 msec to reduce transport
-#endif
-    //if (JobIsActive())
+    if (DiagnosticMode == Diagnostic_Extreme_Mode)
+        DiagnosticTenMsecCollection(); //call the 10msec function every 100 msec to reduce transport
+
+    if (DiagnosticMode >= Diagnostic_Extended_Mode)
     {
-        DiagnosticLoadMotor(FEEDER_MOTOR, ThreadGetMotorSpeed (FEEDER_MOTOR));
-        DiagnosticLoadMotor(DRYER_MOTOR, ThreadGetMotorSpeed (DRYER_MOTOR));
-        DiagnosticLoadMotor(POOLER_MOTOR, ThreadGetMotorSpeed (POOLER_MOTOR));
-        DiagnosticLoadMotor(WINDER_MOTOR, ThreadGetMotorSpeed (WINDER_MOTOR));
-        DiagnosticLoadMotor(SCREW_MOTOR, ThreadGetMotorSpeed (SCREW_MOTOR));
+        if (JobIsActive())
+        {
+            DiagnosticLoadMotor(FEEDER_MOTOR, ThreadGetMotorSpeed (FEEDER_MOTOR));
+            DiagnosticLoadMotor(DRYER_MOTOR, ThreadGetMotorSpeed (DRYER_MOTOR));
+            DiagnosticLoadMotor(POOLER_MOTOR, ThreadGetMotorSpeed (POOLER_MOTOR));
+            DiagnosticLoadMotor(WINDER_MOTOR, ThreadGetMotorSpeed (WINDER_MOTOR));
+            DiagnosticLoadMotor(SCREW_MOTOR, ThreadGetMotorSpeed (SCREW_MOTOR));
+        }
     }
-#endif
     /*
     DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__MixerHeater, MillisecGetTemperatures( MIXER_PT100));
     DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DYEINGH_TEMP1));
@@ -424,13 +441,14 @@ void Diagnostic100msecCollection(void)
             MidTankpressure[i][0] = 1.00-(IDS_Dispenser_Data[i].consumedinnanolitter/5800000);
     }
     */
-#ifndef REDUCED_DIAGNOSTICS
-    for (i=0;i<NUM_OF_CURRENT_HEATERS;i++)
+    if (DiagnosticMode == Diagnostic_Extreme_Mode)
     {
-        HeatersCurrent[i][0] = Get_Heaters_Current(i);
+        for (i=0;i<NUM_OF_CURRENT_HEATERS;i++)
+        {
+            HeatersCurrent[i][0] = Get_Heaters_Current(i);
+        }
     }
-#endif
-    /*     dispenser1motorfrequency[DiagnosticsIndex] = MotorGetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1);
+   /*dispenser1motorfrequency[DiagnosticsIndex] = MotorGetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1);
      dispenser2motorfrequency[DiagnosticsIndex] = MotorGetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2);
      dispenser3motorfrequency[DiagnosticsIndex] = MotorGetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3);
      dispenser4motorfrequency[DiagnosticsIndex] = MotorGetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4);
@@ -507,8 +525,7 @@ void SendDiagnostics(void)
     DiagnosticsMonitor.dancer2angle = dancer2angle;
     DiagnosticsMonitor.dancer3angle = dancer3angle;
 */
-#ifndef REDUCED_DIAGNOSTICS
-    //if (JobIsActive())
+    if ((JobIsActive())&&(DiagnosticMode >= Diagnostic_Extended_Mode))
     {
         DiagnosticsMonitor.n_dancer1angle =  DancerCounterIndex[0];
         DiagnosticsMonitor.n_dancer2angle =  DancerCounterIndex[1];
@@ -537,7 +554,6 @@ void SendDiagnostics(void)
         DiagnosticsMonitor.n_windermotor =  MotorCounterIndex[WINDER_MOTOR];
         DiagnosticsMonitor.n_screwmotor = MotorCounterIndex[SCREW_MOTOR];
     }
-#endif
     DiagnosticsMonitor.mixertemperature = HeaterTemperature[HARDWARE_PID_CONTROL_TYPE__MixerHeater];
     DiagnosticsMonitor.headzone1temperature = HeaterTemperature[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1];
     DiagnosticsMonitor.headzone2temperature = HeaterTemperature[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2];
@@ -653,6 +669,10 @@ void SendDiagnostics(void)
     DiagnosticsMonitor.n_headzone5_6heatercurrent = 1;
     DiagnosticsMonitor.headzone5_6heatercurrent = HeatersCurrent[HEATER_HEAD_CURRENT_ZONE_5_6];
 
+    VOC_Sensor = (double) getGasReading();
+    DiagnosticsMonitor.n_filterdeltapressure = 1;
+    DiagnosticsMonitor.filterdeltapressure = &VOC_Sensor;
+
     response.monitors = &DiagnosticsMonitor;
     //response.digitalpins = DigitalPinArray;
     response.n_componentsstates = 0;
@@ -733,12 +753,10 @@ uint32_t DiagnosticsStart(void)
                 DiagnosticsControlId = AddControlCallback(Diagnostics_ControlTrigger,DiagnosticLimit,TemplateDataReadCBFunction,0,0,0);
             else
                 LOG_ERROR(DiagnosticsControlId,"Diagnostics restarted");
-#ifdef TEN_MSEC_COLLECTION
             if (Diagnostics10MSControlId == 0xFF)
                 Diagnostics10MSControlId = AddControlCallback(Diagnostics_TenMiliControlTrigger,DiagnosticFastLimit,TemplateDataReadCBFunction,0,0,0);
             else
                 LOG_ERROR(DiagnosticsControlId,"Diagnostics restarted");
-#endif
             if (Diagnostics1SecControlId == 0xFF)
                 Diagnostics1SecControlId = AddControlCallback(Diagnostics_OneSecControlTrigger,eOneSecond,TemplateDataReadCBFunction,0,0,0);
             else
@@ -822,13 +840,14 @@ uint32_t Diagnostics_TenMiliControlTrigger(uint32_t IfIndex, uint32_t ReadValue)
 {
     DiagnosticsMessageStruc Message;
 
-    //send message to the Millisec task
-    Message.messageId = DiagnosticsTenMiliTrigger;
-    Message.msglen = sizeof(DiagnosticsMessageStruc);
-    if (DiagnosticsMsgQ != NULL)
-        Mailbox_post(DiagnosticsMsgQ , &Message, BIOS_NO_WAIT);
-
-
+    if (DiagnosticMode == Diagnostic_Extreme_Mode)
+    {
+        //send message to the Millisec task
+        Message.messageId = DiagnosticsTenMiliTrigger;
+        Message.msglen = sizeof(DiagnosticsMessageStruc);
+        if (DiagnosticsMsgQ != NULL)
+            Mailbox_post(DiagnosticsMsgQ , &Message, BIOS_NO_WAIT);
+    }
     return OK;
 }
 
@@ -868,9 +887,7 @@ void DiagnosticsTask(UArg arg0, UArg arg1)
                 Diagnostic100msecCollection();
                 break;
             case DiagnosticsTenMiliTrigger:
-#ifdef TEN_MSEC_COLLECTION
                 DiagnosticTenMsecCollection();
-#endif
                 break;
             case DiagnosticsOneSecTrigger:
                 DiagnosticOneSecCollection();
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.h b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.h
index a68731eea..d6d515598 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.h
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.h
@@ -12,9 +12,17 @@
 extern bool blowervolatgedisplay;
 extern bool midtankDisplay;
 extern double voltage;
-extern uint8_t* diagnosticscontainer_buffer;
+extern char* diagnosticscontainer_buffer;
 
+typedef enum
+{
+    Diagnostic_Minimal_Mode,
+    Diagnostic_Normal_Mode,
+    Diagnostic_Extended_Mode,
+    Diagnostic_Extreme_Mode
+}Diagnostic_Mode;
 
+void SetDiagnosticMode(Diagnostic_Mode Mode);
 uint32_t StartDiagnosticsRequestFunc(MessageContainer* requestContainer);
 uint32_t StopDiagnosticsRequestFunc(MessageContainer* requestContainer);
 
diff --git a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
index eb9425bf3..5a706e25c 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
@@ -48,6 +48,7 @@
 #include "StateMachines/Initialization/PowerOffSequence.h"
 #include "Drivers/I2C_Communication/Dispenser_Card/EEPROM/Dispenser_EEPROM.h"
 #include <Drivers/I2C_Communication/Dispenser_Card/IO_Ports/Dispenser_IO.h>
+#include "Modules/General/buttons.h"
 
 uint32_t EmbeddedParametersInit(void);
 uint32_t EmbeddedParametersWrite(void * buffer, uint16_t size);
@@ -184,6 +185,7 @@ void LoadConfigurationParameters(ConfigurationParameters *Params)
             EmbeddedParameters->dispenserpresegmentwfcf = 80;
             EmbeddedParameters->has_startheatingoninitsequence = true;
             EmbeddedParameters->startheatingoninitsequence = true; //set to true shlomo 14/5/2019
+            EmbeddedParameters->n_generalparameters = 7;
             EmbeddedParameters->generalparameters = malloc (sizeof(double)*10);
             if (EmbeddedParameters->generalparameters)
             {
@@ -193,6 +195,7 @@ void LoadConfigurationParameters(ConfigurationParameters *Params)
                 EmbeddedParameters->generalparameters[3] = 0.0; //CheckMotorAlarms
                 EmbeddedParameters->generalparameters[4] = 800.0; //Winder homing time at end of job
                 EmbeddedParameters->generalparameters[5] = 1000.0; //Dispenser initial pressure speed
+                EmbeddedParameters->generalparameters[6] = Diagnostic_Normal_Mode; //Diagnostic Mode SetDiagnosticMode
             }
             EmbeddedParameters->has_currentalarmlowlimit = true;
             EmbeddedParameters->currentalarmlowlimit = 0.80;
@@ -269,8 +272,15 @@ uint32_t EmbeddedParametersInit(void)
         }
     }
 
+    if (EmbeddedParameters->n_generalparameters >= 6)
+    {
+        IDS_Dispenser_SetBackLashValues(EmbeddedParameters->initialdispenserpressure, EmbeddedParameters->initialdispensertimeout, EmbeddedParameters->initialdispensertimelag,EmbeddedParameters->generalparameters[5]);
+    }
+    else
+    {
+        IDS_Dispenser_SetBackLashValues(EmbeddedParameters->initialdispenserpressure, EmbeddedParameters->initialdispensertimeout, EmbeddedParameters->initialdispensertimelag,900);
+    }
     IDS_Dispenser_SetTimeOutValues(EmbeddedParameters->closevalvetimeout, EmbeddedParameters->openvalvetimeout);
-    IDS_Dispenser_SetBackLashValues(EmbeddedParameters->initialdispenserpressure, EmbeddedParameters->initialdispensertimeout, EmbeddedParameters->initialdispensertimelag,EmbeddedParameters->generalparameters[5]);
     IDS_Dispenser_SetPrepareValues(EmbeddedParameters->dispenserbuildpressurespeed,   EmbeddedParameters->dispenserbuildpressurelimit, EmbeddedParameters->dispenserbuildpressuretimeout, EmbeddedParameters->dispenserbuildpressurelag);
     IDS_Dispenser_SetPreSegmentWFCFValues(EmbeddedParameters->dispenserpresegmentwfcf,  EmbeddedParameters->ids_presegment_wfcf_timebeforesegment);
     IDS_Dispenser_SetPreSegmentCleaningValues(EmbeddedParameters->ids_cleaningspeed,EmbeddedParameters->ids_cleaningstartspraypresegmenttime ,EmbeddedParameters->ids_cleaningstopbeforesegmenttime,EmbeddedParameters->ids_leftcleaningmotorspeed,EmbeddedParameters->ids_rightcleaningmotorspeed);
@@ -283,15 +293,24 @@ uint32_t EmbeddedParametersInit(void)
     PowerOffSetTemperatureThreshold(EmbeddedParameters->powerofftemperaturelimit);
 
     InitSequenceSetStartHeating (EmbeddedParameters->startheatingoninitsequence);
-    bool checkHardLimitAlarms, checkCurrentAlarms,  checkTamperAlarms,  checkMotorAlarms;
-    checkHardLimitAlarms = (EmbeddedParameters->generalparameters[0] < 0.5)?false:true;
-    checkCurrentAlarms = (EmbeddedParameters->generalparameters[1] < 0.5)?false:true;
-    checkTamperAlarms = (EmbeddedParameters->generalparameters[2] < 0.5)?false:true;
-    checkMotorAlarms = (EmbeddedParameters->generalparameters[3] < 0.5)?false:true;
-    AlarmHandlingSetFlags(checkHardLimitAlarms,checkCurrentAlarms,checkTamperAlarms,checkMotorAlarms);
-    SetWinderBackToBaseTime((uint32_t) EmbeddedParameters->generalparameters[4]);
-
-
+    bool checkHardLimitAlarms = false, checkCurrentAlarms = false,  checkTamperAlarms = false,  checkMotorAlarms = false;
+    if (EmbeddedParameters->n_generalparameters >= 4)
+    {
+        checkHardLimitAlarms = (EmbeddedParameters->generalparameters[0] < 0.5)?false:true;
+        checkCurrentAlarms = (EmbeddedParameters->generalparameters[1] < 0.5)?false:true;
+        checkTamperAlarms = (EmbeddedParameters->generalparameters[2] < 0.5)?false:true;
+        checkMotorAlarms = (EmbeddedParameters->generalparameters[3] < 0.5)?false:true;
+        AlarmHandlingSetFlags(checkHardLimitAlarms,checkCurrentAlarms,checkTamperAlarms,checkMotorAlarms);
+    }
+    if (EmbeddedParameters->n_generalparameters >= 5)
+        SetWinderBackToBaseTime((uint32_t) EmbeddedParameters->generalparameters[4]);
+    if (EmbeddedParameters->n_generalparameters >= 7)
+    {
+        if(EmbeddedParameters->generalparameters[6]<0.5)  SetDiagnosticMode(Diagnostic_Minimal_Mode);
+        else if(EmbeddedParameters->generalparameters[6]<1.5)  SetDiagnosticMode(Diagnostic_Normal_Mode);
+        else if(EmbeddedParameters->generalparameters[6]<2.5)  SetDiagnosticMode(Diagnostic_Extended_Mode);
+        else if(EmbeddedParameters->generalparameters[6]<3.5)  SetDiagnosticMode(Diagnostic_Extreme_Mode);
+    }
     PowerIdleSetParameters(EmbeddedParameters->switchtoidletimeinseconds,EmbeddedParameters->idledriertemperature,EmbeddedParameters->idleheadtemperature,EmbeddedParameters->idlemixertemperature);
 
     return Fresult;
@@ -405,7 +424,7 @@ uint32_t HWConfiguration(UploadHardwareConfigurationRequest* UploadRequest)
         upload_hardware_configuration_request__free_unpacked(UploadRequest,NULL);
         return ERROR;
     }
-    Init_Dispensers_IO_Registers(&Disp_IO_Reg);
+    Init_Dispensers_IO_Registers(/*&Disp_IO_Reg*/);
     if (request->n_breaksensors == 1)
     {
         ThreadConfigBreakSensor(request->breaksensors[0]);
diff --git a/Software/Embedded_SW/Embedded/Modules/General/MachineStatus.c b/Software/Embedded_SW/Embedded/Modules/General/MachineStatus.c
new file mode 100644
index 000000000..7949ee0c2
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Modules/General/MachineStatus.c
@@ -0,0 +1,136 @@
+/*
+ * MachineStatus.c
+ *
+ *  Created on: Aug 15, 2019
+ *      Author: shlomo
+ */
+#include <Container.h>
+#include <DataDef.h>
+#include <stdio.h>      /* puts(), etc. */
+#include "Common/report/report.h"
+#include "include.h"
+
+#include "PMR/common/MessageContainer.pb-c.h"
+#include "PMR/MachineStatus/StartMachineStatusUpdateRequest.pb-c.h"
+#include "PMR/MachineStatus/StopMachineStatusUpdateRequest.pb-c.h"
+#include "PMR/MachineStatus/StartMachineStatusUpdateResponse.pb-c.h"
+#include "PMR/MachineStatus/StopMachineStatusUpdateResponse.pb-c.h"
+#include "PMR/MachineStatus/MachineStatus.pb-c.h"
+#include "PMR/MachineStatus/MachineState.pb-c.h"
+#include "PMR/MachineStatus/IDSPackLevel.pb-c.h"
+
+#include "drivers/I2C_Communication/ADC_MUX/ADC_MUX.h"
+
+#include "Modules/General/MachineStatus.h"
+
+#include "modules/ids/ids_ex.h"
+
+MachineState StoredMachineStatus = MACHINE_STATE__Ready;
+
+void SetMachineStatus (MachineState State)
+{
+    StoredMachineStatus = State;
+}
+char MachineUpdateToken[36+1] = {0};
+IDSPackLevel IDS_Level[MAX_SYSTEM_DISPENSERS];
+int MachineUpdateResponseFunc(void)
+{
+    int i;
+    MessageContainer responseContainer;
+    if (MachineUpdateToken[0] == 0)
+        return OK;
+
+    StartMachineStatusUpdateResponse response = START_MACHINE_STATUS_UPDATE_RESPONSE__INIT;
+    MachineStatus MachineStatus;
+    response.status = &MachineStatus;
+
+    machine_status__init(&MachineStatus);
+    MachineStatus.has_state = true;
+    MachineStatus.state = StoredMachineStatus;
+    MachineStatus.n_idspackslevels = MAX_SYSTEM_DISPENSERS;
+    MachineStatus.idspackslevels = (IDSPackLevel**)my_malloc(sizeof(IDSPackLevel *)*8);
+    if (MachineStatus.idspackslevels)
+    {
+        for (i = 0; i<MAX_SYSTEM_DISPENSERS;i++)
+        {
+            IDS_Level[i].has_index = true;
+            IDS_Level[i].index = i;
+            IDS_Level[i].has_dispenserlevel = true;
+            double dispcapacity = (1.00-(IDS_Dispenser_Data[i].consumedinnanolitter/5800000))*130*1000*1000;
+            IDS_Level[i].dispenserlevel = (int32_t)dispcapacity;
+            IDS_Level[i].has_midtanklevel = true;
+            IDS_Level[i].midtanklevel = Get_MidTank_Int100_Sensor(i);
+            MachineStatus.idspackslevels[i] = &IDS_Level[i];
+        }
+    }
+    else
+        return ERROR;
+
+
+
+    responseContainer = /*MachineUpdate*/createContainer(MESSAGE_TYPE__StartMachineStatusUpdateResponse, MachineUpdateToken, false, &response, &start_machine_status_update_response__pack, &start_machine_status_update_response__get_packed_size);
+    responseContainer.continuous = true;
+    //if (responseContainer.data.data)
+    {
+        uint8_t* container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
+        if (container_buffer)
+        {
+            size_t container_size = message_container__pack(&responseContainer, container_buffer);
+            //        if (SendChars(container_buffer, container_size) == false) //comm tx mailbox full
+            if (SendCharsWithType(container_buffer, container_size,MESSAGE_TYPE__StartMachineStatusUpdateResponse) == false) //comm tx mailbox full
+            {
+                //CommunicationMailboxFlush();
+                MachineUpdateToken[0] = 0;
+                my_free(container_buffer);
+            }
+        }
+        my_free(responseContainer.data.data);
+    }
+
+    my_free(MachineStatus.idspackslevels);
+        //Task_sleep(5);
+    return OK;
+
+}
+
+
+uint32_t MachineUpdateInitFunc(MessageContainer* requestContainer)
+{
+    uint32_t status = NOT_SUPPORTED;
+    //MessageContainer responseContainer;
+
+//    MachineUpdateInitParams InitParams;
+
+    StartMachineStatusUpdateRequest* request = start_machine_status_update_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
+    ustrncpy (MachineUpdateToken, requestContainer->token,36);
+
+    start_machine_status_update_request__free_unpacked(request,NULL);
+    return status;
+}
+void MachineUpdateStopReporting(void)
+{
+    MachineUpdateToken[0] = 0;
+}
+uint32_t StopMachineUpdateFunc(MessageContainer* requestContainer)
+{
+
+    MessageContainer responseContainer;
+
+    StopMachineStatusUpdateRequest* request = stop_machine_status_update_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
+
+    StopMachineStatusUpdateResponse response = STOP_MACHINE_STATUS_UPDATE_RESPONSE__INIT;
+
+//TODO Handle the request!!!!
+    MachineUpdateStopReporting();
+    responseContainer = createContainer(MESSAGE_TYPE__StopMachineStatusUpdateResponse, MachineUpdateToken, false, &response, &stop_machine_status_update_response__pack, &stop_machine_status_update_response__get_packed_size);
+    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);
+    //free (container_buffer);
+
+return OK;
+}
+
diff --git a/Software/Embedded_SW/Embedded/Modules/General/MachineStatus.h b/Software/Embedded_SW/Embedded/Modules/General/MachineStatus.h
new file mode 100644
index 000000000..489a8f638
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Modules/General/MachineStatus.h
@@ -0,0 +1,21 @@
+/*
+ * MachineStatus.h
+ *
+ *  Created on: Aug 15, 2019
+ *      Author: shlomo
+ */
+
+#ifndef MODULES_GENERAL_MACHINESTATUS_H_
+#define MODULES_GENERAL_MACHINESTATUS_H_
+#include <PMR/Common/MessageContainer.pb-c.h>
+#include "PMR/MachineStatus/MachineState.pb-c.h"
+
+uint32_t MachineUpdateInitFunc(MessageContainer* requestContainer);
+uint32_t StopMachineUpdateFunc(MessageContainer* requestContainer);
+void SetMachineStatus (MachineState State);
+int MachineUpdateResponseFunc(void);
+
+
+
+
+#endif /* MODULES_GENERAL_MACHINESTATUS_H_ */
diff --git a/Software/Embedded_SW/Embedded/Modules/General/buttons.c b/Software/Embedded_SW/Embedded/Modules/General/buttons.c
index 724db5480..3ffb63508 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/buttons.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/buttons.c
@@ -155,7 +155,7 @@ uint32_t Buttons_Init(void)
     strcpy(power.bttn_name, "power");
     power.bttn_status = release;    // 0=release 1=press
     power.Action = OFFPB ;   //off,short,long,count,replong
-    power.color = BLUE;   //off, blue, blink, bithing
+    power.color = colorON;   //off, blue, blink, bithing
     power.state = sttON; //sttOFF, sttON, sttDISABLE, sttENABLE, sttIDLE, sttJOGGING
     power.count = 0;
 
@@ -164,19 +164,20 @@ uint32_t Buttons_Init(void)
     strcpy(jog.bttn_name, "jog");
     jog.bttn_status = release;    // 0=release 1=press
     jog.Action = OFFPB ;   //OFFPB,short,long,count,replong
-    jog.color = colorOFF;   //colorOFF, BLUE, BLINK,
-    jog.state = sttOFF; // sttDISABLE, sttENABLE, sttJOGGING
+    jog.color = colorON;   //colorOFF, BLUE, BLINK,
+    jog.state = sttENABLE; // sttDISABLE, sttENABLE, sttJOGGING
     jog.count = 0;
-   AddControlCallback( ButtonJogCBFunction, BUTTOMS_SAMPLE_TIME, ButtonJogCallBackFunction, 0,0,0 ); //
 
-   strcpy(load.bttn_name, "load");
-   load.bttn_status = release;    // 0=release 1=press
-   load.Action = OFFPB ;   //OFFPB,short,long,count,replong
-   load.color = colorOFF;   //colorOFF, BLUE, BLINK,
-   load.state = sttRDY; //
-   load.count = 0;
+    AddControlCallback( ButtonJogCBFunction, BUTTOMS_SAMPLE_TIME, ButtonJogCallBackFunction, 0,0,0 ); //
 
-   AddControlCallback( ButtonLoadCBFunction, BUTTOMS_SAMPLE_TIME, ButtonLoadCallBackFunction, 0,0,0 ); //
+    strcpy(load.bttn_name, "load");
+    load.bttn_status = release;    // 0=release 1=press
+    load.Action = OFFPB ;   //OFFPB,short,long,count,replong
+    load.color = colorOFF;   //colorOFF, BLUE, BLINK,
+    load.state = sttRDY; //
+    load.count = 0;
+
+    AddControlCallback( ButtonLoadCBFunction, BUTTOMS_SAMPLE_TIME, ButtonLoadCallBackFunction, 0,0,0 ); //
 return OK;
 }
 
@@ -335,7 +336,7 @@ uint32_t StateMachine( button *pBtn) //short press(=0)/long press(=1)
                         pBtn->state = sttOFF;
                         pBtn->color =  colorOFF;
                         Pannel_Leds(POWER_ON_OFF,MODE_OFF);//AVI+
-                        PowerDown();// todo
+                        PowerDown();
                         REPORT_MSG(parameter," ------------ Power state is OFF  ----------------- ");
                         break;
 //                   case SHORTPB:   //idle ?????
@@ -349,14 +350,14 @@ uint32_t StateMachine( button *pBtn) //short press(=0)/long press(=1)
                 switch (pBtn->Action)
                 {
 //                    case LONGPB:    //Idle?
-//                          // todo
+
 //                        break;
                     case SHORTPB:   //powerup?
                          // to do ?
                         pBtn->state = sttON;
-                        pBtn->color = BLUE ;
+                        pBtn->color = colorON ;
                         Pannel_Leds(POWER_ON_OFF,MODE_ON);//AVI+
-                        PowerUp(); //todo
+                        PowerUp();
                         REPORT_MSG(parameter," ------------ Power state is ON  ----------------- ");
                         break;
                     default:
@@ -370,7 +371,7 @@ uint32_t StateMachine( button *pBtn) //short press(=0)/long press(=1)
                         pBtn->state = sttOFF;
                         pBtn->color =  colorOFF;
                         Pannel_Leds(POWER_ON_OFF,MODE_OFF);//AVI+
-                        PowerDown(); // todo
+                        PowerDown();
                         Pannel_Leds(POWER_ON_OFF,MODE_OFF); //AVI+ - TODO option MODE_ON to stop Breathing and the led will turn off in power down
                         REPORT_MSG(parameter," ------------ Power state is OFF  ----------------- ");
                         break;
@@ -472,7 +473,7 @@ uint32_t joggingMachine(  button *pBtn) //uint8_t OnOffPB,
             REPORT_MSG(parameter," ------------joggingMachine: stop Jogging    ----------------- ");
             pBtn->Action = OFFPB;
             ThreadAbortJoggingFunc(); // to do!!!!
-            pBtn->color =  BLUE;
+            pBtn->color =  colorON;
             Pannel_Leds(THREAD_JOGGING, MODE_ON);//AVI+
         }
         else if ((pBtn->Action == OFFPB) && (pBtn->bttn_status == press))
@@ -548,7 +549,7 @@ uint32_t LoadStatMachine( button *pBtn)
                     if (ThreadLoadButton( THREAD_LOAD_INIT))
                     {
                         pBtn->state = sttPRELOAD ;    // to do
-                        pBtn->color =  BLUE;
+                        pBtn->color =  colorON;
                         Pannel_Leds(THREAD_LOAD, MODE_ON);//AVI+
                     }
                     else
@@ -573,7 +574,7 @@ uint32_t LoadStatMachine( button *pBtn)
                     if (ThreadLoadButton( THREAD_LOAD_INITIAL_TENSION))
                     {
                         pBtn->state = sttRDY ;    // to do
-                        pBtn->color =  BLUE;
+                        pBtn->color =  colorON;
                         Pannel_Leds(THREAD_LOAD, MODE_ON);//AVI+
                     }
                     else
@@ -593,7 +594,7 @@ uint32_t LoadStatMachine( button *pBtn)
             if (ThreadLoadButton( THREAD_LOAD_END))
             {
                 pBtn->state = sttRDY ;    // to do
-                pBtn->color =  BLUE;
+                pBtn->color =  colorON;
                 Pannel_Leds(THREAD_LOAD, MODE_ON);//AVI+
             }
             else
diff --git a/Software/Embedded_SW/Embedded/Modules/General/buttons.h b/Software/Embedded_SW/Embedded/Modules/General/buttons.h
index 4d0df69e1..70879f91a 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/buttons.h
+++ b/Software/Embedded_SW/Embedded/Modules/General/buttons.h
@@ -10,7 +10,7 @@ typedef enum
 typedef enum
 {
     colorOFF = 0,
-    BLUE,
+    colorON,
     BLINK,
     fastBILNK,
     BREATHING
diff --git a/Software/Embedded_SW/Embedded/Modules/General/process.c b/Software/Embedded_SW/Embedded/Modules/General/process.c
index 39e87ed6a..d62d117a0 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/process.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/process.c
@@ -258,14 +258,22 @@ uint32_t LoadProcessParamsFromFile(void)
         UploadProcessParametersRequest* request = upload_process_parameters_request__unpack(NULL, Bytes, buffer);
         ProcessParameters*  ProcessParams = request->processparameters;
 
-        if ((ProcessParams->dryerzone1temp > 0.1)&&(ProcessParams->headzone2temp > 0.1)&&(ProcessParams->headzone3temp > 0.1)&&(ProcessParams->headzone4temp > 0.1))//NOT turning off heaters
+        if ((request!= NULL)&&(ProcessParams!=NULL))
         {
-            Bytes = sizeof(ProcessParameters);
-            EraseFlashSection(PROCESS_PARAMETERS_MAP_IN_FLASH,Bytes+4);
-            ReadAppAndProgram(PROCESS_PARAMETERS_MAP_IN_FLASH, 4,&Bytes);
-            ReadAppAndProgram(PROCESS_PARAMETERS_MAP_IN_FLASH+4, Bytes, ProcessParams);
-            REPORT_MSG(Bytes,"ProcessParameters Bytes write to flash");
-            free (buffer);
+            if ((ProcessParams->dryerzone1temp > 0.1)&&(ProcessParams->headzone2temp > 0.1)&&(ProcessParams->headzone3temp > 0.1)&&(ProcessParams->headzone4temp > 0.1))//NOT turning off heaters
+            {
+                Bytes = sizeof(ProcessParameters);
+                EraseFlashSection(PROCESS_PARAMETERS_MAP_IN_FLASH,Bytes+4);
+                ReadAppAndProgram(PROCESS_PARAMETERS_MAP_IN_FLASH, 4,&Bytes);
+                ReadAppAndProgram(PROCESS_PARAMETERS_MAP_IN_FLASH+4, Bytes, ProcessParams);
+                REPORT_MSG(Bytes,"ProcessParameters Bytes write to flash");
+                free (buffer);
+            }
+        }
+        else
+        {
+            Report("process parameters not loaded",__FILE__,__LINE__,(int)request,RpWarning,(int)request,0);
+            return ERROR;
         }
     }
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
index 8e185750f..050bb65b8 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
@@ -196,11 +196,11 @@ void HeatersControlStop(void)
 //{eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_AN_ENCLOSURETEMP1,  0,40,true,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__MACHINE_INTERNAL_OVERTEMPERATURE      },
 //{eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_AN_ENCLOSURETEMP2,  1,40,true,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__MACHINE_INTERNAL_OVERTEMPERATURE      },
 typedef enum{
-    ENCLOSURE_INTERNAL_TEMP,
-    CABINET_INTERNAL_TEMP,
-    MAIN_CARD_INTERNAL_TEMP,
+    INTERNAL_ENCLOSURE_TEMP,
+    INTERNAL_CABINET_TEMP,
+    INTERNAL_MAIN_CARD_TEMP,
     MAX_INTERNAL_ALARMS
-};
+}InternalTemperatureTestPointsEnum;
 int InternalAlarmCounter[MAX_INTERNAL_ALARMS] = {0,0,0};
 uint32_t InternalId2PT100Id[MAX_INTERNAL_ALARMS] = {TEMP_SENSE_AN_ENCLOSURETEMP1,TEMP_SENSE_AN_ENCLOSURETEMP1,0xFF};
 int32_t    InternalOverHeatCounter [MAX_INTERNAL_ALARMS] = {0,0,0};
@@ -272,7 +272,7 @@ void HeatersControlStart(void)
         ReportWithPackageFilter(HeatersFilter,"HeatersControlStart ", __FILE__,__LINE__,0, RpMessage, 0, 0);
         HeatersRestart = true;
         HeatersStartControlTimer();
-        for (i = 0; i< MAX_INTERNAL_ALARMS;i++)
+        for (i = 0; i< (MAX_INTERNAL_ALARMS-1);i++)
         {
             if (ControlIdtoInternalId [i] == 0xFF)
             {
@@ -557,7 +557,7 @@ void PrepareACHeater(int HeaterId,uint32_t Frequency, uint32_t SetTemperatue)
             HeaterCmd[HeaterId].targettemperatue = 0;
             AlarmHandlingSetAlarm(HeaterEventType[HeaterId], true);
 
-            return ERROR;
+            return;
         }
 
     }
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h b/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h
index c31a1a72b..a919ce4e1 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h
@@ -42,7 +42,6 @@ void IDS_Dispenser_RefillStarted (char DispenserId,char  MicroSteps);
 void IDS_Dispenser_RefillEnded (char DispenserId,char  MicroSteps);
 
 //uint32_t IDS_Dispenser_Build_Pressure(int DispenserId, callback_fptr callback);
-uint32_t IDS_HomeDispenserWaitForHomingEnd(uint32_t DispenserId,  uint32_t timeout , callback_fptr callback);
 
 uint32_t IDS_Cleaning_Move_Rockers (int LeftRockerSpeed,int RightRockerSpeed);
 uint32_t IDS_Cleaning_Center_And_Stop_Rockers (int timeout,callback_fptr callback);
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
index 16545b27d..6c055c1a6 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
@@ -107,8 +107,9 @@ uint32_t IDS_Dispenser_Build_Pressure_Callback(uint32_t DispenserId, uint32_t Re
 
     Control3WayValvesWithCallback ((Valves_t)DispenserId, CloseValve, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
     if (DispenserControlId[DispenserId] != 0xFF)
-        Report("Cannot Add control callback",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0);
-
+    {
+        Report("Cannot Add control callback",__FILE__,(int)DispenserId,GetControlCallbackFuncPtr(DispenserControlId[DispenserId]),RpWarning,(int)DispenserControlId[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);
@@ -127,7 +128,7 @@ uint32_t IDS_Dispenser_Build_Pressure_Callback(uint32_t DispenserId, uint32_t Re
 
  uint32_t IDS_Dispenser_StopMotorCallback(uint32_t DispenserId, uint32_t ReadValue)
  {
-     //Report("IDS_Dispenser_Close_Valve_And_Stop_Motor callback",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)msec_millisecondCounter,0);
+     Report("IDS_Dispenser_Close_Valve_And_Stop_Motor callback",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)msec_millisecondCounter,0);
      if (SafeRemoveControlCallback(DispenserControlId[DispenserId], IDS_Dispenser_StopMotorCallback )==OK)
          DispenserControlId[DispenserId] = 0xFF;
      else
@@ -152,13 +153,13 @@ uint32_t IDS_Dispenser_Build_Pressure_Callback(uint32_t DispenserId, uint32_t Re
 
     Control3WayValvesWithCallback ((Valves_t)DispenserId, CloseValve, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
     if (DispenserControlId[DispenserId] != 0xFF)
-        Report("Cannot Add control callback",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0);
+        Report("Cannot Add control callback",__FILE__,(int)DispenserId,GetControlCallbackFuncPtr(DispenserControlId[DispenserId]),RpWarning,(int)DispenserControlId[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
-    //    Report("Add control callback",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0);
+    else
+        Report("Add control callback",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0);
 
     return OK;
 }
@@ -202,7 +203,7 @@ uint32_t IDS_Dispenser_Start_Motor_and_Open_Valve(int DispenserId, int MotorSpee
         MotorSetSpeed(HW_Motor_Id, MotorSpeed);
         CurrentDispenserSpeed[DispenserId] = MotorSpeed;
         if (DispenserControlId[DispenserId] != 0xFF)
-            Report("Cannot Add control callback",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0);
+            Report("Cannot Add control callback",__FILE__,(int)DispenserId,GetControlCallbackFuncPtr(DispenserControlId[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, TemplateDataReadCBFunction,DispenserId, DispenserId, 0 );
@@ -234,7 +235,7 @@ void IDS_Dispenser_Content_Init (void)
         dispenser_running_data__init(&IDS_Dispenser_Data[i]);
         dispenserdata[i] = &IDS_Dispenser_Data[i];
         IDS_Dispenser_Data[i].nanolitterperpulse = DEFAULT_NANOLITER_PER_PULSE;
-        IDS_Dispenser_Data[i].microsteps = MotorsCfg[HW_Motor_Id].microstep;;
+        IDS_Dispenser_Data[i].microsteps = MotorsCfg[HW_Motor_Id].microstep;
     }
     //==================================
 
@@ -294,9 +295,12 @@ uint32_t IDS_Dispenser_Store_Data (void)
 //    Report("IDS_Dispenser_Store_Data 0",__FILE__,(int)IDS_Dispenser_Data[0].totalconsumedinnanolitter,(int)IDS_Dispenser_Data[0].consumedinnanolitter,RpWarning,(int)IDS_Dispenser_Data[0].microsteps,0);
 //    Report("IDS_Dispenser_Store_Data 4",__FILE__,(int)IDS_Dispenser_Data[4].totalconsumedinnanolitter,(int)IDS_Dispenser_Data[4].consumedinnanolitter,RpWarning,(int)IDS_Dispenser_Data[4].microsteps,0);
         //response_size = dispenser_data__pack(&IDSDispenserData, response_buffer);
-    EraseFlashSection(DISPENSERS_MAP_IN_FLASH,response_size+4);
-    ReadAppAndProgram(DISPENSERS_MAP_IN_FLASH, 4,&response_size);
-    ReadAppAndProgram(DISPENSERS_MAP_IN_FLASH+4, response_size, IDS_Dispenser_Data);
+    if (JobIsActive()==false)
+    {
+        EraseFlashSection(DISPENSERS_MAP_IN_FLASH,response_size+4);
+        ReadAppAndProgram(DISPENSERS_MAP_IN_FLASH, 4,&response_size);
+        ReadAppAndProgram(DISPENSERS_MAP_IN_FLASH+4, response_size, IDS_Dispenser_Data);
+    }
 
     Status = FileWrite(IDS_Dispenser_Data,response_size,DispenserStorePath,BIOS_NO_WAIT);
     if (Status == FR_OK)
@@ -371,24 +375,6 @@ void IDS_Dispenser_RefillEnded (char DispenserId,char  MicroSteps)
     IDS_Dispenser_Data[DispenserId].consumedinnanolitter = 0;
     Report("IDS_Dispenser_RefillEnded",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)IDS_Dispenser_Data[DispenserId].numberofrefills,0);
 }
-void IDS_Dispenser_PrimingEnded (char DispenserId,char  MicroSteps)
-{
-    assert (DispenserId<MAX_SYSTEM_DISPENSERS);
-    /*IDS_Dispenser_Data[DispenserId].microsteps = MicroSteps;
-    IDS_Dispenser_Data[DispenserId].direction = 1;
-    IDS_Dispenser_Data[DispenserId].consumedinnanolitter = 0;*/
-    Report("IDS_Dispenser_PrimingEnded",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)IDS_Dispenser_Data[DispenserId].numberofrefills,0);
-}
-void IDS_Dispenser_PrimingStarted (char DispenserId,char  MicroSteps)
-{
-    assert (DispenserId<MAX_SYSTEM_DISPENSERS);
-    /*IDS_Dispenser_Data[DispenserId].microsteps = MicroSteps;
-    double assumedFlow = IDS_Dispenser_Data[DispenserId].microsteps*IDS_Dispenser_Data[DispenserId].nanolitterperpulse;
-    IDS_Dispenser_Data[DispenserId].nanolitterperpulse = assumedFlow;
-    IDS_Dispenser_Data[DispenserId].microsteps = 1;
-    IDS_Dispenser_Data[DispenserId].direction = 1;*/
-    Report("IDS_Dispenser_PrimingStarted",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)(CurrentDispenserSpeed[DispenserId]),0);
-}
 void DispenserDataRequestFunc(MessageContainer* requestContainer)
 {
     MessageContainer responseContainer;
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h
index b9ccdce27..51086b09e 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h
@@ -63,6 +63,7 @@ uint32_t IDS_DispenserControlInit();
 
 uint32_t IDS_HomeDispenser (uint32_t deviceID, uint32_t speed , callback_fptr callback);
 uint32_t IDS_StopHomeDispenser (uint32_t deviceID);
+uint32_t IDS_HomeDispenserWaitForHomingEnd(uint32_t DispenserId,  uint32_t timeout , callback_fptr callback);
 
 uint32_t IDS_EmptyDispenser (uint32_t deviceID, uint32_t speed , callback_fptr callback);
 uint32_t IDS_Dispenser_Alarm_On (uint8_t deviceID);
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
index bfece1890..0a2dff245 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
@@ -16,6 +16,7 @@
 #include "drivers/I2C_Communication/ADC_MUX/ADC_MUX.h"
 
 #include "drivers/FPGA/FPGA_GPIO/FPGA_GPIO.h"
+#include "drivers/FPGA/FPGA_SPI_Comm.h"
 #include "drivers/Motors/Motor.h"
 #include "drivers/Valves/Valve.h"
 
@@ -63,6 +64,8 @@ callback_fptr HomingBacklashCallback[MAX_SYSTEM_DISPENSERS]={0,0,0,0,0,0,0,0};
 uint32_t HomingBacklashTimeout[MAX_SYSTEM_DISPENSERS];
 uint32_t HomingBacklashTime[MAX_SYSTEM_DISPENSERS];
 
+int32_t KeepMicrostep[MAX_SYSTEM_DISPENSERS];
+
 bool HomingActive[MAX_SYSTEM_DISPENSERS] = {false,false,false,false,false,false,false,false};
 bool PrimingActive[MAX_SYSTEM_DISPENSERS] = {false,false,false,false,false,false,false,false};
 uint32_t DispenserHomingControlId[MAX_SYSTEM_DISPENSERS] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
@@ -140,7 +143,9 @@ uint32_t IDS_HomeDispenserBackMoveCallback(uint32_t motorId, uint32_t ReadValue)
     {
         MotorStop(motorId,Hard_Hiz);
         CurrentDispenserSpeed[DispenserId] = 0;
-        MotorSetMicroStep(motorId, MotorsCfg[motorId].microstep);
+        if (Extended_Motor_Param == true)
+            Combined_dispenser_Driver_Mode(DispenserId,Voltage);
+        MotorSetMicroStep(motorId, KeepMicrostep[DispenserId]);
         HomingActive[DispenserId]= false;
         PrimingActive[DispenserId]= false;
         Report("End backlash",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,(int)DispenserHomingTime[DispenserId],0);
@@ -164,7 +169,7 @@ uint32_t IDS_HomeDispenserCallback(uint32_t motorId, uint32_t ReadValue)
     //close dry air valve in the dispenser
     Valve_Set(IDS_Id_to_AirValve[DispenserId], Atm_MidTank_OFF);
     Disable_MidTank_Pressure_Reading(DispenserId);
-    //MotorSetMicroStep(motorId, MotorsCfg[motorId].microstep);
+    //    MotorSetMicroStep(motorId, KeepMicrostep[DispenserId]);
     if (HomingRequestCallback[DispenserId])
     {
         HomingRequestCallback[DispenserId](DispenserId,0);
@@ -186,6 +191,9 @@ uint32_t IDS_HomeDispenser (uint32_t DispenserId, uint32_t speed , callback_fptr
     assert(DispenserId < MAX_SYSTEM_DISPENSERS);
     //if (DispensersAlarmState[DispenserId] == true)
     //    return ERROR;
+
+    //if Safety is active
+        //if safety is upper position or
     if ((HomingActive[DispenserId] == true)||(PrimingActive[DispenserId] == true))
     {
         LOG_ERROR (DispenserId,"Homing already active");
@@ -201,7 +209,9 @@ uint32_t IDS_HomeDispenser (uint32_t DispenserId, uint32_t speed , callback_fptr
     {
         //open dispenser valve dispenser to midtank direction
         Control3WayValvesWithCallback ((Valves_t)DispenserId, MidTank_Dispenser, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
-        //Valve_Set((Valves_t) request->index, MidTank_Dispenser);
+        KeepMicrostep[DispenserId] = MotorsCfg[MotorId].microstep;
+        if (Extended_Motor_Param == true)
+            Combined_dispenser_Driver_Mode(DispenserId,Current);
         MotorSetMicroStep(MotorId, 1);
         SysCtlDelay(180000);
         //open dry air valve in the dispenser
@@ -224,7 +234,9 @@ uint32_t IDS_Dispenser_Alarm_On (uint8_t DispenserId)
     status |= MotorAbortMovetoLimitSwitch(MotorId);
     Valve_Set(IDS_Id_to_AirValve[DispenserId], Atm_MidTank_OFF);
     Enable_MidTank_Pressure_Reading(DispenserId);
-    status |= MotorSetMicroStep(DispenserId, MotorsCfg[DispenserId].microstep);
+    if (Extended_Motor_Param == true)
+        Combined_dispenser_Driver_Mode(DispenserId,Voltage);
+    status |= MotorSetMicroStep(MotorId, KeepMicrostep[DispenserId]);
     status |= MotorStop(DispenserId, Hard_Hiz);
     CurrentDispenserSpeed[DispenserId] = 0;
     JobEndReason = JOB_OUT_OF_DYE;
@@ -267,7 +279,9 @@ uint32_t IDS_StopHomeDispenser (uint32_t DispenserId)
             Lubricant_2Way_Valve (STOP);
         }
         PrimingActive[DispenserId] = false;
-        MotorSetMicroStep(MotorId, MotorsCfg[MotorId].microstep);
+        if (Extended_Motor_Param == true)
+            Combined_dispenser_Driver_Mode(DispenserId,Voltage);
+        MotorSetMicroStep(MotorId, KeepMicrostep[DispenserId]);
         CurrentDispenserSpeed[DispenserId] = 0;
         CurrentDispenserSpeed[DispenserId] = 0;
     }
@@ -294,7 +308,7 @@ uint32_t IDS_StopHomeDispenserBuildPressure (uint32_t DispenserId)
     //close dry air valve in the dispenser
     Valve_Set(IDS_Id_to_AirValve[DispenserId], Atm_MidTank_OFF);
     Disable_MidTank_Pressure_Reading(DispenserId);
-    //MotorSetMicroStep(motorId, MotorsCfg[motorId].microstep);
+    //    MotorSetMicroStep(motorId, KeepMicrostep[DispenserId]);
     if (HomingRequestCallback[DispenserId])
     {
         HomingRequestCallback[DispenserId](DispenserId,0);
@@ -340,14 +354,16 @@ uint32_t IDS_EmptyDispenserCallback(uint32_t motorId, uint32_t ReadValue)
 
     MotorStop(motorId,Hard_Hiz);
     CurrentDispenserSpeed[DispenserId] = 0;
-    MotorSetMicroStep(motorId, MotorsCfg[motorId].microstep);
+    if (Extended_Motor_Param == true)
+        Combined_dispenser_Driver_Mode(DispenserId,Voltage);
+    MotorSetMicroStep(motorId, KeepMicrostep[DispenserId]);
     PrimingActive[DispenserId]= false;
     if (DispenserId == LUBRICANT_DISPENSER)
     {
         Lubricant_2Way_Valve (STOP);
     }
     Report("End Priming",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,(int)DispenserHomingTime[DispenserId],0);
-    //MotorSetMicroStep(motorId, MotorsCfg[motorId].microstep);
+    //    MotorSetMicroStep(motorId, KeepMicrostep[DispenserId]);
     if (HomingRequestCallback[DispenserId])
     {
         HomingRequestCallback[DispenserId](DispenserId,0);
@@ -373,9 +389,12 @@ uint32_t IDS_EmptyDispenser (uint32_t DispenserId, uint32_t speed , callback_fpt
     {
         //open dispenser valve dispenser to midtank direction
         Control3WayValvesWithCallback ((Valves_t)DispenserId, Dispenser_Mixer, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
+        if (Extended_Motor_Param == true)
+            Combined_dispenser_Driver_Mode(DispenserId,Current);
         //Valve_Set((Valves_t) request->index, Dispenser_Mixer);
+        KeepMicrostep[DispenserId] = MotorsCfg[MotorId].microstep;
         MotorSetMicroStep(MotorId, 1);
-        SysCtlDelay(180000);
+        Task_sleep(100);
         //open dry air valve in the dispenser
         //Valve_Set(IDS_Id_to_AirValve[DispenserId], Atm_MidTank_ON);
         if (DispenserId == LUBRICANT_DISPENSER)
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
index 7a719d39a..0de3fa1f3 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
@@ -69,6 +69,7 @@ int JobBrushStopId = 0;
 int lInterSegmentLength = 0;
  int InterSegmentStepsLimit = 0,InterSegmentStepsCount = 0;
  bool PreSegmentWCFStarted = false;
+ bool PreSegmentPrepareStarted = false;
 
  uint32_t InterSegmentStartSprayCleaner = 0;
  uint32_t InterSegmentStartRocking = 0;
@@ -605,7 +606,7 @@ c.  Go to step 2.a x Segment.BrushStopsCount.
              {
                  NumofReadyDispensers++;
                  tempSpeed = CurrentDispenserSpeed[i];
-                 updatedSpeed = (tempSpeed*0.98>100)?tempSpeed*0.98:100;
+                 updatedSpeed = (tempSpeed*0.985>100)?tempSpeed*0.985:100;
                  MotorSetSpeed(HW_Motor_Id, updatedSpeed);
                  CurrentDispenserSpeed[i] = updatedSpeed;
                  //Report("IDS reduce speed",__FILE__,i,(int)tempSpeed,RpWarning,(int)updatedSpeed,0);
@@ -613,7 +614,7 @@ c.  Go to step 2.a x Segment.BrushStopsCount.
              else
              {
                  tempSpeed = CurrentDispenserSpeed[i];
-                 updatedSpeed = (tempSpeed*1.04<1000)?tempSpeed*1.04:1000;
+                 updatedSpeed = (tempSpeed*1.02<1000)?tempSpeed*1.02:1000;
                  MotorSetSpeed(HW_Motor_Id, updatedSpeed);
                  CurrentDispenserSpeed[i] = updatedSpeed;
                  //Report("IDS accelerate speed",__FILE__,i,(int)tempSpeed,RpWarning,(int)updatedSpeed,0);
@@ -648,7 +649,7 @@ c.  Go to step 2.a x Segment.BrushStopsCount.
     IDS_Active = true;
     Valve_Set(VALVE_MIXCHIP_WASTECH, Mixer_Waste);
 
-    JobTicket* JobTicket = JobDetails;
+    //JobTicket* JobTicket = JobDetails;
 
 
     for (Motor_i = 0;Motor_i < MAX_SYSTEM_DISPENSERS;Motor_i++)
@@ -813,7 +814,7 @@ c.  Go to step 2.a x Segment.BrushStopsCount.
           Report("IDS_PreSegmentPrepare_Callback SafeRemoveControlCallback",__FILE__,DispenserPrepareControlId,InterSegmentStepsCount,RpWarning,(int)NumOfActiveDispensers,0);
           SafeRemoveControlCallback(DispenserPrepareControlId, IDS_Prepare_Callback );
           DispenserPrepareControlId = 0xFF;
-
+          PreSegmentWCFStarted = true;
           setRapidPressureRead(false);
       }
       return OK;
@@ -955,6 +956,7 @@ uint32_t IDS_Cleaning_Stop_Cleaning_Solution (callback_fptr callback);
      {
          //IDS_Valve_PresegmentReady(1,0);
          Report("End of Pre-segment Handling",__FILE__,__LINE__,InterSegmentStepsCount,RpWarning,(int)lInterSegmentLength,0);
+         //PreSegmentReady(Module_IDS,ModuleDone);
          SafeRemoveControlCallback(DispenserPreSegmentControlId,IDSPreSegmentStateCallbackRunner);
          setRapidPressureRead(false);
      }
@@ -977,14 +979,21 @@ uint32_t IDS_Cleaning_Stop_Cleaning_Solution (callback_fptr callback);
              //IDS_Cleaning_Center_And_Stop_Rockers (int timeout,callback_fptr callback);
          }
      }
-     if (PreSegmentWCFStarted == false)
+     if ((InterSegmentStartWFCFDispensers > 12000)&&(InterSegmentStartWFCFDispensers == (InterSegmentStepsCount+12000)))
+     {
+	 	//start prepare 4 seconds before wcf
+         IDSPresegmentPrepareStart();
+         PreSegmentPrepareStarted = true;
+     }
+     if ((PreSegmentWCFStarted == false)&&(PreSegmentPrepareStarted == true))
      {
          IDS_PreSegmentPrepare_Callback(0,0);
      }
-     if ((InterSegmentStartWFCFDispensers > 0)&&(InterSegmentStartWFCFDispensers == (lInterSegmentLength-InterSegmentStepsCount)))
+     if ((InterSegmentStartWFCFDispensers > 0)&&(InterSegmentStartWFCFDispensers == InterSegmentStepsCount))
      {
          Report("start dispensers at rate * WFCF",__FILE__,__LINE__,InterSegmentStepsCount,RpWarning,(int)lInterSegmentLength,0);
          PreSegmentWCFStarted = true; // stop any presegment prepare stages, if still exist
+         PreSegmentPrepareStarted = false;
          setRapidPressureRead(false);
          if (FileBrushStop)
          {
@@ -1044,6 +1053,11 @@ uint32_t IDS_Cleaning_Stop_Cleaning_Solution (callback_fptr callback);
          }
          //startDispensersAtSegmentSpeed*1=WFCFClenerSpray(speed);
      }
+     if ((InterSegmentStartWFCFDispensers > 0)&&((lInterSegmentLength-1000) == InterSegmentStepsCount))
+     {
+         //close waste valve one second before segment - trial
+         Valve_Set(VALVE_MIXCHIP_WASTECH, Mixer_Head);
+     }
      return OK;
  }
 uint32_t IDSCheckSegmentData(void *SegmentDetails, int SegmentId)
@@ -1235,9 +1249,10 @@ uint32_t IDSPreSegmentState(void *SegmentDetails, int SegmentId)
     }
     //Task_sleep(5);
     PreSegmentWCFStarted = false;
+    PreSegmentPrepareStarted = false;
     REPORT_MSG(PreSegmentWCFStarted,"START IDSPresegmentPrepareStart");
 
-    IDSPresegmentPrepareStart();
+//    IDSPresegmentPrepareStart();
     return OK;
 }
 //********************************************************************************************************************
@@ -1480,8 +1495,10 @@ 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);
-
+#ifdef AUTO_HOME_DISPENSERS
+     if (deviceID!=LUBRICANT_DISPENSER)
+     IDS_HomeDispenser (deviceID, 1000 , NULL);
+#endif
      return OK;
  }
 //********************************************************************************************************************
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
index 5c56bcaa5..b47c49cc0 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
@@ -37,6 +37,26 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
         response.has_progress = true;
     }
     else
+    if((request->amount == 0x01) && ((request->delay &0x010000) == 0x010000)) //change mode powerset01
+    {
+        response.progress = Power_Step_01_Mode(((request->delay &0x00FF00)>>8), request->delay &0x0000FF);
+        response.has_progress = true;
+    }
+    else
+    if((request->amount == 0xAB) && (request->delay == 0xAB)) //Get pressure with flow (orifice flow meter)
+    {
+        response.progress = Calculate_Pitot_Pressure(true);
+        response.has_progress = true;
+
+    }
+    else
+        if((request->amount == 0xAB) && (request->delay == 0x0)) //measured sensor voltage without flow (orifice flow meter)
+    {
+        response.progress = Calculate_Pitot_Pressure(false);
+        response.has_progress = true;
+
+    }
+    else
     if((request->amount == 0x5C4E) && (request->delay == 0x5C4E)) //Screw Home Pos dir
         {
             test_Home_Pos();
@@ -92,6 +112,14 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
         response.has_progress = true;
 
     }
+    else
+    if(request->amount == 0x0CC)  //Cùøàøïâò÷ Vùêïâùàïíî ø÷ãôíîã÷
+    {
+		ResponseDemo(request->delay);
+        response.progress = (double)OK;
+        response.has_progress = true;
+
+    }
     else     if((request->amount == 0xDF) && (request->delay == 0xDF)) //Power off
     {
         PowerOffInit();
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Dispenser.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Dispenser.c
index f3efa3b67..a548ce6f6 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Dispenser.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Dispenser.c
@@ -34,34 +34,34 @@ void Stub_DispenserRequest(MessageContainer* requestContainer)
     SysCtlDelay(100000);
 */
 
-    TCA9534Regs Regs;
+    //TCA9534Regs Regs;
 
     //static bool first_time = true;
 
     //if(first_time == true)
     //if ((Regs.Config[request->dispenserid].bit.DISP_DOWN != TCA9534_INPUT) || (Regs.Config[request->dispenserid].bit.DISP_UP!= TCA9534_INPUT))
     //{
-        status |= TCA9534Init(request->dispenserid, &Regs);
+        status |= TCA9534Init(request->dispenserid/*, &Regs*/,true);
         //first_time = false;
     //}
 
     if(request->setdirection == true)
     {
-        TCA9534TestRelay(request->dispenserid, &Regs,ENABLE);
+        TCA9534TestRelay(request->dispenserid/*, &Regs*/,ENABLE);
     }
     else
-        TCA9534TestRelay(request->dispenserid, &Regs,DISABLE);
+        TCA9534TestRelay(request->dispenserid/*, &Regs*/,DISABLE);
 
     delayms(5);
 
 
      if(request->start == true)
      {
-        TCA9534ByPass(request->dispenserid, &Regs, ENABLE);
+        TCA9534ByPass(request->dispenserid/*, &Regs*/, ENABLE);
 
      }
      else
-        TCA9534ByPass(request->dispenserid, &Regs, DISABLE);
+        TCA9534ByPass(request->dispenserid/*, &Regs*/, DISABLE);
 
      delayms(5);
 
@@ -88,16 +88,16 @@ void Stub_DispenserRequest(MessageContainer* requestContainer)
 
 
     status |= TCA9534SetReadInputReg(request->dispenserid);
-    status |= TCA9534ReadInputReg(request->dispenserid, &Regs);
+    status |= TCA9534ReadInputReg(request->dispenserid/*, &Regs*/);
 
 	
 	response.dispenserid = request->dispenserid;
 	response.has_dispenserid = true;
 	
-	response.dispenserposition = (Read_Notification_Disp_UP(request->dispenserid, &Regs) << 8) | (Read_Notification_Disp_Down(request->dispenserid, &Regs));
+	response.dispenserposition = (Get_Notification_Disp_UP(request->dispenserid/*, &Regs*/) << 8) | (Get_Notification_Disp_Down(request->dispenserid/*, &Regs*/));
 	response.has_dispenserposition = true;
 
-	response.inkworninglevel = (Read_Notification_Realy_On(request->dispenserid, &Regs) << 8) | (Read_Notification_Over_Press(request->dispenserid, &Regs));
+	response.inkworninglevel = (Get_Notification_Realy_On(request->dispenserid/*, &Regs*/) << 8) | (Get_Notification_Over_Press(request->dispenserid/*, &Regs*/));
 	response.has_inkworninglevel = true;
 	
 	status_response(status,&response.status, &response.statusword ,&response.has_statusword);
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
index 7d4b66dfb..1f9897905 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
@@ -17,6 +17,9 @@
 #include "Modules/General/process.h"
 #include "Modules/control/pidalgo.h"
 
+#include "Modules/heaters/heaters_ex.h"
+#include "StateMachines/Initialization/InitSequence.h"
+
 #include "PMR/Hardware/HardwareMotor.pb-c.h"
 #include "PMR/Hardware/HardwareMotorType.pb-c.h"
 #include "PMR/Hardware/HardwareDancerType.pb-c.h"
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
index 7e1312464..e01d12a05 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
@@ -59,10 +59,11 @@ static uint32_t WindingConeLocation;
 static uint32_t WinderBackToBaseTime = 800;
 
 InternalWinderConfigStruc InternalWinderCfg = {0};
-
+#define READ_SCREW_ENCODER
+#ifdef READ_SCREW_ENCODER
 uint32_t ScrewLocationLimitSwitch = 0,ScrewLocationStart = 0;
 uint32_t ScrewLocationRun[3];
-
+#endif
 bool SampleWinding = false;
 uint32_t Winder_Init(void)
 {
@@ -89,6 +90,8 @@ uint32_t InternalWinderConfigMessage(HardwareWinder* request)
 
     return status;
 }
+char ScrewStr[150];
+
 uint32_t InternalWindingConfigMessage(JobSpool* request)
 {
     uint32_t status = PASSED;
@@ -99,6 +102,9 @@ uint32_t InternalWindingConfigMessage(JobSpool* request)
     InternalWinderCfg.SpoolBottomBackingRate =  request->bottombackingrate;
     InternalWinderCfg.NumberOfRotationPerPassage = 3.1415926*2;//request->rotationsperpassage;
     InternalWinderCfg.diameter = request->diameter;
+    usnprintf(ScrewStr, 150, "WindingConfig start,offset,head,tail {, %d, %d, %d, %d, %d}",InternalWinderCfg.startoffsetpulses,(int)InternalWinderCfg.segmentoffsetpulses,
+              (int)InternalWinderCfg.spoolbackingrate,(int)InternalWinderCfg.SpoolBottomBackingRate);
+    Report(ScrewStr,__FILE__,__LINE__,(int)InternalWinderCfg.diameter,RpWarning,(int)(InternalWinderCfg.NumberOfRotationPerPassage*1000), 0);
 
     return status;
 }
@@ -132,8 +138,10 @@ uint32_t Winder_Prepare(void *JobDetails)
         return ERROR;
     }*/
 
+#ifdef READ_SCREW_ENCODER
     ScrewLocationRun[0] = 0;
     ScrewLocationRun[1] = 0;
+#endif
     if (( KeepWindingCone == false)||(WindingConeLocation == 0))
     {
        WindingConeLocation = InternalWinderCfg.startoffsetpulses;
@@ -176,10 +184,11 @@ uint32_t Winder_PrepareStage2(uint32_t deviceID, uint32_t ReadValue)
 
     //MotorSetMaxSpeed (HARDWARE_MOTOR_TYPE__MOTO_SCREW,InternalWinderCfg.segmentoffsetpulses);
     //REPORT_MSG(numOfSteps, "Winder_PrepareStage2");
+#ifdef READ_SCREW_ENCODER
     Read_Screw_Encoder();
     ScrewLocationLimitSwitch = Screw_RotEnc.Position;
     REPORT_MSG(ScrewLocationLimitSwitch, "Winder_PrepareStage2 Encoder Location");
-
+#endif
 
     REPORT_MSG(millisecondCounter/*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].maxfrequency*/, "Winder_PrepareStage2");
     if (ReadValue != LIMIT)
@@ -203,6 +212,7 @@ uint32_t Winder_ScrewAtOffsetCallback(uint32_t deviceID, uint32_t BusyFlag)
 
     MotorStop (HARDWARE_MOTOR_TYPE__MOTO_SCREW,Soft_Hiz); //per L6470 errata between mov and run commands
     Task_sleep(5);
+#ifdef READ_SCREW_ENCODER
     Reset_Screw_Encoder();
     Task_sleep(5);
     Read_Screw_Encoder();
@@ -210,10 +220,13 @@ uint32_t Winder_ScrewAtOffsetCallback(uint32_t deviceID, uint32_t BusyFlag)
     ScrewLocationStart = Screw_RotEnc.Position;
 
     REPORT_MSG(ScrewLocationStart, "Winder_ScrewAtOffsetCallback Encoder Location");
+#endif
     SetMotHome(HARDWARE_MOTOR_TYPE__MOTO_SCREW);  //set this point as the spool home
 
     ScrewCurrentDirection = false;
+#ifdef READ_SCREW_ENCODER
     ScrewLocationRun[ScrewCurrentDirection] = Screw_RotEnc.Position;
+#endif
     ScrewSpeed = 0;
     ScrewControlId = 0xFF;
     ScrewNumberOfSteps = 0;
@@ -249,7 +262,7 @@ InternalWinderCfg.segmentoffsetpulses
   
 numOfSteps = InternalWinderCfg.startoffsetpulses*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].microstep;
 */
-char ScrewStr[150];
+
 //char TempScrewStr[100];
 double WinderReferenceSpeed=0;
 double  TotalWinderSpeed=0;
@@ -259,13 +272,17 @@ int flipflop = 0;
 uint32_t motspeed;
 float speedf;
 int WinderCalculation = 0;
+#ifdef READ_SCREW_ENCODER
+float WinderRunAverage = 0.0,WinderRunSum = 0.0;
+int WinderRunSamples = 0;
+#endif
 uint32_t Screw100msecDirectionChange(uint32_t deviceID, uint32_t BusyFlag)
 {
     //uint32_t Steps;
     double temp,tempScrewSpeed;
     double screw_horizontal_speed = 0;
     double RotationsPerSecond;
-    double Averagewinderspeed = 0;
+    //double Averagewinderspeed = 0;
 
 //    {
 //        TotalWinderSpeed-=WinderMotorSpeed[WinderMotorSpeedCounter];
@@ -302,13 +319,29 @@ uint32_t Screw100msecDirectionChange(uint32_t deviceID, uint32_t BusyFlag)
     if (SampleWinding)
         return OK;
     //double calcsteps = (ScrewRunningTime/SYS_CLK_FREQ)*ScrewSpeed;
-    //REPORT_MSG((abs(ScrewLocationRun[1] - ScrewLocationRun[0]), "Screw Run NumberOfSteps");
-//    usnprintf(ScrewStr, 100, "Winder Encoder: 0 0x%x 1 0x%x diff %d intent %d rot %d",ScrewLocationRun[0],ScrewLocationRun[1],abs(ScrewLocationRun[1] - ScrewLocationRun[0]),ScrewNumberOfSteps,Rotations*10);
+#ifdef READ_SCREW_ENCODER
+    int WinderRun;
+     WinderRun = abs(ScrewLocationRun[1] - ScrewLocationRun[0]);
+     if ((WinderRun < 50000)&&(Add100 == false))
+     {
+         WinderRunSum+=WinderRun;
+         WinderRunSamples++;
+         WinderRunAverage = WinderRunSum/WinderRunSamples;
+         if ((fabs(WinderRun-WinderRunAverage)>=30)||(WinderRunSamples%100 == 0))
+         {
+             usnprintf(ScrewStr, 150, "curr,sum,avg,samples {Winder Encoder:, %d, %d, %d, %d, %d}",WinderRun,(int)WinderRunSum,(int)WinderRunAverage,(int)WinderRunSamples,
+                       (int)(100*WinderRun/ScrewNumberOfSteps));
+             Report(ScrewStr,__FILE__,__LINE__,CalculationDirectionChangeCounter,RpWarning,ScrewLocationStart, 0);
+         }
+     }
+         //Report(ScrewStr,__FILE__,__LINE__,CalculationDirectionChangeCounter,RpWarning,ScrewLocationStart, 0);
+    //REPORT_MSG(abs(ScrewLocationRun[1] - ScrewLocationRun[0]), "Screw Run NumberOfSteps");
+    //usnprintf(ScrewStr, 100, "Winder Encoder: 0 0x%x 1 0x%x diff %d intent %d rot %d",ScrewLocationRun[0],ScrewLocationRun[1],abs(ScrewLocationRun[1] - ScrewLocationRun[0]),ScrewNumberOfSteps,Rotations*10);
     //usnprintf(ScrewStr, 150, "Winder Encoder:id, diff, intended,  winderspeed,  rotation, speed, time, mot speed {, %d, %d, %d, %d, %d, %d, %d, %d, }",CalculationDirectionChangeCounter,
     //          abs(ScrewLocationRun[1] - ScrewLocationRun[0]),ScrewNumberOfSteps,(int)(WinderReferenceSpeed),(int)(Rotations*10),(int)ScrewSpeed,(int)ScrewRunningTime,(int)speedf);
     //usnprintf(ScrewStr, 100, "Winder Encoder: 0 %d 1 %d diff %d ",ScrewLocationRun[0],ScrewLocationRun[1],ScrewLocationRun[1] - ScrewLocationRun[0]);
     //Report(ScrewStr,__FILE__,__LINE__,CalculationDirectionChangeCounter,RpWarning,ScrewLocationStart, 0);
-
+#endif
     if (ScrewCurrentDirection == 1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].directionthreadwize) //next time going out
     {
         if (Add100 == true) //once per job
@@ -617,11 +650,13 @@ void ScrewTimerInterrupt(int ARG0)
 
     if (SCREW_TimerActivated == true)
     {
-        Read_Screw_Encoder();
         ROM_TimerLoadSet(Screw_timerBase, TIMER_A,(int)ScrewRunningTime);
         MotorSetDirection (HARDWARE_MOTOR_TYPE__MOTO_SCREW, ScrewCurrentDirection);
         MotorSetSpeedDirect(HARDWARE_MOTOR_TYPE__MOTO_SCREW,ScrewSpeed);
+#ifdef READ_SCREW_ENCODER
+        Read_Screw_Encoder();
         ScrewLocationRun[ScrewCurrentDirection] = Screw_RotEnc.Position;
+#endif
       //  ScrewChangeCounter = 0;
       //  ScrewChangeLimit = ScrewRunningTime/12000000;
         ScrewDirectionChangeCounter++;
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
index a88ce61a5..59542ec38 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
@@ -288,7 +288,6 @@ uint32_t PoolerThreadLengthCBFunction(uint32_t IfIndex, uint32_t ReadValue)
 
     //}
 
-    length = (double)(positionDiff)*PoolerLengthCalculationMultiplier;
     PoolerTotalProcessedLength+= (length/100);
     TempPoolerTotalProcessedLength = PoolerTotalProcessedLength;
 #ifndef FEEDER_LENGTH_CALCULATION
@@ -452,7 +451,7 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
     //read value is the dancer angle
     int i,index=MAX_THREAD_MOTORS_NUM;
     int DancerId;
-    int32_t TranslatedReadValue, avreageSampleValue = 0,avreageMotorSampleValue = 0;
+    int32_t TranslatedReadValue, avreageSampleValue = 0;//,avreageMotorSampleValue = 0;
     //double tempcalcspeed = 0;
     double calculated_speed;
     double NormalizedError;
diff --git a/Software/Embedded_SW/Embedded/Modules/Waste/Waste.h b/Software/Embedded_SW/Embedded/Modules/Waste/Waste.h
index a0a758b94..39894ce2d 100644
--- a/Software/Embedded_SW/Embedded/Modules/Waste/Waste.h
+++ b/Software/Embedded_SW/Embedded/Modules/Waste/Waste.h
@@ -24,10 +24,23 @@
 
 typedef unsigned char U8;
 
+
+typedef enum
+{
+    BLACK,
+    CYAN,
+    MAGENTA,
+    YELLOW,
+    TRANSPARENT,
+    SP_1,
+    CLEANER,
+    LUBRICANT
+} CMYK_color;
+
 typedef enum
 {
-    WHS_CarteidgeNotPrecense = 0,
-    WHS_CarteidgePrecense
+    CarteidgeNotPrecense = 0,
+    CarteidgePrecense
 } WHS_CarteidgPrecenseSensorStatus;
 
 typedef enum
@@ -55,7 +68,8 @@ typedef enum
     WHS_emptying,
     WHS_full,
     WHS_overflow,
-    WHS_sttError
+    WHS_sttError,
+    INK_isOK
 } WHS_sttMachin;
 
 typedef enum
@@ -64,21 +78,44 @@ typedef enum
     WHS_overflow_sensor,
     WHS_full_sensor,
     WHS_empty_sensor,
+    IFS_INK_presence_sensor,
+    IFS_INK_authentication_pass,
+    IFS_INK_authentication_fail,
     WHS_waste1_presence_sensor,
     WHS_waste2_presence_sensor,
     WHS_filter_sensor,
     WHS_cartridge_cover_sensor,
-    WHS_Timeout
+    WHS_Timeout,
+    IFS_Timeout,
+    IFS_Timeout_Second,
+    IFS_MidTankFull
 } WHS_sensor;
 
 typedef enum
 {
-    WasteEmpty = 0,
+   // WasteEmpty = 0,
+   // WasteFilling,
+   // WasteFail,
+    ColorFull = 0,
+    ColorUsed,
+    WasteEmpty,
     WasteFilling,
-    WasteFail,
-    WasteFull
+    WasteFull,
+    WasteFail
 } cartridge_status;
 
+//typedef enum
+//{
+//    midtank1 = 0,
+//    midtank2,
+//    midtank3,
+//    midtank4,
+//    midtank5,
+//    midtank6,
+//    midtank7,
+//    midtank8
+//} cartridge_color_to_midtank;
+
 typedef enum
 {
     led_on = 0,
@@ -89,9 +126,10 @@ typedef enum
 
 typedef enum
 {
-    waste_cartridge1 = 0,
-    waste_cartridge2,
-    no_waste_cartridge
+    no_waste_cartridge = 0,
+    INK_cartridge    ,
+    waste_cartridge1 ,
+    waste_cartridge2
 } cartridge_name;
 
 
@@ -109,6 +147,14 @@ bool WHS_IsValveOpen();
 
 bool SetWastePump( bool power);
 
+void midtanktest6_ON();
+void midtanktest6_OFF();
+
+bool CartridgeValidationResponseFunc(MessageContainer* requestContainer);
+void ResponseDemo(int MidtankId);
+
+bool RdInkCartridgeSensor();
+
 
 #endif
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Waste/Waste_init.c b/Software/Embedded_SW/Embedded/Modules/Waste/Waste_init.c
index 962b941af..5dedfda85 100644
--- a/Software/Embedded_SW/Embedded/Modules/Waste/Waste_init.c
+++ b/Software/Embedded_SW/Embedded/Modules/Waste/Waste_init.c
@@ -7,11 +7,19 @@
 #include "drivers/Valves/Valve.h"
 #include "Common/report/report.h"
 #include "Modules/Waste/Waste.h"
+#include "Modules/IFS/RfidTagContent.h"
 
 #include  <PMR/Diagnostics/EventType.pb-c.h>
 #include "Modules/AlarmHandling/AlarmHandling.h"
+#include "StateMachines/Initialization/PowerOffSequence.h"
+#include "drivers/I2C_Communication/ADC_MUX/ADC_MUX.h"
+#include "CartridgeValidationRequest.pb-c.h"
+#include "CartridgeValidationResponse.pb-c.h"
+#include "Modules/General/buttons.h"
 
-
+#define CARTRIDGE_INK_TIMEOUT           60
+#define CARTRIDGE_INK_TIMEOUTx2         120
+#define CartridgeInkTimeOutCallBackTime eOneSecond
 #define WasteTankCallBackTime           eOneSecond
 #define CartridgeCoverCallBackTime      eOneSecond
 #define CartridgeCoverCallBackFastTime  eTenMillisecond
@@ -19,20 +27,26 @@
 #define CartridgeWaste2CallBackTime     eOneSecond
 #define STARTCOUNT  1
 #define STOPCOUNT   0
-#define PumpTimeout 1200 //  seconds; 20 minutes, per Moty,  15/4/19
+#define PUMPTIMEOUT 1200 //  seconds; 20 minutes, per Moty,  15/4/19
+#define MidTank_Pressure_EMPTY 1000  //todo get from Moti the correct number
 
+#define CARTRIDGE_CAPATICY 1500 //liters
+#define FULL 1000
 
 /*------------Waste Tank function-----------------------*/
 bool initWHS_WasteTank();
-bool InitWasteCartStatus();
+bool InitCartStatus();
 
 bool CartridgeCoverCBFunction();
 U8 CartridgeCoverCallBackFunction();
+WHS_sensor CartridgeInkCallBackFunction();
 WHS_sensor CartridgeWaste1CallBackFunction();
 WHS_sensor CartridgeWaste2CallBackFunction();
 WHS_sensor WasteTankCallBackFunction();
 U8 CartridgeWasteFilling(bool status);
 bool WasteTankCBFunction();
+WHS_sensor CartridgeInkTimeOutCallBackFunction();
+
 
 U8 CartridgePrecenceCBFunction();
 U8 SetCartridgeLED(cartridge_name name,led_status led);
@@ -40,24 +54,29 @@ U8 SetCartridgeLED(cartridge_name name,led_status led);
 bool SetWastePump( bool power);
 bool SetValveDirection();
 bool RdCartridgeCoverSensor();
+
 bool RdWasteCartridge1Sensor();
 bool RdWasteCartridge2Sensor();
 bool RdWasteTankFilterSensor();
 bool RdWasteTankOverFlowSensor();
 bool RdWasteTankFullSensor();
 bool RdWasteTankEmptySensor();
-bool RdWasteCartridgeParam(cartridge_name cart_name);
+bool RdCartridgeParam(cartridge_name cart_name);
 bool CartridgeAuthentication(cartridge_name cart_name);
 bool SetActiveWastCartridge();
 
 
 
+//bool PowerOffInProcessGetState();
+
 
-struct waste_cartridge_params
+struct cartridge_params
 {
     uint32_t serial_number;
-    cartridge_status status;  /*WasteEmpty, WasteFilling, WasteFail, WasteFull*/
+    cartridge_status status;  /*WasteEmpty, WasteFilling, WasteFail, WasteFull.......  */
+    MidTank_t cart_color;
     bool autheticate;
+    uint32_t time_out;
 };
 
 struct pump_params
@@ -70,6 +89,8 @@ struct pump_params
 struct WHS_sensors_status
 {
     WHS_CarteidgeCoverSensorStatus cartridge_cover;                       /*open(1)          ,close(0)           */
+    WHS_CarteidgPrecenseSensorStatus IFS_Ink_precense_sensor;      /*presence(1)      ,not_precense(0)    */
+    bool IFS_Ink_precense_sensor_flag; /* 1=event          0=no enent */
     WHS_CarteidgPrecenseSensorStatus waste_cartridge1_precense_sensor;      /*presence(1)      ,not_precense(0)    */
     bool waste_cartridge1_precense_sensor_flag; /* 1=event          0=no enent */
     WHS_CarteidgPrecenseSensorStatus waste_cartridge2_precense_sensor;      /*presence(1)      ,not_precense(0)    */
@@ -85,18 +106,32 @@ struct WHS_sensors_status
 struct WHS_information
 {
     WHS_sttMachin sttMachine;
-    struct waste_cartridge_params cartridge_1, cartridge_2;
+    struct cartridge_params Ink, cartridge_1, cartridge_2;
     struct WHS_sensors_status WHS_sensors;
     struct pump_params WHS_pump;
     bool WHS_valve;
     WHS_sensor event;
     cartridge_name active_cartridge;
+    uint32_t Cartridge_Ink_device_Id;
+    uint32_t Cartridge_Ink_TimeOut_device_Id;
     uint32_t Cartridge_Waste1_device_Id;
     uint32_t Cartridge_Waste2_device_Id;
     uint32_t Cartridge_Cover_device_Id;
+    //PBcolor Ink_Led, cartridge_1_Led, cartridge_2_Led;
+    double MidTank_capacity;
 };
 
 struct WHS_information WHS_info;
+RfidTagContent cartridge_info;
+
+// function for RFID:
+bool WrRFIDStatus(cartridge_name active_cartridge, cartridge_status status);
+cartridge_status RdRFIDStatus (cartridge_name active_cartridge);
+bool RD_MID_TANK_Level();
+
+//bool PowerOffInProcessGetState() {return OK;}; //todo
+bool WrRFIDStatus(cartridge_name active_cartridge, cartridge_status status)  { return OK;} //todo
+cartridge_status RdRFIDStatus (cartridge_name active_cartridge)  { return WasteEmpty; }  //todo
 
 bool WHS_IsContainerFull(){return WHS_info.WHS_sensors.waste_tank_full_sensor;}
 bool WHS_IsContainerEmpty(){return WHS_info.WHS_sensors.waste_tank_empty_sensor;}
@@ -106,8 +141,68 @@ bool WHS_WasteCartridgeLowerPresent(){return WHS_info.WHS_sensors.waste_cartridg
 bool WHS_WasteCartridgeMiddlePresent(){return WHS_info.WHS_sensors.waste_cartridge2_precense_sensor;}
 bool WHS_IsPumpActive(){return WHS_info.WHS_pump.status;}
 bool WHS_IsValveOpen(){return WHS_info.WHS_valve;}
+bool RD_MID_TANK_Level(){return 0 /* FULL*/ ;}
+bool ColorMatch();
+bool MidTankValvesAction(bool action);
+bool IFS_TimeOutAlarm();
+
+bool IFS_TimeOutAlarm()
+{
+    bool ret =  OK;
+        switch (WHS_info.Ink.cart_color) //todo enter the correct color from RFID
+        {
+            case 1 :
+                AlarmHandlingSetAlarm( EVENT_TYPE__MID_TANK_1_FILL_TIMEOUT,  true);
+                break;
+            case 2 :
+                AlarmHandlingSetAlarm( EVENT_TYPE__MID_TANK_2_FILL_TIMEOUT,  true);
+               break;
+            case 3 :
+                AlarmHandlingSetAlarm( EVENT_TYPE__MID_TANK_3_FILL_TIMEOUT,  true);
+                break;
+            case 4 :
+                AlarmHandlingSetAlarm( EVENT_TYPE__MID_TANK_4_FILL_TIMEOUT,  true);
+               break;
+            case 5 :
+                AlarmHandlingSetAlarm( EVENT_TYPE__MID_TANK_5_FILL_TIMEOUT,  true);
+               break;
+            case 6 :
+                AlarmHandlingSetAlarm( EVENT_TYPE__MID_TANK_6_FILL_TIMEOUT,  true);
+               break;
+            case 7 :
+                AlarmHandlingSetAlarm( EVENT_TYPE__MID_TANK_7_FILL_TIMEOUT,  true);
+                break;
+            case 8 :
+                AlarmHandlingSetAlarm( EVENT_TYPE__MID_TANK_8_FILL_TIMEOUT,  true);
+               break;
+            default: //wrong color
+                ret = notOK;
+                break;
+        }
+
+        return ret;
+}
+
+
+
+bool MidTankValvesAction(bool action) //Cartridge_MidTank_ON of Cartridge_MidTank_OFF
+{
+    bool ret =  false;
 
+    Valve_Set(IDS_Id_to_AirValve[WHS_info.Ink.cart_color], action );   //Atm_MidTank_OFF/ON
+    Valve_Set(IDS_Id_to_CartrideValve[WHS_info.Ink.cart_color], action );   //Atm_MidTank_OFF/ON
 
+    ret = true;
+    return ret;
+}
+
+bool ColorMatch()
+{
+    bool ret =  false;
+
+    ret = true;
+    return ret;
+}
 
 bool WHS_IsEmptying()
 {
@@ -119,10 +214,96 @@ bool WHS_IsEmptying()
     return ret;
 }
 
+char CartridgeRequestToken[36+1];
+int  CartridgeRequestId = 0x01010101;
 /* --------    cartridge function  ----*/
+uint32_t ReadCartridgeData(cartridge_name cart_name)
+{
+    //this function triggers reading and validation of the cartridge information
+    // for now it sends a request to the tablet to inquire for the ink color/midtank id
+    MessageContainer responseContainer;
+    CartridgeValidationRequest ValidationReq = CARTRIDGE_VALIDATION_REQUEST__INIT;
+    Cartridge CartridgeData;
+
+    strcpy(CartridgeRequestToken,"Happy days are coming to us, soon");
+    memcpy(&CartridgeRequestToken[32],&CartridgeRequestId,sizeof(CartridgeRequestId));
+    CartridgeRequestId++;
+
+    cartridge__init(&CartridgeData);
+    CartridgeData.has_slot = true;
+    CartridgeData.slot = CARTRIDGE_SLOT__Ink;
+    CartridgeData.tag = 0;
+    CartridgeData.has_index = false;
+
+    ValidationReq.has_action = true;
+    ValidationReq.action = CARTRIDGE_ACTION__Inserted;
+
+    ValidationReq.cartridge = &CartridgeData;
 
+    responseContainer = createContainer(MESSAGE_TYPE__CartridgeValidationRequest, CartridgeRequestToken, true, &ValidationReq, &cartridge_validation_request__pack, &cartridge_validation_request__get_packed_size);
+    //-------------------------------------------------------------------------------------------
+    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((char*)container_buffer, container_size);
 
-bool RdWasteCartridgeParam(cartridge_name cart_name)
+    return OK;
+}
+void ResponseDemo(int MidtankId)
+{
+    WHS_info.event = IFS_INK_authentication_pass;
+    //global mid tank id = MidtankId;
+    WHS_info.Ink.cart_color = MidtankId;
+    WasteTankCBFunction();//call cart is ok
+}
+bool CartridgeValidationResponseFunc(MessageContainer* requestContainer)
+{
+    bool ret = notOK;
+    CartridgeValidationResponse* response = cartridge_validation_response__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
+
+    Cartridge *cartridge;
+    uint32_t midtankId;
+    cartridge_name cart_name;
+
+    // chack the massege:
+    // 1. the cartridge is valid ( autantication)
+    // 2. the pointer is not 0 !!!
+    if (response->cartridge == 0 )
+    {
+        REPORT_MSG(WHS_filling," ------------ IFS_filling message from PPC is null!!! ----------------- "); // write to log error
+        return ret;
+    }
+
+    if (response->isvalid == true)
+    {
+        REPORT_MSG(WHS_filling," ------------ IFS_filling INK cartridge is valid ----------------- "); // write to log error
+        cartridge = response->cartridge;
+        midtankId = cartridge->index; // midtank 1-8
+        cart_name = cartridge->slot;    //cart1(INK),cart2(WASTE1),cart3(WASTE1)
+        if (cartridge->slot == INK_cartridge)
+        {
+            WHS_info.Ink.cart_color = cartridge->index; // midtank 1-8
+            WHS_info.event = IFS_INK_authentication_pass;
+        }
+        WasteTankCBFunction();//call cart is ok
+        ret = OK;
+    }
+    else
+    {
+        REPORT_MSG(WHS_filling," ------------ IFS_filling INK cartridge is not valid !!!----------------- "); // write to log error
+//        cartridge = response->cartridge;
+//        mimidtankId = cartridge->index;
+//        cart_name = cartridge->slot;
+        WHS_info.event = IFS_INK_authentication_fail;
+        WasteTankCBFunction();// call cart is INVALID
+        ret = OK;
+    }
+return ret;
+}
+
+
+
+bool RdCartridgeParam(cartridge_name cart_name)
 {
     /*
     read all parameters from RFid cartridge:
@@ -130,36 +311,53 @@ bool RdWasteCartridgeParam(cartridge_name cart_name)
     waste_cartridge 1 or 1
     update waste_cartridge struct
     */
-    if (cart_name == waste_cartridge1)
+    bool ret = notOK;
+    switch (cart_name)
     {
+    case waste_cartridge1:
         WHS_info.cartridge_1.serial_number = temp_funcion; //to do
         WHS_info.cartridge_1.status = temp_funcion; // to do
-    }
-    else
-    {
+        break;
+    case waste_cartridge2:
         WHS_info.cartridge_2.serial_number = temp_funcion;
         WHS_info.cartridge_2.status = temp_funcion;
+        break;
+    case INK_cartridge:
+        ReadCartridgeData(cart_name);
+        //memcpy(cartridge_info.ColorName,RED);
+//        add call back!!  WasteTankCallBackTime
+//        state - wait for cartridge validation
+//        //WHS_info.Ink.serial_number = temp_funcion;
+        //WHS_info.Ink.status = temp_funcion;
+        break;
+    default:
+        break;
     }
-    return OK;
+    ret = OK;
+    return ret;
 }
 
-bool CartridgeAuthentication(cartridge_name cart_name)
+bool  CartridgeAuthentication(cartridge_name cart_name)
 {
     bool ret = notOK;
     // TBD;
     switch (cart_name)
     {
+        case INK_cartridge:
+            WHS_info.Ink.autheticate = PASSED;  //todo
+            //Pannel_Leds(CART_1, MODE_ON);
+            break;
         case waste_cartridge1:
-            WHS_info.cartridge_1.autheticate = PASSED;
+            WHS_info.cartridge_1.autheticate = PASSED;  //todo
             //Pannel_Leds(CART_2, MODE_ON);
             break;
         case waste_cartridge2:
-            WHS_info.cartridge_2.autheticate = PASSED;
+            WHS_info.cartridge_2.autheticate = PASSED; //todo
             //Pannel_Leds(CART_3, MODE_ON);
             break;
         default:
-            WHS_info.cartridge_1.autheticate = FAILED;
-            WHS_info.cartridge_2.autheticate = FAILED;
+            WHS_info.cartridge_1.autheticate = FAILED; //todo
+            WHS_info.cartridge_2.autheticate = FAILED; //todo
             //Pannel_Leds(CART_2, MODE_OFF);
             //Pannel_Leds(CART_3, MODE_OFF);
             break;
@@ -215,6 +413,7 @@ bool SetWastePump( bool power)
         void Pumps_Control(PUMPS_ENUM Pump_Id, bool Direction) //1 - OPEN, 0 - CLOSE ?? WHS_WTANKPUMP2 or WASTECH_PUMP2
     */
     bool ret = notOK;
+//    if (( power == OPEN ) && (WHS_info.WHS_sensors.cartridge_cover == CLOSE))
     if ( power == OPEN )
     {
         Pumps_Control(WHS_WTANKPUMP2, OPEN); //waste_pump_power_on();
@@ -264,14 +463,9 @@ U8 CartridgeWasteFilling(bool status)
 
     if ((status == ON) && (WHS_info.active_cartridge != no_waste_cartridge))
     {
-
-       //if (WHS_info.active_cartridge != no_waste_cartridge) //
-        {
-            Valve_Set(VALVE_WASTE_TANK, WHS_info.active_cartridge); //set the valve direction
-            //Pannel_Leds(PANEL_BUTTON_OR_CRAT_ID Pannel_Led_Id, OPERATION_MODE LED_Mode); //set cartridge led color slow blink
-            //write RFID status
-        }
-        // close that line for only ITMA !!! SetWastePump(OPEN);  ToDo
+        Valve_Set(VALVE_WASTE_TANK, WHS_info.active_cartridge); //set the valve direction
+        //Pannel_Leds(PANEL_BUTTON_OR_CRAT_ID Pannel_Led_Id, OPERATION_MODE LED_Mode); //set cartridge led color slow blink
+        SetWastePump(OPEN);
         //WHS_info.WHS_pump.time = 0;
         REPORT_MSG(WHS_empty," ------------ WHS WHS_empty start PUMP  ----------------- ");
         ret=OK;
@@ -285,10 +479,12 @@ U8 CartridgeWasteFilling(bool status)
            {
               case waste_cartridge1:
                   Pannel_Leds( CART_2,  MODE_OFF);                //set led color
+                  cart2.color = colorOFF;
                   REPORT_MSG(WHS_empty," ------------ WHS  waste_cartridge1 is used please replace it ----------------- ");
                   break;
               case waste_cartridge2:
                   Pannel_Leds( CART_3,  MODE_OFF);                //set led color
+                  cart3.color = colorOFF;
                   REPORT_MSG(WHS_empty," ------------ WHS  waste_cartridge2 is used please replace it ----------------- ");
                   break;
               case no_waste_cartridge:
@@ -385,7 +581,7 @@ WHS_sttMachin UpdateStateMachine()
 bool initWHS_WasteTank()
 {
     WHS_info.WHS_sensors.waste_tank_empty_sensor = RdWasteTankEmptySensor();
-    WHS_info.WHS_sensors.waste_tank_full_sensor =  SENSORnotFULL;//;RdWasteTankFullSensor()
+    WHS_info.WHS_sensors.waste_tank_full_sensor =  SENSORnotFULL;
     UpdateStateMachine();
     AddControlCallback(WasteTankCBFunction, WasteTankCallBackTime , WasteTankCallBackFunction, 0,0,0);//eOneMinute
     return OK;
@@ -440,7 +636,7 @@ WHS_sensor WasteTankCallBackFunction()
         }
     else */
     if (WHS_info.WHS_pump.time) WHS_info.WHS_pump.time += 1;
-    if (WHS_info.WHS_pump.time == PumpTimeout)
+    if (WHS_info.WHS_pump.time == PUMPTIMEOUT)
     {
         WHS_info.WHS_pump.time = 0;
         AlarmHandlingSetAlarm( EVENT_TYPE__WASTE_CONTAINER_EMPTYING_TIMEOUT,  false);
@@ -468,14 +664,16 @@ bool start_WHS_machin()
 
 bool WasteTankCBFunction()
 {
+
+    uint8_t parameter = 7;
     bool ret = notOK;
     static bool pump_on_flag = CLOSE;
     //uint32_t Cartridge_Cover_device_Id = 0;
-
+    double MidTank_Pressure = 0;
 
     switch (WHS_info.event)
     {
-       case WHS_empty_sensor:
+        case WHS_empty_sensor:
             if (WHS_info.WHS_sensors.waste_tank_empty_sensor == SENSORnotEMPTY)
             {
                 if (WHS_info.sttMachine == WHS_empty)
@@ -497,7 +695,7 @@ bool WasteTankCBFunction()
                     ret = CartridgeWasteFilling(OFF);
                     WHS_info.Cartridge_Cover_device_Id = RemoveControlCallback(WHS_info.Cartridge_Cover_device_Id, WasteTankCBFunction );
                     WHS_info.Cartridge_Cover_device_Id = AddControlCallback( WasteTankCBFunction, CartridgeCoverCallBackTime, CartridgeCoverCallBackFunction, 0,0,0 );//eOneSecond
-                    //SafeRemoveControlCallback(Cartridge_Cover_device_Id, CartridgeCoverCBFunction );
+                    WrRFIDStatus(WHS_info.active_cartridge, WasteFull);//write RFID status todo
                 }
                 else
                 {
@@ -506,16 +704,32 @@ bool WasteTankCBFunction()
             }
             break;
         case WHS_full_sensor:
+            /* if the machine status is power down : don't start the waste emptying sequence !!!*/
+            if ( PowerOffInProcessGetState() )
+                break;
+
             if (WHS_info.WHS_sensors.waste_tank_full_sensor == SENSORFULL)
             {
                 WHS_info.sttMachine = WHS_full;
                 REPORT_MSG(WHS_emptying," ------------ WHS_full ----------------- ");
                 WHS_info.Cartridge_Cover_device_Id = RemoveControlCallback(WHS_info.Cartridge_Cover_device_Id, WasteTankCBFunction );
                 WHS_info.Cartridge_Cover_device_Id = AddControlCallback( WasteTankCBFunction, CartridgeCoverCallBackFastTime , CartridgeCoverCallBackFunction, 0,0,0 );//eTenMillisecond
-                ret = CartridgeWasteFilling(ON);
+                if (RdRFIDStatus (WHS_info.active_cartridge) == WasteEmpty)
+                {
+                    ret = WrRFIDStatus(WHS_info.active_cartridge, WasteFilling);//write RFID status todo
+                    if (ret == OK)
+                    {
+                        CartridgeWasteFilling(ON);
+                    }
+                    else
+                    {
+                        WrRFIDStatus(WHS_info.active_cartridge,  WasteFail);//write RFID status todo
+                    }
+                }
+
                 if (ret != OK)
                 {
-                    //recreate the full event until cartridge is inserted
+                    //recreate the full event until cartridge is inserted or atontocation
                     WHS_info.WHS_sensors.waste_tank_full_sensor = 1-WHS_info.WHS_sensors.waste_tank_full_sensor;
                 }
 
@@ -552,13 +766,20 @@ bool WasteTankCBFunction()
         case WHS_cartridge_cover_sensor:
             if ( WHS_info.WHS_sensors.cartridge_cover == OPEN )
             {
+                //popup message :"Cartridge cover open"  //todo
+                REPORT_MSG(parameter," Cartridge cover open ");
                 if ( WHS_info.WHS_pump.status == OPEN)
                 {
                     CartridgeWasteFilling(CLOSE);
                     pump_on_flag = OPEN;
                 }
-                WHS_info.Cartridge_Waste1_device_Id = AddControlCallback( WasteTankCBFunction, CartridgeWaste1CallBackTime, CartridgeWaste1CallBackFunction, 0,0,0 ); //eOneSecond
-                WHS_info.Cartridge_Waste2_device_Id = AddControlCallback( WasteTankCBFunction, CartridgeWaste2CallBackTime, CartridgeWaste2CallBackFunction, 0,0,0 ); //eOneSecond
+
+                if ( !PowerOffInProcessGetState() )
+                {
+                    WHS_info.Cartridge_Ink_device_Id = AddControlCallback( WasteTankCBFunction, CartridgeWaste1CallBackTime, CartridgeInkCallBackFunction, 0,0,0 ); //eOneSecond
+                    WHS_info.Cartridge_Waste1_device_Id = AddControlCallback( WasteTankCBFunction, CartridgeWaste1CallBackTime, CartridgeWaste1CallBackFunction, 0,0,0 ); //eOneSecond
+                    WHS_info.Cartridge_Waste2_device_Id = AddControlCallback( WasteTankCBFunction, CartridgeWaste2CallBackTime, CartridgeWaste2CallBackFunction, 0,0,0 ); //eOneSecond
+                }
 
 
 
@@ -579,16 +800,147 @@ bool WasteTankCBFunction()
                     CartridgeWasteFilling(OPEN);
                     pump_on_flag = CLOSE;
                 }
+                WHS_info.Cartridge_Waste1_device_Id = RemoveControlCallback(WHS_info.Cartridge_Ink_device_Id, WasteTankCBFunction );
                 WHS_info.Cartridge_Waste1_device_Id = RemoveControlCallback(WHS_info.Cartridge_Waste1_device_Id, WasteTankCBFunction );
                 WHS_info.Cartridge_Waste2_device_Id = RemoveControlCallback(WHS_info.Cartridge_Waste2_device_Id, WasteTankCBFunction );
+                if (WHS_info.sttMachine == INK_isOK)
+                {
+                    REPORT_MSG(WHS_full," ------------ change INK cartridge status to colorUsed ----------------- ");
+                    Enable_MidTank_Pressure_Reading(WHS_info.Ink.cart_color);
+                    Read_MidTank_Pressure_Sensor(WHS_info.Ink.cart_color);
+                    if ( Get_MidTank_Pressure_Sensor(WHS_info.Ink.cart_color) > MidTank_Pressure_EMPTY )
+                    {
+                        Disable_MidTank_Pressure_Reading(WHS_info.Ink.cart_color);
+                        REPORT_MSG(WHS_full," ------------ Mid-tank not empty ----------------- ");
+
+                        break;
+                    }
+                    MidTankValvesAction(Cartridge_MidTank_ON);
+                    REPORT_MSG(WHS_full," ------------ Mid-tank filling in process ----------------- ");
+                    Pannel_Leds(CART_1, MODE_ON);
+                    cart1.color  = BLINK;
+                    //add timeout
+                    WHS_info.Ink.time_out = 1;
+                    WHS_info.Cartridge_Ink_TimeOut_device_Id = AddControlCallback( WasteTankCBFunction, CartridgeInkTimeOutCallBackTime, CartridgeInkTimeOutCallBackFunction, 0,0,0 ); //eOneSecond
+
+
+                    //add callback for midtank status is full
+
+                }
             }
             break;
+
+        case IFS_INK_presence_sensor:
+            if (WHS_info.WHS_sensors.IFS_Ink_precense_sensor == CarteidgePrecense)
+            {
+                // is power down in process??  //todo
+                if ( !PowerOffInProcessGetState() ) // not in power down proccess
+                {
+                    Pannel_Leds(CART_1, MODE_ON);
+                    //cart1.color = BLINK;
+                    //Pannel_Leds(CART_2, MODE_ON);
+//                    cart2.color = fastBILNK;
+                    RdCartridgeParam(INK_cartridge); //todo
+                }
+                else
+                {
+                    //  print: "power down in process";
+                    REPORT_MSG(WHS_full," ------------ power down in process ----------------- ");
+                }
+
+
+            }
+            else
+            {
+                Pannel_Leds(CART_1, MODE_OFF);
+                cart1.color = colorOFF;
+            }
+            break;
+        case IFS_INK_authentication_pass:
+            if (!ColorMatch())
+            {
+                    //  print: "power down in process";
+                    REPORT_MSG(WHS_full," ------------ cartridge color does not match ----------------- ");
+                    break;
+            }
+            REPORT_MSG(WHS_full," ------------ close cartridge cover ----------------- ");
+            WHS_info.sttMachine = INK_isOK;
+
+            break;
+        case IFS_INK_authentication_fail:
+            break;
+        /*
+        case IFS_INK_presence_sensor: //source  IFS_INK_authentication_pass
+                    if (WHS_info.WHS_sensors.IFS_Ink_precense_sensor == CarteidgePrecense)
+                    {
+                        // is power down in process??  //todo
+                        Pannel_Leds(CART_1, MODE_ON);
+                        if ( RdCartridgeParam(INK_cartridge) )
+                        {
+                            MidTank_Pressure = Get_MidTank_Pressure_Sensor((CMYK_color)cartridge_info.ColorName);
+                            if ( MidTank_Pressure > MidTank_Pressure_EMPTY)
+                            {
+                                REPORT_MSG(WHS_emptying," ------ IFS mid_tank _not _empty remove INK cartridge ---------- ");
+                                break;
+                            }
+                            switch ((CMYK_color)cartridge_info.ColorName) //todo enter the correct color from RFID
+                            {
+                                case CYAN :
+
+                                    Valve_Set( VALVE_2W_CART_MID_1, Cartridge_MidTank_ON);     //Cartridge_MidTank_ON Cartridge_MidTank_OFF
+                                    Valve_Set( VALVE_2W_MID_AIR_1 , Cartridge_MidTank_ON);
+                                    break;
+                                case MAGENTA :
+                                    Valve_Set( VALVE_2W_CART_MID_5, Cartridge_MidTank_ON);
+                                    Valve_Set( VALVE_2W_MID_AIR_5 , Cartridge_MidTank_ON);
+                                   break;
+                                case YELLOW :
+                                    Valve_Set( VALVE_2W_CART_MID_2, Cartridge_MidTank_ON);
+                                    Valve_Set( VALVE_2W_MID_AIR_2 , Cartridge_MidTank_ON);
+                                    break;
+                                case BLACK :
+                                    Valve_Set( VALVE_2W_CART_MID_6, Cartridge_MidTank_ON);
+                                    Valve_Set( VALVE_2W_MID_AIR_6 , Cartridge_MidTank_ON);
+                                   break;
+                                case 4 :
+                                    Valve_Set( VALVE_2W_CART_MID_3, Cartridge_MidTank_ON);
+                                    Valve_Set( VALVE_2W_MID_AIR_3 , Cartridge_MidTank_ON);
+                                   break;
+                                case 5 :
+                                    Valve_Set( VALVE_2W_CART_MID_7, Cartridge_MidTank_ON);
+                                    Valve_Set( VALVE_2W_MID_AIR_7 , Cartridge_MidTank_ON);
+                                   break;
+                                case 6 :
+                                    Valve_Set( VALVE_2W_CART_MID_4, Cartridge_MidTank_ON);
+                                    Valve_Set( VALVE_2W_MID_AIR_4 , Cartridge_MidTank_ON);
+                                    break;
+                                case 7 :
+                                    Valve_Set( VALVE_2W_CART_MID_8, Cartridge_MidTank_ON);
+                                    Valve_Set( VALVE_2W_MID_AIR_8 , Cartridge_MidTank_ON);
+                                   break;
+                                default: //wrong color
+                                    break;
+                            }
+
+                        }
+                        else // if the authentication is failed
+                        {
+                            Pannel_Leds(CART_1, MODE_OFF);
+                        }
+                    }
+                    else //ink cart out
+                    {
+                        Pannel_Leds(CART_1, MODE_OFF);
+                    }
+*/
+
         case WHS_waste1_presence_sensor :
-                    if (WHS_info.WHS_sensors.waste_cartridge1_precense_sensor == WHS_CarteidgePrecense ) // waste cartridge 1 is inserted .
+                    if (WHS_info.WHS_sensors.waste_cartridge1_precense_sensor == CarteidgePrecense ) // waste cartridge 1 is inserted .
                     {
                         //SetCartridgeLED(waste_cartridge1, led_on);
                         Pannel_Leds(CART_2, MODE_ON);
-                        RdWasteCartridgeParam(waste_cartridge1);
+                        cart2.color = colorON;
+                        RdCartridgeParam(waste_cartridge1);
                         SetActiveWastCartridge();
                         SetValveDirection();
                         if ( CartridgeAuthentication(waste_cartridge1)) // to define authentication
@@ -605,6 +957,7 @@ bool WasteTankCBFunction()
                     else    // waste cartridge 1 take out
                     {
                         Pannel_Leds(CART_2, MODE_OFF);
+                        cart2.color = colorOFF;
                         WHS_info.cartridge_1.autheticate = FAILED;
                         //???if (WHS_info.cartridge_2.autheticate == PASSED) // or we should do it only before pumping????
                         //???{
@@ -615,16 +968,17 @@ bool WasteTankCBFunction()
                         //???{
                         //???
                         //???}
-                        //???        RdWasteCartridgeParam(waste_cartridge2);
+                        //???        RdCartridgeParam(waste_cartridge2);
                         //???WHS_info.WHS_valve = waste_cartridge1;
                     }
                     //SetActiveWastCartridge();
                     break;
         case WHS_waste2_presence_sensor :
-                    if (WHS_info.WHS_sensors.waste_cartridge2_precense_sensor == WHS_CarteidgePrecense ) // waste cartridge  is inserted .
+                    if (WHS_info.WHS_sensors.waste_cartridge2_precense_sensor == CarteidgePrecense ) // waste cartridge  is inserted .
                     {
                        Pannel_Leds(CART_3, MODE_ON);//SetCartridgeLED(waste_cartridge2, led_on);
-                       RdWasteCartridgeParam(waste_cartridge2);
+                       cart3.color = colorON;
+                       RdCartridgeParam(waste_cartridge2);
                        if ( CartridgeAuthentication(waste_cartridge2)) // to define authentication
                        {
                            //WHS_info.cartridge_2.autheticate = PASSED; //='0'
@@ -640,6 +994,7 @@ bool WasteTankCBFunction()
                     else    // waste cartridge 2 take out
                     {
                         Pannel_Leds(CART_3, MODE_OFF);
+                        cart3.color = colorOFF;
                         WHS_info.cartridge_2.autheticate = FAILED;
                         /*
                           if (WHS_info.cartridge_2.autheticate == PASSED) // or we should do it only before pumping????
@@ -651,7 +1006,7 @@ bool WasteTankCBFunction()
                         {
 
                         }
-                        RdWasteCartridgeParam(waste_cartridge2);
+                        RdCartridgeParam(waste_cartridge2);
                        WHS_info.WHS_valve = waste_cartridge1;
                        */
                     }
@@ -662,6 +1017,43 @@ bool WasteTankCBFunction()
             AlarmHandlingSetAlarm( EVENT_TYPE__WASTE_CONTAINER_EMPTYING_TIMEOUT,  true);
             CartridgeWasteFilling(OFF);
             break;
+
+//        case IFS_Timeout:
+//            REPORT_MSG(WHS_emptying," ------------ IFS_Timeout ----------------- ");
+//            // try again :
+//            // start timeout
+//            // close and open the correct valves
+//            REPORT_MSG(WHS_full," ------------ IFS_Timeout_Second_Time ----------------- ");
+//            MidTankValvesAction(Cartridge_MidTank_OFF);
+//            MidTankValvesAction(Cartridge_MidTank_ON);
+//
+//            IFS_TimeOutAlarm();
+//
+//            break;
+        case IFS_Timeout_Second:
+            Disable_MidTank_Pressure_Reading(WHS_info.Ink.cart_color);
+            WHS_info.Cartridge_Ink_TimeOut_device_Id = RemoveControlCallback(WHS_info.Cartridge_Ink_TimeOut_device_Id, WasteTankCBFunction );
+            REPORT_MSG(WHS_full," ------------ Change cartridge status to Fail ----------------- ");
+
+            MidTankValvesAction(Cartridge_MidTank_OFF);
+            cart1.color = fastBILNK;
+            REPORT_MSG(WHS_full," ------------ Display Mid-tank # filling fail ----------------- ");
+            REPORT_MSG(WHS_full," ------------ call customer support ----------------- ");
+            IFS_TimeOutAlarm();
+            break;
+
+        case IFS_MidTankFull:
+            Disable_MidTank_Pressure_Reading(WHS_info.Ink.cart_color);
+            WHS_info.Cartridge_Ink_TimeOut_device_Id = RemoveControlCallback(WHS_info.Cartridge_Ink_TimeOut_device_Id, WasteTankCBFunction );
+            REPORT_MSG(WHS_full," ------------ Change cartridge status to WasteEmpty ----------------- ");
+            Pannel_Leds(CART_1, MODE_OFF);
+            cart1.color = colorOFF;
+            MidTankValvesAction(Cartridge_MidTank_OFF);
+            REPORT_MSG(WHS_full," ------------ Display Mid-tank # filling complited ----------------- ");
+            break;
+
+
+
         case WHS_no_event:
             break;
         default: //error state
@@ -672,6 +1064,8 @@ bool WasteTankCBFunction()
 }
 
 
+
+
 /*------------------------------- Cartridge  Cover       -----------------------------------------*/
 
 bool RdCartridgeCoverSensor()
@@ -684,8 +1078,14 @@ bool RdCartridgeCoverSensor()
    // WHS_info.WHS_sensors.cartridge_cover = Get_COVER_1_State(CartridgesDoor);
    // ret = WHS_info.WHS_sensors.cartridge_cover;
     ret = Get_COVER_1_State(CartridgesDoor);
-    if ((ret == OPEN ) && (ret != WHS_info.WHS_sensors.cartridge_cover)) Report(" ------------ RD Cartridge Cover Sensor is = OPEN(1)    ----------------- ",__FILE__,__LINE__,ret,RpWarning,ret,0);
-    if ((ret == CLOSE ) && (ret != WHS_info.WHS_sensors.cartridge_cover)) REPORT_MSG(parameter," ------------ RD Cartridge Cover Sensor is = CLOSE(0)   ----------------- ");
+    if ((ret == OPEN ) && (ret != WHS_info.WHS_sensors.cartridge_cover))
+    {
+        Report(" ------------ RD Cartridge Cover Sensor is = OPEN(1)    ----------------- ",__FILE__,__LINE__,ret,RpWarning,ret,0);
+    }
+    if ((ret == CLOSE ) && (ret != WHS_info.WHS_sensors.cartridge_cover))
+    {
+        REPORT_MSG(parameter," ------------ RD Cartridge Cover Sensor is = CLOSE(0)   ----------------- ");
+    }
     return ret;
 }
 
@@ -699,16 +1099,77 @@ WHS_sensor CartridgeCoverCallBackFunction()
 
     WHS_sensor ret = WHS_no_event;
    //ret = RdCartridgeCoverSensor();
-    if (WHS_info.WHS_sensors.cartridge_cover != RdCartridgeCoverSensor())
+    if ( WHS_info.WHS_sensors.cartridge_cover != RdCartridgeCoverSensor() )
     {
         REPORT_MSG(parameter," ------------ find  :  WHS_cartridge_cover_sensor event   ----------------- ");
         WHS_info.event = WHS_cartridge_cover_sensor;
         WHS_info.WHS_sensors.cartridge_cover = !WHS_info.WHS_sensors.cartridge_cover;
-        ret = WHS_cartridge_cover_sensor;
+        ret = WHS_cartridge_cover_sensor; //todo
+    }
+    return ret;
+}
+
+
+
+WHS_sensor CartridgeInkTimeOutCallBackFunction()
+{
+    WHS_sensor ret = WHS_no_event;
+//    uint32_t time_out_second = 0 ;
+
+    if (WHS_info.Ink.time_out) WHS_info.Ink.time_out += 1;
+    Read_MidTank_Pressure_Sensor(WHS_info.Ink.cart_color);
+    if (Get_MidTank_Pressure_Sensor(WHS_info.Ink.cart_color) >= WHS_info.MidTank_capacity  + CARTRIDGE_CAPATICY)
+    {
+        WHS_info.Ink.time_out = 0;
+        WHS_info.event = IFS_MidTankFull;
+        return IFS_MidTankFull;
+    }
+    if (WHS_info.Ink.time_out == CARTRIDGE_INK_TIMEOUT)
+    {
+        //WHS_info.Ink.time_out = 0;
+        //return WHS_info.event = IFS_Timeout;
+
+        REPORT_MSG(WHS_emptying," ------------ IFS_Timeout ----------------- ");
+        // try again :
+        // start timeout
+        // close and open the correct valves
+        REPORT_MSG(WHS_full," ------------ IFS_Timeout_Second_Time ----------------- ");
+        MidTankValvesAction(Cartridge_MidTank_OFF);
+    }
+
+    if (WHS_info.Ink.time_out == (CARTRIDGE_INK_TIMEOUT+1)) //need to open the valve for second chance
+        {
+            MidTankValvesAction(Cartridge_MidTank_ON);
+        }
+
+    if (WHS_info.Ink.time_out == CARTRIDGE_INK_TIMEOUTx2)
+        {
+            WHS_info.Ink.time_out = 0;
+            WHS_info.event = IFS_Timeout_Second;
+            return IFS_Timeout_Second;
+        }
+    return ret;
+}
+
+
+
+WHS_sensor CartridgeInkCallBackFunction()
+{
+    uint32_t parameter = 6 ;
+
+    WHS_sensor ret = WHS_no_event;
+    if (WHS_info.WHS_sensors.IFS_Ink_precense_sensor != RdInkCartridgeSensor())
+    {
+        REPORT_MSG(parameter," ------------ find  : IFS_Ink_presence_sensor event   ----------------- ");
+        WHS_info.event = IFS_INK_presence_sensor;
+        WHS_info.WHS_sensors.IFS_Ink_precense_sensor = !WHS_info.WHS_sensors.IFS_Ink_precense_sensor;
+        ret = IFS_INK_presence_sensor;
     }
     return ret;
 }
 
+
+
 WHS_sensor CartridgeWaste1CallBackFunction()
 {
     uint32_t parameter = 6 ;
@@ -741,48 +1202,76 @@ WHS_sensor CartridgeWaste2CallBackFunction()
     return ret;
 }
 
-/*------------------------------- Cartridge  Waste       -----------------------------------------*/
-bool InitWasteCartStatus()
+/*------------------------------- Waste Cartridge + IFS Cartridge    -----------------------------------------*/
+bool InitCartStatus()
 {
     uint32_t parameter = 6 ;
 
     WHS_info.WHS_sensors.cartridge_cover = RdCartridgeCoverSensor();
 
+    /* INK =>  CART_1 */
+    REPORT_MSG(parameter," ------------------------------------------------------------------------------------------ ");
+    REPORT_MSG(parameter," ------------!!!!!!!  at INIT what to do if IFS_INK is presence  !!!!!!!  ----------------- ");
+    REPORT_MSG(parameter," ------------------------------------------------------------------------------------------ ");
+
+    if (RdInkCartridgeSensor())
+    {
+       REPORT_MSG(parameter," ------------  INIT : IFS_INK is presence    ----------------- ");
+       WHS_info.WHS_sensors.IFS_Ink_precense_sensor = CarteidgePrecense;
+       Pannel_Leds( CART_1,  MODE_ON);
+       cart1.color = colorON;
+    }
+    else
+    {
+       REPORT_MSG(parameter," ------------  INIT : IFS_INK is NOT presence   ----------------- ");
+       WHS_info.WHS_sensors.IFS_Ink_precense_sensor = CarteidgeNotPrecense;
+       Pannel_Leds( CART_1,  MODE_OFF);
+       cart1.color = colorOFF;
+    }
+
+    /* waste_cartridge1 => CART_2  */
     if (RdWasteCartridge1Sensor())
     {
-        REPORT_MSG(parameter," ------------  WHS_waste1_presence_sensor event   ----------------- ");
-        WHS_info.WHS_sensors.waste_cartridge1_precense_sensor = WHS_CarteidgePrecense;
+        REPORT_MSG(parameter," ------------  INIT : WHS_waste1 cart is presence   ----------------- ");
+        WHS_info.WHS_sensors.waste_cartridge1_precense_sensor = CarteidgePrecense;
         Pannel_Leds( CART_2,  MODE_ON);
+        cart2.color = colorON;
     }
     else
     {
-        REPORT_MSG(parameter," ------------  WHS_waste1_NOT !!!  presence_sensor   ----------------- ");
-        WHS_info.WHS_sensors.waste_cartridge1_precense_sensor = WHS_CarteidgeNotPrecense;
+        REPORT_MSG(parameter," ------------  INIT : WHS_waste1 cart is NOT presence !!!     ----------------- ");
+        WHS_info.WHS_sensors.waste_cartridge1_precense_sensor = CarteidgeNotPrecense;
         Pannel_Leds( CART_2,  MODE_OFF);
+        cart2.color = colorOFF;
     }
 
+    /* waste_cartridge2 => CART_3  */
     if (RdWasteCartridge2Sensor())
     {
-        REPORT_MSG(parameter," ------------  WHS_waste2_presence_sensor event   ----------------- ");
-        WHS_info.WHS_sensors.waste_cartridge2_precense_sensor = WHS_CarteidgePrecense;
+        REPORT_MSG(parameter," ------------  INIT : WHS_waste2 cart is presence   ----------------- ");
+        WHS_info.WHS_sensors.waste_cartridge2_precense_sensor = CarteidgePrecense;
         Pannel_Leds( CART_3,  MODE_ON);
+        cart3.color = colorON;
     }
     else
     {
-        REPORT_MSG(parameter," ------------  WHS_waste1_NOT !!!  presence_sensor   ----------------- ");
-        WHS_info.WHS_sensors.waste_cartridge2_precense_sensor = WHS_CarteidgeNotPrecense;
+        REPORT_MSG(parameter," ------------  INIT : WHS_waste1 cart is NOT presence_sensor !!!     ----------------- ");
+        WHS_info.WHS_sensors.waste_cartridge2_precense_sensor = CarteidgeNotPrecense;
         Pannel_Leds( CART_3,  MODE_OFF);
+        cart3.color = colorOFF;
     }
 
 
 
-    if (WHS_info.WHS_sensors.waste_cartridge1_precense_sensor == WHS_CarteidgePrecense) CartridgeAuthentication(waste_cartridge1);
-    if (WHS_info.WHS_sensors.waste_cartridge2_precense_sensor == WHS_CarteidgePrecense) CartridgeAuthentication(waste_cartridge2);
+    if (WHS_info.WHS_sensors.IFS_Ink_precense_sensor == CarteidgePrecense)          CartridgeAuthentication(INK_cartridge);
+    if (WHS_info.WHS_sensors.waste_cartridge1_precense_sensor == CarteidgePrecense) CartridgeAuthentication(waste_cartridge1);
+    if (WHS_info.WHS_sensors.waste_cartridge2_precense_sensor == CarteidgePrecense) CartridgeAuthentication(waste_cartridge2);
     SetActiveWastCartridge();
 
     if (WHS_info.WHS_sensors.cartridge_cover == WHS_CartridgeCoverOPEN)
     {
-        REPORT_MSG(parameter," ------------ WHS_CartridgeCoverOPEN  : add callback for cart1 and cart 1   ----------------- ");
+        REPORT_MSG(parameter," ------------ WHS_CartridgeCoverOPEN  : add callback for cart1 and cart 2   ----------------- ");
+        WHS_info.Cartridge_Ink_device_Id = AddControlCallback( WasteTankCBFunction, eOneSecond, CartridgeInkCallBackFunction, 0,0,0 );
         WHS_info.Cartridge_Waste1_device_Id = AddControlCallback( WasteTankCBFunction, eOneSecond, CartridgeWaste1CallBackFunction, 0,0,0 );
         WHS_info.Cartridge_Waste2_device_Id = AddControlCallback( WasteTankCBFunction, eOneSecond, CartridgeWaste2CallBackFunction, 0,0,0 );
     }
@@ -791,6 +1280,16 @@ bool InitWasteCartStatus()
     return OK;
 }
 
+bool RdInkCartridgeSensor()
+{
+    bool ret = notOK;
+    WHS_Read_GPI_Registers();
+    //WHS_info.WHS_sensors.waste_cartridge1_precense_sensor = Is_Cartridge_Present(CART_2);
+    //ret = WHS_info.WHS_sensors.waste_cartridge1_precense_sensor;
+    ret = Is_Cartridge_Present(CART_1);
+    return ret;
+}
+
 bool RdWasteCartridge1Sensor()
 {
     bool ret = notOK;
@@ -933,7 +1432,7 @@ bool CartridgeCoverCBFunction()
     {
         //if (WHS_info.WHS_pump == ON)
         //{
-            SetWastePump(OFF); //pump OFF
+            SetWastePump(CLOSE); //pump OFF
         //}
         // prevent NEW Job
         // Display "Close cartridge cover"
@@ -956,17 +1455,25 @@ bool CartridgeCoverCBFunction()
 
 U8 WHS_init(void)
 {
-    InitWasteCartStatus();
-    initWHS_WasteTank();
     SetWastePump(CLOSE);
+    InitCartStatus();
+    initWHS_WasteTank();
+
     return 0;
 }
 
 
+void midtanktest6_ON(void)
+{
+    Valve_Set( VALVE_2W_CART_MID_1, Cartridge_MidTank_ON);
+    Valve_Set( VALVE_2W_MID_AIR_1 , Cartridge_MidTank_ON);
+}
 
-
-
-
+void midtanktest6_OFF(void)
+{
+    Valve_Set( VALVE_2W_CART_MID_1, Cartridge_MidTank_OFF);
+    Valve_Set( VALVE_2W_MID_AIR_1 , Cartridge_MidTank_OFF);
+}
 
 
 
@@ -1344,7 +1851,7 @@ uint32_t start_WHS_machin()
 //            if (WHS_info.WHS_sensors.waste_cartridge1_precense_sensor  ) // waste cartridge 1 is inserted .
 //            {
 //                SetCartridgeLED(waste_cartridge1, led_on);
-//                RdWasteCartridgeParam(waste_cartridge1);
+//                RdCartridgeParam(waste_cartridge1);
 //                if ( CartridgeAuthentication(waste_cartridge1)) // to define authentication
 //                {
 //                    //WHS_info.cartridge_1.autheticate = PASSED; //='0'
@@ -1369,7 +1876,7 @@ uint32_t start_WHS_machin()
 //                //???{
 //                //???
 //                //???}
-//                //???        RdWasteCartridgeParam(waste_cartridge2);
+//                //???        RdCartridgeParam(waste_cartridge2);
 //                //???WHS_info.WHS_valve = waste_cartridge1;
 //            }
 //
@@ -1378,7 +1885,7 @@ uint32_t start_WHS_machin()
 //            if (WHS_info.WHS_sensors.waste_cartridge2_precense_sensor  ) // waste cartridge  is inserted .
 //            {
 //               SetCartridgeLED(waste_cartridge2, led_on);
-//               RdWasteCartridgeParam(waste_cartridge2);
+//               RdCartridgeParam(waste_cartridge2);
 //               if ( CartridgeAuthentication(waste_cartridge2)) // to define authentication
 //               {
 //                   //WHS_info.cartridge_2.autheticate = PASSED; //='0'
@@ -1404,7 +1911,7 @@ uint32_t start_WHS_machin()
 //                {
 //
 //                }
-//                RdWasteCartridgeParam(waste_cartridge2);
+//                RdCartridgeParam(waste_cartridge2);
 //               WHS_info.WHS_valve = waste_cartridge1;
 //
 //            }