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

author: Roy Ben Shabat <Roy.mail.net@gmail.com> 2020-08-25 17:50:22 +0300
committer: Roy Ben Shabat <Roy.mail.net@gmail.com> 2020-08-25 17:50:22 +0300
commit: 9bc0807514a69d97fceab11d77bee02aff4eb3d9 (patch)
tree: 2c5ad002ab84443945943adc2ab531ce6fccda22 /Software/Embedded_SW/Embedded
parent: 26b6bf34090634edf23ed5ed1785560c024da02c (diff)
parent: 642dbff4c449d268d18ec4ca7f2ff267876dce14 (diff)
download: Tango-9bc0807514a69d97fceab11d77bee02aff4eb3d9.tar.gz
Tango-9bc0807514a69d97fceab11d77bee02aff4eb3d9.zip
38 files changed, 356 insertions, 200 deletions
diff --git a/Software/Embedded_SW/Embedded/Common/SWUpdate/FirmwareUpgrade.c b/Software/Embedded_SW/Embedded/Common/SWUpdate/FirmwareUpgrade.c
index 013a06e22..3a1a4ab83 100644
--- a/Software/Embedded_SW/Embedded/Common/SWUpdate/FirmwareUpgrade.c
+++ b/Software/Embedded_SW/Embedded/Common/SWUpdate/FirmwareUpgrade.c
@@ -56,14 +56,15 @@ uint32_t ActivateVersionCallBackFunction(uint32_t IfIndex, uint32_t BusyFlag)
     MessageContainer responseContainer;
     bool last = true;
 
-    usnprintf(activateString, 1000, "file %d of %d bytes %d of %d",CurrentRunningFile+1,NumberOfFiles,vme_index,CurrentFileSize);
-
-    Report(activateString,__FILE__,__LINE__,(int)CurrentRunningFile,RpWarning,CurrentFileSize,0);
-
     if (CurrentRunningFile<NumberOfFiles)
     {
         last = false;
     }
+
+    usnprintf(activateString, 1000, "file %d of %d bytes %d of %d last %d",CurrentRunningFile+1,NumberOfFiles,vme_index,CurrentFileSize,last);
+
+    Report(activateString,__FILE__,__LINE__,(int)CurrentRunningFile,RpWarning,CurrentFileSize,0);
+
     responseContainer = createContainer(MESSAGE_TYPE__ActivateVersionResponse,  ActivateToken, last, &response, &activate_version_response__pack, &activate_version_response__get_packed_size);
     responseContainer.has_continuous = true;
     responseContainer.continuous = true;
diff --git a/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c b/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c
index c5e8b14bc..64002276c 100644
--- a/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c
+++ b/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c
@@ -20,7 +20,7 @@ typedef struct
 } TangoVersion_t;
 
 
-TangoVersion_t _gTangoVersion = {1,4,6,41};
+TangoVersion_t _gTangoVersion = {1,4,6,43};
 #define BUILD_DATE __DATE__
 char Dat[50] = BUILD_DATE; 
  char _gTangoName [MAX_STRING_LEN] = "Tango01 ";//e
diff --git a/Software/Embedded_SW/Embedded/delay.c b/Software/Embedded_SW/Embedded/Common/Utilities/delay.c
index ef095fe5b..ef095fe5b 100644
--- a/Software/Embedded_SW/Embedded/delay.c
+++ b/Software/Embedded_SW/Embedded/Common/Utilities/delay.c
diff --git a/Software/Embedded_SW/Embedded/delay.h b/Software/Embedded_SW/Embedded/Common/Utilities/delay.h
index d35c904fd..a070cae1d 100644
--- a/Software/Embedded_SW/Embedded/delay.h
+++ b/Software/Embedded_SW/Embedded/Common/Utilities/delay.h
@@ -5,8 +5,8 @@
  *      Author: avi
  */
 
-#ifndef DELAY_H_
-#define DELAY_H_
+#ifndef COMMON_UTILITIES_DELAY_H_
+#define COMMON_UTILITIES_DELAY_H_
 
 void delayms(uint32_t ui32ms);
 
@@ -14,4 +14,4 @@ void delayUs(uint32_t ui32Us);
 
 
 
-#endif /* DELAY_H_ */
+#endif /* COMMON_UTILITIES_DELAY_H_ */
diff --git a/Software/Embedded_SW/Embedded/Common/report/reportInit.c b/Software/Embedded_SW/Embedded/Common/report/reportInit.c
index 5c8646bf1..7ffbe5b6d 100644
--- a/Software/Embedded_SW/Embedded/Common/report/reportInit.c
+++ b/Software/Embedded_SW/Embedded/Common/report/reportInit.c
@@ -68,7 +68,7 @@ PackageHandle MaintFilter;
 char LogPath[50] = "0://ErrFile.txt";
 
 char protobufToken[36+1] = {0};
-char message[300];
+char RepMessage[300];
 FRESULT LogFresult = FR_OK;
 FIL *LogFileHandle = 0;  //the system supports a single active file
 bool isReportActive(void)
@@ -81,23 +81,32 @@ bool isReportActive(void)
 }
 uint32_t OpenLogFile(void)
 {
-    /*int len;
-        uint32_t Bytes = 0;
-    LogFresult = f_open(LogFileHandle,LogPath,FA_OPEN_ALWAYS | FA_WRITE | FA_READ);
-    if (LogFresult == FR_OK)
+    int len;
+    uint32_t Bytes = 0;
+    LogFileHandle = my_malloc(sizeof(FIL));
+    if (LogFileHandle)
     {
-        if (LogFileHandle->fsize < 100000)
-            f_lseek(LogFileHandle, LogFileHandle->fsize);
-        len = usnprintf(message, 80, "Log File %s %s",__DATE__, __TIME__);
-        LogFresult = f_write(LogFileHandle,message,len,&Bytes );
-    }*/
+        LogFresult = f_open(LogFileHandle,LogPath,FA_READ | FA_WRITE | FA_OPEN_ALWAYS);
+        if (LogFresult == FR_OK)
+        {
+            if (LogFileHandle->fsize < 50000)
+                f_lseek(LogFileHandle, LogFileHandle->fsize);
+            else
+                f_lseek(LogFileHandle, 0);
+            len = usnprintf(RepMessage, 80, "Log File %s %s",__DATE__, __TIME__);
+            LogFresult = f_write(LogFileHandle,RepMessage,len,&Bytes );
+        }
+    }
+    else
+        LogFresult = FR_INT_ERR;
+
     return LogFresult;
 }
 uint32_t CloseLogFile(void)
 {
     /* perform default error output */
-    //LogFresult = f_close(LogFileHandle);
-
+    LogFresult = f_close(LogFileHandle);
+    LogFileHandle = NULL;
     return LogFresult;
 }
 uint32_t LogToFile(char *message,       /* The formatted message                */
@@ -109,13 +118,15 @@ uint32_t LogToFile(char *message,       /* The formatted message
 {
 
         /* print user supplied error code */
-      /*     uint32_t Bytes = 0;
+    uint32_t Bytes = 0;
     int len;
+    if (LogFileHandle == NULL)
+        return OK;
 
-       len = usnprintf(message, 300, "%s, file %s  line %d code %d sev %d,param %d",message,FileName, LineNumber,errorCode, Severity, parameter);
-        LogFresult = f_write(LogFileHandle,message,len,&Bytes );*/
+    len = usnprintf(RepMessage, 300, "\r\n%s, file %s  line %d code %d sev %d,param %d",message,FileName, LineNumber,errorCode, Severity, parameter);
+    LogFresult = f_write(LogFileHandle,RepMessage,len,&Bytes );
 
-        return LogFresult;
+    return LogFresult;
 }
 int ReportResponseFunc(char *message,       /* The formatted message                */
                        char *FileName,
@@ -315,6 +326,8 @@ uint32_t ReportInitMessage(MessageContainer* requestContainer)
 
     StartDebugLogRequest* request = start_debug_log_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
     ustrncpy (protobufToken, requestContainer->token,36);
+    if (LogFileHandle != NULL)
+		f_sync(LogFileHandle);
     DistributorHandle ReportHandle = ReportAddDistributor("ProtoBuf");
     //CloseLogFile();
     if (ReportHandle == NULL) status |= 0x8;
diff --git a/Software/Embedded_SW/Embedded/Communication/CommunicationTask.c b/Software/Embedded_SW/Embedded/Communication/CommunicationTask.c
index c846ae0a3..4874e82c3 100644
--- a/Software/Embedded_SW/Embedded/Communication/CommunicationTask.c
+++ b/Software/Embedded_SW/Embedded/Communication/CommunicationTask.c
@@ -9,7 +9,7 @@
 #include "drivers/Uart_Comm/uart.h"
 #include "communicationTask.h"
 #include <Container.h>
-#include "delay.h"
+#include <Utilities/delay.h>
 #include "modules/Diagnostics/Diagnostics.h"
 #include "drivers/Uart_Comm/uart.h"
 
@@ -37,15 +37,16 @@ struct serialBuffer {
 } typedef SerialBuffer;
 #define SHORT_BUFFER_SIZE 100
 char CommShortRxBuffer[10][SHORT_BUFFER_SIZE];
-char CommRxBuffer[2][COMM_MAX_BUFFER_SIZE];
-SerialBuffer inBuffer[12];
-bool SerialBufferUsed[12] = {false,false,false,false,false,false,false,false,false,false,false,false};
+char CommRxBuffer[COMM_MAX_BUFFER_SIZE];
+SerialBuffer inBuffer[11];
+bool SerialBufferUsed[11] = {false,false,false,false,false,false,false,false,false,false,false};
 uint32_t initArray(size_t initialSize)
 {
   if (initialSize >= COMM_MAX_BUFFER_SIZE) return 0xFF;
   if (initialSize > SHORT_BUFFER_SIZE)
   {
-      if ((SerialBufferUsed[10] == true)&&(SerialBufferUsed[11] == true))
+      //if ((SerialBufferUsed[10] == true)&&(SerialBufferUsed[11] == true))
+      if (SerialBufferUsed[10] == true)
       {
           return 0xFF;
       }
@@ -60,7 +61,7 @@ uint32_t initArray(size_t initialSize)
               //Report("initArray", __FILE__, 10, inBuffer[10].size, RpWarning,   (int)0, 0);
               return 10;
           }
-          else if (SerialBufferUsed[11] == false)
+          /*else if (SerialBufferUsed[11] == false)
           {
               SerialBufferUsed[11] = true;
               inBuffer[11].buffer = CommRxBuffer;
@@ -68,7 +69,7 @@ uint32_t initArray(size_t initialSize)
               inBuffer[11].size = initialSize;
               //Report("initArray", __FILE__, 10, inBuffer[10].size, RpWarning,   (int)0, 0);
               return 11;
-          }
+          }*/
           else return 0xFF;
       }
   }
diff --git a/Software/Embedded_SW/Embedded/DataDef.h b/Software/Embedded_SW/Embedded/DataDef.h
index 310af654e..2b104a521 100644
--- a/Software/Embedded_SW/Embedded/DataDef.h
+++ b/Software/Embedded_SW/Embedded/DataDef.h
@@ -23,7 +23,7 @@
 #define WATCHDOG
 //#define DISPESER_TEST
 //#define FPGA_WATCHDOG_DISABLE
-
+//#define FOUR_WINDERS
 //#define USE_POWERSTEP01 -NA
 
 //#define EMC_FORCE_MOT_CLOCK_INTERNAL
diff --git a/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_GPIO/FPGA_GPIO.c b/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_GPIO/FPGA_GPIO.c
index fba22d732..f8e8d7b9e 100644
--- a/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_GPIO/FPGA_GPIO.c
+++ b/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_GPIO/FPGA_GPIO.c
@@ -11,7 +11,6 @@
 #include <DataDef.h>
 #include "modules/control/millisecTask.h"
 #include "modules/thread/thread.h"
-#include "delay.h"
 #include "FPGA_GPIO.h"
 #include "drivers/FPGA/FPGA.h"
 #include "StateMachines/Printing/PrintingSTM.h"
@@ -19,6 +18,7 @@
 
 #include "Drivers/I2C_Communication/Head_Card/IO_Ports/Head_IO.h"
 #include <Drivers/I2C_Communication/I2C_Task.h>
+#include <Utilities/delay.h>
 
 FPGA_GPI FPGA_Gpi;
 
@@ -543,9 +543,10 @@ uint32_t MagnetCallBackFunction(uint32_t IfIndex, uint32_t BusyFlag)
     if(Head_Type == HEAD_TYPE_FLAT)
         Trigger_Head_Magnet(DISABLE_MAGNET);
         //HeadCard_HeadMagnet_Disable();
+#ifndef FOUR_WINDERS
     else
         MotorStop(HARDWARE_MOTOR_TYPE__MOTO_RLOADARM,Hard_Hiz );
-
+#endif
     if (SafeRemoveControlCallback(MagnetControlId, MagnetCallBackFunction )==OK)
         MagnetControlId = 0xFF;
     else
@@ -569,6 +570,7 @@ uint32_t ActivateHeadMagnet()
         F2_CTRL = F2_CTRL_Reg.ushort;
 #endif
     }
