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

15 files changed, 326 insertions, 105 deletions

diff --git a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
index cdb8950e4..8e67de0f1 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
+++ b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
@@ -16,7 +16,9 @@
 ///////////////////////////////////////////////////////////////////////////////////////////
 #include "include.h"
 #include "Modules/General/GeneralHardware.h"
+
 #include "Modules/AlarmHandling/AlarmHandling.h"
+#include "Modules/General/MachineStatus.h"
 
 #include "MillisecTask.h"
 #include <driverlib/timer.h>
@@ -40,6 +42,7 @@
 #include "modules/thread/thread_ex.h"
 #include "modules/ids/ids_ex.h"
 #include "modules/Diagnostics/Diagnostics.h"
+#include "Modules/General/MachineStatus.h"
 
 #include "drivers/Flash_Memory/Flash_Memory.h"
 #include "drivers/Flash_Memory/fatfs/ff.h"
@@ -606,7 +609,8 @@ uint32_t MillisecLowLoop(uint32_t tick)
         {
             Read_MidTank_Pressure_Sensor(Disp_i);
         }
-/*        for (Motor_i = 0;Motor_i < NUM_OF_MOTORS;Motor_i++)
+        MachineUpdateResponseFunc();
+        /*        for (Motor_i = 0;Motor_i < NUM_OF_MOTORS;Motor_i++)
         {
             if (Motor_i == HARDWARE_MOTOR_TYPE__MOTO_SCREW)
                 continue;  //
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
index 8956f417d..aaa6f9a50 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
@@ -49,6 +49,8 @@
 
 #include <drivers/FPGA/FPGA_Comm.h>
 
+#include "diagnostics.h"
+
 extern F2_CTRL_REG F2_CTRL_Reg;
 
 char DiagnosticsToken[36+1] = {0};
@@ -63,26 +65,17 @@ uint32_t Diagnostics_TenMiliControlTrigger(uint32_t IfIndex, uint32_t ReadValue)
 uint32_t Diagnostics_OneSecControlTrigger(uint32_t IfIndex, uint32_t ReadValue);
 uint32_t DispensersCollection(uint32_t IfIndex, uint32_t ReadValue);
 
-//#define REDUCED_DIAGNOSTICS
 
 DiagnosticsMonitors DiagnosticsMonitor = DIAGNOSTICS_MONITORS__INIT;
 #define DIAGNOSTICS_LIMIT 3
 #define DIAGNOSTICS_DANCER_LIMIT 30
 int DiagnosticsIndex = 0;
-#ifdef REDUCED_DIAGNOSTICS
-int DiagnosticCollectionLimit = 1;  //number of data samples to collect before sending to the host
-#else
 int DiagnosticCollectionLimit = 2;  //number of data samples to collect before sending to the host
-#endif
 //int DiagnosticLimit = eHundredMillisecond; //frequency of data collection
 //int DiagnosticFastLimit = eTenMillisecond; //frequency of data collection
-#ifdef REDUCED_DIAGNOSTICS
-int DiagnosticLimit =eOneSecond; //frequency of data collection
-#else
 int DiagnosticLimit =eHundredMillisecond; //frequency of data collection
-#endif
+
 int DiagnosticFastLimit = eTenMillisecond; //frequency of data collection
-//#define TEN_MSEC_COLLECTION
 //DigitalPin DigitalPinArray[1][DIAGNOSTICS_LIMIT+1];
 double dancer1angle[DIAGNOSTICS_LIMIT+1];
 double dancer2angle[DIAGNOSTICS_LIMIT+1];
@@ -109,6 +102,7 @@ double dispensermotorfrequency[MAX_SYSTEM_DISPENSERS][DIAGNOSTICS_LIMIT+1];
 double dispenserspressure[MAX_SYSTEM_DISPENSERS][DIAGNOSTICS_LIMIT+1];
 double MidTankpressure[MAX_SYSTEM_DISPENSERS][1];
 double HeatersCurrent[NUM_OF_CURRENT_HEATERS][1];
+double VOC_Sensor;
 
 DoubleArray DispenserFreq[MAX_SYSTEM_DISPENSERS];
 DoubleArray DiagnosticsDispenserPressure[MAX_SYSTEM_DISPENSERS];
@@ -154,6 +148,8 @@ int diag_index=0;
 uint32_t diag_size[MAX_DIAG_LOG];
 uint32_t diag_time[MAX_DIAG_LOG];
 
+Diagnostic_Mode DiagnosticMode = Diagnostic_Normal_Mode;
+
 /******************** CODE  ********************************************/
 //**********************************************************************
 
@@ -192,14 +188,35 @@ void DiagnosticsInit(void)
 
     return;
 }
+/*typedef enum
+{
+    Diagnostic_Minimal_Mode,
+    Diagnostic_Normal_Mode,
+    Diagnostic_Extended_Mode,
+    Diagnostic_Extreme_Mode
+}Diagnostic_Mode;
+if (DiagnosticMode == Diagnostic_Minimal_Mode)
+if (DiagnosticMode == Diagnostic_Normal_Mode)
+if (DiagnosticMode == Diagnostic_Extended_Mode)
+if (DiagnosticMode == Diagnostic_Extreme_Mode)
+*/
+void SetDiagnosticMode(Diagnostic_Mode Mode)
+{
+    DiagnosticMode = Mode;
+    REPORT_MSG(Mode,"Diagnostic Mode set");
+}
 
 void  SetDiagnosticCollectionLimit(int limit)
 {
     if ((limit)&&(limit<= DIAGNOSTICS_LIMIT))
         DiagnosticCollectionLimit = limit;
-#ifdef REDUCED_DIAGNOSTICS
+    DiagnosticLimit =eHundredMillisecond; //frequency of data collection
+
+    if (DiagnosticMode <= Diagnostic_Normal_Mode)
+    {
         DiagnosticCollectionLimit = 1;  //overrule - send at least once every second
-#endif
+        DiagnosticLimit =eOneSecond; //frequency of data collection
+    }
 }
 
 uint8_t HeaterCounterIndex[MAX_HEATERS_NUM]= {0,0,0,0,0,0,0,0,0,0};
