merge

23 files changed, 227 insertions, 64 deletions

diff --git a/Software/Embedded_SW/Embedded/Common/SWUpdate/FileSystem.c b/Software/Embedded_SW/Embedded/Common/SWUpdate/FileSystem.c
index 76c2fe9f2..77efa1cfd 100644
--- a/Software/Embedded_SW/Embedded/Common/SWUpdate/FileSystem.c
+++ b/Software/Embedded_SW/Embedded/Common/SWUpdate/FileSystem.c
@@ -653,7 +653,7 @@ uint32_t    GetFilesRequestFunc(MessageContainer* requestContainer)
     GetFilesRequest* request = get_files_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
 
     GetFilesResponse response = GET_FILES_RESPONSE__INIT;
-
+    //struct tm RTC_time;
     #define MAX_NUM_OF_FILES 20
     DIR dir;
     FILINFO* fno[MAX_NUM_OF_FILES];
@@ -727,6 +727,13 @@ uint32_t    GetFilesRequestFunc(MessageContainer* requestContainer)
               else
                usnprintf(&FullPath[i], 50,  "%s%s%s", request->path,"/", fno[i]->fname);
            Data[i].fullpath = &FullPath[i][0];
+           /*RTC_time.tm_year=(fno[i]->fdate>>9)+1980;//populate the time struct (FAT start==1980, RTC.year==0)
+           RTC_time.tm_mon=(fno[i]->fdate>>5)&0x000F;
+           RTC_time.tm_mday=fno[i]->fdate&0x001F;
+           RTC_time.tm_hour=(fno[i]->ftime>>11)&0x001F;
+           RTC_time.tm_min=(fno[i]->ftime>>5)&0x003F;
+           RTC_time.tm_sec=(fno[i]->ftime<<1)&0x003E;*/
+
 
         }
         response.n_items = NumOfFiles;
diff --git a/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c b/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c
index fd6889185..d0193f970 100644
--- a/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c
+++ b/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c
@@ -20,7 +20,7 @@ typedef struct
 } TangoVersion_t;
 
 
-TangoVersion_t _gTangoVersion = {1,5,2,0};
+TangoVersion_t _gTangoVersion = {1,5,2,1};
 #define BUILD_DATE __DATE__
 char Dat[50] = BUILD_DATE; 
 
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/Fan/Head_Fan.h b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/Fan/Head_Fan.h
index 394a69e1d..438d552ff 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/Fan/Head_Fan.h
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/Fan/Head_Fan.h
@@ -75,5 +75,6 @@ uint8_t Head_Fan_Read_Tacho(bool Fan);
 uint8_t Head_Read_Config_Reg();
 uint8_t Head_Fan_config();
 uint8_t Head_Fans_Init();
+uint8_t Head_Check_Fan_Controller_Type();
 
 #endif /* DRIVERS_I2C_COMMUNICATION_HEAD_CARD_FAN_HEAD_FAN_H_ */
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/Fan/fan_click.c b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/Fan/fan_click.c
index 728531488..ab68d6539 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/Fan/fan_click.c
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/Fan/fan_click.c
@@ -26,7 +26,7 @@ uint8_t readbuffer[2];
 uint8_t writebuffer[2];
 
 
-uint32_t I2C_HEAD_FAN_SLAVE_ADD = 0x5C;
+uint32_t I2C_HEAD_FAN_SLAVE_ADD = UNKNOWN;
 
 
 FAN_CLICK_INFO Fan_Click_Info;
@@ -195,6 +195,34 @@ uint8_t Head_fan_click_revision()
     return status;
 }
 
