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

14 files changed, 188 insertions, 30 deletions

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 e4f7f81ad..a5c9376d2 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
@@ -59,7 +59,7 @@ uint32_t Write_Head_Card_Heaters_Commands()
     if(Semaphore_pend(I2C_Sem, BIOS_NO_WAIT))
     {
         status = Head_Write_IO_Reg(0x40,LOW_AND_HIGH);
-        status = Head_Write_IO_Reg(0x42,LOW);
+        status |= Head_Write_IO_Reg(0x42,LOW);
         Semaphore_post(I2C_Sem);
     }
     else
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 ab05c92a9..8bd21b9b4 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C_Comm.c
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C_Comm.c
@@ -123,6 +123,11 @@ uint32_t I2C_ReadBuff(uint32_t I2C_BASE, unsigned char addr, unsigned char* data
 
         return 0xFF;
     }
+    /*if (Task_self()!= I2C_Task_Handle)
+    {
+        status = ERROR;
+    }
+    status = OK;*/
     I2CMasterSlaveAddrSet(I2C_BASE, addr, true);
     if (len == 1)
     {
@@ -223,7 +228,7 @@ 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)
+        if (Arb_Loss_Count++ >= 5)
         {
             Arb_Loss_Count= 0;
             Init_All_I2C();
@@ -276,7 +281,7 @@ uint32_t I2C_Read(uint32_t I2C_ID, uint32_t Slave_Add, uint32_t *I2C_Read_buf, u
     //status = I2C_ReadFifo(I2C_BASE, Slave_Add, buff, No_BytesToRead);
     if (status)
     {
-        if (Arb_Loss_Count++ > 10)
+        if (Arb_Loss_Count++ >= 5)
         {
             Arb_Loss_Count= 0;
             Init_All_I2C();
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 13ecbd12c..44ab8d710 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C_Task.c
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C_Task.c
@@ -49,6 +49,8 @@ typedef enum
     HeadArcPressureAction,
     HeadValveAction,
 
+    DispenserReadData,
+
     /* enum for WHS :*/
     WHS_start,
     WHS_init_I2C_IO,
@@ -225,6 +227,18 @@ void Trigger_Head_MixerValve(int direction)
     return;
 }
 
+void Trigger_Dispenser_ReadData(int dispenserId)
+{
+    I2C_ReadingMessageStruc I2C_ReadingMessage;
+    //uint8_t Midtank_i;
+
+    I2C_ReadingMessage.messageId = DispenserReadData;
+    I2C_ReadingMessage.parameter = dispenserId;
+    if (I2C_ReadingMsgQ != NULL)
+        Mailbox_post(I2C_ReadingMsgQ , &I2C_ReadingMessage, BIOS_NO_WAIT);
+    return;
+}
+
 void Trigger_HeaterWriting(void)
 {
     I2C_ReadingMessageStruc I2C_ReadingMessage;
@@ -624,6 +638,9 @@ void I2C_ReadingTask(UArg arg0, UArg arg1)
             break;
         case Head_Outputs_Writing:
             break;
+        case DispenserReadData:
+            Dispenser_EEPROM_Read_Data(I2C_ReadingMessage.parameter);
+            break;
         case WHS_PT100_Reading:
             for (Sensor_i = WHS_PT100_1_0X80_0; Sensor_i <= WHS_PT100_4_0X82_1; Sensor_i++)
             {
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C_Task.h b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C_Task.h
index 35440bca5..20fcb0074 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C_Task.h
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C_Task.h
@@ -55,4 +55,6 @@ void Trigger_Head_Magnet(int direction);
 void Trigger_Head_MixerValve(int direction);
 void Trigger_Head_PressureArc(bool Enable_Disable);
 
+void Trigger_Dispenser_ReadData(int dispenserId);
+
 #endif /* DRIVERS_I2C_COMMUNICATION_I2C_TASK_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 f75e6c6e6..c5f8037aa 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
@@ -430,7 +430,7 @@ void SendLimitedBlowerControl(int mV)
             //SegmentReady(Module_Heaters,ModuleFail);
             ReportWithPackageFilter(HeatersFilter, "Waste airflow Error",__FILE__,__LINE__,mV,RpError, 0,0);
             HeatersEnd();
-            return OK;
+            return;
         }
     }
     else
diff --git a/Software/Embedded_SW/Embedded/Drivers/Motors/Motor.c b/Software/Embedded_SW/Embedded/Drivers/Motors/Motor.c
index 8fb0fc573..8f5bd0b1d 100644
--- a/Software/Embedded_SW/Embedded/Drivers/Motors/Motor.c
+++ b/Software/Embedded_SW/Embedded/Drivers/Motors/Motor.c
@@ -286,6 +286,82 @@ bool MotorParseStatus(TimerMotors_t _motorId)
     }
     return OK;
 }
+uint32_t MotorGetOverCurrentStatus(TimerMotors_t _motorId)
+{
+    if (MotorDriverResponse[_motorId].DriverType == CombinrdMotDriver)
+    {
+        return (PStep01Status[_motorId].bits.OCD_ActiveLow==0);
+    }
+    else
+    if (MotorDriverResponse[_motorId].DriverType == VoltageMotDriver)
+    {
+        return (VolMotDriverStatus[_motorId].bits.OCD_ActiveLow==0);
+    }
+    else
+    if (MotorDriverResponse[_motorId].DriverType == CurrentMotDriver)
+    {
+        return (CurMotDriverStatus[_motorId].bits.OCD_ActiveLow==0);
+    }
+
+    return ERROR;
+}
+uint32_t MotorGetUnderVoltageStatus(TimerMotors_t _motorId)
+{
+    if (MotorDriverResponse[_motorId].DriverType == CombinrdMotDriver)
+    {
+        return (PStep01Status[_motorId].bits.UVLO_ActiveLow==0);
+    }
+    else
+    if (MotorDriverResponse[_motorId].DriverType == VoltageMotDriver)
+    {
+        return (VolMotDriverStatus[_motorId].bits.UVLO_ActiveLow==0);
+    }
+    else
+    if (MotorDriverResponse[_motorId].DriverType == CurrentMotDriver)
+    {
+        return (CurMotDriverStatus[_motorId].bits.UVLO_ActiveLow==0);
+    }
+
+    return ERROR;
+}
+uint32_t MotorGetStallStatus(TimerMotors_t _motorId)
+{
+    if (MotorDriverResponse[_motorId].DriverType == CombinrdMotDriver)
+    {
+        return (PStep01Status[_motorId].bits.STALL_A_ActiveLow==0);
+    }
+    else
+    if (MotorDriverResponse[_motorId].DriverType == VoltageMotDriver)
+    {
+        return (VolMotDriverStatus[_motorId].bits.STEP_LOSS_A_ActiveLow && VolMotDriverStatus[_motorId].bits.STEP_LOSS_B_ActiveLow);
+    }
+    else
+    if (MotorDriverResponse[_motorId].DriverType == CurrentMotDriver)
+    {
+        return false;
+    }
+
+    return ERROR;
+}
+uint32_t MotorGetOverHeatStatus(TimerMotors_t _motorId)
+{
+    if (MotorDriverResponse[_motorId].DriverType == CombinrdMotDriver)
+    {
+        return (PStep01Status[_motorId].bits.TH_STATUS>1);
+    }
+    else
+    if (MotorDriverResponse[_motorId].DriverType == VoltageMotDriver)
+    {
+        return (VolMotDriverStatus[_motorId].bits.TH_SD_ActiveLow==0);
+    }
+    else
+    if (MotorDriverResponse[_motorId].DriverType == CurrentMotDriver)
+    {
+        return (CurMotDriverStatus[_motorId].bits.TH_SD_ActiveLow==0);
+    }
+
+    return ERROR;
+}
 
 uint32_t MotorGetStatus(TimerMotors_t _motorId)
 {
diff --git a/Software/Embedded_SW/Embedded/Drivers/Motors/Motor.h b/Software/Embedded_SW/Embedded/Drivers/Motors/Motor.h
index 5e39b481a..aa5ffbb12 100644
--- a/Software/Embedded_SW/Embedded/Drivers/Motors/Motor.h
+++ b/Software/Embedded_SW/Embedded/Drivers/Motors/Motor.h
@@ -222,7 +222,7 @@ typedef union
         bool WRONG_CMD              : 1; //8
         bool UVLO_ActiveLow         : 1; //9
         bool TH_WRN                 : 1; //10
-        bool TH_SD                  : 1; //11
+        bool TH_SD_ActiveLow        : 1; //11
         bool OCD_ActiveLow          : 1; //12
         bool X_Bit_13               : 1; //13
         bool X_Bit_14               : 1; //14
@@ -328,6 +328,11 @@ uint32_t MotorSetKvalDec(TimerMotors_t _motorId, uint8_t Value);
 
 void MotorActionsInit(void);
 
+uint32_t MotorGetOverHeatStatus(TimerMotors_t _motorId);
+uint32_t MotorGetStallStatus(TimerMotors_t _motorId);
+uint32_t MotorGetUnderVoltageStatus(TimerMotors_t _motorId);
+uint32_t MotorGetOverCurrentStatus(TimerMotors_t _motorId);
+
 uint32_t MotorGetStatus(TimerMotors_t _motorId);
 uint32_t MotorGetStatusFromFPGA_Callback(TimerMotors_t _motorId,uint32_t Data);
 typedef enum {
diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
index f73c1c2c7..356f192a3 100644
--- a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
+++ b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
@@ -1240,14 +1240,14 @@ uint32_t AlarmHandlingLoop(uint32_t tick)
                                     if (doubleValue >= (float)(AlarmItem[Alarm_i].AlarmValue*CurrentAlarmHighLimit))
                                     {
                                         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 (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*CurrentAlarmLowLimit))&&(isHeaterReady(AlarmItem[Alarm_i].DeviceId)==false)&&(doubleValue>100))
                                     {
                                         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 (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
@@ -1255,8 +1255,8 @@ uint32_t AlarmHandlingLoop(uint32_t tick)
                                     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);
+                                        //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);
                                     }
                                 }
                             }
