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

19 files changed, 324 insertions, 102 deletions

diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
index 6acdf5d67..368c52436 100644
--- a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
+++ b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
@@ -175,6 +175,14 @@ const AlarmHandlingItemStruc  HardCodedAlarmItem[MAX_SYSTEM_ALARMS]={
  {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_7_OVERPRESSURE,"Dispenser 7 Over Pressure"},
  {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_8_OVERPRESSURE,"Dispenser 8 Over Pressure"},
 
+ {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,0,0,50/*500cc*/,false,DEBUG_LOG_CATEGORY__Warning,0xFF,2,EVENT_TYPE__MID_TANK_1_EMPTY,"MidTank 1 Empty alarm"},
+ {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,1,1,50/*500cc*/,false,DEBUG_LOG_CATEGORY__Warning,0xFF,2,EVENT_TYPE__MID_TANK_2_EMPTY,"MidTank 2 Empty alarm"},
+ {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,2,2,50/*500cc*/,false,DEBUG_LOG_CATEGORY__Warning,0xFF,2,EVENT_TYPE__MID_TANK_3_EMPTY,"MidTank 3 Empty alarm"},
+ {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,3,3,50/*500cc*/,false,DEBUG_LOG_CATEGORY__Warning,0xFF,2,EVENT_TYPE__MID_TANK_4_EMPTY,"MidTank 4 Empty alarm"},
+ {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,4,4,50/*500cc*/,false,DEBUG_LOG_CATEGORY__Warning,0xFF,2,EVENT_TYPE__MID_TANK_5_EMPTY,"MidTank 5 Empty alarm"},
+ {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,7,7,50/*500cc*/,false,DEBUG_LOG_CATEGORY__Warning,0xFF,2,EVENT_TYPE__MID_TANK_8_EMPTY,"MidTank 8 Empty alarm"},
+
+
  {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DRYER_MOTOR_OVERCURRENT,"Motor Drier Over Current"},
  {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,     HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,     x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__FEEDER_MOTOR_OVERCURRENT,"Motor Feeder Over Current"},
  {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_SCREW,        HARDWARE_MOTOR_TYPE__MOTO_SCREW,        x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__SCREW_MOTOR_OVERCURRENT,"Motor Screw Over Current"},
@@ -243,14 +251,14 @@ const AlarmHandlingItemStruc  HardCodedAlarmItem[MAX_SYSTEM_ALARMS]={
  {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,RearDoor      ,1,false,true,DEBUG_LOG_CATEGORY__Error,  0xFF,5,EVENT_TYPE__REAR_COVER_OPEN,"Rear door Open"},
  {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,CartridgesDoor,1,false,true,DEBUG_LOG_CATEGORY__Warning,0xFF,5,EVENT_TYPE__CARTRIDGES_COVER_OPEN,"Cartridges door Open"},
 
- {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,MIXER_PT100,   HARDWARE_PID_CONTROL_TYPE__MixerHeater        ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MIXER_UNDERTEMPERATURE_A,"Mixer PT100 Not Heating"},
- {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_A,"DyeingHead 1 PT100 Not Heating"},
- {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_A,"DyeingHead 2 PT100 Not Heating"},
- {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_A,"DyeingHead 3 PT100 Not Heating"},
- {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_A,"DyeingHead 4 PT100 Not Heating"},
- {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_A,"DyeingHead 5 PT100 Not Heating"},
- {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,HEAD6_PT100, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_A,"DyeingHead 6 PT100 Not Heating"},
- {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1,  HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_A,"Dryer PT100 Not Heating"},
+ {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,MIXER_PT100,   HARDWARE_PID_CONTROL_TYPE__MixerHeater        ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__MIXER_UNDERTEMPERATURE_A,"Mixer PT100 Not Heating"},
+ {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1       ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_A,"DyeingHead 1 PT100 Not Heating"},
+ {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2       ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_A,"DyeingHead 2 PT100 Not Heating"},
+ {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3       ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_A,"DyeingHead 3 PT100 Not Heating"},
+ {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4       ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_A,"DyeingHead 4 PT100 Not Heating"},
+ {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5       ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_A,"DyeingHead 5 PT100 Not Heating"},
+ {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,HEAD6_PT100, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6       ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_A,"DyeingHead 6 PT100 Not Heating"},
+ {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1,  HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_A,"Dryer PT100 Not Heating"},
  {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,MIXER_PT100,   HARDWARE_PID_CONTROL_TYPE__MixerHeater        ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MIXER_UNDERTEMPERATURE_B,"Mixer PT100 Heating Failure"},
  {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_B,"DyeingHead 1 PT100 Heating Failure"},
  {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_B,"DyeingHead 2 PT100 Heating Failure"},
@@ -566,6 +574,7 @@ JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob)
     }
     for (Alarm_i = 0;Alarm_i<MAX_SYSTEM_ALARMS;Alarm_i++)
     {
+
         if (AlarmItem[Alarm_i].AlarmSource == ALARM_SOURCE_TYPE__CoversAlarm)
         {
             if (AlarmState[Alarm_i].Status == true)
@@ -575,6 +584,15 @@ JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob)
                 break;
             }
         }
+        /*if (AlarmItem[Alarm_i].AlarmSource == ALARM_SOURCE_TYPE__FluidLevelAlarm)
+        {
+            if (AlarmState[Alarm_i].Status == true)
+            {
+                status = ERROR;
+                AlarmId = Alarm_i;
+                break;
+            }
+        }*/
         if (AlarmItem[Alarm_i].AlarmSource == ALARM_SOURCE_TYPE__MotorAlarm)
         {
             if (AlarmState[Alarm_i].Status == true)
@@ -865,14 +883,14 @@ uint32_t AlarmHandlingLoop(uint32_t tick)
                 value = Get_MidTank_Int100_Sensor(AlarmItem[Alarm_i].DeviceId);
                 if (AlarmItem[Alarm_i].AlarmDirection == OVER_VALUE)
                 {
-                    if (value*100 > AlarmItem[Alarm_i].AlarmValue)
+                    if (value > AlarmItem[Alarm_i].AlarmValue)
                     {
                         Status = true;
                     }
                 }
                 else
                 {
-                    if (value*100 < AlarmItem[Alarm_i].AlarmValue)
+                    if (value < AlarmItem[Alarm_i].AlarmValue)
                     {
                         Status = true;
                     }
diff --git a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
index 193769265..916d33772 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
+++ b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
@@ -48,6 +48,7 @@
 #include "Common/SWUpdate/FileSystem.h"
 
 #include "Communication/Connection.h"
+#include "Modules/General/buttons.h"
 
 Task_Handle Millisecond_Task_Handle;
 /******************** Definitions  ********************************************/
@@ -514,6 +515,7 @@ uint32_t MillisecLowLoop(uint32_t tick)
     {
         Speed_Data = Calculate_Speed_Sensor_Velocity();
         Read_Buttons_Reg();
+        Ink_Cart_Led();
         for (Sensor_i = 0;Sensor_i < MAX_TEMPERATURE_SENSOR_ID;Sensor_i++)
         {
             MillisecUpdateTemperatures (Sensor_i,TemperatureSensorRead(Sensor_i));
diff --git a/Software/Embedded_SW/Embedded/Modules/Control/control.c b/Software/Embedded_SW/Embedded/Modules/Control/control.c
index b316fd73f..f1e19d851 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/control.c
+++ b/Software/Embedded_SW/Embedded/Modules/Control/control.c
@@ -158,7 +158,7 @@ uint32_t ControlActivityLed( uint32_t Parameter1)
 {
     static bool flag = false;
     static uint8_t counter;
-    const uint8_t Blink_Freq = 15;//odd number
+    const uint8_t Blink_Freq = 3;//odd number
 
     if (flag==true)
     {
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c
index 97489f431..2b24f9832 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c
@@ -26,6 +26,7 @@
 #include "drivers/I2C_Communication/ADC_MUX/ADC_MUX.h"
 #include "drivers/Valves/Valve.h"
 #include "drivers/Heater/Heater.h"
+#include "modules/waste/waste.h"
 
 #include "modules/ids/ids_ex.h"
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
index 5ef216264..785d9fc3c 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
@@ -61,6 +61,7 @@ uint32_t Diagnostics_ControlTrigger(uint32_t IfIndex, uint32_t ReadValue);
 uint32_t Diagnostics_TenMiliControlTrigger(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
@@ -69,7 +70,11 @@ int DiagnosticsIndex = 0;
 int DiagnosticCollectionLimit = 2;  //number of data samples to collect before sending to the host
 //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
 
 //DigitalPin DigitalPinArray[1][DIAGNOSTICS_LIMIT+1];
@@ -152,7 +157,7 @@ void DiagnosticsInit(void)
 
     Error_init(&eb);
 
-    DiagnosticsMsgQ = Mailbox_create(sizeof(DiagnosticsMessageStruc), 20, NULL,&eb);
+    DiagnosticsMsgQ = Mailbox_create(sizeof(DiagnosticsMessageStruc), 40, NULL,&eb);
 
     DiagnosticsMonitor.dispensersmotorsfrequency = (DoubleArray**)my_malloc(sizeof(DoubleArray *)*8);
     DiagnosticsMonitor.dispenserspressure = (DoubleArray**)my_malloc(sizeof(DoubleArray)*8);
@@ -322,6 +327,7 @@ 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));
@@ -333,7 +339,7 @@ void DiagnosticTenMsecCollection(void)
     DiagnosticLoadDancerError(FEEDER_DANCER,ThreadGetMotorCalculatedError(FEEDER_DANCER));
 
     //DiagnosticLoadSpeedSensor(getSensorSpeedData());
-
+#endif
 }
 void Diagnostic100msecCollection(void)
 {
@@ -342,7 +348,10 @@ 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())
     {
         DiagnosticLoadMotor(FEEDER_MOTOR, ThreadGetMotorSpeed (FEEDER_MOTOR));
@@ -351,6 +360,7 @@ void Diagnostic100msecCollection(void)
         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));
     DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DYEINGH_TEMP2));
@@ -368,11 +378,13 @@ void Diagnostic100msecCollection(void)
         dispenserspressure[i][DiagnosticsIndex] = GetDispenserPressure(i); //Read_MidTank_Pressure_Sensor
         MidTankpressure[i][0] = Get_MidTank_Pressure_Sensor(i);
     }
