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

24 files changed, 440 insertions, 196 deletions

diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
index e754b0df2..eceb92d63 100644
--- a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
+++ b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
@@ -631,8 +631,16 @@ JobEndReasonEnum getEndReason(uint32_t AlarmId)
     switch (AlarmItem[AlarmId].AlarmSource)
     {
         case ALARM_SOURCE_TYPE__TemperatureAlarm:
-            usnprintf(AlarmReasonStr, 100, "Temperature problem in heater %d",AlarmItem[AlarmId].DeviceId);
-            return JOB_TEMPERATURE_ALARM;
+            if (AlarmItem[AlarmId].Severity == DEBUG_LOG_CATEGORY__Critical)
+            {
+                usnprintf(AlarmReasonStr, 100, "Safety Critical Alarm %d",AlarmItem[AlarmId].EventType);
+                return JOB_SAFETY_CRITICAL_ALARM;
+            }
+            else
+            {
+                usnprintf(AlarmReasonStr, 100, "Temperature problem in heater %d",AlarmItem[AlarmId].DeviceId);
+                return JOB_TEMPERATURE_ALARM;
+            }
         case ALARM_SOURCE_TYPE__LimitSwitchAlarm:
             usnprintf(AlarmReasonStr, 100, "Dispenser %d empty",AlarmItem[AlarmId].DeviceId);
             return JOB_OUT_OF_DYE;
@@ -987,13 +995,20 @@ JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob)
     }
     if ((IFS_Availability[1] == IFS_RECOGNIZED_INIT_PASSED)&&(IFS_Availability[2] == IFS_RECOGNIZED_INIT_PASSED)) //ifs installed -check cartridges
     {
-
-        tempFoundReason = Waste_CheckState(&AlarmId);
-        if (tempFoundReason!=JOB_OK)
-        {
-            FoundReason = tempFoundReason;
-            ReportWithPackageFilter(AlarmFilter,"waste handling alarm preventing job", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, AlarmItem[Alarm_i].Severity, AlarmItem[Alarm_i].DeviceId, 0);
-        }
+            tempFoundReason = Waste_CheckState(&AlarmId);
+            if (tempFoundReason!=JOB_OK)
+            {
+                for (Alarm_i = 0;Alarm_i<NumOfSystemAlarms;Alarm_i++)
+                {
+                    if (AlarmId == (AlarmItem[Alarm_i].EventType))
+                    {
+                        FoundReason = tempFoundReason;
+                        AlarmId = Alarm_i;
+                        ReportWithPackageFilter(AlarmFilter,"waste handling alarm preventing job", __FILE__,AlarmId,AlarmItem[Alarm_i].EventType, AlarmItem[Alarm_i].Severity, AlarmItem[Alarm_i].DeviceId, 0);
+                        break;
+                    }
+                }
+            }
     }
     if ((AlarmState[Alarm_i].Status == true)&&(FoundReason == JOB_OK))
     {
@@ -1025,6 +1040,18 @@ JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob)
     if (FoundReason == JOB_OK)
     {
         FoundReason = Winder_Check_Cone();
+        if (FoundReason!=JOB_OK)
+        {
+            for (Alarm_i = 0;Alarm_i<NumOfSystemAlarms;Alarm_i++)
+            {
+                if (AlarmItem[Alarm_i].EventType == EVENT_TYPE__WINDER_CONE_DOES_NOT_EXIST)
+                {
+                    AlarmId = Alarm_i;
+                    ReportWithPackageFilter(AlarmFilter,"cone not in place - preventing job", __FILE__,AlarmId,AlarmItem[Alarm_i].EventType, AlarmItem[Alarm_i].Severity, AlarmItem[Alarm_i].DeviceId, 0);
+                    break;
+                }
+            }
+        }
     }
     if (FoundReason != JOB_OK)
     {
diff --git a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
index 1057ddbc3..3de362af9 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
+++ b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
@@ -524,11 +524,13 @@ int TemperatureSum[MAX_HEAD_CARD_TEMP_SENS_ID];
 int TemperatureMin[MAX_HEAD_CARD_TEMP_SENS_ID];
 int TemperatureMax[MAX_HEAD_CARD_TEMP_SENS_ID];
 int TemperatureCount[MAX_HEAD_CARD_TEMP_SENS_ID];
-int TemperatureCalc[MAX_HEAD_CARD_TEMP_SENS_ID];
+int TemperatureCalc[MAX_HEAD_CARD_TEMP_SENS_ID] = {2.1,2.1,2.1,2.1,2.1,2.1,2.1,2.1,2.1,2.1,2.1,2.1,2.1,2.1,2.1,2.1,2.1,2.1,2.1,2.1,2.1,2.1,2.1,2.1,2.1,2.1,2.1};
 void MillisecUpdateTemperatures (TEMPERATURE_SENSOR_ID_ENUM SensorId,int temperature)
 {
    //if(TemperatureCount[SensorId]++>=10)
    //    TemperatureCount[SensorId] = 0;
+    if ((temperature>28000)||(temperature<900))
+        return;
     TemperatureCount[SensorId]++;
     if (TemperatureMax[SensorId]<temperature) TemperatureMax[SensorId]=temperature;
     if (TemperatureMin[SensorId]>temperature) TemperatureMin[SensorId]=temperature;
@@ -540,7 +542,11 @@ int MillisecCalculateTemperatures (TEMPERATURE_SENSOR_ID_ENUM SensorId)
     TemperatureSum[SensorId]-=TemperatureMax[SensorId];
     TemperatureSum[SensorId]-=TemperatureMin[SensorId];
     calc = TemperatureSum[SensorId] / (TemperatureCount[SensorId]-2);
-
+    if (TemperatureSum[SensorId]>10)
+    {
+        if(abs(TemperatureMax[SensorId]-TemperatureMin[SensorId])>2000)
+                Report("Millisec Temp spike",__FILE__,SensorId,(int)TemperatureMax[SensorId],RpWarning,(int) TemperatureMin[SensorId],0);
+    }
     TemperatureSum[SensorId] = 0;
     TemperatureCount[SensorId] = 0;
     TemperatureMin[SensorId] = 30000;
@@ -703,14 +709,14 @@ uint32_t MillisecLowLoop(uint32_t tick)
 
         Trigger_InputsReading();
 
-        #ifdef USE_RFID
+        #ifdef USE_RFID_LOGIC
             //every 100 m sec
             for(readerID = READER_1; readerID < Max_Readers ; readerID++)
             {
                 if(DiscoverRFIDTagEvery100mSec[readerID] == true)
                 {
                     RFIDCallEvery100mSec(readerID);
-                    break;
+                    //break;
                 }
             }
         #endif
@@ -821,12 +827,13 @@ uint32_t MillisecLowLoop(uint32_t tick)
         //call IFS state machine
         midTankStateMachine();
 
-        #ifdef USE_RFID
-                RFIDCycleEvery1Sec();
-        #endif
+
     }
     if (Tensecond_Tick)
     {
+	#ifdef USE_RFID_LOGIC
+	        RFIDCycleEvery1Sec();
+	#endif
     }
     if (OneMinute_Tick)
     {
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
index cfd4db0e6..11a48b587 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
@@ -545,23 +545,15 @@ void CopyTemperaturesToMonitor(void)
         headblowervoltage2 = HeadBlowersGetRPM(HEAD_FAN_LEFT);
         DiagnosticsMonitor.headblowervoltage1 = &headblowervoltage1;
         DiagnosticsMonitor.headblowervoltage2 = &headblowervoltage2;
-#warning machine to machine test
+//#warning machine to machine test
         DiagnosticsMonitor.headzone4temperature =
                 HeaterTemperature[HEATER_TYPE__HeaterZone4];
-        DiagnosticsMonitor.headzone6temperature =
-                HeaterTemperature[HEATER_TYPE__HeaterZone6];
-        DiagnosticsMonitor.headzone8temperature =
-                HeaterTemperature[HEATER_TYPE__HeaterZone8];
         DiagnosticsMonitor.headzone9temperature =
                 HeaterTemperature[HEATER_TYPE__HeaterZone9];
         DiagnosticsMonitor.headzone10temperature =
                 HeaterTemperature[HEATER_TYPE__HeaterZone10];
         DiagnosticsMonitor.n_headzone4temperature =
                 HeaterCounterIndex[HEATER_TYPE__HeaterZone4];
-        DiagnosticsMonitor.n_headzone6temperature =
-                HeaterCounterIndex[HEATER_TYPE__HeaterZone6];
-        DiagnosticsMonitor.n_headzone8temperature =
-                HeaterCounterIndex[HEATER_TYPE__HeaterZone8];
         DiagnosticsMonitor.n_headzone9temperature =
                 HeaterCounterIndex[HEATER_TYPE__HeaterZone9];
         DiagnosticsMonitor.n_headzone10temperature =
@@ -1013,8 +1005,6 @@ void DiagnosticOneSecCollection(void)
         DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone12, MillisecGetTemperatures(HEAD_PT100_ZONE_12_0X8A_1));
 #warning MACHINE TO MACHINE TEST
         DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone4, MillisecGetTemperatures(HEAD_PT100_ZONE_4_0X82_1));
-        DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone6, MillisecGetTemperatures(HEAD_PT100_ZONE_6_0X84_1));
-        DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone8, MillisecGetTemperatures(HEAD_PT100_ZONE_8_0X86_1));
         DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone9, MillisecGetTemperatures(HEAD_PT100_ZONE_9_0X88_0));
         DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone10, MillisecGetTemperatures(HEAD_PT100_ZONE_10_0X88_1));
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.h b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.h
index 7ec1962f3..e0afad820 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.h
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.h
@@ -54,6 +54,7 @@ uint32_t SetBlowerStateRequestFunc(MessageContainer* requestContainer);
 
 void DiaglosticChangeBlowerData();
 
+void HomingStopReporting(void);
 
 
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c
index c7f8740d1..086525bc1 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c
@@ -46,6 +46,16 @@ uint32_t Diagnostics_Dryer_UnLoading(void);
 uint32_t Diagnostics_Dryer_Loading(void);
 int kval_upper_value;
 
+void HomingStopReporting(void)
+{
+    int i;
+    for (i = 0; i< NUM_OF_MOTORS;i++)
+    {
+        HomingToken[i][0] == 0;
+    }
+    LOG_ERROR(0,"HomingStopReporting");
+}
+
 /********************************************************************************
  * Motor Homing
  ********************************************************************************/
