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

16 files changed, 318 insertions, 120 deletions

diff --git a/Software/Embedded_SW/Embedded/Common/SWUpdate/FileSystem.c b/Software/Embedded_SW/Embedded/Common/SWUpdate/FileSystem.c
index 84d8fa725..1b53a826b 100644
--- a/Software/Embedded_SW/Embedded/Common/SWUpdate/FileSystem.c
+++ b/Software/Embedded_SW/Embedded/Common/SWUpdate/FileSystem.c
@@ -35,6 +35,7 @@
 #include "drivers/Flash_Memory/fatfs/ff.h"
 #include "drivers/FPGA/FPGA_GPIO/FPGA_GPIO.h"
 
+#include "Modules/Control/Control.h"
 #include "StateMachines/Printing/PrintingSTM.h"
 
 
@@ -152,6 +153,20 @@ uint32_t    FileUploadRequestFunc(MessageContainer* requestContainer)
     return OK;
 }
 FRESULT lFresult = FR_OK;
+uint32_t Chunk_ControlId = 0xFF;
+uint32_t FileChunkUploadCallBackFunction(uint32_t IfIndex, uint32_t BusyFlag)
+{
+    Report("chunk timeout error",__FILE__,IfIndex,FileReceivedLength,RpWarning,BusyFlag,0);
+    f_close(UploadFileHandle);
+    my_free (UploadFileHandle);
+    UploadFileHandle = 0;
+    FileReceivedLength = 0;
+    FileDone = true;
+    if (SafeRemoveControlCallback(Chunk_ControlId, FileChunkUploadCallBackFunction )==OK)
+        Chunk_ControlId = 0xFF;
+
+}
+
 uint32_t    FileChunkUploadRequestFunc(MessageContainer* requestContainer)
 {
     //uint32_t status = OK;
@@ -177,13 +192,15 @@ uint32_t    FileChunkUploadRequestFunc(MessageContainer* requestContainer)
     if (ReceivedFileHandle==NULL)
     {
         Fresult = FR_DENIED;
-        Report("file chunk uplad rejected - file not created", __FILE__, __LINE__, 4, RpWarning,   (int)0, 0);
+        Report("file chunk upload rejected - file not created", __FILE__, __LINE__, 4, RpWarning,   (int)0, 0);
         FileDone = true;
     }
     else
     {
         KeepAliveOneSecondCounter = 0;
         save_milisec = msec_millisecondCounter;
+        Chunk_ControlId = AddControlCallback("chunk", FileChunkUploadCallBackFunction, eOneSecond, TemplateDataReadCBFunction,0,request->buffer.len, WrittenBytes );
+
         Fresult = f_write(ReceivedFileHandle,request->buffer.data,request->buffer.len,&WrittenBytes );
         lFresult = Fresult;
         if(Fresult != FR_OK)
@@ -195,6 +212,8 @@ uint32_t    FileChunkUploadRequestFunc(MessageContainer* requestContainer)
         {
             FileReceivedLength += WrittenBytes;
             ReportWithPackageFilter(CommFilter,"Chunk received", __FILE__,FileLength,FileReceivedLength, RpMessage,msec_millisecondCounter-save_milisec, 0);
+            RemoveControlCallback(Chunk_ControlId, FileChunkUploadCallBackFunction );
+            Chunk_ControlId = 0xFF;
 
             //REPORT_MSG (FileReceivedLength,"file upload chunk");
             if (FileReceivedLength == FileLength)
diff --git a/Software/Embedded_SW/Embedded/Drivers/ADC_Sampling/ADC.c b/Software/Embedded_SW/Embedded/Drivers/ADC_Sampling/ADC.c
index f495758ec..627ad45b9 100644
--- a/Software/Embedded_SW/Embedded/Drivers/ADC_Sampling/ADC.c
+++ b/Software/Embedded_SW/Embedded/Drivers/ADC_Sampling/ADC.c
@@ -349,7 +349,7 @@ void ADCAcquireInit(void) // (called by MillisecInit)
     ADCReferenceSet(ADC0_BASE, ADC_REF_EXT_3V);
     ADCReferenceSet(ADC1_BASE, ADC_REF_EXT_3V);
 
-    VOCAlarmsInit();
+    //VOCAlarmsInit();
     if (!isInitialized)
     {
         // Create a periodic Clock Instance with _period - triggers the ADC sampling
@@ -391,7 +391,7 @@ void ADCAcquireStart(ProcessCallback _callback, uint32_t _period) // (called by
     MAP_ADCIntClear(ADC1_BASE, 0);
     MAP_ADCIntEnable(ADC0_BASE, 0);
     MAP_ADCIntEnable(ADC0_BASE, 1);
-    ROM_IntEnable(INT_ADC0SS0);
+    //ROM_IntEnable(INT_ADC0SS0);
 
     // Store process
     processCallBack = _callback;
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/EEPROM/Head_EEPROM.c b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/EEPROM/Head_EEPROM.c
index d55e1f617..fa584a683 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/EEPROM/Head_EEPROM.c
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/EEPROM/Head_EEPROM.c
@@ -7,6 +7,7 @@
 #include "include.h"
 #include "Head_EEPROM.h"
 #include <Drivers/I2C_Communication/I2C.h>
+#include "PMR/Diagnostics/EventType.pb-c.h"
 #include "../I2C_Head_Mux.h"
 #include "driverlib/i2c.h"
 
@@ -116,8 +117,13 @@ uint32_t Check_Head_Type_Via_EEPROM()
     status |= I2C_Read(I2C_ID_HEAD_CARD, I2C_HEAD_EEPROM_SLAVE_ADD + 1, Read_Buf, 2);
 
 #ifndef EVALUATION_BOARD
+    if (status == 0xFF)
+    {
+        ACTIVITY_RED_LED_ON;
+        AlarmHandlingSetAlarm(EVENT_TYPE__POWER_UP_BIT_FAILURE, true);
+    }
 
-    if(Head_i2c_status == I2C_MASTER_ERR_ADDR_ACK)
+    if((Head_i2c_status == I2C_MASTER_ERR_ADDR_ACK)||(status == 0xFF))
     {
         Head_Type = HEAD_TYPE_SYLKO_WITHOUT_CARD;
     }
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/WHS_Card/D_Max5805_ADC_Blower/WHS_Blower.c b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/WHS_Card/D_Max5805_ADC_Blower/WHS_Blower.c
index 3341557c6..4dc30752d 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/WHS_Card/D_Max5805_ADC_Blower/WHS_Blower.c
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/WHS_Card/D_Max5805_ADC_Blower/WHS_Blower.c
@@ -222,6 +222,7 @@ double WHS_Blower_Avarege(WHS_Flow_Meter ORF_id)
     Q_temp = get_Q(ORF_id);
     if (fabs(Q_temp - average_Q) > 1.75)
     {
+        Report("------------ set_new_Q_average :-----------------", __FILE__,__LINE__, (int)(Q_temp*100), RpMessage, (int)(average_Q*100), 0);
         set_new_Q_average(ORF_id, Q_temp);
         average_Q = Q_temp;
     }
@@ -256,13 +257,15 @@ void set_new_Q_average(WHS_Flow_Meter ORF_id,double Q_temp)
             break;
     }
 }
-
+//char whs_str[150];
 double calc_Q_average(WHS_Flow_Meter ORF_id,double Q_temp)
 {
     static uint8_t i_head = 0 ;
     static uint8_t i_drier = 0 ;
     double sum_orifice_Q = 0.0;
     double Q_average = 0.0;
+	//double Q_sum = 0.0,t_avg;
+    //int ii;
 
     switch (ORF_id)
     {
@@ -280,6 +283,17 @@ double calc_Q_average(WHS_Flow_Meter ORF_id,double Q_temp)
             sum_orifice_Q += average_orf1_Q_buff[i_head];
             average_Q_orifice1 = sum_orifice_Q /ORF_BUFF_SIZE;
             Q_average = average_Q_orifice1;
+            /*if (i_head == 0)
+            {
+                for (ii = 0; ii<ORF_BUFF_SIZE;ii++)
+                {
+                    Q_sum+=average_orf1_Q_buff[ii];
+                }
+                t_avg = Q_sum/ORF_BUFF_SIZE;
+                usnprintf(whs_str, 150, "whs average shai's sum %d avg %d my sum %d avg %d",(int)(sum_orifice_Q*100),(int)(Q_average*100),(int)(Q_sum*100),(int)(t_avg*100));
+                Report(whs_str, __FILE__,__LINE__, (int)(Q_temp*100), RpMessage, (int)(Q_average*100), 0);
+
+            }*/
            break;
         case DRIER_FLOW_METER:
             if (i_drier == ORF_BUFF_SIZE)
@@ -423,14 +437,14 @@ bool WHS_Set_Blower_Control_Closed_Loop(double Q_value)
                     /* increase blower voltage by small step: */
                     ReportWithPackageFilter(WasteFilter,"------------ increase blower voltage by 10:-----------------", __FILE__,__LINE__, volt, RpMessage, STEP_10, 0);
                     SendLimitedBlowerControl(volt + STEP_10);
-                    close_loop_time = 10;
+                    close_loop_time = 4;
                 }
                 else
                 {
                     /* increase blower voltage by small step: */
                     ReportWithPackageFilter(WasteFilter,"------------ increase blower voltage by 1:-----------------", __FILE__,__LINE__, volt, RpMessage, STEP_1, 0);
                     SendLimitedBlowerControl(volt + STEP_1);
-                    close_loop_time = 5;
+                    close_loop_time = 2;
                 }
             }
         }
@@ -450,14 +464,14 @@ bool WHS_Set_Blower_Control_Closed_Loop(double Q_value)
                     /* decrease blower voltage by small step: */
                     ReportWithPackageFilter(WasteFilter,"------------ decrease blower voltage by 10:-----------------", __FILE__,__LINE__, volt, RpMessage, STEP_10, 0);
                     SendLimitedBlowerControl(volt - STEP_10);
-                    close_loop_time = 10;
+                    close_loop_time = 4;
                 }
                 else
                 {
                     /* decrease blower voltage by small step: */
                     ReportWithPackageFilter(WasteFilter,"------------ decrease blower voltage by 1:-----------------", __FILE__,__LINE__, volt, RpMessage, STEP_1, 0);
                     SendLimitedBlowerControl(volt - STEP_1);
-                    close_loop_time = 5;
+                    close_loop_time = 2;
                 }
             }
         }
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/WHS_Card/EEPROM/WHS_EEPROM.c b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/WHS_Card/EEPROM/WHS_EEPROM.c
index 86a88197c..4e889f58c 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/WHS_Card/EEPROM/WHS_EEPROM.c
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/WHS_Card/EEPROM/WHS_EEPROM.c
@@ -16,6 +16,8 @@
 #include "PMR/stubs/StubWhsEEpromData.pb-c.h"
 #include "PMR/stubs/StubWhsEEpromRequest.pb-c.h"
 #include "PMR/stubs/StubWhsEEpromResponse.pb-c.h"
