merge conflicts

17 files changed, 199 insertions, 127 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 c48538752..60707d0cb 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,32};
+TangoVersion_t _gTangoVersion = {1,4,6,33};
 #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/Dispenser_Card/EEPROM/Dispenser_EEPROM.c b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Dispenser_Card/EEPROM/Dispenser_EEPROM.c
index ffbbf6608..9ae12d0b4 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Dispenser_Card/EEPROM/Dispenser_EEPROM.c
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Dispenser_Card/EEPROM/Dispenser_EEPROM.c
@@ -427,7 +427,7 @@ uint32_t StubDispenserEEpromRequestFunc(MessageContainer* requestContainer)
     MessageContainer responseContainer;
 
     uint32_t status = OK;
-    StubDispenserEEpromData *DispenserEEpromInstance;
+    StubDispenserEEpromData *DispenserEEpromInstance = NULL;
     Report("StubDispenserEEpromRequestFunc",__FILE__,__LINE__,request->dispenserid,RpWarning,(int)request->burnrequest,0);
 
     if (request->burnrequest == true)
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/IO_Ports/Heaters/Head_Heaters.c b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/IO_Ports/Heaters/Head_Heaters.c
index 0cc1db9f6..e4f7f81ad 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/IO_Ports/Heaters/Head_Heaters.c
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/IO_Ports/Heaters/Head_Heaters.c
@@ -64,6 +64,8 @@ uint32_t Write_Head_Card_Heaters_Commands()
     }
     else
         Report(" Write_Head_Card_Heaters",__FILE__,__LINE__,255,RpWarning,0,0);
+    if (status)
+        ReadFailures++;
    return status;
 }
 
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/PT100/Head_PT100_ADC.c b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/PT100/Head_PT100_ADC.c
index 35d0a0b1e..108676b47 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/PT100/Head_PT100_ADC.c
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/PT100/Head_PT100_ADC.c
@@ -22,6 +22,10 @@ ADDR 0x8E
 #include "modules/control/millisecTask.h"
 #include "Modules/AlarmHandling/AlarmHandling.h"
 #include "drivers/Heater/TemperatureSensor.h"
+
+#include "PMR/Diagnostics/EventType.pb-c.h"
+//#include "StateMachines/Initialization/InitSequence.h"
+
 //#include "PT100RTD.h"
 
 #include "../I2C_Head_Mux.h"
@@ -92,8 +96,8 @@ uint32_t I2C_Write_SensorId(uint32_t I2C_ID, TEMPERATURE_SENSOR_ID_ENUM SensorId
 
     I2C_ADC_ADS122C04_SLAVE_ADD = SensorId_To_SlaveAdd(SensorId);
     status |= I2C_Write(I2C_ID, I2C_ADC_ADS122C04_SLAVE_ADD, I2C_Write_buf, No_BytesToWrite);
-    if (status)
-        Report("I2C_Write_SensorId error", __FILE__,Arb_Loss_Count,status, RpMessage,SensorId, 0);
+    //if (status)
+    //    ReportWithPackageFilter(LoadFilter,"I2C_Write_SensorId error", __FILE__,Arb_Loss_Count,status, RpMessage,SensorId, 0);
 
     return status;
 }
@@ -126,6 +130,8 @@ uint32_t I2C_Read_SensorId(uint32_t I2C_ID, TEMPERATURE_SENSOR_ID_ENUM SensorId,
     //TODO Choose TEMP1 sensor by I/O
     I2C_ADC_ADS122C04_SLAVE_ADD = SensorId_To_SlaveAdd(SensorId);
     status |= I2C_Read(I2C_ID, I2C_ADC_ADS122C04_SLAVE_ADD + 1, I2C_Read_buf, No_BytesToRead);
+    //if (status)
+    //    ReportWithPackageFilter(LoadFilter,"I2C_Read_SensorId error", __FILE__,Arb_Loss_Count,status, RpMessage,SensorId, 0);
 
     return status;
 }
@@ -210,8 +216,8 @@ uint32_t HeadADCPT100_SendReadDataCommand(TEMPERATURE_SENSOR_ID_ENUM SensorId)
     //delayms(10);
 
     Status |= I2C_Read_SensorId(I2C_ID_HEAD_CARD, SensorId, temp, 3);
-    if (Status)
-        Report("HeadADCPT100_SendReadDataCommand error", __FILE__,Arb_Loss_Count,Status, RpMessage,SensorId, 0);
+    //if (Status)
+    //    ReportWithPackageFilter(LoadFilter,"HeadADCPT100_SendReadDataCommand error", __FILE__,Arb_Loss_Count,Status, RpMessage,SensorId, 0);
 
     //First send the MSB so we need to reorder the bytes
     Data_ADC_Head = temp[0];