+uint8_t Head_Check_Fan_Controller_Type()
+{
+    uint8_t status = ERROR;
+
+    Select_Main_Head_Mux_Channel();
+
+    if(I2C_HEAD_FAN_SLAVE_ADD == UNKNOWN)
+    {
+        I2C_HEAD_FAN_SLAVE_ADD = 0x5C;
+        status = Head_fan_click_productID();
+
+        if((Fan_Click_Info.Product_ID != 0x36) || (status != OK))
+        {
+            I2C_HEAD_FAN_SLAVE_ADD = 0x5E;
+            status = Head_fan_click_productID();
+        }
+
+        if((Fan_Click_Info.Product_ID != 0x36) || (status != OK))
+        {
+            I2C_HEAD_FAN_SLAVE_ADD = 0x00;
+            ReportWithPackageFilter(GeneralFilter,"unable to recognize the Head fan controller", __FILE__,__LINE__, status, RpMessage, 0, 0);
+            status = ERROR;
+        }
+    }
+    return status;
+}
+
+
 uint8_t Head_Read_Config_Reg()
 {
     uint8_t status = OK;
@@ -296,6 +324,7 @@ uint8_t Head_Fans_Init()
 {
     uint8_t status = OK;
 
+    Head_Check_Fan_Controller_Type();
     Head_Read_Config_Reg();
     //Output is configured as a push-pull output
     EMC2302_Write.Reg.PWM_Output_Config |= 0x3;//Bit0 Output PWM1, Bit2 Output PWM2, 0 open drain, 1 push-pull
diff --git a/Software/Embedded_SW/Embedded/Drivers/RFID/RFID_Task.c b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C_RFID_Dispenser_Task/I2C_RFID_Disp_Task.c
index f5101d9e7..fc4bad71d 100644
--- a/Software/Embedded_SW/Embedded/Drivers/RFID/RFID_Task.c
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C_RFID_Dispenser_Task/I2C_RFID_Disp_Task.c
@@ -10,7 +10,7 @@
 #include "include.h"
 #include "inc/hw_memmap.h"
 
-#include <Drivers/RFID/RFID_Task.h>
+#include <Drivers/I2C_Communication/I2C_RFID_Dispenser_Task/I2C_RFID_Disp_Task.h>
 Task_Handle RFID_Task_Handle;
 Mailbox_Handle          RFID_ReadingMsgQ = NULL;
 typedef enum
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C_RFID_Dispenser_Task/I2C_RFID_Disp_Task.h b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C_RFID_Dispenser_Task/I2C_RFID_Disp_Task.h
new file mode 100644
index 000000000..6d16701fc
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C_RFID_Dispenser_Task/I2C_RFID_Disp_Task.h
@@ -0,0 +1,16 @@
+/*
+ * RFID_Task.h
+ *
+ *  Created on: 2 Nov 2020
+ *      Author: avi
+ */
+
+#ifndef DRIVERS_RFID_TASK_RFID_TASK_H_
+#define DRIVERS_RFID_TASK_RFID_TASK_H_
+
+void Trigger_RFID_Init();
+void Trigger_Dispenser_ReadData(int dispenserId);;
+
+
+
+#endif /* DRIVERS_RFID_TASK_RFID_TASK_H_ */
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/WHS_Card/D_EMC2302_Fan/WHS_Fan.c b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/WHS_Card/D_EMC2302_Fan/WHS_Fan.c
index f22d53a77..73bc2f9af 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/WHS_Card/D_EMC2302_Fan/WHS_Fan.c
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/WHS_Card/D_EMC2302_Fan/WHS_Fan.c
@@ -233,7 +233,7 @@ uint8_t WHS_Check_Fan_Controller_Type(WHS_fan_num fan_number)
         if((Fan_Driver_Info[fan_number].Product_ID != 0x36) || (status != OK))
         {
             I2CFanViaSwitch_ADD_Buf[fan_number] = 0x00;
-            ReportWithPackageFilter(WasteFilter,"unable to recognize the an controller", __FILE__,__LINE__, status, RpMessage, fan_number, 0);
+            ReportWithPackageFilter(WasteFilter,"unable to recognize the WHS fan controller", __FILE__,__LINE__, status, RpMessage, fan_number, 0);
             status = ERROR;
         }
 
diff --git a/Software/Embedded_SW/Embedded/Drivers/RFID/RFID_Task.h b/Software/Embedded_SW/Embedded/Drivers/RFID/RFID_Task.h
deleted file mode 100644
index e69de29bb..000000000
--- a/Software/Embedded_SW/Embedded/Drivers/RFID/RFID_Task.h
+++ /dev/null
diff --git a/Software/Embedded_SW/Embedded/Main.c b/Software/Embedded_SW/Embedded/Main.c
index c1d83abb3..36883df23 100644
--- a/Software/Embedded_SW/Embedded/Main.c
+++ b/Software/Embedded_SW/Embedded/Main.c
@@ -182,8 +182,8 @@ Void errHook(Error_Block *eb)
             System_printf("assertion violation: ");
             f_write(LogFileHandle,"\r\nassertion violation: ",22,&Bytes );
         }
+        CloseLogFile();
     }
-    CloseLogFile();
 
 
 #ifdef WATCHDOG
@@ -222,6 +222,7 @@ void Init_EVB()
 
 int main(void)
 {
+    FRESULT Fresult = FR_OK;
     // Enable interrupts to the processor.
     //
     ROM_IntMasterDisable();
@@ -255,6 +256,39 @@ int main(void)
         LOG_ERROR (iFResult, "Error during init Flash File System");
         assert(iFResult);
     }
