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

16 files changed, 177 insertions, 69 deletions

diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
index 25022ab67..91389bb7f 100644
--- a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
+++ b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
@@ -974,15 +974,15 @@ void AlarmHandlingInternalSetAlarm(uint32_t AlarmId, bool value);
 
 void AlarmHandlingSetAlarm(uint32_t AlarmId, bool value)
 {
-    AlarmHandlingInternalSetAlarm( AlarmId, value);
-    /*AlarmHandlingMessageStruc Message;
+    //AlarmHandlingInternalSetAlarm( AlarmId, value);
+    AlarmHandlingMessageStruc Message;
 
     //send message to the Millisec task
     Message.messageId = AlarmHandlingAlarm;
     Message.AlarmId = AlarmId;
     Message.Value = value;
     if (AlarmHandlingMsgQ != NULL)
-        Mailbox_post(AlarmHandlingMsgQ , &Message, BIOS_NO_WAIT);*/
+        Mailbox_post(AlarmHandlingMsgQ , &Message, BIOS_NO_WAIT);
 }
 void AlarmHandlingInternalSetAlarm(uint32_t AlarmId, bool value)
 {
@@ -1461,11 +1461,11 @@ uint32_t AlarmHandlingLoop(uint32_t tick)
                     }
                 }
             }
-            if (AlarmItem[Alarm_i].Predecessor!=0xFF)
+            /*if (AlarmItem[Alarm_i].Predecessor!=0xFF)
             {
                 if (AlarmState[AlarmItem[Alarm_i].Predecessor].Status == true)  //higher hierarchy alarm is on
                     Status = false;
-            }
+            }*/
             if (Status !=  AlarmState[Alarm_i].Status) //change in alarm Status
             {
                 if (Status == true) // alarm on
diff --git a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
index 0e95f4053..a5421e60a 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
+++ b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
@@ -118,7 +118,6 @@ static GateMutex_Handle gateMillisecDB;
 
 uint32_t        Millisec_timerBase = TIMER1_BASE;        //Timer handle
 /******************** Functions  ********************************************/
-void CalculateVOCAlarms(void);
 //**********************************************************************
 /******************** CODE  ********************************************/
 //**********************************************************************
@@ -151,7 +150,7 @@ void MillisecInit(void)
         System_abort("Could not create USB Wait gate");
     }
 
-    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0);
+    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER1);
     ROM_TimerConfigure(Millisec_timerBase, TIMER_CFG_PERIODIC);   // 32 bits Timer
     //TimerIntRegister(Millisec_timerBase, TIMER_A, Timer0Isr);    // Registering  isr
     ROM_TimerEnable(Millisec_timerBase, TIMER_A);
@@ -637,7 +636,9 @@ uint32_t MillisecLowLoop(uint32_t tick)
     if (Hundred_msTick)
     {
         Speed_Data = Calculate_Speed_Sensor_Velocity();
+#ifndef EVALUATION_BOARD
         Read_Buttons_Reg();
+#endif
         //Ink_Cart_Led();
         ///////////////////////////////////////////////////////////////////
 
@@ -749,7 +750,8 @@ uint32_t MillisecLowLoop(uint32_t tick)
                 MotorGetStatusFromFPGA(Motor_i);
         }*/
         midtankDisplay = 1-midtankDisplay;
-        Gas_PPM_Info = Calculate_Gas_Power_Consumption();
+        if (WHS_Type == WHS_TYPE_UNKNOWN)
+            Gas_PPM_Info = Calculate_Gas_Power_Consumption();
         //Trigger_WHS_MAX11614_Read_allADC();
 #ifdef CONTROL_DEBUG
         ResetControlTime();
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
index bfcf379d0..0181121a3 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
@@ -238,19 +238,14 @@ uint32_t GetDiagnosticCollectionLimit(void)
 {
     return (DiagnosticLimit*DiagnosticCollectionLimit);
 }