@@ -475,7 +485,7 @@ uint32_t Diagnostics_Set_Load_Arm_To_Stopper_Callback(uint32_t deviceID, uint32_
 
     angle = Calculate_Arm_Distance(D_DrierPrevLocation,temp);
 
-    if ((angle<14000  )||(BusyFlag == BUSY)) // OK - take another round
+    if ((abs (angle)<14000  )||(BusyFlag == BUSY)) // OK - take another round
     {
         responseContainer.has_error = true;
         responseContainer.error = ERROR_CODE__GENERAL_ERROR;
@@ -611,7 +621,7 @@ uint32_t Diagnostics_Dryer_Loading_Callback(uint32_t MotorId, uint32_t ReadValue
     ReportWithPackageFilter(DiagnosticsFilter,"Diagnostics_Dryer_Loading_Callback",__FILE__,(int)angle,(int)ReadValue,RpMessage,temp,0);
 
     MCU_E2PromProgram(EEPROM_STORAGE_DRYER_CYCLES,D_numberOfCycles);
-    if ((angle>14000  )&&(ReadValue == NOTBUSY)) // OK - take another round
+    if ((abs(angle)>14000  )&&(ReadValue == NOTBUSY)) // OK - take another round
     {
         D_DrierPrevLocation = temp;
         //ReportWithPackageFilter(DiagnosticsFilter,"Diagnostics_Dryer_Loading_Callback",__FILE__,__LINE__,LoadStages,RpMessage,NumberOfDrierLoaderCycles,0);
diff --git a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
index 193a35e12..6c4293f6f 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
@@ -446,12 +446,19 @@ uint32_t HWConfiguration(UploadHardwareConfigurationRequest* UploadRequest)
         LOG_ERROR (0, "Wrong Data Allocation");
         return ERROR;
     }
-    if (InitFailures > 3)
+    if (InitFailures > REPEATED_INIT_FAILURE_LIMIT)
     {
         Report("HWConfigurationInit repeated failure",__FILE__,__LINE__,(int)InitFailures,RpWarning,(int)EEPROM_INIT_FAILURE_COUNTER,0);
         AlarmHandlingSetAlarm (EVENT_TYPE__POWER_UP_BIT_FAILURE,ON);
         return ERROR;
     }
+    else
+    {
+        if (InitFailures > 2)
+        {
+            Report("HWConfigurationInit repeated failure going up",__FILE__,__LINE__,(int)InitFailures,RpWarning,(int)EEPROM_INIT_FAILURE_COUNTER,0);
+        }
+    }
 
     HardwareConfiguration *request =    UploadRequest->hardwareconfiguration;
 
@@ -628,7 +635,6 @@ uint32_t HWConfiguration(UploadHardwareConfigurationRequest* UploadRequest)
     return OK;
 }
 char Serial[21];
-MidTankData MidTankInfo[MAX_SYSTEM_DISPENSERS];
 
 uint32_t MachineCalibrationDataRequestFunc(MessageContainer* requestContainer)
 {
@@ -636,6 +642,7 @@ uint32_t MachineCalibrationDataRequestFunc(MessageContainer* requestContainer)
     MachineCalibrationDataRequest *request = machine_calibration_data_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
     uint32_t *DancersData = my_malloc(MAX_SYSTEM_DANCERS*sizeof(uint32_t));
     MidTankData ** MidTankDataCollect = my_malloc(sizeof(MidTankData *)*MAX_SYSTEM_DISPENSERS);
+    MidTankData MidTankInfo[MAX_SYSTEM_DISPENSERS];
 
     int i;
     for (i = 0;i<MAX_SYSTEM_DANCERS;i++)
@@ -655,7 +662,8 @@ uint32_t MachineCalibrationDataRequestFunc(MessageContainer* requestContainer)
     //MCU_E2PromSerialNumRead(&Serial);
 
     MachineCalibrationDataResponse response = MACHINE_CALIBRATION_DATA_RESPONSE__INIT;
-    machine_calibration_data__init(&response.machinecalibrationdata);
+    response.machinecalibrationdata = my_malloc(sizeof(MachineCalibrationData));
+    machine_calibration_data__init(response.machinecalibrationdata);
     response.machinecalibrationdata->n_dancermiddlepoint = MAX_SYSTEM_DANCERS;
     response.machinecalibrationdata->dancermiddlepoint = DancersData;
     response.machinecalibrationdata->machineserialnumber = Serial;
@@ -885,7 +893,9 @@ void FlashInitAndLoad(void)
     }
     Report("Hardware Initialized", __FILE__,__LINE__,Bytes, RpMessage, GENHWCFG_MAP_IN_FLASH, 0);
 
-    StoreDancerConfigMessage();
+    StoreDancerConfigMessage(0);
+    StoreDancerConfigMessage(1);
+    StoreDancerConfigMessage(2);
     Report("Dancer Initialized", __FILE__,DancersCfg[0].zeropoint,DancersCfg[1].zeropoint, RpMessage, DancersCfg[2].zeropoint, 0);
     /*Bytes = AlarmHandlingLoadFile();
     if (Bytes>0)
diff --git a/Software/Embedded_SW/Embedded/Modules/General/MachineStatus.c b/Software/Embedded_SW/Embedded/Modules/General/MachineStatus.c
index 4c248e94b..bf68b64f0 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/MachineStatus.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/MachineStatus.c
@@ -245,7 +245,7 @@ return OK;
  * */
 
 char WasteEmptyingToken[36+1] = {0};
-uint32_t CartridgeStateUpdate(CartridgeSlot Slot,CartridgeState State, double percentage)
+uint32_t CartridgeStateUpdate(CartridgeSlot Slot, int32_t index, CartridgeState State, double percentage)
 {
     if (WasteEmptyingToken[0] == 0)
         return ERROR;
@@ -271,6 +271,9 @@ uint32_t CartridgeStateUpdate(CartridgeSlot Slot,CartridgeState State, double pe
     CartData.has_slot = true;
     CartData.slot = Slot;
 
+    CartData.has_index = true;
+    CartData.index = index;
+
     /*
         struct  _CartridgeStatus
         {
@@ -327,9 +330,9 @@ uint32_t StartInkFillingStatusRequestFunc(MessageContainer* requestContainer)
     StartInkFillingStatusRequest* request = start_ink_filling_status_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
     ustrncpy (WasteEmptyingToken, requestContainer->token,36);
 
-    CartridgeStateUpdate(CARTRIDGE_SLOT__Ink,CARTRIDGE_STATE__None,0);
-    CartridgeStateUpdate(CARTRIDGE_SLOT__WasteMiddle,CARTRIDGE_STATE__None,0);
-    CartridgeStateUpdate(CARTRIDGE_SLOT__WasteLower,CARTRIDGE_STATE__None,0);
+    CartridgeStateUpdate(CARTRIDGE_SLOT__Ink,0, CARTRIDGE_STATE__None,0);
+    CartridgeStateUpdate(CARTRIDGE_SLOT__WasteMiddle, 0, CARTRIDGE_STATE__None,0);
+    CartridgeStateUpdate(CARTRIDGE_SLOT__WasteLower, 1, CARTRIDGE_STATE__None,0);
     start_ink_filling_status_request__free_unpacked(request,NULL);
     return status;
 //    case MESSAGE_TYPE__StartWasteEmptyingRequest:
diff --git a/Software/Embedded_SW/Embedded/Modules/General/MachineStatus.h b/Software/Embedded_SW/Embedded/Modules/General/MachineStatus.h
index ed3ec205d..a9539e0fa 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/MachineStatus.h
+++ b/Software/Embedded_SW/Embedded/Modules/General/MachineStatus.h
@@ -19,7 +19,7 @@ void SetMachineStatus (MachineState State);
 int MachineUpdateResponseFunc(void);
 uint32_t StartInkFillingStatusRequestFunc(MessageContainer* requestContainer);
 
-uint32_t CartridgeStateUpdate(CartridgeSlot Slot,CartridgeState State, double percentage);
+uint32_t CartridgeStateUpdate(CartridgeSlot Slot, int32_t index, CartridgeState State, double percentage);
 
 
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_Blowers.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_Blowers.c
index 021dd243f..946958a08 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_Blowers.c
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_Blowers.c
@@ -92,8 +92,8 @@ void HeadBlowersInit()
     HeadBlowerControl[0].m_params.MAX = 200;
     HeadBlowerControl[0].m_params.MIN = -200;
     HeadBlowerControl[0].m_params.Kd = 0;
-    HeadBlowerControl[0].m_params.Kp = 350;
-    HeadBlowerControl[0].m_params.Ki = 25;
+    HeadBlowerControl[0].m_params.Kp = 800;
+    HeadBlowerControl[0].m_params.Ki = 80;
     HeadBlowerControl[0].m_params.IntegralErrorMultiplier = 10;
     HeadBlowerControl[0].m_params.ProportionalErrorMultiplier = 10;
     HeadBlowerControl[0].m_params.epsilon = 0;
@@ -110,8 +110,8 @@ void HeadBlowersInit()
     HeadBlowerControl[1].m_params.MAX = 200;
     HeadBlowerControl[1].m_params.MIN = -200;
     HeadBlowerControl[1].m_params.Kd = 0;
-    HeadBlowerControl[1].m_params.Kp = 350;
-    HeadBlowerControl[1].m_params.Ki = 25;
+    HeadBlowerControl[1].m_params.Kp = 800;
+    HeadBlowerControl[1].m_params.Ki = 80;
     HeadBlowerControl[1].m_params.IntegralErrorMultiplier = 10;
     HeadBlowerControl[1].m_params.ProportionalErrorMultiplier = 10;
     HeadBlowerControl[1].m_params.epsilon = 0;
@@ -212,108 +212,148 @@ uint32_t HeadBlowersOffGet()
     ReportWithPackageFilter(HeatersFilter,"HeadBlowersOffGet",__FILE__,__LINE__,HeadBlowersEnable,RpError, 0,0);
     return HeadBlowersEnable;
 }
+static int8_t count1 = 0, count2 = 0, count3 = 0, count4 = 0, count5 = 0;
+static int8_t count6 = 0, count7 = 0, count8 = 0, count9 = 0, count10 = 0;
+void setArcHeadAlarms(uint32_t AlarmId, bool value)
+{
+    AlarmHandlingSetAlarm(AlarmId, value);
+    if (value == true)
+    {
+        switch(AlarmId)
+        {
+            /*case EVENT_TYPE__DYEING_HEAD_ARC_LID_IS_OPEN:
+                ReportWithPackageFilter(HeatersFilter,"ArcHeadAlarms on",__FILE__,AlarmId,count9,RpError, 0,0);
+                break;
+            case EVENT_TYPE__DYEING_HEAD_TUNNEL_LID_IS_OPEN:
+                ReportWithPackageFilter(HeatersFilter,"ArcHeadAlarms on",__FILE__,AlarmId,count9,RpError, 0,0);
+                break;
+            case EVENT_TYPE__DYEING_HEAD_BLOWER_1_FAN_STOPPED:
+                ReportWithPackageFilter(HeatersFilter,"ArcHeadAlarms on",__FILE__,AlarmId,count9,RpError, 0,0);
+                break;
+            case EVENT_TYPE__DYEING_HEAD_BLOWER_2_FAN_STOPPED:
+                ReportWithPackageFilter(HeatersFilter,"ArcHeadAlarms on",__FILE__,AlarmId,count9,RpError, 0,0);
+                break;*/
+            case EVENT_TYPE__DYEING_HEAD_BLOWER_1_FAN_RPM_TOO_LOW:
+                ReportWithPackageFilter(HeatersFilter,"ArcHeadAlarms on",__FILE__,AlarmId,count3,RpError, HeadBlowersGetRPM(HEAD_FAN_RIGHT),0);
+                break;
+            case EVENT_TYPE__DYEING_HEAD_BLOWER_2_FAN_RPM_TOO_LOW:
+                ReportWithPackageFilter(HeatersFilter,"ArcHeadAlarms on",__FILE__,AlarmId,count4,RpError, HeadBlowersGetRPM(HEAD_FAN_LEFT),0);
+                break;
+            case EVENT_TYPE__DYEING_HEAD_BLOWER_1_FLOW_TOO_HIGH:
+                ReportWithPackageFilter(HeatersFilter,"ArcHeadAlarms on",__FILE__,AlarmId,count5,RpError, PressureSensorGetPressure(HEAD_FAN_RIGHT),0);
+                break;
+            case EVENT_TYPE__DYEING_HEAD_BLOWER_2_FLOW_TOO_HIGH:
+                ReportWithPackageFilter(HeatersFilter,"ArcHeadAlarms on",__FILE__,AlarmId,count7,RpError, PressureSensorGetPressure(HEAD_FAN_LEFT),0);
+                break;
+            case EVENT_TYPE__DYEING_HEAD_BLOWER_1_FLOW_TOO_LOW:
+                ReportWithPackageFilter(HeatersFilter,"ArcHeadAlarms on",__FILE__,AlarmId,count6,RpError, PressureSensorGetPressure(HEAD_FAN_RIGHT),0);
+                break;
+            case EVENT_TYPE__DYEING_HEAD_BLOWER_2_FLOW_TOO_LOW:
+                ReportWithPackageFilter(HeatersFilter,"ArcHeadAlarms on",__FILE__,AlarmId,count8,RpError, PressureSensorGetPressure(HEAD_FAN_LEFT),0);
+                break;
+        }
+    }
+}
 
 void ArcHeadAlarms(void)
 {
     double currentFlow = 0.0;
-    static int8_t count1 = 0, count2 = 0, count3 = 0, count4 = 0, count5 = 0;
-    static int8_t count6 = 0, count7 = 0, count8 = 0, count9 = 0, count10 = 0;
 
     if (FPGA_Read_limit_Switches(I2C_HEADCARD_COVER_LS_ARC) != LIMIT) {
         if (++count9 == ARC_ALARM_LIMIT)
-            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_ARC_LID_IS_OPEN, true);
+            setArcHeadAlarms(EVENT_TYPE__DYEING_HEAD_ARC_LID_IS_OPEN, true);
         count9 = (count9 > ARC_ALARM_LIMIT)?(ARC_ALARM_LIMIT):(count9);
     } else {
         if (--count9 == 0)
-            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_ARC_LID_IS_OPEN, false);
+            setArcHeadAlarms(EVENT_TYPE__DYEING_HEAD_ARC_LID_IS_OPEN, false);
         count9 = (count9 < 0)?(0):(count9);
     }
 
     if (FPGA_Read_limit_Switches(I2C_HEADCARD_COVER_LS_TUNNEL_ARC) != LIMIT) {
         if (++count10 == ARC_ALARM_LIMIT)
-            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_TUNNEL_LID_IS_OPEN, true);
+            setArcHeadAlarms(EVENT_TYPE__DYEING_HEAD_TUNNEL_LID_IS_OPEN, true);
         count10 = (count10 > ARC_ALARM_LIMIT)?(ARC_ALARM_LIMIT):(count10);
     } else {
         if (--count10 == 0)
-            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_TUNNEL_LID_IS_OPEN, false);
+            setArcHeadAlarms(EVENT_TYPE__DYEING_HEAD_TUNNEL_LID_IS_OPEN, false);
         count10 = (count10 < 0)?(0):(count10);
     }
 
     if (Head_Fan_Tach[0] == 0x1FFE) {
         if (++count1 == ARC_ALARM_LIMIT)
-            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_1_FAN_STOPPED, true);
+            setArcHeadAlarms(EVENT_TYPE__DYEING_HEAD_BLOWER_1_FAN_STOPPED, true);
         count1 = (count1 > ARC_ALARM_LIMIT)?(ARC_ALARM_LIMIT):(count1);
     } else {
         if (--count1 == 0)
-            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_1_FAN_STOPPED, false);
+            setArcHeadAlarms(EVENT_TYPE__DYEING_HEAD_BLOWER_1_FAN_STOPPED, false);
         count1 = (count1 < 0)?(0):(count1);
     }
     if (Head_Fan_Tach[1] == 0x1FFE) {
         if (++count2 == ARC_ALARM_LIMIT)
-            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_2_FAN_STOPPED, true);
+            setArcHeadAlarms(EVENT_TYPE__DYEING_HEAD_BLOWER_2_FAN_STOPPED, true);
         count2 = (count2 > ARC_ALARM_LIMIT)?(ARC_ALARM_LIMIT):(count2);
     } else {
         if (--count2 == 0)
-            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_2_FAN_STOPPED, false);
+            setArcHeadAlarms(EVENT_TYPE__DYEING_HEAD_BLOWER_2_FAN_STOPPED, false);
         count2 = (count2 < 0)?(0):(count2);
     }
 
     if (HeadBlowersGetRPM(HEAD_FAN_RIGHT) < 2000) {
         if (++count3 == ARC_ALARM_LIMIT)
-            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_1_FAN_RPM_TOO_LOW, true);
+            setArcHeadAlarms(EVENT_TYPE__DYEING_HEAD_BLOWER_1_FAN_RPM_TOO_LOW, true);
         count3 = (count3 > ARC_ALARM_LIMIT)?(ARC_ALARM_LIMIT):(count3);
     } else {
         if (--count3 == 0)
-            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_1_FAN_RPM_TOO_LOW, false);
+            setArcHeadAlarms(EVENT_TYPE__DYEING_HEAD_BLOWER_1_FAN_RPM_TOO_LOW, false);
         count3 = (count3 < 0)?(0):(count3);
     }
     if (HeadBlowersGetRPM(HEAD_FAN_LEFT) < 2000) {
         if (++count4 == ARC_ALARM_LIMIT)
-            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_2_FAN_RPM_TOO_LOW, true);
+            setArcHeadAlarms(EVENT_TYPE__DYEING_HEAD_BLOWER_2_FAN_RPM_TOO_LOW, true);
         count4 = (count4 > ARC_ALARM_LIMIT)?(ARC_ALARM_LIMIT):(count4);
     } else {
         if (--count4 == 0)
-            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_2_FAN_RPM_TOO_LOW, false);
+            setArcHeadAlarms(EVENT_TYPE__DYEING_HEAD_BLOWER_2_FAN_RPM_TOO_LOW, false);
         count4 = (count4 < 0)?(0):(count4);
     }
 
     currentFlow = PressureSensorGetPressure(HEAD_FAN_RIGHT);
     if (currentFlow > 5.0) {
         if (++count5 == ARC_ALARM_LIMIT)
-            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_1_FLOW_TOO_HIGH, true);
+            setArcHeadAlarms(EVENT_TYPE__DYEING_HEAD_BLOWER_1_FLOW_TOO_HIGH, true);
         count5 = (count5 > ARC_ALARM_LIMIT)?(ARC_ALARM_LIMIT):(count5);
     } else {
         if (--count5 == 0)
-            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_1_FLOW_TOO_HIGH, false);
+            setArcHeadAlarms(EVENT_TYPE__DYEING_HEAD_BLOWER_1_FLOW_TOO_HIGH, false);
         count5 = (count5 < 0)?(0):(count5);
     }
     if (currentFlow < 1.0) {
         if (++count6 == ARC_ALARM_LIMIT)
-            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_1_FLOW_TOO_LOW, true);
+            setArcHeadAlarms(EVENT_TYPE__DYEING_HEAD_BLOWER_1_FLOW_TOO_LOW, true);
         count6 = (count6 > ARC_ALARM_LIMIT)?(ARC_ALARM_LIMIT):(count6);
     } else {
         if (--count6 == 0)
-            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_1_FLOW_TOO_LOW, false);
+            setArcHeadAlarms(EVENT_TYPE__DYEING_HEAD_BLOWER_1_FLOW_TOO_LOW, false);
         count6 = (count6 < 0)?(0):(count6);
     }
 
     currentFlow = PressureSensorGetPressure(HEAD_FAN_LEFT);
     if (currentFlow > 5.0) {
         if (++count7 == ARC_ALARM_LIMIT)
-            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_2_FLOW_TOO_HIGH, true);
+            setArcHeadAlarms(EVENT_TYPE__DYEING_HEAD_BLOWER_2_FLOW_TOO_HIGH, true);
         count7 = (count7 > ARC_ALARM_LIMIT)?(ARC_ALARM_LIMIT):(count7);
     } else {
         if (--count7 == 0)
-            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_2_FLOW_TOO_HIGH, false);
+            setArcHeadAlarms(EVENT_TYPE__DYEING_HEAD_BLOWER_2_FLOW_TOO_HIGH, false);
         count7 = (count7 < 0)?(0):(count7);
     }
     if (currentFlow < 1.0) {
         if (++count8 == ARC_ALARM_LIMIT)
-            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_2_FLOW_TOO_LOW, true);
+            setArcHeadAlarms(EVENT_TYPE__DYEING_HEAD_BLOWER_2_FLOW_TOO_LOW, true);
         count8 = (count8 > ARC_ALARM_LIMIT)?(ARC_ALARM_LIMIT):(count8);
     } else {
         if (--count8 == 0)
-            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_2_FLOW_TOO_LOW, false);
+            setArcHeadAlarms(EVENT_TYPE__DYEING_HEAD_BLOWER_2_FLOW_TOO_LOW, false);
         count8 = (count8 < 0)?(0):(count8);
     }
 }
