Add head heaters + PT100 to I2C task + add semaphores to head PT100 ADC

18 files changed, 142 insertions, 38 deletions

diff --git a/Software/Embedded_SW/Embedded/.cproject b/Software/Embedded_SW/Embedded/.cproject
index 454152802..d1239ce44 100644
--- a/Software/Embedded_SW/Embedded/.cproject
+++ b/Software/Embedded_SW/Embedded/.cproject
@@ -34,7 +34,7 @@
 							</option>
 							<option id="com.ti.ccstudio.buildDefinitions.core.OPT_CODEGEN_VERSION.1146150501" name="Compiler version" superClass="com.ti.ccstudio.buildDefinitions.core.OPT_CODEGEN_VERSION" value="16.9.2.LTS" valueType="string"/>
 							<targetPlatform id="com.ti.ccstudio.buildDefinitions.TMS470_16.9.exe.targetPlatformDebug.2027292704" name="Platform" superClass="com.ti.ccstudio.buildDefinitions.TMS470_16.9.exe.targetPlatformDebug"/>
-							<builder buildPath="${BuildDirectory}" id="com.ti.ccstudio.buildDefinitions.TMS470_16.9.exe.builderDebug.511066236" keepEnvironmentInBuildfile="false" name="GNU Make" parallelBuildOn="true" parallelizationNumber="optimal" stopOnErr="true" superClass="com.ti.ccstudio.buildDefinitions.TMS470_16.9.exe.builderDebug"/>
+							<builder buildPath="${BuildDirectory}" enableAutoBuild="false" id="com.ti.ccstudio.buildDefinitions.TMS470_16.9.exe.builderDebug.511066236" keepEnvironmentInBuildfile="false" name="GNU Make" parallelBuildOn="true" parallelizationNumber="optimal" stopOnErr="true" superClass="com.ti.ccstudio.buildDefinitions.TMS470_16.9.exe.builderDebug"/>
 							<tool id="com.ti.ccstudio.buildDefinitions.TMS470_16.9.exe.compilerDebug.1552867542" name="ARM Compiler" superClass="com.ti.ccstudio.buildDefinitions.TMS470_16.9.exe.compilerDebug">
 								<option id="com.ti.ccstudio.buildDefinitions.TMS470_16.9.compilerID.SILICON_VERSION.2092431293" name="Target processor version (--silicon_version, -mv)" superClass="com.ti.ccstudio.buildDefinitions.TMS470_16.9.compilerID.SILICON_VERSION" value="com.ti.ccstudio.buildDefinitions.TMS470_16.9.compilerID.SILICON_VERSION.7M4" valueType="enumerated"/>
 								<option id="com.ti.ccstudio.buildDefinitions.TMS470_16.9.compilerID.CODE_STATE.290630393" name="Designate code state, 16-bit (thumb) or 32-bit (--code_state)" superClass="com.ti.ccstudio.buildDefinitions.TMS470_16.9.compilerID.CODE_STATE" value="com.ti.ccstudio.buildDefinitions.TMS470_16.9.compilerID.CODE_STATE.16" valueType="enumerated"/>
diff --git a/Software/Embedded_SW/Embedded/.project b/Software/Embedded_SW/Embedded/.project
index ad9721244..36cdbe8e6 100644
--- a/Software/Embedded_SW/Embedded/.project
+++ b/Software/Embedded_SW/Embedded/.project
@@ -7,6 +7,7 @@
 	<buildSpec>
 		<buildCommand>
 			<name>org.eclipse.cdt.managedbuilder.core.genmakebuilder</name>
+			<triggers>clean,full,incremental,</triggers>
 			<arguments>
 			</arguments>
 		</buildCommand>
diff --git a/Software/Embedded_SW/Embedded/Drivers/ADC_Sampling/ADC_VAC.c b/Software/Embedded_SW/Embedded/Drivers/ADC_Sampling/ADC_VAC.c
index a6ee83ecc..d5f7b6a0e 100644
--- a/Software/Embedded_SW/Embedded/Drivers/ADC_Sampling/ADC_VAC.c
+++ b/Software/Embedded_SW/Embedded/Drivers/ADC_Sampling/ADC_VAC.c
@@ -17,6 +17,7 @@
 #define AcTable_MaxColumn 2
 
 double AcLookUpTable[AcTable_MaxLine][AcTable_MaxColumn] =