+#include "PMR/Diagnostics/EventType.pb-c.h"
+
 
 //EEPROM M24M01-DFMN6TP
 //uint32_t I2C_WHS_EEPROM_SLAVE_ADD = 0xA0;
@@ -95,6 +97,12 @@ uint32_t Check_WHS_Type_Via_EEPROM()
     Select_Main_WHS_Mux_Channel();
     status = WHS_I2C_EEprom_Write_Byte(WHS_TYPE_ADDR, &data);
 
+    if (status == 0xFF)
+    {
+        ACTIVITY_RED_LED_ON;
+        ACTIVITY_GREEN_LED_ON;
+        AlarmHandlingSetAlarm(EVENT_TYPE__POWER_UP_BIT_FAILURE, true);
+    }
 
     if (status)
     //if(I2CMasterErr(I2C_ID_WHS_CARD) == I2C_MASTER_ERR_NONE)
diff --git a/Software/Embedded_SW/Embedded/Embedded.cfg b/Software/Embedded_SW/Embedded/Embedded.cfg
index fe3d71979..666d9f9b3 100644
--- a/Software/Embedded_SW/Embedded/Embedded.cfg
+++ b/Software/Embedded_SW/Embedded/Embedded.cfg
@@ -26,9 +26,10 @@ BIOS.heapSize = 60000;   // bios heapmem
 
 Clock.timerId = 7;
 