@@ -1281,7 +1281,7 @@ uint32_t AlarmHandlingLoop(uint32_t tick)
                                          {
                                              //usnprintf(AlarmReasonStr, 100, "OverCurrent Alarm %d ON dev %d debounce %d/%d value %d",AlarmItem[Alarm_i].EventType,AlarmItem[Alarm_i].DeviceId,AlarmState[Alarm_i].DebounceCounter,AlarmItem[Alarm_i].DebounceValue,(int)(doubleValue*100));
                                              //ReportWithPackageFilter(AlarmFilter,AlarmReasonStr, __FILE__,AlarmItem[Alarm_i].DeviceId,(int)(AlarmItem[Alarm_i].AlarmValue*100), RpMessage, (int)(doubleValue*100), 0);
-                                             ReportWithPackageFilter(AlarmFilter,"OverCurrent Alarm ON ", __FILE__,AlarmItem[Alarm_i].DeviceId,(int)(AlarmItem[Alarm_i].AlarmValue*100), RpMessage, (int)(doubleValue*100), 0);
+                                            // ReportWithPackageFilter(AlarmFilter,"OverCurrent Alarm ON ", __FILE__,AlarmItem[Alarm_i].DeviceId,(int)(AlarmItem[Alarm_i].AlarmValue*100), RpMessage, (int)(doubleValue*100), 0);
                                          }
                                      }
                                  }
@@ -1294,7 +1294,7 @@ uint32_t AlarmHandlingLoop(uint32_t tick)
                                          {
                                              //usnprintf(AlarmReasonStr, 100, "LOOP BREAK Alarm %d ON dev %d debounce %d/%d value %d",AlarmItem[Alarm_i].EventType,AlarmItem[Alarm_i].DeviceId,AlarmState[Alarm_i].DebounceCounter,AlarmItem[Alarm_i].DebounceValue,(int)(doubleValue*100));
                                              //ReportWithPackageFilter(AlarmFilter,AlarmReasonStr, __FILE__,AlarmItem[Alarm_i].DeviceId,(int)(AlarmItem[Alarm_i].AlarmValue*100), RpMessage, (int)(doubleValue*100), 0);
-                                             ReportWithPackageFilter(AlarmFilter,"loop break Alarm ON ", __FILE__,AlarmItem[Alarm_i].DeviceId,(int)(AlarmItem[Alarm_i].AlarmValue*100), RpMessage, (int)(doubleValue*100), 0);
+                                            // ReportWithPackageFilter(AlarmFilter,"loop break Alarm ON ", __FILE__,AlarmItem[Alarm_i].DeviceId,(int)(AlarmItem[Alarm_i].AlarmValue*100), RpMessage, (int)(doubleValue*100), 0);
                                          }
                                      }
                                  }
@@ -1309,7 +1309,7 @@ uint32_t AlarmHandlingLoop(uint32_t tick)
                  }
                  break;
             case ALARM_SOURCE_TYPE__MotorAlarm:
-                if (CheckMotorAlarms)
+                if (0)//(CheckMotorAlarms)
                 {
                     if (FPGA_WD_Occurred == true)
                     {
@@ -1321,7 +1321,32 @@ uint32_t AlarmHandlingLoop(uint32_t tick)
                     }
                     else
                     {
-                        value = MotorGetStatus((TimerMotors_t)AlarmItem[Alarm_i].DeviceId);
+                        switch (AlarmItem[Alarm_i].AlarmValue)
+                        {
+                            case 1:
+                                Status = MotorGetOverCurrentStatus((TimerMotors_t)AlarmItem[Alarm_i].DeviceId);
+                                if (Status == true)
+                                   Report("------Overcurrent on motor------", __FILE__,__LINE__,AlarmItem[Alarm_i].DeviceId, RpMessage, AlarmItem[Alarm_i].EventType, 0);
+                                break;
+                            case 2:
+                                Status = MotorGetUnderVoltageStatus((TimerMotors_t)AlarmItem[Alarm_i].DeviceId);
+                                if (Status == true)
+                                   Report("------Undervoltage on motor------", __FILE__,__LINE__,AlarmItem[Alarm_i].DeviceId, RpMessage, AlarmItem[Alarm_i].EventType, 0);
+                                break;
+                            case 3:
+                                Status = MotorGetStallStatus((TimerMotors_t)AlarmItem[Alarm_i].DeviceId);
+                                if (Status == true)
+                                   Report("------Stall on motor------", __FILE__,__LINE__,AlarmItem[Alarm_i].DeviceId, RpMessage, AlarmItem[Alarm_i].EventType, 0);
+                                break;
+                            case 4:
+                                Status = MotorGetOverHeatStatus((TimerMotors_t)AlarmItem[Alarm_i].DeviceId);
+                                if (Status == true)
+                                   Report("------Overtemperature on motor------", __FILE__,__LINE__,AlarmItem[Alarm_i].DeviceId, RpMessage, AlarmItem[Alarm_i].EventType, 0);
+                                break;
+                            default:
+                                Status = false;
+                        }
+                        /*value = MotorGetStatus((TimerMotors_t)AlarmItem[Alarm_i].DeviceId);
                         if (AlarmItem[Alarm_i].AlarmDirection == true)
                         {
                             if (value && AlarmItem[Alarm_i].AlarmValue)
@@ -1335,7 +1360,7 @@ uint32_t AlarmHandlingLoop(uint32_t tick)
                             {
                                 Status = true;
                             }
-                        }
+                        }*/
                     }
                 }
                 else
diff --git a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
index d2379c309..6d4d1c668 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
@@ -496,7 +496,7 @@ uint32_t HWConfiguration(UploadHardwareConfigurationRequest* UploadRequest)
                 LOG_ERROR (DispenserId, "Dispenser identification failed");
                 //return ERROR;
             }
-            status |= Dispenser_EEPROM_Read_Data(DispenserId);
+            Trigger_Dispenser_ReadData(DispenserId);
         }
         Calculateinit();
     }
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
index 1221be915..309eada85 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
@@ -785,10 +785,13 @@ int PrepareDCHeater(int HeaterId, uint32_t Frequency, uint32_t SetTemperatue)
     AlarmHandlingSetAlarm(HeaterUnderEventType_B[HeaterId], false);
     AlarmHandlingSetAlarm(HeaterEventType[HeaterId], false);
 
-    if(Head_Type > HEAD_TYPE_SYLKO_WITHOUT_CARD)
-        Enable_Reading_Heaters_ADC(HeaterId2CurrentId[HeaterId]);
-    else
-        Enable_Reading_Heaters_Current(HeaterId2CurrentId[HeaterId]);
+    if (HeaterPreviousRead[HeaterId] < HeaterCmd[HeaterId].targettemperatue )
+    {
+        if(Head_Type > HEAD_TYPE_SYLKO_WITHOUT_CARD)
+            Enable_Reading_Heaters_ADC(HeaterId2CurrentId[HeaterId]);
+        else
+            Enable_Reading_Heaters_Current(HeaterId2CurrentId[HeaterId]);
+    }
 
     //ReportWithPackageFilter(HeatersFilter,"PrepareHeater Read", __FILE__,HeaterId, SetTemperatue, RpWarning,HeaterPreviousRead[HeaterId], 0);
     if (ControlIdtoMaxHeaterId [HeaterId] == 0xFF)
@@ -1021,11 +1024,19 @@ uint32_t DcHeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue)
                 ReportWithPackageFilter(HeatersFilter, "Temperature Error",__FILE__,__LINE__,index,RpError, 0,0);
                 return OK;
             }
-            if (getIdleState() == false)
+            //if (getIdleState() == false)
+                //not idle, not cooling to temp
             {
-                ReportWithPackageFilter(HeatersFilter,"DC Heater Over the max temperature, turned off",__FILE__,index,HeaterPreviousRead[index],RpWarning,  HeaterReady[index],0);
-                ReportWithPackageFilter(HeatersFilter,"Heater over the max temperature",__FILE__,index,OverHeatCounter[index],RpWarning,HeaterControl[index].sensormaxvalue,  0);
-                AlarmHandlingSetAlarm(HeaterEventType[index], true);
+                if ((HeaterReady[index]==false)&&(HeaterPreviousRead[index]>HeaterCmd[index].targettemperatue))
+                {
+                    ReportWithPackageFilter(HeatersFilter,"DC Heater Over the max temperature, cooling off",__FILE__,index,HeaterPreviousRead[index],RpWarning,  HeaterCmd[index].targettemperatue,0);
+                }
+                else
+                {
+                    ReportWithPackageFilter(HeatersFilter,"DC Heater Over the max temperature, turned off",__FILE__,index,HeaterPreviousRead[index],RpWarning,  HeaterReady[index],0);
+                    ReportWithPackageFilter(HeatersFilter,"Heater over the max temperature",__FILE__,index,OverHeatCounter[index],RpWarning,HeaterControl[index].sensormaxvalue,  0);
+                    AlarmHandlingSetAlarm(HeaterEventType[index], true);
+                }
             }
         }
         if (index == HEATER_TYPE__DryerAirHeater)