+//VAC = 29.5522 * VDC + 3.981;//linear line according to the lookup table
 {
     180.2  , 5.963,
     190.1  , 6.298,
@@ -93,7 +94,7 @@ double ReadVAC()
 
     VSensor = (1.96- (VADC/1000)) * 4.64 + 1.96;
 
-    VAC = VDC2VAC((double)(VSensor));
+    VAC = VDC2VAC(VSensor);
 
     return VAC; //Volts
 }
diff --git a/Software/Embedded_SW/Embedded/Drivers/Heater/Heater.c b/Software/Embedded_SW/Embedded/Drivers/Heater/Heater.c
index c1b6af4bb..12aee6465 100644
--- a/Software/Embedded_SW/Embedded/Drivers/Heater/Heater.c
+++ b/Software/Embedded_SW/Embedded/Drivers/Heater/Heater.c
@@ -107,6 +107,7 @@ uint32_t ActivateHeater (int HeaterId)
     if (HeaterId>HEATER_TYPE__DryerSecondaryHeater)
     {
         HeadCard_Control_Heaters(HeaterTypetoHeadHeater[HeaterId],ON);
+        //Activate_Head_Card_Heaters(HeaterTypetoHeadHeater[HeaterId]);
     }
     else
     {        //F2_CTRL |= portMap[HeaterId].m_pin;
@@ -178,6 +179,7 @@ uint32_t DeActivateHeater (int HeaterId)
     if (HeaterId>HEATER_TYPE__DryerSecondaryHeater)
     {
         HeadCard_Control_Heaters(HeaterTypetoHeadHeater[HeaterId],OFF);
+        //Deactivate_Head_Card_Heaters(HeaterTypetoHeadHeater[HeaterId]);
     }
     else
     {
diff --git a/Software/Embedded_SW/Embedded/Drivers/Heater/TemperatureSensor.c b/Software/Embedded_SW/Embedded/Drivers/Heater/TemperatureSensor.c
index b8d0ab4e3..c5511e745 100644
--- a/Software/Embedded_SW/Embedded/Drivers/Heater/TemperatureSensor.c
+++ b/Software/Embedded_SW/Embedded/Drivers/Heater/TemperatureSensor.c
@@ -190,6 +190,22 @@ int TemperatureListString(char* str)
     //Prepare H1: 78 H2: 111 H3: 137 H4: 135 H5: 144 H6: 75 D1: 120 D2: 167 D3: 158 M: 129
     return len;
 }
+#else
+int TemperatureListString(char* str)
+{
+    int len;
+
+    len = usnprintf(str, 160, "Prepare H1: ,%d, H2: ,%d, H3: ,%d, H4: ,%d, H5: ,%d, H6: ,%d, H7: ,%d, H8: ,%d, H9: ,%d, H10: ,%d, H11: ,%d, H12: ,%d,  M: ,%d, D: ,%d,",
+                    TempSensorResponse[HEAD_PT100_ZONE_1_0X80_0].Temperature_C_mult_by_100/100, TempSensorResponse[HEAD_PT100_ZONE_2_0X80_1].Temperature_C_mult_by_100/100,
+                    TempSensorResponse[HEAD_PT100_ZONE_3_0X82_0].Temperature_C_mult_by_100/100, TempSensorResponse[HEAD_PT100_ZONE_4_0X82_1].Temperature_C_mult_by_100/100,
+                    TempSensorResponse[HEAD_PT100_ZONE_5_0X84_0].Temperature_C_mult_by_100/100, TempSensorResponse[HEAD_PT100_ZONE_6_0X84_1].Temperature_C_mult_by_100/100,
+                    TempSensorResponse[HEAD_PT100_ZONE_7_0X86_0].Temperature_C_mult_by_100/100, TempSensorResponse[HEAD_PT100_ZONE_8_0X86_1].Temperature_C_mult_by_100/100,
+                    TempSensorResponse[HEAD_PT100_ZONE_9_0X88_0].Temperature_C_mult_by_100/100, TempSensorResponse[HEAD_PT100_ZONE_10_0X88_1].Temperature_C_mult_by_100/100,
+                    TempSensorResponse[HEAD_PT100_ZONE_11_0X8A_0].Temperature_C_mult_by_100/100,TempSensorResponse[HEAD_PT100_ZONE_12_0X8A_1].Temperature_C_mult_by_100/100,
+                    TempSensorResponse[HEAD_PT100_MIXER_0X8E_0].Temperature_C_mult_by_100/100,  TempSensorResponse[TEMP_SENSE_ANALOG_DRYER_TEMP1].Temperature_C_mult_by_100/100);
+    //Prepare H1: 78 H2: 111 H3: 137 H4: 135 H5: 144 H6: 75 D1: 120 D2: 167 D3: 158 M: 129
+    return len;
+}
 #endif
 
 
@@ -431,6 +447,7 @@ uint32_t CalculateTemperatures(TEMPERATURE_SENSOR_ID_ENUM SensorId, uint32_t Dat
         Status = Filter_Temparature_Measurement(SensorId, Current_Measurement_C, NoOfAvrSamples);
     #else
         TempSensorResponse[SensorId].Temperature_C_mult_by_100 = Current_Measurement_C;
+
     #endif
 return Current_Measurement_C;
 }
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 fe8a96b32..48b6b7883 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
@@ -363,6 +363,7 @@ double Read_MidTank_Pressure_Sensor(MidTank_t MidTank_ID) //0-7
 
             break;
     }
