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

19 files changed, 1039 insertions, 174 deletions

diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
index bae57d876..6f80fdffb 100644
--- a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
+++ b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
@@ -130,8 +130,10 @@ AlarmStatusItem  AlarmState[MAX_SYSTEM_ALARMS];
 * or static variable whose declaration follows the pragma directive (only if using it without #define for example: #pragma location = MOTOR_MAP_IN_FLASH)
 * The variables must be declared either __no_init or const!
 */
-AlarmHandlingItemStruc  *AlarmItem  = (AlarmHandlingItemStruc *)ALARM_MAP_IN_FLASH;
-const AlarmHandlingItemStruc  HardCodedAlarmItem[MAX_SYSTEM_ALARMS]={
+uint32_t * pAlarmItemSize = (uint32_t *)(ALARM_MAP_IN_FLASH);
+uint32_t AlarmItemSize ;
+AlarmHandlingItemStruc  *AlarmItem  = (AlarmHandlingItemStruc *)(ALARM_MAP_IN_FLASH+4);
+AlarmHandlingItemStruc  HardCodedAlarmItem[MAX_SYSTEM_ALARMS]={
      {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_1,0,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_1_EMPTY},
      {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_2,1,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_2_EMPTY},
      {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_3,2,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_3_EMPTY},
@@ -176,12 +178,22 @@ const AlarmHandlingItemStruc  HardCodedAlarmItem[MAX_SYSTEM_ALARMS]={
      {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_7_OVERPRESSURE},
      {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_8_OVERPRESSURE},
 
-     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,0,0,50/*500cc*/,false,DEBUG_LOG_CATEGORY__Warning,0xFF,2,EVENT_TYPE__MID_TANK_1_EMPTY},
-     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,1,1,50/*500cc*/,false,DEBUG_LOG_CATEGORY__Warning,0xFF,2,EVENT_TYPE__MID_TANK_2_EMPTY},
-     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,2,2,50/*500cc*/,false,DEBUG_LOG_CATEGORY__Warning,0xFF,2,EVENT_TYPE__MID_TANK_3_EMPTY},
-     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,3,3,50/*500cc*/,false,DEBUG_LOG_CATEGORY__Warning,0xFF,2,EVENT_TYPE__MID_TANK_4_EMPTY},
-     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,4,4,50/*500cc*/,false,DEBUG_LOG_CATEGORY__Warning,0xFF,2,EVENT_TYPE__MID_TANK_5_EMPTY},
-     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,7,7,50/*500cc*/,false,DEBUG_LOG_CATEGORY__Warning,0xFF,2,EVENT_TYPE__MID_TANK_8_EMPTY},
+     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,0,0,50/*500cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_1_LOW_LEVEL},
+     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,1,1,50/*500cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_2_LOW_LEVEL},
+     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,2,2,50/*500cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_3_LOW_LEVEL},
+     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,3,3,50/*500cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_4_LOW_LEVEL},
+     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,4,4,50/*500cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_5_LOW_LEVEL},
+     //{eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,5,5,50/*500cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_6_LOW_LEVEL},
+     //{eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,6,6,50/*500cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_7_LOW_LEVEL},
+     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,7,7,50/*500cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_8_LOW_LEVEL},
+     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,0,0,20/*500cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_1_EMPTY},
+     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,1,1,20/*500cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_2_EMPTY},
+     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,2,2,20/*500cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_3_EMPTY},
+     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,3,3,20/*500cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_4_EMPTY},
+     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,4,4,20/*500cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_5_EMPTY},
+     //{eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,5,5,20/*500cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_6_EMPTY},
+     //{eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,6,6,20/*500cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_7_EMPTY},
+     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,7,7,20/*500cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_8_EMPTY},
 
 
      {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DRYER_MOTOR_OVERCURRENT  },
@@ -338,6 +350,9 @@ const AlarmHandlingItemStruc  HardCodedAlarmItem[MAX_SYSTEM_ALARMS]={
      {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_DRYER_CURRENT_2, HEATER_DRYER_CURRENT_2, 0         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 2 , EVENT_TYPE__DRYER_HEATERS_ZONE_2_CURRENT_LOOP_BREAK          },                                           /* 6004 */
      {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DYEING_HEAD_THERMAL_CUTOFF},
 
+     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__VOC_SENSOR_ALARM_TIME},
+     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__VOC_SENSOR_ALARM_SLOPE},
+
      {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__THREAD_BREAK},
      {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_FEEDER_DANCER},
      {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_PULLER_DANCER},
