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

3 files changed, 86 insertions, 22 deletions

diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
index 128564586..698852f00 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
@@ -32,6 +32,9 @@
 #include "drivers/motors/motor.h"
 #include "drivers/Flash_ram/MCU_E2Prom.h"
 #include "Drivers/I2C_Communication/I2C.h"
+#include <Drivers/I2C_Communication/WHS_Card/D_Max5805_ADC_Blower/WHS_Blower.h>
+#include <Drivers/I2C_Communication/I2C_Task.h>
+
 #include "PMR/Stubs/StubHeatingTestRequest.pb-c.h"
 #include "PMR/Stubs/StubHeatingTestResponse.pb-c.h"
 #include "PMR/Stubs/StubHeatingTestPollRequest.pb-c.h"
@@ -186,8 +189,10 @@
         ProcessParametersClear.headzone10temp  = 0;
         ProcessParametersClear.headzone11temp  = 0;
         ProcessParametersClear.headzone12temp  = 0;
-        ProcessParametersClear.stspzone1temp  = 0;
-        ProcessParametersClear.stspzone2temp  = 0;
+        ProcessParametersClear.rblowertemp  = 0;
+        ProcessParametersClear.lblowertemp  = 0;
+        ProcessParametersClear.rblowerflow  = 0;
+        ProcessParametersClear.lblowerflow  = 0;
         ProcessParametersClear.dyeingspeed = 40;
         ProcessParametersClear.dryerbufferlength = ProcessParametersKeep.dryerbufferlength;
         if (HandleProcessParameters(&ProcessParametersClear,false)!= OK)
@@ -199,7 +204,7 @@
         }
         else
         {
-            //WHS_Start_Blower_Control_Closed_Loop(2.5);
+            WHS_Set_SetPoint_Q_value(headairflow/2);
             Turn_the_Blower_On();//Turn on with the Default_Voltage
             if (BlowerCfg.heatingvoltage)
                 Control_Voltage_To_Blower(BlowerCfg.heatingvoltage);
@@ -410,7 +415,8 @@
         CallbackCounter++;
         //MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID].directionthreadwize, 200,  Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID], Thread_Load_HomingCallback,10000);
         MotorGotoWithCallback(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID, 0, Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID], Thread_Load_HomingCallback,10000);
-        Trigger_Head_Actuators_Control(ACTOT, LOW,true);
+        Trigger_Head_Actuators_Control(ACTOT, LOW,false);
+        Trigger_Head_Actuators_Control(ACTIN, LOW,false);
         return OK;
     }
     uint32_t Thread_Load_Lift_Dancers(void)
@@ -422,6 +428,8 @@
         MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_RDANCER,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDANCER].directionthreadwize, 15,  Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_RDANCER], Thread_Load_HomingCallback,15000);*/
         CallbackCounter++;
         MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_LDANCER1,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LDANCER1].directionthreadwize, 500,  Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_LDANCER1], Thread_Load_HomingCallback,25000);
+        CallbackCounter++;
+        MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_LDANCER2,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LDANCER2].directionthreadwize, 500,  Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_LDANCER2], Thread_Load_HomingCallback,25000);
 
         return OK;
     }
@@ -504,6 +512,11 @@
 
 //        MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_LDANCER1,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LDANCER1].directionthreadwize, 500,  Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_LDANCER1], Thread_Load_HomingCallback,25000);
         MotorMoveWithCallback (HARDWARE_MOTOR_TYPE__MOTO_LDANCER1, MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LDANCER1].directionthreadwize, (5000*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LDANCER1].microstep), Thread_Load_HomingCallback,20000);
+        CallbackCounter++;
+        MotorSetMaxSpeed (HARDWARE_MOTOR_TYPE__MOTO_LDANCER2, 500);
+
+//        MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_LDANCER1,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LDANCER1].directionthreadwize, 500,  Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_LDANCER1], Thread_Load_HomingCallback,25000);
+        MotorMoveWithCallback (HARDWARE_MOTOR_TYPE__MOTO_LDANCER2, MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LDANCER2].directionthreadwize, (5000*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LDANCER2].microstep), Thread_Load_HomingCallback,20000);
 
         return OK;
     }
@@ -518,7 +531,8 @@
         CallbackCounter++;
 //        MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID].directionthreadwize, 200,  Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID], Thread_Load_HomingCallback,10000);
         MotorGotoWithCallback(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID, 2, Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID], Thread_Load_HomingCallback,10000);