@@ -340,7 +357,6 @@ void DiagnosticTenMsecCollection(void)
 {
     if (DiagnosticsActive == false)
         return;
-//#ifdef TEN_MSEC_COLLECTION
     /*if (JobIsActive()== false)
         return;*/
     DiagnosticLoadDancer(WINDER_DANCER,Control_Read_Dancer_Position(WINDER_DANCER, 0,0));
@@ -352,7 +368,6 @@ void DiagnosticTenMsecCollection(void)
     DiagnosticLoadDancerError(FEEDER_DANCER,ThreadGetMotorCalculatedError(FEEDER_DANCER));
 
     //DiagnosticLoadSpeedSensor(getSensorSpeedData());
-//#endif
 }
 void DiagnosticOneSecCollection(void)
 {
@@ -378,6 +393,7 @@ void DiagnosticOneSecCollection(void)
             MidTankpressure[i][0] = Get_MidTank_Pressure_Sensor(i);
         else
             MidTankpressure[i][0] = 1.00-(IDS_Dispenser_Data[i].consumedinnanolitter/5800000);
+        //double dispcapacity = (1.00-(IDS_Dispenser_Data[i].consumedinnanolitter/5800000))*130*1000*1000;
     }
 }
 void Diagnostic100msecCollection(void)
@@ -387,19 +403,20 @@ void Diagnostic100msecCollection(void)
         return;
 
     //DiagnosticLoadSpeedSensor(getSensorSpeedData());
-#ifndef REDUCED_DIAGNOSTICS
-#ifndef TEN_MSEC_COLLECTION
-    DiagnosticTenMsecCollection(); //call the 10msec function every 100 msec to reduce transport
-#endif
-    //if (JobIsActive())
+    if (DiagnosticMode == Diagnostic_Extreme_Mode)
+        DiagnosticTenMsecCollection(); //call the 10msec function every 100 msec to reduce transport
+
+    if (DiagnosticMode >= Diagnostic_Extended_Mode)
     {
-        DiagnosticLoadMotor(FEEDER_MOTOR, ThreadGetMotorSpeed (FEEDER_MOTOR));
-        DiagnosticLoadMotor(DRYER_MOTOR, ThreadGetMotorSpeed (DRYER_MOTOR));
-        DiagnosticLoadMotor(POOLER_MOTOR, ThreadGetMotorSpeed (POOLER_MOTOR));
-        DiagnosticLoadMotor(WINDER_MOTOR, ThreadGetMotorSpeed (WINDER_MOTOR));
-        DiagnosticLoadMotor(SCREW_MOTOR, ThreadGetMotorSpeed (SCREW_MOTOR));
+        if (JobIsActive())
+        {
+            DiagnosticLoadMotor(FEEDER_MOTOR, ThreadGetMotorSpeed (FEEDER_MOTOR));
+            DiagnosticLoadMotor(DRYER_MOTOR, ThreadGetMotorSpeed (DRYER_MOTOR));
+            DiagnosticLoadMotor(POOLER_MOTOR, ThreadGetMotorSpeed (POOLER_MOTOR));
+            DiagnosticLoadMotor(WINDER_MOTOR, ThreadGetMotorSpeed (WINDER_MOTOR));
+            DiagnosticLoadMotor(SCREW_MOTOR, ThreadGetMotorSpeed (SCREW_MOTOR));
+        }
     }
-#endif
     /*
     DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__MixerHeater, MillisecGetTemperatures( MIXER_PT100));
     DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DYEINGH_TEMP1));
@@ -424,13 +441,14 @@ void Diagnostic100msecCollection(void)
             MidTankpressure[i][0] = 1.00-(IDS_Dispenser_Data[i].consumedinnanolitter/5800000);
     }
     */
-#ifndef REDUCED_DIAGNOSTICS
-    for (i=0;i<NUM_OF_CURRENT_HEATERS;i++)
+    if (DiagnosticMode == Diagnostic_Extreme_Mode)
     {
-        HeatersCurrent[i][0] = Get_Heaters_Current(i);
+        for (i=0;i<NUM_OF_CURRENT_HEATERS;i++)
+        {
+            HeatersCurrent[i][0] = Get_Heaters_Current(i);
+        }
     }
-#endif
-    /*     dispenser1motorfrequency[DiagnosticsIndex] = MotorGetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1);
+   /*dispenser1motorfrequency[DiagnosticsIndex] = MotorGetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1);
      dispenser2motorfrequency[DiagnosticsIndex] = MotorGetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2);
      dispenser3motorfrequency[DiagnosticsIndex] = MotorGetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3);
      dispenser4motorfrequency[DiagnosticsIndex] = MotorGetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4);
@@ -507,8 +525,7 @@ void SendDiagnostics(void)
     DiagnosticsMonitor.dancer2angle = dancer2angle;
     DiagnosticsMonitor.dancer3angle = dancer3angle;
 */
-#ifndef REDUCED_DIAGNOSTICS
-    //if (JobIsActive())
+    if ((JobIsActive())&&(DiagnosticMode >= Diagnostic_Extended_Mode))
     {
         DiagnosticsMonitor.n_dancer1angle =  DancerCounterIndex[0];
         DiagnosticsMonitor.n_dancer2angle =  DancerCounterIndex[1];
@@ -537,7 +554,6 @@ void SendDiagnostics(void)
         DiagnosticsMonitor.n_windermotor =  MotorCounterIndex[WINDER_MOTOR];
         DiagnosticsMonitor.n_screwmotor = MotorCounterIndex[SCREW_MOTOR];
     }
-#endif
     DiagnosticsMonitor.mixertemperature = HeaterTemperature[HARDWARE_PID_CONTROL_TYPE__MixerHeater];
     DiagnosticsMonitor.headzone1temperature = HeaterTemperature[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1];
     DiagnosticsMonitor.headzone2temperature = HeaterTemperature[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2];
@@ -653,6 +669,10 @@ void SendDiagnostics(void)
     DiagnosticsMonitor.n_headzone5_6heatercurrent = 1;
     DiagnosticsMonitor.headzone5_6heatercurrent = HeatersCurrent[HEATER_HEAD_CURRENT_ZONE_5_6];
 