@@ -411,6 +451,7 @@ uint32_t  HeadBlowerCommandRequestMessage(int blowerId, float flow)
         ReportWithPackageFilter(HeatersFilter,"flow not in range",__FILE__, flow, blowerId,RpError, 0,0);
         return ERROR;
     }
+    ReportWithPackageFilter(HeatersFilter,"HeadBlower configured",__FILE__,blowerId,(int)(flow*100),RpError, PressureSensorV0[blowerId],0);
     headBlowersFlow[blowerId] = flow;
     return OK;
 }
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
index 84013add6..def9c5530 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
@@ -1053,7 +1053,7 @@ uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue)
     }
     if (abs(readValue - HeaterPreviousRead[index])>2000)
     {
-        ReportWithPackageFilter(HeatersFilter,"Temperature Spike",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index);
+        ReportWithPackageFilter(HeatersFilter,"Temperature Spike AC",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index);
 #ifdef IGNORE_SPIKE
         HeaterPreviousRead[index] = readValue;
 #else
@@ -1345,18 +1345,18 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
             DeActivateHeater(HEATER_TYPE__DryerMainHeater);
             HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerMainHeater,0);
             HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerSecondaryHeater,0);
-            if (HeaterSpikeRead[index] == 0)
-            {
-                HeaterSpikeRead[index] = readValue;
-            }
-            else
-            {
-                ReportWithPackageFilter(HeatersFilter,"restoring read Temperature Spike",__FILE__,index,HeaterPreviousRead[index],RpWarning,HeaterSpikeRead[index], index);
-                HeaterPreviousRead[index] = HeaterSpikeRead[index];
-                HeaterSpikeRead[index] = 0;
-            }
-
         }