+#ifndef FOUR_WINDERS
     if (isMotorConfigured(HARDWARE_MOTOR_TYPE__MOTO_RLOADARM))
     {
         if (MotorDriverResponse[HARDWARE_MOTOR_TYPE__MOTO_RLOADARM].DriverType == CombinrdMotDriver)
@@ -576,6 +578,7 @@ uint32_t ActivateHeadMagnet()
         else
             MotorGoTo(HARDWARE_MOTOR_TYPE__MOTO_RLOADARM,DH_LID_CLOSE );
     }
+#endif
     MagnetControlId = AddControlCallback(NULL, MagnetCallBackFunction, 2* eOneSecond, TemplateDataReadCBFunction,0,0, 0 );
     return OK;
 }
@@ -603,6 +606,7 @@ uint32_t DeActivateHeadMagnet()
 #endif
     }
     Report("DeActivateHeadMagnet - open the lid magnet",__FILE__,__LINE__,(int)HARDWARE_MOTOR_TYPE__MOTO_RLOADARM,RpWarning,(int)DH_LID_CLOSE,0);
+#ifndef FOUR_WINDERS
     if (isMotorConfigured(HARDWARE_MOTOR_TYPE__MOTO_RLOADARM))
     {
         if (MotorDriverResponse[HARDWARE_MOTOR_TYPE__MOTO_RLOADARM].DriverType == CombinrdMotDriver)
@@ -611,6 +615,7 @@ uint32_t DeActivateHeadMagnet()
             MotorGoTo(HARDWARE_MOTOR_TYPE__MOTO_RLOADARM,DH_LID_OPEN );
         //MotorGotoWithCallback(HARDWARE_MOTOR_TYPE__MOTO_RLOADARM, DH_LID_OPEN, Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_RLOADARM], NULL,1000);
     }
+#endif
     //MagnetControlId = AddControlCallback(NULL, MagnetCallBackFunction, 2* eOneSecond, TemplateDataReadCBFunction,0,0, 0 );
     Task_sleep(500);
     return OK;
diff --git a/Software/Embedded_SW/Embedded/Drivers/FPGA/Full_Vme/ispvme/hardware.c b/Software/Embedded_SW/Embedded/Drivers/FPGA/Full_Vme/ispvme/hardware.c
index 2e3b3c3ff..549a41477 100644
--- a/Software/Embedded_SW/Embedded/Drivers/FPGA/Full_Vme/ispvme/hardware.c
+++ b/Software/Embedded_SW/Embedded/Drivers/FPGA/Full_Vme/ispvme/hardware.c
@@ -29,13 +29,12 @@
 #include <stdio.h>
 #include <stdint.h>
 #include <string.h>
+#include <Utilities/delay.h>
 #include "inc/hw_memmap.h"
 #include "inc/hw_types.h"
 #include "driverlib/gpio.h"
 #include "Drivers/FPGA/Full_Vme/FPGA_Programming_Up.h"
 
-#include "delay.h"
-
 #include "vmopcode.h"
 
 #include "Drivers/FPGA/Full_vme/FPGA_Programming_Up.h"
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 0118e029e..5bac56231 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
@@ -483,7 +483,7 @@ uint32_t Read_Head_MixChip_Heaters_Current(HEATERS_CURRENT Heater_ID) //0-5
 
     if (Heater_ID>=NUM_OF_CURRENT_HEATERS)
         return ERROR;