-var hwi0Params = new Hwi.Params();
-hwi0Params.instance.name = "adcHwi";
-Program.global.adcHwi = Hwi.create(30, "&ADC0SS0Handler", hwi0Params);
+//var hwi0Params = new Hwi.Params();
+//hwi0Params.instance.name = "adcHwi";
+//Program.global.adcHwi = Hwi.create(30, "&ADC0SS0Handler", hwi0Params);
+
 var hwi1Params = new Hwi.Params();
 hwi1Params.instance.name = "sysTick";
 Program.global.sysTick = Hwi.create(15, "&SysTickHandler", hwi1Params);
diff --git a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
index d334c9001..a6380c188 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
+++ b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
@@ -570,6 +570,10 @@ float MillisecGetPressures (int SensorId)
     return PressureCalc[SensorId];
 }
 
+bool getRapidPressureRead(void)
+{
+    return RapidPressureRead;
+}
 void setRapidPressureRead(bool value)
 {
     RapidPressureRead = value;
@@ -626,6 +630,10 @@ uint32_t MillisecLowLoop(uint32_t tick)
         Trigger_HeaterWriting();
 
     }
+    if (m20msecTick)
+    {
+        ADC0SS0Handler();
+    }
     if(Fifty_msTick)
     {
         WHS_Read_GPI_Registers();
diff --git a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.h b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.h
index 9335a6d08..226d0d57a 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.h
+++ b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.h
@@ -36,6 +36,7 @@ uint8_t getGasReading(void);
 int MillisecGetTemperatures (TEMPERATURE_SENSOR_ID_ENUM SensorId);
 float MillisecGetPressures (int SensorId);
 void setRapidPressureRead(bool value);
+bool getRapidPressureRead(void);
 
 
 void MillisecInit(void);
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
index 3f9811636..2ff1588f2 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
@@ -781,6 +781,9 @@ void DiagnosticOneSecCollection(void)
         DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone10, MillisecGetTemperatures(HEAD_PT100_ZONE_10_0X88_1));
         DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone11, MillisecGetTemperatures(HEAD_PT100_ZONE_11_0X8A_0));
         DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone12, MillisecGetTemperatures(HEAD_PT100_ZONE_12_0X8A_1));
+
+        DiagnosticLoadTemperature(HEATER_TYPE__HeadCoverHeater1, MillisecGetTemperatures(HEAD_PT100_AIR_HEATER_2_0X8C_1));
+        DiagnosticLoadTemperature(HEATER_TYPE__HeadCoverHeater2, MillisecGetTemperatures(HEAD_PT100_AIR_HEATER_1_0X8C_0));
     }
     if (Head_Type == HEAD_TYPE_STAPLE_SPUN)
     {
@@ -790,6 +793,8 @@ void DiagnosticOneSecCollection(void)
         DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone3, MillisecGetTemperatures(HEAD_PT100_ZONE_3_0X82_0));
         DiagnosticLoadTemperature(HEATER_TYPE__HeadCoverHeater1, MillisecGetTemperatures(HEAD_PT100_AIR_HEATER_2_0X8C_1));
         DiagnosticLoadTemperature(HEATER_TYPE__HeadCoverHeater2, MillisecGetTemperatures(HEAD_PT100_AIR_HEATER_1_0X8C_0));
+        DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone4, MillisecGetTemperatures(HEAD_PT100_ZONE_4_0X82_1));
+        DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone6, MillisecGetTemperatures(HEAD_PT100_ZONE_6_0X84_1));
     }
     DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DRYER_TEMP1));
     DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DRYER_TEMP2));
@@ -797,16 +802,31 @@ void DiagnosticOneSecCollection(void)
     for (i=0;i<MAX_SYSTEM_DISPENSERS;i++)
     {
         dispensermotorfrequency[i][0] = IdsGetMotorSpeed(i);
-        /*if ((i == 1)&&(JobIsActive()))
-           {
-            Report("Dispenser 1",__FILE__,(int)__LINE__,(int)dispensermotorfrequency[i][DiagnosticsIndex],RpWarning,(int)DiagnosticsIndex,0);
-           }*/
-        //dispensermotorfrequency[i][DiagnosticsIndex] = IDS_Dispenser_Data[i].consumedinnanolitter;
-
         if (DiagnosticMode < Diagnostic_Extended_Mode)
             dispenserspressure[i][0] = GetDispenserPressure(i); //Read_MidTank_Pressure_Sensor
         MidTankpressure[i][0] = Get_MidTank_Pressure_Sensor(i);
     }
+    if (DiagnosticMode < Diagnostic_Extended_Mode)
+    {
+        DiagnosticsMonitor.n_dispenser1pressure = 1;
+        DiagnosticsMonitor.dispenser1pressure = dispenserspressure[0];
+        DiagnosticsMonitor.n_dispenser2pressure = 1;
+        DiagnosticsMonitor.dispenser2pressure = dispenserspressure[1];
+        DiagnosticsMonitor.n_dispenser3pressure = 1;
+        DiagnosticsMonitor.dispenser3pressure = dispenserspressure[2];
+        DiagnosticsMonitor.n_dispenser4pressure = 1;
+        DiagnosticsMonitor.dispenser4pressure = dispenserspressure[3];
+        DiagnosticsMonitor.n_dispenser5pressure = 1;
+        DiagnosticsMonitor.dispenser5pressure = dispenserspressure[4];
+        DiagnosticsMonitor.n_dispenser6pressure = 1;
+        DiagnosticsMonitor.dispenser6pressure = dispenserspressure[5];
+        DiagnosticsMonitor.n_dispenser7pressure = 1;
+        DiagnosticsMonitor.dispenser7pressure = dispenserspressure[6];
+        DiagnosticsMonitor.n_dispenser8pressure = 1;
+        DiagnosticsMonitor.dispenser8pressure = dispenserspressure[7];
+
+    }
+
 }
 void Diagnostic100msecCollection(void)
 {
@@ -977,14 +997,23 @@ void SendDiagnostics(void)
         DiagnosticsMonitor.n_headzone10temperature = HeaterCounterIndex[HEATER_TYPE__HeaterZone10];
         DiagnosticsMonitor.n_headzone11temperature = HeaterCounterIndex[HEATER_TYPE__HeaterZone11];
         DiagnosticsMonitor.n_headzone12temperature = HeaterCounterIndex[HEATER_TYPE__HeaterZone12];
+//temporary
+        DiagnosticsMonitor.headcoverheater1temperature = HeaterTemperature[HEATER_TYPE__HeadCoverHeater1];
+        DiagnosticsMonitor.headcoverheater2temperature = HeaterTemperature[HEATER_TYPE__HeadCoverHeater2];
+        DiagnosticsMonitor.n_headcoverheater1temperature = HeaterCounterIndex[HEATER_TYPE__HeadCoverHeater1];
+        DiagnosticsMonitor.n_headcoverheater2temperature = HeaterCounterIndex[HEATER_TYPE__HeadCoverHeater2];
     }