@@ -852,7 +858,7 @@ uint32_t Get_HeadCard_PT100(TEMPERATURE_SENSOR_ID_ENUM SensorId)
     return TempSensorResponse[SensorId].Temperature_C_mult_by_100;
 }
 
-uint16_t ReadCalls = 0;ReadFailures = 0;
+uint16_t ReadCalls = 0, ReadFailures = 0, ReadResets = 0;
 bool I2C_Failure = false;
 #define I2C_FAILURES_PERIOD 100
 #define I2C_FAILURES_LIMIT 30
@@ -884,10 +890,15 @@ uint32_t Set_HeadCard_PT100() //call every 50mSec (minimum delay 30mSec)
         ReadFailures++;
         if(ReadFailures>I2C_FAILURES_LIMIT) //30 failures in 10 seconds
         {
+            ReadResets++;
             //I2C_Failure = true;
-            ReportWithPackageFilter(HeatersFilter,"Head I2C interface failure ",__FILE__,__LINE__,ReadFailures,RpError, ReadCalls,0);
-            //SetMachineState(MACHINE_STATE_BUILT_IN_FAILED);
-            //AlarmHandlingSetAlarm(EVENT_TYPE__POWER_UP_BIT_FAILURE,true);
+            ReportWithPackageFilter(HeatersFilter,"Head I2C interface failure ",__FILE__,ReadResets,ReadFailures,RpError, ReadCalls,0);
+            if (ReadResets > 50)
+            {
+                Report("Head malfunctioning, shut down",__FILE__,ReadResets,ReadFailures,RpError, ReadCalls,0);
+                //SetMachineState(MACHINE_STATE_BUILT_IN_FAILED);
+                AlarmHandlingSetAlarm(EVENT_TYPE__POWER_UP_BIT_FAILURE,true);
+            }
         }
     }
     return Status;
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C.c b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C.c
index b5790b6a2..a9f037942 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C.c
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C.c
@@ -17,6 +17,7 @@
 #include "driverlib/sysctl.h"
 #include "driverlib/i2c.h"
 #include "I2C.h"
+#include "i2c_fifo.h"
 
 #define I2C_DELAY 3000
 uint8_t Main_Mux_Flag = UNKNOWN;
@@ -69,6 +70,8 @@ void Configuring_Master_I2C2(/*uint32_t ui32SysClock*/)
     #else
         I2CMasterInitExpClk(I2C2_BASE, ui32SysClock, false);//The last parameter sets the I2C data transfer rate: false for 100kbps and true for 400kbps
     #endif
+
+    i2c_fifo_setup(I2C2_BASE);
 }
 
 //--------------------------------------------------------------
@@ -122,6 +125,7 @@ void Configuring_Master_I2C3(/*uint32_t ui32SysClock*/)
         I2CMasterInitExpClk(I2C3_BASE, ui32SysClock, false);//The last parameter sets the I2C data transfer rate: false for 100kbps and true for 400kbps
     #endif
 
+    i2c_fifo_setup(I2C3_BASE);
 }
 
 
@@ -175,6 +179,7 @@ void Configuring_Master_I2C4(/*uint32_t ui32SysClock*/)
         I2CMasterInitExpClk(I2C4_BASE, ui32SysClock, false);//The last parameter sets the I2C data transfer rate: false for 100kbps and true for 400kbps
     #endif
 