-    #warning need to change the hardware://there is overflow in Dyer Head zone 4 with resistor 0.05
+    //#warning need to change the hardware://there is overflow in Dyer Head zone 4 with resistor 0.05
     const double Resistor[NUM_OF_CURRENT_HEATERS] = {0.025, 0.025, 0.025, 0.025, 0.020, 0.025};
 
     if (Heaters_Current_Read_Enable[Heater_ID] == false)
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Dispenser_Card/EEPROM/Dispenser_EEPROM.c b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Dispenser_Card/EEPROM/Dispenser_EEPROM.c
index d9f5385f6..9023f8250 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Dispenser_Card/EEPROM/Dispenser_EEPROM.c
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Dispenser_Card/EEPROM/Dispenser_EEPROM.c
@@ -106,8 +106,8 @@ uint32_t Dispenser_EEPROM_Read_Data(uint8_t Dispenser_ID)//0..7
 uint32_t test_disp_eeprom(uint8_t Dispenser_ID , uint8_t EEprom_Add)//0..7
 {
     uint32_t status= OK;
-    uint32_t i;
-/*
+/*    uint32_t i;
+
     Dispenser_struct[Dispenser_ID].Write_Disp_EEPROM.bytes.Dispebser_Data.SN = 0x12345678;
     Dispenser_struct[Dispenser_ID].Write_Disp_EEPROM.bytes.Nl_Pulse_Value = 0xAB;
     Dispenser_struct[Dispenser_ID].Write_Disp_EEPROM.bytes.Flow_Pass_Fail = 0xCD;
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Dispenser_Card/IO_Ports/Dispenser_IO.c b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Dispenser_Card/IO_Ports/Dispenser_IO.c
index 45da809af..445d835c5 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Dispenser_Card/IO_Ports/Dispenser_IO.c
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Dispenser_Card/IO_Ports/Dispenser_IO.c
@@ -9,11 +9,11 @@
 
 #include <stdbool.h>
 #include <stdint.h>
-#include <delay.h>
 #include <DataDef.h>
 #include <Drivers/I2C_Communication/Dispenser_Card/I2C_Dispenser_Card_Mux.h>
 #include <Drivers/I2C_Communication/Dispenser_Card/IO_Ports/Dispenser_IO.h>
 #include <Drivers/I2C_Communication/I2C.h>
+#include <Utilities/delay.h>
 
 //TCA9534Regs* Disp_IO_Reg;
 TCA9534Regs Regs;
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/RFID_NFC/I2C_IFS_Mux.c b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/RFID_NFC/I2C_IFS_Mux.c
index 9be6a90b9..4057b4912 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/RFID_NFC/I2C_IFS_Mux.c
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/RFID_NFC/I2C_IFS_Mux.c
@@ -10,12 +10,12 @@
 #include <stdbool.h>
 #include <string.h> //memset
 #include <DataDef.h>
-#include "delay.h"
 #include "driverlib/sysctl.h"
 #include "driverlib/i2c.h"
 #include <Drivers/I2C_Communication/I2C.h>
 #include "drivers/FPGA/FPGA_Comm.h"
 #include <Drivers/I2C_Communication/RFID_NFC/PN7150/PN7150.h>
+#include <Utilities/delay.h>
 #include "I2C_IFS_Mux.h"
 #include "NFC_MainBaord.h"
 #include "Modules/Control/Control.h"
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/RFID_NFC/NFC.c b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/RFID_NFC/NFC.c
index 8da522961..a1139591d 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/RFID_NFC/NFC.c
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/RFID_NFC/NFC.c
@@ -10,12 +10,12 @@
 #include <string.h> //memset
 #include <DataDef.h>
 #include "datadef.h"
-#include "delay.h"
 #include "drivers/I2C_Communication/I2C.h"
 #include "drivers/I2C_Communication/RFID_NFC/I2C_IFS_Mux.h"
 #include "drivers/I2C_Communication/RFID_NFC/logi-tag/LT_RFID.h"
 #include <Drivers/I2C_Communication/RFID_NFC/NFC_MainBaord.h>
 #include <Drivers/I2C_Communication/RFID_NFC/NFC.h>
+#include <Utilities/delay.h>
 
 RFID_TAG_State_Machine    TagStage = Tag_Idle;
 
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/RFID_NFC/NFC_MainBaord.c b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/RFID_NFC/NFC_MainBaord.c
index bc8ef08e0..74b00f4ad 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/RFID_NFC/NFC_MainBaord.c
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/RFID_NFC/NFC_MainBaord.c
@@ -14,7 +14,6 @@
 #include "driverlib/sysctl.h"
 #include <Drivers/I2C_Communication/I2C.h>
 #include "drivers/FPGA/FPGA_Comm.h"
-#include "delay.h"
 #include <Drivers/I2C_Communication/RFID_NFC/PN7150/PN7150.h>
 #include <Drivers/I2C_Communication/RFID_NFC/Test_RFID.h>
 #include "drivers/I2C_Communication/RFID_NFC/logi-tag/LT_RFID.h"
@@ -22,6 +21,7 @@
 #include "Drivers/I2C_Communication/RFID_NFC/NFC.h"
 #include "driverlib/i2c.h"
 #include <Drivers/I2C_Communication/RFID_NFC/logi-tag/LT_NFC.h>
+#include <Utilities/delay.h>
 //#include <Drivers/I2C_Communication/RFID_NFC/logi-tag/LT_NFC.h>
 //#include <Drivers/I2C_Communication/RFID_NFC/logi-tag/LT_NFC_Settings.h>
 //#include <Drivers/I2C_Communication/RFID_NFC/I2C_IFS_Mux.h>
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/WHS_Card/D_ADS122_PT100/WHS_PT100_ADC.c b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/WHS_Card/D_ADS122_PT100/WHS_PT100_ADC.c
index 3e5ed6ab5..6c2d54111 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/WHS_Card/D_ADS122_PT100/WHS_PT100_ADC.c
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/WHS_Card/D_ADS122_PT100/WHS_PT100_ADC.c
@@ -267,8 +267,6 @@ bool  WHS_PT100_Read(TEMPERATURE_SENSOR_ID_ENUM SensorId)
                break;
        }
 
-    #warning what to do with the data   ??????? //- see TempSensorResponse[SensorId].Temperature_C_mult_by_100
-
     return Status;
 }
 
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 002bfa25f..764ef0d44 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
@@ -465,7 +465,7 @@ bool WHS_Set_Blower_Control_Closed_Loop(double Q_value)
         close_loop_time = 15;
         if (midtank_cleared < NUM_OF_MIDTANKS)
         {
-#warning open waiting midtank both valves for 15 seconds
+//#warning open waiting midtank both valves for 15 seconds
             Valve_Set(IDS_Id_to_AirValve[midtank_cleared], Atm_MidTank_ON );   //Atm_MidTank_OFF/ON
             Valve_Set(IDS_Id_to_CartrideValve[midtank_cleared], Atm_MidTank_ON );   //Atm_MidTank_OFF/ON
         }
@@ -475,7 +475,7 @@ bool WHS_Set_Blower_Control_Closed_Loop(double Q_value)
     {
         if (midtank_cleared < NUM_OF_MIDTANKS)
         {
-#warning close waiting midtank both valves for 15 seconds
+//#warning close waiting midtank both valves for 15 seconds
             Valve_Set(IDS_Id_to_AirValve[midtank_cleared], Atm_MidTank_OFF );   //Atm_MidTank_OFF/ON
             Valve_Set(IDS_Id_to_CartrideValve[midtank_cleared], Atm_MidTank_OFF );   //Atm_MidTank_OFF/ON
             midtank_cleared = NUM_OF_MIDTANKS;
@@ -613,7 +613,7 @@ char whs_str[150];
 uint32_t WHS_Pid_Testing_Func(double setParam,double measuredParam)
 {
     float calculated_speed;
-    float avreageSampleValue = 0;
+    //float avreageSampleValue = 0;
     int i;
 
     /*WhsBlowerSamples[WhsBlowerSamplesPointer] = measuredParam;//(-1 * TranslatedReadValue);
diff --git a/Software/Embedded_SW/Embedded/Drivers/Motors/MotorActions.c b/Software/Embedded_SW/Embedded/Drivers/Motors/MotorActions.c
index bc8288ded..f500104f4 100644
--- a/Software/Embedded_SW/Embedded/Drivers/Motors/MotorActions.c
+++ b/Software/Embedded_SW/Embedded/Drivers/Motors/MotorActions.c
@@ -52,6 +52,39 @@ uint32_t MotorTimeLag[NUM_OF_MOTORS];
 uint32_t MotorTimeLimit[NUM_OF_MOTORS];
 uint32_t MotorControlId[NUM_OF_MOTORS];
 uint32_t StoredMotorPosition[NUM_OF_MOTORS];
+#ifdef FOUR_WINDERS
+FPGA_GPI_ENUM     Motor_Id_to_LS_IdDown[NUM_OF_MOTORS] = { // limit switch for normal homing into working mode
+      GPI_LS_DH_CLEAN_LEFT    , //MOTO_DH_CLEANHEAD = 0, Shlomo Correct setting for machine 7 25/3
+      GPI_LS_DH_CLEAN_RIGHT, //MOTO_DH_CLEANMECH = 1, Shlomo Correct setting for machine 7 25/3
+      GPI_LS_DH_LID_CLOSED, //MOTO_DH_LID = 2,
+      MAX_GPI, //MOTO_DRYER_DRIVING = 3,
+      GPI_LS_DRYER_LID_CLOSED, //MOTO_DRYER_LID = 4,
+      MAX_GPI, //MOTO_DRYER_LOADARM = 5,
+      GPI_LS_DISPENSER_DOWN_1, //MOTO_DISPENSER_1 = 6,
+      GPI_LS_DISPENSER_DOWN_2, //MOTO_DISPENSER_2 = 7,
+      GPI_LS_DISPENSER_DOWN_3, //MOTO_DISPENSER_3 = 8,
+      GPI_LS_DISPENSER_DOWN_4, //MOTO_DISPENSER_4 = 9,
+      GPI_LS_DISPENSER_DOWN_5, //MOTO_DISPENSER_5 = 10,
+      GPI_LS_DISPENSER_DOWN_6, //MOTO_DISPENSER_6 = 11,
+      GPI_LS_DISPENSER_DOWN_7, //MOTO_DISPENSER_7 = 12,
+      GPI_LS_DISPENSER_DOWN_8, //MOTO_DISPENSER_8 = 13,
+      GPI_LS_SCREW_RIGHT, //MOTO_SCREW = 14,
+      MAX_GPI, //MOTO_WINDER = 15,
+      GPI_LS_LDANCER1_DOWN, //MOTO_LDANCER1 = 16,
+      GPI_LS_LSPARE1, //MOTO_LDANCER2 = 17,
+      MAX_GPI, //MOTO_LDRIVING = 18,
+      GPI_LS_LLOADMOTOR_DOWN, //MOTO_LLOADING = 19,
+      GPI_LS_LPIVOT_DOWN, //MOTO_LPIVOT1 = 20,
+      GPI_LS_RDANCER_UP, //MOTO_RDANCER = 21,
+      MAX_GPI, //MOTO_RDRIVING = 22,
+      GPI_LS_RDANCER_LONG, //MOTO_RLOADARM = 23,
+      GPI_LS_RLOADMOTOR_DOWN, //MOTO_RLOADING = 24,
+      GPI_LS_SPARE1_2, //HARDWARE_MOTOR_TYPE__MOTO_SPARE1_1 = 25,
+      MAX_GPI, //HARDWARE_MOTOR_TYPE__MOTO_SPARE1_2 = 26,
+      GPI_LS_SPARE2_2, //HARDWARE_MOTOR_TYPE__MOTO_SPARE2_1 = 27,
+      MAX_GPI, //HARDWARE_MOTOR_TYPE__MOTO_SPARE2_2 = 28,
+};
+#else
 FPGA_GPI_ENUM     Motor_Id_to_LS_IdDown[NUM_OF_MOTORS] = { // limit switch for normal homing into working mode
       GPI_LS_DH_CLEAN_LEFT    , //MOTO_DH_CLEANHEAD = 0, Shlomo Correct setting for machine 7 25/3
       GPI_LS_DH_CLEAN_RIGHT, //MOTO_DH_CLEANMECH = 1, Shlomo Correct setting for machine 7 25/3
@@ -79,6 +112,7 @@ FPGA_GPI_ENUM     Motor_Id_to_LS_IdDown[NUM_OF_MOTORS] = { // limit switch for n
       GPI_LS_RDANCER_LONG, //MOTO_RLOADARM = 23,
       GPI_LS_RLOADMOTOR_DOWN, //MOTO_RLOADING = 24,
 };
+#endif
 FPGA_GPI_ENUM     Motor_Id_to_LS_IdUp[NUM_OF_MOTORS] = { // limit switch for normal homing out of working mode
       GPI_LS_DH_CLEAN_LEFT    , //MOTO_DH_CLEANHEAD = 0, Shlomo Correct setting for machine 7 25/3
       GPI_LS_DH_CLEAN_RIGHT, //MOTO_DH_CLEANMECH = 1, Shlomo Correct setting for machine 7 25/3
@@ -475,7 +509,7 @@ uint32_t MotorMoveCallBackFunction(uint32_t IfIndex, uint32_t BusyFlag) //TODO
             printBusy = false;
         }*/
            //stop this control loop
-        Report("MotorControlGetnBusyState stop",__FILE__,__LINE__,BusyFlag,RpMessage,MotorTimeout[MotorId],0);
+        Report("MotorControlGetnBusyState stop",__FILE__,MotorId,BusyFlag,RpMessage,MotorTimeout[MotorId],0);
            SafeRemoveControlCallback(MotorControlId[MotorId], MotorMoveCallBackFunction );
            MotorControlCallback[MotorId] = 0;
            MotorControlId[MotorId] = 0xFF;
@@ -688,8 +722,7 @@ uint32_t MotorMovetoLimitSwitch (TimerMotors_t MotorId,bool direction, uint32_t
             /*if (Head_Type == HEAD_TYPE_FLAT)
             {
                 Report("Close_actuators",__FILE__,__LINE__,LOW,RpMessage,true,0);
-                Trigger_Head_Actuators_Control(ACTOT, LOW,false);
-                //Trigger_Head_Actuators_Control(ACTIN, LOW,false);
+                Trigger_Head_Actuators_Stub(ACTOT, ENABLE, DOWN);
                 HeadCard_Actuators_Relocate();
             }*/
         }
@@ -901,7 +934,7 @@ void MotorActionsInit(void)
         MotorDriverResponse[i].Status = 0xFFFFFFFF;
         StoredMotorPosition[i] = 0;
     }
-    if (Head_Type == HEAD_TYPE_FLAT)//adjust the limit switches
+    if ((Head_Type == HEAD_TYPE_FLAT)||(Head_Type == HEAD_TYPE_ARC))//adjust the limit switches
     {
         Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_DH_LID] = I2C_HEADCARD_COVER_LS_FRONT;
         Motor_Id_to_LS_IdUp  [HARDWARE_MOTOR_TYPE__MOTO_DH_LID] = I2C_HEADCARD_COVER_LS_REAR ;
diff --git a/Software/Embedded_SW/Embedded/Drivers/SSI_Comm/Dancer/Dancer.h b/Software/Embedded_SW/Embedded/Drivers/SSI_Comm/Dancer/Dancer.h
index 6598b88c2..4f864eaca 100644
--- a/Software/Embedded_SW/Embedded/Drivers/SSI_Comm/Dancer/Dancer.h
+++ b/Software/Embedded_SW/Embedded/Drivers/SSI_Comm/Dancer/Dancer.h
@@ -17,8 +17,8 @@ uint32_t Read_Dryer_Status(HardwareDancerType DancerId);
 
 void Loop_SSI();
 
-void test_dancer_responce_RTFU(bool motor_direction);
-void test_dancer_responce_RTFU();
+//void test_dancer_responce_RTFU(bool motor_direction);
+void test_dancer_responce_RTFU(void);
 
 
 extern bool test_dancer_direction, test_dancer_flag;
diff --git a/Software/Embedded_SW/Embedded/Drivers/flash_ram/MCU_E2Prom.c b/Software/Embedded_SW/Embedded/Drivers/flash_ram/MCU_E2Prom.c
index e2d0443b4..3389d941c 100644
--- a/Software/Embedded_SW/Embedded/Drivers/flash_ram/MCU_E2Prom.c
+++ b/Software/Embedded_SW/Embedded/Drivers/flash_ram/MCU_E2Prom.c
@@ -245,7 +245,6 @@ void MainCardEEpromReadRequestFunc(MessageContainer* requestContainer)
 
     uint32_t status = PASSED;
     MessageContainer responseContainer;
-    int32_t EEdata = 0;
 
     StubMainCardEEpromReadRequest* request = stub_main_card_eeprom_read_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
 
diff --git a/Software/Embedded_SW/Embedded/Embedded.cfg b/Software/Embedded_SW/Embedded/Embedded.cfg
index 10f94e08c..f41e56966 100644
--- a/Software/Embedded_SW/Embedded/Embedded.cfg
+++ b/Software/Embedded_SW/Embedded/Embedded.cfg
@@ -97,12 +97,12 @@ semaphore7Params.instance.name = "ReconnectSem";
 semaphore7Params.mode = Semaphore.Mode_BINARY;
 Program.global.ReconnectSem = Semaphore.create(null, semaphore7Params);
 
-/*Task.addHookSet({
+Task.addHookSet({
    // registerFxn: '&myRegisterFxn',
    // createFxn: '&myCreateFxn',
    // deleteFxn: '&myDeleteFxn',
-    switchFxn: '&mySwitchFxn'
-});*/
+    switchFxn: '&MyswitchFxn'
+});
 
 var MillisecTaskParams = new Task.Params();
 MillisecTaskParams.instance.name = "MilliSecond";
diff --git a/Software/Embedded_SW/Embedded/Include.h b/Software/Embedded_SW/Embedded/Include.h
index bc0bb6bce..34410bd29 100644
--- a/Software/Embedded_SW/Embedded/Include.h
+++ b/Software/Embedded_SW/Embedded/Include.h
@@ -50,8 +50,8 @@
 
 #include "Common/Utilities/Utils.h"
 #include "Common/report/report.h"
+#include "Common/Utilities/delay.h"
 #include "DataDef.h"
-#include "delay.h"
 
 #define SYS_CLK_FREQ                120000000
 
diff --git a/Software/Embedded_SW/Embedded/Main.c b/Software/Embedded_SW/Embedded/Main.c
index d22ee2006..d6f74dd48 100644
--- a/Software/Embedded_SW/Embedded/Main.c
+++ b/Software/Embedded_SW/Embedded/Main.c
@@ -81,7 +81,6 @@
 #include "Modules/Waste/Waste.h"
 #include <Drivers/I2C_Communication/Dispenser_Card/IO_Ports/Dispenser_IO.h>
 #include "Drivers/I2C_Communication/Main_Board_EEPROM/Main_EEPROM.h"
-#include "delay.h"
 #include "Drivers/I2C_Communication/Head_Card/IO_Ports/Head_IO.h"
 #include "Drivers/I2C_Communication/Head_Card/EEPROM/Head_EEPROM.h"
 #include "modules/AlarmHandling/AlarmHandling.h"
@@ -94,6 +93,7 @@
 #include <Drivers/I2C_Communication/RFID_NFC/NFC.h>
 
 #include <Drivers/I2C_Communication/RFID_NFC/NFC_MainBaord.h>
+#include <Utilities/delay.h>
 //*****************************************************************************
 //
 // The system tick rate expressed both as ticks per second and a millisecond
@@ -122,71 +122,69 @@ Error_Id eid;
 int eCode;
 char ErrorPath[50] = "0://ErrFile.txt";
 bool UpdateFlag = false;
+bool FirstErrorFlag = true;
+Task_Handle PrevTask,NextTask;
+extern FIL *LogFileHandle;
+/* ======== Function switchHook ======== */
+Void MyswitchFxn(Task_Handle prev, Task_Handle next)
+{
+    PrevTask = prev;
+    NextTask = next;
+}
+
 /* ======== errHook ======== */
 Void errHook(Error_Block *eb)
 {
-    /*FRESULT Fresult = FR_OK;
-    FIL *FileHandle = 0;  //the system supports a single active file
+    FRESULT Fresult = FR_OK;
+
     uint32_t Bytes = 0;
-    char File[50] = "";
+    //char File[50] = "";*/
     char message[300];
-    int len;*/
+    int len;
 
     STATUS_GREEN_LED_OFF;
     ACTIVITY_GREEN_LED_OFF;
     COMM_GREEN_LED_OFF;
 
     STATUS_RED_LED_ON;
-    MCU_E2PromProgram(EEPROM_INIT_FAILURE_COUNTER,InitFailures+1);
-
     ACTIVITY_RED_LED_ON;
     COMM_RED_LED_ON;
-
-    site = Error_getSite(eb);
-    eid = Error_getId(eb);
-    eCode = Error_getCode(eb);
-    //CloseLogFile();
+    ReportStopReporting();
     if (UpdateFlag == true)
         return;
-    /*FileHandle = my_malloc(sizeof(FIL));
-    if (FileHandle == 0)
-        Fresult = FR_DENIED;
-    else
+    if (FirstErrorFlag == true)
     {
-        Fresult = f_open(FileHandle,ErrorPath,FA_OPEN_ALWAYS | FA_WRITE | FA_READ);
-        if (Fresult == FR_OK)
-        {
-            f_lseek(FileHandle, FileHandle->fsize);
-            strncpy(File,site->file,49);
-            len = usnprintf(message, 80, "\r\n%s %s",__DATE__, __TIME__);
-            Fresult = f_write(FileHandle,message,len,&Bytes );
-            // print user supplied error code
-            len = usnprintf(message, 300, "\r\nerror %d, eid %d  mod %d file %s line %d",
-                            eCode, eid,site->mod,
-                            site->file,site->line);
-            Fresult = f_write(FileHandle,message,len,&Bytes );
-
-            //LOG_ERROR (eCode, "error # ");
-            // check originator's mod id against known mods
-            if (site->mod == Main_Module_id()) {
-                Fresult = f_write(FileHandle,"\r\napp error: ",12,&Bytes );
-            }
+        FirstErrorFlag = false;
+        MCU_E2PromProgram(EEPROM_INIT_FAILURE_COUNTER,InitFailures+1);
+        len = usnprintf(message, 300, "\r\nerror task 0x%x %s context prev task 0x%x,%s", PrevTask,Task_Handle_name(PrevTask),NextTask,Task_Handle_name(NextTask));
+        Fresult = f_write(LogFileHandle,message,len,&Bytes );
+        site = Error_getSite(eb);
+        eid = Error_getId(eb);
+        eCode = Error_getCode(eb);
+        // print user supplied error code
+        len = usnprintf(message, 300, "\r\nerror %d, eid %d  mod %d file %s line %d",
+                        eCode, eid,site->mod,
+                        site->file,site->line);
+        Fresult = f_write(LogFileHandle,message,len,&Bytes );
 
-            // check error id against known errors
-            if (eid == Error_E_generic) {
-                Fresult = f_write(FileHandle,"generic: ",10,&Bytes );
-            }
-            else if (eid == Assert_E_assertFailed) {
-                System_printf("assertion violation: ");
-                Fresult = f_write(FileHandle,"\r\nassertion violation: ",22,&Bytes );
-            }
+        //LOG_ERROR (eCode, "error # ");
+        // check originator's mod id against known mods
+        if (site->mod == Main_Module_id()) {
+            Fresult = f_write(LogFileHandle,"\r\napp error: ",12,&Bytes );
+        }
 
-            // perform default error output
-            f_close(FileHandle);
+        // check error id against known errors
+        if (eid == Error_E_generic) {
+            Fresult = f_write(LogFileHandle,"generic: ",10,&Bytes );
+        }
+        else if (eid == Assert_E_assertFailed) {
+            System_printf("assertion violation: ");
+            Fresult = f_write(LogFileHandle,"\r\nassertion violation: ",22,&Bytes );
         }
-        Task_sleep (200);
-        my_free(FileHandle);
-    }*/
+    }
+    CloseLogFile();
+
+
 #ifdef WATCHDOG
     //Power_Reset();
     SysCtlReset();
@@ -245,17 +243,6 @@ int main(void)
     uint32_t Data,i;
 
    MCU_E2PromInit();
-   Data = MCU_E2PromEmbeddedVersionRead();
-   memcpy (&Version,&Data,4);
-   i = memcmp(&Version,&_gTangoVersion,4);
-   if (i)
-   {
-       LOG_ERROR(Version.m_minor,"Version change, do stuff");
-       FlashInit();
-       MCU_E2PromEmbeddedVersionProgram();
-       MCU_E2PromProgram(EEPROM_INIT_FAILURE_COUNTER,0);
-   }
-   MCU_E2PromRead(EEPROM_INIT_FAILURE_COUNTER,&InitFailures);
 
 #endif
     #ifdef EVALUATION_BOARD
@@ -268,7 +255,18 @@ int main(void)
         LOG_ERROR (iFResult, "Error during init Flash File System");
         assert(iFResult);
     }
-    //OpenLogFile();
+    OpenLogFile();
+    Data = MCU_E2PromEmbeddedVersionRead();
+    memcpy (&Version,&Data,4);
+    i = memcmp(&Version,&_gTangoVersion,4);
+    if (i)
+    {
+        LOG_ERROR(Version.m_minor,"Version change, do stuff");
+        FlashInit();
+        MCU_E2PromEmbeddedVersionProgram();
+        MCU_E2PromProgram(EEPROM_INIT_FAILURE_COUNTER,0);
+    }
+    MCU_E2PromRead(EEPROM_INIT_FAILURE_COUNTER,&InitFailures);
 
    Init_All_I2C();
 #ifndef EVALUATION_BOARD
@@ -295,7 +293,6 @@ int main(void)
    FPGA_Init();
 
    Check_IFS_Availability();//Init_IFS();//must be done after FPGA_Init
-
 #endif
 
 	MAP_FPULazyStackingEnable();
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
index c000ad85f..a76142b00 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
@@ -332,26 +332,26 @@ uint32_t DiagnosticsLoadDigitalValues(void)
     DigitalOutputState[index].interfaceio = INTERFACE_IOS__GPI_WCONTAINER_WARN;
     DigitalOutputState[index++].value = WHS_IsContainerEmpty();
 
-    DigitalOutputState[index].interfaceio = INTERFACE_IOS__GPO_SPARE1_1; /*waste lower cartridge presence*/
-    DigitalOutputState[index++].value = WHS_WasteCartridgeLowerPresent();
-
-    DigitalOutputState[index].interfaceio = INTERFACE_IOS__GPO_SPARE1_2; /*waste middle cartridge presence*/
-    DigitalOutputState[index++].value = WHS_WasteCartridgeMiddlePresent();
-
     DigitalOutputState[index].interfaceio = INTERFACE_IOS__GPO_SPARE_SSR12_CTRL; /*lubricant valve*/
     DigitalOutputState[index++].value = GetLubricantState();
 
-    DigitalOutputState[index].interfaceio = INTERFACE_IOS__GPO_TFEED_BREAK_1; /*Secondary Pump Active*/
-    DigitalOutputState[index++].value = SecondaryPumpActive;
-
     DigitalOutputState[index].interfaceio = INTERFACE_IOS__CART1; /*Secondary Pump Active*/
-    DigitalOutputState[index++].value = IFS_CartridgeLowerPresent();
+    DigitalOutputState[index++].value = Is_Cartridge_Present(CART_1);
 
     DigitalOutputState[index].interfaceio = INTERFACE_IOS__CART2; /*Secondary Pump Active*/
-    DigitalOutputState[index++].value = WHS_WasteCartridgeMiddlePresent();
+    DigitalOutputState[index++].value = Is_Cartridge_Present(CART_2);
 
     DigitalOutputState[index].interfaceio = INTERFACE_IOS__CART3; /*Secondary Pump Active*/
-    DigitalOutputState[index++].value = WHS_WasteCartridgeLowerPresent();
+    DigitalOutputState[index++].value = Is_Cartridge_Present(CART_3);
+
+    DigitalOutputState[index].interfaceio = INTERFACE_IOS__GPO_SPARE1_1; /*Waste filling middle cartridge*/
+    DigitalOutputState[index++].value = (cartGetState(WasteCartridge_middle)==CartridgeStateACTIVE)?1:0;
+
+    DigitalOutputState[index].interfaceio = INTERFACE_IOS__GPO_SPARE1_2; /*Waste filling lower cartridge*/
+    DigitalOutputState[index++].value = (cartGetState(WasteCartridge_lower)==CartridgeStateACTIVE)?1:0;
+
+    DigitalOutputState[index].interfaceio = INTERFACE_IOS__GPO_TFEED_BREAK_1; /*IFS MidTank Filling*/
+    DigitalOutputState[index++].value = IFS_MidTankFilling();
 
     return index;
 }
@@ -593,8 +593,8 @@ void DiagnosticOneMinuteCollection(void)
 
     }
     DiagnosticsMonitor.n_overalltemperature = 1;
-    OverallTemperature = max(MillisecGetTemperatures(TEMP_SENSE_AN_ENCLOSURETEMP1),MillisecGetTemperatures(TEMP_SENSE_AN_ENCLOSURETEMP2));
-    OverallTemperature = ((int)(MillisecGetTemperatures(TEMP_SENSE_AN_ENCLOSURETEMP1)/100)*1000 + (int)(MillisecGetTemperatures(TEMP_SENSE_AN_ENCLOSURETEMP2)/100));
+    OverallTemperature = (max(MillisecGetTemperatures(TEMP_SENSE_AN_ENCLOSURETEMP1),MillisecGetTemperatures(TEMP_SENSE_AN_ENCLOSURETEMP2)))/100;
+    //OverallTemperature = ((int)(MillisecGetTemperatures(TEMP_SENSE_AN_ENCLOSURETEMP1)/100)*1000 + (int)(MillisecGetTemperatures(TEMP_SENSE_AN_ENCLOSURETEMP2)/100));
     DiagnosticsMonitor.overalltemperature = &OverallTemperature;
 
     DiagnosticsMonitor.n_midtank1level = 1;
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c
index a3caadf7b..d9f8d30fd 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c
@@ -48,7 +48,7 @@ int kval_upper_value;
 /********************************************************************************
  * Motor Homing
  ********************************************************************************/
-//int32_t keepkvalright,keepkvalleft;
+int32_t keepkvalright,keepkvalleft;
 uint32_t MotorHomingProgressReport(uint32_t deviceID, uint32_t ReadValue)
 {
     if (HomingToken[deviceID][0] == 0)
@@ -89,11 +89,11 @@ uint32_t MotorHomingRequestCallback(uint32_t deviceID, uint32_t ReadValue)
 
     if(deviceID == HARDWARE_MOTOR_TYPE__MOTO_RLOADING)
     {
-        MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_RLOADING, kval_upper_value);
+        MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_RLOADING, keepkvalright);
     }
     if(deviceID == HARDWARE_MOTOR_TYPE__MOTO_LLOADING)
     {
-        MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_LLOADING, kval_upper_value);
+        MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_LLOADING, keepkvalleft);
     }
     if (resetPullerDancer == true)
     {
@@ -102,7 +102,7 @@ uint32_t MotorHomingRequestCallback(uint32_t deviceID, uint32_t ReadValue)
     }
     if (resetWinderDancer == true)
     {
-        resetPullerDancer = false;
+        resetWinderDancer = false;
         MCU_E2PromProgram(EEPROM_WINDER_TENSION_POSITION,1);
     }
     if (HomingControlId[deviceID] != 0xff)
@@ -148,7 +148,7 @@ uint32_t MotorHomingRequestFunc(MessageContainer* requestContainer)
     LoadArmRounds = (int)dryerbufferlength;
 
     if (Is_PP_Machine())
-        kval_upper_value = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].kvalrun;
+        kval_upper_value = 28;
     else
         kval_upper_value = 70;
 
@@ -200,12 +200,12 @@ uint32_t MotorHomingRequestFunc(MessageContainer* requestContainer)
                         }
                         if(MotorId == HARDWARE_MOTOR_TYPE__MOTO_RLOADING)
                         {
-                            //keepkvalright = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].kvalrun;
+                            keepkvalright = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].kvalrun;
                             MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_RLOADING, kval_upper_value);
                         }
                         if(MotorId == HARDWARE_MOTOR_TYPE__MOTO_LLOADING)
                         {
-                            //keepkvalleft = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LLOADING].kvalrun;
+                            keepkvalleft = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LLOADING].kvalrun;
                             MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_LLOADING, kval_upper_value);
                         }
                         MotorMovetoLimitSwitch (MotorId,1-MotorsCfg[MotorId].directionthreadwize, speed,  Motor_Id_to_LS_IdUp[MotorId], MotorHomingRequestCallback,30000);
@@ -241,12 +241,12 @@ uint32_t MotorHomingRequestFunc(MessageContainer* requestContainer)
                     {
                         if(MotorId == HARDWARE_MOTOR_TYPE__MOTO_RLOADING)
                         {
-                            //keepkvalright = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].kvalrun;
+                            keepkvalright = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].kvalrun;
                             MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_RLOADING, kval_upper_value);
                         }
                         if(MotorId == HARDWARE_MOTOR_TYPE__MOTO_LLOADING)
                         {
-                            //keepkvalleft = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LLOADING].kvalrun;
+                            keepkvalleft = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LLOADING].kvalrun;
                             MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_LLOADING, kval_upper_value);
                         }
                         MotorMovetoLimitSwitch (MotorId,MotorsCfg[MotorId].directionthreadwize, speed,  Motor_Id_to_LS_IdDown[MotorId], MotorHomingRequestCallback,30000);
@@ -298,6 +298,16 @@ uint32_t MotorAbortHomingRequestFunc(MessageContainer* requestContainer)
     {
         resetWinderDancer = false;
     }
+    if(MotorId == HARDWARE_MOTOR_TYPE__MOTO_RLOADING)
+    {
+        if (keepkvalright)
+            MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_RLOADING, keepkvalright);
+    }
+    if(MotorId == HARDWARE_MOTOR_TYPE__MOTO_LLOADING)
+    {
+        if (keepkvalleft)
+            MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_LLOADING, keepkvalleft);
+    }
 
     responseContainer = createContainer(MESSAGE_TYPE__MotorAbortHomingResponse,  requestContainer->token, false, &response, &motor_abort_homing_response__pack, &motor_abort_homing_response__get_packed_size);
     responseContainer.continuous = false;
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
index 52e9a6e85..ce3ced6ef 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
@@ -724,7 +724,7 @@ void PrepareACHeater(int HeaterId,uint32_t Frequency, uint32_t SetTemperatue)
     {
         if(Head_Type > HEAD_TYPE_FLAT_WITHOUT_CARD)
         {
-            WHS_Set_SetPoint_Q_value(headairflow*2/3);
+            WHS_Set_SetPoint_Q_value(headairflow);
         }
         else
         {
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_Cleaning.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_Cleaning.c
index abfb5f229..09f5ae108 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_Cleaning.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_Cleaning.c
@@ -123,6 +123,7 @@ uint32_t IDS_Cleaning_Spray_Cleaning_Solution (int dispenserSpeed,callback_fptr
     Tdelay1 = LeftRockerSpeed%100;
     Tdelay2 = RightRockerSpeed;
     status = IDS_Dispenser_Start_Motor_and_Open_Valve(CLEANER_DISPENSER, dispenserSpeed, callback);
+    Init_CleaningStageCounter();
     Report("IDS_Cleaning_Spray_Cleaning_Solution", __FILE__, __LINE__, CLEANER_DISPENSER, RpWarning,   dispenserSpeed, 0);
     Report("IDS_Cleaning parameters", __FILE__, Tup*100, Tdelay1*100, RpWarning,   Tdelay2*100, 0);
 
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h
index 831fa18cd..9973e4c7c 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h
@@ -49,6 +49,7 @@ extern bool ActuatorsCleaningSequence;
 
 extern bool         DispenserUsedInJob[MAX_SYSTEM_DISPENSERS];
 extern int32_t CurrentDispenserSpeed[MAX_SYSTEM_DISPENSERS];
+extern bool DispenserLastMovementDown[MAX_SYSTEM_DISPENSERS];
 
 bool IDS_MapDispenserUsedinJob(void *JobDetails);
 
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
index 8dc12e615..14bb59661 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
@@ -296,6 +296,8 @@ uint32_t IDS_HomeDispenser (uint32_t DispenserId, uint32_t speed , callback_fptr
             Report("IDS_HomeDispenser ",__FILE__,(int)(midTankContent*1000),(int)DispenserId,RpWarning,speed,0);
         }
         CurrentDispenserSpeed[DispenserId] = (-1*CurrentDispenserSpeed[DispenserId]);
+        DispenserLastMovementDown[DispenserId] = true;
+
         return OK;
     }
     return ERROR;
@@ -531,15 +533,24 @@ uint32_t IDS_Check_Pressure_Callback(uint32_t DispenserId, uint32_t ReadValue)
 
     if (GetDispenserPressure(DispenserId)>3.0)
     {
-        Report("Pulling dispenser down to reduce pressure",__FILE__,DispenserId,(int)(GetDispenserPressure(DispenserId)*100),RpWarning,200,0);
+        //10/8/2020 pulling down 2000 steps
+        Report("Pulling dispenser down to reduce pressure",__FILE__,DispenserId,(int)(GetDispenserPressure(DispenserId)*100),RpWarning,2000,0);
         if ((HomingActive[DispenserId] == true)||(PrimingActive[DispenserId] == true))
         {
             Report("Dispenser in pressure but homing active",__FILE__,DispenserId,(int)HomingActive[DispenserId],RpWarning,PrimingActive[DispenserId],0);
             LOG_ERROR(DispenserId,"IDS_Check_Pressure_Callback homing active");
             return ERROR;
         }
-        MotorMove(HW_Motor_Id,1-MotorsCfg[HW_Motor_Id].directionthreadwize,200*MotorsCfg[HW_Motor_Id].microstep);
+        MotorMove(HW_Motor_Id,1-MotorsCfg[HW_Motor_Id].directionthreadwize,2000*MotorsCfg[HW_Motor_Id].microstep);
         AddControlCallback("IDS_ReCheck_Pressure", IDS_ReCheck_Pressure_Callback, eOneSecond*4,TemplateDataReadCBFunction ,DispenserId, 0, 0 );
+        if (GetDispenserPressure(DispenserId)>5.5)
+        {
+            //stop job on pressure rise above 5.5 bar
+            IDS_Dispenser_Alarm_On(DispenserId);
+            //open valve toward mixer on pressure rise above 5.5 bar
+            Task_sleep(100);
+            Control3WayValvesWithCallback ((Valves_t)DispenserId, Dispenser_Mixer, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
+        }
     }
     return OK;
 }
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
index 1d69a2925..9c82cb1bf 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
@@ -452,6 +452,9 @@ c.  Go to step 2.a x Segment.BrushStopsCount.
  uint32_t DispenserPrepareControlId = 0xFF;
  int NumOfActiveDispensers = 0;
  int DispenserBuildTimeCounter = 0;
+#define DISPENSER_UP_MOVEMENT
+ int DispenserTotalPrepareSteps[MAX_SYSTEM_DISPENSERS];
+ bool DispenserLastMovementDown[MAX_SYSTEM_DISPENSERS];
 #define PRESSURE_READ_TIME_GAP 100
 uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
 {
@@ -508,6 +511,7 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
       return OK; // all configured heaters are ready
   }
   char IdsMessage[100];
+  char IdMessage[100];
   int SegmentPrepareWFCFCounter = 0;
   bool pressureReady = false,endOfPrepareWCF = false;
  //********************************************************************************************************************
@@ -532,6 +536,11 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
          {
              if (DispenserBuildTimeCounter<(2*eOneSecond))
              {
+                 for (i = 0; i < MAX_DYE_DISPENSERS; i++)
+                 {
+                     DispenserTotalPrepareSteps[i]+=(CurrentDispenserSpeed[i]*PRESSURE_READ_TIME_GAP/eOneSecond);
+                     DispenserLastMovementDown[i] = false;
+                 }
                  //REPORT_MSG(DispenserBuildTimeCounter,"waiting 2 seconds for pressure changes");
                  return OK;
              }
@@ -541,10 +550,18 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
              //IDS_StopHomeDispenser(i);
              if (DispenserUsedInJob[i] == true) //we actually should check for all dispensers
              {
+                 DispenserTotalPrepareSteps[i]+=(CurrentDispenserSpeed[i]*PRESSURE_READ_TIME_GAP/eOneSecond);
+
                  HW_Motor_Id = DispenserIdToMotorId[i];
                  if (GetDispenserPressure(i) > DispenserPreparePressure*1.05)
                  {
-                     NumofReadyDispensers++;
+#ifdef DISPENSER_UP_MOVEMENT
+                     if (DispenserTotalPrepareSteps[i]>120000)
+#endif
+                     {
+                         NumofReadyDispensers++;
+                         Report("Dispenser total prepare steps ready",__FILE__,DispenserTotalPrepareSteps[i],(int)(DispenserPreparePressure*100),RpWarning,IDS_Dispenser_Data[i].consumedinnanolitter,0);
+                     }
                      if (Special_Dispensers == true)
                      {
                          MotorStop(HW_Motor_Id, Hard_Hiz);
@@ -582,8 +599,9 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
          {
              HW_Motor_Id = DispenserIdToMotorId[CLEANER_DISPENSER];
              MotorStop(HW_Motor_Id, Hard_Hiz);
+             if (CurrentDispenserSpeed[CLEANER_DISPENSER])
+                 Report("IDS stop cleaner",__FILE__,CLEANER_DISPENSER,(int)(GetDispenserPressure(CLEANER_DISPENSER)*100),RpWarning,(int)CurrentDispenserSpeed[CLEANER_DISPENSER] ,0);
              CurrentDispenserSpeed[CLEANER_DISPENSER] = 0;
-             //Report("IDS stop cleaner",__FILE__,CLEANER_DISPENSER,(int)(GetDispenserPressure(CLEANER_DISPENSER)*100),RpWarning,(int)CurrentDispenserSpeed[CLEANER_DISPENSER] ,0);
          }
 
          if ((NumofReadyDispensers)&&(DispenserBuildTimeCounter%1000 == 0))
@@ -599,7 +617,7 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
          {
              DispenserBuildTimeCounter = 0;
              pressureReady = true;
-             Report("pressureReady = true  or timeout;",__FILE__,DispenserBuildTimeCounter,NumofReadyDispensers,RpWarning,(int)NumOfActiveDispensers,0);
+             Report("pressureReady = true  or timeout;",__FILE__,DispenserBuildTimeCounter,NumofReadyDispensers,RpWarning,(int)(DispenserPreparePressure*100),0);
          }
      }
      else if (endOfPrepareWCF == false)
@@ -641,7 +659,6 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
                          }
                          if (segmentfirst_speed > MINIMAL_MOTOR_SPEED)
                          {
-                             char IdMessage[100];
                              segmentfirst_speed *= (100+WFCF);
                              segmentfirst_speed /= 100;
                              DispenserSegmentReady[DispenserId] = false;
@@ -730,7 +747,7 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
     JobTicket* JobTicket = JobDetails;
 
     JobEndSequence = false;
-    if ((pressurebuildup>0.1)&&(pressurebuildup<2.5))
+    if ((pressurebuildup>0.1)&&(pressurebuildup<4.0))
     {
         Report("Setting pressure from RML feeder tension",__FILE__,__LINE__,(int)(pressurebuildup*100),RpWarning,(int)(DispenserPreparePressure*100),0);
         DispenserPreparePressure = pressurebuildup;
@@ -742,7 +759,7 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
     }
     if ((cleanerFlow>200)&&(cleanerFlow<1150))
     {
-        Report("Setting pressure from RML feeder tension",__FILE__,__LINE__,(int)(cleanerFlow),RpWarning,(int)CleaningDispenserSpeed,0);
+        Report("Setting cleanerFlow from RML cleanerFlow",__FILE__,__LINE__,(int)(cleanerFlow),RpWarning,(int)CleaningDispenserSpeed,0);
         CleaningDispenserSpeed = cleanerFlow;
     }
     else if (cleanerFlow <= 10)
@@ -813,6 +830,8 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
                  Report("Stop active dispenser homing ",__FILE__,i,HomingActive[i],RpWarning,CurrentDispenserSpeed[i],0);
                  IDS_StopHomeDispenser(i);
              }
+             DispenserTotalPrepareSteps[i] = 0;
+             Report("Dispenser total prepare steps zero",__FILE__,i,DispenserTotalPrepareSteps[i],RpWarning,IDS_Dispenser_Data[i].consumedinnanolitter,0);
          }
          else
          {
@@ -1220,8 +1239,11 @@ uint32_t IDSCheckSegmentData(void *SegmentDetails, int SegmentId)
     uint32_t status = OK;
     JobDescriptionFileBrushStop * tFileBrushStop;
     int Brush_i;
+    Task_Stat statbuf;
 
 //check and close previous segment
+    RemoveControlCallback(BrushStopControlId,IDSBrushStopRestartCallback);
+    BrushStopControlId = 0xFF;
     if (PrevSegment)
     {
         if (JobBrushStopId<PrevSegment->brushstopscount) //we did not finish reading the brushstops of the previous segment
@@ -1241,6 +1263,10 @@ uint32_t IDSCheckSegmentData(void *SegmentDetails, int SegmentId)
                 }
                 else
                 {
+                    Task_stat(Task_self(),&statbuf);
+                    Report("Unhandled BrushStopRead Error",__FILE__,statbuf.used,(int)statbuf.stackSize,RpWarning,(int)statbuf.stackHeap,0);
+                    //JobEndReason = JOB_OUT_OF_DYE;
+                    //SegmentReady(Module_IDS,ModuleFail);
                     Report("Unhandled brushstops ERROR",__FILE__,__LINE__,(int)tFileBrushStop,RpWarning,(int)PrevSegment->brushstopscount,0);
                     status = ERROR;
                     break;
@@ -1527,7 +1553,7 @@ uint32_t IDSBrushStopRestartCallback(uint32_t IfIndex, uint32_t readValue)
     Task_Stat statbuf;
     if(BrushStopStartTime+BrushStopLength+100 < msec_millisecondCounter   )
     {
-        Report("!!!!!!!!!!!!Overtime!",__FILE__,msec_millisecondCounter,(int)BrushStopStartTime,RpWarning,(int)BrushStopLength,0);
+       Report("!!!!!!!!!!!!Overtime!",__FILE__,msec_millisecondCounter,(int)BrushStopStartTime,RpWarning,(int)BrushStopLength,0);
     }
 
     if(++BrushStopCounter <  BrushStopTime)
@@ -1537,6 +1563,11 @@ uint32_t IDSBrushStopRestartCallback(uint32_t IfIndex, uint32_t readValue)
     BrushStopCounter = 0;
     BrushStopStartTime = msec_millisecondCounter;
 
+    if (BrushStopControlId == 0xFF)
+    {
+        Report("!!!BrushStopControlId = 0xFF",__FILE__,msec_millisecondCounter,(int)BrushStopStartTime,RpWarning,(int)BrushStopLength,0);
+        return OK;
+    }
 
     if (JobEndSequence == true)
     {
@@ -1565,7 +1596,8 @@ uint32_t IDSBrushStopRestartCallback(uint32_t IfIndex, uint32_t readValue)
         }
         else
         {
-            LOG_ERROR(FileBrushStop,"BrushStopReadError");
+            Task_stat(Task_self(),&statbuf);
+            Report("BrushStopRead Error",__FILE__,statbuf.used,(int)statbuf.stackSize,RpWarning,(int)statbuf.stackHeap,0);
             JobEndReason = JOB_OUT_OF_DYE;
             SegmentReady(Module_IDS,ModuleFail);
         }
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
index 151886016..c478b82de 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
@@ -164,7 +164,7 @@
     {
 
         if (Is_PP_Machine())
-            kval_upperValue = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].kvalrun;
+            kval_upperValue = 28;
         else
             kval_upperValue = 70;
 
@@ -208,7 +208,7 @@
         {
             if(Head_Type > HEAD_TYPE_FLAT_WITHOUT_CARD)
             {
-                WHS_Set_SetPoint_Q_value(headairflow*2/3);
+                WHS_Set_SetPoint_Q_value(headairflow);
             }
             else
             {
@@ -349,7 +349,10 @@
         if (Head_Type != HEAD_TYPE_ARC)
         {
             CallbackCounter++;
-            MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_DH_LID,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DH_LID].directionthreadwize, 200,  Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_DH_LID], Thread_Load_HomingCallback,10000);
+            if (MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_DH_LID,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DH_LID].directionthreadwize, 300,  Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_DH_LID], Thread_Load_HomingCallback,20000)==ERROR)
+            {
+                Thread_Load_HomingCallback(HARDWARE_MOTOR_TYPE__MOTO_DH_LID,NO_LIMIT);
+            }
         }
         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);