-void  SetDiagnosticCollectionLimit(int limit)
+/*void  SetDiagnosticCollectionLimit(int limit)
 {
     if ((limit)&&(limit<= DIAGNOSTICS_LIMIT))
         DiagnosticCollectionLimit = limit;
     DiagnosticLimit =eHundredMillisecond; //frequency of data collection
 
-    /*if (DiagnosticMode <= Diagnostic_Normal_Mode)
-    {
-        DiagnosticCollectionLimit = 1;  //overrule - send at least once every second
-        DiagnosticLimit =eOneSecond; //frequency of data collection
-    }*/
     REPORT_MSG(DiagnosticCollectionLimit,"Diagnostic limit set");
-}
+}*/
 
 uint8_t HeaterCounterIndex[HEATER_TYPE_MAX_HEATERS]= {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
 double HeaterTemperature[HEATER_TYPE_MAX_HEATERS][DIAGNOSTICS_LIMIT+1];
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.h b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.h
index b7b1ec9c8..7ec1962f3 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.h
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.h
@@ -30,7 +30,7 @@ uint32_t StopDiagnosticsRequestFunc(MessageContainer* requestContainer);
 
 uint32_t DiagnosticsStart(void);
 uint32_t DiagnosticsStop(void);
-void  SetDiagnosticCollectionLimit(int limit);
+//void  SetDiagnosticCollectionLimit(int limit);
 uint32_t GetDiagnosticCollectionLimit(void);
 
 void DiagnosticsReset(void);
diff --git a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
index 618d4569c..f373e079d 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
@@ -61,10 +61,16 @@ uint32_t HWConfiguration(UploadHardwareConfigurationRequest* UploadRequest);
 
 bool GeneralHwReady = false;
 
+bool PP_Machine = false;
+
 HardwareBlower BlowerCfg;
 char *SW_INFO_DIR = "0://SysInfo";
 
 char HwConfigPath[50] = "0://SysInfo//GenHwCfg.cfg";
+bool Is_PP_Machine(void)
+{
+    return PP_Machine;
+}
 void *HWConfigurationLoadFromFile( uint32_t *NumOfBytes)
 {
     FRESULT Fresult = FR_OK;
@@ -175,23 +181,14 @@ void LoadConfigurationParameters(ConfigurationParameters *Params)
         {
             EmbeddedParameters = my_malloc(sizeof(ConfigurationParameters));
             configuration_parameters__init(EmbeddedParameters);
+            EmbeddedParameters->has_breaksensorlimit = true;
             EmbeddedParameters->breaksensorlimit = 10;
-            EmbeddedParameters->has_diagnosticcollectionlimit = true;
-            EmbeddedParameters->diagnosticcollectionlimit = 3;
-            EmbeddedParameters->has_overheatcountlimit = true;
-            EmbeddedParameters->overheatcountlimit = 3;
-            EmbeddedParameters->has_underheatcountlimit = true;
-            EmbeddedParameters->underheatcountlimit = 3;
+
             EmbeddedParameters->has_closevalvetimeout = true;
             EmbeddedParameters->closevalvetimeout = 52;
             EmbeddedParameters->has_openvalvetimeout = true;
             EmbeddedParameters->openvalvetimeout = 52;
-            EmbeddedParameters->has_initialdispenserpressure = true;
-            EmbeddedParameters->initialdispenserpressure = 0.25;
-            EmbeddedParameters->has_initialdispensertimeout = true;
-            EmbeddedParameters->initialdispensertimeout = 180000;
-            EmbeddedParameters->has_initialdispensertimelag = true;
-            EmbeddedParameters->initialdispensertimelag = 100;
+
             EmbeddedParameters->has_dispenserbuildpressurespeed = true;
             EmbeddedParameters->dispenserbuildpressurespeed=500;
             EmbeddedParameters->has_dispenserbuildpressurelimit = true;
@@ -200,6 +197,7 @@ void LoadConfigurationParameters(ConfigurationParameters *Params)
             EmbeddedParameters->dispenserbuildpressuretimeout=150000;
             EmbeddedParameters->has_dispenserbuildpressurelag = true;
             EmbeddedParameters->dispenserbuildpressurelag=50;
+
             EmbeddedParameters->has_acheatersloweroperationlimit = true;
             EmbeddedParameters->acheatersloweroperationlimit = 980;
             EmbeddedParameters->has_acheatersupperoperationlimit = true;
@@ -208,12 +206,13 @@ void LoadConfigurationParameters(ConfigurationParameters *Params)
             EmbeddedParameters->dcheatersloweroperationlimit = 978;
             EmbeddedParameters->has_dcheatersupperoperationlimit = true;
             EmbeddedParameters->dcheatersupperoperationlimit = 1002;
-            EmbeddedParameters->has_midtankpressurecorrection = true;
-            EmbeddedParameters->midtankpressurecorrection = 0.0;
+
             EmbeddedParameters->has_dispenserpresegmentwfcf = true;
             EmbeddedParameters->dispenserpresegmentwfcf = 40;
+
             EmbeddedParameters->has_startheatingoninitsequence = true;
             EmbeddedParameters->startheatingoninitsequence = true; //set to true shlomo 14/5/2019
+
             EmbeddedParameters->n_generalparameters = 8;
             EmbeddedParameters->generalparameters = malloc (sizeof(double)*10);
             if (EmbeddedParameters->generalparameters)
@@ -227,12 +226,12 @@ void LoadConfigurationParameters(ConfigurationParameters *Params)
                 EmbeddedParameters->generalparameters[6] = Diagnostic_Extended_Mode; //Diagnostic Mode SetDiagnosticMode
                 EmbeddedParameters->generalparameters[7] = AutoHoming_JobEnd_PowerOn_off; //
             }
+
             EmbeddedParameters->has_currentalarmlowlimit = true;
             EmbeddedParameters->currentalarmlowlimit = 0.78;
             EmbeddedParameters->has_currentalarmhighlimit = true;
             EmbeddedParameters->currentalarmhighlimit= 1.07;
-            EmbeddedParameters->has_ids_segmentrefilltimeout = true;
-            EmbeddedParameters->ids_segmentrefilltimeout = 5000;
+
             EmbeddedParameters->has_ids_presegmentbuilduptime = true;
             EmbeddedParameters->ids_presegmentbuilduptime = 5000;
             EmbeddedParameters->has_ids_cleaningspeed = true;
@@ -245,6 +244,7 @@ void LoadConfigurationParameters(ConfigurationParameters *Params)
             EmbeddedParameters->ids_leftcleaningmotorspeed = 52;
             EmbeddedParameters->has_ids_rightcleaningmotorspeed = true;
             EmbeddedParameters->ids_rightcleaningmotorspeed = 52;
+
             EmbeddedParameters->has_switchtoidletimeinseconds = true;
             EmbeddedParameters->switchtoidletimeinseconds = 3600;
             EmbeddedParameters->has_idledriertemperature = true;
@@ -315,24 +315,24 @@ uint32_t EmbeddedParametersInit(void)
         }
     }
 