@@ -1767,21 +1778,21 @@ uint32_t HeatersControlLoop(uint32_t tick)
             continue;
         if (DCTimeSliceAllocation[DcHeaterId] > 0) //heater active
         {
-            if (SliceCounter == 0)
+            if (SliceCounter == DcHeaterId)
             {
                 if (HeaterMaxTempFlag[DcHeaterId] == false)
                 {
                     ActivateHeater (DcHeaterId);
                 }
             }
-            else if (SliceCounter >= DCTimeSliceAllocation[DcHeaterId]) //turn off
+            else if (SliceCounter-DcHeaterId >= DCTimeSliceAllocation[DcHeaterId]) //turn off
             {
                 DeActivateHeater (DcHeaterId);
             }
         }
         else
         {
-            DeActivateHeater (DcHeaterId);
+            DeActivateHeater (DcHeaterId); 
         }
     }
     //handle the time sharing module
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
index 6c8c36564..cbdab01d1 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
@@ -492,6 +492,14 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
         response.has_progress = true;
     }
     else
+    if(request->amount == 0xAD5) //Set SecondFeederCorrection
+    {
+        LOG_ERROR(request->delay,"Set SecondFeederCorrection");
+        SecondFeederCorrection = request->delay;
+        response.progress = SecondFeederCorrection;
+        response.has_progress = true;
+    }
+    else
     if((request->amount == 0x01) && ((request->delay &0x010000) == 0x010000)) //change mode powerset01
     {
         response.progress = Power_Step_01_Mode(((request->delay &0x00FF00)>>8), request->delay &0x0000FF);
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h
index 5c9b360f6..4081b53f2 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h
@@ -23,6 +23,7 @@ typedef enum threadMotorsEnum
 
 extern double TotalProcessedLength;
 extern double PoolerTotalProcessedLength;
+extern int SecondFeederCorrection;
 
 void ThreadSetBreakSensorLimit(int limit);
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
index 21211481e..8a4960433 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
@@ -846,15 +846,22 @@ uint32_t Release_Right_TFU_Tension()
 
     return status;
 }
+int SecondFeederCorrection = 4;
 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);
+    MotorStop (HARDWARE_MOTOR_TYPE__MOTO_RDANCER,Soft_Stop); //per L6470 errata between mov and run commands
+    Report("Adjust_Right_TFU_Tension_2ndCallback x more steps",__FILE__,__LINE__,MotorId,RpMessage,SecondFeederCorrection,0);
+    if (JobIsActive()==false)
+    {
+        Report("release tension - job aborted",__FILE__,__LINE__,MotorId,RpMessage,0,0);
+        Release_Right_TFU_Tension();
+    }
     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);
+    MotorMoveWithCallback(HARDWARE_MOTOR_TYPE__MOTO_RDANCER, 1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDANCER].directionthreadwize,SecondFeederCorrection* MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDANCER].microstep, Adjust_Right_TFU_Tension_2nd_Callback,1000);
     RTFU_Up = true;
     return OK;
 }
diff --git a/Software/Embedded_SW/Embedded/StateMachines/Initialization/InitSequence.c b/Software/Embedded_SW/Embedded/StateMachines/Initialization/InitSequence.c
index e14b420fa..761433888 100644
--- a/Software/Embedded_SW/Embedded/StateMachines/Initialization/InitSequence.c
+++ b/Software/Embedded_SW/Embedded/StateMachines/Initialization/InitSequence.c
@@ -846,6 +846,7 @@ uint32_t PowerUpUpdateFunc(MessageContainer* requestContainer)
     StartPowerUpRequest* request = start_power_up_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
     ustrncpy (PowerUpToken, requestContainer->token,36);
 
+    PowerUpUpdate(MachineStateDetail);
     start_power_up_request__free_unpacked(request,NULL);
     return status;
 }