@@ -366,8 +369,8 @@
         if (Head_Type == HEAD_TYPE_FLAT)
         {
             Report("Thread_Load_Lift_actuators",__FILE__,__LINE__,LOW,RpMessage,false,0);
-            Trigger_Head_Actuators_Control(ACT_IN_AND_OUT, LOW,true);
-            //Trigger_Head_Actuators_Control(ACTIN, LOW,true);
+            Trigger_Head_Actuators_Stub(ACTOT, ENABLE, UP);
+            Trigger_Head_Actuators_Stub(ACTIN, ENABLE, UP);
         }
         return OK;
     }
@@ -395,8 +398,8 @@
     {
         keepmicrostep = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].microstep;
         keepkvalrun = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].kvalrun;
-        if (keepkvalrun>=25)
-            keepkvalrun = 25;
+        /*if (keepkvalrun>=25)
+            keepkvalrun = 25;*/
 
         Report("Read_Dryer_ENC_Position()",__FILE__,__LINE__,0,RpWarning,Read_Dryer_ENC_Position(),0);
 
@@ -428,6 +431,7 @@
         if (FPGA_Read_limit_Switches(GPI_SW_SPOOL_EXISTS)==LIMIT)
         {
             REPORT_MSG(LIMIT, "No cone in winder");
+            Thread_Load_HomingCallback(HARDWARE_MOTOR_TYPE__MOTO_WINDER,NO_LIMIT);
             //return ERROR;
         }
         CallbackCounter++;
@@ -440,8 +444,8 @@
     {
         keepmicrostep = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].microstep;
         keepkvalrun = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].kvalrun;
-        if (keepkvalrun>=25)
-            keepkvalrun = 25;
+        /*if (keepkvalrun>=25)
+            keepkvalrun = 25;*/
         Report("Thread_Load_Close_Rockers",__FILE__,__LINE__,keepkvalrun,RpMessage,keepmicrostep,0);
 
         MotorSetMicroStep(HARDWARE_MOTOR_TYPE__MOTO_RLOADING, 8);
@@ -460,7 +464,7 @@
     uint32_t Thread_Load_Close_Dancers(void)
     //Send Dancer Motors To Preset Location, Check That The Dancers Are On The Thread
     {
-        uint32_t  current = 0;
+        uint32_t  current = 1;
         REPORT_MSG(LoadStages, "Thread Load State Machine step Thread_Load_Close_Dancers");
         CallbackCounter++;
         MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_RDANCER,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDANCER].directionthreadwize, 15,  Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_RDANCER], Thread_Load_HomingCallback,10000);
@@ -500,14 +504,14 @@
         if (Head_Type == HEAD_TYPE_FLAT)
         {
             Report("Thread_Load_Close_actuators",__FILE__,__LINE__,LOW,RpMessage,true,0);
-            Trigger_Head_Actuators_Control(ACTOT, LOW,false);
-            //Trigger_Head_Actuators_Control(ACTIN, LOW,false);
+            Trigger_Head_Actuators_Stub(ACTOT, ENABLE, DOWN);
+            //Trigger_Head_Actuators_Stub(ACTIN, ENABLE, DOWN);
             HeadCard_Actuators_Relocate();
         }
         if (Head_Type != HEAD_TYPE_ARC)
         {
             CallbackCounter++;
-            MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_DH_LID,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DH_LID].directionthreadwize, 200,  Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_DH_LID], Thread_Load_HomingCallback,10000);
+            MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_DH_LID,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DH_LID].directionthreadwize, 300,  Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_DH_LID], Thread_Load_HomingCallback,20000);
         }
         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);
@@ -1227,11 +1231,11 @@ uint32_t ThreadLoadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
     index = IfIndex&0xFF;
 
     DancerId = ThreadMotorIdToDancerId[index];
-    if (ReadValue < 10)
+    /*if (ReadValue < 10)
     {
         Report("Dancer value read too small.",__FILE__,__LINE__,DancerId,RpError,ReadValue,0);
         return OK;
-    }
+    }*/
     if (ReadValue == 0x3FFF)
     {
         return OK;
@@ -1242,6 +1246,11 @@ uint32_t ThreadLoadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
         //pooler dancer is right sided: data is opposite
         TranslatedReadValue = (-1*TranslatedReadValue);
     }