-    if ((Head_Type == HEAD_TYPE_SYLKO)||(Head_Type == HEAD_TYPE_STAPLE_SPUN))
-//    if (Head_Type == HEAD_TYPE_STAPLE_SPUN)
+    //if ((Head_Type == HEAD_TYPE_SYLKO)||(Head_Type == HEAD_TYPE_STAPLE_SPUN))
+    if (Head_Type == HEAD_TYPE_STAPLE_SPUN)
     {
         DiagnosticsMonitor.headcoverheater1temperature = HeaterTemperature[HEATER_TYPE__HeadCoverHeater1];
         DiagnosticsMonitor.headcoverheater2temperature = HeaterTemperature[HEATER_TYPE__HeadCoverHeater2];
         DiagnosticsMonitor.n_headcoverheater1temperature = HeaterCounterIndex[HEATER_TYPE__HeadCoverHeater1];
         DiagnosticsMonitor.n_headcoverheater2temperature = HeaterCounterIndex[HEATER_TYPE__HeadCoverHeater2];
+        DiagnosticsMonitor.headzone4temperature = HeaterTemperature[HEATER_TYPE__HeaterZone4];
+        DiagnosticsMonitor.headzone6temperature = HeaterTemperature[HEATER_TYPE__HeaterZone6];
+        DiagnosticsMonitor.n_headzone4temperature = HeaterCounterIndex[HEATER_TYPE__HeaterZone4];
+        DiagnosticsMonitor.n_headzone6temperature = HeaterCounterIndex[HEATER_TYPE__HeaterZone6];
     }
     DiagnosticsMonitor.dryerzone1temperature = HeaterTemperature[HEATER_TYPE__DryerAirHeater];
     DiagnosticsMonitor.dryerzone2temperature = HeaterTemperature[HEATER_TYPE__DryerMainHeater];
@@ -1036,22 +1065,26 @@ void SendDiagnostics(void)
     DiagnosticsMonitor.n_dispenserslinearpositions = 0;
     DiagnosticsMonitor.n_dispensersangularencoders = 0;
 
-    DiagnosticsMonitor.n_dispenser1pressure = temp;
-    DiagnosticsMonitor.dispenser1pressure = dispenserspressure[0];
-    DiagnosticsMonitor.n_dispenser2pressure = temp;
-    DiagnosticsMonitor.dispenser2pressure = dispenserspressure[1];
-    DiagnosticsMonitor.n_dispenser3pressure = temp;
-    DiagnosticsMonitor.dispenser3pressure = dispenserspressure[2];
-    DiagnosticsMonitor.n_dispenser4pressure = temp;
-    DiagnosticsMonitor.dispenser4pressure = dispenserspressure[3];
-    DiagnosticsMonitor.n_dispenser5pressure = temp;
-    DiagnosticsMonitor.dispenser5pressure = dispenserspressure[4];
-    DiagnosticsMonitor.n_dispenser6pressure = temp;
-    DiagnosticsMonitor.dispenser6pressure = dispenserspressure[5];
-    DiagnosticsMonitor.n_dispenser7pressure = temp;
-    DiagnosticsMonitor.dispenser7pressure = dispenserspressure[6];
-    DiagnosticsMonitor.n_dispenser8pressure = temp;
-    DiagnosticsMonitor.dispenser8pressure = dispenserspressure[7];
+    if (DiagnosticMode >= Diagnostic_Extended_Mode)
+    {
+        DiagnosticsMonitor.n_dispenser1pressure = temp;
+        DiagnosticsMonitor.dispenser1pressure = dispenserspressure[0];
+        DiagnosticsMonitor.n_dispenser2pressure = temp;
+        DiagnosticsMonitor.dispenser2pressure = dispenserspressure[1];
+        DiagnosticsMonitor.n_dispenser3pressure = temp;
+        DiagnosticsMonitor.dispenser3pressure = dispenserspressure[2];
+        DiagnosticsMonitor.n_dispenser4pressure = temp;
+        DiagnosticsMonitor.dispenser4pressure = dispenserspressure[3];
+        DiagnosticsMonitor.n_dispenser5pressure = temp;
+        DiagnosticsMonitor.dispenser5pressure = dispenserspressure[4];
+        DiagnosticsMonitor.n_dispenser6pressure = temp;
+        DiagnosticsMonitor.dispenser6pressure = dispenserspressure[5];
+        DiagnosticsMonitor.n_dispenser7pressure = temp;
+        DiagnosticsMonitor.dispenser7pressure = dispenserspressure[6];
+        DiagnosticsMonitor.n_dispenser8pressure = temp;
+        DiagnosticsMonitor.dispenser8pressure = dispenserspressure[7];
+
+    }
 
 
     DiagnosticsMonitor.n_midtank1level = 1;
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c
index d81ab7abb..3b010247d 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c
@@ -30,6 +30,7 @@
 #include "drivers/Valves/Valve.h"
 #include "Drivers/I2C_Communication/DAC/blower.h"
 #include "drivers/Flash_ram/MCU_E2Prom.h"
+#include <Drivers/SSI_Comm/Dancer/Dancer.h>
 
 #include "ids/ids_ex.h"
 #include "General/process.h"
@@ -40,6 +41,9 @@ char HomingToken[NUM_OF_MOTORS][36+1]={0};
 int HomingCounter[NUM_OF_MOTORS];
 uint32_t HomingControlId[NUM_OF_MOTORS];
 
+uint32_t Diagnostics_Dryer_UnLoading(void);
+uint32_t Diagnostics_Dryer_Loading(void);
+
 /********************************************************************************
  * Motor Homing
  ********************************************************************************/
@@ -119,61 +123,9 @@ uint32_t D_numberOfSteps = 0;
 float D_numberOfCycles = 0;
 double D_DrierPrevLocation = 0;
 