+    VOC_Sensor = (double) getGasReading();
+    DiagnosticsMonitor.n_filterdeltapressure = 1;
+    DiagnosticsMonitor.filterdeltapressure = &VOC_Sensor;
+
     response.monitors = &DiagnosticsMonitor;
     //response.digitalpins = DigitalPinArray;
     response.n_componentsstates = 0;
@@ -733,12 +753,10 @@ uint32_t DiagnosticsStart(void)
                 DiagnosticsControlId = AddControlCallback(Diagnostics_ControlTrigger,DiagnosticLimit,TemplateDataReadCBFunction,0,0,0);
             else
                 LOG_ERROR(DiagnosticsControlId,"Diagnostics restarted");
-#ifdef TEN_MSEC_COLLECTION
             if (Diagnostics10MSControlId == 0xFF)
                 Diagnostics10MSControlId = AddControlCallback(Diagnostics_TenMiliControlTrigger,DiagnosticFastLimit,TemplateDataReadCBFunction,0,0,0);
             else
                 LOG_ERROR(DiagnosticsControlId,"Diagnostics restarted");
-#endif
             if (Diagnostics1SecControlId == 0xFF)
                 Diagnostics1SecControlId = AddControlCallback(Diagnostics_OneSecControlTrigger,eOneSecond,TemplateDataReadCBFunction,0,0,0);
             else
@@ -822,13 +840,14 @@ uint32_t Diagnostics_TenMiliControlTrigger(uint32_t IfIndex, uint32_t ReadValue)
 {
     DiagnosticsMessageStruc Message;
 
-    //send message to the Millisec task
-    Message.messageId = DiagnosticsTenMiliTrigger;
-    Message.msglen = sizeof(DiagnosticsMessageStruc);
-    if (DiagnosticsMsgQ != NULL)
-        Mailbox_post(DiagnosticsMsgQ , &Message, BIOS_NO_WAIT);
-
-
+    if (DiagnosticMode == Diagnostic_Extreme_Mode)
+    {
+        //send message to the Millisec task
+        Message.messageId = DiagnosticsTenMiliTrigger;
+        Message.msglen = sizeof(DiagnosticsMessageStruc);
+        if (DiagnosticsMsgQ != NULL)
+            Mailbox_post(DiagnosticsMsgQ , &Message, BIOS_NO_WAIT);
+    }
     return OK;
 }
 
@@ -868,9 +887,7 @@ void DiagnosticsTask(UArg arg0, UArg arg1)
                 Diagnostic100msecCollection();
                 break;
             case DiagnosticsTenMiliTrigger:
-#ifdef TEN_MSEC_COLLECTION
                 DiagnosticTenMsecCollection();
-#endif
                 break;
             case DiagnosticsOneSecTrigger:
                 DiagnosticOneSecCollection();
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.h b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.h
index a68731eea..d6d515598 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.h
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.h
@@ -12,9 +12,17 @@
 extern bool blowervolatgedisplay;
 extern bool midtankDisplay;
 extern double voltage;
-extern uint8_t* diagnosticscontainer_buffer;
+extern char* diagnosticscontainer_buffer;
 
+typedef enum
+{
+    Diagnostic_Minimal_Mode,
+    Diagnostic_Normal_Mode,
+    Diagnostic_Extended_Mode,
+    Diagnostic_Extreme_Mode
+}Diagnostic_Mode;
 
+void SetDiagnosticMode(Diagnostic_Mode Mode);
 uint32_t StartDiagnosticsRequestFunc(MessageContainer* requestContainer);
 uint32_t StopDiagnosticsRequestFunc(MessageContainer* requestContainer);
 
diff --git a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
index f5e33ed14..5a706e25c 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
@@ -185,6 +185,7 @@ void LoadConfigurationParameters(ConfigurationParameters *Params)
             EmbeddedParameters->dispenserpresegmentwfcf = 80;
             EmbeddedParameters->has_startheatingoninitsequence = true;
             EmbeddedParameters->startheatingoninitsequence = true; //set to true shlomo 14/5/2019
+            EmbeddedParameters->n_generalparameters = 7;
             EmbeddedParameters->generalparameters = malloc (sizeof(double)*10);
             if (EmbeddedParameters->generalparameters)
             {
@@ -194,6 +195,7 @@ void LoadConfigurationParameters(ConfigurationParameters *Params)
                 EmbeddedParameters->generalparameters[3] = 0.0; //CheckMotorAlarms
                 EmbeddedParameters->generalparameters[4] = 800.0; //Winder homing time at end of job
                 EmbeddedParameters->generalparameters[5] = 1000.0; //Dispenser initial pressure speed
+                EmbeddedParameters->generalparameters[6] = Diagnostic_Normal_Mode; //Diagnostic Mode SetDiagnosticMode
             }
             EmbeddedParameters->has_currentalarmlowlimit = true;
             EmbeddedParameters->currentalarmlowlimit = 0.80;
@@ -270,8 +272,15 @@ uint32_t EmbeddedParametersInit(void)
         }
     }
 
+    if (EmbeddedParameters->n_generalparameters >= 6)
+    {
+        IDS_Dispenser_SetBackLashValues(EmbeddedParameters->initialdispenserpressure, EmbeddedParameters->initialdispensertimeout, EmbeddedParameters->initialdispensertimelag,EmbeddedParameters->generalparameters[5]);
+    }
+    else
+    {
+        IDS_Dispenser_SetBackLashValues(EmbeddedParameters->initialdispenserpressure, EmbeddedParameters->initialdispensertimeout, EmbeddedParameters->initialdispensertimelag,900);
+    }
     IDS_Dispenser_SetTimeOutValues(EmbeddedParameters->closevalvetimeout, EmbeddedParameters->openvalvetimeout);