-    if (EmbeddedParameters->n_generalparameters >= 6)
+   /* if (EmbeddedParameters->n_generalparameters >= 6)
     {
         IDS_Dispenser_SetBackLashValues(EmbeddedParameters->initialdispenserpressure, EmbeddedParameters->initialdispensertimeout, EmbeddedParameters->initialdispensertimelag,EmbeddedParameters->generalparameters[5]);
     }
     else
     {
         IDS_Dispenser_SetBackLashValues(EmbeddedParameters->initialdispenserpressure, EmbeddedParameters->initialdispensertimeout, EmbeddedParameters->initialdispensertimelag,1000);
-    }
+    }*/
 
     IDS_Dispenser_SetTimeOutValues(EmbeddedParameters->closevalvetimeout, EmbeddedParameters->openvalvetimeout);
     IDS_Dispenser_SetPrepareValues(EmbeddedParameters->dispenserbuildpressurespeed,   EmbeddedParameters->dispenserbuildpressurelimit, EmbeddedParameters->dispenserbuildpressuretimeout, EmbeddedParameters->dispenserbuildpressurelag);
     IDS_Dispenser_SetPreSegmentWFCFValues(EmbeddedParameters->dispenserpresegmentwfcf,  EmbeddedParameters->ids_presegment_wfcf_timebeforesegment);
     IDS_Dispenser_SetPreSegmentCleaningValues(EmbeddedParameters->ids_cleaningspeed,EmbeddedParameters->ids_cleaningstartspraypresegmenttime ,EmbeddedParameters->ids_cleaningstopbeforesegmenttime,EmbeddedParameters->ids_leftcleaningmotorspeed,EmbeddedParameters->ids_rightcleaningmotorspeed);
 