-uint32_t Diagnostics_Set_Load_Arm_To_Stopper_Callback(uint32_t deviceID, uint32_t BusyFlag)
-{
-    Report("Diagnostics_Set_Load_Arm_To_Stopper_Callback",__FILE__,__LINE__,D_numberOfCycles,RpMessage,0,0);
-    //storeLoadArmParameters();
-
-    SetMotHome(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM);  //set this point as the spool home
-    if (HomingControlId[deviceID] != 0xff)
-    {
-        Report("MotorHomingProgressReport stopped",__FILE__,__LINE__,deviceID,RpMessage,HomingCounter[deviceID],0);
-        RemoveControlCallback(HomingControlId[deviceID],MotorHomingProgressReport);
-        HomingControlId[deviceID] = 0xff;
-    }
-    return OK;
-}
-
-uint32_t Diagnostics_Dryer_UnLoading_Callback(uint32_t MotorId, uint32_t ReadValue)
-{
-    D_numberOfCycles++;
-    uint32_t temp = Read_Dryer_ENC_Position();
-    Report("Thread_Load_Dryer_UnLoading_Callback",__FILE__,ReadValue,temp,RpMessage,D_DrierPrevLocation,0);
-    //Report("Thread_Load_Dryer_UnLoading_Callback details",__FILE__,(int)(TotalLoadedLen),D_numberOfCycles,RpMessage,CallbackCounter,0);
-    if ((abs (temp -D_DrierPrevLocation)>1000  )&&(ReadValue == NOTBUSY)) // OK - take another round
-    {
-        D_DrierPrevLocation = temp;
-        Report("Thread_Load_Dryer_UnLoading cycles",__FILE__,D_numberOfCycles,LoadArmRounds,RpMessage,0,0);
-        if (D_numberOfCycles<LoadArmRounds)
-        {
-            MotorMoveWithCallback (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, 1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize,
-                                   D_numberOfSteps,    Diagnostics_Dryer_UnLoading_Callback, 10000);
-        }
-        else //done enough cycles, go to the center point
-        {
-            MotorMovetoEncoderPosition(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM,Diagnostics_Set_Load_Arm_To_Stopper_Callback,30000);
-            MCU_E2PromProgram(EEPROM_STORAGE_DRYER_CYCLES,LoadArmRounds-D_numberOfCycles);
-            Report("Store Number of cycles in drier",__FILE__,__LINE__,D_numberOfCycles,RpMessage,LoadArmRounds,0);
-        }
-    }
-    else  //timeout or no movement
-    {
-        Report("Store Number of cycles in drier - halted",__FILE__,__LINE__,D_numberOfCycles,RpMessage,LoadArmRounds,0);
-        MCU_E2PromProgram(EEPROM_STORAGE_DRYER_CYCLES,LoadArmRounds-(D_numberOfCycles-2));//it takes two cycles to identify a stop of the arm
-        Report("Drier unloading timeout(1) or no movement",__FILE__,temp,D_DrierPrevLocation,RpWarning,ReadValue,0);
-        if (HomingControlId[MotorId] != 0xff)
-        {
-            Report("MotorHomingProgressReport stopped",__FILE__,__LINE__,MotorId,RpMessage,HomingCounter[MotorId],0);
-            RemoveControlCallback(HomingControlId[MotorId],MotorHomingProgressReport);
-            HomingControlId[MotorId] = 0xff;
-        }
-    }
-    return OK;
-}
 
 uint32_t MotorHomingRequestFunc(MessageContainer* requestContainer)
 {
-    //uint32_t numberOfSteps = 0;
     uint32_t status = FAILED;
     MessageContainer responseContainer;
 
@@ -215,16 +167,7 @@ uint32_t MotorHomingRequestFunc(MessageContainer* requestContainer)
                 {
                     if(MotorId == HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM)
                     {
-                        D_numberOfSteps = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround*LoadArmRounds*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].microstep*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulleyradius;
-                        Report("MotorHomingRequestFunc Set_Load_Arm_To_Start_Position",__FILE__,__LINE__,D_numberOfSteps,RpMessage,LoadArmRounds,0);
-                        //MotorMoveToStopper(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, (1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize),
-                        //                                MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround/2, MotorHomingRequestCallback,0,1000);
-                        MotorMoveWithCallback (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, 1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize,
-                                               D_numberOfSteps-800,    Diagnostics_Dryer_UnLoading_Callback, 10000);
-                        D_numberOfCycles = 0;
-
-                        //MotorMoveWithCallback(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, (1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize),
-                        //                                D_numberOfSteps, MotorHomingRequestCallback,1000);
+                        Diagnostics_Dryer_UnLoading();
                         status = OK;
                     }
                     if ( Motor_Id_to_LS_IdDown[MotorId] != MAX_GPI)
@@ -265,18 +208,7 @@ uint32_t MotorHomingRequestFunc(MessageContainer* requestContainer)
                 {
                     if(MotorId == HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM)
                     {
-                        if (LoadArmRounds <= 2)
-                                LoadArmRounds = 30;
-
-                        D_numberOfSteps = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround*LoadArmRounds*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].microstep*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulleyradius;
-                        D_numberOfSteps -= 100;
-                        D_numberOfCycles = LoadArmRounds;
-                        Report("MotorHomingRequestFunc Set_Load_Arm_To_Start_Position",__FILE__,__LINE__,D_numberOfSteps,RpMessage,LoadArmRounds,0);
-
-                        MotorSetMaxSpeed (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround/4);
-
-                        MotorMoveWithCallback (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize,
-                                               D_numberOfSteps,    MotorHomingRequestCallback, 100000);
+                        Diagnostics_Dryer_Loading();
                         status = OK;
                     }
                     if ( Motor_Id_to_LS_IdUp[MotorId] != MAX_GPI)
@@ -486,4 +418,128 @@ uint32_t DispenserAbortHomingRequestFunc(MessageContainer* requestContainer)
 
 return OK;
 }