@@ -367,27 +382,54 @@ bool EventsNotificationRequestAccepted = false;
 //machine cover open
 uint32_t AlarmHandlingFlashLoad(void)
 {
+    AlarmItemSize = sizeof(AlarmHandlingItemStruc)*MAX_SYSTEM_ALARMS;
+
 
-    EraseFlashSection(AlarmItem,sizeof(AlarmHandlingItemStruc)*MAX_SYSTEM_ALARMS);
+    EraseFlashSection(pAlarmItemSize,sizeof(AlarmHandlingItemStruc)*MAX_SYSTEM_ALARMS+4);
+    ReadAppAndProgram(pAlarmItemSize, 4,&AlarmItemSize);
     ReadAppAndProgram(AlarmItem, sizeof(AlarmHandlingItemStruc)*MAX_SYSTEM_ALARMS, HardCodedAlarmItem);
-//    LOG_ERROR(AlarmItem[2].EventName,"Flash Test");
+    LOG_ERROR(AlarmItem[110].EventType,"Flash Test");
 
-    return sizeof(AlarmHandlingItemStruc)*MAX_SYSTEM_ALARMS;
+    return AlarmItemSize;
 }
 uint32_t AlarmHandlingLoadFile(void)
 {
     FRESULT Fresult = FR_OK;
     uint8_t* buffer = NULL;
-    uint32_t Bytes = 0;
-
+    uint32_t Bytes = 0,i,p_size = 0;
+    AlarmParameters * AlarmParametersTable = NULL;
     Fresult = FileRead(AlarmStorePath, &Bytes, &buffer);
     if (Fresult == FR_OK)
     {
-        EraseFlashSection(AlarmItem,sizeof(AlarmHandlingItemStruc)*MAX_SYSTEM_ALARMS);
-        ReadAppAndProgram(AlarmItem, Bytes,buffer);
-        free (buffer);
-        ReportWithPackageFilter(AlarmFilter,"AlarmHandlingLoadFile", __FILE__,__LINE__,Bytes, RpMessage, Fresult, 0);
-
+        AlarmParametersTable = alarm_parameters__unpack(NULL, Bytes, buffer);
+        if (AlarmParametersTable)
+        {
+            if (AlarmParametersTable->n_alarmitem)
+            {
+                for (i = 0; i < AlarmParametersTable->n_alarmitem ;i++)
+                {
+                    HardCodedAlarmItem[i].AlarmDirection = AlarmParametersTable->alarmitem[i]->alarmdirection;
+                    HardCodedAlarmItem[i].AlarmDirection =  AlarmParametersTable->alarmitem[i]->alarmdirection;
+                    HardCodedAlarmItem[i].Frequency =       AlarmParametersTable->alarmitem[i]->frequency;  //1/10/100/1000
+                    HardCodedAlarmItem[i].AlarmSource =     AlarmParametersTable->alarmitem[i]->alarmsource;
+                    HardCodedAlarmItem[i].DeviceId =        AlarmParametersTable->alarmitem[i]->deviceid;
+                    HardCodedAlarmItem[i].ModuleDeviceId =  AlarmParametersTable->alarmitem[i]->moduledeviceid;
+                    HardCodedAlarmItem[i].AlarmValue =      AlarmParametersTable->alarmitem[i]->alarmvalue;
+                    HardCodedAlarmItem[i].AlarmDirection =  AlarmParametersTable->alarmitem[i]->alarmdirection;
+                    HardCodedAlarmItem[i].Severity =        AlarmParametersTable->alarmitem[i]->severity;
+                    HardCodedAlarmItem[i].Predecessor =     AlarmParametersTable->alarmitem[i]->predecessor;
+                    HardCodedAlarmItem[i].DebounceValue =   AlarmParametersTable->alarmitem[i]->debouncevalue;
+                    HardCodedAlarmItem[i].EventType =       AlarmParametersTable->alarmitem[i]->eventtype;
+                    p_size+= sizeof(AlarmHandlingItemStruc);
+                }
+                EraseFlashSection(pAlarmItemSize,p_size+4);
+                ReadAppAndProgram(pAlarmItemSize, 4,&p_size);
+                ReadAppAndProgram(AlarmItem, p_size,HardCodedAlarmItem);
+                free (buffer);
+                ReportWithPackageFilter(AlarmFilter,"AlarmHandlingLoadFile", __FILE__,__LINE__,p_size, RpMessage, AlarmParametersTable->n_alarmitem, 0);
+            }
+            alarm_parameters__free_unpacked(AlarmParametersTable,NULL);
+        }
     }
     return Bytes;
 }
@@ -395,6 +437,7 @@ uint32_t AlarmHandlingLoadFile(void)
 void AlarmHandlingInit(void)
 {
     Error_Block eb;
+    uint32_t Bytes;
 
     Error_init(&eb);
 
@@ -408,9 +451,20 @@ void AlarmHandlingInit(void)
         AlarmState[Alarm_i].EventPtr = NULL;
     }
 
-    AlarmItem = (AlarmHandlingItemStruc *)ALARM_MAP_IN_FLASH;
+    memcpy(&Bytes,(void *)pAlarmItemSize,sizeof(Bytes));
+    REPORT_MSG(Bytes,"Bytes read from flash");
+
+    if ((Bytes)&&(Bytes < 10000))
+    {
+        AlarmItem = (AlarmHandlingItemStruc *)ALARM_MAP_IN_FLASH+4;
+    }
+    else
+    {
+        Bytes = AlarmHandlingFlashLoad();
+        REPORT_MSG(Bytes,"Bytes read hard coded");
+    }
+    AlarmItem  = HardCodedAlarmItem; //back to hard coded until flash problem are solved
 
-    //AlarmHandlingFlashLoad();
 
     return;
 }