-    Heaters_SetOverHeatTimeOutValues( EmbeddedParameters->overheatcountlimit,  EmbeddedParameters->underheatcountlimit);
+    //Heaters_SetOverHeatTimeOutValues( EmbeddedParameters->overheatcountlimit,  EmbeddedParameters->underheatcountlimit);
     Heaters_SetOperationLimits(EmbeddedParameters->acheatersloweroperationlimit,EmbeddedParameters->acheatersupperoperationlimit,EmbeddedParameters->dcheatersloweroperationlimit,EmbeddedParameters->dcheatersupperoperationlimit);
-    MidTankPressureCorrection(EmbeddedParameters->midtankpressurecorrection);
-    SetDiagnosticCollectionLimit(EmbeddedParameters->diagnosticcollectionlimit);
+    //MidTankPressureCorrection(EmbeddedParameters->midtankpressurecorrection);
+    //SetDiagnosticCollectionLimit(EmbeddedParameters->diagnosticcollectionlimit);
     ThreadSetBreakSensorLimit(EmbeddedParameters->breaksensorlimit);
     PowerOffSetTemperatureThreshold(EmbeddedParameters->powerofftemperaturelimit);
 
diff --git a/Software/Embedded_SW/Embedded/Modules/General/process.c b/Software/Embedded_SW/Embedded/Modules/General/process.c
index 4cb35d488..5760d5b79 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/process.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/process.c
@@ -31,10 +31,11 @@ double dyeingspeed = 0;
 double dryerbufferlength = 0;
 double mininkuptake = 0;
 double feedertension = 0;
-double pullertension = 0;
-double windertension = 0;
+double pullertension = 5000;
+double windertension = 5000;
 double headairflow = 5.0;
 double dryerairflow = 5.0;
+double pressurebuildup = 0;
 int32_t tableindex = 0;
 
 double dryerbufferMeters = 0;
@@ -273,6 +274,7 @@ uint32_t HandleProcessParameters(ProcessParameters* ProcessParams,bool saveData)
     windertension = ProcessParams->windertension;
     headairflow = ProcessParams->headairflow;
     dryerairflow = ProcessParams->dryerairflow;
+    pressurebuildup = ProcessParams->pressurebuildup;
 
    return status;//status;
 }
diff --git a/Software/Embedded_SW/Embedded/Modules/General/process.h b/Software/Embedded_SW/Embedded/Modules/General/process.h
index a546ffdbe..695cf9516 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/process.h
+++ b/Software/Embedded_SW/Embedded/Modules/General/process.h
@@ -17,6 +17,8 @@ extern double pullertension;
 extern double windertension;
 extern double headairflow;
 extern double dryerairflow;
+extern double pressurebuildup;
+
 extern int32_t tableindex;
 
 extern double dryerbufferMeters;
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
index ca4255a95..373fdfaec 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
@@ -267,11 +267,11 @@ void HeatersControlInit(void)
     return;
 }
 