+    Fresult = f_mkdir("0://SysInfo");
+    if ((Fresult != FR_OK)&&(Fresult != FR_EXIST))
+    {
+#ifdef WATCHDOG
+        ROM_WatchdogResetDisable(WATCHDOG0_BASE);
+        uint32_t timeout = 0xFFFFFFFFU;
+        ROM_WatchdogReloadSet(WATCHDOG0_BASE, timeout);
+#endif
+        STATUS_GREEN_LED_ON;
+        ACTIVITY_GREEN_LED_ON;
+        COMM_GREEN_LED_ON;
+
+        STATUS_RED_LED_ON;
+        ACTIVITY_RED_LED_ON;
+        COMM_RED_LED_ON;
+        //FFS error
+        Report("FFS error - rebuilding", __FILE__,__LINE__,Fresult, RpMessage,0, 0);
+        FRESULT iFResult = Init_Flash_File_System(true);// true
+        Fresult = f_mkdir("0://SysInfo");
+
+        ACTIVITY_GREEN_LED_OFF;
+        COMM_GREEN_LED_OFF;
+
+        STATUS_RED_LED_OFF;
+        ACTIVITY_RED_LED_OFF;
+        COMM_RED_LED_OFF;
+#ifdef WATCHDOG
+        ROM_WatchdogResetEnable(WATCHDOG0_BASE);
+        timeout = 120000000*3;
+        ROM_WatchdogReloadSet(WATCHDOG0_BASE, timeout);
+#endif
+    }
+
     OpenLogFile();
     Data = MCU_E2PromEmbeddedVersionRead();
     memcpy (&Version,&Data,4);
@@ -277,6 +311,7 @@ int main(void)
    I2C_BUSY_DELAY = 100; //temporary workaround!!!
 
    //WHS_Type = WHS_TYPE_NEW; //for testing
