Veraion 1.4.6.10 improve current reading, fir I2C interface, improve (?) task priorities

18 files changed, 183 insertions, 130 deletions

diff --git a/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c b/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c
index 20dc627e8..e0dc92e1b 100644
--- a/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c
+++ b/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c
@@ -20,7 +20,7 @@ typedef struct
 } TangoVersion_t;
 
 
-TangoVersion_t _gTangoVersion = {1,4,6,9};
+TangoVersion_t _gTangoVersion = {1,4,6,10};
 #define BUILD_DATE __DATE__
 char Dat[50] = BUILD_DATE; 
  char _gTangoName [MAX_STRING_LEN] = "Tango01 ";//d
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/ADC_MUX/ADC_MUX.c b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/ADC_MUX/ADC_MUX.c
index 123f3f1e9..e39d690aa 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/ADC_MUX/ADC_MUX.c
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/ADC_MUX/ADC_MUX.c
@@ -404,7 +404,7 @@ int Get_MidTank_Int1000_Sensor(MidTank_t MidTank_ID) //0-7
 /////////////////////////  Head_MixChip_Heaters_Current //////////////////////////////
 
 
-bool Heaters_Current_Read_Enable[9] = {false,false,false,false,false,false,false,false,false};
+bool Heaters_Current_Read_Enable[9] = {false,false,false,false,false,false,true,true,false};
 
 double Heaters_Current[9] = {1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0};
 