-        Trigger_Head_Actuators_Control(ACTOT, LOW,false);
+        Trigger_Head_Actuators_Control(ACTOT, LOW,true);
+        Trigger_Head_Actuators_Control(ACTIN, LOW,true);
         return OK;
     }
     uint32_t Thread_Load_Resume_Heating(void)
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
index 78092ae2b..78150e9f9 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
@@ -213,9 +213,16 @@ uint32_t Winder_PrepareStage2(uint32_t deviceID, uint32_t ReadValue)
     REPORT_MSG(millisecondCounter/*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].maxfrequency*/, "Winder_PrepareStage2");
     if (ReadValue != LIMIT)
     {
-        LOG_ERROR(ReadValue,"Screw failed to reach the limit switch!!");
-        //returned with a timeout
-        Winder_ScrewAtOffsetCallback(0,0);
+        if (JobIsActive()==true)
+        {
+            LOG_ERROR(ReadValue,"Screw failed to reach the limit switch!!");
+            //returned with a timeout
+            Winder_ScrewAtOffsetCallback(0,0);
+        }
+        else //short jog, etc
+        {
+            AlarmHandlingSetAlarm (EVENT_TYPE__SCREW_MOTOR_LIMIT_TIMEOUT,OFF);  //on a short jog, this callback will be called without need
+        }
     }
     else
     {
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
index 1dd101f82..be6644067 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
@@ -15,6 +15,7 @@
 #include "PMR/Hardware/HardwareDancerType.pb-c.h"
 #include "PMR/Printing/JobSegment.pb-c.h"
 #include "PMR/Printing/JobTicket.pb-c.h"
+#include "PMR/Printing/ThreadParameters.pb-c.h"
 #include  <PMR/Diagnostics/EventType.pb-c.h>
 
 #include <utils/ustdlib.h>
@@ -71,10 +72,12 @@ double TempTotalProcessedLength = 0.0;
 
 bool InitialProcess = false;
 bool PrepareState = false;
+
 // job parameters
 bool EnableLubrication = false;
 bool EnableIntersegment = false;
 double IntersegmentLength = 0;
+bool Thread_Rockers_Bypass = false;
 
 
 int CurrentSegmentId = 0;
@@ -442,7 +445,6 @@ void testDancersControl()
     ThreadControlActive = false;
 }
 #endif
-bool dancerinvalid = false;
 int MotorFailedSample[MAX_THREAD_MOTORS_NUM] = {0,0,0,0,0};
 char TMessage[150];
 //char time[150];
@@ -456,7 +458,8 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
 //extern int MotorSamplePointer[MAX_THREAD_MOTORS_NUM];
 
     //read value is the dancer angle
-    int i,index=MAX_THREAD_MOTORS_NUM,len;
+    int i,index=MAX_THREAD_MOTORS_NUM;
+    int len;
     int DancerId;
     int32_t TranslatedReadValue, avreageSampleValue = 0;//,avreageMotorSampleValue = 0;
     //double tempcalcspeed = 0;
@@ -481,21 +484,20 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
         //if (MotorDriverResponse[ThreadMotorIdToMotorId[index]].Busy == true)
         //    return OK;
         DancerId = ThreadMotorIdToDancerId[index];
-        if (ReadValue < 10)
+/*        if (ReadValue < 10)
         {
             MotorFailedSample[index]++;
             ReportWithPackageFilter(ThreadFilter,"Dancer value read too small.",__FILE__,__LINE__,DancerId,RpError,ReadValue,0);
             return OK;
-        }
+        }*/
         if (ReadValue == 0x3FFF)
         {
-            MotorFailedSample[index]++;
-            if (dancerinvalid == false)
+            if (Read_Dryer_Status(DancerId) != OK)
             {
-                dancerinvalid = true;
-                ReportWithPackageFilter(ThreadFilter,"Dancer value invalid.",__FILE__,__LINE__,(int)IfIndex,RpError,(int)ReadValue,0);
+                ReportWithPackageFilter(ThreadFilter,"Dancer value invalid.",__FILE__,ReadValue,(int)DancerId,RpError,(int)Read_Dryer_Status(DancerId),0);
+                MotorFailedSample[index]++;
+                return OK;
             }
-            return OK;
         }
         KeepReadValue = ReadValue;
         TranslatedReadValue = ReadValue - DancersCfg[DancerId].zeropoint;
@@ -746,7 +748,47 @@ uint32_t ThreadInitialTestStub(HardwareMotor * request)
      ThreadPreSegmentState(request,0);
     return OK;
 }