-    IDS_Dispenser_SetBackLashValues(EmbeddedParameters->initialdispenserpressure, EmbeddedParameters->initialdispensertimeout, EmbeddedParameters->initialdispensertimelag,EmbeddedParameters->generalparameters[5]);
     IDS_Dispenser_SetPrepareValues(EmbeddedParameters->dispenserbuildpressurespeed,   EmbeddedParameters->dispenserbuildpressurelimit, EmbeddedParameters->dispenserbuildpressuretimeout, EmbeddedParameters->dispenserbuildpressurelag);
     IDS_Dispenser_SetPreSegmentWFCFValues(EmbeddedParameters->dispenserpresegmentwfcf,  EmbeddedParameters->ids_presegment_wfcf_timebeforesegment);
     IDS_Dispenser_SetPreSegmentCleaningValues(EmbeddedParameters->ids_cleaningspeed,EmbeddedParameters->ids_cleaningstartspraypresegmenttime ,EmbeddedParameters->ids_cleaningstopbeforesegmenttime,EmbeddedParameters->ids_leftcleaningmotorspeed,EmbeddedParameters->ids_rightcleaningmotorspeed);
@@ -284,15 +293,24 @@ uint32_t EmbeddedParametersInit(void)
     PowerOffSetTemperatureThreshold(EmbeddedParameters->powerofftemperaturelimit);
 
     InitSequenceSetStartHeating (EmbeddedParameters->startheatingoninitsequence);
-    bool checkHardLimitAlarms, checkCurrentAlarms,  checkTamperAlarms,  checkMotorAlarms;
-    checkHardLimitAlarms = (EmbeddedParameters->generalparameters[0] < 0.5)?false:true;
-    checkCurrentAlarms = (EmbeddedParameters->generalparameters[1] < 0.5)?false:true;
-    checkTamperAlarms = (EmbeddedParameters->generalparameters[2] < 0.5)?false:true;
-    checkMotorAlarms = (EmbeddedParameters->generalparameters[3] < 0.5)?false:true;
-    AlarmHandlingSetFlags(checkHardLimitAlarms,checkCurrentAlarms,checkTamperAlarms,checkMotorAlarms);
-    SetWinderBackToBaseTime((uint32_t) EmbeddedParameters->generalparameters[4]);
-
-
+    bool checkHardLimitAlarms = false, checkCurrentAlarms = false,  checkTamperAlarms = false,  checkMotorAlarms = false;
+    if (EmbeddedParameters->n_generalparameters >= 4)
+    {
+        checkHardLimitAlarms = (EmbeddedParameters->generalparameters[0] < 0.5)?false:true;
+        checkCurrentAlarms = (EmbeddedParameters->generalparameters[1] < 0.5)?false:true;
+        checkTamperAlarms = (EmbeddedParameters->generalparameters[2] < 0.5)?false:true;
+        checkMotorAlarms = (EmbeddedParameters->generalparameters[3] < 0.5)?false:true;
+        AlarmHandlingSetFlags(checkHardLimitAlarms,checkCurrentAlarms,checkTamperAlarms,checkMotorAlarms);
+    }
+    if (EmbeddedParameters->n_generalparameters >= 5)
+        SetWinderBackToBaseTime((uint32_t) EmbeddedParameters->generalparameters[4]);
+    if (EmbeddedParameters->n_generalparameters >= 7)
+    {
+        if(EmbeddedParameters->generalparameters[6]<0.5)  SetDiagnosticMode(Diagnostic_Minimal_Mode);
+        else if(EmbeddedParameters->generalparameters[6]<1.5)  SetDiagnosticMode(Diagnostic_Normal_Mode);
+        else if(EmbeddedParameters->generalparameters[6]<2.5)  SetDiagnosticMode(Diagnostic_Extended_Mode);
+        else if(EmbeddedParameters->generalparameters[6]<3.5)  SetDiagnosticMode(Diagnostic_Extreme_Mode);
+    }
     PowerIdleSetParameters(EmbeddedParameters->switchtoidletimeinseconds,EmbeddedParameters->idledriertemperature,EmbeddedParameters->idleheadtemperature,EmbeddedParameters->idlemixertemperature);
 
     return Fresult;