@@ -490,11 +544,11 @@ uint32_t AlarmHandlingConsequentActions(uint32_t AlarmId, DebugLogCategory Sever
             {
                 if (Severity == DEBUG_LOG_CATEGORY__Info)
                 {
-                    IDS_Dispenser_Alarm_Off(AlarmItem[AlarmId].ModuleDeviceId);
+                    IDS_Dispenser_Alarm_Off(AlarmItem[AlarmId].ModuleDeviceId-HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1);
                 }
                 else
                 {
-                    IDS_Dispenser_Alarm_On (AlarmItem[AlarmId].ModuleDeviceId);
+                    IDS_Dispenser_Alarm_On (AlarmItem[AlarmId].ModuleDeviceId-HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1);
                 }
             }
             break;
@@ -816,11 +870,13 @@ uint32_t AlarmHandlingLoop(uint32_t tick)
     int32_t value;
     //int32_t ivalue;
     bool Status = false;
+    int AlarmCounter=0;
     for (Alarm_i = 0;Alarm_i < MAX_SYSTEM_ALARMS;Alarm_i++)
     {
         Status = false;
         if (AlarmItem[Alarm_i].AlarmSource > ALARM_SOURCE_TYPE__FluidLevelAlarm)
             continue;
+        AlarmCounter++;
         if (tick%AlarmItem[Alarm_i].Frequency == 0)
         {
             switch (AlarmItem[Alarm_i].AlarmSource)
@@ -951,6 +1007,7 @@ uint32_t AlarmHandlingLoop(uint32_t tick)
                     Status = false;
                 break;
             case ALARM_SOURCE_TYPE__FluidLevelAlarm:
+                Status = false;
                 value = Get_MidTank_Int100_Sensor(AlarmItem[Alarm_i].DeviceId);
                 if (AlarmItem[Alarm_i].AlarmDirection == OVER_VALUE)
                 {
@@ -1055,6 +1112,8 @@ uint32_t AlarmHandlingLoop(uint32_t tick)
     //valve OCD
     //Motor Status
     //machine cover open
+    if ((tick%(eOneSecond*5) == 0)&&(AlarmCounter == 0))
+        ReportWithPackageFilter(AlarmFilter,"Error in alarms data!!!!!!!!! ", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, RpFatalError, 0, Alarm_i);
 
     if ((tick%eOneSecond == 0)&&(EventsNotificationRequestAccepted==true))
         SendEventNotifications();
diff --git a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
index 063d7c823..fa94614fd 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
+++ b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
@@ -39,6 +39,7 @@
 
 #include "modules/thread/thread_ex.h"
 #include "modules/ids/ids_ex.h"
+#include "modules/Diagnostics/Diagnostics.h"
 
 #include "drivers/Flash_Memory/Flash_Memory.h"
 #include "drivers/Flash_Memory/fatfs/ff.h"
@@ -87,14 +88,13 @@ uint32_t  Dancer_Data[NUM_OF_DANCERS] = {0};
 float  Speed_Data = 0;
 uint32_t DrawerFansStatus = 0;
 uint32_t SystemFansStatus = 0;
-uint8_t Gas_PPM = 0;
-
 bool watchdogCriticalAlarm = false;
 
 uint32_t msec_millisecondCounter = 0;
 
 extern bool Machine_Idle_Mode;
 
+uint8_t Gas_PPM_Info;
 MillisecMotorDataStruc ScrewSetMaxSpeedPending = {0};
 MillisecMotorDataStruc ScrewMovePending = {0};
 MillisecMotorDataStruc MotorData[NUM_OF_MOTORS] = {0};
@@ -110,6 +110,7 @@ static GateMutex_Handle gateMillisecDB;
 uint32_t        Millisec_timerBase = TIMER1_BASE;        //Timer handle
 /******************** Functions  ********************************************/
 uint32_t Control_Delta_Position_Pass(uint32_t Current_Read,uint32_t Previous_Read);
+void CalculateVOCAlarms(void);
 //**********************************************************************
 /******************** CODE  ********************************************/
 //**********************************************************************
@@ -594,7 +595,6 @@ uint32_t MillisecLowLoop(uint32_t tick)
                 Read_Heaters_Current(Heater_i);
             }
         }
-        Gas_PPM = Calculate_Gas_Power_Consumption();
         for (Sensor_i = 0;Sensor_i < MAX_TEMPERATURE_SENSOR_ID;Sensor_i++)
         {
             TemperatureCalc[Sensor_i] =  MillisecCalculateTemperatures ( Sensor_i);
@@ -613,6 +613,9 @@ uint32_t MillisecLowLoop(uint32_t tick)
             if (isMotorConfigured(Motor_i))
                 MotorGetStatusFromFPGA(Motor_i);
         }*/
+        midtankDisplay = 1-midtankDisplay;
+        Gas_PPM_Info = Calculate_Gas_Power_Consumption();
+
     }
     if (OneHourTick)
     {
@@ -718,7 +721,7 @@ uint32_t getDrawerFansStatus(void)
 }
 uint8_t getGasReading(void)
 {
-    return Gas_PPM;
+    return Gas_PPM_Info;
 }
 
 uint32_t getSystemFansStatus(void)
diff --git a/Software/Embedded_SW/Embedded/Modules/Control/control.c b/Software/Embedded_SW/Embedded/Modules/Control/control.c
index f1e19d851..a88f67d5e 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/control.c
+++ b/Software/Embedded_SW/Embedded/Modules/Control/control.c
@@ -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..ca76ec8e1 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/control.h
+++ b/Software/Embedded_SW/Embedded/Modules/Control/control.h
@@ -47,6 +47,9 @@ int         SafeRemoveHighControlCallback(uint32_t deviceId , ControlCBFunction
 uint32_t    TemplateDataReadCBFunction (uint32_t deviceId, uint32_t Parameter1);
 uint32_t    GetControlDevice_i(void);
 uint32_t    GetControlLowDevice_i(void);
+ControlCBFunction GetControlCallbackFuncPtr(uint32_t ControlId);
+
+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 5d20791c0..8956f417d 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
@@ -60,6 +60,7 @@ uint32_t DiagnosticsStop(void);
 
 uint32_t Diagnostics_ControlTrigger(uint32_t IfIndex, uint32_t ReadValue);
 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
@@ -81,7 +82,7 @@ int DiagnosticLimit =eOneSecond; //frequency of data collection
 int DiagnosticLimit =eHundredMillisecond; //frequency of data collection
 #endif
 int DiagnosticFastLimit = eTenMillisecond; //frequency of data collection
-#define TEN_MSEC_COLLECTION
+//#define TEN_MSEC_COLLECTION
 //DigitalPin DigitalPinArray[1][DIAGNOSTICS_LIMIT+1];
 double dancer1angle[DIAGNOSTICS_LIMIT+1];
 double dancer2angle[DIAGNOSTICS_LIMIT+1];
@@ -129,6 +130,7 @@ Task_Handle Diagnostics_Task_Handle;
 Mailbox_Handle          DiagnosticsMsgQ = NULL;
 
 bool blowervolatgedisplay = false;
+bool midtankDisplay = false;
 double diagvoltage = 0;
 /******************** Functions  ********************************************/
 //uint32_t Control_Delta_Position_Pass(uint32_t Current_Read,uint32_t Previous_Read);
@@ -137,6 +139,7 @@ typedef enum
 {
     DiagnosticsTrigger,
     DiagnosticsTenMiliTrigger,
+    DiagnosticsOneSecTrigger,
 }DiagnosticsMessages;
 
 typedef struct DiagnosticsMessage{
@@ -337,7 +340,7 @@ void DiagnosticTenMsecCollection(void)
 {
     if (DiagnosticsActive == false)
         return;
-#ifdef TEN_MSEC_COLLECTION
+//#ifdef TEN_MSEC_COLLECTION
     /*if (JobIsActive()== false)
         return;*/
     DiagnosticLoadDancer(WINDER_DANCER,Control_Read_Dancer_Position(WINDER_DANCER, 0,0));
@@ -349,7 +352,33 @@ void DiagnosticTenMsecCollection(void)
     DiagnosticLoadDancerError(FEEDER_DANCER,ThreadGetMotorCalculatedError(FEEDER_DANCER));
 
     //DiagnosticLoadSpeedSensor(getSensorSpeedData());
-#endif
+//#endif
+}
+void DiagnosticOneSecCollection(void)
+{
+    int i;
+    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__MixerHeater, MillisecGetTemperatures( MIXER_PT100));
+    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DYEINGH_TEMP1));
+    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DYEINGH_TEMP2));
+    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DYEINGH_TEMP3));
+    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DYEINGH_TEMP4));
+    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DYEINGH_TEMP5));
+    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6, MillisecGetTemperatures(HEAD6_PT100));
+
+    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DRYER_TEMP1));
+    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DRYER_TEMP2));
+    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DRYER_TEMP3));
+    for (i=0;i<MAX_SYSTEM_DISPENSERS;i++)
+    {
+        dispensermotorfrequency[i][DiagnosticsIndex] = IdsGetMotorSpeed(i);
+        //dispensermotorfrequency[i][DiagnosticsIndex] = IDS_Dispenser_Data[i].consumedinnanolitter;
+
+        dispenserspressure[i][DiagnosticsIndex] = GetDispenserPressure(i); //Read_MidTank_Pressure_Sensor
+        if (midtankDisplay)
+            MidTankpressure[i][0] = Get_MidTank_Pressure_Sensor(i);
+        else
+            MidTankpressure[i][0] = 1.00-(IDS_Dispenser_Data[i].consumedinnanolitter/5800000);
+    }
 }
 void Diagnostic100msecCollection(void)
 {
@@ -357,7 +386,7 @@ void Diagnostic100msecCollection(void)
     if (DiagnosticsActive == false)
         return;
 
-    DiagnosticLoadSpeedSensor(getSensorSpeedData());
+    //DiagnosticLoadSpeedSensor(getSensorSpeedData());
 #ifndef REDUCED_DIAGNOSTICS
 #ifndef TEN_MSEC_COLLECTION
     DiagnosticTenMsecCollection(); //call the 10msec function every 100 msec to reduce transport
@@ -371,6 +400,7 @@ void Diagnostic100msecCollection(void)
         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));
     DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DYEINGH_TEMP2));
@@ -388,10 +418,12 @@ void Diagnostic100msecCollection(void)
         //dispensermotorfrequency[i][DiagnosticsIndex] = IDS_Dispenser_Data[i].consumedinnanolitter;
 
         dispenserspressure[i][DiagnosticsIndex] = GetDispenserPressure(i); //Read_MidTank_Pressure_Sensor
-        MidTankpressure[i][0] = Get_MidTank_Pressure_Sensor(i);
-        //MidTankpressure[i][0] = IDS_Dispenser_Data[i].totalconsumedinnanolitter;
-		MidTankpressure[i][0] = 1.00-(IDS_Dispenser_Data[i].consumedinnanolitter/5800000);
+        if (midtankDisplay)
+            MidTankpressure[i][0] = Get_MidTank_Pressure_Sensor(i);
+        else
+            MidTankpressure[i][0] = 1.00-(IDS_Dispenser_Data[i].consumedinnanolitter/5800000);
     }
+    */
 #ifndef REDUCED_DIAGNOSTICS
     for (i=0;i<NUM_OF_CURRENT_HEATERS;i++)
     {
@@ -687,6 +719,7 @@ void SendDiagnostics(void)
 }
 uint32_t DiagnosticsControlId = 0xff;
 uint32_t Diagnostics10MSControlId = 0xff;
+uint32_t Diagnostics1SecControlId = 0xff;
 bool DiagnosticRequestAccepted = false;
 uint32_t DiagnosticsStart(void)
 {
@@ -706,6 +739,10 @@ uint32_t DiagnosticsStart(void)
             else
                 LOG_ERROR(DiagnosticsControlId,"Diagnostics restarted");
 #endif
+            if (Diagnostics1SecControlId == 0xFF)
+                Diagnostics1SecControlId = AddControlCallback(Diagnostics_OneSecControlTrigger,eOneSecond,TemplateDataReadCBFunction,0,0,0);
+            else
+                LOG_ERROR(Diagnostics1SecControlId,"Diagnostics restarted");
        }
 
     }
@@ -720,9 +757,12 @@ uint32_t DiagnosticsStop(void)
             RemoveControlCallback(DiagnosticsControlId,Diagnostics_ControlTrigger);
         if (Diagnostics10MSControlId != 0xFF)
             RemoveControlCallback(Diagnostics10MSControlId,Diagnostics_TenMiliControlTrigger);
+        if (Diagnostics1SecControlId != 0xFF)
+            RemoveControlCallback(Diagnostics1SecControlId,Diagnostics_OneSecControlTrigger);
 
         DiagnosticsControlId = 0xFF;
         Diagnostics10MSControlId = 0xFF;
+        Diagnostics1SecControlId = 0xFF;
 
     }
     return OK;
@@ -792,6 +832,19 @@ uint32_t Diagnostics_TenMiliControlTrigger(uint32_t IfIndex, uint32_t ReadValue)
     return OK;
 }
 
+uint32_t Diagnostics_OneSecControlTrigger(uint32_t IfIndex, uint32_t ReadValue)
+{
+    DiagnosticsMessageStruc Message;
+
+    //send message to the Millisec task
+    Message.messageId = DiagnosticsOneSecTrigger;
+    Message.msglen = sizeof(DiagnosticsMessageStruc);
+    if (DiagnosticsMsgQ != NULL)
+        Mailbox_post(DiagnosticsMsgQ , &Message, BIOS_NO_WAIT);
+
+
+    return OK;
+}
 /******************************************************************************
  *  ======== messageTsk ========
  *  Task for this function is created statically. See the project's .cfg file.
@@ -815,7 +868,12 @@ void DiagnosticsTask(UArg arg0, UArg arg1)
                 Diagnostic100msecCollection();
                 break;
             case DiagnosticsTenMiliTrigger:
+#ifdef TEN_MSEC_COLLECTION
                 DiagnosticTenMsecCollection();
+#endif
+                break;
+            case DiagnosticsOneSecTrigger:
+                DiagnosticOneSecCollection();
                 break;
             default:
                 break;
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.h b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.h
index 5e394947a..a68731eea 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.h
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.h
@@ -10,6 +10,7 @@
 #include "PMR/common/MessageContainer.pb-c.h"
 
 extern bool blowervolatgedisplay;
+extern bool midtankDisplay;
 extern double voltage;
 extern uint8_t* diagnosticscontainer_buffer;
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c
index 8ddc2f84d..f5606f704 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c
@@ -29,6 +29,7 @@
 #include "Drivers/I2C_Communication/DAC/blower.h"
 
 #include "ids/ids_ex.h"
+#include "General/process.h"
 
 #include "StateMachines/Printing/PrintingSTM.h"
 
@@ -55,6 +56,8 @@ return OK;
 }
 uint32_t MotorHomingRequestFunc(MessageContainer* requestContainer)
 {
+    uint32_t numberOfSteps = 0;
+    uint32_t LoadArmRounds = (int)dryerbufferlength;
 
     MessageContainer responseContainer;
 
@@ -79,11 +82,20 @@ uint32_t MotorHomingRequestFunc(MessageContainer* requestContainer)
                 }
                 else
                 {
+                    if(MotorId == HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM)
+                    {
+                        numberOfSteps = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround*LoadArmRounds*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].microstep*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulleyradius;
+                        Report("MotorHomingRequestFunc Set_Load_Arm_To_Start_Position",__FILE__,__LINE__,numberOfSteps,RpMessage,LoadArmRounds,0);
+                        MotorMoveWithCallback(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, (1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize),
+                                                        numberOfSteps, MotorHomingRequestCallback,1000);
+                        return OK;
+                    }
                     if ( Motor_Id_to_LS_IdDown[MotorId] != MAX_GPI)
                     {
                         MotorMovetoLimitSwitch (MotorId,1-MotorsCfg[MotorId].directionthreadwize, speed,  Motor_Id_to_LS_IdUp[MotorId], MotorHomingRequestCallback,10000);
                         return OK;
                     }
+
                 }
             }
             else // closing the system into normal work
@@ -95,6 +107,21 @@ uint32_t MotorHomingRequestFunc(MessageContainer* requestContainer)
                 }
                 else
                 {
+                    if(MotorId == HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM)
+                    {
+                        if (LoadArmRounds <= 2)
+                                LoadArmRounds = 20;
+
+                        numberOfSteps = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround*LoadArmRounds*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].microstep*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulleyradius;
+                        numberOfSteps -= 100;
+                        Report("MotorHomingRequestFunc Set_Load_Arm_To_Start_Position",__FILE__,__LINE__,numberOfSteps,RpMessage,LoadArmRounds,0);
+
+                        MotorSetMaxSpeed (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround/4);
+
+                        MotorMoveWithCallback (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize,
+                                               numberOfSteps,    MotorHomingRequestCallback, 100000);
+                        return OK;
+                    }
                     if ( Motor_Id_to_LS_IdUp[MotorId] != MAX_GPI)
                     {
                         MotorMovetoLimitSwitch (MotorId,MotorsCfg[MotorId].directionthreadwize, speed,  Motor_Id_to_LS_IdDown[MotorId], MotorHomingRequestCallback,10000);
diff --git a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
index 7e6ce928a..777225d56 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);
@@ -129,6 +130,8 @@ uint32_t HWConfigurationInit(void)
     //EmbeddedParametersInit();
     IDS_Dispenser_Content_Init();
     //ProcessParamsInit();
+    Buttons_Init();
+
     GeneralHwReady = true;
     STATUS_RED_LED_OFF;
     return status;
@@ -281,12 +284,12 @@ uint32_t EmbeddedParametersInit(void)
     PowerOffSetTemperatureThreshold(EmbeddedParameters->powerofftemperaturelimit);
 
     InitSequenceSetStartHeating (EmbeddedParameters->startheatingoninitsequence);
-    bool a1,a2,a3,a4;
-    a1 = (EmbeddedParameters->generalparameters[0] < 0.5)?false:true;
-    a2 = (EmbeddedParameters->generalparameters[1] < 0.5)?false:true;
-    a3 = (EmbeddedParameters->generalparameters[2] < 0.5)?false:true;
-    a4 = (EmbeddedParameters->generalparameters[3] < 0.5)?false:true;
-    AlarmHandlingSetFlags(a1,a2,a3,a4);
+    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]);
 
 
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/IDS/IDS.h b/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h
index 33033ad69..a919ce4e1 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h
@@ -24,6 +24,8 @@ extern bool DispensersAlarmState[ MAX_SYSTEM_DISPENSERS];
 
 extern uint32_t DispenserIdToMotorId[MAX_SYSTEM_DISPENSERS];
 
+extern bool HomingActive[MAX_SYSTEM_DISPENSERS];
+
 uint32_t IDS_Dispenser_EmptyCBFunction(uint32_t IfIndex, uint32_t ReadValue);
 
 /*typedef struct
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
index de7d12024..2f563d7d1 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
@@ -48,7 +48,7 @@ void IDS_Dispenser_SetPrepareValues(    uint32_t DispenserBuildPressureSpeed,
      DispenserPreparePressure = DispenserBuildPressureLimit;
      DispenserPrepareTimeout = DispenserBuildPressureTimeout;
      DispenserPrepareTimeLag = DispenserBuildPressureLag;
-     Report("IDS_Dispenser_SetPrepareValues ",__FILE__,__LINE__,DispenserPrepareSpeed,RpWarning,(int)DispenserPreparePressure,0);
+     Report("IDS_Dispenser_SetPrepareValues ",__FILE__,__LINE__,DispenserPrepareSpeed,RpWarning,(int)(DispenserPreparePressure*100),0);
      Report("IDS_Dispenser_SetPrepareValues ",__FILE__,__LINE__,DispenserPrepareTimeout,RpWarning,(int)DispenserPrepareTimeLag,0);
 }
 void IDS_Dispenser_SetTimeOutValues(uint32_t CloseTimeout, uint32_t OpenTimeout)
@@ -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 );
@@ -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)
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h
index e578d593a..51086b09e 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h
@@ -63,7 +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_StopHomeDispenserBuildPressure (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 9a0f23cbd..603c4ac66 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
@@ -59,9 +59,14 @@ FPGA_GPI_ENUM     Dispenser_Id_to_Alarm_LS_Id[MAX_SYSTEM_DISPENSERS*2] = {
       GPI_LS_DISPENSER_25_8, //MOTO_DISPENSER_8 = 13,
 };
 callback_fptr HomingRequestCallback[MAX_SYSTEM_DISPENSERS]={0,0,0,0,0,0,0,0};
+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];
+
 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};
+uint32_t DispenserBacklashControlId[MAX_SYSTEM_DISPENSERS] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
 uint32_t DispenserHomingTime[MAX_SYSTEM_DISPENSERS] = {0,0,0,0,0,0,0,0};
 #define INITIAL_DISPENSER_PRESSURE 2.10
 #define INITIAL_DISPENSER_TIMEOUT_LIMIT 60000
@@ -73,6 +78,9 @@ uint32_t InitialDispenserTimeout = INITIAL_DISPENSER_TIMEOUT_LIMIT;
 uint32_t InitialDispenserTimeLag = INITIAL_DISPENSER_TIMEOUT;
 uint32_t InitialDispenserSpeed = INITIAL_DISPENSER_SPEED;
 
+uint32_t IDS_StopHomeDispenserBuildPressure (uint32_t deviceID);
+
+
 void IDS_Dispenser_SetBackLashValues(double   initialdispenserpressure,   uint32_t initialdispensertimeout,   uint32_t initialdispensertimelag,   uint32_t initialdispenserspeed)
 {
     InitialDispenserPressure = initialdispenserpressure;
@@ -82,6 +90,49 @@ void IDS_Dispenser_SetBackLashValues(double   initialdispenserpressure,   uint32
 
     Report("IDS_Dispenser_SetBackLashValues ",__FILE__,InitialDispenserPressure,InitialDispenserTimeout,RpWarning,(int)InitialDispenserTimeLag,0);
 }
+uint32_t IDS_HomeDispenserWaitForHomingEndCallback(uint32_t DispenserId, uint32_t ReadValue)
+{
+    HomingBacklashTime[DispenserId]+=eOneSecond;
+    if (( HomingActive[DispenserId]== false) ||((HomingBacklashTime[DispenserId]>=HomingBacklashTimeout[DispenserId])&&(HomingBacklashTimeout[DispenserId]>0)))
+       {
+           //stop this control loop
+           SafeRemoveControlCallback(DispenserBacklashControlId[DispenserId], IDS_HomeDispenserWaitForHomingEndCallback );
+           DispenserBacklashControlId[DispenserId] = 0xFF;
+
+           if (HomingBacklashCallback[DispenserId])
+           {
+               if ( HomingActive[DispenserId]== false)
+                   HomingBacklashCallback[DispenserId](DispenserId,OK);
+               else
+                   HomingBacklashCallback[DispenserId](DispenserId,ERROR);
+           }
+           HomingBacklashCallback[DispenserId] = 0;
+       }
+    return OK;
+}
+uint32_t IDS_HomeDispenserWaitForHomingEnd(uint32_t DispenserId,  uint32_t timeout , callback_fptr callback)
+{
+    assert(DispenserId < MAX_SYSTEM_DISPENSERS);
+
+    if (HomingBacklashCallback[DispenserId]!=NULL)
+        return ERROR;
+    HomingBacklashCallback[DispenserId] = callback;
+    HomingBacklashTimeout[DispenserId] = timeout;
+    HomingBacklashTime[DispenserId] = 0;
+
+    if (DispenserBacklashControlId[DispenserId] != 0xFF)
+    {
+        RemoveControlCallback(DispenserBacklashControlId[DispenserId], IDS_HomeDispenserWaitForHomingEndCallback );
+        DispenserBacklashControlId[DispenserId] = 0xFF;
+        //return ERROR;
+    }
+    DispenserBacklashControlId[DispenserId] = AddControlCallback( IDS_HomeDispenserWaitForHomingEnd,eOneSecond , TemplateDataReadCBFunction,DispenserId,0, 0 );
+    if ( DispenserBacklashControlId[DispenserId] == 0xFF)
+        return ERROR;
+
+    return OK;
+}
+
 uint32_t IDS_HomeDispenserBackMoveCallback(uint32_t motorId, uint32_t ReadValue)
 {
     uint8_t DispenserId = motorId-HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1;
@@ -135,6 +186,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");
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
index e3ecd5d55..7a719d39a 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
@@ -104,6 +104,9 @@ int lInterSegmentLength = 0;
          LeftRockerSpeed = ids_leftcleaningmotorspeed;
      if ( ids_rightcleaningmotorspeed)
          RighttRockerSpeed = ids_rightcleaningmotorspeed;
+     Report("IDS_Dispenser_SetPreSegmentCleaningValues ",__FILE__,__LINE__,CleaningDispenserSpeed,RpWarning,(int)LeftRockerSpeed,0);
+     Report("IDS_Dispenser_SetPreSegmentCleaningValues ",__FILE__,__LINE__,InterSegmentStartSprayCleaner,RpWarning,(int)InterSegmentCenterRockers,0);
+
  }
 
  uint32_t DispenserPreSegmentControlId = 0xFF;
@@ -602,7 +605,7 @@ c.  Go to step 2.a x Segment.BrushStopsCount.
              {
                  NumofReadyDispensers++;
                  tempSpeed = CurrentDispenserSpeed[i];
-                 updatedSpeed = (tempSpeed*0.95>100)?tempSpeed*0.95:100;
+                 updatedSpeed = (tempSpeed*0.98>100)?tempSpeed*0.98:100;
                  MotorSetSpeed(HW_Motor_Id, updatedSpeed);
                  CurrentDispenserSpeed[i] = updatedSpeed;
                  //Report("IDS reduce speed",__FILE__,i,(int)tempSpeed,RpWarning,(int)updatedSpeed,0);
@@ -610,7 +613,7 @@ c.  Go to step 2.a x Segment.BrushStopsCount.
              else
              {
                  tempSpeed = CurrentDispenserSpeed[i];
-                 updatedSpeed = (tempSpeed*1.1<1000)?tempSpeed*1.1:1000;
+                 updatedSpeed = (tempSpeed*1.04<1000)?tempSpeed*1.04:1000;
                  MotorSetSpeed(HW_Motor_Id, updatedSpeed);
                  CurrentDispenserSpeed[i] = updatedSpeed;
                  //Report("IDS accelerate speed",__FILE__,i,(int)tempSpeed,RpWarning,(int)updatedSpeed,0);
@@ -683,6 +686,19 @@ c.  Go to step 2.a x Segment.BrushStopsCount.
     }
     return OK;
 }
+ uint32_t IDSPrepareStartDispenserAfterHoming(uint32_t DispenserId, uint32_t Result)
+ {
+     double dispenserspeed = 0;
+     Report("IDSPrepare Start Dispenser After Homing",__FILE__,__LINE__,DispenserId,RpWarning,(int)Result,0);
+     dispenserspeed = DispenserPrepareSpeed;
+     if (DispenserUsedInJob[DispenserId] == true) //we actually should check for all dispensers
+     {
+         Report("Prepare Speed",__FILE__,__LINE__,DispenserId,RpWarning,(int)dispenserspeed,0);
+         IDS_Dispenser_Start_Motor_and_Open_Valve(DispenserId,dispenserspeed, NULL);
+     }
+     return OK;
+
+ }
  void IDSPrepareStart(void)
  {
      int i;
@@ -697,9 +713,9 @@ c.  Go to step 2.a x Segment.BrushStopsCount.
      NumOfActiveDispensers = 0;
      for (i = 0; i < MAX_DYE_DISPENSERS; i++)
      {
-         //IDS_StopHomeDispenser(i);
          if (DispenserUsedInJob[i] == true) //we actually should check for all dispensers
          {
+             IDS_StopHomeDispenser(i);
              NumOfActiveDispensers++;
          }
      }
@@ -711,8 +727,16 @@ c.  Go to step 2.a x Segment.BrushStopsCount.
              dispenserspeed = DispenserPrepareSpeed;
              if (DispenserUsedInJob[i] == true) //we actually should check for all dispensers
              {
-                 Report("Prepare Speed",__FILE__,__LINE__,i,RpWarning,(int)dispenserspeed,0);
-                 IDS_Dispenser_Start_Motor_and_Open_Valve(i,dispenserspeed, NULL);
+                 if (HomingActive[i] == false)
+                 {
+                     Report("Prepare Speed",__FILE__,__LINE__,i,RpWarning,(int)dispenserspeed,0);
+                     IDS_Dispenser_Start_Motor_and_Open_Valve(i,dispenserspeed, NULL);
+                 }
+                 else
+                 {
+                     Report("IDSPrepare Stop Dispenser Homing",__FILE__,__LINE__,i,RpWarning,(int)HomingActive[i],0);
+                     IDS_HomeDispenserWaitForHomingEnd(i,  DispenserPrepareTimeout/2 , IDSPrepareStartDispenserAfterHoming);
+                 }
              }
          }
      }
@@ -742,7 +766,7 @@ c.  Go to step 2.a x Segment.BrushStopsCount.
 
       if (DispenserBuildTimeCounter<(1*eOneSecond))
       {
-          REPORT_MSG(DispenserBuildTimeCounter,"waiting 1 seconds for pressure changes");
+          //REPORT_MSG(DispenserBuildTimeCounter,"waiting 1 seconds for pressure changes");
           return OK;
       }
       if (PreSegmentWCFStarted == true)
@@ -762,7 +786,7 @@ c.  Go to step 2.a x Segment.BrushStopsCount.
               {
                   NumofReadyDispensers++;
                   tempSpeed = CurrentDispenserSpeed[i];
-                  updatedSpeed = (tempSpeed*0.95>100)?tempSpeed*0.95:100;
+                  updatedSpeed = (tempSpeed*0.98>100)?tempSpeed*0.98:100;
                   MotorSetSpeed(HW_Motor_Id, updatedSpeed);
                   CurrentDispenserSpeed[i] = updatedSpeed;
                   //Report("IDS PreSegment reduce speed",__FILE__,i,(int)tempSpeed,RpWarning,(int)updatedSpeed,0);
@@ -770,7 +794,7 @@ c.  Go to step 2.a x Segment.BrushStopsCount.
               else
               {
                   tempSpeed = CurrentDispenserSpeed[i];
-                  updatedSpeed = (tempSpeed*1.1<1000)?tempSpeed*1.1:1000;
+                  updatedSpeed = (tempSpeed*1.04<1100)?tempSpeed*1.04:1100;
                   MotorSetSpeed(HW_Motor_Id, updatedSpeed);
                   CurrentDispenserSpeed[i] = updatedSpeed;
                   //Report("IDS PreSegment accelerate speed",__FILE__,i,(int)tempSpeed,RpWarning,(int)updatedSpeed,0);
@@ -779,14 +803,14 @@ c.  Go to step 2.a x Segment.BrushStopsCount.
       }
 
       if ((NumofReadyDispensers)&&(DispenserBuildTimeCounter%1000 == 0))
-          Report("IDS_PreSegmentPrepare_Callback",__FILE__,DispenserBuildTimeCounter,NumofReadyDispensers,RpWarning,(int)NumOfActiveDispensers,0);
+          Report("IDS_PreSegmentPrepare_Callback",__FILE__,DispenserBuildTimeCounter,InterSegmentStepsCount,RpWarning,(int)NumOfActiveDispensers,0);
 
       if (NumofReadyDispensers>=NumOfActiveDispensers)
           pressureReady = true;
 
       if ((DispenserBuildTimeCounter >= DispenserPrepareTimeout)||(pressureReady == true))
       {
-          Report("IDS_PreSegmentPrepare_Callback SafeRemoveControlCallback",__FILE__,DispenserPrepareControlId,NumofReadyDispensers,RpWarning,(int)NumOfActiveDispensers,0);
+          Report("IDS_PreSegmentPrepare_Callback SafeRemoveControlCallback",__FILE__,DispenserPrepareControlId,InterSegmentStepsCount,RpWarning,(int)NumOfActiveDispensers,0);
           SafeRemoveControlCallback(DispenserPrepareControlId, IDS_Prepare_Callback );
           DispenserPrepareControlId = 0xFF;
 
@@ -797,7 +821,7 @@ c.  Go to step 2.a x Segment.BrushStopsCount.
   //********************************************************************************************************************
  void IDSPresegmentPrepareStart(void)
  {
-     int i;
+
      int Dispenser_i,n_dispensers,DispenserId;
      TimerMotors_t HW_Motor_Id;
      double segmentfirst_speed;
@@ -834,16 +858,16 @@ c.  Go to step 2.a x Segment.BrushStopsCount.
                      DispenserUsedInSegment[Dispenser_i] = true;
                      MotorSetSpeed(HW_Motor_Id, DispenserPrepareSpeed);
                      CurrentDispenserSpeed[Dispenser_i] = DispenserPrepareSpeed;
-                     usnprintf(IdsMessage, 80,"WFCF Prepare Dispenser %d speed %d",DispenserId,(int) segmentfirst_speed);
+                     usnprintf(IdsMessage, 80,"Presegment Prepare Dispenser %d speed %d",DispenserId,(int) DispenserPrepareSpeed);
                      //REPORT_MSG(segmentfirst_speed,IdsMessage);
-                     Report(IdsMessage, __FILE__, __LINE__, Dispenser_i, RpWarning,   segmentfirst_speed, 0);
+                     Report(IdsMessage, __FILE__, __LINE__, Dispenser_i, RpWarning,   DispenserPrepareSpeed, 0);
                      //SendJobProgress(0.0, 0, false, IdsMessage);
                  }
                  else
                  {
                      MotorStop(HW_Motor_Id, Hard_Hiz);
                      CurrentDispenserSpeed[Dispenser_i] = 0;
-                     usnprintf(IdsMessage, 80,"WFCF Prepare Dispenser %d stopped",DispenserId,(int) segmentfirst_speed);
+                     usnprintf(IdsMessage, 80,"Presegment Prepare Dispenser %d stopped",DispenserId,(int) segmentfirst_speed);
                      Report(IdsMessage, __FILE__, __LINE__, Dispenser_i, RpWarning,   segmentfirst_speed, 0);
 
                  }
@@ -957,7 +981,7 @@ uint32_t IDS_Cleaning_Stop_Cleaning_Solution (callback_fptr callback);
      {
          IDS_PreSegmentPrepare_Callback(0,0);
      }
-     if ((InterSegmentStartWFCFDispensers > 0)&&(InterSegmentStartWFCFDispensers == InterSegmentStepsCount))
+     if ((InterSegmentStartWFCFDispensers > 0)&&(InterSegmentStartWFCFDispensers == (lInterSegmentLength-InterSegmentStepsCount)))
      {
          Report("start dispensers at rate * WFCF",__FILE__,__LINE__,InterSegmentStepsCount,RpWarning,(int)lInterSegmentLength,0);
          PreSegmentWCFStarted = true; // stop any presegment prepare stages, if still exist
@@ -1445,7 +1469,7 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId)
              InterSegmentStartRocking = 1000;
              InterSegmentCenterRockers = 3000;
          }*/