+#ifndef REDUCED_DIAGNOSTICS
     for (i=0;i<NUM_OF_CURRENT_HEATERS;i++)
     {
         HeatersCurrent[i][0] = Get_Heaters_Current(i);
     }
-/*     dispenser1motorfrequency[DiagnosticsIndex] = MotorGetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1);
+#endif
+    /*     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);
@@ -449,6 +461,7 @@ void SendDiagnostics(void)
     DiagnosticsMonitor.dancer2angle = dancer2angle;
     DiagnosticsMonitor.dancer3angle = dancer3angle;
 */
+#ifndef REDUCED_DIAGNOSTICS
     //if (JobIsActive())
     {
         DiagnosticsMonitor.n_dancer1angle =  DancerCounterIndex[0];
@@ -478,7 +491,7 @@ 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];
@@ -660,11 +673,11 @@ void SendDiagnostics(void)
 }
 void DispensersCollectionCall(void)
 {
-    int i;
+    /*int i;
     for (i = 0; i<MAX_SYSTEM_DISPENSERS;i++)
     {
         IDS_Dispenser_Content_Calculation(i);
-    }
+    }*/
 }
 uint32_t DiagnosticsControlId = 0xff;
 uint32_t Diagnostics10MSControlId = 0xff;
@@ -682,11 +695,12 @@ 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 (DispensersControlId == 0xFF)
                 DispensersControlId = AddControlCallback(DispensersCollection,eOneSecond,TemplateDataReadCBFunction,0,0,0);
             else
@@ -759,8 +773,8 @@ uint32_t DispensersCollection(uint32_t IfIndex, uint32_t ReadValue)
     //send message to the Millisec task
     Message.messageId = DispensersCollectionTrigger;
     Message.msglen = sizeof(DiagnosticsMessageStruc);
-    if (DiagnosticsMsgQ != NULL)
-        Mailbox_post(DiagnosticsMsgQ , &Message, BIOS_NO_WAIT);
+    //if (DiagnosticsMsgQ != NULL)
+    //    Mailbox_post(DiagnosticsMsgQ , &Message, BIOS_NO_WAIT);
 
 
     return OK;
@@ -819,7 +833,7 @@ void DiagnosticsTask(UArg arg0, UArg arg1)
                 DiagnosticTenMsecCollection();
                 break;
             case DispensersCollectionTrigger:
-                DispensersCollectionCall();
+                //DispensersCollectionCall();  //suspended for ITMA
                 break;
             default:
                 break;
diff --git a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
index 6f1dc2052..b12064915 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
@@ -130,7 +130,7 @@ void LoadConfigurationParameters(ConfigurationParameters *Params)
             EmbeddedParameters.has_initialdispenserpressure = true;
             EmbeddedParameters.initialdispenserpressure = 0.08;
             EmbeddedParameters.has_initialdispensertimeout = true;
-            EmbeddedParameters.initialdispensertimeout = 10000;
+            EmbeddedParameters.initialdispensertimeout = 60000;
             EmbeddedParameters.has_initialdispensertimelag = true;
             EmbeddedParameters.initialdispensertimelag = 100;
             EmbeddedParameters.has_dispenserbuildpressurespeed = true;
@@ -138,7 +138,7 @@ void LoadConfigurationParameters(ConfigurationParameters *Params)
             EmbeddedParameters.has_dispenserbuildpressurelimit = true;
             EmbeddedParameters.dispenserbuildpressurelimit=1.5 ;
             EmbeddedParameters.has_dispenserbuildpressuretimeout = true;
-            EmbeddedParameters.dispenserbuildpressuretimeout=20000;
+            EmbeddedParameters.dispenserbuildpressuretimeout=50000;
             EmbeddedParameters.has_dispenserbuildpressurelag = true;
             EmbeddedParameters.dispenserbuildpressurelag=50;
             EmbeddedParameters.has_acheatersloweroperationlimit = true;
@@ -150,7 +150,7 @@ void LoadConfigurationParameters(ConfigurationParameters *Params)
             EmbeddedParameters.has_dcheatersupperoperationlimit = true;
             EmbeddedParameters.dcheatersupperoperationlimit = 1002;
             EmbeddedParameters.has_midtankpressurecorrection = true;
-            EmbeddedParameters.midtankpressurecorrection = 0.2;
+            EmbeddedParameters.midtankpressurecorrection = 0.0;
             EmbeddedParameters.has_dispenserpresegmentwfcf = true;
             EmbeddedParameters.dispenserpresegmentwfcf = 80;
             EmbeddedParameters.has_startheatingoninitsequence = true;
diff --git a/Software/Embedded_SW/Embedded/Modules/General/Safety.c b/Software/Embedded_SW/Embedded/Modules/General/Safety.c
index 840898db7..f54a4be19 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/Safety.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/Safety.c
@@ -25,7 +25,10 @@
 uint32_t SafetyControlId;
 bool DispenserOverPressure[MAX_SYSTEM_DISPENSERS] = {false,false,false,false,false,false,false,false};
 uint32_t Safety_Main_State(uint32_t IfIndex, uint32_t BusyFlag);