diff --git a/Software/Embedded_SW/Embedded/Modules/General/MachineStatus.c b/Software/Embedded_SW/Embedded/Modules/General/MachineStatus.c
new file mode 100644
index 000000000..7949ee0c2
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Modules/General/MachineStatus.c
@@ -0,0 +1,136 @@
+/*
+ * MachineStatus.c
+ *
+ *  Created on: Aug 15, 2019
+ *      Author: shlomo
+ */
+#include <Container.h>
+#include <DataDef.h>
+#include <stdio.h>      /* puts(), etc. */
+#include "Common/report/report.h"
+#include "include.h"
+
+#include "PMR/common/MessageContainer.pb-c.h"
+#include "PMR/MachineStatus/StartMachineStatusUpdateRequest.pb-c.h"
+#include "PMR/MachineStatus/StopMachineStatusUpdateRequest.pb-c.h"
+#include "PMR/MachineStatus/StartMachineStatusUpdateResponse.pb-c.h"
+#include "PMR/MachineStatus/StopMachineStatusUpdateResponse.pb-c.h"
+#include "PMR/MachineStatus/MachineStatus.pb-c.h"
+#include "PMR/MachineStatus/MachineState.pb-c.h"
+#include "PMR/MachineStatus/IDSPackLevel.pb-c.h"
+
+#include "drivers/I2C_Communication/ADC_MUX/ADC_MUX.h"
+
+#include "Modules/General/MachineStatus.h"
+
+#include "modules/ids/ids_ex.h"
+
+MachineState StoredMachineStatus = MACHINE_STATE__Ready;
+
+void SetMachineStatus (MachineState State)
+{
+    StoredMachineStatus = State;
+}
+char MachineUpdateToken[36+1] = {0};
+IDSPackLevel IDS_Level[MAX_SYSTEM_DISPENSERS];
+int MachineUpdateResponseFunc(void)
+{
+    int i;
+    MessageContainer responseContainer;
+    if (MachineUpdateToken[0] == 0)
+        return OK;
+
+    StartMachineStatusUpdateResponse response = START_MACHINE_STATUS_UPDATE_RESPONSE__INIT;
+    MachineStatus MachineStatus;
+    response.status = &MachineStatus;
+
+    machine_status__init(&MachineStatus);
+    MachineStatus.has_state = true;
+    MachineStatus.state = StoredMachineStatus;
+    MachineStatus.n_idspackslevels = MAX_SYSTEM_DISPENSERS;
+    MachineStatus.idspackslevels = (IDSPackLevel**)my_malloc(sizeof(IDSPackLevel *)*8);
+    if (MachineStatus.idspackslevels)
+    {
+        for (i = 0; i<MAX_SYSTEM_DISPENSERS;i++)
+        {
+            IDS_Level[i].has_index = true;
+            IDS_Level[i].index = i;
+            IDS_Level[i].has_dispenserlevel = true;
+            double dispcapacity = (1.00-(IDS_Dispenser_Data[i].consumedinnanolitter/5800000))*130*1000*1000;
+            IDS_Level[i].dispenserlevel = (int32_t)dispcapacity;
+            IDS_Level[i].has_midtanklevel = true;
+            IDS_Level[i].midtanklevel = Get_MidTank_Int100_Sensor(i);
+            MachineStatus.idspackslevels[i] = &IDS_Level[i];
+        }
+    }
+    else
+        return ERROR;
+
+
+
+    responseContainer = /*MachineUpdate*/createContainer(MESSAGE_TYPE__StartMachineStatusUpdateResponse, MachineUpdateToken, false, &response, &start_machine_status_update_response__pack, &start_machine_status_update_response__get_packed_size);
+    responseContainer.continuous = true;
+    //if (responseContainer.data.data)
+    {
+        uint8_t* container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
+        if (container_buffer)
+        {
+            size_t container_size = message_container__pack(&responseContainer, container_buffer);
+            //        if (SendChars(container_buffer, container_size) == false) //comm tx mailbox full
+            if (SendCharsWithType(container_buffer, container_size,MESSAGE_TYPE__StartMachineStatusUpdateResponse) == false) //comm tx mailbox full
+            {
+                //CommunicationMailboxFlush();
+                MachineUpdateToken[0] = 0;
+                my_free(container_buffer);
+            }
+        }
+        my_free(responseContainer.data.data);
+    }
+
+    my_free(MachineStatus.idspackslevels);
+        //Task_sleep(5);
+    return OK;
+
+}
+
+
+uint32_t MachineUpdateInitFunc(MessageContainer* requestContainer)
+{
+    uint32_t status = NOT_SUPPORTED;
+    //MessageContainer responseContainer;
+
+//    MachineUpdateInitParams InitParams;
+
+    StartMachineStatusUpdateRequest* request = start_machine_status_update_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
+    ustrncpy (MachineUpdateToken, requestContainer->token,36);
+
+    start_machine_status_update_request__free_unpacked(request,NULL);
+    return status;
+}
+void MachineUpdateStopReporting(void)
+{
+    MachineUpdateToken[0] = 0;
+}
+uint32_t StopMachineUpdateFunc(MessageContainer* requestContainer)
+{
+
+    MessageContainer responseContainer;
+
+    StopMachineStatusUpdateRequest* request = stop_machine_status_update_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
+
+    StopMachineStatusUpdateResponse response = STOP_MACHINE_STATUS_UPDATE_RESPONSE__INIT;
+
+//TODO Handle the request!!!!
+    MachineUpdateStopReporting();
+    responseContainer = createContainer(MESSAGE_TYPE__StopMachineStatusUpdateResponse, MachineUpdateToken, false, &response, &stop_machine_status_update_response__pack, &stop_machine_status_update_response__get_packed_size);
+    responseContainer.continuous = true;
+    uint8_t* container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
+    size_t container_size = message_container__pack(&responseContainer, container_buffer);
+    my_free(responseContainer.data.data);
+    //USBCDCD_sendData(container_buffer, container_size,10);
+    SendChars(container_buffer, container_size);
+    //free (container_buffer);
+
+return OK;
+}
+
diff --git a/Software/Embedded_SW/Embedded/Modules/General/MachineStatus.h b/Software/Embedded_SW/Embedded/Modules/General/MachineStatus.h
new file mode 100644
index 000000000..489a8f638
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Modules/General/MachineStatus.h
@@ -0,0 +1,21 @@
+/*
+ * MachineStatus.h
+ *
+ *  Created on: Aug 15, 2019
+ *      Author: shlomo
+ */
+
+#ifndef MODULES_GENERAL_MACHINESTATUS_H_
+#define MODULES_GENERAL_MACHINESTATUS_H_
+#include <PMR/Common/MessageContainer.pb-c.h>
+#include "PMR/MachineStatus/MachineState.pb-c.h"
+
+uint32_t MachineUpdateInitFunc(MessageContainer* requestContainer);
+uint32_t StopMachineUpdateFunc(MessageContainer* requestContainer);
+void SetMachineStatus (MachineState State);
+int MachineUpdateResponseFunc(void);
+
+
+
+
+#endif /* MODULES_GENERAL_MACHINESTATUS_H_ */
diff --git a/Software/Embedded_SW/Embedded/Modules/General/process.c b/Software/Embedded_SW/Embedded/Modules/General/process.c
index 39e87ed6a..d62d117a0 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/process.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/process.c
@@ -258,14 +258,22 @@ uint32_t LoadProcessParamsFromFile(void)
         UploadProcessParametersRequest* request = upload_process_parameters_request__unpack(NULL, Bytes, buffer);
         ProcessParameters*  ProcessParams = request->processparameters;
 