+    Semaphore_pend(I2C_Sem, BIOS_WAIT_FOREVER);
 
     Status = I2C_ADC_Config(I2C_Slave_Add, Channel);
     SysCtlDelay(1);
@@ -381,6 +382,7 @@ double Read_MidTank_Pressure_Sensor(MidTank_t MidTank_ID) //0-7
     //MidTank_Pressure[MidTank_ID] = Calculate_MidTank_Liquid(VsampleInBits , Factor);//According to Gal (email 28-Aug-19)
 
     MidTank_Pressure[MidTank_ID] = Calc_Calibration_MidTank_Liquid(VsampleInBits, MidTank_ID );
+    Semaphore_post(I2C_Sem);
 
    return MidTank_Pressure[MidTank_ID];
 }
@@ -406,16 +408,25 @@ uint32_t Heaters_Current_Bits[9];//just for debug
 
 void Enable_Reading_Heaters_Current(HEATERS_CURRENT Heater_ID) //0-8
 {
+#ifdef Use_Head_Card
+    return;
+#endif
     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
 {
+#ifdef Use_Head_Card
+    return;
+#endif
     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
 {
+#ifdef Use_Head_Card
+    return;
+#endif
     assert (Heater_ID<NUM_OF_CURRENT_HEATERS);
     return Heaters_Current_Read_Enable[Heater_ID];
 }
@@ -423,6 +434,9 @@ 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;
+#ifdef Use_Head_Card
+    return 0;
+#endif
 
     assert (Heater_ID<NUM_OF_CURRENT_HEATERS);
     if (Heaters_Current_Read_Enable[Heater_ID] == true)
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/ADC/Head_ADC.c b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/ADC/Head_ADC.c
index 954e8b762..f5671d7f6 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/ADC/Head_ADC.c
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/ADC/Head_ADC.c
@@ -156,10 +156,12 @@ uint32_t Head_I2C_ADC_Calc()
 uint32_t Head_I2C_ADC()
 {
     uint32_t Status = OK;
+    Semaphore_pend(I2C_Sem, BIOS_WAIT_FOREVER);
 
     Head_I2C_ADC_Read_ADC_8Bytes(0x50);
     Head_I2C_ADC_Read_ADC_8Bytes(0x54);
     Head_I2C_ADC_Read_ADC_8Bytes(0x56);
+    Semaphore_post(I2C_Sem);
 
     Head_I2C_ADC_Calc();
 
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 d80b829e1..f902277ae 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
@@ -56,9 +56,11 @@ uint32_t Deactivate_Head_Card_Heaters(HEADCARD_HEATERS_ENUM Head_Heater_ID)
 uint32_t Write_Head_Card_Heaters_Commands()
 {
     uint32_t status= OK;
+    Semaphore_pend(I2C_Sem, BIOS_WAIT_FOREVER);
     status = Head_Write_IO_Reg(0x40,LOW_AND_HIGH);
     status = Head_Write_IO_Reg(0x42,LOW);
-    return status;
+    Semaphore_post(I2C_Sem);
+   return status;
 }
 
 bool Get_HeadCard_Heater_State(uint8_t Heater_ID)
@@ -81,87 +83,87 @@ uint32_t HeadCard_Control_Heaters(HEADCARD_HEATERS_ENUM Heater_ID, bool Pwr_Cmd)
     {
         case HEADCARD_HIT_ZN1:
                 Head_I2C_EXP1_0x40.bits.OUTPUT_SWON_ZN1  = Pwr_Cmd;
-                status |= Head_Write_IO_Reg(0x40,LOW);
+                //status |= Head_Write_IO_Reg(0x40,LOW);
             break;
         case HEADCARD_HIT_ZN2:
                 Head_I2C_EXP1_0x40.bits.OUTPUT_SWON_ZN2  = Pwr_Cmd;
-                status |= Head_Write_IO_Reg(0x40,LOW);
+                //status |= Head_Write_IO_Reg(0x40,LOW);
             break;
         case HEADCARD_HIT_ZN3:
                 Head_I2C_EXP1_0x40.bits.OUTPUT_SWON_ZN3  = Pwr_Cmd;
-                status |= Head_Write_IO_Reg(0x40,LOW);
+                //status |= Head_Write_IO_Reg(0x40,LOW);
             break;
         case HEADCARD_HIT_ZN4:
                 Head_I2C_EXP1_0x40.bits.OUTPUT_SWON_ZN4  = Pwr_Cmd;
-                status |= Head_Write_IO_Reg(0x40,LOW);
+                //status |= Head_Write_IO_Reg(0x40,LOW);
             break;
         case HEADCARD_HIT_ZN5:
                 Head_I2C_EXP1_0x40.bits.OUTPUT_SWON_ZN5  = Pwr_Cmd;
-                status |= Head_Write_IO_Reg(0x40,LOW);
+                //status |= Head_Write_IO_Reg(0x40,LOW);
             break;
         case HEADCARD_HIT_ZN6:
                 Head_I2C_EXP1_0x40.bits.OUTPUT_SWON_ZN6  = Pwr_Cmd;
-                status |= Head_Write_IO_Reg(0x40,LOW);
+                //status |= Head_Write_IO_Reg(0x40,LOW);
             break;
         case HEADCARD_HIT_ZN7:
                 Head_I2C_EXP1_0x40.bits.OUTPUT_SWON_ZN7  = Pwr_Cmd;
-                status |= Head_Write_IO_Reg(0x40,LOW);
+                //status |= Head_Write_IO_Reg(0x40,LOW);
             break;
         case HEADCARD_HIT_ZN8:
                 Head_I2C_EXP1_0x40.bits.OUTPUT_SWON_ZN8  = Pwr_Cmd;
-                status |= Head_Write_IO_Reg(0x40,LOW);
+                //status |= Head_Write_IO_Reg(0x40,LOW);
             break;
         case HEADCARD_HIT_ZN9:
                 Head_I2C_EXP1_0x40.bits.OUTPUT_SWON_ZN9  = Pwr_Cmd;
-                status |= Head_Write_IO_Reg(0x40,HIGH);
+                //status |= Head_Write_IO_Reg(0x40,HIGH);
             break;
         case HEADCARD_HIT_ZN10:
                 Head_I2C_EXP1_0x40.bits.OUTPUT_SWON_ZN10  = Pwr_Cmd;
-                status |= Head_Write_IO_Reg(0x40,HIGH);
+                //status |= Head_Write_IO_Reg(0x40,HIGH);
             break;
         case HEADCARD_HIT_ZN11:
                 Head_I2C_EXP1_0x40.bits.OUTPUT_SWON_ZN11  = Pwr_Cmd;
-                status |= Head_Write_IO_Reg(0x40,HIGH);
+                //status |= Head_Write_IO_Reg(0x40,HIGH);
             break;
         case HEADCARD_HIT_ZN12:
                 Head_I2C_EXP1_0x40.bits.OUTPUT_SWON_ZN12  = Pwr_Cmd;
-                status |= Head_Write_IO_Reg(0x40,HIGH);
+                //status |= Head_Write_IO_Reg(0x40,HIGH);
             break;
         case HEADCARD_UPPER_HIT_IN1:
                 Head_I2C_EXP1_0x40.bits.OUTPUT_ON_HTIN1  = Pwr_Cmd;
-                status |= Head_Write_IO_Reg(0x40,HIGH);
+                //status |= Head_Write_IO_Reg(0x40,HIGH);
             break;
         case HEADCARD_UPPER_HIT_IN2:
                 Head_I2C_EXP1_0x40.bits.OUTPUT_ON_HTIN2  = Pwr_Cmd;
-                status |= Head_Write_IO_Reg(0x40,HIGH);
+                //status |= Head_Write_IO_Reg(0x40,HIGH);
             break;
         case HEADCARD_UPPER_HIT_IN3:
                 Head_I2C_EXP1_0x40.bits.OUTPUT_ON_HTIN3  = Pwr_Cmd;
-                status |= Head_Write_IO_Reg(0x40,HIGH);
+                //status |= Head_Write_IO_Reg(0x40,HIGH);
             break;
         case HEADCARD_UPPER_HIT_IN4:
                 Head_I2C_EXP1_0x40.bits.OUTPUT_ON_HTIN4  = Pwr_Cmd;
-                status |= Head_Write_IO_Reg(0x40,HIGH);
+                //status |= Head_Write_IO_Reg(0x40,HIGH);
             break;
         case HEADCARD_UPPER_HIT_OUT1:
                 Head_I2C_EXP2_0x42.bits.OUTPUT_ON_HTOT1  = Pwr_Cmd;
-                status |= Head_Write_IO_Reg(0x42,LOW);
+                //status |= Head_Write_IO_Reg(0x42,LOW);
             break;
         case HEADCARD_UPPER_HIT_OUT2:
                 Head_I2C_EXP2_0x42.bits.OUTPUT_ON_HTOT2  = Pwr_Cmd;
-                status |= Head_Write_IO_Reg(0x42,LOW);
+                //status |= Head_Write_IO_Reg(0x42,LOW);
             break;
         case HEADCARD_UPPER_HIT_OUT3:
                 Head_I2C_EXP2_0x42.bits.OUTPUT_ON_HTOT3  = Pwr_Cmd;
-                status |= Head_Write_IO_Reg(0x42,LOW);
+                //status |= Head_Write_IO_Reg(0x42,LOW);
             break;
         case HEADCARD_UPPER_HIT_OUT4:
                 Head_I2C_EXP2_0x42.bits.OUTPUT_ON_HTOT4  = Pwr_Cmd;
-                status |= Head_Write_IO_Reg(0x42,LOW);
+                //status |= Head_Write_IO_Reg(0x42,LOW);
             break;
         case HEADCARD_HIT_MIXER:
                 Head_I2C_EXP2_0x42.bits.OUTPUT_ON_MIX  = Pwr_Cmd;
-                status |= Head_Write_IO_Reg(0x42,LOW);
+                //status |= Head_Write_IO_Reg(0x42,LOW);
             break;
         default:
             break;
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 4a664a0c5..0f2be54f1 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
@@ -454,6 +454,12 @@ void HeadADCPT100_SensorInitConfig()
             for(Register=SENSOR_CONFIG_REG0;Register<=SENSOR_CONFIG_REG3;Register++)
                 HeadADCPT100_Config_callback( (TEMPERATURE_SENSOR_ID_ENUM)(Sensor), Register);
         }
+/*        for(Sensor=HEAD_PT100_ZONE_2_0X80_1;Sensor < HEAD_PT100_RESERVE_0X8E_1;Sensor++) - no need every couple of even and odd use the same ADC
+        {
+            for(Register=SENSOR_CONFIG_REG0;Register<=SENSOR_CONFIG_REG3;Register++)
+                HeadADCPT100_Config_callback( (TEMPERATURE_SENSOR_ID_ENUM)(Sensor), Register);
+        }
+*/
 }
 /*
 uint32_t HeadCard_Toggle_PT100(bool Odd_OR_Even)//ODD/EVEN
@@ -659,6 +665,7 @@ uint32_t control_HeadCard_PT100(uint8_t HEAD_CONFIG_PT100_MUX)
     uint8_t Write_Buf[2];
     TEMPERATURE_SENSOR_ID_ENUM SensorId;
 
+    Semaphore_pend(I2C_Sem, BIOS_WAIT_FOREVER);
     Select_Main_Head_Mux_Channel();
     //delayms(5);
     if(HEAD_CONFIG_PT100_MUX == HEAD_CONFIG_ODD_PT100_MUX)
@@ -738,6 +745,7 @@ uint32_t control_HeadCard_PT100(uint8_t HEAD_CONFIG_PT100_MUX)
 //            HeadADCPT100_PowerDown(SensorId);
 //        }
     }
+    Semaphore_post(I2C_Sem);
 
     return Status;
 }
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/PT100/Head_PT100_ADC.h b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/PT100/Head_PT100_ADC.h
index f185f5c81..69af0635b 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/PT100/Head_PT100_ADC.h
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/PT100/Head_PT100_ADC.h
@@ -8,6 +8,8 @@
 #ifndef DRIVERS_I2C_COMMUNICATION_HEAD_CARD_PT100_PT100_ADC_H_
 #define DRIVERS_I2C_COMMUNICATION_HEAD_CARD_PT100_PT100_ADC_H_
 
+#include "drivers/Heater/TemperatureSensor.h"
+
 extern uint32_t I2C_ADC_ADS122C04_SLAVE_ADD;
 
 extern uint32_t Data_ADC_Head;
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C.h b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C.h
index f8407268a..c2de36571 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C.h
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C.h
@@ -24,7 +24,10 @@ uint32_t I2C_Read(uint32_t I2C_ID, uint32_t Slave_Add, uint32_t *I2C_Read_buf, u
 
 void Trigger_Heater_Current_Read(void);
 void Trigger_MidTank_Pressure_Read(void);
+void Trigger_PT100_Read(void);
+void Trigger_HeaterWriting(void);
 
 extern uint8_t Main_Mux_Flag ;
+extern Semaphore_Handle I2C_Sem;
 
 #endif /* DRIVERS_I2C_COMMUNICATION_I2C_H_ */
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 0fc597c4e..bfae7e3f6 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C_Task.c
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C_Task.c
@@ -12,15 +12,20 @@
 
 #include "drivers/ADC_Sampling/adc.h"
 #include "drivers/I2C_Communication/Head_Card/ADC/Head_ADC.h"
+#include "Drivers/I2C_Communication/Head_Card/PT100/Head_PT100_ADC.h"
+#include "Drivers/I2C_Communication/Head_Card/IO_Ports/Heaters/Head_Heaters.h"
 
 #include "ADC_MUX/ADC_MUX.h"
 #include "modules/ids/ids_ex.h"
 
+extern Semaphore_Handle I2C_Sem;
 Mailbox_Handle          I2C_ReadingMsgQ = NULL;
 typedef enum
 {
     Midtank_Pressure_Reading,
-    Heater_Current_Reading
+    Heater_Current_Reading,
+    PT100_Reading,
+    HeaterWriting
 }I2C_ReadingMessages;
 
 typedef struct I2C_ReadingMessage{
@@ -62,11 +67,35 @@ void Trigger_MidTank_Pressure_Read(void)
     return;
 
 }
+void Trigger_PT100_Read(void)
+{
+    I2C_ReadingMessageStruc I2C_ReadingMessage;
+    uint8_t Midtank_i;
+
+    I2C_ReadingMessage.messageId = PT100_Reading;
+    if (I2C_ReadingMsgQ != NULL)
+        Mailbox_post(I2C_ReadingMsgQ , &I2C_ReadingMessage, BIOS_NO_WAIT);
+    return;
+
+}
+void Trigger_HeaterWriting(void)
+{
+    I2C_ReadingMessageStruc I2C_ReadingMessage;
+    uint8_t Midtank_i;
+
+    I2C_ReadingMessage.messageId = HeaterWriting;
+    if (I2C_ReadingMsgQ != NULL)
+        Mailbox_post(I2C_ReadingMsgQ , &I2C_ReadingMessage, BIOS_NO_WAIT);
+    return;
+
+}
 void I2C_ReadingTask(UArg arg0, UArg arg1)
 {
     I2C_ReadingMessageStruc I2C_ReadingMessage;
     Error_Block eb;
     Error_init(&eb);
+    Semaphore_post(I2C_Sem);
+
     I2C_ReadingMsgQ = Mailbox_create(sizeof(I2C_ReadingMessageStruc), 40, NULL,&eb);
 
     while(1)
@@ -86,6 +115,12 @@ void I2C_ReadingTask(UArg arg0, UArg arg1)
            Read_Heaters_Current(I2C_ReadingMessage.parameter);
 #endif
         break;
+        case PT100_Reading:
+            Set_HeadCard_PT100();
+            break;
+        case HeaterWriting:
+            Write_Head_Card_Heaters_Commands();
+            break;
         default:
             break;
         }
diff --git a/Software/Embedded_SW/Embedded/Embedded.cfg b/Software/Embedded_SW/Embedded/Embedded.cfg
index 1f8651545..3c81a0382 100644
--- a/Software/Embedded_SW/Embedded/Embedded.cfg
+++ b/Software/Embedded_SW/Embedded/Embedded.cfg
@@ -58,11 +58,6 @@ hwi17Params.arg = 3;
 hwi17Params.priority = 96;
 Program.global.timer3 = Hwi.create(51, "&ScrewTimerInterrupt", hwi17Params);
 
-var semaphore4Params = new Semaphore.Params();
-semaphore4Params.instance.name = "initConnectionSem";
-semaphore4Params.mode = Semaphore.Mode_BINARY;
-Program.global.initConnectionSem = Semaphore.create(null, semaphore4Params);
-
 var semaphore0Params = new Semaphore.Params();
 semaphore0Params.instance.name = "adcResultSem";
 semaphore0Params.mode = Semaphore.Mode_BINARY;
@@ -73,10 +68,21 @@ semaphore3Params.instance.name = "updateSem";
 semaphore3Params.mode = Semaphore.Mode_BINARY;
 Program.global.updateSem = Semaphore.create(null, semaphore3Params);
 
+
 var semaphore4Params = new Semaphore.Params();
-semaphore4Params.instance.name = "FFS_Sem";
+semaphore4Params.instance.name = "initConnectionSem";
 semaphore4Params.mode = Semaphore.Mode_BINARY;
-Program.global.FFS_Sem = Semaphore.create(null, semaphore4Params);
+Program.global.initConnectionSem = Semaphore.create(null, semaphore4Params);
+
+var semaphore5Params = new Semaphore.Params();
+semaphore5Params.instance.name = "I2C_Sem";
+semaphore5Params.mode = Semaphore.Mode_BINARY;
+Program.global.I2C_Sem = Semaphore.create(null, semaphore5Params);
+
+var semaphore6Params = new Semaphore.Params();
+semaphore6Params.instance.name = "FFS_Sem";
+semaphore6Params.mode = Semaphore.Mode_BINARY;
+Program.global.FFS_Sem = Semaphore.create(null, semaphore6Params);
 
 var semaphore7Params = new Semaphore.Params();
 semaphore7Params.instance.name = "ReconnectSem";
diff --git a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
index a5bf4d336..aa8f29451 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
+++ b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
@@ -54,7 +54,6 @@
 
 #include "Communication/Connection.h"
 #include "Modules/General/buttons.h"
-#include "Drivers/I2C_Communication/Head_Card/PT100/Head_PT100_ADC.h"
 
 Task_Handle Millisecond_Task_Handle;
 /******************** Definitions  ********************************************/
@@ -611,11 +610,14 @@ uint32_t MillisecLowLoop(uint32_t tick)
         //if (Sensor_Read++ >= MAX_MAIN_CARD_TEMPERATURE_SENSOR_ID) Sensor_Read = 0;
         if(Machine_Idle_Mode == true)
             Machine_Idle_Breathing_Led();
+        Trigger_HeaterWriting();
+
     }
 #ifdef Use_Head_Card
     if(Fifty_msTick)
     {
-            Set_HeadCard_PT100();//call every 50mSec (minimum delay 30mSec)
+        Trigger_PT100_Read();//call every 50mSec (minimum delay 30mSec)
+        //Set_HeadCard_PT100();//call every 50mSec (minimum delay 30mSec)
     }
 #endif
 /*#ifdef Use_Head_Card
@@ -653,6 +655,14 @@ uint32_t MillisecLowLoop(uint32_t tick)
         Speed_Data = Calculate_Speed_Sensor_Velocity();
         Read_Buttons_Reg();
         //Ink_Cart_Led();
+        ///////////////////////////////////////////////////////////////////
+        char Lenstr[160];
+        static int Counter = 0;
+
+        TemperatureListString(Lenstr);
+        ReportWithPackageFilter(ThreadFilter,Lenstr,__FILE__,__LINE__,(int)Counter++,RpWarning,(int) msec_millisecondCounter,0);
+        ///////////////////////////////////////////////////////////////////////////
+
 #ifdef Use_Head_Card
         for (Sensor_i = TEMP_SENSE_ANALOG_DRYER_TEMP1;Sensor_i < MAX_HEAD_CARD_TEMP_SENS_ID;Sensor_i++)
 #else
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
index b879a1404..71fd9a428 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
@@ -36,6 +36,7 @@
 #include "drivers/FPGA/FPGA_GPIO/FPGA_GPIO.h"
 #include "drivers/I2C_Communication/ADC_MUX/ADC_MUX.h"
 #include "drivers/I2C_Communication/Head_Card/ADC/Head_ADC.h"
+#include "Drivers/I2C_Communication/I2C.h"
 
 #include "StateMachines/Printing/PrintingSTM.h"
 #include "StateMachines/Initialization/PowerIdle.h"
@@ -1468,7 +1469,7 @@ uint32_t HeatersControlLoop(uint32_t tick)
     SliceCounter++;
     if (SliceCounter >= NumberOFSlicesInUse)
         SliceCounter = 0;
-
+    //Trigger_HeaterWriting();
     return OK;
 }
 /******************************************************************************
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
index f3eb9cb60..fb5de9011 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
@@ -1311,7 +1311,7 @@ uint32_t StopThreadLoadingFunc(MessageContainer* requestContainer)
     MessageContainer responseContainer;
     MessageState = 2;
     Thread_Load_End();
-    Report("StopThreadLoadingFunc",__FILE__,__LINE__,(int)(request->processparameters->dryerbufferlength),RpWarning,(int)LoadStages,0);
+    Report("StopThreadLoadingFunc",__FILE__,__LINE__,(int)11,RpWarning,(int)LoadStages,0);
 
     responseContainer = createContainer(MESSAGE_TYPE__StopThreadLoadingResponse, requestContainer->token, true, &Cresponse, &stop_thread_loading_response__pack, &stop_thread_loading_response__get_packed_size);
     responseContainer.continuous = false;
diff --git a/Software/Embedded_SW/Embedded/StateMachines/Initialization/InitSequence.c b/Software/Embedded_SW/Embedded/StateMachines/Initialization/InitSequence.c
index bba24e22f..937e348b0 100644
--- a/Software/Embedded_SW/Embedded/StateMachines/Initialization/InitSequence.c
+++ b/Software/Embedded_SW/Embedded/StateMachines/Initialization/InitSequence.c
@@ -115,7 +115,7 @@ uint32_t InitScheduler(uint32_t IfIndex, uint32_t BusyFlag)
 uint32_t Start_InitSequence(void)
 {
     MachineStateDetail = MACHINE_STATE_HW_CONFIG;
-    SetMachineStatus(MACHINE_STATE__Initializing);
+    SetMachineStatus(MACHINE_STATE__PowerUp);
     HWControlId = AddControlCallback("Init HW Init", InitSequenceCallBackFunction, 4* eOneSecond, TemplateDataReadCBFunction,0,0, 0 );
     InitSchedulerControlId = AddControlCallback("InitScheduler", InitScheduler, eOneSecond, TemplateDataReadCBFunction,0,0, 0 );
     return OK;
diff --git a/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerIdle.c b/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerIdle.c
index b0d101809..2a39a83bc 100644
--- a/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerIdle.c
+++ b/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerIdle.c
@@ -164,7 +164,7 @@ void PowerIdleOutOfIdleState(void)
             IdleControlId = AddControlCallback( "NULL",PowerIdleCallBackFunction, eOneSecond, TemplateDataReadCBFunction,0,0, 0 );
         if (IdleControlId == 0xFF)
             Report("AddControlCallback failed",__FILE__,__LINE__,(int)IdleControlId,RpWarning,(int)0,0);
-        SetMachineStatus(MACHINE_STATE__Initializing);
+        SetMachineStatus(MACHINE_STATE__PowerUp);
         IdleHeatingControlId = AddControlCallback("Heating Out of Idle", PowerIdleStartHeatingCallBackFunction, 2*eOneSecond, TemplateDataReadCBFunction,0,0, 0 );