+uint32_t Diagnostics_Set_Load_Arm_To_Stopper_Callback(uint32_t deviceID, uint32_t BusyFlag)
+{
+
+    Report("Diagnostics_Set_Load_Arm_To_Stopper time",__FILE__,__LINE__,msec_millisecondCounter,RpMessage,0,0);
+
+    //NumberOfDrierLoaderCycles=0;
+    //storeLoadArmParameters();
+    SetMotHome(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM);  //set this point as the spool home
+
+    return OK;
+}
+
+uint32_t Diagnostics_Dryer_UnLoading_Callback(uint32_t MotorId, uint32_t ReadValue)
+{
+    D_numberOfCycles++;
+    uint32_t temp = Read_Dryer_ENC_Position();
+    Report("Diagnostics_Dryer_UnLoading_Callback",__FILE__,ReadValue,temp,RpMessage,D_DrierPrevLocation,0);
+    //Report("Diagnostics_Dryer_UnLoading_Callback details",__FILE__,(int)(TotalLoadedLen),D_numberOfCycles,RpMessage,CallbackCounter,0);
+    if (ReadValue == NOTBUSY) // OK - take another round
+    {
+        D_DrierPrevLocation = temp;
+        Report("Diagnostics_Dryer_UnLoading cycles",__FILE__,D_numberOfCycles,LoadArmRounds,RpMessage,0,0);
+        if (D_numberOfCycles<LoadArmRounds)
+        {
+            MotorMoveWithCallback (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, 1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize,
+                                   D_numberOfSteps,    Diagnostics_Dryer_UnLoading_Callback, 10000);
+        }
+        else //done enough cycles, go to the center point
+        {
+            MotorMovetoEncoderPosition(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM,Diagnostics_Set_Load_Arm_To_Stopper_Callback,15000);
+            MCU_E2PromProgram(EEPROM_STORAGE_DRYER_CYCLES,LoadArmRounds-D_numberOfCycles);
+            Report("Store Number of cycles in drier",__FILE__,__LINE__,D_numberOfCycles,RpMessage,LoadArmRounds,0);
+        }
+    }
+    else  //timeout or no movement
+    {
+        Report("Store Number of cycles in drier - halted",__FILE__,__LINE__,D_numberOfCycles,RpMessage,LoadArmRounds,0);
+        MCU_E2PromProgram(EEPROM_STORAGE_DRYER_CYCLES,LoadArmRounds-(D_numberOfCycles-2));//it takes two cycles to identify a stop of the arm
+
+        Report("Drier unloading timeout(1) or no movement",__FILE__,temp,D_DrierPrevLocation,RpWarning,ReadValue,0);
+    }
+    return OK;
+}
+uint32_t Diagnostics_Dryer_UnLoading(void)
+{
+    uint32_t temp;
+
+    D_numberOfSteps = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround/**LoadArmRounds*/*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].microstep*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulleyradius;
+    D_numberOfCycles = 0;
+
+    MCU_E2PromRead(EEPROM_STORAGE_DRYER_CYCLES,&LoadArmRounds);
+    if (LoadArmRounds == 0) //prev trial stopped
+    {
+        LoadArmRounds = (int)dryerbufferlength;
+    }
+    if (LoadArmRounds <= 2)
+        MCU_E2PromRead(EEPROM_STORAGE_DRYER_CYCLES,&LoadArmRounds);
+
+    MCU_E2PromRead(EEPROM_STORAGE_DRYER_CENTER,&temp);
+    D_DrierPrevLocation = temp;
+    Report("Diagnostics_Set_Load_Arm_To_Start_Position",__FILE__,__LINE__,D_DrierPrevLocation,RpMessage, LoadArmRounds,0);
+    MotorSetMaxSpeed (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround/6*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulleyradius);
+//        status |= MotorMoveToStopper(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, (1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize),
+//                                        MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround/4, Diagnostics_Set_Load_Arm_To_Stopper_Callback,0,1000);
+    MotorMoveWithCallback (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, 1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize,
+                           D_numberOfSteps-800,    Diagnostics_Dryer_UnLoading_Callback, 10000);
+
+    return OK;
+}
+uint32_t Diagnostics_Dryer_MovetoEncoderPosition_Callback(uint32_t MotorId, uint32_t ReadValue)
+{
+    //Report("Diagnostics_Dryer_MovetoEncoderPosition_Callback",__FILE__,__LINE__,0,RpMessage,CallbackCounter,0);
+    MotorSetMaxSpeed (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, 200);
+
+    return OK;
+}
+
+uint32_t Diagnostics_Dryer_Loading_Callback(uint32_t MotorId, uint32_t ReadValue)
+{
+    D_numberOfCycles++;
+
+    Report("Diagnostics_Dryer_Loading_Callback",__FILE__,(int)D_numberOfCycles,(int)D_DrierPrevLocation,RpMessage,ReadValue,0);
+
+    if (ReadValue == NOTBUSY)
+    {
+        //Report("Diagnostics_Dryer_Loading_Callback",__FILE__,__LINE__,LoadStages,RpMessage,NumberOfDrierLoaderCycles,0);
+        //Report("Diagnostics_Dryer_Loading_Callback details",__FILE__,(int)(TotalLoadedLen),numberOfCycles,RpMessage,CallbackCounter,0);
+        if (D_numberOfCycles<LoadArmRounds)
+        {
+            MotorMoveWithCallback (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize,
+                                   D_numberOfSteps,    Diagnostics_Dryer_Loading_Callback, 10000);
+        }
+        else
+        {
+            MotorMovetoEncoderPosition(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM,Diagnostics_Dryer_MovetoEncoderPosition_Callback,15000);
+            MCU_E2PromProgram(EEPROM_STORAGE_DRYER_CYCLES,D_numberOfCycles);
+            Report("Store Number of cycles in drier",__FILE__,__LINE__,D_numberOfCycles,RpMessage,LoadArmRounds,0);
+        }
+    }
+    else
+    {
+        Report("Store Number of cycles in drier - halted",__FILE__,__LINE__,D_numberOfCycles,RpMessage,LoadArmRounds,0);
+        MCU_E2PromProgram(EEPROM_STORAGE_DRYER_CYCLES,D_numberOfCycles);
+        MotorSetMaxSpeed (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, 200);
+    }
+    return OK;
+}
+
+uint32_t Diagnostics_Dryer_Loading(void)
+{
+    if (dryerbufferlength)
+        LoadArmRounds = (int)dryerbufferlength;
+    MCU_E2PromRead(EEPROM_STORAGE_DRYER_CENTER,&D_DrierPrevLocation);
+    D_numberOfCycles = 0;
+    D_numberOfSteps = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround/**LoadArmRounds*/*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].microstep*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulleyradius;
+
+    MotorSetMaxSpeed (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround/6*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulleyradius);
+    //6 seconds per round
+
+    //SetMotHome(ThreadMotorIdToMotorId[Motor_i]);
+    MotorMoveWithCallback (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize,
+                           D_numberOfSteps-800,    Diagnostics_Dryer_Loading_Callback, 10000);
+    return OK;
+}
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
index 30f9d7596..95441d1a6 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
@@ -1009,8 +1009,18 @@ uint32_t DcHeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue)
                 AlarmHandlingSetAlarm(HeaterEventType[index], true);
             }
         }