+        if (HeaterSpikeRead[index] == 0)
+        {
+            HeaterSpikeRead[index] = readValue;
+        }
+        else
+        {
+            ReportWithPackageFilter(HeatersFilter,"restoring read Temperature Spike",__FILE__,index,HeaterPreviousRead[index],RpWarning,HeaterSpikeRead[index], index);
+            HeaterPreviousRead[index] = HeaterSpikeRead[index];
+            HeaterSpikeRead[index] = 0;
+        }
+
         return ERROR;
 #endif
     }
@@ -1580,20 +1580,20 @@ uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
 #ifdef IGNORE_SPIKE
         HeaterPreviousRead[index] = readValue;
 #else
-        //if (readValue > HeaterCmd[index].targettemperatue)
+        if (readValue > HeaterCmd[index].targettemperatue)
         {
             DeActivateHeater(index);
             HeaterRecalculateHeaterParams(index, 0);
-            if (HeaterSpikeRead[index] == 0)
-            {
-                HeaterSpikeRead[index] = readValue;
-            }
-            else
-            {
-                ReportWithPackageFilter(HeatersFilter,"restoring read Temperature Spike",__FILE__,index,HeaterPreviousRead[index],RpWarning,HeaterSpikeRead[index], index);
-                HeaterPreviousRead[index] = HeaterSpikeRead[index];
-                HeaterSpikeRead[index] = 0;
-            }
+        }
+        if (HeaterSpikeRead[index] == 0)
+        {
+            HeaterSpikeRead[index] = readValue;
+        }
+        else
+        {
+            ReportWithPackageFilter(HeatersFilter,"restoring read Temperature Spike",__FILE__,index,HeaterPreviousRead[index],RpWarning,HeaterSpikeRead[index], index);
+            HeaterPreviousRead[index] = HeaterSpikeRead[index];
+            HeaterSpikeRead[index] = 0;
         }
 #endif
     }
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h b/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h
index d86d7ab2d..0f8108dad 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h
@@ -5,9 +5,6 @@
 #include "drivers/motors/motor.h"
 #include "ids_ex.h"
 
-#define LUBRICANT_DISPENSER 7
-#define CLEANER_DISPENSER 6
-
 extern uint32_t DispenserPrepareSpeed ;
 extern double   DispenserPreparePressure ;
 extern uint32_t DispenserPrepareTimeout ;
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_Cleaning.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_Cleaning.c
index 0ae017c13..59b9a56be 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_Cleaning.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_Cleaning.c
@@ -107,6 +107,16 @@ uint32_t IDS_Cleaning_Move_Actuators()
    CleaningStageCounter++;
    return OK;
 }
+
+uint32_t IDS_Cleaning_stop_cleaner_motor()
+{
+    TimerMotors_t MotorId = HARDWARE_MOTOR_TYPE__MOTO_DH_LID;
+    if (Head_Type != HEAD_TYPE_ARC)
+       return OK;
+
+    MotorStop(MotorId,Soft_Stop);
+    return OK;
+}
 /*uint32_t IDS_Cleaning_Move_Rockers (int LeftRockerSpeed,int RightRockerSpeed)
 {
     uint32_t status = OK;
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h
index 57d3ff5e2..0a8060496 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h
@@ -118,5 +118,6 @@ void DispenserDataRequestFunc(MessageContainer* requestContainer);
 void IDS_Start_Pid_Testing(int DispenserId);
 void IDS_Stop_Pid_Testing(int DispenserId);
 uint32_t cleaningMotorCBFunction (uint32_t deviceID, uint32_t Parameter1);
+uint32_t IDS_Cleaning_stop_cleaner_motor();
 
 #endif /* MODULES_IDS_IDS_EX_H_ */
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
index fcd1c05a2..a28d00a91 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
@@ -43,7 +43,6 @@ typedef struct
 }DispenserControlConfig_t;
 HardwarePidControl *DispensersControl;
 HardwarePidControl DispensersCtrl[MAX_SYSTEM_DISPENSERS];
-#define MAX_DYE_DISPENSERS 6
 #define IDS_PRESEGMENT_TIME_STEP 50
 #define INITIAL_CLEANER_SPEED 300
 
@@ -251,6 +250,7 @@ JobDescriptionFileBrushStop *FirstBrushStop = NULL;
          DispenserUsedInJob[Dispenser_i] = false;
      }
      n_segments = 0;
+#ifndef LIGHT_COLORS
      if (MotorsCfg[DispenserIdToMotorId[CLEANER_DISPENSER]].hardwaremotortype == DispenserIdToMotorId[CLEANER_DISPENSER])
      {
          DispenserUsedInJob[CLEANER_DISPENSER] = true;
@@ -261,7 +261,7 @@ JobDescriptionFileBrushStop *FirstBrushStop = NULL;
          DispenserUsedInJob[CLEANER_DISPENSER] = false;
          EnableCleaning = false;
      }