-
+bool DrierDoorAlarmState = false;
+bool AirFlowAlarmState = false;
+bool AirFilterAlarmState = false;
+bool WasteOverflowAlarmState = false;
 void Safety_Init(void)
 {
     SafetyControlId = AddControlCallback( Safety_Main_State, eOneSecond, TemplateDataReadCBFunction,0,0, 0 );
@@ -36,6 +39,10 @@ uint32_t Safety_Main_State(uint32_t IfIndex, uint32_t BusyFlag)
    int Disp_i;
    bool AllDispensersInSafety = true;
    bool AnyDispensersInSafety = false;
+   /*bool mDrierDoorAlarmState = false;
+   bool mAirFlowAlarmState = false;
+   bool mAirFilterAlarmState = false;
+   bool mWasteOverflowAlarmState = false;*/
    for (Disp_i = 0;Disp_i < MAX_SYSTEM_DISPENSERS;Disp_i++)
    {
        if (isMotorConfigured(Disp_i + HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1)==true)
@@ -51,6 +58,8 @@ uint32_t Safety_Main_State(uint32_t IfIndex, uint32_t BusyFlag)
        {
            //report and handle dryer door open
            AlarmHandlingSetAlarm(EVENT_TYPE__DRYER_DOOR_OPEN, true);
+          // mDrierDoorAlarmState = true;
+          // DrierDoorAlarmState = true;
        }
        else
        {
@@ -59,6 +68,8 @@ uint32_t Safety_Main_State(uint32_t IfIndex, uint32_t BusyFlag)
                //report and handle air flow failure
                //if blower if off handling is different
                AlarmHandlingSetAlarm(EVENT_TYPE__NO_AIR_PRESSURE, true);
+            //   mAirFlowAlarmState = true;
+            //   AirFlowAlarmState = true;
            }
            else
            {
@@ -66,6 +77,8 @@ uint32_t Safety_Main_State(uint32_t IfIndex, uint32_t BusyFlag)
                {
                    //report and handle filter missing
                    AlarmHandlingSetAlarm(EVENT_TYPE__AIR_FILTER_NOT_INSTALLED, true);
+              //     mAirFilterAlarmState = true;
+              //     AirFilterAlarmState = true;
                }
                else
                {
@@ -73,6 +86,8 @@ uint32_t Safety_Main_State(uint32_t IfIndex, uint32_t BusyFlag)
                    {
                        //report and handle waste overflow
                        AlarmHandlingSetAlarm(EVENT_TYPE__WASTE_CONTAINER_OVERFLOW, true);
+                //       mWasteOverflowAlarmState = true;
+                 //      WasteOverflowAlarmState = true;
                    }
                }
            }
@@ -108,7 +123,31 @@ uint32_t Safety_Main_State(uint32_t IfIndex, uint32_t BusyFlag)
            }
        }
    }
-
+/*   if  ((mDrierDoorAlarmState != DrierDoorAlarmState)|| (mDrierDoorAlarmState == false))
+   {
+      //alarm went off
+       AlarmHandlingSetAlarm(EVENT_TYPE__DRYER_DOOR_OPEN, false);
+       DrierDoorAlarmState = mDrierDoorAlarmState;
+   }
+   if  ((mAirFlowAlarmState != AirFlowAlarmState)|| (mAirFlowAlarmState == false))
+   {
+      //alarm went off
+       AlarmHandlingSetAlarm(EVENT_TYPE__NO_AIR_PRESSURE, false);
+       AirFlowAlarmState = mAirFlowAlarmState;
+   }
+   if  ((mAirFilterAlarmState != AirFilterAlarmState)|| (mAirFilterAlarmState == false))
+   {
+      //alarm went off
+       AlarmHandlingSetAlarm(EVENT_TYPE__AIR_FILTER_NOT_INSTALLED, false);
+       AirFilterAlarmState = mAirFilterAlarmState;
+   }
+   if  ((mWasteOverflowAlarmState != WasteOverflowAlarmState)|| (mWasteOverflowAlarmState == false))
+   {
+      //alarm went off
+       AlarmHandlingSetAlarm(EVENT_TYPE__WASTE_CONTAINER_OVERFLOW, false);
+       WasteOverflowAlarmState = mWasteOverflowAlarmState;
+   }
+*/
     return OK;
 }
 
diff --git a/Software/Embedded_SW/Embedded/Modules/General/buttons.c b/Software/Embedded_SW/Embedded/Modules/General/buttons.c
index 74cb81aac..cfd44a6fa 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/buttons.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/buttons.c
@@ -603,6 +603,17 @@ uint32_t LoadStatMachine( button *pBtn)
     return OK;
 }
 
+void Ink_Cart_Led()//temporary for ITMA
+{
+    if(Is_Cartridge_Present(CART_1) == true)
+    {
+        Pannel_Leds( CART_1,  MODE_ON);
+    }
+    else
+    {
+        Pannel_Leds( CART_1,  MODE_OFF);
+    }
+}
 
 void test_avi()
 {
diff --git a/Software/Embedded_SW/Embedded/Modules/General/buttons.h b/Software/Embedded_SW/Embedded/Modules/General/buttons.h
index 2d14eb000..4d0df69e1 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/buttons.h
+++ b/Software/Embedded_SW/Embedded/Modules/General/buttons.h
@@ -58,6 +58,7 @@ uint32_t Buttons_Init(void);
 uint32_t Button_load_Init(void);
 uint32_t Button_JOG_Init(void);
 bool SetPowerMachineState(PBmachineState state);
+void Ink_Cart_Led();
 
 
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters.h b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters.h
index 3c9c59f3e..b25c3e5c7 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters.h
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters.h
@@ -5,7 +5,7 @@
 #include "PMR/Hardware/HardwarePidControlType.pb-c.h"
 #include "heaters_ex.h"
 /******************** DEFINITIONS  ********************************************/
-#define MAX_AC_HEATERS HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary+1
+#define MAX_AC_HEATERS (HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary+1)
 #define MAX_TIMESLICES 200
 
 extern uint32_t OutputProportionalSingleStep;  //A/C Heaters step size from one decision point to another - in cpu clocks. 120000 = 1 millisecod
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
index 8fe0a9fd8..3a9ce53d8 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
@@ -172,7 +172,7 @@ void Heaters_SetOverHeatTimeOutValues(uint32_t OverHeatTimeout, uint32_t UnderHe
     Overheat_Count_Limit = OverHeatTimeout;
     Underheat_Count_Limit = UnderHeatTimeout;
 }
-void  Heaters_SetOperationLimits(acheatersloweroperationlimit,acheatersupperoperationlimit,dcheatersloweroperationlimit,dcheatersupperoperationlimit)
+void  Heaters_SetOperationLimits(int acheatersloweroperationlimit, int acheatersupperoperationlimit, int dcheatersloweroperationlimit, int dcheatersupperoperationlimit)
 {
     AcHeatersLoweroperationLimit =  acheatersloweroperationlimit;
     AcHeatersUpperoperationLimit =  acheatersupperoperationlimit;
@@ -249,13 +249,13 @@ uint32_t HeatersSingleHeaterEnd(HardwarePidControlType HeaterId)
             {
                 status |= RemoveControlCallback(ControlIdtoHeaterId [HeaterId], DCHeaterControlCBFunction);
                 ControlIdtoHeaterId [HeaterId]=0xFF;
-                HeaterRecalculateHeaterParams(HeaterId, 0);
             }
             if (ControlIdtoMaxHeaterId [HeaterId]!=0xFF)
             {
                 status |= RemoveControlCallback(ControlIdtoMaxHeaterId [HeaterId], DcHeaterMaxTempCBFunction);
                 ControlIdtoMaxHeaterId [HeaterId]=0xFF;
             }
+            HeaterRecalculateHeaterParams(HeaterId, 0);
             DeActivateHeater(HeaterId);
             HeaterReady[HeaterId] = true;
         }
@@ -323,7 +323,7 @@ void HeatersStartControlTimer (void)
     Report("HeatersStartControlTimer ", __FILE__,__LINE__,0, RpMessage, 0, 0);
     return;
 }