+    i2c_fifo_setup(I2C4_BASE);
 }
 
 void Init_All_I2C()
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C.h b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C.h
index d8b2d1286..ed4c1228f 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C.h
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C.h
@@ -17,6 +17,8 @@ uint32_t I2C_control(uint32_t I2C_ID, uint32_t Slave_Add, bool RW,uint32_t Byte2
 void Init_All_I2C();
 void I2C_ReadingTask_Init(void);
 
+extern uint16_t ReadFailures;
+
 //-------------------------------------------------------------------------------------------------------------
 
 //uint32_t I2C_Write(uint32_t I2C_ID, uint32_t Slave_Add, uint32_t No_BytesTWrite, uint32_t *Bytes2Write );
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 79c986978..ab05c92a9 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C_Comm.c
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C_Comm.c
@@ -19,7 +19,7 @@
 #include "driverlib/sysctl.h"
 #include "driverlib/i2c.h"
 #include "inc/hw_i2c.h"
-
+#include "i2c_fifo.h"
 #include "i2c.h"
 
 
@@ -179,9 +179,8 @@ uint32_t I2C_ReadBuff(uint32_t I2C_BASE, unsigned char addr, unsigned char* data
 
 uint32_t I2C_Write(uint32_t I2C_ID, uint32_t Slave_Add, uint32_t *I2C_Write_buf, uint32_t No_BytesToWrite )
 {
-
     uint32_t status = OK;
-
+    uint8_t* buff = (uint8_t *)I2C_Write_buf;
     uint32_t I2C_BASE;
 
     if (I2C_ID == 4)
@@ -208,14 +207,11 @@ uint32_t I2C_Write(uint32_t I2C_ID, uint32_t Slave_Add, uint32_t *I2C_Write_buf,
 
     //Byte2Write = Byte2Write & 0xFF;
 
-//    if(No_BytesTWrite == 1)
-//    {
-//        status = Write_Single_I2C(I2C_BASE, Slave_Add,Bytes2Write[0] & 0xFF);
-//    }
-//    else
-//    {
-//
-//    }
+    /*if(No_BytesToWrite <= 2) {
+        status = I2C_WriteBuff(I2C_BASE, Slave_Add, I2C_Write_buf, No_BytesToWrite);
+    } else {
+        status = I2C_WriteFifo(I2C_BASE, Slave_Add, buff, No_BytesToWrite);
+    }*/
 
     //uint32_t I2C_W_buf[256] = {0},i;
 
@@ -249,7 +245,7 @@ uint32_t I2C_Read(uint32_t I2C_ID, uint32_t Slave_Add, uint32_t *I2C_Read_buf, u
 {
 
     uint32_t status = OK;
-
+    uint8_t* buff = (uint8_t *)I2C_Read_buf;
     uint32_t I2C_BASE;
 
     if (I2C_ID == 4)
@@ -276,24 +272,8 @@ uint32_t I2C_Read(uint32_t I2C_ID, uint32_t Slave_Add, uint32_t *I2C_Read_buf, u
 
     //Byte2Write = Byte2Write & 0xFF;
 
-//    if(No_BytesTWrite == 1)
-//    {
-//        status = Write_Single_I2C(I2C_BASE, Slave_Add,Bytes2Write[0] & 0xFF);
-//    }
-//    else
-//    {
-//
-//    }
-
-    //uint32_t I2C_W_buf[256] = {0},i;
-
-//   for(i = 0; i < request->n_bytestwrite;i++)
-//   {
-//    I2C_W_buf[i] = request->bytestwrite[i];
-//   }
-
-    //status = I2C_WriteBuff(I2C_BASE, Slave_Add, Bytes2Write, No_BytesTWrite);
     status = I2C_ReadBuff(I2C_BASE, Slave_Add, I2C_Read_buf, No_BytesToRead);
+    //status = I2C_ReadFifo(I2C_BASE, Slave_Add, buff, No_BytesToRead);
     if (status)
     {
         if (Arb_Loss_Count++ > 10)
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C_FIFO.c b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C_FIFO.c
index ce69fdb93..b72e23576 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C_FIFO.c
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C_FIFO.c
@@ -20,7 +20,7 @@
 #include "driverlib/i2c.h"
 
 #define MAX_FIFO_BURST 8
-
+#define I2C_BUSY_DELAY 5000
 ///
 /**
  * Flushes I2C fifos
@@ -36,13 +36,25 @@ void i2c_flush(uint32_t base){
  * @param base Base address of I2C transceiver
  * @param highspeed True if 400kbit, else 100kbit
  */
-void i2c_setup(uint32_t base, bool highspeed){
-    //I2CMasterInitExpClk(base, g_syshz, highspeed);
-    I2CTxFIFOConfigSet(base, I2C_FIFO_CFG_TX_MASTER);
-    I2CRxFIFOConfigSet(base, I2C_FIFO_CFG_RX_MASTER);
+void i2c_fifo_setup(uint32_t base) {
+    I2CTxFIFOConfigSet(base, I2C_FIFO_CFG_TX_MASTER | I2C_FIFO_CFG_TX_TRIG_3);
+    I2CRxFIFOConfigSet(base, I2C_FIFO_CFG_RX_MASTER | I2C_FIFO_CFG_RX_TRIG_2);
+    I2CMasterGlitchFilterConfigSet(base, I2C_MASTER_GLITCH_FILTER_8);
     i2c_flush(base);
 }
 
+uint32_t I2C_BusyWithTimeout(uint32_t base)
+{
+    uint32_t count = 0;
+    while(I2CMasterBusy(base) && (count++ < 10)) {
+        SysCtlDelay(I2C_BUSY_DELAY);
+        if(count > 10) {
+            return I2C_MASTER_ERR_CLK_TOUT;
+        }
+    }
+    return 0;
+}
+
 /**
  * Writes array over I2C to address given
  * @param base Base address of I2C transceiver
@@ -51,12 +63,11 @@ void i2c_setup(uint32_t base, bool highspeed){
  * @param len Length of data
  * @return 0 if success, else value of I2CMasterErr
  */
-uint32_t I2C_WriteFifo(uint32_t base, uint8_t addr, void *data, size_t len){
-    size_t offset = 0;
-    size_t len_mod = len % MAX_FIFO_BURST;
-    size_t final_burst = (len_mod !=0 )? len_mod : MAX_FIFO_BURST;
-    uint32_t err;
-    size_t i = 0;
+uint32_t I2C_WriteFifo(uint32_t base, uint8_t addr, uint8_t *data, uint32_t len){
+    uint32_t offset = 0;
+    uint32_t len_mod = len % MAX_FIFO_BURST;
+    uint32_t final_burst = (len_mod !=0 )? len_mod : MAX_FIFO_BURST;
+    uint32_t i, err;
 
     // Send configuration to INA219 config register
     I2CMasterSlaveAddrSet(base, addr, false);
@@ -64,85 +75,66 @@ uint32_t I2C_WriteFifo(uint32_t base, uint8_t addr, void *data, size_t len){
     for(offset = 0; offset < (len-1)/MAX_FIFO_BURST; offset++){
         I2CMasterBurstLengthSet(base, MAX_FIFO_BURST);
         for(i = 0; i < MAX_FIFO_BURST; ++i){
-            I2CFIFODataPut(base, ((uint8_t *)data)[offset*MAX_FIFO_BURST+i]);
+            I2CFIFODataPutNonBlocking(base, *data++);
         }
         if( 0 == offset){
             I2CMasterControl(base, I2C_MASTER_CMD_FIFO_BURST_SEND_START);
         }else{
             I2CMasterControl(base, I2C_MASTER_CMD_FIFO_BURST_SEND_CONT);
         }
-        err = I2CMasterErr(base);
-        if(err != I2C_MASTER_ERR_NONE){
-            goto error;
-        }
     }
     I2CMasterBurstLengthSet(base, final_burst);
     for(i = 0; i < final_burst; ++i){
-        I2CFIFODataPut(base, ((uint8_t *)data)[offset*MAX_FIFO_BURST+i]);
+        I2CFIFODataPutNonBlocking(base, *data++);
     }
     if(len <= MAX_FIFO_BURST){
         I2CMasterControl(base, I2C_MASTER_CMD_FIFO_SINGLE_SEND);
     }else{
         I2CMasterControl(base, I2C_MASTER_CMD_FIFO_BURST_SEND_FINISH);
     }
-    err = I2CMasterErr(base);
-    if(err != I2C_MASTER_ERR_NONE){
-        goto error;
+    if((err = I2C_BusyWithTimeout(base)) != 0) {
+        return err;
+    } else {
+        err = I2CMasterErr(base);
     }
-    while(I2CMasterBusy(base));
-    return 0;
-error:
     return err;
 }
 
-/**
- * Reads array over I2C from address given
- * @param base Base address of I2C transceiver
- * @param addr Address of I2C device to read from
- * @param data Data to read
- * @param len Length of data
- * @return 0 if success, else value of I2CMasterErr
- */
-uint32_t I2C_ReadFifo(uint32_t base, uint8_t addr, void *data, size_t len){
-    size_t offset = 0;
-    size_t len_mod = len % MAX_FIFO_BURST;
-    size_t final_burst = (len_mod !=0 )? len_mod : MAX_FIFO_BURST;
-    uint32_t err;
-    size_t i = 0;
+uint32_t I2C_ReadFifo(uint32_t base, uint8_t addr, uint8_t *data, uint32_t len) {
+    uint32_t len_mod = len % MAX_FIFO_BURST;
+    uint32_t final_burst = (len_mod !=0 )? len_mod : MAX_FIFO_BURST;
+    uint32_t i, offset, err;
 
     // Send configuration to INA219 config register
+    I2CRxFIFOFlush(base);
     I2CMasterSlaveAddrSet(base, addr, true);
-
-    for(offset = 0; offset < (len-1)/MAX_FIFO_BURST; offset++){
+    for(offset = 0; offset < len/MAX_FIFO_BURST; offset++) {
         I2CMasterBurstLengthSet(base, MAX_FIFO_BURST);
-        for(i = 0; i < MAX_FIFO_BURST; ++i){
-            ((uint8_t *)data)[offset*MAX_FIFO_BURST+i] = I2CFIFODataGet(base);
-        }
-        if(0 == offset){
+
+        if(0 == offset) {
             I2CMasterControl(base, I2C_MASTER_CMD_FIFO_BURST_RECEIVE_START);
-        }else{
+        } else {
             I2CMasterControl(base, I2C_MASTER_CMD_FIFO_BURST_RECEIVE_CONT);
         }
-        err = I2CMasterErr(base);
-        if(err != I2C_MASTER_ERR_NONE){
-            goto error;
+        if((err = I2C_BusyWithTimeout(base)) != 0)
+            return err;
+        for(i = 0; i < MAX_FIFO_BURST; ++i) {
+            I2CFIFODataGetNonBlocking(base, data++);
         }
     }
+
     I2CMasterBurstLengthSet(base, final_burst);
-    for(i = 0; i < final_burst; ++i){
-        ((uint8_t *)data)[offset*MAX_FIFO_BURST+i] = I2CFIFODataGet(base);
-    }
     if(len <= MAX_FIFO_BURST){
         I2CMasterControl(base, I2C_MASTER_CMD_FIFO_SINGLE_RECEIVE);
-    }else{
+    } else {
         I2CMasterControl(base, I2C_MASTER_CMD_FIFO_BURST_RECEIVE_FINISH);
     }
-    err = I2CMasterErr(base);
-    if(err != I2C_MASTER_ERR_NONE){
-        goto error;
+    if((err = I2C_BusyWithTimeout(base)) != 0)
+        return err;
+    for(i = 0; i < final_burst; ++i) {
+        I2CFIFODataGetNonBlocking(base, data++);
     }
-    return 0;
-error:
+    err = I2CMasterErr(base);
     return err;
 }
 
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C_FIFO.h b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C_FIFO.h
index 2e2ccc37a..6ff5b5ce6 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C_FIFO.h
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C_FIFO.h
@@ -8,10 +8,9 @@
 #ifndef DRIVERS_I2C_COMMUNICATION_I2C_FIFO_H_
 #define DRIVERS_I2C_COMMUNICATION_I2C_FIFO_H_
 
-void i2c_setup(uint32_t base, bool highspeed);
-uint32_t I2C_ReadFifo(uint32_t base, uint8_t addr, void *data, size_t len);
-uint32_t I2C_WriteFifo(uint32_t base, uint8_t addr, void *data, size_t len);
-
-
+void i2c_fifo_setup(uint32_t base);
+uint32_t I2C_ReadFifo(uint32_t base, uint32_t addr, uint8_t *data, uint32_t len);
+uint32_t I2C_WriteFifo(uint32_t base, uint32_t addr, uint8_t *data, uint32_t len);
+uint32_t I2C_BusyWithTimeout(uint32_t base);
 
 #endif /* DRIVERS_I2C_COMMUNICATION_I2C_FIFO_H_ */
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 7590113c1..c36d27d74 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
@@ -41,9 +41,9 @@ typedef struct
 }WhsControlConfig_t;
 
 WhsControlConfig_t WHS_ControlData = {0};
-#define MAX_WHS_CONTROL_SAMPLES 10
+/*#define MAX_WHS_CONTROL_SAMPLES 10
 float WhsBlowerSamples[MAX_WHS_CONTROL_SAMPLES] ;
-int WhsBlowerSamplesPointer = 0;
+int WhsBlowerSamplesPointer = 0;*/
 
 bool Read_Max5805_device_ID();
 double calc_Q_average(WHS_Flow_Meter ORF_id,double Q_temp);
@@ -236,9 +236,9 @@ bool WHS_init_Blower()
     WHS_ControlData.m_preError = 0;
     WHS_ControlData.m_SetParam = 5.0;//need to update SetParams on presegment stage
 
-    WHS_ControlData.SamplesFilterSize = MAX_WHS_CONTROL_SAMPLES/2;
+    //WHS_ControlData.SamplesFilterSize = MAX_WHS_CONTROL_SAMPLES/2;
 
-    memset (WhsBlowerSamples,0,sizeof(WhsBlowerSamples));
+    //memset (WhsBlowerSamples,0,sizeof(WhsBlowerSamples));
 
     return status;
 }
@@ -614,7 +614,7 @@ uint32_t WHS_Pid_Testing_Func(double setParam,double measuredParam)
     float avreageSampleValue = 0;
     int i;
 
-    WhsBlowerSamples[WhsBlowerSamplesPointer] = measuredParam;//(-1 * TranslatedReadValue);
+    /*WhsBlowerSamples[WhsBlowerSamplesPointer] = measuredParam;//(-1 * TranslatedReadValue);
     WhsBlowerSamplesPointer++;
     if (WhsBlowerSamplesPointer >= WHS_ControlData.SamplesFilterSize)
         WhsBlowerSamplesPointer = 0;
@@ -622,7 +622,7 @@ uint32_t WHS_Pid_Testing_Func(double setParam,double measuredParam)
         avreageSampleValue += WhsBlowerSamples[i];
     avreageSampleValue = avreageSampleValue / (int)WHS_ControlData.SamplesFilterSize;
 
-    /*WHS_ControlData.m_mesuredParam = avreageSampleValue;*/
+    WHS_ControlData.m_mesuredParam = avreageSampleValue;*/
     WHS_ControlData.m_mesuredParam = measuredParam;
     WHS_ControlData.m_SetParam = setParam;
     WHS_ControlData.m_calculatedError = PIDAlgorithmCalculation((float)WHS_ControlData.m_SetParam , (float)WHS_ControlData.m_mesuredParam,
@@ -687,14 +687,14 @@ uint32_t WHS_PidRequestMessage(void* request)
     WHS_ControlData.m_preError = 0;
     WHS_ControlData.m_SetParam = PID_Request->outputproportionalcycletime;//need to update SetParams on presegment stage
 
-    WHS_ControlData.SamplesFilterSize = PID_Request->pvinputfilterfactormode;
+    /*WHS_ControlData.SamplesFilterSize = PID_Request->pvinputfilterfactormode;
     if (PID_Request->pvinputfilterfactormode > MAX_WHS_CONTROL_SAMPLES)
         WHS_ControlData.SamplesFilterSize = MAX_WHS_CONTROL_SAMPLES;
     if (PID_Request->pvinputfilterfactormode < 0.5) // = 0
         WHS_ControlData.SamplesFilterSize = MAX_WHS_CONTROL_SAMPLES/2;
-
-    memset (WhsBlowerSamples,0,sizeof(WhsBlowerSamples));
-    WhsBlowerSamplesPointer = 0;
+*/
+    //memset (WhsBlowerSamples,0,sizeof(WhsBlowerSamples));
+    //WhsBlowerSamplesPointer = 0;
 
 
     return OK;
diff --git a/Software/Embedded_SW/Embedded/Drivers/Motors/MotorActions.c b/Software/Embedded_SW/Embedded/Drivers/Motors/MotorActions.c
index 0d6cd35c7..b2e623a11 100644
--- a/Software/Embedded_SW/Embedded/Drivers/Motors/MotorActions.c
+++ b/Software/Embedded_SW/Embedded/Drivers/Motors/MotorActions.c
@@ -674,7 +674,7 @@ uint32_t MotorMovetoLimitSwitch (TimerMotors_t MotorId,bool direction, uint32_t
     }
 
     MotorTimeout[MotorId] = 0;
-    MotorTimeLag[MotorId] = eTenMillisecond;
+    MotorTimeLag[MotorId] = 5; //five milliseconds for better accuracy
     MotorTimeLimit[MotorId] = timeout;
 
     if ((MotorId == HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD)||(HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH)||(HARDWARE_MOTOR_TYPE__MOTO_SCREW))
diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
index 8af4720a6..eded4bdce 100644
--- a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
+++ b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
@@ -976,6 +976,13 @@ JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob)
                     AlarmId = Alarm_i;
                     ReportWithPackageFilter(AlarmFilter,"an alarm preventing job", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, AlarmItem[Alarm_i].Severity, AlarmItem[Alarm_i].DeviceId, 0);
                     break;
+                case EVENT_TYPE__ELECTRICAL_CABINET_OVERTEMPERATURE:
+                case EVENT_TYPE__MACHINE_INTERNAL_OVERTEMPERATURE:
+                case EVENT_TYPE__MACHINE_INTERNAL_OVERTEMPERATURE_2:
+                    FoundReason = JOB_TEMPERATURE_ALARM;
+                    AlarmId = Alarm_i;
+                    ReportWithPackageFilter(AlarmFilter,"machine internal over-temperature is preventing job", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, AlarmItem[Alarm_i].Severity, AlarmItem[Alarm_i].DeviceId, 0);
+                    break;
                 default:
                     break;
             }
@@ -1214,7 +1221,7 @@ uint32_t AlarmHandlingLoop(uint32_t tick)
                 }
                 break;
             case ALARM_SOURCE_TYPE__CurrentAlarm:
-                if (CheckCurrentAlarms)
+                if ((CheckCurrentAlarms)&&(getIdleState()==false))
                  {
                     if (AlarmItem[Alarm_i].ModuleDeviceId == 0xFF)
                     {
@@ -1338,7 +1345,7 @@ uint32_t AlarmHandlingLoop(uint32_t tick)
                     break;
                 if (AlarmItem[Alarm_i].Severity == DEBUG_LOG_CATEGORY__Warning)
                     FluidLevelWarning = AlarmItem[Alarm_i].AlarmValue;
-                else if (AlarmItem[Alarm_i].Severity == DEBUG_LOG_CATEGORY__Error)
+                else if ((AlarmItem[Alarm_i].Severity == DEBUG_LOG_CATEGORY__Error)&&(AlarmItem[Alarm_i].AlarmDirection == UNDER_VALUE))
                     FluidLevelError = AlarmItem[Alarm_i].AlarmValue;
                 value = Get_MidTank_Int1000_Sensor(AlarmItem[Alarm_i].DeviceId);
                 if (AlarmItem[Alarm_i].AlarmDirection == OVER_VALUE)
diff --git a/Software/Embedded_SW/Embedded/Modules/General/Safety.c b/Software/Embedded_SW/Embedded/Modules/General/Safety.c
index e8454370c..400b083e4 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/Safety.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/Safety.c
@@ -65,7 +65,46 @@ uint32_t Safety_Main_State(uint32_t IfIndex, uint32_t BusyFlag)
 
    if (AllDispensersInSafety)
    {
-       if (Get_COVER_1_State(DryerDoor))
+       if (WHS_GPI_SW_FILTER_PRES())
+       {
+           //report and handle filter missing
+           AlarmHandlingSetAlarm(EVENT_TYPE__AIR_FILTER_NOT_INSTALLED, true);
+           mAirFilterAlarmState = true;
+           AirFilterAlarmState = true;
+       }
+       else
+       {
+           if (WHS_GPI_WASTE_FLOW_SWITCH() == false)
+           {
+               //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
+           {
+               if (Get_COVER_1_State(DryerDoor))
+               {
+                   //report and handle dryer door open
+                   AlarmHandlingSetAlarm(EVENT_TYPE__DRYER_DOOR_OPEN, true);
+                   mDrierDoorAlarmState = true;
+                   DrierDoorAlarmState = true;
+               }
+               else
+               {
+                   //if (WHS_GPI_WASTE_OVERFULL()) - cannot read this switch
+                   {
+                       //report and handle waste overflow
+                       AlarmHandlingSetAlarm(EVENT_TYPE__WASTE_CONTAINER_OVERFLOW, true);
+                       mWasteOverflowAlarmState = true;
+                       WasteOverflowAlarmState = true;
+                   }
+               }
+           }
+       }
+
+/*     if (Get_COVER_1_State(DryerDoor))
        {
            //report and handle dryer door open
            AlarmHandlingSetAlarm(EVENT_TYPE__DRYER_DOOR_OPEN, true);
@@ -103,6 +142,7 @@ uint32_t Safety_Main_State(uint32_t IfIndex, uint32_t BusyFlag)
                }
            }
        }
+       */
    }
    else if (AnyDispensersInSafety)
    {
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
index b796cae50..0e3bf95a4 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
@@ -106,6 +106,11 @@ uint32_t InternalWindingConfigMessage(JobSpool* request)
     InternalWinderCfg.segmentoffsetpulses = request->segmentoffsetpulses;
     InternalWinderCfg.spoolbackingrate = request->backingrate;
     InternalWinderCfg.startoffsetpulses = request->startoffsetpulses;
+    if (request->has_limitswitchstartpointoffset)
+    {
+        InternalWinderCfg.startoffsetpulses += request->limitswitchstartpointoffset;
+        Report("limit switch start point offset",__FILE__,__LINE__,(int)(request->startoffsetpulses),RpWarning,(int)(request->limitswitchstartpointoffset), 0);
+    }
     InternalWinderCfg.SpoolBottomBackingRate =  request->bottombackingrate;
     InternalWinderCfg.NumberOfRotationPerPassage = 3.1415926*3;//request->rotationsperpassage;
     if (request->rotationsperpassage > 6.1)
@@ -543,7 +548,7 @@ uint32_t WinderDistanceToSpoolEnded(uint32_t deviceID, uint32_t ReadValue)
 }
 uint32_t ScrewDTSCallback(uint32_t deviceID, uint32_t BusyFlag)
 {
-    REPORT_MSG ((int)msec_millisecondCounter,"ScrewDTSCallback called");
+    Report("ScrewDTSCallback called", __FILE__,__LINE__,msec_millisecondCounter, RpMessage, ScrewSpeed, 0);
     SafeRemoveControlCallback(ScrewDTSControlId, ScrewDTSCallback);
 
     if (ScrewControlId != 0xFF)
@@ -566,7 +571,7 @@ uint32_t WinderDistanceToSpoolState(void )
     REPORT_MSG ((int)DTS_Time,"WinderDistanceToSpoolState");
 
     ScrewDTSControlId = AddControlCallback("screw DTS",ScrewDTSCallback, DTS_Time-WinderBackToBaseTime,TemplateDataReadCBFunction,0,0,0);
-    REPORT_MSG ((int)msec_millisecondCounter,"ScrewDTSCallback start");
+    Report("ScrewDTSCallback start", __FILE__,DTS_Time,msec_millisecondCounter, RpMessage, WinderBackToBaseTime, 0);
 
     return OK;
 }
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
index e7a333cc2..21211481e 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
@@ -794,16 +794,6 @@ uint32_t ThreadInitialTestStub(HardwareMotor * request)
 }
 uint32_t HandleJobThreadControlParameters(ThreadParameters* ThreadParams)
 {
-    /*
-         FEEDER_MOTOR,
-    DRYER_MOTOR,
-    POOLER_MOTOR,
-    WINDER_MOTOR,
-    MotorControlConfig[Motor_i].m_params.Kd = MotorsControl[Pid_Id].derivativetime;
-    MotorControlConfig[Motor_i].m_params.Kp = MotorsControl[Pid_Id].proportionalgain;
-    MotorControlConfig[Motor_i].m_params.Ki = MotorsControl[Pid_Id].integraltime;
-
-     */
     if (ThreadParams == NULL)
     {
         return OK;
@@ -828,6 +818,7 @@ uint32_t HandleJobThreadControlParameters(ThreadParameters* ThreadParams)
         MotorControlConfig[WINDER_MOTOR].m_params.Ki = ThreadParams->winderi;
     if(ThreadParams->winderd)
         MotorControlConfig[WINDER_MOTOR].m_params.Kd = ThreadParams->winderd;
+    ReportWithPackageFilter(ThreadFilter,"Rockers activity",__FILE__,__LINE__,(int)Thread_Rockers_Bypass,RpWarning,(int)ThreadParams->bypassrockers,0);
     if(ThreadParams->bypassrockers)
         Thread_Rockers_Bypass = true;
 
@@ -850,14 +841,20 @@ uint32_t Release_Right_TFU_Tension()
     {
         Report("Release_Right_TFU_Tension",__FILE__,__LINE__,HARDWARE_MOTOR_TYPE__MOTO_RDANCER,RpMessage,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDANCER].pulseperround/4,0);
         RTFU_Up = false;
-        status = MotorMoveWithCallback(HARDWARE_MOTOR_TYPE__MOTO_RDANCER, MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDANCER].directionthreadwize, MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDANCER].pulseperround/2, Release_Right_TFU_TensionCallback,1000);
+        status = MotorMoveWithCallback(HARDWARE_MOTOR_TYPE__MOTO_RDANCER, MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDANCER].directionthreadwize, MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDANCER].pulseperround/4* MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDANCER].microstep, Release_Right_TFU_TensionCallback,1000);
     }
 
     return status;
 }
+uint32_t Adjust_Right_TFU_Tension_2nd_Callback(uint32_t MotorId, uint32_t ReadValue)
+{
+    Report("Adjust_Right_TFU_Tension_2ndCallback 4 more steps",__FILE__,__LINE__,MotorId,RpMessage,0,0);
+    return OK;
+}
 uint32_t Adjust_Right_TFU_Tension_Callback(uint32_t MotorId, uint32_t ReadValue)
 {
     Report("Adjust_Right_TFU_Tension_Callback",__FILE__,__LINE__,MotorId,RpMessage,0,0);
+    MotorMoveWithCallback(HARDWARE_MOTOR_TYPE__MOTO_RDANCER, 1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDANCER].directionthreadwize,4* MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDANCER].microstep, Release_Right_TFU_TensionCallback,1000);
     RTFU_Up = true;
     return OK;
 }
diff --git a/Software/Embedded_SW/Embedded/Software Release Notes.txt b/Software/Embedded_SW/Embedded/Software Release Notes.txt
index ac4f813eb..b53a7016f 100644
--- a/Software/Embedded_SW/Embedded/Software Release Notes.txt
+++ b/Software/Embedded_SW/Embedded/Software Release Notes.txt
@@ -1,3 +1,33 @@
+Embedded SW Release note - Version 1.4.6.33 - Pack 2+
+=============================================================
+remove logs from I2C errors - show only summary.
+stop job, prevent job on internal heating.
+remove current alarm on entering idle.
+motor go to switch - improve accuracy.
+handle machine specific spool offset.
+add additional 4 steps for the RTFU raising in RML feeder tension.
+fix midtank warning bug (these alarm went missing).
+fix safety handling.
+
+I2C FIFO in code (not active yet).
+
+Embedded SW Release note - Version 1.4.6.32 - Pack 2+
+=============================================================
+remove file system semaphore protection.
+new paramete for motors for powerstep drivers.
+preparation for dispensers test (compilation flag).
+fix dispenser new pressure sensor reading.
+whs pid fixing, minimum and maximum limits, alarms.
+prevent job on VOC / air flow alarms
+dancers motors homing - update (clear) EEPROM
+skip HW Config storing if there is no change
+minimal fill-up level for new midtankks - 0.5 litres
+test for dancers PID on more than 1 millisecond - set by controloutputtype
+thread movement waits for LTFU tension preparation
+prevent job on missing spool - PP machines
+
+
+
 Embedded SW Release note - Version 1.4.6.31 - Pack 2+
 =============================================================
 fix bug in SW update - 											test many short jobs.
diff --git a/Software/Embedded_SW/Embedded/StateMachines/Initialization/InitSequence.c b/Software/Embedded_SW/Embedded/StateMachines/Initialization/InitSequence.c
index ced5e2677..629804170 100644
--- a/Software/Embedded_SW/Embedded/StateMachines/Initialization/InitSequence.c
+++ b/Software/Embedded_SW/Embedded/StateMachines/Initialization/InitSequence.c
@@ -417,6 +417,8 @@ uint32_t InitSequenceInitialBlowerActivation(void)
     {
         Control_Voltage_To_Blower(1); //stop the blower
         Task_sleep (1000);
+        Trigger_WHS_MAX11614_Read_allADC();
+        Task_sleep (10);
         if (ResetReason  & SYSCTL_CAUSE_POR)
         {
             for (i=0;i<8;i++)