-
+#endif
      if (JobTicket->enablelubrication == true)
      {
          //DispenserUsedInJob[LUBRICANT_DISPENSER] = true;
@@ -522,7 +522,20 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
   char IdMessage[100];
   int SegmentPrepareWFCFCounter = 0;
   bool pressureReady = false,endOfPrepareWCF = false;
-
+int BuildIdsJobPrintString(char *dest,char *desc, int info)
+{
+    int len = 0,i;
+    int DispenserSpeed[MAX_SYSTEM_DISPENSERS] = {0,0,0,0,0,0,0,0};
+    if (dest == NULL)
+        return 0;
+    for (i = 0; i<MAX_SYSTEM_DISPENSERS; i++)
+    {
+        if (DispenserUsedInJob[i])
+            DispenserSpeed[i] = CurrentDispenserSpeed[i];
+    }
+    len = usnprintf(dest, 80,"%s %d K %d,C %d,M %d,Y %d,TI %d",desc,(int)info,DispenserSpeed[0],DispenserSpeed[1],DispenserSpeed[2],DispenserSpeed[3],DispenserSpeed[4]);
+  return len;
+}
 bool AdjustDispenserSpeedToPressure(int DispenserId, double RefMaxPressure,double pressure)
 {
     TimerMotors_t HW_Motor_Id = DispenserIdToMotorId[DispenserId];
@@ -565,7 +578,7 @@ bool AdjustDispenserSpeedToPressure(int DispenserId, double RefMaxPressure,doubl
      double segmentfirst_speed;
      double pressure;
      ModuleStateEnum result = ModuleDone;
-     bool DispenserReady[MAX_DYE_DISPENSERS] = {false,false,false,false,false,false};
+     bool DispenserReady[MAX_SYSTEM_DISPENSERS] = {false,false,false,false,false,false,false,false};
 
      //REPORT_MSG((int)DispenserPrepareControlId, "Prepare Callback");
 
@@ -591,10 +604,10 @@ bool AdjustDispenserSpeedToPressure(int DispenserId, double RefMaxPressure,doubl
              {
                  DispenserTotalPrepareSteps[i]+=(CurrentDispenserSpeed[i]*PRESSURE_READ_TIME_GAP/eOneSecond);
                  HW_Motor_Id = DispenserIdToMotorId[i];
-                 if ((DispenserTotalPrepareSteps[i]>TargetNumberOfStepsPreRun)&&(DispenserTotalPrepareSteps[i]<(TargetNumberOfStepsPreRun+InitialDispenserSpeed)))
+                 /*if ((DispenserTotalPrepareSteps[i]>TargetNumberOfStepsPreRun)&&(DispenserTotalPrepareSteps[i]<(TargetNumberOfStepsPreRun+InitialDispenserSpeed)))
                  {
                      ReportWithPackageFilter(IDSFilter,"IDS dispenser pre-run ended",__FILE__,i,(int)DispenserTotalPrepareSteps[i],RpWarning,(int)(pressure*100),0);
-                 }
+                 }*/
                  if (DispenserTotalPrepareSteps[i]<TargetNumberOfStepsPreRun)
                  {
                      AdjustDispenserSpeedToPressure(i,MaximalPressurePreRun,pressure);
@@ -617,6 +630,7 @@ bool AdjustDispenserSpeedToPressure(int DispenserId, double RefMaxPressure,doubl
              else
                  DispenserReady[i] = true;
          }
+#ifndef LIGHT_COLORS
          pressure = GetDispenserPressure(CLEANER_DISPENSER);
          if (pressure > 0.02)
          {
@@ -626,7 +640,7 @@ bool AdjustDispenserSpeedToPressure(int DispenserId, double RefMaxPressure,doubl
                  ReportWithPackageFilter(IDSFilter,"IDS stop cleaner",__FILE__,CLEANER_DISPENSER,(int)(pressure*100),RpWarning,(int)CurrentDispenserSpeed[CLEANER_DISPENSER] ,0);
              CurrentDispenserSpeed[CLEANER_DISPENSER] = 0;
          }
-
+#endif
          if ((NumofReadyDispensers)&&(DispenserBuildTimeCounter%1000 == 0))
          {
              ReportWithPackageFilter(IDSFilter,"IDS_Prepare_Callback",__FILE__,DispenserBuildTimeCounter,NumofReadyDispensers,RpWarning,(int)NumOfActiveDispensers,0);
@@ -634,7 +648,9 @@ bool AdjustDispenserSpeedToPressure(int DispenserId, double RefMaxPressure,doubl
          if (NumofReadyDispensers>=NumOfActiveDispensers)
          {
              pressureReady = true;
-             ReportWithPackageFilter(IDSFilter,"pressureReady = true;",__FILE__,DispenserBuildTimeCounter,NumofReadyDispensers,RpWarning,(int)NumOfActiveDispensers,0);
+             usnprintf(IdMessage, 80,"setting pressureReady = true %d K %d,C %d,M %d,Y %d,TI %d",(int)TargetNumberOfStepsPreRun,DispenserTotalPrepareSteps[0],DispenserTotalPrepareSteps[1],
+                       DispenserTotalPrepareSteps[2],DispenserTotalPrepareSteps[3],DispenserTotalPrepareSteps[4]);
+             ReportWithPackageFilter(IDSFilter,IdMessage,__FILE__,DispenserBuildTimeCounter,NumofReadyDispensers,RpWarning,(int)NumOfActiveDispensers,0);
          }
          if (pressureReady == true)
          {
@@ -736,9 +752,10 @@ bool AdjustDispenserSpeedToPressure(int DispenserId, double RefMaxPressure,doubl
                              }
                          }
                      }//for
-                     usnprintf(IdMessage, 80,"WFCF %d K %d,C %d,M %d,Y %d,TI %d",WFCF,CurrentDispenserSpeed[0],
-                               CurrentDispenserSpeed[1],CurrentDispenserSpeed[2],CurrentDispenserSpeed[3],CurrentDispenserSpeed[4]);
-                     ReportWithPackageFilter(IDSFilter,IdMessage, __FILE__, __LINE__, DispenserBuildTimeCounter, RpWarning,   WFCF, 0);
+                     //usnprintf(IdMessage, 80,"WFCF %d K %d,C %d,M %d,Y %d,TI %d",WFCF,CurrentDispenserSpeed[0],
+                     //          CurrentDispenserSpeed[1],CurrentDispenserSpeed[2],CurrentDispenserSpeed[3],CurrentDispenserSpeed[4]);
+                     if (BuildIdsJobPrintString(IdMessage,"WFCF ",WFCF))
+                             ReportWithPackageFilter(IDSFilter,IdMessage, __FILE__, __LINE__, DispenserBuildTimeCounter, RpWarning,   WFCF, 0);
 
                  }//if n_dis
              }
@@ -760,6 +777,7 @@ bool AdjustDispenserSpeedToPressure(int DispenserId, double RefMaxPressure,doubl
      //start new stage
      if (endOfPrepareWCF == true)
      {
+#ifndef LIGHT_COLORS
          if (CurrentDispenserSpeed[CLEANER_DISPENSER])
          {
              HW_Motor_Id = DispenserIdToMotorId[CLEANER_DISPENSER];
@@ -767,6 +785,7 @@ bool AdjustDispenserSpeedToPressure(int DispenserId, double RefMaxPressure,doubl
              CurrentDispenserSpeed[CLEANER_DISPENSER] = 0;
              ReportWithPackageFilter(IDSFilter,"IDS stop cleaner",__FILE__,CLEANER_DISPENSER,(int)(pressure*100),RpWarning,(int)CurrentDispenserSpeed[CLEANER_DISPENSER] ,0);
          }
+#endif
          SafeRemoveControlCallback(DispenserPrepareControlId, IDS_Prepare_Callback );
          DispenserPrepareControlId = 0xFF;
          ReportWithPackageFilter(IDSFilter,"IDS_Prepare_Callback SafeRemoveControlCallback",__FILE__,DispenserBuildTimeCounter,NumofReadyDispensers,RpWarning,(int)NumOfActiveDispensers,0);
@@ -884,6 +903,7 @@ bool AdjustDispenserSpeedToPressure(int DispenserId, double RefMaxPressure,doubl
          }
          else
          {
+             DispenserTotalPrepareSteps[i] = 0;
              if (AutoHoming_Config >= AutoHoming_JobEnd_PowerOn_off)
              {
                  if ((HomingActive[i] == false)&&(PrimingActive[i] == false))
@@ -940,11 +960,12 @@ bool AdjustDispenserSpeedToPressure(int DispenserId, double RefMaxPressure,doubl
                  }*/
              }
          }
+#ifndef LIGHT_COLORS
          TimerMotors_t  HW_Motor_Id = DispenserIdToMotorId[CLEANER_DISPENSER];
          MotorSetSpeed((TimerMotors_t)HW_Motor_Id,INITIAL_CLEANER_SPEED ); //set the dispenser to the
          CurrentDispenserSpeed[CLEANER_DISPENSER] = INITIAL_CLEANER_SPEED;
          ReportWithPackageFilter(IDSFilter,"IDS start cleaner",__FILE__,CLEANER_DISPENSER,(int)(GetDispenserPressure(CLEANER_DISPENSER)*100),RpWarning,(int)CurrentDispenserSpeed[CLEANER_DISPENSER] ,0);
-
+#endif
 
      }
      DispenserBuildTimeCounter = 0;
@@ -1087,9 +1108,10 @@ bool AdjustDispenserSpeedToPressure(int DispenserId, double RefMaxPressure,doubl
                      }
                  }
              }//for
-             usnprintf(IdMessage, 80,"Presegment Prepare K %d,C %d,M %d,Y %d,TI %d",CurrentDispenserSpeed[0],
-                       CurrentDispenserSpeed[1],CurrentDispenserSpeed[2],CurrentDispenserSpeed[3],CurrentDispenserSpeed[4]);
-             ReportWithPackageFilter(IDSFilter,IdMessage, __FILE__, __LINE__, Dispenser_i, RpWarning,   segmentfirst_speed, 0);
+             //usnprintf(IdMessage, 80,"Presegment Prepare K %d,C %d,M %d,Y %d,TI %d",CurrentDispenserSpeed[0],
+             //          CurrentDispenserSpeed[1],CurrentDispenserSpeed[2],CurrentDispenserSpeed[3],CurrentDispenserSpeed[4]);
+             if (BuildIdsJobPrintString(IdMessage,"Presegment Prepare ",0))
+                 ReportWithPackageFilter(IDSFilter,IdMessage, __FILE__, __LINE__, Dispenser_i, RpWarning,   segmentfirst_speed, 0);
 
              DispenserBuildTimeCounter = 0;
              //DispenserPrepareControlId = AddControlCallback( IDS_PreSegmentPrepare_Callback, IDS_PRESEGMENT_TIME_STEP,TemplateDataReadCBFunction ,0, 0, 0 );
@@ -1175,8 +1197,10 @@ uint32_t IDS_Cleaning_Stop_Cleaning_Solution (callback_fptr callback);
          ReportWithPackageFilter(IDSFilter,"End of Pre-segment Handling",__FILE__,__LINE__,InterSegmentStepsCount,RpWarning,(int)lInterSegmentLength,0);
          //PreSegmentReady(Module_IDS,ModuleDone);
          SafeRemoveControlCallback(DispenserPreSegmentControlId,IDSPreSegmentStateCallbackRunner);
+#ifndef LIGHT_COLORS
          if (CurrentDispenserSpeed[CLEANER_DISPENSER]>0)
              IDS_Cleaning_Stop_Cleaning_Solution (NULL);
+#endif
          setRapidPressureRead(false);
          //if (JobEndSequence == true)
          //    DistanceToSpoolReady(Module_IDS,ModuleDone);
@@ -1289,9 +1313,10 @@ uint32_t IDS_Cleaning_Stop_Cleaning_Solution (callback_fptr callback);
                          //SendJobProgress(0.0, 0, false, IdsMessage);*/
                      }
                  }//for
-                 usnprintf(IdMessage, 80,"Presegment WFCF %d K %d,C %d,M %d,Y %d,TI %d",WFCF,CurrentDispenserSpeed[0],
-                           CurrentDispenserSpeed[1],CurrentDispenserSpeed[2],CurrentDispenserSpeed[3],CurrentDispenserSpeed[4]);
-                 ReportWithPackageFilter(IDSFilter,IdMessage, __FILE__, __LINE__, FileBrushStop->index, RpWarning,   lInterSegmentLength, 0);
+                 //usnprintf(IdMessage, 80,"Presegment WFCF %d K %d,C %d,M %d,Y %d,TI %d",WFCF,CurrentDispenserSpeed[0],
+                 //          CurrentDispenserSpeed[1],CurrentDispenserSpeed[2],CurrentDispenserSpeed[3],CurrentDispenserSpeed[4]);
+                 if (BuildIdsJobPrintString(IdMessage,"Presegment WFCF ",WFCF))
+                     ReportWithPackageFilter(IDSFilter,IdMessage, __FILE__, __LINE__, FileBrushStop->index, RpWarning,   lInterSegmentLength, 0);
              }
          }
          //startDispensersAtSegmentSpeed*1=WFCFClenerSpray(speed);
@@ -1616,9 +1641,10 @@ void IDS_StartBrushStop(int n_dispensers,  JobDispenser** Dispensers)
             }
         } //for
     }
-    usnprintf(IdMessage, 80,"IDS_StartBrushStop %d/%d K %d,C %d,M %d,Y %d,TI %d",FileBrushStop->index,SegmentNumOfBrushStops,CurrentDispenserSpeed[0],
-              CurrentDispenserSpeed[1],CurrentDispenserSpeed[2],CurrentDispenserSpeed[3],CurrentDispenserSpeed[4]);
-    ReportWithPackageFilter(IDSFilter,IdMessage, __FILE__, SegmentNumOfBrushStops, FileBrushStop->index, RpWarning,(int)FileBrushStop->offsetmeters, 0);
+    //usnprintf(IdMessage, 80,"IDS_StartBrushStop %d/%d K %d,C %d,M %d,Y %d,TI %d",FileBrushStop->index,SegmentNumOfBrushStops,CurrentDispenserSpeed[0],
+    //          CurrentDispenserSpeed[1],CurrentDispenserSpeed[2],CurrentDispenserSpeed[3],CurrentDispenserSpeed[4]);
+    if (BuildIdsJobPrintString(IdMessage,"IDS_StartBrushStop ",FileBrushStop->index))
+        ReportWithPackageFilter(IDSFilter,IdMessage, __FILE__, SegmentNumOfBrushStops, FileBrushStop->index, RpWarning,(int)FileBrushStop->offsetmeters, 0);
 
 }
 uint32_t IDSBrushStopRestartCallback(uint32_t IfIndex, uint32_t readValue)
@@ -1717,8 +1743,10 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId)
 #else
      Valve_Set(VALVE_MIXCHIP_WASTECH, Mixer_Head);
 #endif
+#ifndef LIGHT_COLORS
      if (CurrentDispenserSpeed[CLEANER_DISPENSER]>0)
          IDS_Cleaning_Stop_Cleaning_Solution(NULL);
+#endif
      SegmentNumOfBrushStops = Segment->n_brushstops;
      BrushStopTime = Segment->length*1000/(double)SegmentNumOfBrushStops;  //brushstop in meters //brushstop in millisecond
      BrushStopTime = ((BrushStopTime*100)/dyeingspeed);//brushstop in seconds
@@ -1935,27 +1963,38 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId)
          }
 
      }
-	IDS_StopLubrication();
+#ifndef LIGHT_COLORS
+     if (CurrentDispenserSpeed[CLEANER_DISPENSER]>0)
+         IDS_Cleaning_Stop_Cleaning_Solution(NULL);
+#endif
+     IDS_StopLubrication();
 	Init_CleaningStageCounter();//set the counter before relocating
+	IDS_Cleaning_stop_cleaner_motor();
 	HeadCard_Actuators_Relocate();
 	return OK;
 }
 uint32_t IDS_StartLubrication(void)
 {
+#ifdef LIGHT_COLORS
+#else
     IDS_Dispenser_Start_Motor_and_Open_Valve(LUBRICANT_DISPENSER,lubricant_speed,NULL);
     CurrentDispenserSpeed[LUBRICANT_DISPENSER] = lubricant_speed;
-    REPORT_MSG (lubricant_speed, "IDS_StartLubrication");
     Lubricant_2Way_Valve (START);
+#endif
+    REPORT_MSG (lubricant_speed, "IDS_StartLubrication");
     return OK;
 }
 uint32_t IDS_StopLubrication(void)
 {
     REPORT_MSG (lubricant_speed, "IDS_StopLubrication and home dispenser");
+#ifdef LIGHT_COLORS
+#else
     Lubricant_2Way_Valve (STOP);
     //IDS_Dispenser_Close_Valve_And_Stop_Motor(LUBRICANT_DISPENSER,IDS_Valve_EndValveReady);
     TimerMotors_t  HW_Motor_Id = DispenserIdToMotorId[LUBRICANT_DISPENSER];
     MotorStop(HW_Motor_Id,Hard_Hiz);
     CurrentDispenserSpeed[LUBRICANT_DISPENSER] = 0;
     //IDS_HomeDispenser (LUBRICANT_DISPENSER, 1000 , NULL);   do not fill lubricant between jobs
+#endif
     return OK;
 }