-        DeActivateHeater(index);
-        HeaterRecalculateHeaterParams(index, 0);
+        if (index == HEATER_TYPE__DryerAirHeater)
+        {
+            DeActivateHeater(HEATER_TYPE__DryerMainHeater);
+            HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerMainHeater,0);
+            DeActivateHeater(HEATER_TYPE__DryerSecondaryHeater);
+            HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerSecondaryHeater,0);
+        }
+        else
+        {
+            DeActivateHeater(index);
+            HeaterRecalculateHeaterParams(index, 0);
+        }
         HeaterMaxTempFlag[index] = true;
         //ReportWithPackageFilter(HeatersFilter,(MinreadValue/100), "Heater Over the max temperature, turned off");
         return OK;
@@ -1149,9 +1159,9 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
         if (readValue < ((HeaterCmd[index].targettemperatue * (100-HeaterControl[index].outputproportionalband))/100))
         //if (readValue < (/*HeaterCmd[index].targettemperatue * AcHeatersLoweroperationLimit/1000*/HeaterCmd[index].targettemperatue-800))
         {
-            //ReportWithPackageFilter(HeatersFilter,"AC Activating",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index);
             if ((HeaterMaxTempFlag[HEATER_TYPE__DryerSecondaryHeater] == false)&&(HeaterMaxTempFlag[HEATER_TYPE__DryerMainHeater] == false))
             {
+                ReportWithPackageFilter(HeatersFilter,"AC Activating",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index);
                 ActivateHeater(HEATER_TYPE__DryerSecondaryHeater);
                 ActivateHeater(HEATER_TYPE__DryerMainHeater);
                 HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerMainHeater,100);
@@ -1181,6 +1191,7 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
         }
         */
 //        if ((readValue > (HeaterCmd[index].targettemperatue * AcHeatersLoweroperationLimit/1000))&&(readValue < (HeaterCmd[index].targettemperatue * AcHeatersUpperoperationLimit/1000)))//read value within 0.5 percent from target
+
         if    (   (readValue >  (HeaterCmd[index].targettemperatue * ((100-HeaterControl[index].outputproportionalband)/100)))
               &&  (readValue < (HeaterCmd[index].targettemperatue *  ((100+HeaterControl[index].outputproportionalband)/100))))
         {
@@ -1190,7 +1201,7 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
             HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerSecondaryHeater, 0);
             HeatersControlStart();
             AlarmHandlingSetAlarm(HeaterUnderEventType[index], false);
-            if (BlowerCfg.enabled == true)
+            /*if (BlowerCfg.enabled == true)
             {
                 if(Head_Type > HEAD_TYPE_SYLKO_WITHOUT_CARD)
                 {
@@ -1202,7 +1213,7 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
                     if (BlowerCfg.voltage)
                         Control_Voltage_To_Blower(BlowerCfg.voltage);
                 }
-            }
+            }*/
             HeaterReady[index] = true;
             //Disable_Reading_Heaters_Current(HeaterId2CurrentId[HEATER_TYPE__DryerMainHeater]);
             //Disable_Reading_Heaters_Current(HeaterId2CurrentId[HEATER_TYPE__DryerSecondaryHeater]);
@@ -1220,6 +1231,23 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
                 HeaterPrepareReady();
             }
     }