-         InterSegmentStartWFCFDispensers = 0;
+         //InterSegmentStartWFCFDispensers = 0;
 
 
      return OK;
@@ -1456,7 +1480,7 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId)
      //TimerMotors_t  HW_Motor_Id = DispenserIdToMotorId[deviceID];
      //REPORT_MSG(deviceID,"Dispenser End called");
      //MotorStop(HW_Motor_Id,Hard_Hiz);
-     //IDS_HomeDispenser (deviceID, 800 , NULL);
+     //IDS_HomeDispenser (deviceID, 1000 , NULL);
 
      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..d18833ca6 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
@@ -37,6 +37,20 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
         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();
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
index 7e1312464..0ac23baf5 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)
 {
@@ -132,8 +133,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 +179,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 +207,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 +215,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;
@@ -302,13 +310,27 @@ 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
+     WinderRun = abs(ScrewLocationRun[1] - ScrewLocationRun[0]);
+     if (WinderRun < 50000)
+     {
+         WinderRunSum+=WinderRun;
+         WinderRunSamples++;
+         WinderRunAverage = WinderRunSum/WinderRunSamples;
+         if ((fabs(WinderRun-WinderRunAverage)>=50)||(WinderRunSamples%50 == 0))
+         {
+             usnprintf(ScrewStr, 150, "curr,sum,avg,samples {Winder Encoder:, %d, %d, %d, %d }",WinderRun,(int)WinderRunSum,(int)WinderRunAverage,(int)WinderRunSamples);
+             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 +639,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/Waste/Waste.h b/Software/Embedded_SW/Embedded/Modules/Waste/Waste.h
index a0a758b94..5242aa3b1 100644
--- a/Software/Embedded_SW/Embedded/Modules/Waste/Waste.h
+++ b/Software/Embedded_SW/Embedded/Modules/Waste/Waste.h
@@ -24,10 +24,19 @@
 
 typedef unsigned char U8;
 
+
+typedef enum
+{
+    CYAN = 1,
+    MAGENTA,
+    YELLOW,
+    BLACK
+} CMYK_color;
+
 typedef enum
 {
-    WHS_CarteidgeNotPrecense = 0,
-    WHS_CarteidgePrecense
+    CarteidgeNotPrecense = 0,
+    CarteidgePrecense
 } WHS_CarteidgPrecenseSensorStatus;
 
 typedef enum
@@ -55,7 +64,8 @@ typedef enum
     WHS_emptying,
     WHS_full,
     WHS_overflow,
-    WHS_sttError
+    WHS_sttError,
+    INK_isOK
 } WHS_sttMachin;
 
 typedef enum
@@ -64,21 +74,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 +122,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 +143,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..c7054e3bb 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,9 +141,103 @@ 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;
+    switch (WHS_info.Ink.cart_color) //todo enter the correct color from RFID
+    {
+        case CYAN :
+
+            Valve_Set( VALVE_2W_CART_MID_1, action);     //Cartridge_MidTank_ON Cartridge_MidTank_OFF
+            Valve_Set( VALVE_2W_MID_AIR_1 , action);
+            break;
+        case MAGENTA :
+            Valve_Set( VALVE_2W_CART_MID_5, action);
+            Valve_Set( VALVE_2W_MID_AIR_5 , action);
+           break;
+        case YELLOW :
+            Valve_Set( VALVE_2W_CART_MID_2, action);
+            Valve_Set( VALVE_2W_MID_AIR_2 , action);
+            break;
+        case BLACK :
+            Valve_Set( VALVE_2W_CART_MID_6, action);
+            Valve_Set( VALVE_2W_MID_AIR_6 , action);
+           break;
+        case 5 :
+            Valve_Set( VALVE_2W_CART_MID_3, action);
+            Valve_Set( VALVE_2W_MID_AIR_3 , action);
+           break;
+        case 6 :
+            Valve_Set( VALVE_2W_CART_MID_7, action);
+            Valve_Set( VALVE_2W_MID_AIR_7 , action);
+           break;
+        case 7 :
+            Valve_Set( VALVE_2W_CART_MID_4, action);
+            Valve_Set( VALVE_2W_MID_AIR_4 , action);
+            break;
+        case 8 :
+            Valve_Set( VALVE_2W_CART_MID_8, action);
+            Valve_Set( VALVE_2W_MID_AIR_8 , action);
+           break;
+        default: //wrong color
+            break;
+    }
+    ret = true;
+    return ret;
+}
+
+bool ColorMatch()
+{
+    bool ret =  false;
+
+    ret = true;
+    return ret;
+}
+
 bool WHS_IsEmptying()
 {
     bool ret =  false;
@@ -119,10 +248,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++;
 
-bool RdWasteCartridgeParam(cartridge_name cart_name)
+    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);
+
+    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 +345,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 +447,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 +497,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 +513,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 +615,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 +670,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 +698,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 +729,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 +738,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 +800,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 +834,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 +991,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 +1002,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 +1028,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 +1040,7 @@ bool WasteTankCBFunction()
                         {
 
                         }
-                        RdWasteCartridgeParam(waste_cartridge2);
+                        RdCartridgeParam(waste_cartridge2);
                        WHS_info.WHS_valve = waste_cartridge1;
                        */
                     }