diff --git a/Software/Embedded_SW/Embedded/Modules/IFS/ifs.c b/Software/Embedded_SW/Embedded/Modules/IFS/ifs.c
index 329357ed4..469e82aa8 100644
--- a/Software/Embedded_SW/Embedded/Modules/IFS/ifs.c
+++ b/Software/Embedded_SW/Embedded/Modules/IFS/ifs.c
@@ -157,9 +157,20 @@ bool CartridgeInkFull()
 int GetCartridgeFillPercent()
 {
     double MidTank_Pressure = 0;
-
+#ifdef IFS_DEBUG
+    static int percent = 0;
+    if (midTankState == MidTankStateFilling) {
+        if (percent < 100) {
+            percent += 1;
+        }
+    } else {
+        percent = 0;
+    }
+    return percent;
+#else
     MidTank_Pressure = Read_MidTank_Pressure_Sensor(midTankCartColor);
     return (((MidTank_Pressure - midTankCapacity)* 100) / CARTRIDGE_CAPATICY);
+#endif
 }
 
 bool midTankCart_door()
@@ -284,7 +295,6 @@ void midTankStateMachine(void)
                     break;
                 }
                 //check RFID - check cartridge OK
-                CartridgeStateUpdate(CARTRIDGE_SLOT__Ink, CARTRIDGE_STATE__Inserted, 0);
 
                 // send request for validation to ppc
                 inkAuthenticationPass = 2; //not defined
@@ -306,17 +316,18 @@ void midTankStateMachine(void)
                 Report("MidTank Cartridge authentication wait...", __FILE__, __LINE__, authenticationTimeOutCounter, RpMessage, 0, 0);
                 if (authenticationTimeOutCounter > 60) {
                     midTankState = MidTankStateIdle;
-                    CartridgeStateUpdate(CARTRIDGE_SLOT__Ink, CARTRIDGE_STATE__Error, 0);
+                    CartridgeStateUpdate(CARTRIDGE_SLOT__Ink, midTankCartColor, CARTRIDGE_STATE__Error, 0);
                 }
                 break;
             }
             if (inkAuthenticationPass == false) {
                 Report("MidTank Cartridge authentication fail", __FILE__, __LINE__, 0, RpMessage, 0, 0);
-                CartridgeStateUpdate(CARTRIDGE_SLOT__Ink, CARTRIDGE_STATE__Error, 0);
+                CartridgeStateUpdate(CARTRIDGE_SLOT__Ink, midTankCartColor, CARTRIDGE_STATE__Error, 0);
                 midTankState = MidTankStateIdle;
                 break;
             }
             // Cartridge status received from user - assume cartridge is full
+            CartridgeStateUpdate(CARTRIDGE_SLOT__Ink, midTankCartColor, CARTRIDGE_STATE__Inserted, 0);
 
             midTankCapacity = Get_MidTank_Pressure_Sensor(midTankCartColor);
             if ((midTankCapacity > MidTankEmptyLimit)&&(midTankCartColor!=MIDTANK_8))//enable lubricant filling in two stages
@@ -325,13 +336,13 @@ void midTankStateMachine(void)
                 cart1.color = fastBILNK;
                 Report("Mid-tank not empty", __FILE__, __LINE__, midTankCapacity, RpMessage, MidTankEmptyLimit, 0);
                 midTankState = MidTankStateIdle;
-                CartridgeStateUpdate(CARTRIDGE_SLOT__Ink, CARTRIDGE_STATE__Error, 0);
+                CartridgeStateUpdate(CARTRIDGE_SLOT__Ink, midTankCartColor, CARTRIDGE_STATE__Error, 0);
                 break;
             }
             Report("Mid-tank filling in process", __FILE__,__LINE__,(int)(MidTankEmptyLimit*1000), RpMessage, (int)(midTankCapacity*1000), 0);
             Pannel_Leds(CART_1, MODE_ON);
             cart1.color  = BLINK;
-            CartridgeStateUpdate(CARTRIDGE_SLOT__Ink, CARTRIDGE_STATE__Filling, 0);
+            CartridgeStateUpdate(CARTRIDGE_SLOT__Ink, midTankCartColor, CARTRIDGE_STATE__Filling, 0);
 
             if (midTankCartColor == MIDTANK_8)
             {
@@ -356,7 +367,7 @@ void midTankStateMachine(void)
                 Report("Cartridge extracted during filling!!!", __FILE__, __LINE__, midTankState, RpMessage, 0, 0);
                 Report("Mid-tank # filling fail", __FILE__, __LINE__, midTankState, RpMessage, 0, 0);
                 midTankState = MidTankStateIdle;
-                CartridgeStateUpdate(CARTRIDGE_SLOT__Ink, CARTRIDGE_STATE__Absent, GetCartridgeFillPercent());
+                CartridgeStateUpdate(CARTRIDGE_SLOT__Ink, midTankCartColor, CARTRIDGE_STATE__Absent, GetCartridgeFillPercent());
             }
             // if time out or emptying done - idle
             if (midTankTimeoutCounter++ > CartridgeInkTimeout) {
@@ -366,7 +377,7 @@ void midTankStateMachine(void)
                 MidTankValvesAction(Cartridge_MidTank_OFF);
                 Report("Mid-tank # filling fail", __FILE__, __LINE__, midTankState, RpMessage, 0, 0);
                 Report("Call customer support", __FILE__, __LINE__, midTankState, RpMessage, 0, 0);
-                CartridgeStateUpdate(CARTRIDGE_SLOT__Ink, CARTRIDGE_STATE__Error, GetCartridgeFillPercent());
+                CartridgeStateUpdate(CARTRIDGE_SLOT__Ink, midTankCartColor, CARTRIDGE_STATE__Error, GetCartridgeFillPercent());
                 midTankState = MidTankStateIdle;
             } else if (CartridgeInkFull()) {
                 midTankTimeoutCounter = 0;
@@ -376,9 +387,10 @@ void midTankStateMachine(void)
                 Report("Mid-tank # filling done", __FILE__, __LINE__, midTankState, RpMessage, 0, 0);
                 midTankState = MidTankStateIdle;
                 // RFID change status - inkEmpty
-                CartridgeStateUpdate(CARTRIDGE_SLOT__Ink, CARTRIDGE_STATE__FillingCompleted, 100.0);
+                CartridgeStateUpdate(CARTRIDGE_SLOT__Ink, midTankCartColor, CARTRIDGE_STATE__FillingCompleted, 100.0);
             }
-            CartridgeStateUpdate(CARTRIDGE_SLOT__Ink, CARTRIDGE_STATE__Filling, GetCartridgeFillPercent());
+            if (midTankState == MidTankStateFilling)
+                CartridgeStateUpdate(CARTRIDGE_SLOT__Ink, midTankCartColor, CARTRIDGE_STATE__Filling, GetCartridgeFillPercent());
             break;
         default:
             Report("wrong state", __FILE__, __LINE__, midTankState, RpMessage, 0, 0);
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Calculate.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Calculate.c
index e386df88c..d26b3d814 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Calculate.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Calculate.c
@@ -5,22 +5,32 @@
 #include <PMR/Stubs/CalculateResponse.pb-c.h>
 #include "include.h"
 #include "driverlib/gpio.h"
+#include "modules/control/control.h"
 
 #include "Drivers/USB_Communication/USBCDCD.h"
 
-
-void Stub_CalculateRequest(MessageContainer* requestContainer)
+char CalculateToken[36+1] = {0};
+//char init_string[100];
+int aaa = 0;
+uint32_t CalculateControlId = 0xFF;
+uint32_t CalculateRpeat(uint32_t IfIndex, uint32_t BusyFlag)
 {
     MessageContainer responseContainer;
-
-    CalculateRequest* request = calculate_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
-
-
     CalculateResponse response = CALCULATE_RESPONSE__INIT;
-    response.sum = request->a + request->b;
+    bool last = false;
+    response.sum = aaa++;
     response.has_sum = true;
+    if (aaa >=20)
+    {
+        RemoveControlCallback(CalculateControlId, CalculateRpeat);
+        last = true;
+        aaa=0;
+    }
+    Report("CalculateRpeat",__FILE__,__LINE__,(int)aaa,RpWarning,(int)0,0);
 
-    responseContainer = createContainer(MESSAGE_TYPE__CalculateResponse, requestContainer->token, true, &response, &calculate_response__pack, &calculate_response__get_packed_size);
+    responseContainer = createContainer(MESSAGE_TYPE__CalculateResponse, CalculateToken, last, &response, &calculate_response__pack, &calculate_response__get_packed_size);
+    responseContainer.has_continuous = true;
+    responseContainer.continuous = true;
 
 //    free(request);
 
@@ -30,5 +40,21 @@ void Stub_CalculateRequest(MessageContainer* requestContainer)
     SendChars((char*)container_buffer, container_size);
     //free(container_buffer);
     //free(requestContainer);
+
+    return OK;
+}
+
+
+void Stub_CalculateRequest(MessageContainer* requestContainer)
+{
+    MessageContainer responseContainer;
+
+    CalculateRequest* request = calculate_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
+    ustrncpy (CalculateToken, requestContainer->token,36);
+
+
+    Report("Stub_CalculateRequest",__FILE__,__LINE__,(int)aaa,RpWarning,(int)0,0);
+    CalculateControlId = AddControlCallback("PowerUpLoad", CalculateRpeat, eOneSecond, TemplateDataReadCBFunction,0,0, 0 );
+
     calculate_request__free_unpacked(request,NULL);
 }
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
index 0ce6474cc..284a43e41 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
@@ -1246,7 +1246,7 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
         response.has_progress = true;
     }
     else
-    if(request->amount == 0xB24)  //Set loading arm cycles
+    if(request->amount == 0xB24)  //AttemptThreadJoggingFunc
     {
         REPORT_MSG(request->delay,"AttemptThreadJoggingFunc");
         AttemptThreadJoggingFunc(NULL);
@@ -1254,7 +1254,7 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
         response.has_progress = true;
     }
     else
-    if(request->amount == 0xB25)  //Set loading arm cycles
+    if(request->amount == 0xB25)  //Change jog speed
     {
         REPORT_MSG(request->delay,"Change jog speed");
         if (request->delay<100)
@@ -1263,6 +1263,14 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
         response.has_progress = true;
     }
     else