+    if    (   (readValue >  (HeaterCmd[index].targettemperatue * ((100-HeaterControl[index].outputproportionalband+2)/100)))
+          &&  (readValue < (HeaterCmd[index].targettemperatue *  ((100+HeaterControl[index].outputproportionalband)/100))))
+    {
+        if (BlowerCfg.enabled == true)
+        {
+            if(Head_Type > HEAD_TYPE_SYLKO_WITHOUT_CARD)
+            {
+                WHS_Set_SetPoint_Q_value(headairflow);
+            }
+            else
+            {
+                Turn_the_Blower_On();//Turn on with the Default_Voltage
+                if (BlowerCfg.voltage)
+                    Control_Voltage_To_Blower(BlowerCfg.voltage);
+            }
+        }
+    }
     if(HeaterPIDConfig[index].m_isEnabled && (HeaterPIDConfig[index].m_SetParam != 0))
     {
         HeaterPIDConfig[index].m_mesuredParam = readValue;
@@ -1255,10 +1283,12 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
                HeaterPIDConfig[index].m_calculatedError = PIDAlgorithmCalculation(HeaterPIDConfig[index].m_SetParam , HeaterPIDConfig[index].m_mesuredParam,
                                      &HeaterPIDConfig[index].m_params,   &HeaterPIDConfig[index].m_preError, &HeaterPIDConfig[index].m_integral);
             //}
-//            len = usnprintf(ACheatstr, 254, "ACD Id, Temp , Integral, Output{ %d, %d ,%d, %d} ",index,(int)HeaterPIDConfig[index].m_mesuredParam ,(int)HeaterPIDConfig[index].m_integral,(int)HeaterPIDConfig[index].m_calculatedError);
+            int len = usnprintf(ACheatstr, 254, "ACD Id, Temp , Integral, Output{ %d, %d ,%d, %d} H1 %d H2 %d ",index,
+                            (int)HeaterPIDConfig[index].m_mesuredParam ,(int)HeaterPIDConfig[index].m_integral,(int)HeaterPIDConfig[index].m_calculatedError,
+                            GetHeaterState(HEATER_TYPE__DryerMainHeater),GetHeaterState(HEATER_TYPE__DryerSecondaryHeater));
             //        ReportWithPackageFilter(HeatersFilter,logmsg[index],__FILE__,__LINE__,index,RpWarning,index,  Counter[index]);
             //        #warning PID is now only proportional (above)
-//             ReportWithPackageFilter(HeatersFilter,ACheatstr,__FILE__,__LINE__,index,RpWarning,readValue,  HeaterPIDConfig[index].m_calculatedError);
+             ReportWithPackageFilter(HeatersFilter,ACheatstr,__FILE__,__LINE__,index,RpWarning,readValue,  HeaterPIDConfig[index].m_calculatedError);
             //ReportWithPackageFilter(HeatersFilter,"AC PID",__FILE__,__LINE__,HeaterPIDConfig[index].m_calculatedError/100,RpWarning,readValue, index);
             if (HeaterRestarted[HEATER_TYPE__DryerMainHeater] == true)
             {
@@ -1668,6 +1698,10 @@ uint32_t HeatersControlLoop(uint32_t tick)
                     //DeActivate HEATER_TYPE__DryerSecondaryHeater
                     //DeActivateHeater (HEATER_TYPE__DryerSecondaryHeater);
                 }
+                else
+                {
+                    DeActivateHeater (HEATER_TYPE__DryerSecondaryHeater);
+                }
             }
             /*else if (TimeSliceAllocation[SliceCounter] == HEATER_TYPE__DryerSecondaryHeater)
             {
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
index f34e56470..1c43872cc 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
@@ -710,7 +710,7 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
     JobTicket* JobTicket = JobDetails;
 
     JobEndSequence = false;
-    if ((pressurebuildup>0.1)&&(pressurebuildup<1.5))
+    if ((pressurebuildup>0.1)&&(pressurebuildup<2.5))
     {
         Report("Setting pressure from RML feeder tension",__FILE__,__LINE__,(int)(pressurebuildup*100),RpWarning,(int)(DispenserPreparePressure*100),0);
         DispenserPreparePressure = pressurebuildup;
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_TempSensor.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_TempSensor.c
index f4384ab94..fe1118f15 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_TempSensor.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_TempSensor.c
@@ -149,6 +149,7 @@ void Stub_TempSensorRequest(MessageContainer* requestContainer)
             response.temperature_c_mult_by_100 = TempSensorResponse[request->stemp_sensor_id].Temperature_C_mult_by_100;
         }
 
+        response.temperature_c_mult_by_100 = MillisecGetTemperatures(request->stemp_sensor_id);
 
 
     /*
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
index edfc517bf..386b34f49 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
@@ -961,7 +961,7 @@ uint32_t ThreadPrepare_Tension (int DancerId, double tension)
     }
     MotorStop(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, Hard_Stop);
 
-    if (FPGA_Read_limit_Switches(Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_DH_LID]) != LIMIT)
+    /*if (FPGA_Read_limit_Switches(Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_DH_LID]) != LIMIT)
     {
         ReportWithPackageFilter(ThreadFilter,"Dyeing head is open!!!",__FILE__,__LINE__,HARDWARE_MOTOR_TYPE__MOTO_DH_LID,RpFatalError,LIMIT,0);
         //JobEndReason = JOB_LIDS_OPEN;
@@ -974,6 +974,21 @@ uint32_t ThreadPrepare_Tension (int DancerId, double tension)
         //JobEndReason = JOB_LIDS_OPEN;
         //PrepareReady(Module_Thread,ModuleFail);
         //return ERROR;
+    }*/
+
+    if (FPGA_Read_limit_Switches(Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_DH_LID]) == LIMIT)
+    {
+        ReportWithPackageFilter(ThreadFilter,"Dyeing head is wide open!!!",__FILE__,__LINE__,HARDWARE_MOTOR_TYPE__MOTO_DH_LID,RpFatalError,LIMIT,0);
+        JobEndReason = JOB_LIDS_OPEN;
+        PrepareReady(Module_Thread,ModuleFail);
+        return ERROR;
+    }
+    if (FPGA_Read_limit_Switches(Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID]) == LIMIT)
+    {
+        ReportWithPackageFilter(ThreadFilter,"Dryer lid is wide open!!!",__FILE__,__LINE__,HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID,RpFatalError,LIMIT,0);
+        JobEndReason = JOB_LIDS_OPEN;
+        PrepareReady(Module_Thread,ModuleFail);
+        return ERROR;
     }
 
     //start thread control for all motors
diff --git a/Software/Embedded_SW/Embedded/StateMachines/Initialization/InitSequence.c b/Software/Embedded_SW/Embedded/StateMachines/Initialization/InitSequence.c
index d8367316b..fb5cd884d 100644
--- a/Software/Embedded_SW/Embedded/StateMachines/Initialization/InitSequence.c
+++ b/Software/Embedded_SW/Embedded/StateMachines/Initialization/InitSequence.c
@@ -573,7 +573,7 @@ void InitSequenceSetStartHeating(bool StartHeating)
 uint32_t InitSequenceStartHeating(void)
 {
     SetMachineReadyForHeating(true);
-    SetMachineStatus(MACHINE_STATE__Ready); //prevent job while waiting for the cooler
+    //SetMachineStatus(MACHINE_STATE__Ready); //prevent job while waiting for the cooler
 
     if (InitialHeating)
     {
@@ -594,6 +594,7 @@ uint32_t InitSequenceStartHeating(void)
     else
     {
         REPORT_MSG(InitialHeating,"InitSequenceStateMachine InitialHeating is OFF");
+        SetMachineStatus(MACHINE_STATE__Ready);
         SetMachineState(MACHINE_STATE_MACHINE_READY_TO_DYE);
         InitStages++;
     }
diff --git a/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerIdle.c b/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerIdle.c
index 402db9d1e..69df1c183 100644
--- a/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerIdle.c
+++ b/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerIdle.c
@@ -93,6 +93,7 @@ void PowerIdleSetIdle(void)
     ProcessParametersClear.headzone11temp  = (ActiveProcessParameters.headzone11temp <80)? ActiveProcessParameters.headzone11temp  :IdleHeadTemperature;
     ProcessParametersClear.headzone12temp  = (ActiveProcessParameters.headzone12temp <80)? ActiveProcessParameters.headzone12temp  :IdleHeadTemperature;
     ProcessParametersClear.dyeingspeed    = (ActiveProcessParameters.dyeingspeed   <40)? ActiveProcessParameters.dyeingspeed    :IdleHeadTemperature;
+    ProcessParametersClear.dryerbufferlength    = (ActiveProcessParameters.dryerbufferlength   <30)? ActiveProcessParameters.dryerbufferlength    :30;
     ProcessParametersClear.rblowertemp  = (ActiveProcessParameters.rblowertemp <80)? ActiveProcessParameters.rblowertemp  :IdleHeadTemperature;
     ProcessParametersClear.lblowertemp  = (ActiveProcessParameters.lblowertemp <80)? ActiveProcessParameters.lblowertemp  :IdleHeadTemperature;
     ProcessParametersClear.rblowerflow  = (ActiveProcessParameters.rblowerflow <96)? ActiveProcessParameters.rblowerflow  :96;