+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;
+    }
+    if(ThreadParams->feederp)
+        MotorControlConfig[FEEDER_MOTOR].m_params.Kd = ThreadParams->feederp;
+    if(ThreadParams->feederi)
+        MotorControlConfig[FEEDER_MOTOR].m_params.Ki = ThreadParams->feederi;
+    if(ThreadParams->feederd)
+        MotorControlConfig[FEEDER_MOTOR].m_params.Kd = ThreadParams->feederd;
+
+    if(ThreadParams->pullerp)
+        MotorControlConfig[POOLER_MOTOR].m_params.Kd = ThreadParams->pullerp;
+    if(ThreadParams->pulleri)
+        MotorControlConfig[POOLER_MOTOR].m_params.Ki = ThreadParams->pulleri;
+    if(ThreadParams->pullerd)
+        MotorControlConfig[POOLER_MOTOR].m_params.Kd = ThreadParams->pullerd;
+
+    if(ThreadParams->winderp)
+        MotorControlConfig[WINDER_MOTOR].m_params.Kd = ThreadParams->winderp;
+    if(ThreadParams->winderi)
+        MotorControlConfig[WINDER_MOTOR].m_params.Ki = ThreadParams->winderi;
+    if(ThreadParams->winderd)
+        MotorControlConfig[WINDER_MOTOR].m_params.Kd = ThreadParams->winderd;
+    if(ThreadParams->bypassrockers)
+        Thread_Rockers_Bypass = true;
+
+    return OK;
+}
 //********************************************************************************************************************
  uint32_t ThreadPrepareState(void *JobDetails)
 {
@@ -826,10 +868,10 @@ uint32_t ThreadInitialTestStub(HardwareMotor * request)
 //////////////////////////////////////////////////
             for (i = 0;i < (int)MotorsControl[Motor_i].pvinputfilterfactormode; i++)
             {
-                if (Motor_i == DRYER_MOTOR) // dryer motor is speed controlled. later a speed sensor will be utilized, but for now it will not be controlled
+                //if (Motor_i == DRYER_MOTOR) // dryer motor is speed controlled. later a speed sensor will be utilized, but for now it will not be controlled
                     MotorSamples[Motor_i][i] = Control_Read_Dancer_Position(ThreadMotorIdToDancerId[Motor_i],0);  //reset the samples value for control beginning
-                else if ((Motor_i == POOLER_MOTOR)||(Motor_i == FEEDER_MOTOR))
-                    MotorSamples[Motor_i][i] = DancersCfg[ThreadMotorIdToDancerId[Motor_i]].zeropoint;
+               // else if ((Motor_i == POOLER_MOTOR)||(Motor_i == FEEDER_MOTOR))
+                //    MotorSamples[Motor_i][i] = DancersCfg[ThreadMotorIdToDancerId[Motor_i]].zeropoint;
                 //MotorSpeedSamples[Motor_i][i] = 0;
             }
             MotorSamplePointer[Motor_i] = 0;
@@ -907,6 +949,8 @@ uint32_t ThreadInitialTestStub(HardwareMotor * request)
             if (Motor_i == ThreadMotorIdToMotorId[DRYER_MOTOR]) // dryer motor is speed controlled. later a speed sensor will be utilized, but for now it will not be controlled
                 continue;
     }
+    HandleJobThreadControlParameters(JobTicket->threadparameters);  //OVERRIDES CONFIGURATION PARAMETERS!!!
+
 #ifdef TEST_PID_THREAD
     testDancersControl();
 #endif
@@ -965,7 +1009,6 @@ uint32_t ThreadDryerRampUp(uint32_t IfIndex, uint32_t BusyFlag)
 
     return OK;
 }
-bool Thread_Rockers_Bypass = false;
 bool Set_Thread_Rockers_Bypass (int value)
 {
     if (value == 0)
@@ -1146,7 +1189,7 @@ char Endstr[150];
      if (PoolerSpeedControlId != 0xFF)
      {
          if(RemoveControlCallback(PoolerSpeedControlId,PoolerThreadLengthCBFunction)!=OK)
-             ReportWithPackageFilter(ThreadFilter,"Remove Control Failed.",__FILE__,__LINE__,(int)Motor_i,RpError,(int)PoolerSpeedControlId,0);
+             ReportWithPackageFilter(ThreadFilter,"Remove Control Failed.",__FILE__,__LINE__,(int)PoolerThreadLengthCBFunction,RpError,(int)PoolerSpeedControlId,0);
          PoolerSpeedControlId = 0xFF;
      }