+    if(request->amount == 0xB26)  //Change sublimation time
+    {
+        REPORT_MSG(request->delay,"Change sublimation time");
+        setSublimationBlowTime(request->delay);
+        response.progress = JogSpeed;
+        response.has_progress = true;
+    }
+    else
     if(request->amount == 0xC3)  //suspend I2C task
     {
         if (request->delay == 0)
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Cartridge.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Cartridge.c
index 63c7b6963..f4b1f7463 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Cartridge.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Cartridge.c
@@ -9,21 +9,23 @@
 #include "include.h"
 #include "inc/hw_uart.h"
 #include "driverlib/gpio.h"
-
-#include "Drivers/I2C_Communication/RFID_NFC/logi-tag/LT_RFID.h"
 #include <Drivers/I2C_Communication/RFID_NFC/NFC_MainBaord.h>
+#include "Drivers/I2C_Communication/RFID_NFC/logi-tag/LT_RFID.h"
+
+#include <Drivers/I2C_Communication/RFID_NFC/RFIDTagInfo.h>
 #include "Drivers/I2C_Communication/RFID_NFC/NFC.h"
 #include <Utilities/RfidTagHandling.h>
-#include <Drivers/I2C_Communication/RFID_NFC/RFIDTagInfo.h>
+
 #include <Drivers/I2C_Communication/I2C.h>
 #include <Drivers/I2C_Communication/RFID_NFC/I2C_IFS_Mux.h>
+#include <Drivers/I2C_Communication/I2C_RFID_Dispenser_Task/I2C_RFID_Disp_Task.h>
 
 
 #include "Stub_Status.h"
 
 void Stub_CartridgeReadRequest(MessageContainer* requestContainer)
 {
-    //uint32_t status = PASSED;
+    uint32_t status = PASSED;
     MessageContainer responseContainer;
 
     static bool first_time = true;
@@ -38,26 +40,69 @@ void Stub_CartridgeReadRequest(MessageContainer* requestContainer)
 
     uint8_t readerID = request->cartridgeid >> 8;
 
-    /*if(request->cartridgeid == 0x0100)
+    if(request->cartridgeid == 0x0100)
     {
-        Init_RFID_Reader(readerID);//0-2
+        Init_RFID_Reader(readerID);//0-2 - done in main.c. by Init_IFS no need to use it
     }
     else if(request->cartridgeid == 0x0101)
     {
-        Connect_to_RFID_Reder(readerID);//0-2 - conect the card and get tag id
+        Connect_to_RFID_Reder(readerID);//0-2 - conect the card and get tag id - while(1)
     }
     else if(request->cartridgeid == 0x0102)
     {
+        /*
         Active_RFID_Reader = readerID + 1;
-        if(first_time == true)
-        {
-            TagStage =  Tag_PrepareForDiscovery;
-            first_time = false;
-        }
+//        if(first_time == true)
+//        {
+//            TagStage =  Tag_PrepareForDiscovery;
+//            first_time = false;
+//        }
+        TagStage[readerID] =  Tag_PrepareForDiscovery;
+
+        RFIDTagComm_StateMachine(readerID, Auto);
+        */
+        Trigger_RFID_TestTask(readerID);
 
-        RFIDTagComm_StateMachine(Auto);
     }
-    */
+    else if(request->cartridgeid == 0x0103)//first time before 0x0102 - no need done in 102
+    {
+        Active_RFID_Reader = readerID + 1;
+        TagStage[readerID] =  Tag_PrepareForDiscovery;
+
+    }
+    else if((request->cartridgeid & 0xFF)== 0xC1)
+    {
+        Trigger_RFID_UpdateInkFill(readerID);
+    }
+    else if((request->cartridgeid & 0xFF)== 0xC2)
+    {
+        Trigger_RFID_UpdateInkUsed(readerID);
+    }
+    else if((request->cartridgeid & 0xFF)== 0xC3)
+    {
+        Trigger_RFID_UpdateInkEmpty(readerID);
+    }
+    else if((request->cartridgeid & 0xFF)== 0xC4)
+    {
+        Trigger_RFID_UpdateInkMachineID(readerID);
+    }
+    else if((request->cartridgeid & 0xFF)== 0xE1)
+    {
+        Trigger_RFID_UpdateWasteFill(readerID);
+    }
+    else if((request->cartridgeid & 0xFF)== 0xE2)
+    {
+        Trigger_RFID_UpdateWasteFull(readerID);
+    }
+    else if((request->cartridgeid & 0xFF)== 0xE3)
+    {
+        Trigger_RFID_UpdateWasteEmpty(readerID);
+    }
+    else if((request->cartridgeid & 0xFF)== 0xE4)
+    {
+        Trigger_RFID_UpdateWasteMachineID(readerID);
+    }
+
     response.cartridge = &CartridgeRead;
     CartridgeRead.has_index = false;
     CartridgeRead.has_slot = true;
@@ -82,7 +127,7 @@ void Stub_CartridgeReadRequest(MessageContainer* requestContainer)
 
 void Stub_CartridgeWriteRequest(MessageContainer* requestContainer)
 {
-    //uint32_t status = NOT_SUPPORTED;
+    uint32_t status = NOT_SUPPORTED;
     MessageContainer responseContainer;
 
     StubCartridgeWriteRequest* request = stub_cartridge_write_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Dancer.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Dancer.c
index 3d2db071e..27a7dfb31 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Dancer.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Dancer.c
@@ -70,6 +70,7 @@ void Stub_DancerPositionRequest(MessageContainer* requestContainer)
         response.has_general_status = true;
         response.detailed_status = DANCER_ENC[request->dancer_id].Det_status;
         response.has_general_status = true;
+        StoreDancerConfigMessage(Dancer_Id);
     }
     else if(Dancer_Id < NUM_OF_ROTENC*2)
     {
@@ -86,8 +87,6 @@ void Stub_DancerPositionRequest(MessageContainer* requestContainer)
         response.detailed_status = ERROR; // use the Reserved bits to send our errors
         response.has_general_status = true;
     }
-    if (Dancer_Id == 2)
-        StoreDancerConfigMessage();
     responseContainer = createContainer(MESSAGE_TYPE__StubDancerPositionResponse, requestContainer->token, true, &response, &stub_dancer_position_response__pack, &stub_dancer_position_response__get_packed_size);
 
     //free(request);
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
index cdb726b5e..c3f15aff8 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
@@ -258,7 +258,7 @@
         {
             CallbackCounter--;
         }
-        if ((angle>14000  )&&(BusyFlag == NOTBUSY)) // OK - take another round
+        if ((abs(angle)>14000  )&&(BusyFlag == NOTBUSY)) // OK - take another round
         {
             Report("Thread_Load_Set_Load_Arm_To_Stopper time",__FILE__,msec_millisecondCounter - UnloadingStart,msec_millisecondCounter,RpMessage,UnloadingStart,0);
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h
index 07ecf5d0b..11a92ab63 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h
@@ -46,7 +46,7 @@ uint32_t ThreadEndState();
 
 bool Set_Thread_Rockers_Bypass (int value);
 
-uint32_t StoreDancerConfigMessage(void);
+uint32_t StoreDancerConfigMessage(int DancerId);
 uint32_t LoadDancerConfigMessage(void);
 
 //uint32_t MotorPidRequestMessage(HardwarePidControl* request);
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c
index 1920db03a..869485b71 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c
@@ -188,40 +188,36 @@ uint32_t MotorPidRequestMessage(HardwarePidControl* request)
 }
 char DancerConfigPath[50] = "0://SysInfo//DancCfg.cfg";
 
-uint32_t StoreDancerConfigMessage()
+uint32_t StoreDancerConfigMessage(int DancerId)
 {
     uint32_t status = OK;
   //  FRESULT Fresult = FR_OK;
     //HardwareConfiguration DancerConfig;
     HardwareDancer Dancers[MAX_SYSTEM_DANCERS];
-  //  uint8_t* response_buffer;
+#ifdef FOUR_WINDERS
+    uint8_t DancerAddress[MAX_SYSTEM_DANCERS] = {EEPROM_STORAGE_DANCER_0,EEPROM_STORAGE_DANCER_1,EEPROM_STORAGE_DANCER_2,EEPROM_STORAGE_DANCER_3,EEPROM_STORAGE_DANCER_4};
+#else
+    uint8_t DancerAddress[MAX_SYSTEM_DANCERS] = {EEPROM_STORAGE_DANCER_0,EEPROM_STORAGE_DANCER_1,EEPROM_STORAGE_DANCER_2};
+#endif
   //  size_t response_size = 0;
-    int Dancer_i;
+    int Dancer_i = DancerId;
 
     //hardware_configuration__init(&DancerConfig);
     //DancerConfig.dancers = (HardwareDancer**)my_malloc(sizeof(HardwareDancer*)*MAX_SYSTEM_DANCERS);
-    for (Dancer_i = 0; Dancer_i < MAX_SYSTEM_DANCERS; Dancer_i++)
-    {
-        hardware_dancer__init(&Dancers[Dancer_i]);
-        //DancerConfig.dancers[Dancer_i] = &Dancers[Dancer_i];
-        Dancers[Dancer_i].has_zeropoint = true;
-        Dancers[Dancer_i].hardwaredancertype = Dancer_i;
-        Dancers[Dancer_i].has_hardwaredancertype = true;
-        Dancers[Dancer_i].zeropoint=Control_Read_Dancer_Position(Dancer_i,0);
-        //DancerConfig.n_dancers++;
-        DancersCfg[Dancer_i].zeropoint = Dancers[Dancer_i].zeropoint;
-        DancersCfg[Dancer_i].zeropoint = Control_Read_Dancer_Position(Dancer_i,0);
-    }
+    hardware_dancer__init(&Dancers[Dancer_i]);
+    //DancerConfig.dancers[Dancer_i] = &Dancers[Dancer_i];
+    Dancers[Dancer_i].has_zeropoint = true;
+    Dancers[Dancer_i].hardwaredancertype = Dancer_i;
+    Dancers[Dancer_i].has_hardwaredancertype = true;
+    Dancers[Dancer_i].zeropoint=Control_Read_Dancer_Position(Dancer_i,0);
+    //DancerConfig.n_dancers++;
+    DancersCfg[Dancer_i].zeropoint = Dancers[Dancer_i].zeropoint;
+    DancersCfg[Dancer_i].zeropoint = Control_Read_Dancer_Position(Dancer_i,0);
 
-    status |= MCU_E2PromProgram(EEPROM_STORAGE_DANCER_0,DancersCfg[0].zeropoint);
-    status |= MCU_E2PromProgram(EEPROM_STORAGE_DANCER_1,DancersCfg[1].zeropoint);
-    status |= MCU_E2PromProgram(EEPROM_STORAGE_DANCER_2,DancersCfg[2].zeropoint);
-    Report("~~~~~~Store eeprom 0",__FILE__,DancersCfg[0].zeropoint,(int)DancersCfg[1].zeropoint,RpWarning,(int)DancersCfg[2].zeropoint,0);
-#ifdef FOUR_WINDERS
-    status |= MCU_E2PromProgram(EEPROM_STORAGE_DANCER_3,DancersCfg[HARDWARE_DANCER_3].zeropoint);
-    status |= MCU_E2PromProgram(EEPROM_STORAGE_DANCER_4,DancersCfg[HARDWARE_DANCER_4].zeropoint);
-    Report("~~~~~~Store eeprom 1",__FILE__,__LINE__,(int)DancersCfg[HARDWARE_DANCER_3].zeropoint,RpWarning,(int)DancersCfg[HARDWARE_DANCER_4].zeropoint,0);
-#endif
+
+
+    status |= MCU_E2PromProgram(DancerAddress[Dancer_i],DancersCfg[Dancer_i].zeropoint);
+    Report("~~~~~~Store eeprom dancer",__FILE__,__LINE__,Dancer_i,RpWarning,(int)DancersCfg[Dancer_i].zeropoint,0);
     /*
     response_buffer = my_malloc(hardware_configuration__get_packed_size(&DancerConfig));
     if (response_buffer)
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
index 8d41f3b9a..5fee72dc7 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
@@ -1338,22 +1338,22 @@ uint32_t UpdatePidDuringRun(HardwarePidControl *request)
         return ERROR;
 
 
-    if (request->derivativetime == true)
+    if (request->has_derivativetime == true)
     {
         MotorControlConfig[Motor_i].m_params.Kd = request->derivativetime;
         ReportWithPackageFilter(ThreadFilter,"UpdatePidDuringRun Kd",__FILE__,Motor_i,(int)(request->derivativetime),RpWarning,0,0);
     }
-    if (request->proportionalgain == true)
+    if (request->has_proportionalgain == true)
     {
         MotorControlConfig[Motor_i].m_params.Kp = request->proportionalgain;
         ReportWithPackageFilter(ThreadFilter,"UpdatePidDuringRun Kp",__FILE__,Motor_i,(int)(request->proportionalgain),RpWarning,0,0);
     }
-    if (request->integraltime == true)
+    if (request->has_integraltime == true)
     {
         MotorControlConfig[Motor_i].m_params.Ki = request->integraltime;
         ReportWithPackageFilter(ThreadFilter,"UpdatePidDuringRun Ki",__FILE__,Motor_i,(int)(request->integraltime),RpWarning,0,0);
     }
-    if (request->epsilon == true)
+    if (request->has_epsilon == true)
     {
         MotorControlConfig[Motor_i].m_params.epsilon = request->epsilon;
         ReportWithPackageFilter(ThreadFilter,"UpdatePidDuringRun epsilon",__FILE__,Motor_i,(int)(request->epsilon*10000),RpWarning,0,0);
diff --git a/Software/Embedded_SW/Embedded/Modules/Waste/Waste_maint.c b/Software/Embedded_SW/Embedded/Modules/Waste/Waste_maint.c
index 9c5fe9822..490a0c0a5 100644
--- a/Software/Embedded_SW/Embedded/Modules/Waste/Waste_maint.c
+++ b/Software/Embedded_SW/Embedded/Modules/Waste/Waste_maint.c
@@ -8,8 +8,9 @@
 #include "Modules/Waste/Waste_ex.h"
 #include "modules/heaters/heaters_ex.h"
 #include <Drivers/I2C_Communication/RFID_NFC/RFIDTagInfo.h>
-#include "Drivers/I2C_Communication/RFID_NFC/logi-tag/LT_RFID.h"
 #include <Drivers/I2C_Communication/RFID_NFC/NFC_MainBaord.h>
+#include "Drivers/I2C_Communication/RFID_NFC/logi-tag/LT_RFID.h"
+
 #include "Drivers/I2C_Communication/RFID_NFC/NFC.h"
 #include <Utilities/RfidTagHandling.h>
 #include "PMR/IFS/CartridgeState.pb-c.h"
@@ -27,6 +28,7 @@
 #include <Drivers/I2C_Communication/I2C_Task.h>
 #include <Drivers/I2C_Communication/WHS_Card/D_MAX11614_ADC/WHS_MAX11614_A2D.h>
 #include <Drivers/I2C_Communication/WHS_Card/D_Max5805_ADC_Blower/WHS_Blower.h>
+#include <Drivers/I2C_Communication/RFID_NFC/RFID_Waste.h>
 #include <Drivers/I2C_Communication/WHS_Card/D_AD5272_Rheostat/WHS_Rheostat.h>
 
 uint8_t VocPpmAlarmLimit = 10;//PPM
@@ -42,6 +44,7 @@ uint32_t Cartridge_Cover_Control;
 button *CartLed[MaxWasteCartridges] = {0, &cart2, &cart3};
 WasteTankStateEnum WasteTankState = WasteTankStateIdle;
 
+extern char WasteEmptyingToken[36+1];
 int init = 1;
 
 bool setWasteValve (WasteCartridgeEnum WasteCartridge);
@@ -165,7 +168,7 @@ WasteCartridgeEnum cartGetActiveCart()
 {
     uint32_t CartId;
 
-    for (CartId = 0; CartId < MaxWasteCartridges; CartId++) {
+    for (CartId = WasteCartridge_middle; CartId < MaxWasteCartridges; CartId++) {
         if (CartState[CartId] == CartridgeStateACTIVE)
             return CartId;
     }
@@ -223,10 +226,13 @@ bool setWasteValve (WasteCartridgeEnum WasteCartridge)
 bool RdWasteTankEmptySensor()
 {
     //double WasteLevel = 0.0;
-
+#ifndef WHS_DEBUG
     if (WHS_Type == WHS_TYPE_UNKNOWN) {
         return WHS_GPI_WCONTAINER_WARN();
-    } else { //new WHS
+    }
+    else
+#endif
+    { //new WHS
         //WasteLevel = GetWHSWasteTankLevelMiliLiter();
         if (wasteLevel < wasteLevelEmpty)
             return 1; //Empty
@@ -237,10 +243,13 @@ bool RdWasteTankEmptySensor()
 bool RdWasteTankFullSensor()
 {
     //double WasteLevel = 0.0;
-
+#ifndef WHS_DEBUG
     if (WHS_Type == WHS_TYPE_UNKNOWN) {
         return WHS_GPI_WCONTAINER_FULL();
-    } else { //new WHS
+    }
+    else
+#endif
+    { //new WHS
         //WasteLevel = GetWHSWasteTankLevelMiliLiter();
         if (wasteLevel >= wasteLevelFull)
             return 1; //full
@@ -251,10 +260,13 @@ bool RdWasteTankFullSensor()
 bool RdWasteTankOverFlowSensor()
 {
     //double WasteLevel = 0.0;
-
+#ifndef WHS_DEBUG
     if (WHS_Type == WHS_TYPE_UNKNOWN) {
         return WHS_GPI_WASTE_OVERFULL();
-    } else {//new WHS
+    }
+    else
+#endif
+    {//new WHS
         //WasteLevel = GetWHSWasteTankLevelMiliLiter();
         if (wasteLevel > wasteLevelOverflow)
             return 1; //overflow
@@ -348,13 +360,14 @@ uint32_t Waste_DoorOpenDuringEmptying(uint32_t IfIndex, uint32_t ReadValue)
 void Waste_StateMachine_OneSecond_Call(void)
 {
     static WasteTankStateEnum prev_state = 0;
-    static int prev_wasteLevel = 0;
+    static int cart, prev_wasteLevel = 0;
+    static int insertUpdate[3] = {0, 0, 0};
 
     //call cartridge state
     if ((Is_Cartridge_Present(CART_2) != cartGetPresence(WasteCartridge_middle)) || (init)) {
         if (Is_Cartridge_Present(CART_2)) {
             cartCART_INSERTED(WasteCartridge_middle);
-            CartridgeStateUpdate(CARTRIDGE_SLOT__WasteMiddle, CARTRIDGE_STATE__Inserted, 0);
+            insertUpdate[CARTRIDGE_SLOT__WasteMiddle-1] = 1;
         } else {
             cartCART_EXTRACTED(WasteCartridge_middle);
         }
@@ -362,12 +375,20 @@ void Waste_StateMachine_OneSecond_Call(void)
     if ((Is_Cartridge_Present(CART_3) != cartGetPresence(WasteCartridge_lower)) || (init)) {
         if (Is_Cartridge_Present(CART_3)) {
             cartCART_INSERTED(WasteCartridge_lower);
-            CartridgeStateUpdate(CARTRIDGE_SLOT__WasteLower, CARTRIDGE_STATE__Inserted, 0);
+            insertUpdate[CARTRIDGE_SLOT__WasteLower-1] = 1;
         } else {
             cartCART_EXTRACTED(WasteCartridge_lower);
         }
     }
 
+    //update ppc
+    for (cart = WasteCartridge_middle; cart <= WasteCartridge_lower; cart++) {
+        if ((insertUpdate[cart]) && (WasteEmptyingToken[0])) {
+            CartridgeStateUpdate(cart, cart-1, CARTRIDGE_STATE__Inserted, 0);
+            insertUpdate[cart] = 0;
+        }
+    }
+
     //call door state
     cartCart_door();
 
@@ -467,7 +488,7 @@ void Waste_StateMachine(void)
             //start  emptying
             // RFID change status - set wasteFilling
             WasteTankState = WasteTankStateEmptying;
-            CartridgeStateUpdate(activeCart, CARTRIDGE_STATE__Emptying, 0);
+            CartridgeStateUpdate(activeCart, activeCart-1, CARTRIDGE_STATE__Emptying, 0);
             break;
         case WasteTankStateEmptying:
             // if time out or emptying done - idle
@@ -478,7 +499,7 @@ void Waste_StateMachine(void)
                 WasteTankState = WasteTankStateIdle;
                 usnprintf(str, 100, "WasteTankStateEmptying Timeout. time:%d:%d volume:%d", timeout_counter/60, timeout_counter%60, WHS_GetCartridgeFill());
                 Report(str, __FILE__, __LINE__, 0, RpMessage, 0, 0);
-                CartridgeStateUpdate(activeCart, CARTRIDGE_STATE__Error, WHS_GetCartridgeFillPercent());
+                CartridgeStateUpdate(activeCart, activeCart-1, CARTRIDGE_STATE__Error, WHS_GetCartridgeFillPercent());
                 AlarmHandlingSetAlarm( EVENT_TYPE__WASTE_CONTAINER_EMPTYING_TIMEOUT,  true);
                 RemoveControlCallback(Cartridge_Cover_Control, Waste_DoorOpenDuringEmptying);
                 timeout_counter = 0;
@@ -493,10 +514,11 @@ void Waste_StateMachine(void)
                     AlarmHandlingSetAlarm( EVENT_TYPE__ALL_WASTE_CARTRIDGES_FULL,  true);
                 usnprintf(str, 100, "WasteTankStateEmptying done. time:%d:%d volume:%d", timeout_counter/60, timeout_counter%60, WHS_GetCartridgeFill());
                 Report(str, __FILE__, __LINE__, 0, RpMessage, 0, 0);
-                CartridgeStateUpdate(activeCart, CARTRIDGE_STATE__EmptyingCompleted, WHS_GetCartridgeFillPercent());
+                CartridgeStateUpdate(activeCart, activeCart-1, CARTRIDGE_STATE__EmptyingCompleted, WHS_GetCartridgeFillPercent());
                 timeout_counter = 0;
             }
-            CartridgeStateUpdate(activeCart, CARTRIDGE_STATE__Emptying, WHS_GetCartridgeFillPercent());
+            if (WasteTankState == WasteTankStateEmptying)
+                CartridgeStateUpdate(activeCart, activeCart-1, CARTRIDGE_STATE__Emptying, WHS_GetCartridgeFillPercent());
 #ifdef WHS_DEBUG
             wasteLevel -= 100;
             timeout_counter += 10;
@@ -517,7 +539,7 @@ void Waste_StateMachine(void)
                     AlarmHandlingSetAlarm( EVENT_TYPE__ALL_WASTE_CARTRIDGES_FULL,  true);
                 Report("WasteTankStatePaused done", __FILE__, __LINE__, 0, RpMessage, 0, 0);
                 timeout_counter = 0;
-                CartridgeStateUpdate(activeCart, CARTRIDGE_STATE__Error, WHS_GetCartridgeFillPercent());
+                CartridgeStateUpdate(activeCart, activeCart-1, CARTRIDGE_STATE__Error, WHS_GetCartridgeFillPercent());
             }
             break;
         default: