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

6 files changed, 77 insertions, 25 deletions

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;
 }