+    if (abs(TranslatedReadValue) > 0x2000)
+    {
+        TranslatedReadValue = 0x3FFF- TranslatedReadValue; //overcome zero environment
+    }
+
     //TranslatedReadValue = 0;//test
     MotorSamples[index][MotorSamplePointer[index]] = TranslatedReadValue;//(-1 * TranslatedReadValue);
     MotorSamplePointer[index]++;
@@ -1469,7 +1478,7 @@ uint32_t ThreadLoadingReport(void)
 
 uint32_t TryThreadLoadingFunc(MessageContainer* requestContainer)
 {
-    TryThreadLoadingRequest *request = continue_thread_loading_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
+    TryThreadLoadingRequest *request = try_thread_loading_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
     TryThreadLoadingResponse Cresponse = TRY_THREAD_LOADING_RESPONSE__INIT;
     MessageContainer responseContainer;
     MessageState = 2;
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
index bb838a5bd..1ce27115d 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
@@ -133,6 +133,7 @@ uint32_t InternalWindingConfigMessage(JobSpool* request)
  * 1. move home to the limit switch (check that the cart is clear from the limit switch, start moving, with acceleration to maximal speed. enable interrupt on the limit switch, upon interrupt stop.
  * report ready to the job STM
  */
+int Screw_wait_counter;
 uint32_t Winder_Prepare(void *JobDetails)
 {
     JobTicket* JobTicket = JobDetails;
@@ -199,11 +200,15 @@ uint32_t Winder_Prepare(void *JobDetails)
         //REPORT_MSG(ScrewSpeed, "Winder_Prepare");
         Winder_ScrewHoming = true;
         //REPORT_MSG(MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].directionthreadwize, "Winder_Prepare move to limit");
+        Screw_wait_counter=1;
         status = MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_SCREW,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].directionthreadwize, ScrewSpeed, GPI_LS_SCREW_RIGHT, Winder_PrepareStage2,2000);
 #ifdef FOUR_WINDERS
-        status = MotorMovetoLimitSwitch (SCREW_2_Motor,MotorsCfg[SCREW_2_Motor].directionthreadwize, ScrewSpeed, 5/*LS_SPARE2_2*/, NULL,2000);
-        status = MotorMovetoLimitSwitch (SCREW_3_Motor,MotorsCfg[SCREW_3_Motor].directionthreadwize, ScrewSpeed, 5/*LS_SPARE1_2*/, NULL,2000);
-        status = MotorMovetoLimitSwitch (SCREW_4_Motor,MotorsCfg[SCREW_4_Motor].directionthreadwize, ScrewSpeed, GPI_LS_RDANCER_UP, NULL,2000);
+        Screw_wait_counter++;
+        status = MotorMovetoLimitSwitch (SCREW_2_Motor,MotorsCfg[SCREW_2_Motor].directionthreadwize, ScrewSpeed, GPI_LS_SPARE2_2, Winder_PrepareStage2,2000);
+        Screw_wait_counter++;
+        status = MotorMovetoLimitSwitch (SCREW_3_Motor,MotorsCfg[SCREW_3_Motor].directionthreadwize, ScrewSpeed, GPI_LS_SPARE1_2, Winder_PrepareStage2,2000);
+        Screw_wait_counter++;
+        status = MotorMovetoLimitSwitch (SCREW_4_Motor,MotorsCfg[SCREW_4_Motor].directionthreadwize, ScrewSpeed, GPI_LS_RDANCER_UP, Winder_PrepareStage2,2000);
 #endif
     }
     return status;
@@ -219,7 +224,7 @@ uint32_t Winder_PrepareStage2(uint32_t deviceID, uint32_t ReadValue)
     uint32_t status=OK;
     uint32_t numOfSteps = WindingConeLocation*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].microstep;
 
-    //MotorSetMaxSpeed (HARDWARE_MOTOR_TYPE__MOTO_SCREW,InternalWinderCfg.segmentoffsetpulses);
+        //MotorSetMaxSpeed (HARDWARE_MOTOR_TYPE__MOTO_SCREW,InternalWinderCfg.segmentoffsetpulses);
     //REPORT_MSG(numOfSteps, "Winder_PrepareStage2");
 #ifdef READ_SCREW_ENCODER
     Read_Screw_Encoder();
@@ -228,11 +233,12 @@ uint32_t Winder_PrepareStage2(uint32_t deviceID, uint32_t ReadValue)
 #endif
 
     REPORT_MSG(millisecondCounter/*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].maxfrequency*/, "Winder_PrepareStage2");
+    Screw_wait_counter--;
     if (ReadValue != LIMIT)
     {
         if (JobIsActive()==true)
         {
-            LOG_ERROR(ReadValue,"Screw failed to reach the limit switch!!");
+            LOG_ERROR(deviceID,"Screw failed to reach the limit switch!!");
             //returned with a timeout
             Winder_ScrewAtOffsetCallback(0,0);
         }
@@ -243,11 +249,20 @@ uint32_t Winder_PrepareStage2(uint32_t deviceID, uint32_t ReadValue)
     }
     else
     {
+        if (Screw_wait_counter!=0)
+        {
+            ReportWithPackageFilter(ThreadFilter,"waiting for winders",__FILE__,__LINE__,Screw_wait_counter,RpWarning,deviceID, 0);
+            return status;
+        }
+        Screw_wait_counter++;
         status |= MotorMoveWithCallback(HARDWARE_MOTOR_TYPE__MOTO_SCREW, (1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].directionthreadwize),numOfSteps, Winder_ScrewAtOffsetCallback,1000);
 #ifdef FOUR_WINDERS
-        status |= MotorMoveWithCallback (SCREW_2_Motor,(1-MotorsCfg[SCREW_2_Motor].directionthreadwize), numOfSteps,  NULL,1000);
-        status |= MotorMoveWithCallback (SCREW_3_Motor,(1-MotorsCfg[SCREW_3_Motor].directionthreadwize), numOfSteps,  NULL,1000);
-        status |= MotorMoveWithCallback (SCREW_4_Motor,(1-MotorsCfg[SCREW_4_Motor].directionthreadwize), numOfSteps,  NULL,1000);
+        Screw_wait_counter++;
+        status |= MotorMoveWithCallback (SCREW_2_Motor,(1-MotorsCfg[SCREW_2_Motor].directionthreadwize), numOfSteps,  Winder_ScrewAtOffsetCallback,1000);
+        Screw_wait_counter++;
+        status |= MotorMoveWithCallback (SCREW_3_Motor,(1-MotorsCfg[SCREW_3_Motor].directionthreadwize), numOfSteps,  Winder_ScrewAtOffsetCallback,1000);
+        Screw_wait_counter++;
+        status |= MotorMoveWithCallback (SCREW_4_Motor,(1-MotorsCfg[SCREW_4_Motor].directionthreadwize), numOfSteps,  Winder_ScrewAtOffsetCallback,1000);
 #endif
     }
      //set motor location 0 here
@@ -255,16 +270,17 @@ uint32_t Winder_PrepareStage2(uint32_t deviceID, uint32_t ReadValue)
 
 }
 
-uint32_t Winder_ScrewAtOffsetCallback(uint32_t deviceID, uint32_t BusyFlag)
+uint32_t Winder_ScrewAtOffsetCallback(uint32_t MotorId, uint32_t BusyFlag)
 {
     //MotorSetMaxSpeed (HARDWARE_MOTOR_TYPE__MOTO_SCREW,temp_MaxFrequency);
+    Screw_wait_counter--;
 
-    MotorStop (HARDWARE_MOTOR_TYPE__MOTO_SCREW,Soft_Hiz); //per L6470 errata between mov and run commands
-#ifdef FOUR_WINDERS
+    MotorStop (MotorId,Soft_Hiz); //per L6470 errata between mov and run commands
+/*#ifdef FOUR_WINDERS
     MotorStop(SCREW_2_Motor, Hard_Hiz);
     MotorStop(SCREW_3_Motor, Hard_Hiz);
     MotorStop(SCREW_4_Motor, Hard_Hiz);
-#endif
+#endif*/
     Task_sleep(5);
 #ifdef READ_SCREW_ENCODER
     Reset_Screw_Encoder();
@@ -275,12 +291,12 @@ uint32_t Winder_ScrewAtOffsetCallback(uint32_t deviceID, uint32_t BusyFlag)
 
     REPORT_MSG(ScrewLocationStart, "Winder_ScrewAtOffsetCallback Encoder Location");
 #endif
-    SetMotHome(HARDWARE_MOTOR_TYPE__MOTO_SCREW);  //set this point as the spool home
-#ifdef FOUR_WINDERS
+    SetMotHome(MotorId);  //set this point as the spool home
+/*#ifdef FOUR_WINDERS
     SetMotHome(SCREW_2_Motor);
     SetMotHome(SCREW_3_Motor);
     SetMotHome(SCREW_4_Motor);
-#endif
+#endif*/
 
     ScrewCurrentDirection = false;
 #ifdef READ_SCREW_ENCODER
@@ -289,8 +305,9 @@ uint32_t Winder_ScrewAtOffsetCallback(uint32_t deviceID, uint32_t BusyFlag)
     ScrewSpeed = 0;
     ScrewControlId = 0xFF;
     ScrewNumberOfSteps = 0;
-    REPORT_MSG(millisecondCounter, "Winder_ScrewAtOffsetCallback");
-    PrepareReady(Module_Winder, ModuleDone);
+    ReportWithPackageFilter(ThreadFilter,"Winder_ScrewAtOffsetCallback",__FILE__,millisecondCounter,Screw_wait_counter,RpWarning,MotorId, 0);
+    if (Screw_wait_counter == 0)
+        PrepareReady(Module_Winder, ModuleDone);
     return OK;
 }
 
@@ -626,7 +643,7 @@ uint32_t Winder_End(void)
 #endif
     return OK;
 }