-/***************************************************************************************************/
+/***************************************************************************************************
 int GetFilteredHeaterRead(int HeaterId)
 {
 #define MAX_FILTER 12
@@ -347,7 +347,7 @@ int GetFilteredHeaterRead(int HeaterId)
     Report("GetFilteredHeaterRead ", __FILE__,HeaterId,sum, minread, maxread, 0);
     return (sum/(MAX_FILTER-2));
 }
-/**************************************************************************************
+**************************************************************************************
  * HeaterCommandRequestMessage
  * called by: Communication from host
  * initialized all global data
@@ -462,9 +462,9 @@ void PrepareACHeater(int HeaterId,uint32_t Frequency, uint32_t SetTemperatue)
     HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain, 0);
     HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary, 0);
     if (MainDryerHeaterMaxTempControl == 0xFF)
-        MainDryerHeaterMaxTempControl = AddControlCallback( HeaterMaxTempCBFunction, eHundredMillisecond,MillisecGetTemperatures,(IfTypeHeaters*0x100+HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain),HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain],0);
+        MainDryerHeaterMaxTempControl = AddControlCallback( HeaterMaxTempCBFunction, eOneSecond,MillisecGetTemperatures,(IfTypeHeaters*0x100+HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain),HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain],0);
     if (SecondDryerHeaterMaxTempControl == 0xFF)
-        SecondDryerHeaterMaxTempControl = AddControlCallback( HeaterMaxTempCBFunction, eHundredMillisecond,MillisecGetTemperatures,(IfTypeHeaters*0x100+HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary),HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary],0);
+        SecondDryerHeaterMaxTempControl = AddControlCallback( HeaterMaxTempCBFunction, eOneSecond,MillisecGetTemperatures,(IfTypeHeaters*0x100+HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary),HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary],0);
     //InitialHeating = true;
     HeaterReady[HeaterId] = false;
     if (BlowerCfg.enabled == true)
@@ -492,7 +492,7 @@ int PrepareDCHeater(int HeaterId, uint32_t Frequency, uint32_t SetTemperatue)
         DisasterControlId = AddControlCallback( HeatersDisasterControl, eOneSecond,TemplateDataReadCBFunction,0,0, 0);
 
     if (ControlIdtoHeaterId [HeaterId] == 0xFF)
-    ControlIdtoHeaterId [HeaterId] = AddControlCallback( DCHeaterControlCBFunction, Frequency/*eOneSecond*/,MillisecGetTemperatures,(IfTypeHeaters*0x100+HeaterId),HeaterId2PT100Id[HeaterId],0);
+        ControlIdtoHeaterId [HeaterId] = AddControlCallback( DCHeaterControlCBFunction, Frequency/*eOneSecond*/,MillisecGetTemperatures,(IfTypeHeaters*0x100+HeaterId),HeaterId2PT100Id[HeaterId],0);
     //HeaterPIDConfig[HeaterId].m_params.dt *=10;
     //DCInitialHeating[HeaterId] = true;
     HeaterReady[HeaterId] = false;
@@ -665,7 +665,7 @@ uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue)
     MaxreadValue = max (MainPT100Read,SecondaryPT100Read);
     MinreadValue = min (MainPT100Read,SecondaryPT100Read);
 
-    if ((MaxreadValue) >= HeaterControl[index].sensormaxvalue)
+    if (MaxreadValue >= HeaterControl[index].sensormaxvalue)
     {
         if (HeaterMaxTempFlag[index] == false)
         {
@@ -679,7 +679,7 @@ uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue)
         //HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary,0);
         return OK;
     }
-    if ((MaxreadValue) <= (HeaterControl[index].sensormaxvalue-HeaterControl[index].sensorminvalue)) //was MinreadValue
+    if (MaxreadValue <= (HeaterControl[index].sensormaxvalue-HeaterControl[index].sensorminvalue)) //was MinreadValue
     {
         if (HeaterControl[index].sensorminvalue > 0)
         {
@@ -808,7 +808,7 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
         //Heaters OFF until coming into the proportional band
         HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain,0);
         HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary,0);
-        //LOG_ERROR (0, "unconfigured");
+        LOG_ERROR (0, "unconfigured");
         return ERROR;
     }
     if (abs(readValue - HeaterPreviousRead[index])>2000)
@@ -846,20 +846,24 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
                     HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary,0);
                     return OK;
                 }
-//        if (readValue < ((HeaterCmd[index].targettemperatue * (100-HeaterControl[index].outputproportionalband))/100))
-        if (readValue < (/*HeaterCmd[index].targettemperatue * AcHeatersLoweroperationLimit/1000*/HeaterCmd[index].targettemperatue-1000))
+        if (readValue < ((HeaterCmd[index].targettemperatue * (100-HeaterControl[index].outputproportionalband))/100))
+        //if (readValue < (/*HeaterCmd[index].targettemperatue * AcHeatersLoweroperationLimit/1000*/HeaterCmd[index].targettemperatue-800))
         {
+            //Report("AC Activating",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index);
             if ((HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary] == false)&&(HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] == false))
             {
                 ActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
                 ActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
+                HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain,100);
+                HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary,100);
             }
             return OK;
         }
 
-        if ((readValue > (HeaterCmd[index].targettemperatue-1000)/*(HeaterCmd[index].targettemperatue * AcHeatersLoweroperationLimit/1000)*/)&&(readValue < (HeaterCmd[index].targettemperatue * AcHeatersUpperoperationLimit/1000)))//read value within 0.5 percent from target
+/*        if ((readValue > (HeaterCmd[index].targettemperatue-300)/`*(HeaterCmd[index].targettemperatue * AcHeatersLoweroperationLimit/1000)*`/)&&(readValue < (HeaterCmd[index].targettemperatue * AcHeatersUpperoperationLimit/1000)))//read value within 0.5 percent from target
         {
 //////////////////
+            Report("AC Turn Off secondary",__FILE__,__LINE__,readValue,RpWarning,(HeaterCmd[index].targettemperatue), 0);
             //InitialHeating = false;
             DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
             HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary, 0);
@@ -875,11 +879,25 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
                     Control_Voltage_To_Blower(BlowerCfg.voltage);
             }
         }
-        if ((HeaterCmd[index].targettemperatue * AcHeatersLoweroperationLimit/1000)&&(readValue < (HeaterCmd[index].targettemperatue * AcHeatersUpperoperationLimit/1000)))//read value within 0.5 percent from target
+        */
+        if ((readValue > (HeaterCmd[index].targettemperatue * AcHeatersLoweroperationLimit/1000))&&(readValue < (HeaterCmd[index].targettemperatue * AcHeatersUpperoperationLimit/1000)))//read value within 0.5 percent from target
         {
 //////////////////
             //InitialHeating = false;
-            Report("AC PID Activating",__FILE__,__LINE__,readValue,RpWarning,(HeaterCmd[index].targettemperatue-1000), 0);
+            Report("AC PID Activating",__FILE__,__LINE__,readValue,RpWarning,(HeaterCmd[index].targettemperatue), 0);
+////////////////////////
+            DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
+            HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary, 0);
+            HeatersControlStart();
+            AlarmHandlingSetAlarm(HeaterUnderEventType[index], false);
+            if (BlowerCfg.enabled == true)
+            {
+                Turn_the_Blower_On();//Turn on with the Default_Voltage
+                if (BlowerCfg.voltage)
+                    //Gradual_Increase_Blower(BlowerCfg.heatingvoltage,BlowerCfg.voltage);
+                    Control_Voltage_To_Blower(BlowerCfg.voltage);
+            }
+
 ////////////////////////
             HeaterReady[index] = true;
             Disable_Reading_Heaters_Current(HeaterId2CurrentId[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain]);
@@ -935,6 +953,7 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
             //        Report(logmsg[index],__FILE__,__LINE__,index,RpWarning,index,  Counter[index]);
             //        #warning PID is now only proportional (above)
 //             Report(ACheatstr,__FILE__,__LINE__,index,RpWarning,readValue,  HeaterPIDConfig[index].m_calculatedError);