@@ -662,6 +1051,40 @@ 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 ----------------- ");
+            REPORT_MSG(WHS_full," ------------ Display Mid-tank # filling fail ----------------- ");
+            MidTankValvesAction(Cartridge_MidTank_OFF);
+            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 +1095,8 @@ bool WasteTankCBFunction()
 }
 
 
+
+
 /*------------------------------- Cartridge  Cover       -----------------------------------------*/
 
 bool RdCartridgeCoverSensor()
@@ -684,8 +1109,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 +1130,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.time_out) >= 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))
+        {
+            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 +1233,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 +1311,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 +1463,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 +1486,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 +1882,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 +1907,7 @@ uint32_t start_WHS_machin()
 //                //???{
 //                //???
 //                //???}
-//                //???        RdWasteCartridgeParam(waste_cartridge2);
+//                //???        RdCartridgeParam(waste_cartridge2);
 //                //???WHS_info.WHS_valve = waste_cartridge1;
 //            }
 //
@@ -1378,7 +1916,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 +1942,7 @@ uint32_t start_WHS_machin()
 //                {
 //
 //                }
-//                RdWasteCartridgeParam(waste_cartridge2);
+//                RdCartridgeParam(waste_cartridge2);
 //               WHS_info.WHS_valve = waste_cartridge1;
 //
 //            }