-void Winder_ScrewHomeLimitSwitchInterrupt(void)
+/*void Winder_ScrewHomeLimitSwitchInterrupt(void)
 {
     //uint32_t status;
     //handle glitch - send information to the next time that the motor stops
@@ -641,7 +658,7 @@ void Winder_ScrewOutLimitSwitchInterrupt(void)
     //handle glitch - send information to the next time that the motor stops
     //uint32_t status;
     MotorSetDirection(HARDWARE_MOTOR_TYPE__MOTO_SCREW,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].directionthreadwize);//make sure to move the cart out
-}
+}*/
 
 uint32_t  Screw_timerBase = TIMER3_BASE;        //Timer handle
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
index 849d54a67..98147f6b2 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
@@ -696,7 +696,8 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
             }*`/
         }*/
         calculated_speed = (1-MotorControlConfig[index].m_calculatedError)*OriginalMotorSpd_2PPS[index];
-        calculated_speed = calculated_speed*InitialDryerSpeed/OriginalMotorSpd_2PPS[DRYER_MOTOR];
+        if (index != WINDER_MOTOR)
+            calculated_speed = calculated_speed*InitialDryerSpeed/OriginalMotorSpd_2PPS[DRYER_MOTOR];
         //calculated_speed = (1-MotorControlConfig[index].m_calculatedError)*CurrentControlledSpeed[index];
         if (0)//(JobCounter % 1000 == 0)
         //if (JobCounter < 100)//(FirstCalcInJob == true)
@@ -863,6 +864,7 @@ int SecondFeederCorrection = 4;
 int PrepareWaitCount = 0;
 uint32_t Adjust_Right_TFU_Tension_2nd_Callback(uint32_t MotorId, uint32_t ReadValue)
 {
+#ifndef FOUR_WINDERS
     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)
@@ -881,14 +883,16 @@ uint32_t Adjust_Right_TFU_Tension_2nd_Callback(uint32_t MotorId, uint32_t ReadVa
         ReportWithPackageFilter(ThreadFilter,"ThreadPrepare_TensionCallback  Prepare Ready",__FILE__,__LINE__,2,RpWarning,PrepareWaitCount,0);
         PrepareReady(Module_Thread,ModuleDone);
     }
-
+#endif
     return OK;
 }
 uint32_t Adjust_Right_TFU_Tension_Callback(uint32_t MotorId, uint32_t ReadValue)
 {
+#ifndef FOUR_WINDERS
     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,SecondFeederCorrection* MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDANCER].microstep, Adjust_Right_TFU_Tension_2nd_Callback,1000);
     RTFU_Up = true;
+#endif
     return OK;
 }
 
@@ -1023,11 +1027,11 @@ uint32_t ThreadPrepareState(void *JobDetails)
 
     PrepareWaitCount = 0;
     status = ThreadPrepare_Tension (HARDWARE_DANCER_TYPE__LeftDancer, windertension);
-    ReportWithPackageFilter(ThreadFilter,"ThreadPrepare_Tension Winder",__FILE__,HARDWARE_DANCER_TYPE__LeftDancer,PrepareWaitCount,RpFatalError,(int)windertension,0);
+    ReportWithPackageFilter(ThreadFilter,"ThreadPrepare_Tension Winder",__FILE__,HARDWARE_DANCER_TYPE__LeftDancer,PrepareWaitCount,RpWarning,(int)windertension,0);
     status = ThreadPrepare_Tension (HARDWARE_DANCER_TYPE__MiddleDancer, pullertension);
-    ReportWithPackageFilter(ThreadFilter,"ThreadPrepare_Tension Puller",__FILE__,HARDWARE_DANCER_TYPE__MiddleDancer,PrepareWaitCount,RpFatalError,(int)pullertension,0);
+    ReportWithPackageFilter(ThreadFilter,"ThreadPrepare_Tension Puller",__FILE__,HARDWARE_DANCER_TYPE__MiddleDancer,PrepareWaitCount,RpWarning,(int)pullertension,0);
     status = ThreadPrepare_Tension (HARDWARE_DANCER_TYPE__RightDancer, feedertension);
-    ReportWithPackageFilter(ThreadFilter,"ThreadPrepare_Tension Feeder",__FILE__,HARDWARE_DANCER_TYPE__RightDancer,PrepareWaitCount,RpFatalError,(int)feedertension,0);
+    ReportWithPackageFilter(ThreadFilter,"ThreadPrepare_Tension Feeder",__FILE__,HARDWARE_DANCER_TYPE__RightDancer,PrepareWaitCount,RpWarning,(int)feedertension,0);
 
     FirstCalcInJob = true;
     if(MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDRIVING].speedmaster == false)
@@ -1044,14 +1048,14 @@ uint32_t ThreadPrepareState(void *JobDetails)
 
     /*if (FPGA_Read_limit_Switches(Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_DH_LID]) != LIMIT)
     {
-        ReportWithPackageFilter(ThreadFilter,"Dyeing head is open!!!",__FILE__,__LINE__,HARDWARE_MOTOR_TYPE__MOTO_DH_LID,RpFatalError,LIMIT,0);
+        ReportWithPackageFilter(ThreadFilter,"Dyeing head is open!!!",__FILE__,__LINE__,HARDWARE_MOTOR_TYPE__MOTO_DH_LID,RpWarning,LIMIT,0);
         //JobEndReason = JOB_LIDS_OPEN;
         //PrepareReady(Module_Thread,ModuleFail);
         //return ERROR;
     }
     if (FPGA_Read_limit_Switches(Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID]) != LIMIT)
     {
-        ReportWithPackageFilter(ThreadFilter,"Dryer lid is open!!!",__FILE__,__LINE__,HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID,RpFatalError,LIMIT,0);
+        ReportWithPackageFilter(ThreadFilter,"Dryer lid is open!!!",__FILE__,__LINE__,HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID,RpWarning,LIMIT,0);
         //JobEndReason = JOB_LIDS_OPEN;
         //PrepareReady(Module_Thread,ModuleFail);
         //return ERROR;
diff --git a/Software/Embedded_SW/Embedded/Modules/Waste/Waste_maint.c b/Software/Embedded_SW/Embedded/Modules/Waste/Waste_maint.c
index c0e51a143..222b618d2 100644
--- a/Software/Embedded_SW/Embedded/Modules/Waste/Waste_maint.c
+++ b/Software/Embedded_SW/Embedded/Modules/Waste/Waste_maint.c
@@ -526,6 +526,4 @@ uint32_t Waste_Prepare(void)
         //PrepareReady(Module_Waste,ModuleFail);
         return JOB_OTHER_ALARM;
     }
-    return;
-
 }
diff --git a/Software/Embedded_SW/Embedded/Software Release Notes.txt b/Software/Embedded_SW/Embedded/Software Release Notes.txt
index 96b11bcc1..7d39689d4 100644
--- a/Software/Embedded_SW/Embedded/Software Release Notes.txt
+++ b/Software/Embedded_SW/Embedded/Software Release Notes.txt
@@ -1,3 +1,22 @@
+Embedded SW Release note - Version 1.4.6.42 - Pack Mid alpha
+=============================================================
+log events before report starts and after afailure to a file (errorfile.txt)
+save space in the usb communication
+4 winders support (under a flag)
+ARC head -read tacho fan correctly
+fix actuator handling in loading and jogging
+diagnostics - cartridges state, ambient temp (max of cabinet/machine)
+initial heating headflow - full
+pressure relief in inactive dispensers - pull down 2000 steps, issue an alarm in 5 bars and open valve
+update PID during run stub (not tested)
+transfer RML PID params on cleaning/ jogging jobs (from the previous job)
+raise motor voltage on loading wheels movement to 0.8 (kval 28)
+IDS job prepare - run at least 120000 steps in each active dispenser before the job. pressure buildup up to 4 bars
+fix IDS bug - when the thread runs fast and need to cancel the last brushstops (delta job)
+fix winder thread movement on start
+fix stuck in power down right after restart
+
+
 Embedded SW Release note - Version 1.4.6.41 - Pack Mid alpha
 =============================================================
 fix a bug that crashed the SW on arm movement (motorMovewithcallback)
diff --git a/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerOffSequence.c b/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerOffSequence.c
index 776d55080..73d93a7b2 100644
--- a/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerOffSequence.c
+++ b/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerOffSequence.c
@@ -256,7 +256,7 @@ uint32_t PowerOffHeatersOff(void)
     if (HandleProcessParameters(&ProcessParametersClear,false)!= OK)
     {
         LOG_ERROR (PowerOffMachineState, "Turn Off Heaters  failed");
-        return ERROR;
+        //return ERROR;
     }
 
     PowerOffMachineState++;
@@ -501,6 +501,8 @@ uint32_t PowerOffPowerOff(void)
         REPORT_MSG (10-i, "Power off in x seconds");
         Task_sleep (1000);
     }
+    CloseLogFile();
+
     ControlStop();
     MillisecStop();
     HeatersEnd();
diff --git a/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c b/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c
index 33face713..8bce76ccf 100644
--- a/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c
+++ b/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c
@@ -151,6 +151,7 @@ bool JobResumed = false;
 char JobToken[36+1]={0};
 bool JobAbortedByUser = false;
 
+ThreadParameters SavedThreadParameters;
 ////////////////////////////////////////////////////////////////////////////
 void StartJob(void *JobDetails);
 
@@ -425,6 +426,7 @@ uint32_t ThreadJoggingFunc(int speed)
             Tspool->rotationsperpassage = 3.1415926*2;
             Tspool->has_limitswitchstartpointoffset = false;
             Ticket.spool = Tspool;
+            Ticket.threadparameters = &SavedThreadParameters;
             CurrentJob = &Ticket;
             InternalWindingConfigMessage(Tspool);
             JoggingJobActive = true;
@@ -608,6 +610,7 @@ uint32_t ThreadCleaningJob(int speed)
                 Tspool->rotationsperpassage = 3.1415926*2;
                 Tspool->has_limitswitchstartpointoffset = false;
                 Ticket.spool = Tspool;
+                Ticket.threadparameters = &SavedThreadParameters;
                 CurrentJob = &Ticket;
                 job_length = CurrentJob->length + dryerbufferMeters;
 
@@ -958,6 +961,7 @@ void JobRequestFunc(MessageContainer* requestContainer)
             {
                 Report("Job Request ",__FILE__,__LINE__,Ticket->processparameters->dyeingspeed,RpWarning,n_segments, Ticket->intersegmentlength);
                 memcpy(&Configured,&JobConfigured,sizeof(JobConfigured));
+                memcpy(&SavedThreadParameters,&Ticket->threadparameters,sizeof(SavedThreadParameters));
                 StartJob(CurrentJob);
             }
         }
@@ -1352,6 +1356,7 @@ Void jobTask(UArg arg0, UArg arg1)
     //uint16_t length;
     //Clock_setTimeout(HostKAClock, 1000);
     //Clock_start(HostKAClock);
+    memset(&SavedThreadParameters,0,sizeof(SavedThreadParameters));
     JobmsgQ = Mailbox_create(MAX_MSG_LEN, 20, NULL,NULL);
 
 
diff --git a/Software/Embedded_SW/Embedded/StateMachines/Printing/PrintingSTM.c b/Software/Embedded_SW/Embedded/StateMachines/Printing/PrintingSTM.c
index b874e5eaf..52aac94f5 100644
--- a/Software/Embedded_SW/Embedded/StateMachines/Printing/PrintingSTM.c
+++ b/Software/Embedded_SW/Embedded/StateMachines/Printing/PrintingSTM.c
@@ -142,7 +142,6 @@ FRESULT RewindJobFile()
 FRESULT CloseJobFile()
 {
     Fresult = f_close(JobRequestFileHandle);
-#warning trying not to hold the semaphore and enable the PPC/MS to work on several files simultaneously
 
     readbBytes = 0;
     ImmediateRead = 0;
@@ -254,6 +253,8 @@ JobDescriptionFileBrushStop *GetNextBrushStopFromJobFile()
             {
                 readbBytes += ImmediateRead;
                 BrushStop = job_description_file_brush_stop__unpack(NULL, BrushStopSize, BrushStopPtr);
+                if (BrushStop == NULL)
+                    Report("brush_stop__unpack error!",__FILE__,BrushStopSize,(int)readbBytes,RpWarning,(int)ImmediateRead,0);
             }//brushstop malloc ok
             else
             {
@@ -310,7 +311,7 @@ uint32_t PrintingHWConfiguration(void *Configuration)
     if ((IFS_Availability[1] == IFS_RECOGNIZED_INIT_PASSED)&&(IFS_Availability[2] == IFS_RECOGNIZED_INIT_PASSED)) //ifs installed -check cartridges
         Configured[Module_Waste] = true;
 
-    if (request->n_motors < HARDWARE_MOTOR_TYPE__MOTO_SPARE1_1)
+    if (request->n_motors)
     {
         for (i = 0; i < request->n_motors ; i++)
         {
author	Roy Ben Shabat <Roy.mail.net@gmail.com>	2020-08-25 17:50:22 +0300
committer	Roy Ben Shabat <Roy.mail.net@gmail.com>	2020-08-25 17:50:22 +0300
commit	9bc0807514a69d97fceab11d77bee02aff4eb3d9 (patch)
tree	2c5ad002ab84443945943adc2ab531ce6fccda22 /Software/Embedded_SW/Embedded
parent	26b6bf34090634edf23ed5ed1785560c024da02c (diff)
parent	642dbff4c449d268d18ec4ca7f2ff267876dce14 (diff)
download	Tango-9bc0807514a69d97fceab11d77bee02aff4eb3d9.tar.gz Tango-9bc0807514a69d97fceab11d77bee02aff4eb3d9.zip