-        if ((ProcessParams->dryerzone1temp > 0.1)&&(ProcessParams->headzone2temp > 0.1)&&(ProcessParams->headzone3temp > 0.1)&&(ProcessParams->headzone4temp > 0.1))//NOT turning off heaters
+        if ((request!= NULL)&&(ProcessParams!=NULL))
         {
-            Bytes = sizeof(ProcessParameters);
-            EraseFlashSection(PROCESS_PARAMETERS_MAP_IN_FLASH,Bytes+4);
-            ReadAppAndProgram(PROCESS_PARAMETERS_MAP_IN_FLASH, 4,&Bytes);
-            ReadAppAndProgram(PROCESS_PARAMETERS_MAP_IN_FLASH+4, Bytes, ProcessParams);
-            REPORT_MSG(Bytes,"ProcessParameters Bytes write to flash");
-            free (buffer);
+            if ((ProcessParams->dryerzone1temp > 0.1)&&(ProcessParams->headzone2temp > 0.1)&&(ProcessParams->headzone3temp > 0.1)&&(ProcessParams->headzone4temp > 0.1))//NOT turning off heaters
+            {
+                Bytes = sizeof(ProcessParameters);
+                EraseFlashSection(PROCESS_PARAMETERS_MAP_IN_FLASH,Bytes+4);
+                ReadAppAndProgram(PROCESS_PARAMETERS_MAP_IN_FLASH, 4,&Bytes);
+                ReadAppAndProgram(PROCESS_PARAMETERS_MAP_IN_FLASH+4, Bytes, ProcessParams);
+                REPORT_MSG(Bytes,"ProcessParameters Bytes write to flash");
+                free (buffer);
+            }
+        }
+        else
+        {
+            Report("process parameters not loaded",__FILE__,__LINE__,(int)request,RpWarning,(int)request,0);
+            return ERROR;
         }
     }
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
index 4789db31f..050bb65b8 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
@@ -196,11 +196,11 @@ void HeatersControlStop(void)
 //{eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_AN_ENCLOSURETEMP1,  0,40,true,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__MACHINE_INTERNAL_OVERTEMPERATURE      },
 //{eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_AN_ENCLOSURETEMP2,  1,40,true,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__MACHINE_INTERNAL_OVERTEMPERATURE      },
 typedef enum{
-    ENCLOSURE_INTERNAL_TEMP,
-    CABINET_INTERNAL_TEMP,
-    MAIN_CARD_INTERNAL_TEMP,
+    INTERNAL_ENCLOSURE_TEMP,
+    INTERNAL_CABINET_TEMP,
+    INTERNAL_MAIN_CARD_TEMP,
     MAX_INTERNAL_ALARMS
-};
+}InternalTemperatureTestPointsEnum;
 int InternalAlarmCounter[MAX_INTERNAL_ALARMS] = {0,0,0};
 uint32_t InternalId2PT100Id[MAX_INTERNAL_ALARMS] = {TEMP_SENSE_AN_ENCLOSURETEMP1,TEMP_SENSE_AN_ENCLOSURETEMP1,0xFF};
 int32_t    InternalOverHeatCounter [MAX_INTERNAL_ALARMS] = {0,0,0};
@@ -557,7 +557,7 @@ void PrepareACHeater(int HeaterId,uint32_t Frequency, uint32_t SetTemperatue)
             HeaterCmd[HeaterId].targettemperatue = 0;
             AlarmHandlingSetAlarm(HeaterEventType[HeaterId], true);
 
-            return ERROR;
+            return;
         }
 
     }
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
index 2f563d7d1..6c055c1a6 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
@@ -235,7 +235,7 @@ void IDS_Dispenser_Content_Init (void)
         dispenser_running_data__init(&IDS_Dispenser_Data[i]);
         dispenserdata[i] = &IDS_Dispenser_Data[i];
         IDS_Dispenser_Data[i].nanolitterperpulse = DEFAULT_NANOLITER_PER_PULSE;
-        IDS_Dispenser_Data[i].microsteps = MotorsCfg[HW_Motor_Id].microstep;;
+        IDS_Dispenser_Data[i].microsteps = MotorsCfg[HW_Motor_Id].microstep;
     }
     //==================================
 
@@ -375,24 +375,6 @@ void IDS_Dispenser_RefillEnded (char DispenserId,char  MicroSteps)
     IDS_Dispenser_Data[DispenserId].consumedinnanolitter = 0;
     Report("IDS_Dispenser_RefillEnded",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)IDS_Dispenser_Data[DispenserId].numberofrefills,0);
 }