-void Heaters_SetOverHeatTimeOutValues(uint32_t OverHeatTimeout, uint32_t UnderHeatTimeout)
+/*void Heaters_SetOverHeatTimeOutValues(uint32_t OverHeatTimeout, uint32_t UnderHeatTimeout)
 {
     Overheat_Count_Limit = OverHeatTimeout;
     Underheat_Count_Limit = UnderHeatTimeout;
-}
+}*/
 void  Heaters_SetOperationLimits(int acheatersloweroperationlimit, int acheatersupperoperationlimit, int dcheatersloweroperationlimit, int dcheatersupperoperationlimit)
 {
     AcHeatersLoweroperationLimit =  acheatersloweroperationlimit;
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
index 6e4eed580..1176d3132 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
@@ -66,7 +66,7 @@ int32_t IdsGetMotorSpeed(uint32_t DispenserId)
 {
     return  CurrentDispenserSpeed[DispenserId];
 }
-
+/*
 uint32_t IDS_Dispenser_Build_Pressure_Callback(uint32_t DispenserId, uint32_t ReadValue)
  {
     uint32_t status;
@@ -128,7 +128,7 @@ uint32_t IDS_Dispenser_Build_Pressure_Callback(uint32_t DispenserId, uint32_t Re
 
     return OK;
 }
-
+*/
  uint32_t IDS_Dispenser_StopMotorCallback(uint32_t DispenserId, uint32_t ReadValue)
  {
      Report("IDS_Dispenser_Close_Valve_And_Stop_Motor callback",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)msec_millisecondCounter,0);
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
index 3b6291285..107fd425b 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
@@ -102,7 +102,7 @@ void IDS_Dispenser_SetBackLashValues(double   initialdispenserpressure,   uint32
     InitialDispenserPressure = initialdispenserpressure;
     InitialDispenserTimeout = initialdispensertimeout;
     InitialDispenserTimeLag = initialdispensertimelag;
-    InitialDispenserSpeed = INITIAL_DISPENSER_SPEED;
+    InitialDispenserSpeed = initialdispenserspeed;
 
     Report("IDS_Dispenser_SetBackLashValues ",__FILE__,InitialDispenserPressure*100,InitialDispenserTimeout,RpWarning,(int)InitialDispenserTimeLag,0);
 }
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
index 0c28ee564..a34594d56 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
@@ -687,20 +687,23 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
     int Motor_i, Pid_Id;
     //start IDS control for all motors
     IDS_Active = true;
+    double cleanerFlow = 0;
     Valve_Set(VALVE_MIXCHIP_WASTECH, Mixer_Waste);
 
-    //JobTicket* JobTicket = JobDetails;
+    JobTicket* JobTicket = JobDetails;
 
     JobEndSequence = false;
-    if ((feedertension>0.1)&&(feedertension<1.5))
+    if ((pressurebuildup>0.1)&&(pressurebuildup<1.5))
     {
-        Report("Setting pressure from RML feeder tension",__FILE__,__LINE__,(int)(feedertension*100),RpWarning,(int)(DispenserPreparePressure*100),0);
-        DispenserPreparePressure = feedertension;
+        Report("Setting pressure from RML feeder tension",__FILE__,__LINE__,(int)(pressurebuildup*100),RpWarning,(int)(DispenserPreparePressure*100),0);
+        DispenserPreparePressure = pressurebuildup;
     }
-    if ((pullertension>200)&&(pullertension<1150))
+    if (JobTicket->headcleaningparameters->has_cleanerflow)
+            cleanerFlow =  JobTicket->headcleaningparameters->cleanerflow;
+    if ((cleanerFlow>200)&&(cleanerFlow<1150))
     {
-        Report("Setting pressure from RML feeder tension",__FILE__,__LINE__,(int)(pullertension),RpWarning,(int)CleaningDispenserSpeed,0);
-        CleaningDispenserSpeed = pullertension;
+        Report("Setting pressure from RML feeder tension",__FILE__,__LINE__,(int)(cleanerFlow),RpWarning,(int)CleaningDispenserSpeed,0);
+        CleaningDispenserSpeed = cleanerFlow;
     }
 
     for (Motor_i = 0;Motor_i < MAX_SYSTEM_DISPENSERS;Motor_i++)
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
index 76a92bd89..7a9b66a0b 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
@@ -368,7 +368,7 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
 
             if(Write_Buf[0] == 0)//Read
             {
-                Head_Read_IO_Reg(Script_Slave_Add, LOW);
+                //Head_Read_IO_Reg(Script_Slave_Add, LOW);
 
                 delayms(1);
                 if(Script_Slave_Add == 0x40)
@@ -403,7 +403,7 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
 
             if(Write_Buf[0] == 1)//Read
             {
-                Head_Read_IO_Reg(Script_Slave_Add, HIGH);
+                //Head_Read_IO_Reg(Script_Slave_Add, HIGH);
 
                 delayms(1);
                 if(Script_Slave_Add == 0x40)
@@ -427,7 +427,7 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
                     response.has_progress = true;
                 }
                 else
-                if(Script_Slave_Add == 0x46)
+                if(Script_Slave_Add == 0x46)//LS
                 {
                     Read_Buf[0] = Head_I2C_EXP4_0x46.uchar[1];
                     response.progress = Read_Buf[0];
@@ -435,6 +435,7 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
                 }
             }
             else
+            /*
             if(Write_Buf[0] == 2)//write
             {
                 if(Script_Slave_Add == 0x40)
@@ -452,7 +453,7 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
                     Head_I2C_EXP4_0x46.uchar[0] = (Write_Buf[1] & 0x80);
                 }
 
-                Head_Write_IO_Reg(Script_Slave_Add, LOW);
+                //Head_Write_IO_Reg(Script_Slave_Add, LOW);
             }
             if(Write_Buf[0] == 3)//write
             {
@@ -463,15 +464,48 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
                 else
                 if(Script_Slave_Add == 0x42)
                 {
-                    Head_I2C_EXP2_0x42.uchar[1] = Write_Buf[1];
+                    //Head_I2C_EXP2_0x42.uchar[1] = Write_Buf[1];
+                    Head_I2C_EXP2_0x42.bits.OUTPUT_MAG_DIR = (Write_Buf[1] & 0x01);//control only the magnet
                 }
                 else
                 if(Script_Slave_Add == 0x46)
                 {
                     Head_I2C_EXP3_0x44.uchar[1] = (Write_Buf[1] & 0x0C);
                 }
-                Head_Write_IO_Reg(Script_Slave_Add, HIGH);
+                //Head_Write_IO_Reg(Script_Slave_Add, HIGH);
             }
+            */
+                if(Write_Buf[0] >=0xF0) // write
+                {
+                    // write , Write_Buf[0] bit number 0..15 , Write_Buf[1] 0 or 1
+                    Write_Buf[1] = Write_Buf[1] & 0x01;
+
+                    Write_Buf[0] &=0x0f;
+
+                    if(Script_Slave_Add == 0x40)
+                    {
+                        if(Write_Buf[1] == 0x01)
+                            Head_I2C_EXP1_0x40.ushort |= (0x01 << Write_Buf[0]);
+                        else if(Write_Buf[1] == 0x00)
+                            Head_I2C_EXP1_0x40.ushort &= ~(0x01 << Write_Buf[0]);
+                    }
+                    else
+                    if(Script_Slave_Add == 0x42)
+                    {
+                        if(Write_Buf[1] == 0x01)
+                            Head_I2C_EXP2_0x42.ushort |= (0x01 << Write_Buf[0]);
+                        else if(Write_Buf[1] == 0x00)
+                            Head_I2C_EXP2_0x42.ushort &= ~(0x01 << Write_Buf[0]);
+                    }
+                    else
+                    if(Script_Slave_Add == 0x46)
+                    {
+                        if(Write_Buf[1] == 0x01)
+                            Head_I2C_EXP4_0x46.ushort |= (0x01 << Write_Buf[0]);
+                        else if(Write_Buf[1] == 0x00)
+                            Head_I2C_EXP4_0x46.ushort &= ~(0x01 << Write_Buf[0]);
+                    }
+                }
         }
         else
     if(request->amount == 0xFEAD)  //functions Head Card I/O
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Motor.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Motor.c
index 1c39385d4..1663219bd 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Motor.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Motor.c
@@ -283,13 +283,13 @@ void Stub_MotorStopRequest(MessageContainer* requestContainer)
     
     Stop_Command = (STOP_TYPE_ENUM)request->stop_cmd;
 
+    TimerMotors_t Motor_Id  = (TimerMotors_t)request->motor_id; //to remove warning
 #ifdef EVALUATION_BOARD
   uint32_t read_status;
 
  //SPI_Control(SKIP_INIT);
     Mot_Stop();
 #else
-    TimerMotors_t Motor_Id  = (TimerMotors_t)request->motor_id; //to remove warning
     MotorStop(Motor_Id, Stop_Command);
 #endif
     if ((Motor_Id >= HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1)&&(Motor_Id <= HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8))
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
index 698852f00..1181082ea 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
@@ -428,9 +428,14 @@
         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);
+        status |= MCU_E2PromProgram(EEPROM_WINDER_TENSION_POSITION,1);
+        if (Is_PP_Machine() == true) //PP machine - new LTFU
+        {
+            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);
+            status |= MCU_E2PromProgram(EEPROM_PULLER_TENSION_POSITION,1);
 
+        }
         return OK;
     }
     uint32_t Thread_Load_Lift_Rockers(void)
@@ -511,12 +516,15 @@
         MotorSetMaxSpeed (HARDWARE_MOTOR_TYPE__MOTO_LDANCER1, 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_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);
+        MotorMoveWithCallback (HARDWARE_MOTOR_TYPE__MOTO_LDANCER1, MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LDANCER1].directionthreadwize, ((int)windertension*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LDANCER1].microstep), Thread_Load_HomingCallback,20000);
+        status |= MCU_E2PromProgram(EEPROM_WINDER_TENSION_POSITION,(int)windertension);
+        if (Is_PP_Machine() == true) //PP machine - new LTFU
+        {
+            CallbackCounter++;
+            MotorSetMaxSpeed (HARDWARE_MOTOR_TYPE__MOTO_LDANCER2, 500);
+            MotorMoveWithCallback (HARDWARE_MOTOR_TYPE__MOTO_LDANCER2, MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LDANCER2].directionthreadwize, ((int)pullertension*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LDANCER2].microstep), Thread_Load_HomingCallback,20000);
+            status |= MCU_E2PromProgram(EEPROM_PULLER_TENSION_POSITION,(int)pullertension);
+        }
 
         return OK;
     }
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
index 78150e9f9..3b97e9eb7 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
@@ -149,9 +149,9 @@ uint32_t Winder_Prepare(void *JobDetails)
     if (FPGA_Read_limit_Switches(GPI_SW_SPOOL_EXISTS)==LIMIT)
     {
         REPORT_MSG(LIMIT, "No cone in winder");
-        PrepareReady(Module_Winder,ModuleFail);
-        AlarmHandlingSetAlarm(EVENT_TYPE__WINDER_CONE_DOES_NOT_EXIST,true);
-        return ERROR;
+        //PrepareReady(Module_Winder,ModuleFail);
+        //AlarmHandlingSetAlarm(EVENT_TYPE__WINDER_CONE_DOES_NOT_EXIST,true);
+        //return ERROR;
     }
 
 #ifdef READ_SCREW_ENCODER
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
index be6644067..fb8fa4711 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
@@ -35,6 +35,7 @@
 #include "modules/ids/ids_ex.h"
 #include "Modules/AlarmHandling/AlarmHandling.h"
 #include "Control/MillisecTask.h"