+   //Head_Type = HEAD_TYPE_ARC; //for testing
 
    if ((Head_Type >= HEAD_TYPE_UNKNOWN_WITH_CARD)&&(WHS_Type == WHS_TYPE_NEW))
    {
diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
index 5c24b2338..eceb92d63 100644
--- a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
+++ b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
@@ -1040,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/Diagnostics/Diagnostics.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
index cfd4db0e6..4122955b3 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
@@ -548,20 +548,12 @@ void CopyTemperaturesToMonitor(void)
 #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/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 5be5f1232..5134e97aa 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_Blowers.c
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_Blowers.c
@@ -53,7 +53,7 @@
 #define PRESSURE_SENSOR_CP      0.269
 #define PRESSURE_SENSOR_B       0.45
 #define V0_DEFAULT_VALUE        1050
-#define FAN_MIN_RPM_THRESHOLD   3200
+#define FAN_MIN_RPM_THRESHOLD   4000
 extern uint16_t Head_Fan_Tach[2];
 extern uint8_t Head_Fan_PWM_Command[2];
 
@@ -354,13 +354,12 @@ void HeadBlowersCfg()
 
 uint32_t PressureSensorInit(int blowerId)
 {
-    uint32_t V0;
+    uint32_t rpm, V0 = 0;
 
-    if (HeadBlowersGetRPM(blowerId) < FAN_MIN_RPM_THRESHOLD) {
+    rpm = HeadBlowersGetRPM(blowerId);
+    if (rpm < FAN_MIN_RPM_THRESHOLD) {
         V0 = MillisecGetTemperatures(BlowerIdToSensorId[blowerId]);
         V0 /= 10;
-    } else {
-        V0 = V0_DEFAULT_VALUE;
     }
     return V0;
 }
@@ -412,6 +411,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/IDS/IDS_print.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
index 3a2bbc347..b1b81b3f1 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
@@ -634,7 +634,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)
          {
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/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/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..c1b54b4d6 100644
--- a/Software/Embedded_SW/Embedded/Modules/Waste/Waste_maint.c
+++ b/Software/Embedded_SW/Embedded/Modules/Waste/Waste_maint.c
@@ -42,6 +42,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 +166,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 +224,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 +241,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 +258,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 +358,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 +373,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 +486,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 +497,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 +512,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 +537,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:
diff --git a/Software/Embedded_SW/Embedded/Software Release Notes.txt b/Software/Embedded_SW/Embedded/Software Release Notes.txt
index 4e1f7104f..736f6e3be 100644
--- a/Software/Embedded_SW/Embedded/Software Release Notes.txt
+++ b/Software/Embedded_SW/Embedded/Software Release Notes.txt
@@ -1,3 +1,18 @@
+Embedded SW Release note - Version 1.5.2(1) - Pack 3
+=============================================================
+Rebuild Flash file system on Initialization failure.
+Protobuf - Procedure request, Read all hardware request, AttemptThreadJoggingRequest.
+Align pressure reading setup with electric scripts.
+fix alarm handling bugs (#4085, #4097), fix job failures report.
+add diagnostic temperature meters to diagnostic data (zone 4,9,10).
+add stub to control jog speed.
+fix Change Pid During Job stub handling.
+IFS and waste cartridge requests.
+Blowers V0 initialization and handling fixed and improved.
+Dancer resetting - enable for single dancer
+support initial BTSR tests
+Store cleaning parameters from the last job for cleaning jobs (#4112)
+
 Embedded SW Release note - Version 1.5.1(4) - Pack 3
 =============================================================
 fix tunnel pressure calculation
diff --git a/Software/Embedded_SW/Embedded/StateMachines/Initialization/InitSequence.c b/Software/Embedded_SW/Embedded/StateMachines/Initialization/InitSequence.c
index 98326a1da..5d97a0003 100644
--- a/Software/Embedded_SW/Embedded/StateMachines/Initialization/InitSequence.c
+++ b/Software/Embedded_SW/Embedded/StateMachines/Initialization/InitSequence.c
@@ -917,6 +917,7 @@ uint32_t PowerUpUpdate(MACHINE_STATE_STAGES_ENUM stage)
         {
             RemoveControlCallback(PowerUpLoadControlId, PowerUpUpdateCallBackFunction);
             PowerUpLoadControlId = 0xFF;
+            PowerUpStopReporting();
         }
     }
     return status;
diff --git a/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerOffSequence.h b/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerOffSequence.h
index 10dd4c71e..d7352492a 100644
--- a/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerOffSequence.h
+++ b/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerOffSequence.h
@@ -39,6 +39,7 @@ void setPowerOffDisableCleaning (bool value);
 
 uint32_t PowerDownUpdateFunc(MessageContainer* requestContainer);
 uint32_t AbortPowerDownFunc(MessageContainer* requestContainer);
+void PowerDownStopReporting(void);
 
 
 #endif /* STATEMACHINES_INITIALIZATION_POWEROFFSEQUENCE_H_ */
diff --git a/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c b/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c
index 82601a162..a2a0d6f67 100644
--- a/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c
+++ b/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c
@@ -105,7 +105,7 @@ JobSegment *TSegment;
 JobBrushStop *TbrushStop;
 JobDispenser *Tdispenser;
 JobSpool *Tspool;
-HeadCleaningParameters *CleaningParameters;
+HeadCleaningParameters *CleaningParameters = NULL;
 bool CopyConfigured[MAX_SYSTEM_MODULES];
 bool CleaningJobActive = false, JoggingJobActive = false;
 char ErrorMsg[100];
@@ -596,10 +596,9 @@ uint32_t ThreadCleaningJob(int speed)
                 TSegment = my_malloc(sizeof(JobSegment));
                 Tspool = my_malloc(sizeof(JobSpool));
                 TbrushStop = my_malloc(sizeof(JobBrushStop));
-                CleaningParameters = my_malloc(sizeof(CleaningParameters));
-                CleaningParameters->has_cleanerflow = true;
-                CleaningParameters->cleanerflow = 800;
                 Ticket.headcleaningparameters = CleaningParameters;
+                if (Ticket.headcleaningparameters)
+                    Report("Clean job cleaning parameters", __FILE__, __LINE__, Ticket.headcleaningparameters->cleanerflow, RpWarning, Ticket.headcleaningparameters->archeadcleaningmotorspeed, 0);
                 TSegment->length = 10.0;
                 Ticket.length += (TSegment->length*n_segments);
                 TSegment->n_brushstops = 1;
@@ -649,8 +648,8 @@ void FreeCleaningJobData(void *JobDetails)
 {
     JobTicket* JobTicket = JobDetails;
 
-    if (JobTicket->headcleaningparameters)
-        free (JobTicket->headcleaningparameters);
+    //if (JobTicket->headcleaningparameters)
+    //    free (JobTicket->headcleaningparameters);
     if (JobTicket->spool)
     {
         free (JobTicket->spool);
@@ -962,6 +961,18 @@ void JobRequestFunc(MessageContainer* requestContainer)
                             usnprintf(ErrorMsg, 100, "spool parameters error");
                         }
                     }
+                    if (Ticket->headcleaningparameters)
+                    {
+                        ///store last updated cleaning parameters
+                        if (CleaningParameters == NULL)
+                            CleaningParameters = my_malloc(sizeof(CleaningParameters));
+                        CleaningParameters->has_cleanerflow = Ticket->headcleaningparameters->has_cleanerflow;
+                        CleaningParameters->cleanerflow = Ticket->headcleaningparameters->cleanerflow;
+                        CleaningParameters->has_archeadcleaningmotorspeed = Ticket->headcleaningparameters->has_archeadcleaningmotorspeed;
+                        CleaningParameters->archeadcleaningmotorspeed = Ticket->headcleaningparameters->archeadcleaningmotorspeed;
+                        Report("Save job cleaning parameters", __FILE__, __LINE__, CleaningParameters->cleanerflow, RpWarning, CleaningParameters->archeadcleaningmotorspeed, 0);
+
+                    }
 
                 }
                 else