-void IDS_Dispenser_PrimingEnded (char DispenserId,char  MicroSteps)
-{
-    assert (DispenserId<MAX_SYSTEM_DISPENSERS);
-    /*IDS_Dispenser_Data[DispenserId].microsteps = MicroSteps;
-    IDS_Dispenser_Data[DispenserId].direction = 1;
-    IDS_Dispenser_Data[DispenserId].consumedinnanolitter = 0;*/
-    Report("IDS_Dispenser_PrimingEnded",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)IDS_Dispenser_Data[DispenserId].numberofrefills,0);
-}
-void IDS_Dispenser_PrimingStarted (char DispenserId,char  MicroSteps)
-{
-    assert (DispenserId<MAX_SYSTEM_DISPENSERS);
-    /*IDS_Dispenser_Data[DispenserId].microsteps = MicroSteps;
-    double assumedFlow = IDS_Dispenser_Data[DispenserId].microsteps*IDS_Dispenser_Data[DispenserId].nanolitterperpulse;
-    IDS_Dispenser_Data[DispenserId].nanolitterperpulse = assumedFlow;
-    IDS_Dispenser_Data[DispenserId].microsteps = 1;
-    IDS_Dispenser_Data[DispenserId].direction = 1;*/
-    Report("IDS_Dispenser_PrimingStarted",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)(CurrentDispenserSpeed[DispenserId]),0);
-}
 void DispenserDataRequestFunc(MessageContainer* requestContainer)
 {
     MessageContainer responseContainer;
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
index 603c4ac66..0a2dff245 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
@@ -16,6 +16,7 @@
 #include "drivers/I2C_Communication/ADC_MUX/ADC_MUX.h"
 
 #include "drivers/FPGA/FPGA_GPIO/FPGA_GPIO.h"
+#include "drivers/FPGA/FPGA_SPI_Comm.h"
 #include "drivers/Motors/Motor.h"
 #include "drivers/Valves/Valve.h"
 
@@ -63,6 +64,8 @@ callback_fptr HomingBacklashCallback[MAX_SYSTEM_DISPENSERS]={0,0,0,0,0,0,0,0};
 uint32_t HomingBacklashTimeout[MAX_SYSTEM_DISPENSERS];
 uint32_t HomingBacklashTime[MAX_SYSTEM_DISPENSERS];
 
+int32_t KeepMicrostep[MAX_SYSTEM_DISPENSERS];
+
 bool HomingActive[MAX_SYSTEM_DISPENSERS] = {false,false,false,false,false,false,false,false};
 bool PrimingActive[MAX_SYSTEM_DISPENSERS] = {false,false,false,false,false,false,false,false};
 uint32_t DispenserHomingControlId[MAX_SYSTEM_DISPENSERS] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
@@ -140,7 +143,9 @@ uint32_t IDS_HomeDispenserBackMoveCallback(uint32_t motorId, uint32_t ReadValue)
     {
         MotorStop(motorId,Hard_Hiz);
         CurrentDispenserSpeed[DispenserId] = 0;
-        MotorSetMicroStep(motorId, MotorsCfg[motorId].microstep);
+        if (Extended_Motor_Param == true)
+            Combined_dispenser_Driver_Mode(DispenserId,Voltage);
+        MotorSetMicroStep(motorId, KeepMicrostep[DispenserId]);
         HomingActive[DispenserId]= false;
         PrimingActive[DispenserId]= false;
         Report("End backlash",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,(int)DispenserHomingTime[DispenserId],0);
@@ -164,7 +169,7 @@ uint32_t IDS_HomeDispenserCallback(uint32_t motorId, uint32_t ReadValue)
     //close dry air valve in the dispenser
     Valve_Set(IDS_Id_to_AirValve[DispenserId], Atm_MidTank_OFF);
     Disable_MidTank_Pressure_Reading(DispenserId);
-    //MotorSetMicroStep(motorId, MotorsCfg[motorId].microstep);
+    //    MotorSetMicroStep(motorId, KeepMicrostep[DispenserId]);
     if (HomingRequestCallback[DispenserId])
     {
         HomingRequestCallback[DispenserId](DispenserId,0);
@@ -204,7 +209,9 @@ uint32_t IDS_HomeDispenser (uint32_t DispenserId, uint32_t speed , callback_fptr
     {
         //open dispenser valve dispenser to midtank direction
         Control3WayValvesWithCallback ((Valves_t)DispenserId, MidTank_Dispenser, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
-        //Valve_Set((Valves_t) request->index, MidTank_Dispenser);
+        KeepMicrostep[DispenserId] = MotorsCfg[MotorId].microstep;
+        if (Extended_Motor_Param == true)
+            Combined_dispenser_Driver_Mode(DispenserId,Current);
         MotorSetMicroStep(MotorId, 1);
         SysCtlDelay(180000);
         //open dry air valve in the dispenser
@@ -227,7 +234,9 @@ uint32_t IDS_Dispenser_Alarm_On (uint8_t DispenserId)
     status |= MotorAbortMovetoLimitSwitch(MotorId);
     Valve_Set(IDS_Id_to_AirValve[DispenserId], Atm_MidTank_OFF);
     Enable_MidTank_Pressure_Reading(DispenserId);
-    status |= MotorSetMicroStep(DispenserId, MotorsCfg[DispenserId].microstep);
+    if (Extended_Motor_Param == true)
+        Combined_dispenser_Driver_Mode(DispenserId,Voltage);
+    status |= MotorSetMicroStep(MotorId, KeepMicrostep[DispenserId]);
     status |= MotorStop(DispenserId, Hard_Hiz);
     CurrentDispenserSpeed[DispenserId] = 0;
     JobEndReason = JOB_OUT_OF_DYE;
@@ -270,7 +279,9 @@ uint32_t IDS_StopHomeDispenser (uint32_t DispenserId)
             Lubricant_2Way_Valve (STOP);
         }
         PrimingActive[DispenserId] = false;
-        MotorSetMicroStep(MotorId, MotorsCfg[MotorId].microstep);
+        if (Extended_Motor_Param == true)
+            Combined_dispenser_Driver_Mode(DispenserId,Voltage);
+        MotorSetMicroStep(MotorId, KeepMicrostep[DispenserId]);
         CurrentDispenserSpeed[DispenserId] = 0;
         CurrentDispenserSpeed[DispenserId] = 0;
     }
@@ -297,7 +308,7 @@ uint32_t IDS_StopHomeDispenserBuildPressure (uint32_t DispenserId)
     //close dry air valve in the dispenser
     Valve_Set(IDS_Id_to_AirValve[DispenserId], Atm_MidTank_OFF);
     Disable_MidTank_Pressure_Reading(DispenserId);
-    //MotorSetMicroStep(motorId, MotorsCfg[motorId].microstep);
+    //    MotorSetMicroStep(motorId, KeepMicrostep[DispenserId]);
     if (HomingRequestCallback[DispenserId])
     {
         HomingRequestCallback[DispenserId](DispenserId,0);
@@ -343,14 +354,16 @@ uint32_t IDS_EmptyDispenserCallback(uint32_t motorId, uint32_t ReadValue)
 
     MotorStop(motorId,Hard_Hiz);
     CurrentDispenserSpeed[DispenserId] = 0;
-    MotorSetMicroStep(motorId, MotorsCfg[motorId].microstep);
+    if (Extended_Motor_Param == true)
+        Combined_dispenser_Driver_Mode(DispenserId,Voltage);
+    MotorSetMicroStep(motorId, KeepMicrostep[DispenserId]);
     PrimingActive[DispenserId]= false;
     if (DispenserId == LUBRICANT_DISPENSER)
     {
         Lubricant_2Way_Valve (STOP);
     }
     Report("End Priming",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,(int)DispenserHomingTime[DispenserId],0);
-    //MotorSetMicroStep(motorId, MotorsCfg[motorId].microstep);
+    //    MotorSetMicroStep(motorId, KeepMicrostep[DispenserId]);
     if (HomingRequestCallback[DispenserId])
     {
         HomingRequestCallback[DispenserId](DispenserId,0);
@@ -376,9 +389,12 @@ uint32_t IDS_EmptyDispenser (uint32_t DispenserId, uint32_t speed , callback_fpt
     {
         //open dispenser valve dispenser to midtank direction
         Control3WayValvesWithCallback ((Valves_t)DispenserId, Dispenser_Mixer, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
+        if (Extended_Motor_Param == true)
+            Combined_dispenser_Driver_Mode(DispenserId,Current);
         //Valve_Set((Valves_t) request->index, Dispenser_Mixer);
+        KeepMicrostep[DispenserId] = MotorsCfg[MotorId].microstep;
         MotorSetMicroStep(MotorId, 1);
-        SysCtlDelay(180000);
+        Task_sleep(100);
         //open dry air valve in the dispenser
         //Valve_Set(IDS_Id_to_AirValve[DispenserId], Atm_MidTank_ON);
         if (DispenserId == LUBRICANT_DISPENSER)
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
index 3e68bc0a4..0de3fa1f3 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
@@ -606,7 +606,7 @@ c.  Go to step 2.a x Segment.BrushStopsCount.
              {
                  NumofReadyDispensers++;
                  tempSpeed = CurrentDispenserSpeed[i];
-                 updatedSpeed = (tempSpeed*0.98>100)?tempSpeed*0.98:100;
+                 updatedSpeed = (tempSpeed*0.985>100)?tempSpeed*0.985:100;
                  MotorSetSpeed(HW_Motor_Id, updatedSpeed);
                  CurrentDispenserSpeed[i] = updatedSpeed;
                  //Report("IDS reduce speed",__FILE__,i,(int)tempSpeed,RpWarning,(int)updatedSpeed,0);
@@ -614,7 +614,7 @@ c.  Go to step 2.a x Segment.BrushStopsCount.
              else
              {
                  tempSpeed = CurrentDispenserSpeed[i];
-                 updatedSpeed = (tempSpeed*1.04<1000)?tempSpeed*1.04:1000;
+                 updatedSpeed = (tempSpeed*1.02<1000)?tempSpeed*1.02:1000;
                  MotorSetSpeed(HW_Motor_Id, updatedSpeed);
                  CurrentDispenserSpeed[i] = updatedSpeed;
                  //Report("IDS accelerate speed",__FILE__,i,(int)tempSpeed,RpWarning,(int)updatedSpeed,0);
@@ -649,7 +649,7 @@ c.  Go to step 2.a x Segment.BrushStopsCount.
     IDS_Active = true;
     Valve_Set(VALVE_MIXCHIP_WASTECH, Mixer_Waste);
 
-    JobTicket* JobTicket = JobDetails;
+    //JobTicket* JobTicket = JobDetails;
 
 
     for (Motor_i = 0;Motor_i < MAX_SYSTEM_DISPENSERS;Motor_i++)
@@ -814,7 +814,7 @@ c.  Go to step 2.a x Segment.BrushStopsCount.
           Report("IDS_PreSegmentPrepare_Callback SafeRemoveControlCallback",__FILE__,DispenserPrepareControlId,InterSegmentStepsCount,RpWarning,(int)NumOfActiveDispensers,0);
           SafeRemoveControlCallback(DispenserPrepareControlId, IDS_Prepare_Callback );
           DispenserPrepareControlId = 0xFF;
-
+          PreSegmentWCFStarted = true;
           setRapidPressureRead(false);
       }
       return OK;
@@ -979,7 +979,7 @@ uint32_t IDS_Cleaning_Stop_Cleaning_Solution (callback_fptr callback);
              //IDS_Cleaning_Center_And_Stop_Rockers (int timeout,callback_fptr callback);
          }
      }
-     if ((InterSegmentStartWFCFDispensers > 0)&&(InterSegmentStartWFCFDispensers == (InterSegmentStepsCount+12000)))
+     if ((InterSegmentStartWFCFDispensers > 12000)&&(InterSegmentStartWFCFDispensers == (InterSegmentStepsCount+12000)))
      {
 	 	//start prepare 4 seconds before wcf
          IDSPresegmentPrepareStart();
@@ -1495,8 +1495,10 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId)
      //TimerMotors_t  HW_Motor_Id = DispenserIdToMotorId[deviceID];
      //REPORT_MSG(deviceID,"Dispenser End called");
      //MotorStop(HW_Motor_Id,Hard_Hiz);
-     //IDS_HomeDispenser (deviceID, 1000 , NULL);
-
+#ifdef AUTO_HOME_DISPENSERS
+     if (deviceID!=LUBRICANT_DISPENSER)
+     IDS_HomeDispenser (deviceID, 1000 , NULL);
+#endif
      return OK;
  }
 //********************************************************************************************************************
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
index 153ab0e43..b47c49cc0 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
@@ -37,6 +37,12 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
         response.has_progress = true;
     }
     else
+    if((request->amount == 0x01) && ((request->delay &0x010000) == 0x010000)) //change mode powerset01
+    {
+        response.progress = Power_Step_01_Mode(((request->delay &0x00FF00)>>8), request->delay &0x0000FF);
+        response.has_progress = true;
+    }
+    else
     if((request->amount == 0xAB) && (request->delay == 0xAB)) //Get pressure with flow (orifice flow meter)
     {
         response.progress = Calculate_Pitot_Pressure(true);
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
index 7d4b66dfb..1f9897905 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
@@ -17,6 +17,9 @@
 #include "Modules/General/process.h"
 #include "Modules/control/pidalgo.h"
 
+#include "Modules/heaters/heaters_ex.h"
+#include "StateMachines/Initialization/InitSequence.h"
+
 #include "PMR/Hardware/HardwareMotor.pb-c.h"
 #include "PMR/Hardware/HardwareMotorType.pb-c.h"
 #include "PMR/Hardware/HardwareDancerType.pb-c.h"
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
index c5e124ad3..e01d12a05 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
@@ -282,7 +282,7 @@ uint32_t Screw100msecDirectionChange(uint32_t deviceID, uint32_t BusyFlag)
     double temp,tempScrewSpeed;
     double screw_horizontal_speed = 0;
     double RotationsPerSecond;
-    double Averagewinderspeed = 0;
+    //double Averagewinderspeed = 0;
 
 //    {
 //        TotalWinderSpeed-=WinderMotorSpeed[WinderMotorSpeedCounter];
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
index 9e77f2de8..59542ec38 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
@@ -451,7 +451,7 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
     //read value is the dancer angle
     int i,index=MAX_THREAD_MOTORS_NUM;
     int DancerId;
-    int32_t TranslatedReadValue, avreageSampleValue = 0,avreageMotorSampleValue = 0;
+    int32_t TranslatedReadValue, avreageSampleValue = 0;//,avreageMotorSampleValue = 0;
     //double tempcalcspeed = 0;
     double calculated_speed;
     double NormalizedError;