+#include "drivers/Flash_ram/MCU_E2Prom.h"
 
 ////////////////////////////////State machine operation////////////////////////////////////
 //the state machine operation is used to operate in runtime correct profile flow execution
@@ -789,11 +790,61 @@ uint32_t HandleJobThreadControlParameters(ThreadParameters* ThreadParams)
 
     return OK;
 }
+uint32_t ThreadPrepare_Tension (int DancerId, double tension)
+{
+    int current, request = (int)tension,movement;
+    int HW_Motor_Id;
+    bool direction;
+    uint32_t status = OK, address = 0;
+    switch (DancerId)
+    {
+    case HARDWARE_DANCER_TYPE__LeftDancer:
+        address = EEPROM_WINDER_TENSION_POSITION;
+        HW_Motor_Id = HARDWARE_MOTOR_TYPE__MOTO_LDANCER1;
+        break;
+    case HARDWARE_DANCER_TYPE__MiddleDancer:
+        if (Is_PP_Machine() == false) //LP machine - old LTFU
+            return OK;
+        address = EEPROM_PULLER_TENSION_POSITION;
+        HW_Motor_Id = HARDWARE_MOTOR_TYPE__MOTO_LDANCER2;
+        break;
+    case HARDWARE_DANCER_TYPE__RightDancer:
+        return ERROR;
+    default:
+        return ERROR;
+    }
+    status |= MCU_E2PromRead(address,&current);
+    if ((status!= OK )||(current == 0)||(current == 0xFFFF))
+        return status;
+    if (abs(current - request)<100)
+        return status;
+    else
+    {
+        if (current < request) //go down
+        {
+            direction = MotorsCfg[HW_Motor_Id].directionthreadwize;
+            movement = request - current;
+        }
+        else
+        {
+            direction = 1-MotorsCfg[HW_Motor_Id].directionthreadwize;
+            movement = current - request;
+        }
+        MotorMoveWithCallback (HW_Motor_Id, direction, (movement*MotorsCfg[HW_Motor_Id].microstep), NULL,20000);
+        status |= MCU_E2PromProgram(address,request);
+    }
+    usnprintf(Lenstr, 100, "ThreadPrepare_Tension Dancer %d Request: %d Current %d movement %d dir %d motor %d address %d",
+              DancerId,request,current,movement,direction,HW_Motor_Id,address);
+    ReportWithPackageFilter(ThreadFilter,Lenstr,__FILE__,address,HARDWARE_MOTOR_TYPE__MOTO_DH_LID,RpFatalError,LIMIT,0);
+
+    return status;
+}
 //********************************************************************************************************************
  uint32_t ThreadPrepareState(void *JobDetails)
 {
     int Motor_i,i, HW_Motor_Id, Pid_Id;
     JobTicket* JobTicket = JobDetails;
+    uint32_t status = OK;
     CurrentSegmentId = 0;
 
     JobCounter = 0;
@@ -810,11 +861,22 @@ uint32_t HandleJobThreadControlParameters(ThreadParameters* ThreadParams)
     AlarmHandlingSetAlarm(EVENT_TYPE__WINDER_CONE_DOES_NOT_EXIST,false);
     AlarmHandlingSetAlarm(EVENT_TYPE__FPGA_WATCHDOG_ACTIVATED,false);
 
+//    status |= MCU_E2PromProgram(EEPROM_STORAGE_DANCER_0,DancersCfg[0].zeropoint);
+//      double feedertension = 0;
+//    double pullertension = 0;
+//    double windertension = 0;
 
     EnableLubrication = JobTicket->enablelubrication;
     EnableIntersegment = JobTicket->enableintersegment;
     IntersegmentLength = JobTicket->intersegmentlength;
 
+    status = ThreadPrepare_Tension (HARDWARE_DANCER_TYPE__LeftDancer, windertension);
+    ReportWithPackageFilter(ThreadFilter,"ThreadPrepare_Tension",__FILE__,HARDWARE_DANCER_TYPE__LeftDancer,status,RpFatalError,(int)windertension,0);
+    status = ThreadPrepare_Tension (HARDWARE_DANCER_TYPE__MiddleDancer, pullertension);
+    ReportWithPackageFilter(ThreadFilter,"ThreadPrepare_Tension",__FILE__,HARDWARE_DANCER_TYPE__MiddleDancer,status,RpFatalError,(int)pullertension,0);
+    status = ThreadPrepare_Tension (HARDWARE_DANCER_TYPE__RightDancer, feedertension);
+    ReportWithPackageFilter(ThreadFilter,"ThreadPrepare_Tension",__FILE__,HARDWARE_DANCER_TYPE__RightDancer,status,RpFatalError,(int)feedertension,0);
+
     FirstCalcInJob = true;
     if(MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDRIVING].speedmaster == false)
     {