+            //Report("AC PID",__FILE__,__LINE__,HeaterPIDConfig[index].m_calculatedError/100,RpWarning,readValue, index);
             HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain, (int)(HeaterPIDConfig[index].m_calculatedError/100));
         }
     }
@@ -974,13 +993,14 @@ uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
     if (HeaterCmd[index].targettemperatue == 0)
     {
         DeActivateHeater(index);
-        //LOG_ERROR (index, "unconfigured");
+        HeaterRecalculateHeaterParams(index, 0);
+        LOG_ERROR (index, "unconfigured");
         return ERROR;
     }
     if (abs(readValue - HeaterPreviousRead[index])>2000)
     {
         Report("DC Temperature Spike",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index);
-        if (readValue > HeaterCmd[index].targettemperatue)
+        //if (readValue > HeaterCmd[index].targettemperatue)
         {
             DeActivateHeater(index);
             HeaterRecalculateHeaterParams(index, 0);
@@ -991,6 +1011,7 @@ uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
     {
         Report("DC Temperature disaster",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index);
         DeActivateHeater (index);
+        HeaterRecalculateHeaterParams(index, 0);
         return ERROR;
     }
 
@@ -1017,6 +1038,7 @@ uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
 
         if ((readValue > (HeaterCmd[index].targettemperatue * DcHeatersLoweroperationLimit/1000))&&(readValue < (HeaterCmd[index].targettemperatue * DcHeatersUpperoperationLimit/1000)))//read value within 0.5 percent from target
         {
+            Report("DC PID Activating",__FILE__,index,readValue,RpWarning,(HeaterCmd[index].targettemperatue), 0);
             //DCInitialHeating[index] = false;
             HeatersControlStart();
             HeaterReady[index] = true;
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h b/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h
index 3d2bcf9ff..b47305d8c 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h
@@ -5,6 +5,9 @@
 #include "drivers/motors/motor.h"
 #include "ids_ex.h"
 
+#define LUBRICANT_DISPENSER 7
+#define CLEANER_DISPENSER 6
+
 extern int32_t CurrentDispenserSpeed[MAX_SYSTEM_DISPENSERS];
 extern uint32_t DispenserIdToMotorId[MAX_SYSTEM_DISPENSERS];
 extern float DispenserPressure[MAX_SYSTEM_DISPENSERS];
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
index 13142ad5f..ed9a3adb7 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
@@ -66,8 +66,15 @@ uint32_t IDS_Dispenser_Build_Pressure_Callback(uint32_t DispenserId, uint32_t Re
  {
     uint32_t status;
     DispenserPrepareTime[DispenserId]+=DispenserPrepareTimeLag;
+    double DispenserPressure = DispenserPreparePressure;
 
-     if ((GetDispenserPressure(DispenserId)>=DispenserPreparePressure)||(DispenserPrepareTime[DispenserId]>=DispenserPrepareTimeout))
+    if (DispenserId == LUBRICANT_DISPENSER)
+    {
+        DispenserPressure = DispenserPreparePressure/5;
+		//lubricant lower pressure buildup
+    }
+
+     if ((GetDispenserPressure(DispenserId)>=DispenserPressure)||(DispenserPrepareTime[DispenserId]>=DispenserPrepareTimeout))
      {
          if (DispenserPrepareTime[DispenserId]>=DispenserPrepareTimeout)
              status = ERROR;
@@ -249,6 +256,7 @@ void IDS_Dispenser_Content_Init (void)
 uint16_t seconds_counter = 0;
 uint32_t IDS_Dispenser_Store_Data (void)
 {
+    uint32_t timing =  msec_millisecondCounter;
     FRESULT Status = FR_OK;
     IDSDispenserData.n_dispenserinfo = MAX_SYSTEM_DISPENSERS;
     IDSDispenserData.dispenserinfo = dispenserdata;
@@ -263,6 +271,7 @@ uint32_t IDS_Dispenser_Store_Data (void)
     else
         return ERROR;
 
+    REPORT_MSG(msec_millisecondCounter - timing, "Updating dispensers file - time");
     return Status;
 }
 void IDS_Dispenser_Content_Calculation (char DispenserId)
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
index 5ebe10705..668ab9dcd 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
@@ -40,8 +40,6 @@ typedef struct
     PID_Config_Params   m_params;
 }DispenserControlConfig_t;
 HardwarePidControl *DispensersControl;// = (HardwarePidControl *)GENHWCFG_MAP_IN_FLASH + 0x4000;
-#define LUBRICANT_DISPENSER 7
-#define CLEANER_DISPENSER 6
 #define MAX_DYE_DISPENSERS 6
 int32_t DispenserSamples[MAX_SYSTEM_DISPENSERS][MAX_CONTROL_SAMPLES] = {0};
 int DispenserSamplePointer[MAX_SYSTEM_DISPENSERS] = {0};
@@ -197,7 +195,7 @@ JobDescriptionFileBrushStop *GetNextBrushStopFromJobFile();
 void FreeBrushStopFileData(JobDescriptionFileBrushStop *BrushStop);
 
  */
- /************************************************************************************************************************************/
+ /************************************************************************************************************************************
  uint32_t IDS_MapDispenserUsedinFileJobshort(void *JobDetails)
  {
      JobTicket* JobTicket = JobDetails;
@@ -206,6 +204,7 @@ void FreeBrushStopFileData(JobDescriptionFileBrushStop *BrushStop);
      int Dispenser_i, Brush_i,DispenserId;
      FRESULT Fresult = FR_OK;
      uint32_t status = OK;
+     bool lookForLubrication = false;
 
      for (Dispenser_i = 0;Dispenser_i<MAX_SYSTEM_DISPENSERS;Dispenser_i++)
      {
@@ -214,7 +213,10 @@ void FreeBrushStopFileData(JobDescriptionFileBrushStop *BrushStop);
      if (EnableCleaning == true)
          DispenserUsedInJob[CLEANER_DISPENSER] = true;
      if (JobTicket->enablelubrication == true)
+     {
          DispenserUsedInJob[LUBRICANT_DISPENSER] = true;
+         lookForLubrication = true;
+     }
 
      Fresult = OpenJobFile();
      if (Fresult == FR_OK)
@@ -238,12 +240,23 @@ void FreeBrushStopFileData(JobDescriptionFileBrushStop *BrushStop);
                                  if (BrushStop->dispensers[Dispenser_i]->nanolitterpersecond>0.0)
                                  {
                                      DispenserUsedInJob[DispenserId] = true;
-                                     /*if(DispenserId == LUBRICANT_DISPENSER)
+                                     if ((lookForLubrication == true)&&(DispenserId == LUBRICANT_DISPENSER))
                                      {
-                                        lubricant_speed = JobTicket->segments[0]->brushstops[0]->dispensers[Dispenser_i]->nanolitterpersecond/
-                                                         JobTicket->segments[0]->brushstops[0]->dispensers[Dispenser_i]->nanoliterperpulse;
-                                        REPORT_MSG (lubricant_speed*100, "LUBRICANT_SPEED*100");
-                                     }*/
+                                         lookForLubrication = false;
+                                         lubricant_speed = BrushStop->dispensers[Dispenser_i]->nanolitterpersecond/BrushStop->dispensers[Dispenser_i]->nanoliterperpulse;
+                                         if (BrushStop->dispensers[Dispenser_i]->dispenserstepdivision
+                                                 != DISPENSER_STEP_DIVISION__Auto)
+                                         {
+                                             //MotorSetMicroStep(HW_Motor_Id, Dispensers[Dispenser_i]->dispenserstepdivision);
+                                             lubricant_speed /=
+                                                     BrushStop->dispensers[Dispenser_i]->dispenserstepdivision; //the dye supply is calculated based on a 1/8 microstep
+                                         }
+                                         else
+                                         {
+                                             lubricant_speed/=8;//MotorsCfg[HW_Motor_Id].microstep;  //the dye supply is calculated based on a 1/8 microstep
+                                         }
+                                         REPORT_MSG (lubricant_speed*100, "LUBRICANT_SPEED*100");
+                                     }
                                  }
                              }//for dispenser
                          }//if dispensers
@@ -270,6 +283,7 @@ void FreeBrushStopFileData(JobDescriptionFileBrushStop *BrushStop);
      return status;
 
  }