@@ -412,21 +412,21 @@ uint32_t Heaters_Current_Bits[9];//just for debug
 
 void Enable_Reading_Heaters_Current(HEATERS_CURRENT Heater_ID) //0-8
 {
-    if(Head_Type > HEAD_TYPE_SYLKO_WITHOUT_CARD)
+    if((Head_Type > HEAD_TYPE_SYLKO_WITHOUT_CARD)&&(Heater_ID>=HEATER_DRYER_CURRENT_3))
         return;
     assert (Heater_ID<NUM_OF_CURRENT_HEATERS);
     Heaters_Current_Read_Enable[Heater_ID] = true;
 }
 void Disable_Reading_Heaters_Current(HEATERS_CURRENT Heater_ID) //0-8
 {
-    if(Head_Type > HEAD_TYPE_SYLKO_WITHOUT_CARD)
+    if((Head_Type > HEAD_TYPE_SYLKO_WITHOUT_CARD)&&(Heater_ID>=HEATER_DRYER_CURRENT_3))
         return;
     assert (Heater_ID<NUM_OF_CURRENT_HEATERS);
     Heaters_Current_Read_Enable[Heater_ID] = false;
 }
 bool Get_Heater_Current_Reading_State(HEATERS_CURRENT Heater_ID) //0-8
 {
-    if(Head_Type > HEAD_TYPE_SYLKO_WITHOUT_CARD)
+    if((Head_Type > HEAD_TYPE_SYLKO_WITHOUT_CARD)&&(Heater_ID>=HEATER_DRYER_CURRENT_3))
         return false;
     assert (Heater_ID<NUM_OF_CURRENT_HEATERS);
     return Heaters_Current_Read_Enable[Heater_ID];
@@ -435,7 +435,7 @@ bool Get_Heater_Current_Reading_State(HEATERS_CURRENT Heater_ID) //0-8
 uint32_t Read_Heaters_Current(HEATERS_CURRENT Heater_ID) //0-8
 {
     uint32_t Status = OK;
-    if(Head_Type > HEAD_TYPE_SYLKO_WITHOUT_CARD)
+    if((Head_Type > HEAD_TYPE_SYLKO_WITHOUT_CARD)&&(Heater_ID>=HEATER_DRYER_CURRENT_3))
         return 0;
 
     assert (Heater_ID<NUM_OF_CURRENT_HEATERS);
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/IO_Ports/Head_IO.c b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/IO_Ports/Head_IO.c
index 691513452..64f9d6412 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/IO_Ports/Head_IO.c
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/IO_Ports/Head_IO.c
@@ -382,7 +382,7 @@ uint32_t HeadCard_Actuators_Status(ACTUATORS Act_ID)//
 {
     uint32_t Motioin_Status = STOPPED;
 
-    Head_Read_IO_Reg(0x46,HIGH);
+    //Head_Read_IO_Reg(0x46,HIGH);
 
     if(Act_ID == ACTIN)
     {
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C.h b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C.h
index c04c6de7f..6c46410e4 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C.h
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C.h
@@ -38,5 +38,6 @@ uint32_t Block_Main_MUX_TCA9548A_0xE4(); ////unused I2C MUX
 
 extern uint8_t Main_Mux_Flag ;
 extern Semaphore_Handle I2C_Sem;
+extern Task_Handle I2C_Task_Handle;
 
 #endif /* DRIVERS_I2C_COMMUNICATION_I2C_H_ */
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C_Comm.c b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C_Comm.c
index e6095b9f8..79c986978 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C_Comm.c
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C_Comm.c
@@ -108,22 +108,6 @@ uint32_t I2C_WriteBuff(uint32_t I2C_BASE, unsigned char addr, unsigned char* dat
         SysCtlDelay(I2C_BUSY_DELAY);
     }
 
-    if (status == I2C_MASTER_ERR_ARB_LOST)
-    {
-        if (Arb_Loss_Count++ > 10)
-        {
-            Arb_Loss_Count= 0;
-            Init_All_I2C();
-            ReportWithPackageFilter(CommFilter,"Reinitializing I2C master", __FILE__,__LINE__,status, RpMessage, Task_self(), 0);
-        }
-    }
-    else
-    {
-        if (Arb_Loss_Count)
-        ReportWithPackageFilter(CommFilter,"Resetting count", __FILE__, Arb_Loss_Count, status, RpMessage, Task_self(), 0);
-
-       // Arb_Loss_Count = 0;
-    }
     return status;
 }
 
@@ -190,23 +174,6 @@ uint32_t I2C_ReadBuff(uint32_t I2C_BASE, unsigned char addr, unsigned char* data
         //return I2CMasterErr(I2C_BASE) == I2C_MASTER_ERR_NONE;
         status |= I2CMasterErr(I2C_BASE);
     }
-    if (status == I2C_MASTER_ERR_ARB_LOST)
-    {
-        if (Arb_Loss_Count++ > 10)
-        {
-            Arb_Loss_Count= 0;
-            Init_All_I2C();
-            ReportWithPackageFilter(CommFilter,"Reinitializing I2C master", __FILE__,__LINE__, status, RpMessage, Task_self(), 0);
-
-        }
-    }
-    else
-    {
-        if (Arb_Loss_Count)
-        ReportWithPackageFilter(CommFilter,"Resetting count", __FILE__, Arb_Loss_Count, status, RpMessage, Task_self(), 0);
-
-        //Arb_Loss_Count = 0;
-    }
     return status;
 }
 
@@ -228,6 +195,10 @@ uint32_t I2C_Write(uint32_t I2C_ID, uint32_t Slave_Add, uint32_t *I2C_Write_buf,
     else
         return ERROR;
 
+   /* if (Task_self()!=I2C_Task_Handle)
+    {
+        ReportWithPackageFilter(CommFilter,"I2C_Write called from different task", __FILE__,__LINE__, I2C_Task_Handle, RpMessage, Task_self(), 0);
+    }*/
 /*    if ( (Slave_Add != 0xE0) && (Slave_Add != 0xE4) && (Slave_Add != 0xE3) &
          (Slave_Add != 0x40) && (Slave_Add != 0x44) && (Slave_Add != 0x46) &
          (Slave_Add != 0x98) && (Slave_Add != 0xA0)                            )
@@ -254,6 +225,22 @@ uint32_t I2C_Write(uint32_t I2C_ID, uint32_t Slave_Add, uint32_t *I2C_Write_buf,
 //   }
 
     status = I2C_WriteBuff(I2C_BASE, Slave_Add, I2C_Write_buf, No_BytesToWrite);
+    if (status)
+    {
+        if (Arb_Loss_Count++ > 10)
+        {
+            Arb_Loss_Count= 0;
+            Init_All_I2C();
+            ReportWithPackageFilter(CommFilter,"Reinitializing I2C master", __FILE__,__LINE__, status, RpMessage, Task_self(), 0);
+
+        }
+    }
+    /*else
+    {
+        if (Arb_Loss_Count)
+            ReportWithPackageFilter(CommFilter,"Resetting count", __FILE__, Arb_Loss_Count, status, RpMessage, Task_self(), 0);
+        //Arb_Loss_Count = 0;
+    }*/
 
     return status;
 }
@@ -280,6 +267,10 @@ uint32_t I2C_Read(uint32_t I2C_ID, uint32_t Slave_Add, uint32_t *I2C_Read_buf, u
          (Slave_Add != 0x40) && (Slave_Add != 0x44) && (Slave_Add != 0x46) &
          (Slave_Add != 0x98) && (Slave_Add != 0xA0)                            )
         return ERROR;*/
+   /*if (Task_self()!=I2C_Task_Handle)
+    {
+        ReportWithPackageFilter(CommFilter,"I2C_Write called from different task", __FILE__,__LINE__, I2C_Task_Handle, RpMessage, Task_self(), 0);
+    }*/
 
     Slave_Add = Slave_Add>>1;
 
@@ -303,6 +294,22 @@ uint32_t I2C_Read(uint32_t I2C_ID, uint32_t Slave_Add, uint32_t *I2C_Read_buf, u
 
     //status = I2C_WriteBuff(I2C_BASE, Slave_Add, Bytes2Write, No_BytesTWrite);
     status = I2C_ReadBuff(I2C_BASE, Slave_Add, I2C_Read_buf, No_BytesToRead);
+    if (status)
+    {
+        if (Arb_Loss_Count++ > 10)
+        {
+            Arb_Loss_Count= 0;
+            Init_All_I2C();
+            ReportWithPackageFilter(CommFilter,"Reinitializing I2C master", __FILE__,__LINE__, status, RpMessage, Task_self(), 0);
+
+        }
+    }
+    /*else
+    {
+        if (Arb_Loss_Count)
+            ReportWithPackageFilter(CommFilter,"Resetting count", __FILE__, Arb_Loss_Count, status, RpMessage, Task_self(), 0);
+        //Arb_Loss_Count = 0;
+    }*/
 
     return status;
 }
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C_Task.c b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C_Task.c
index 4308a7913..c2097dbef 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C_Task.c
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C_Task.c
@@ -28,6 +28,7 @@
 #include "modules/ids/ids_ex.h"
 
 extern Semaphore_Handle I2C_Sem;
+Task_Handle I2C_Task_Handle;
 Mailbox_Handle          I2C_ReadingMsgQ = NULL;
 typedef enum
 {
@@ -41,7 +42,6 @@ typedef enum
     Actuators_Control,
 
     /* enum for WHS :*/
-    DetectNewWHS,
     WHS_start,
     WHS_init_I2C_IO,
     WHS_init_fan,
@@ -78,7 +78,10 @@ void Trigger_Heater_Current_Read(void)
     uint8_t Heater_i=0;
 
     I2C_ReadingMessage.messageId = Heater_Current_Reading;
-    I2C_ReadingMessage.parameter = Heater_i;
+    I2C_ReadingMessage.parameter = HEATER_DRYER_CURRENT_1;
+    if (I2C_ReadingMsgQ != NULL)
+       Mailbox_post(I2C_ReadingMsgQ , &I2C_ReadingMessage, BIOS_NO_WAIT);
+    I2C_ReadingMessage.parameter = HEATER_DRYER_CURRENT_2;
     if (I2C_ReadingMsgQ != NULL)
        Mailbox_post(I2C_ReadingMsgQ , &I2C_ReadingMessage, BIOS_NO_WAIT);
 
@@ -161,16 +164,6 @@ void Trigger_InputsReading(void)
 
 }
 
-void Trigger_Check_WHS_Type_Via_EEPROM()
-{
-    I2C_ReadingMessageStruc I2C_ReadingMessage;
-
-     I2C_ReadingMessage.messageId = DetectNewWHS;
-     if (I2C_ReadingMsgQ != NULL)
-         Mailbox_post(I2C_ReadingMsgQ , &I2C_ReadingMessage, BIOS_NO_WAIT);
-     return;
-}
-
 void Trigger_WHS_init_IO(void)
 {
     I2C_ReadingMessageStruc I2C_ReadingMessage;
@@ -398,6 +391,7 @@ void I2C_ReadingTask(UArg arg0, UArg arg1)
     I2C_ReadingMessageStruc I2C_ReadingMessage;
     Semaphore_post(I2C_Sem);
     TEMPERATURE_SENSOR_ID_ENUM Sensor_i;
+    I2C_Task_Handle = Task_self();
 
     while(1)
     {
@@ -425,7 +419,7 @@ void I2C_ReadingTask(UArg arg0, UArg arg1)
             break;
         case Heater_Current_Reading:
             //Report("Read_Heaters_Current",__FILE__,__LINE__,255,RpWarning,0,0);
-            if(Head_Type > HEAD_TYPE_SYLKO_WITHOUT_CARD)
+            if((Head_Type > HEAD_TYPE_SYLKO_WITHOUT_CARD)&&(I2C_ReadingMessage.parameter>=HEATER_DRYER_CURRENT_3))
                 Read_Head_ADC(I2C_ReadingMessage.parameter);
             else
                 Read_Heaters_Current(I2C_ReadingMessage.parameter);
@@ -440,7 +434,7 @@ void I2C_ReadingTask(UArg arg0, UArg arg1)
             HeadADCPT100_SensorInitConfig();
             break;
         case Actuators_Control:
-            HeadCard_Actuators_Control(I2C_ReadingMessage.parameter, (bool)I2C_ReadingMessage.parameter2,(bool)I2C_ReadingMessage.parameter2);
+            HeadCard_Actuators_Control(I2C_ReadingMessage.parameter, (bool)I2C_ReadingMessage.parameter2,(bool)I2C_ReadingMessage.parameter3);
             break;
         case Inputs_Reading:
             Head_Read_IO_Reg(0x46, HIGH);//READ HEAD CARD LS
@@ -461,10 +455,6 @@ void I2C_ReadingTask(UArg arg0, UArg arg1)
             }
             break;
 
-        case DetectNewWHS:
-            Check_WHS_Type_Via_EEPROM();
-            break;
-
         case WHS_init_I2C_IO:
             WHS_IO_Init();
             break;
diff --git a/Software/Embedded_SW/Embedded/Drivers/Motors/MotorActions.c b/Software/Embedded_SW/Embedded/Drivers/Motors/MotorActions.c
index ddd0d293c..9fe7a67cc 100644
--- a/Software/Embedded_SW/Embedded/Drivers/Motors/MotorActions.c
+++ b/Software/Embedded_SW/Embedded/Drivers/Motors/MotorActions.c
@@ -839,6 +839,11 @@ void MotorActionsInit(void)
         MotorDriverResponse[i].Status = 0xFFFFFFFF;
         StoredMotorPosition[i] = 0;
     }
+    if (Head_Type == HEAD_TYPE_SYLKO)//adjust the limit switches
+    {
+        Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_DH_LID] = HEADCARD_COVER_LS_REAR;
+        Motor_Id_to_LS_IdUp  [HARDWARE_MOTOR_TYPE__MOTO_DH_LID] = HEADCARD_COVER_LS_FRONT;
+    }
 }
 
 
diff --git a/Software/Embedded_SW/Embedded/Drivers/flash_ram/FlashProgram.c b/Software/Embedded_SW/Embedded/Drivers/flash_ram/FlashProgram.c
index bef2b1727..240585e43 100644
--- a/Software/Embedded_SW/Embedded/Drivers/flash_ram/FlashProgram.c
+++ b/Software/Embedded_SW/Embedded/Drivers/flash_ram/FlashProgram.c
@@ -106,7 +106,7 @@ uint32_t ReadAppAndProgram(uint32_t ui32FlashStart,uint32_t ui32FileSize,void* b
 
         status = FlashProgram((uint32_t *)ui32BufferAddr, ui32ProgAddr,(ui32DataSize + 3) & ~3);
         if (status)
-            Report("FlashProgram Error", __FILE__,status,ui32FlashStart , RpMessage, (ui32DataSize + 3) & ~3, 0);
+            Report("FlashProgram Error", __FILE__,status,ui32ProgAddr , RpMessage, (ui32DataSize + 3) & ~3, 0);
 
         //
         // If there is more image to program, then update the programming
diff --git a/Software/Embedded_SW/Embedded/Embedded.cfg b/Software/Embedded_SW/Embedded/Embedded.cfg
index 26fd2a980..734902ce7 100644
--- a/Software/Embedded_SW/Embedded/Embedded.cfg
+++ b/Software/Embedded_SW/Embedded/Embedded.cfg
@@ -99,66 +99,60 @@ Program.global.ReconnectSem = Semaphore.create(null, semaphore7Params);
 var MillisecTaskParams = new Task.Params();
 MillisecTaskParams.instance.name = "MilliSecond";
 MillisecTaskParams.stackSize = 4096;
-MillisecTaskParams.priority = 12;
+MillisecTaskParams.priority = 14;
 Program.global.millisec = Task.create("&MillisecTask", MillisecTaskParams);
 
-var FPGALoad = new Task.Params();
-FPGALoad.instance.name = "FPGALoad";
-FPGALoad.stackSize = 4096;
-FPGALoad.priority = 4;
-Program.global.FPGALoad = Task.create("&FPGALoadTask", FPGALoad);
-
-var I2C_Reading = new Task.Params();
-I2C_Reading.instance.name = "I2C_Reading";
-I2C_Reading.stackSize = 2048;
-I2C_Reading.priority = 8;
-Program.global.I2C_Reading = Task.create("&I2C_ReadingTask", I2C_Reading);
-
 var ControlTaskParams = new Task.Params();
 ControlTaskParams.instance.name = "control";
 ControlTaskParams.stackSize = 2048;
-ControlTaskParams.priority = 11;
+ControlTaskParams.priority = 13;
 Program.global.control = Task.create("&controlTask", ControlTaskParams);
 
-var AlarmHandlingTaskParams = new Task.Params();
-AlarmHandlingTaskParams.instance.name = "AlarmHandling";
-AlarmHandlingTaskParams.stackSize = 4096;
-AlarmHandlingTaskParams.priority = 9;
-Program.global.AlarmHandling = Task.create("&AlarmHandlingTask", AlarmHandlingTaskParams);
-
 var CommTxTaskParams = new Task.Params();
 CommTxTaskParams.instance.name = "communicationTx";
-CommTxTaskParams.priority = 10;
+CommTxTaskParams.priority = 12;
 CommTxTaskParams.stackSize = 4096;
 Program.global.communicationTx = Task.create("&communicationTxTask", CommTxTaskParams);
 
+var CommRxTaskParams = new Task.Params();
+CommRxTaskParams.instance.name = "communicationRx";
+CommRxTaskParams.priority = 11;
+CommRxTaskParams.stackSize = 8192;
+Program.global.communication = Task.create("&communicationTask", CommRxTaskParams);
+
+var AlarmHandlingTaskParams = new Task.Params();
+AlarmHandlingTaskParams.instance.name = "AlarmHandling";
+AlarmHandlingTaskParams.stackSize = 4096;
+AlarmHandlingTaskParams.priority = 10;
+Program.global.AlarmHandling = Task.create("&AlarmHandlingTask", AlarmHandlingTaskParams);
+
 var ProcessTaskParams = new Task.Params();
 ProcessTaskParams.instance.name = "process";
 ProcessTaskParams.stackSize = 4096;
-ProcessTaskParams.priority = 8;
+ProcessTaskParams.priority = 9;
 Program.global.process = Task.create("&jobTask", ProcessTaskParams);
 
+var I2C_Reading = new Task.Params();
+I2C_Reading.instance.name = "I2C_Reading";
+I2C_Reading.stackSize = 2048;
+I2C_Reading.priority = 8;
+Program.global.I2C_Reading = Task.create("&I2C_ReadingTask", I2C_Reading);
+
 var HeaterControlTaskParams = new Task.Params();
 HeaterControlTaskParams.instance.name = "HeatersControl";
 HeaterControlTaskParams.priority = 7;
 Program.global.HeatersControl = Task.create("&HeatersControlTask", HeaterControlTaskParams);
 
-var CommRxTaskParams = new Task.Params();
-CommRxTaskParams.instance.name = "communicationRx";
-CommRxTaskParams.priority = 9;
-CommRxTaskParams.stackSize = 8192;
-Program.global.communication = Task.create("&communicationTask", CommRxTaskParams);
-
-var MillisecLowTaskParams = new Task.Params();
-MillisecLowTaskParams.instance.name = "MilliSecondLow";
-MillisecLowTaskParams.stackSize = 2048;
-MillisecLowTaskParams.priority = 5;
-Program.global.millisecLow = Task.create("&MillisecLowTask", MillisecLowTaskParams);
+var ReportTaskParams = new Task.Params();
+ReportTaskParams.instance.name = "report";
+ReportTaskParams.stackSize = 4096;
+ReportTaskParams.priority = 6;
+Program.global.report = Task.create("&reportService", ReportTaskParams);
 
 var ControlLowTaskParams = new Task.Params();
 ControlLowTaskParams.instance.name = "controlLow";
 ControlLowTaskParams.stackSize = 4096;
-ControlLowTaskParams.priority = 6;
+ControlLowTaskParams.priority = 5;
 Program.global.controlLow = Task.create("&controlLowTask", ControlLowTaskParams);
 
 var DiagnosticsTaskParams = new Task.Params();
@@ -167,17 +161,23 @@ DiagnosticsTaskParams.priority = 4;
 DiagnosticsTaskParams.stackSize = 8192;
 Program.global.Diagnostics = Task.create("&DiagnosticsTask", DiagnosticsTaskParams);
 
+var MillisecLowTaskParams = new Task.Params();
+MillisecLowTaskParams.instance.name = "MilliSecondLow";
+MillisecLowTaskParams.stackSize = 2048;
+MillisecLowTaskParams.priority = 3;
+Program.global.millisecLow = Task.create("&MillisecLowTask", MillisecLowTaskParams);
+
 var ADCProcessTaskParams = new Task.Params();
 ADCProcessTaskParams.instance.name = "adcProcess";
 ADCProcessTaskParams.stackSize = 512;
 ADCProcessTaskParams.priority = 2;
 Program.global.adcProcess = Task.create("&ADCProcessTask", ADCProcessTaskParams);
 
-var ReportTaskParams = new Task.Params();
-ReportTaskParams.instance.name = "report";
-ReportTaskParams.stackSize = 4096;
-ReportTaskParams.priority = 7;
-Program.global.report = Task.create("&reportService", ReportTaskParams);
+var FPGALoad = new Task.Params();
+FPGALoad.instance.name = "FPGALoad";
+FPGALoad.stackSize = 4096;
+FPGALoad.priority = 2;
+Program.global.FPGALoad = Task.create("&FPGALoadTask", FPGALoad);
 
 var updateTaskParams = new Task.Params();
 updateTaskParams.instance.name = "update";
diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
index d1fd48b32..caa3e8df4 100644
--- a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
+++ b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
@@ -66,7 +66,6 @@ uint32_t AlarmHandlingControlId = 0xFF;
 uint32_t AlarmHandlingTick = 0;
 
 double     CurrentAlarmHighLimit ,CurrentAlarmLowLimit;
-
 bool    CheckHardLimitAlarms = false,CheckCurrentAlarms = false,CheckTamperAlarms = false,CheckMotorAlarms = false;
 uint8_t alarm_response_buffer[500];
 
@@ -837,6 +836,13 @@ JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob)
     }
     for (Alarm_i = 0;Alarm_i<NumOfSystemAlarms;Alarm_i++)
     {
+        if ((AlarmState[Alarm_i].Status == true)&&(AlarmItem[Alarm_i].Severity == DEBUG_LOG_CATEGORY__Critical))
+        {
+            status = JOB_SAFETY_CRITICAL_ALARM;
+            ReportWithPackageFilter(AlarmFilter,"critical alarm preventing job", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, AlarmItem[Alarm_i].Severity, AlarmItem[Alarm_i].DeviceId, 0);
+            AlarmId = Alarm_i;
+            break;
+        }
 
         if (AlarmItem[Alarm_i].AlarmSource == ALARM_SOURCE_TYPE__CoversAlarm)
         {
@@ -1151,24 +1157,31 @@ uint32_t AlarmHandlingLoop(uint32_t tick)
                  {
                     if (AlarmItem[Alarm_i].ModuleDeviceId == 0xFF)
                     {
-                        if (Get_Heaters_Current_float(AlarmItem[Alarm_i].DeviceId, &doubleValue) == OK)
+                        if (LoadHeaterSetPoint(HEATER_TYPE__DryerAirHeater) <= 2)
+                        {
+                            Status = false;
+                        }
+                        else
                         {
-                            if (AlarmItem[Alarm_i].AlarmDirection == true)
+                            if (Get_Heaters_Current_float(AlarmItem[Alarm_i].DeviceId, &doubleValue) == OK)
                             {
-                                if ((doubleValue >= (float)(AlarmItem[Alarm_i].AlarmValue*CurrentAlarmHighLimit)) || (doubleValue <= (float)(AlarmItem[Alarm_i].AlarmValue*CurrentAlarmLowLimit)))
+                                if (AlarmItem[Alarm_i].AlarmDirection == true)
                                 {
-                                    Status = true;
-                                    if (AlarmState[Alarm_i].Status == false)
-                                        ReportWithPackageFilter(AlarmFilter,"OverCurrent Alarm ON ", __FILE__,AlarmItem[Alarm_i].DeviceId,(int)(AlarmItem[Alarm_i].AlarmValue*100), RpMessage, (int)(doubleValue*100), 0);
+                                    if ((doubleValue >= (float)(AlarmItem[Alarm_i].AlarmValue*CurrentAlarmHighLimit)) || (doubleValue <= (float)(AlarmItem[Alarm_i].AlarmValue*CurrentAlarmLowLimit)))
+                                    {
+                                        Status = true;
+                                        if (AlarmState[Alarm_i].Status == false)
+                                            ReportWithPackageFilter(AlarmFilter,"OverCurrent Alarm ON ", __FILE__,AlarmItem[Alarm_i].DeviceId,(int)(AlarmItem[Alarm_i].AlarmValue*100), RpMessage, (int)(doubleValue*100), 0);
+                                    }
                                 }
-                            }
-                            else
-                            {
-                                if (doubleValue <= 0.1)
+                                else
                                 {
-                                    Status = true;
-                                    if (AlarmState[Alarm_i].Status == false)
-                                        ReportWithPackageFilter(AlarmFilter,"loop break Alarm ON ", __FILE__,AlarmItem[Alarm_i].DeviceId,(int)(AlarmItem[Alarm_i].AlarmValue*100), RpMessage, (int)(doubleValue*100), 0);
+                                    if (doubleValue <= 0.1)
+                                    {
+                                        Status = true;
+                                        if (AlarmState[Alarm_i].Status == false)
+                                            ReportWithPackageFilter(AlarmFilter,"loop break Alarm ON ", __FILE__,AlarmItem[Alarm_i].DeviceId,(int)(AlarmItem[Alarm_i].AlarmValue*100), RpMessage, (int)(doubleValue*100), 0);
+                                    }
                                 }
                             }
                         }
@@ -1266,7 +1279,7 @@ uint32_t AlarmHandlingLoop(uint32_t tick)
 
             case ALARM_SOURCE_TYPE__TachoAlarm: // add by shai
                 Status = false;
-                if (CheckCurrentAlarms)
+                if (CheckTamperAlarms)
                 {
 
 //                ReportWithPackageFilter(AlarmFilter,"------------FANS_RPM[Alarm_i]----------------", __FILE__,__LINE__,Alarm_i, RpMessage, value, 0);
diff --git a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
index 48c7c3f5e..e5064ef70 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
+++ b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
@@ -579,7 +579,7 @@ uint32_t MillisecLowLoop(uint32_t tick)
     //test dancers and speed encoders
     //check all callback units (state machine waiting for completion of a change)
     bool Ten_msTick, Fifty_msTick, Hundred_msTick , m20msecTick,m70msecTick,m90msecTick, Onesecond_Tick,OneMinute_Tick,OneHourTick,Gradient_Tick;
-    bool O100Millisecond_Tick,O200Millisecond_Tick,O400Millisecond_Tick,O500Millisecond_Tick,O600Millisecond_Tick;
+    bool O700Millisecond_Tick,O200Millisecond_Tick,O400Millisecond_Tick,O500Millisecond_Tick,O600Millisecond_Tick;
     //bool O100Millisecond_Tick,O200Millisecond_Tick,O400Millisecond_Tick,O500Millisecond_Tick,O600Millisecond_Tick,O800Millisecond_Tick,O900Millisecond_Tick;
     Ten_msTick      =   (tick%eTenMillisecond == 0)      ?true:false;
     Fifty_msTick      =   (tick%eHundredMillisecond == 40)      ?true:false; //eFiftyMillisecond
@@ -587,7 +587,7 @@ uint32_t MillisecLowLoop(uint32_t tick)
     m20msecTick  =   (tick%eHundredMillisecond == 20)  ?true:false;
     m70msecTick  =   (tick%eHundredMillisecond == 70)  ?true:false;
     m90msecTick  =   (tick%eHundredMillisecond == 90)  ?true:false;
-    O100Millisecond_Tick  =   (tick%eOneSecond == 100)           ?true:false;
+    O700Millisecond_Tick  =   (tick%eOneSecond == 700)           ?true:false;
     O200Millisecond_Tick  =   (tick%eOneSecond == 200)           ?true:false;
     O400Millisecond_Tick  =   (tick%eOneSecond == 400)           ?true:false;
     O500Millisecond_Tick  =   (tick%eOneSecond == 500)           ?true:false;
@@ -663,7 +663,7 @@ uint32_t MillisecLowLoop(uint32_t tick)
     }
     if (Gradient_Tick)
         DispensersCollectionCall();
-    if (O100Millisecond_Tick)
+    if (O700Millisecond_Tick)
     {
         Trigger_Heater_Current_Read();
     }
@@ -705,8 +705,8 @@ uint32_t MillisecLowLoop(uint32_t tick)
         MachineUpdateResponseFunc();
         //KeepAliveOneSecondCall();
 
-        TemperatureListString(Lenstr);
-        ReportWithPackageFilter(ThreadFilter,Lenstr,__FILE__,__LINE__,(int)Counter++,RpWarning,(int) msec_millisecondCounter,0);
+        //TemperatureListString(Lenstr);
+        //ReportWithPackageFilter(ThreadFilter,Lenstr,__FILE__,__LINE__,(int)Counter++,RpWarning,(int) msec_millisecondCounter,0);
         for (Sensor_i = StartPT100;Sensor_i < MAX_HEAD_CARD_TEMP_SENS_ID;Sensor_i++)
         {
             TemperatureCalc[Sensor_i] =  MillisecCalculateTemperatures ( Sensor_i);
@@ -718,10 +718,10 @@ uint32_t MillisecLowLoop(uint32_t tick)
                 PressureCalc[Disp_i] = MillisecCalculatePressures(Disp_i);
             }
         }
-    Trigger_WHS_PT100_Read_All();
-    Trigger_WHS_MAX11614_Read_allADC();
+        Trigger_WHS_PT100_Read_All();
+        Trigger_WHS_MAX11614_Read_allADC();
 //    WHS_Blower_Avarege_ORF1(); //drier
-    WHS_Blower_Avarege_ORF3(); //head
+        WHS_Blower_Avarege_ORF3(); //head
         Trigger_WHSReadAllFanTacho ();
     }
     if (OneMinute_Tick)
diff --git a/Software/Embedded_SW/Embedded/Modules/Control/control.c b/Software/Embedded_SW/Embedded/Modules/Control/control.c
index 5adf6f83d..a6540bc81 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/control.c
+++ b/Software/Embedded_SW/Embedded/Modules/Control/control.c
@@ -576,8 +576,8 @@ uint32_t ControlLowLoop(uint32_t tick)
     if (tick-prevtick>1)
     {
         skipped_ticks = tick-prevtick-1;
-        if (tick-prevtick>10)
-            Report("ControlLowLoop skipped",__FILE__,tick,(int)prevtick,RpWarning,(int)skipped_ticks,0);
+        //if (tick-prevtick>10)
+         //   Report("ControlLowLoop skipped",__FILE__,tick,(int)prevtick,RpWarning,(int)skipped_ticks,0);
     }
     prevtick = tick;
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
index bb8f5d994..f1538197b 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
@@ -461,7 +461,7 @@ void DiagnosticOneMinuteCollection(void)
 
     for (i=0;i<NUM_OF_CURRENT_HEATERS;i++)
     {
-        if (Read_Head_MixChip_Heaters_Current(i) == true)
+        if (Get_Heater_Current_Reading_State(i) == true)
         {
             HeatersCurrent[i][0] = Get_Heaters_Current(i);
             switch(i)
@@ -542,7 +542,16 @@ void DiagnosticOneSecCollection(void)
         DiagnosticsMonitor.whsblower2voltage = &AcVoltage;
         DiagnosticsMonitor.n_whsblower2voltage = 1;
     }
+    if (WHS_Type == WHS_TYPE_NEW) //rapid/pp machines
+    {
+        DrierFlowMeter = GetWHSAirFlow(DRIER_FLOW_METER);
+        DiagnosticsMonitor.n_dryerairflow = 1;
+        DiagnosticsMonitor.dryerairflow = &DrierFlowMeter;
 
+        HeadFlowMeter = GetWHSAirFlow(HEAD_FLOW_METER);
+        DiagnosticsMonitor.n_headairflow = 1;
+        DiagnosticsMonitor.headairflow = &HeadFlowMeter;
+    }
     if (Head_Type == HEAD_TYPE_SYLKO_WITHOUT_CARD)
     {
         DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__MixerHeater, MillisecGetTemperatures( MIXER_PT100));
@@ -616,7 +625,7 @@ void Diagnostic100msecCollection(void)
             dispenserspressure[i][DiagnosticsIndex] = GetDispenserPressure(i); //Read_MidTank_Pressure_Sensor
         }
     }
-    if (DiagnosticMode == Diagnostic_Extreme_Mode)
+    //if (DiagnosticMode == Diagnostic_Extreme_Mode)
     {
         for (i=0;i<NUM_OF_CURRENT_HEATERS;i++)
         {
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
index 079903a1c..5f7505e24 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
@@ -441,7 +441,7 @@ uint32_t HeatersSingleHeaterEnd(int HeaterId)
             HeaterCmd[HeaterId].targettemperatue = 0;
             HeaterReady[HeaterId] = true;
             HeaterAtTemp[HeaterId] = true;
-            Disable_Reading_Heaters_Current(HeaterId2CurrentId[HeaterId]);
+            //Disable_Reading_Heaters_Current(HeaterId2CurrentId[HeaterId]);
         }
         else if (HeaterId < MAX_AC_HEATERS) //AC Heaters
         {
@@ -1333,7 +1333,7 @@ uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
             //DCInitialHeating[index] = false;
             HeatersControlStart();
             AlarmHandlingSetAlarm(HeaterUnderEventType[index], false);
-            Disable_Reading_Heaters_Current(HeaterId2CurrentId[index]);
+           // Disable_Reading_Heaters_Current(HeaterId2CurrentId[index]);
             HeaterReady[index] = true;
         }
         return OK;
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
index 8e01ee810..04abb6870 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
@@ -519,7 +519,7 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
              if (DispenserUsedInJob[i] == true) //we actually should check for all dispensers
              {
                  HW_Motor_Id = DispenserIdToMotorId[i];
-                 if (GetDispenserPressure(i) > DispenserPreparePressure)
+                 if (GetDispenserPressure(i) > DispenserPreparePressure*1.02)
                  {
                      NumofReadyDispensers++;
                      CurrentDispenserSpeed[i] = 0;
@@ -528,7 +528,7 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
                      //Report("IDS stopped ready",__FILE__,i,(int)(DispenserPreparePressure*100),RpWarning,(int)NumofReadyDispensers,0);
 #else
                      tempSpeed = CurrentDispenserSpeed[i];
-                     updatedSpeed = (tempSpeed*0.985>100)?tempSpeed*0.985:100;
+                     updatedSpeed = (tempSpeed*0.992>100)?tempSpeed*0.992:100;
                      MotorSetSpeed(HW_Motor_Id, updatedSpeed);
                      CurrentDispenserSpeed[i] = updatedSpeed;
                      //Report("IDS reduce speed",__FILE__,i,(int)tempSpeed,RpWarning,(int)updatedSpeed,0);
@@ -543,7 +543,7 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
 #else
                      tempSpeed = CurrentDispenserSpeed[i];
 #endif
-                     updatedSpeed = (tempSpeed*1.02<InitialDispenserSpeed)?tempSpeed*1.02:InitialDispenserSpeed;
+                     updatedSpeed = (tempSpeed*1.03<InitialDispenserSpeed)?tempSpeed*1.03:InitialDispenserSpeed;
                      MotorSetSpeed(HW_Motor_Id, updatedSpeed);
                      CurrentDispenserSpeed[i] = updatedSpeed;
 #ifdef SPECIAL_DISPENSERS
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
index f87aa2eda..e968717e3 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
@@ -587,7 +587,25 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
         response.has_progress = true;
 
     }
+    else
+    if(request->amount == 0xC3)  //suspend I2C task
+    {
+        if (request->delay == 0)
+        {
+            LOG_ERROR(request->delay,"Suspend I2C");
+            PowerOffHeatersOff();
+            Task_sleep(1000);
+            Task_setPri (I2C_Task_Handle,-1);
+        }
+        else
+        {
+            LOG_ERROR(request->delay,"Resume");
+            Task_setPri (I2C_Task_Handle,8);
+        }
+        response.progress = request->delay;
+        response.has_progress = true;
 
+    }
     else     
 	if((request->amount == 0xDF) && (request->delay == 0xDF)) //Power off
     {
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
index aa090625c..4ab59ec19 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
@@ -180,6 +180,14 @@
         ProcessParametersClear.headzone4temp  = 0;
         ProcessParametersClear.headzone5temp  = 0;
         ProcessParametersClear.headzone6temp  = 0;
+        ProcessParametersClear.headzone7temp  = 0;
+        ProcessParametersClear.headzone8temp  = 0;
+        ProcessParametersClear.headzone9temp  = 0;
+        ProcessParametersClear.headzone10temp  = 0;
+        ProcessParametersClear.headzone11temp  = 0;
+        ProcessParametersClear.headzone12temp  = 0;
+        ProcessParametersClear.stspzone1temp  = 0;
+        ProcessParametersClear.stspzone2temp  = 0;
         ProcessParametersClear.dyeingspeed = 40;
         ProcessParametersClear.dryerbufferlength = ProcessParametersKeep.dryerbufferlength;
         if (HandleProcessParameters(&ProcessParametersClear,false)!= OK)
diff --git a/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerOffSequence.c b/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerOffSequence.c
index 0d45b8477..5cc94a909 100644
--- a/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerOffSequence.c
+++ b/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerOffSequence.c
@@ -250,6 +250,8 @@ uint32_t PowerOffHeatersOff(void)
     ProcessParametersClear.headzone10temp  = 0;
     ProcessParametersClear.headzone11temp  = 0;
     ProcessParametersClear.headzone12temp  = 0;
+    ProcessParametersClear.stspzone1temp  = 0;
+    ProcessParametersClear.stspzone2temp  = 0;
     ProcessParametersClear.dyeingspeed = 40;
     if (HandleProcessParameters(&ProcessParametersClear,false)!= OK)
     {