+ *************************************************************************************************************************************/
  /************************************************************************************************************************************/
  uint32_t IDS_MapDispenserUsedinFileJob(void *JobDetails)
  {
@@ -282,7 +296,8 @@ void FreeBrushStopFileData(JobDescriptionFileBrushStop *BrushStop);
      uint32_t status = OK;
      FRESULT Fresult = FR_OK;
      FIL *FileHandle = 0;  //the system supports a single active file
-
+     bool lookForLubrication = false;
+     int brushCounter = 0;
 /*
  Parsing the job description file.
 The job description file simply contains an array of segments and their brush stops.
@@ -304,6 +319,7 @@ b.  Read brush stop message.
 c.  Go to step 2.a x Segment.BrushStopsCount.
 3.  Go to step 1 until end of file.
  */
+     GeneralHwReady = false;
      for (Dispenser_i = 0;Dispenser_i<MAX_SYSTEM_DISPENSERS;Dispenser_i++)
      {
          DispenserUsedInJob[Dispenser_i] = false;
@@ -312,7 +328,10 @@ c.  Go to step 2.a x Segment.BrushStopsCount.
      if (EnableCleaning == true)
          DispenserUsedInJob[CLEANER_DISPENSER] = true;
      if (JobTicket->enablelubrication == true)
+     {
          DispenserUsedInJob[LUBRICANT_DISPENSER] = true;
+         lookForLubrication = true;
+     }
      if (JobTicket->uploadstrategy == JOB_UPLOAD_STRATEGY__JobDescriptionFile)
      {
          FileHandle = my_malloc(sizeof(FIL));
@@ -337,7 +356,7 @@ c.  Go to step 2.a x Segment.BrushStopsCount.
                              Segment = job_description_file_segment__unpack(NULL, SegmentSize, SegmentPtr);
                              if ((Segment->has_brushstopscount)&&(Segment->brushstopscount))
                              {
-                                 REPORT_MSG (Segment->brushstopscount, "Segment->brushstopscount");
+                                 //REPORT_MSG (Segment->brushstopscount, "Segment->brushstopscount");
                                  for (Brush_i=0;Brush_i<Segment->brushstopscount;Brush_i++)
                                  {
                                      if (status == ERROR)
@@ -354,7 +373,13 @@ c.  Go to step 2.a x Segment.BrushStopsCount.
                                              {
                                                  readBytes += ImmediateRead;
                                                  BrushStop = job_description_file_brush_stop__unpack(NULL, BrushStopSize, BrushStopPtr);
-                                                 REPORT_MSG (BrushStopSize, "BrushStop");
+                                                 //REPORT_MSG (BrushStopSize, "BrushStop");
+                                                 if ((brushCounter % 100)==0)
+                                                 {
+                                                     SendJobProgress(0.0,0,false, "Processing file");
+                                                     Control_WD(ENABLE,55);  //activate heaters/dispenser watchdog, 0.5 seconds
+                                                 }
+                                                 brushCounter++;
                                                  if (BrushStop->n_dispensers)
                                                  {
                                                      for (Dispenser_i = 0;Dispenser_i < BrushStop->n_dispensers;Dispenser_i++)
@@ -365,6 +390,26 @@ c.  Go to step 2.a x Segment.BrushStopsCount.
                                                          {
                                                              DispenserUsedInJob[DispenserId] = true;
                                                          }
+                                                         if ((lookForLubrication == true)&&(DispenserId == LUBRICANT_DISPENSER))
+                                                         {
+                                                             lookForLubrication = false;
+                                                             lubricant_speed = BrushStop->dispensers[Dispenser_i]->nanolitterpersecond/BrushStop->dispensers[Dispenser_i]->nanoliterperpulse;
+                                                             REPORT_MSG (BrushStop->dispensers[Dispenser_i]->nanolitterpersecond*100, "LUBRICANT nl / sec");
+                                                             REPORT_MSG (BrushStop->dispensers[Dispenser_i]->nanoliterperpulse*100, "LUBRICANT nl / pulse");
+                                                             REPORT_MSG (BrushStop->dispensers[Dispenser_i]->dispenserstepdivision, "step division");
+                                                             if (BrushStop->dispensers[Dispenser_i]->dispenserstepdivision
+                                                                     != DISPENSER_STEP_DIVISION__Auto)
+                                                             {
+                                                                 //MotorSetMicroStep(HW_Motor_Id, Dispensers[Dispenser_i]->dispenserstepdivision);
+                                                                 lubricant_speed /=
+                                                                         BrushStop->dispensers[Dispenser_i]->dispenserstepdivision; //the dye supply is calculated based on a 1/8 microstep
+                                                             }
+                                                             else
+                                                             {
+                                                                 lubricant_speed/=8;//MotorsCfg[HW_Motor_Id].microstep;  //the dye supply is calculated based on a 1/8 microstep
+                                                             }
+                                                             REPORT_MSG (lubricant_speed*100, "LUBRICANT_SPEED*100");
+                                                         }
                                                      }//for dispenser
                                                  }//if dispensers
                                                  else
@@ -436,6 +481,7 @@ c.  Go to step 2.a x Segment.BrushStopsCount.
      if (BrushStop != NULL)
          job_description_file_brush_stop__free_unpacked (BrushStop,NULL);
      Fresult = f_close(FileHandle);
+     GeneralHwReady = true;
      REPORT_MSG (n_segments, "Finished checking the file");
      return status;
 
@@ -477,6 +523,17 @@ c.  Go to step 2.a x Segment.BrushStopsCount.
                                  {
                                     lubricant_speed = JobTicket->segments[0]->brushstops[0]->dispensers[Dispenser_i]->nanolitterpersecond/
                                                      JobTicket->segments[0]->brushstops[0]->dispensers[Dispenser_i]->nanoliterperpulse;
+                                    if (JobTicket->segments[0]->brushstops[0]->dispensers[Dispenser_i]->dispenserstepdivision
+                                            != DISPENSER_STEP_DIVISION__Auto)
+                                    {
+                                        //MotorSetMicroStep(HW_Motor_Id, Dispensers[Dispenser_i]->dispenserstepdivision);
+                                        lubricant_speed /=
+                                                JobTicket->segments[0]->brushstops[0]->dispensers[Dispenser_i]->dispenserstepdivision; //the dye supply is calculated based on a 1/8 microstep
+                                    }
+                                    else
+                                    {
+                                        lubricant_speed/=8;//MotorsCfg[HW_Motor_Id].microstep;  //the dye supply is calculated based on a 1/8 microstep
+                                    }
                                     REPORT_MSG (lubricant_speed*100, "LUBRICANT_SPEED*100");
                                  }
 
@@ -529,7 +586,7 @@ c.  Go to step 2.a x Segment.BrushStopsCount.
     //IDS_MapDispenserUsedinJob(JobDetails);
     for (i = 0; i < MAX_SYSTEM_DISPENSERS; i++)
     {
-        IDS_StopHomeDispenser(i);
+        //IDS_StopHomeDispenser(i);
         if (DispenserUsedInJob[i] == true) //we actually should check for all dispensers
         {
             DispenserReady[i] = false;
@@ -701,7 +758,7 @@ uint32_t IDS_Cleaning_Stop_Cleaning_Solution (callback_fptr callback);
                                    (int) segmentfirst_speed);
                          //REPORT_MSG(segmentfirst_speed,IdsMessage);
                          Report(IdsMessage, __FILE__, __LINE__, Dispenser_i, RpWarning,   segmentfirst_speed, 0);
-                         SendJobProgress(0.0, 0, false, IdsMessage);
+                         //SendJobProgress(0.0, 0, false, IdsMessage);
                      }
                  }
              }
@@ -862,8 +919,7 @@ void IDS_StartBrushStop(int n_dispensers,  JobDispenser** Dispensers)
             //(Speed*uStep*PPR)/((2*PI*Dispenser_Radius)
             segmentfirst_speed = Dispensers[Dispenser_i]->nanolitterpersecond
                     / Dispensers[Dispenser_i]->nanoliterperpulse;
-            if (Dispensers[Dispenser_i]->dispenserstepdivision
-                    != DISPENSER_STEP_DIVISION__Auto)
+            if (Dispensers[Dispenser_i]->dispenserstepdivision != DISPENSER_STEP_DIVISION__Auto)
             {
                 //MotorSetMicroStep(HW_Motor_Id, Dispensers[Dispenser_i]->dispenserstepdivision);
                 segmentfirst_speed /=
@@ -891,14 +947,14 @@ void IDS_StartBrushStop(int n_dispensers,  JobDispenser** Dispensers)
                 MotorSetSpeed(HW_Motor_Id, segmentfirst_speed);
                 CurrentDispenserSpeed[DispenserId] = segmentfirst_speed;
                 usnprintf(IdsMessage, 80,
-                          "Dispenser %d nl/sec %d nl/pulse %d speed %d",
+                          "Dispenser %d nl/sec %d nl/pulse %d speed %d steps %d/%d",
                           DispenserId,
                           (int) Dispensers[Dispenser_i]->nanolitterpersecond,
                           (int) Dispensers[Dispenser_i]->nanoliterperpulse,
-                          (int) segmentfirst_speed);
+                          (int) segmentfirst_speed,Dispensers[Dispenser_i]->dispenserstepdivision,MotorsCfg[HW_Motor_Id].microstep);
                 //REPORT_MSG(segmentfirst_speed,IdsMessage);
                 Report(IdsMessage, __FILE__, __LINE__, Dispenser_i, RpWarning,   segmentfirst_speed, 0);
-                SendJobProgress(0.0, 0, false, IdsMessage);
+                //SendJobProgress(0.0, 0, false, IdsMessage);
             }
             else
             {
@@ -1060,7 +1116,7 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId)
      //TimerMotors_t  HW_Motor_Id = DispenserIdToMotorId[deviceID];
      //REPORT_MSG(deviceID,"Dispenser End called");
      //MotorStop(HW_Motor_Id,Hard_Hiz);
-     IDS_HomeDispenser (deviceID, 800 , NULL);
+     //IDS_HomeDispenser (deviceID, 800 , NULL);
 
      return OK;
  }
@@ -1094,21 +1150,22 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId)
          }
 
      }
-
+	IDS_StopLubrication();
     return OK;
 }
 uint32_t IDS_StartLubrication(void)
 {
     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);
     return OK;
 }
 uint32_t IDS_StopLubrication(void)
 {
-    if(DispenserUsedInJob[LUBRICANT_DISPENSER])
-    {
-        IDS_Dispenser_Close_Valve_And_Stop_Motor(LUBRICANT_DISPENSER,IDS_Valve_EndValveReady);
-        Lubricant_2Way_Valve (STOP);
-    }
+    IDS_Dispenser_Close_Valve_And_Stop_Motor(LUBRICANT_DISPENSER,IDS_Valve_EndValveReady);
+    CurrentDispenserSpeed[LUBRICANT_DISPENSER] = 0;
+    REPORT_MSG (lubricant_speed, "IDS_StopLubrication");
+    Lubricant_2Way_Valve (STOP);
     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 d041b648e..c6f2526db 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
@@ -9,6 +9,10 @@
 #include "Drivers/USB_Communication/USBCDCD.h"
 #include "StateMachines/Initialization/PowerOffSequence.h"
 
+#include "drivers/Flash_Memory/FATFS/ff.h"
+#include "drivers/Flash_Memory/FATFS/Control_File_System.h"
+#include "drivers/adc_sampling/adc.h"
+
 //#include "graphics_adapter.h"
 
 void Stub_ProgressRequest(MessageContainer* requestContainer)
@@ -20,27 +24,49 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
     //writeLine("Progress Request...");
 
     ProgressResponse response = PROGRESS_RESPONSE__INIT;
-    response.has_progress = true;
-    PowerOffInit();
-    int i = 0;
-    for (i = 0; i < request->amount; i++)
-    {
-        response.progress = i;
-        responseContainer = createContainer(MESSAGE_TYPE__ProgressResponse, requestContainer->token, false, &response, &progress_response__pack, &progress_response__get_packed_size);
-        uint8_t* container_buffer = malloc(message_container__get_packed_size(&responseContainer));
-        size_t container_size = message_container__pack(&responseContainer, container_buffer);
-        free(responseContainer.data.data);
-        SendChars((char*)container_buffer, container_size);
-        //free(container_buffer);
 
-
-        int co = 0;
-        for (co = 0; co < request->delay; co++)
+    if((request->amount == 0xCF) && (request->delay == 0xCF)) //Create File System on the Drive
+    {
+        FRESULT iFResult = Init_Flash_File_System(true);
+        if(iFResult != FR_OK)
         {
-            __delay_cycles(1000000);
+            LOG_ERROR (iFResult, "Error during init Flash File System");
+            assert(iFResult);
         }
     }
+    else
+    if((request->amount == 0x0C) && (request->delay == 0x0C)) //Get Gas Sensor
+    {
+        response.progress = (double)Calculate_Gas_Power_Consumption();
+        response.has_progress = true;
+
+    }
+    else     if((request->amount == 0xDF) && (request->delay == 0xDF)) //Power off
+    {
+        PowerOffInit();
+    }
+    else
+    {
+        response.has_progress = true;
+        int i = 0;
+        for (i = 0; i < request->amount; i++)
+        {
+            response.progress = i;
+            responseContainer = createContainer(MESSAGE_TYPE__ProgressResponse, requestContainer->token, false, &response, &progress_response__pack, &progress_response__get_packed_size);
+            uint8_t* container_buffer = malloc(message_container__get_packed_size(&responseContainer));
+            size_t container_size = message_container__pack(&responseContainer, container_buffer);
+            free(responseContainer.data.data);
+            SendChars((char*)container_buffer, container_size);
+            //free(container_buffer);
 
+
+            int co = 0;
+            for (co = 0; co < request->delay; co++)
+            {
+                __delay_cycles(1000000);
+            }
+        }
+    }
     responseContainer = createContainer(MESSAGE_TYPE__ProgressResponse, requestContainer->token, true, &response, &progress_response__pack, &progress_response__get_packed_size);
     uint8_t* container_buffer = malloc(message_container__get_packed_size(&responseContainer));
     size_t container_size = message_container__pack(&responseContainer, container_buffer);
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread.h b/Software/Embedded_SW/Embedded/Modules/Thread/Thread.h
index 3e2a6aa40..97f3811c7 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread.h
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread.h
@@ -41,8 +41,8 @@ typedef struct
 }MotorControlConfig_t;
 
 
-#define MAX_THREAD_FEED_MOTORS WINDER_MOTOR+1
-#define MAX_SYSTEM_DANCERS HARDWARE_DANCER_TYPE__RightDancer+1
+#define MAX_THREAD_FEED_MOTORS (WINDER_MOTOR+1)
+#define MAX_SYSTEM_DANCERS (HARDWARE_DANCER_TYPE__RightDancer+1)
 
 extern TimerMotors_t ThreadMotorIdToMotorId[MAX_THREAD_MOTORS_NUM];
 extern HardwareDancerType ThreadMotorIdToDancerId[MAX_THREAD_MOTORS_NUM];
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
index 70f32ce6d..df88db3f9 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
@@ -54,6 +54,9 @@ uint32_t ScrewControlId = 0xFF;
 
 InternalWinderConfigStruc InternalWinderCfg = {0};
 
+uint32_t ScrewLocationLimitSwitch = 0,ScrewLocationStart = 0;
+uint32_t ScrewLocationRun[3];
+
 uint32_t Winder_Init(void)
 {
     ScrewTimerInterruptInit();
@@ -109,6 +112,10 @@ uint32_t Winder_Prepare(void)
         AlarmHandlingSetAlarm(EVENT_TYPE__WINDER_CONE_DOES_NOT_EXIST,true);
         return ERROR;
     }*/
+
+    ScrewLocationRun[0] = 0;
+    ScrewLocationRun[1] = 0;
+
     if (FPGA_Read_limit_Switches(GPI_LS_SCREW_RIGHT)==LIMIT)
     {
         //REPORT_MSG(LIMIT, "Winder_Prepare at limit");
@@ -136,6 +143,11 @@ uint32_t Winder_PrepareStage2(uint32_t deviceID, uint32_t ReadValue)
 
     //MotorSetMaxSpeed (HARDWARE_MOTOR_TYPE__MOTO_SCREW,InternalWinderCfg.segmentoffsetpulses);
     //REPORT_MSG(numOfSteps, "Winder_PrepareStage2");
+    //Read_Screw_Encoder();
+    //ScrewLocationLimitSwitch = Screw_RotEnc.Position;
+    //REPORT_MSG(ScrewLocationLimitSwitch, "Winder_PrepareStage2 Encoder Location");
+
+
     REPORT_MSG(millisecondCounter/*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].maxfrequency*/, "Winder_PrepareStage2");
     if (ReadValue != LIMIT)
     {
@@ -157,7 +169,13 @@ uint32_t Winder_ScrewAtOffsetCallback(uint32_t deviceID, uint32_t BusyFlag)
     //SetMotHome(HARDWARE_MOTOR_TYPE__MOTO_SCREW);  //set this point as the spool home
     //MotorSetMaxSpeed (HARDWARE_MOTOR_TYPE__MOTO_SCREW,temp_MaxFrequency);
 
+    //Read_Screw_Encoder();
+    //ScrewLocationStart = Screw_RotEnc.Position;
+
+    REPORT_MSG(ScrewLocationStart, "Winder_ScrewAtOffsetCallback Encoder Location");
+
     ScrewCurrentDirection = false;
+    ScrewLocationRun[ScrewCurrentDirection] = Screw_RotEnc.Position;
     ScrewSpeed = 0;
     ScrewControlId = 0xFF;
     ScrewNumberOfSteps = 0;
@@ -230,6 +248,10 @@ uint32_t Screw100msecDirectionChange(uint32_t deviceID, uint32_t BusyFlag)
 
     ScrewCurrentDirection = 1-ScrewCurrentDirection;
     CalculationDirectionChangeCounter++;
+    //REPORT_MSG(ScrewLocationRun[1] - ScrewLocationRun[0], "Screw Run NumberOfSteps");
+    //usnprintf(ScrewStr, 100, "Winder Encoder: 0 0x%x 1 0x%x diff %d ",ScrewLocationRun[0],ScrewLocationRun[1],abs(ScrewLocationRun[1] - ScrewLocationRun[0]));
+    //usnprintf(ScrewStr, 100, "Winder Encoder: 0 %d 1 %d diff %d ",ScrewLocationRun[0],ScrewLocationRun[1],ScrewLocationRun[1] - ScrewLocationRun[0]);
+    //Report(ScrewStr,__FILE__,__LINE__,ScrewLocationLimitSwitch,RpWarning,ScrewLocationStart, 0);
 
     if (ScrewCurrentDirection == 1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].directionthreadwize) //next time going out
     {
@@ -242,7 +264,7 @@ uint32_t Screw100msecDirectionChange(uint32_t deviceID, uint32_t BusyFlag)
         if ((CalculationDirectionChangeCounter/2)%InternalWinderCfg.spoolbackingrate == 0)
         {
             ScrewNumberOfSteps--;
-            //REPORT_MSG(ScrewNumberOfSteps, "Head Backing ScrewNumberOfSteps");
+            REPORT_MSG(ScrewNumberOfSteps, "Head Backing ScrewNumberOfSteps");
 
         }
     }
@@ -251,7 +273,7 @@ uint32_t Screw100msecDirectionChange(uint32_t deviceID, uint32_t BusyFlag)
         if ((CalculationDirectionChangeCounter/2)%InternalWinderCfg.SpoolBottomBackingRate == 0)
         {
             ScrewNumberOfSteps++;
-            //REPORT_MSG(ScrewNumberOfSteps, "Bottom Backing ScrewNumberOfSteps");
+            REPORT_MSG(ScrewNumberOfSteps, "Bottom Backing ScrewNumberOfSteps");
         }
     }
     if (WinderMotorSpeedRollOver)
@@ -288,7 +310,7 @@ uint32_t Screw100msecDirectionChange(uint32_t deviceID, uint32_t BusyFlag)
         //Report(TempScrewStr,__FILE__,__LINE__,0,RpWarning,0, 0);
         //Report(ScrewStr,__FILE__,__LINE__,ScrewCurrentDirection,RpWarning,CalculationDirectionChangeCounter, 0);
         //REPORT_MSG(temp , "new winder speed");
-//        Report("new winder speed",__FILE__,ScrewNumberOfSteps,temp,RpWarning,ScrewSpeed,0);
+        //Report("new winder speed",__FILE__,ScrewNumberOfSteps,temp,RpWarning,ScrewSpeed,0);
     }
 
     /********************************************************************************/
@@ -440,6 +462,9 @@ void ScrewTimerInterrupt(int ARG0)
     ROM_TimerIntClear(Screw_timerBase, TIMER_TIMA_TIMEOUT);  // Clear the timer interrupt
     ROM_IntMasterDisable();
 
+    //Read_Screw_Encoder();
+    //ScrewLocationRun[ScrewCurrentDirection] = Screw_RotEnc.Position;
+
     if (SCREW_TimerActivated == true)
     {
         ROM_TimerLoadSet(Screw_timerBase, TIMER_A,(int)ScrewRunningTime);
@@ -455,13 +480,7 @@ void ScrewTimerInterrupt(int ARG0)
     }
     ROM_IntMasterEnable();
     Rotations+=0.03;
-    /*random++;
-    if (random >= 2)
-        random = -1;*/
-    //Report("ScrewTimerInterrupt dir, duration, speed", __FILE__,ScrewCurrentDirection,ScrewRunningTime, RpMessage, ScrewSpeed, 0);
-    //
-    // Enable all interrupts.
-    //
+
     return ;
 
 }
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h
index d7ce917c0..91eedeb6b 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h
@@ -9,7 +9,7 @@
 #define WINDER_DANCER HARDWARE_DANCER_TYPE__LeftDancer
 #define POOLER_DANCER HARDWARE_DANCER_TYPE__MiddleDancer
 #define FEEDER_DANCER HARDWARE_DANCER_TYPE__RightDancer
-#define NUM_OF_DANCERS HARDWARE_DANCER_TYPE__RightDancer+1
+#define NUM_OF_DANCERS (HARDWARE_DANCER_TYPE__RightDancer+1)
 //} DANCER_ENUM;
 typedef enum threadMotorsEnum
 {
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
index a4208ad25..c292f7dcd 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
@@ -842,8 +842,8 @@ char Endstr[150];
      Report(Endstr,__FILE__,__LINE__,(int)TotalProcessedLength,RpWarning,(int)PoolerTotalProcessedLength,0);
 
      ThreadUpdateProcessLength (0.0,(void *)NULL);
-     TotalProcessedLength = 0.0;
-    SetOriginMotorSpeed(0);
+     //TotalProcessedLength = 0.0;
+     SetOriginMotorSpeed(0);
 #ifdef HUNDRED_MICROSECONDS_DANCER_READ
      MillisecLogClose();
 #endif