Version 1.4.2.0 - infrastructure for IFS, improved flash handling, thread unloading

11 files changed, 385 insertions, 174 deletions

diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
index c67f50705..84c232ffc 100644
--- a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
+++ b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
@@ -382,6 +382,8 @@ uint32_t AlarmHandlingLoadFile(void)
     {
         ReadAppAndProgram(AlarmItem, Bytes,buffer);
         free (buffer);
+        Report("AlarmHandlingLoadFile", __FILE__,__LINE__,Bytes, RpMessage, Fresult, 0);
+
     }
     return Bytes;
 }
diff --git a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
index 2871a31c8..627ef84cd 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
@@ -149,116 +149,113 @@ uint32_t HWConfigurationInit(void)
 }
 
 char EmbeddedParametersPath[50] = "0://SysInfo//EmbParam.cfg";
-ConfigurationParameters EmbeddedParameters;
+ConfigurationParameters *EmbeddedParameters;
 bool DataUpdated = false;
 void LoadConfigurationParameters(ConfigurationParameters *Params)
 {
     if (Params == 0)
         {
-            configuration_parameters__init(&EmbeddedParameters);
-            EmbeddedParameters.has_breaksensorlimit = true;
-            EmbeddedParameters.breaksensorlimit = 10;
-            EmbeddedParameters.has_diagnosticcollectionlimit = true;
-            EmbeddedParameters.diagnosticcollectionlimit = 1;
-            EmbeddedParameters.has_overheatcountlimit = true;
-            EmbeddedParameters.overheatcountlimit = 3;
-            EmbeddedParameters.has_underheatcountlimit = true;
-            EmbeddedParameters.underheatcountlimit = 3;
-            EmbeddedParameters.has_closevalvetimeout = true;
-            EmbeddedParameters.closevalvetimeout = 250;
-            EmbeddedParameters.has_openvalvetimeout = true;
-            EmbeddedParameters.openvalvetimeout = 250;
-            EmbeddedParameters.has_initialdispenserpressure = true;
-            EmbeddedParameters.initialdispenserpressure = 1.08;
-            EmbeddedParameters.has_initialdispensertimeout = true;
-            EmbeddedParameters.initialdispensertimeout = 60000;
-            EmbeddedParameters.has_initialdispensertimelag = true;
-            EmbeddedParameters.initialdispensertimelag = 100;
-            EmbeddedParameters.has_dispenserbuildpressurespeed = true;
-            EmbeddedParameters.dispenserbuildpressurespeed=500;
-            EmbeddedParameters.has_dispenserbuildpressurelimit = true;
-            EmbeddedParameters.dispenserbuildpressurelimit=0.8 ;
-            EmbeddedParameters.has_dispenserbuildpressuretimeout = true;
-            EmbeddedParameters.dispenserbuildpressuretimeout=60000;
-            EmbeddedParameters.has_dispenserbuildpressurelag = true;
-            EmbeddedParameters.dispenserbuildpressurelag=50;
-            EmbeddedParameters.has_acheatersloweroperationlimit = true;
-            EmbeddedParameters.acheatersloweroperationlimit = 980;
-            EmbeddedParameters.has_acheatersupperoperationlimit = true;
-            EmbeddedParameters.acheatersupperoperationlimit = 1005;
-            EmbeddedParameters.has_dcheatersloweroperationlimit = true;
-            EmbeddedParameters.dcheatersloweroperationlimit = 978;
-            EmbeddedParameters.has_dcheatersupperoperationlimit = true;
-            EmbeddedParameters.dcheatersupperoperationlimit = 1002;
-            EmbeddedParameters.has_midtankpressurecorrection = true;
-            EmbeddedParameters.midtankpressurecorrection = 0.0;
-            EmbeddedParameters.has_dispenserpresegmentwfcf = true;
-            EmbeddedParameters.dispenserpresegmentwfcf = 80;
-            EmbeddedParameters.has_startheatingoninitsequence = true;
-            EmbeddedParameters.startheatingoninitsequence = true; //set to true shlomo 14/5/2019
-//size_t n_generalparameters;
-//            EmbeddedParameters.*generalparameters;
-            EmbeddedParameters.generalparameters = malloc (sizeof(double)*10);
-            if (EmbeddedParameters.generalparameters)
+            EmbeddedParameters = my_malloc(sizeof(ConfigurationParameters));
+            configuration_parameters__init(EmbeddedParameters);
+            EmbeddedParameters->breaksensorlimit = 10;
+            EmbeddedParameters->has_diagnosticcollectionlimit = true;
+            EmbeddedParameters->diagnosticcollectionlimit = 1;
+            EmbeddedParameters->has_overheatcountlimit = true;
+            EmbeddedParameters->overheatcountlimit = 3;
+            EmbeddedParameters->has_underheatcountlimit = true;
+            EmbeddedParameters->underheatcountlimit = 3;
+            EmbeddedParameters->has_closevalvetimeout = true;
+            EmbeddedParameters->closevalvetimeout = 250;
+            EmbeddedParameters->has_openvalvetimeout = true;
+            EmbeddedParameters->openvalvetimeout = 250;
+            EmbeddedParameters->has_initialdispenserpressure = true;
+            EmbeddedParameters->initialdispenserpressure = 1.08;
+            EmbeddedParameters->has_initialdispensertimeout = true;
+            EmbeddedParameters->initialdispensertimeout = 60000;
+            EmbeddedParameters->has_initialdispensertimelag = true;
+            EmbeddedParameters->initialdispensertimelag = 100;
+            EmbeddedParameters->has_dispenserbuildpressurespeed = true;
+            EmbeddedParameters->dispenserbuildpressurespeed=500;
+            EmbeddedParameters->has_dispenserbuildpressurelimit = true;
+            EmbeddedParameters->dispenserbuildpressurelimit=0.8 ;
+            EmbeddedParameters->has_dispenserbuildpressuretimeout = true;
+            EmbeddedParameters->dispenserbuildpressuretimeout=60000;
+            EmbeddedParameters->has_dispenserbuildpressurelag = true;
+            EmbeddedParameters->dispenserbuildpressurelag=50;
+            EmbeddedParameters->has_acheatersloweroperationlimit = true;
+            EmbeddedParameters->acheatersloweroperationlimit = 980;
+            EmbeddedParameters->has_acheatersupperoperationlimit = true;
+            EmbeddedParameters->acheatersupperoperationlimit = 1005;
+            EmbeddedParameters->has_dcheatersloweroperationlimit = true;
+            EmbeddedParameters->dcheatersloweroperationlimit = 978;
+            EmbeddedParameters->has_dcheatersupperoperationlimit = true;
+            EmbeddedParameters->dcheatersupperoperationlimit = 1002;
+            EmbeddedParameters->has_midtankpressurecorrection = true;
+            EmbeddedParameters->midtankpressurecorrection = 0.0;
+            EmbeddedParameters->has_dispenserpresegmentwfcf = true;
+            EmbeddedParameters->dispenserpresegmentwfcf = 80;
+            EmbeddedParameters->has_startheatingoninitsequence = true;
+            EmbeddedParameters->startheatingoninitsequence = true; //set to true shlomo 14/5/2019
+            EmbeddedParameters->generalparameters = malloc (sizeof(double)*10);
+            if (EmbeddedParameters->generalparameters)
             {
-                EmbeddedParameters.generalparameters[0] = 1.0; //CheckHardLimitAlarms
-                EmbeddedParameters.generalparameters[1] = 0.0; //CheckCurrentAlarms
-                EmbeddedParameters.generalparameters[2] = 0.0; //CheckTamperAlarms
-                EmbeddedParameters.generalparameters[3] = 800.0; //Winder homing time at end of job
-                //EmbeddedParameters.generalparameters[4] = 1.0; //Dispenser initial pressure limit
-                //EmbeddedParameters.generalparameters[5] = 1.0; //Dispenser initial pressure speed
+                EmbeddedParameters->generalparameters[0] = 1.0; //CheckHardLimitAlarms
+                EmbeddedParameters->generalparameters[1] = 0.0; //CheckCurrentAlarms
+                EmbeddedParameters->generalparameters[2] = 0.0; //CheckTamperAlarms
+                EmbeddedParameters->generalparameters[3] = 800.0; //Winder homing time at end of job
+                //EmbeddedParameters->generalparameters[4] = 1.0; //Dispenser initial pressure limit
+                //EmbeddedParameters->generalparameters[5] = 1.0; //Dispenser initial pressure speed
             }
-            EmbeddedParameters.has_currentalarmlowlimit = true;
-            EmbeddedParameters.currentalarmlowlimit = 0.80;
-            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;
-            EmbeddedParameters.ids_cleaningspeed = 50;
-            EmbeddedParameters.has_ids_cleaningstopbeforesegmenttime = true;
-            EmbeddedParameters.ids_cleaningstopbeforesegmenttime = 3000;
-            EmbeddedParameters.has_ids_cleaningstartspraypresegmenttime = true;
-            EmbeddedParameters.ids_cleaningstartspraypresegmenttime = 1000;
-            EmbeddedParameters.has_ids_leftcleaningmotorspeed = true;
-            EmbeddedParameters.ids_leftcleaningmotorspeed = 30;
-            EmbeddedParameters.has_ids_rightcleaningmotorspeed = true;
-            EmbeddedParameters.ids_rightcleaningmotorspeed = 23;
-            EmbeddedParameters.has_switchtoidletimeinseconds = true;
-            EmbeddedParameters.switchtoidletimeinseconds = 3600;
-            EmbeddedParameters.has_idledriertemperature = true;
-            EmbeddedParameters.idledriertemperature = 80;
-            EmbeddedParameters.has_idleheadtemperature = true;
-            EmbeddedParameters.idleheadtemperature = 80;
-            EmbeddedParameters.has_idlemixertemperature = true;
-            EmbeddedParameters.idlemixertemperature = 0;
-            EmbeddedParameters.has_powerofftemperaturelimit = true;
-            EmbeddedParameters.powerofftemperaturelimit = 50;
-            EmbeddedParameters.has_ids_presegment_wfcf_timebeforesegment = true;
-            EmbeddedParameters.ids_presegment_wfcf_timebeforesegment = 1500;
-            uint8_t* response_buffer = my_malloc(configuration_parameters__get_packed_size(&EmbeddedParameters));
+            EmbeddedParameters->has_currentalarmlowlimit = true;
+            EmbeddedParameters->currentalarmlowlimit = 0.80;
+            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;
+            EmbeddedParameters->ids_cleaningspeed = 50;
+            EmbeddedParameters->has_ids_cleaningstopbeforesegmenttime = true;
+            EmbeddedParameters->ids_cleaningstopbeforesegmenttime = 3000;
+            EmbeddedParameters->has_ids_cleaningstartspraypresegmenttime = true;
+            EmbeddedParameters->ids_cleaningstartspraypresegmenttime = 1000;
+            EmbeddedParameters->has_ids_leftcleaningmotorspeed = true;
+            EmbeddedParameters->ids_leftcleaningmotorspeed = 30;
+            EmbeddedParameters->has_ids_rightcleaningmotorspeed = true;
+            EmbeddedParameters->ids_rightcleaningmotorspeed = 23;
+            EmbeddedParameters->has_switchtoidletimeinseconds = true;
+            EmbeddedParameters->switchtoidletimeinseconds = 3600;
+            EmbeddedParameters->has_idledriertemperature = true;
+            EmbeddedParameters->idledriertemperature = 80;
+            EmbeddedParameters->has_idleheadtemperature = true;
+            EmbeddedParameters->idleheadtemperature = 80;
+            EmbeddedParameters->has_idlemixertemperature = true;
+            EmbeddedParameters->idlemixertemperature = 0;
+            EmbeddedParameters->has_powerofftemperaturelimit = true;
+            EmbeddedParameters->powerofftemperaturelimit = 50;
+            EmbeddedParameters->has_ids_presegment_wfcf_timebeforesegment = true;
+            EmbeddedParameters->ids_presegment_wfcf_timebeforesegment = 1500;
+            uint8_t* response_buffer = my_malloc(configuration_parameters__get_packed_size(EmbeddedParameters));
             size_t response_size = 0;
             if (response_buffer)
             {
-                response_size = configuration_parameters__pack(&EmbeddedParameters, response_buffer);
+                response_size = configuration_parameters__pack(EmbeddedParameters, response_buffer);
+                //FileWrite(response_buffer,response_size,EmbeddedParametersPath);
+                ReadAppAndProgram(EMBEDDED_PARAMETERS_MAP_IN_FLASH, 4,&response_size);
+                ReadAppAndProgram(EMBEDDED_PARAMETERS_MAP_IN_FLASH+4, response_size, response_buffer);
+                my_free(response_buffer);
             }
-            FileWrite(response_buffer,response_size,EmbeddedParametersPath);
-            my_free(response_buffer);
         }
         else
         {
-            memcpy (&EmbeddedParameters,Params,sizeof(EmbeddedParameters));
+            EmbeddedParameters = Params;
         }
-    uint32_t Bytes = sizeof(EmbeddedParameters);
-    ReadAppAndProgram(EMBEDDED_PARAMETERS_MAP_IN_FLASH, 4,&Bytes);
-    ReadAppAndProgram(EMBEDDED_PARAMETERS_MAP_IN_FLASH+4, Bytes, &EmbeddedParameters);
 }
 uint32_t EmbeddedParametersInit(void)
 {
     FRESULT Fresult = FR_OK;
-    //void* buffer = NULL;
+    void* buffer = NULL;
     uint32_t Bytes = 0;
 
     ConfigurationParameters *Params;
@@ -267,35 +264,44 @@ uint32_t EmbeddedParametersInit(void)
 
     if ((Bytes)&&(Bytes < 1000))
     {
-        Params = (ConfigurationParameters *)(EMBEDDED_PARAMETERS_MAP_IN_FLASH+4);
-        memcpy (&EmbeddedParameters,Params,sizeof(EmbeddedParameters));
+        Params = configuration_parameters__unpack(NULL, Bytes, (void *)(EMBEDDED_PARAMETERS_MAP_IN_FLASH+4));
+        LoadConfigurationParameters(Params);
+        Report("LoadConfigurationParameters from flash", __FILE__,__LINE__,Bytes, RpMessage, Fresult, 0);
     }
     else
     {
-        LoadConfigurationParameters(0);
+        if (LoadConfigurationParamsFromFile()!=OK)
+        {
+            LoadConfigurationParameters(0);
+            Report("LoadConfigurationParameters default", __FILE__,__LINE__,0, RpMessage, Fresult, 0);
+        }
+        else
+        {
+            Report("LoadConfigurationParameters from file", __FILE__,__LINE__,EmbeddedParameters->closevalvetimeout, RpMessage, Fresult, 0);
+        }
     }
 
-    IDS_Dispenser_SetTimeOutValues(EmbeddedParameters.closevalvetimeout, EmbeddedParameters.openvalvetimeout);
-    IDS_Dispenser_SetBackLashValues(EmbeddedParameters.initialdispenserpressure, EmbeddedParameters.initialdispensertimeout, EmbeddedParameters.initialdispensertimelag);
-    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);
+    IDS_Dispenser_SetTimeOutValues(EmbeddedParameters->closevalvetimeout, EmbeddedParameters->openvalvetimeout);
+    IDS_Dispenser_SetBackLashValues(EmbeddedParameters->initialdispenserpressure, EmbeddedParameters->initialdispensertimeout, EmbeddedParameters->initialdispensertimelag);
+    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_SetOperationLimits(EmbeddedParameters.acheatersloweroperationlimit,EmbeddedParameters.acheatersupperoperationlimit,EmbeddedParameters.dcheatersloweroperationlimit,EmbeddedParameters.dcheatersupperoperationlimit);
-    MidTankPressureCorrection(EmbeddedParameters.midtankpressurecorrection);
-    SetDiagnosticCollectionLimit(EmbeddedParameters.diagnosticcollectionlimit);
-    ThreadSetBreakSensorLimit(EmbeddedParameters.breaksensorlimit);
-    PowerOffSetTemperatureThreshold(EmbeddedParameters.powerofftemperaturelimit);
+    Heaters_SetOverHeatTimeOutValues( EmbeddedParameters->overheatcountlimit,  EmbeddedParameters->underheatcountlimit);
+    Heaters_SetOperationLimits(EmbeddedParameters->acheatersloweroperationlimit,EmbeddedParameters->acheatersupperoperationlimit,EmbeddedParameters->dcheatersloweroperationlimit,EmbeddedParameters->dcheatersupperoperationlimit);
+    MidTankPressureCorrection(EmbeddedParameters->midtankpressurecorrection);
+    SetDiagnosticCollectionLimit(EmbeddedParameters->diagnosticcollectionlimit);
+    ThreadSetBreakSensorLimit(EmbeddedParameters->breaksensorlimit);
+    PowerOffSetTemperatureThreshold(EmbeddedParameters->powerofftemperaturelimit);
 
-    InitSequenceSetStartHeating (EmbeddedParameters.startheatingoninitsequence);
+    InitSequenceSetStartHeating (EmbeddedParameters->startheatingoninitsequence);
     bool a1,a2,a3;
-    a1 = (EmbeddedParameters.generalparameters[0] < 0.5)?false:true;
-    a2 = (EmbeddedParameters.generalparameters[1] < 0.5)?false:true;
-    a3 = (EmbeddedParameters.generalparameters[2] < 0.5)?false:true;
+    a1 = (EmbeddedParameters->generalparameters[0] < 0.5)?false:true;
+    a2 = (EmbeddedParameters->generalparameters[1] < 0.5)?false:true;
+    a3 = (EmbeddedParameters->generalparameters[2] < 0.5)?false:true;
     AlarmHandlingSetFlags(a1,a2,a3);
 
-    PowerIdleSetParameters(EmbeddedParameters.switchtoidletimeinseconds,EmbeddedParameters.idledriertemperature,EmbeddedParameters.idleheadtemperature,EmbeddedParameters.idlemixertemperature);
+    PowerIdleSetParameters(EmbeddedParameters->switchtoidletimeinseconds,EmbeddedParameters->idledriertemperature,EmbeddedParameters->idleheadtemperature,EmbeddedParameters->idlemixertemperature);
 
     return Fresult;
 }
@@ -347,10 +353,8 @@ uint32_t HWConfiguration(UploadHardwareConfigurationRequest* UploadRequest)
  
     if (request->n_motors < NUM_OF_MOTORS)
     {
-       //EraseFlashSection(GENHWCFG_MAP_IN_FLASH + 0x2000,sizeof(HardwareMotor)*request->n_motors);
-
-        for (Motor_i = 0; Motor_i < request->n_motors ; Motor_i++)
-        status += MotorsConfigMessage(request->motors[Motor_i]);
+        //for (Motor_i = 0; Motor_i < request->n_motors ; Motor_i++)
+        status += MotorsConfigMessage(request);
     }
     else
     {
@@ -521,6 +525,28 @@ void HWSystemResetRequest(MessageContainer* requestContainer)
 
 }
 uint32_t FlashInitResults[5] = {0,0,0,0,0};
+uint32_t LoadConfigurationParamsFromFile(void)
+{
+    FRESULT Fresult = FR_OK;
+    uint8_t* buffer = NULL;
+    uint32_t Bytes = 0;
+
+    ConfigurationParameters *Params = NULL;
+
+    Fresult = FileRead(EmbeddedParametersPath, &Bytes, &buffer);
+    if (Fresult == FR_OK)
+    {
+        Params = configuration_parameters__unpack(NULL, Bytes, buffer);
+        LoadConfigurationParameters(Params);
+        free (buffer);
+        //configuration_parameters__free_unpacked(Params,NULL);
+        FlashInitResults[1] = true;
+        Report("Parameters Initialized from file", __FILE__,__LINE__,Bytes, RpMessage, EMBEDDED_PARAMETERS_MAP_IN_FLASH, 0);
+        ReadAppAndProgram(EMBEDDED_PARAMETERS_MAP_IN_FLASH, 4,&Bytes);
+        ReadAppAndProgram(EMBEDDED_PARAMETERS_MAP_IN_FLASH+4, Bytes, buffer);
+    }
+    return Fresult;
+}
 void FlashInitAndLoad(void)
 {
     FRESULT Fresult = FR_OK;
@@ -534,7 +560,7 @@ void FlashInitAndLoad(void)
     char ProcessParamsPath[50] = "0://SysInfo//ProcessP.cfg";
 #ifdef WATCHDOG
         ROM_WatchdogResetDisable(WATCHDOG0_BASE);
-        uint32_t timeout = 120000000*35;
+        uint32_t timeout = 0xFFFFFFFFU;
         ROM_WatchdogReloadSet(WATCHDOG0_BASE, timeout);
 #endif
 
@@ -569,8 +595,11 @@ void FlashInitAndLoad(void)
     {
         Params = configuration_parameters__unpack(NULL, Bytes, buffer);
         LoadConfigurationParameters(Params);
+        //Bytes = sizeof(EmbeddedParameters);
+        ReadAppAndProgram(EMBEDDED_PARAMETERS_MAP_IN_FLASH, 4,&Bytes);
+        ReadAppAndProgram(EMBEDDED_PARAMETERS_MAP_IN_FLASH+4, Bytes, buffer);
         free (buffer);
-        configuration_parameters__free_unpacked(Params,NULL);
+        //configuration_parameters__free_unpacked(Params,NULL);
         FlashInitResults[1] = true;
         Report("Parameters Initialized from file", __FILE__,__LINE__,sizeof(EmbeddedParameters), RpMessage, EMBEDDED_PARAMETERS_MAP_IN_FLASH, 0);
     }
@@ -580,9 +609,6 @@ void FlashInitAndLoad(void)
         FlashInitResults[1] = 2;
         Report("Parameters Initialized from default", __FILE__,__LINE__,sizeof(EmbeddedParameters), RpMessage, EMBEDDED_PARAMETERS_MAP_IN_FLASH, 0);
     }
-    Bytes = sizeof(EmbeddedParameters);
-    ReadAppAndProgram(EMBEDDED_PARAMETERS_MAP_IN_FLASH, 4,&Bytes);
-    ReadAppAndProgram(EMBEDDED_PARAMETERS_MAP_IN_FLASH+4, Bytes, &EmbeddedParameters);
 
     Fresult = FileRead(ProcessParamsPath, &Bytes, &buffer);
     if (Fresult == FR_OK)
diff --git a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.h b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.h
index 86f164977..338217e74 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.h
+++ b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.h
@@ -7,13 +7,13 @@
 #include "PMR/common/MessageContainer.pb-c.h"
 #include "PMR/Hardware/HardwareBlower.pb-c.h"
 #include "PMR/EmbeddedParameters/ConfigurationParameters.pb-c.h"
-extern ConfigurationParameters EmbeddedParameters;
+extern ConfigurationParameters *EmbeddedParameters;
 
 extern uint32_t HWConfigurationFunc(MessageContainer* requestContainer);
 extern void HWSystemResetRequest(MessageContainer* requestContainer);
 uint32_t HWConfigurationInit(void);
 void FlashInitAndLoad(void);
-
+uint32_t LoadConfigurationParamsFromFile(void);
 extern HardwareBlower BlowerCfg;
 
 extern bool DataUpdated;
diff --git a/Software/Embedded_SW/Embedded/Modules/General/process.c b/Software/Embedded_SW/Embedded/Modules/General/process.c
index aafc1c5a9..6ee11105f 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/process.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/process.c
@@ -195,7 +195,7 @@ void ProcessRequestFunc(MessageContainer* requestContainer)
         Bytes = sizeof(ProcessParameters);
         ReadAppAndProgram(PROCESS_PARAMETERS_MAP_IN_FLASH, 4,&Bytes);
         ReadAppAndProgram(PROCESS_PARAMETERS_MAP_IN_FLASH+4, Bytes, ProcessParams);
-        REPORT_MSG(Bytes,"Bytes wrtie to flash");
+        REPORT_MSG(Bytes,"Bytes write to flash");
 
     }
     ////////////////////////////////////////////////////////////////////////
@@ -237,51 +237,34 @@ void ProcessRequestFunc(MessageContainer* requestContainer)
     upload_process_parameters_request__free_unpacked(request,NULL);
 
 }
-uint32_t ProcessParamsInit(void)
+uint32_t LoadProcessParamsFromFile(void)
 {
     FRESULT Fresult = FR_OK;
-    //FIL *FileHandle = 0;  //the system supports a single active file
-    //uint8_t* buffer = NULL;
-    uint32_t Bytes;// = 0,i,j,k=0;
-    //UploadProcessParametersRequest* request;
-/*
-    FileHandle = my_malloc(sizeof(FIL));
-    if (FileHandle)
+    uint8_t* buffer = NULL;
+    uint32_t Bytes = 0;
+
+    Fresult = FileRead(ProcessParamsConfigPath, &Bytes, &buffer);
+    if (Fresult == FR_OK)
     {
-        Fresult = FileOpen(ProcessParamsConfigPath, &Bytes, FileHandle);
-        if (Fresult == FR_OK)
-        {
-            buffer = my_malloc (Bytes);
-            if (buffer)
-            {
-                for (i=0;i<=(Bytes/100);i++)
-                {
-                    Fresult = f_read(FileHandle,&buffer[i*100],100,&j );
-                    k+=j;
-                }
-                if (k!=Bytes)
-                    LOG_ERROR(k,"File read error");
+        UploadProcessParametersRequest* request = upload_process_parameters_request__unpack(NULL, Bytes, buffer);
+        ProcessParameters*  ProcessParams = request->processparameters;
 
-               request = upload_process_parameters_request__unpack(NULL, Bytes, buffer);
-        //           ProcessParameters*  ProcessParams = process_parameters__unpack(NULL, Bytes, buffer);
-               if (request)
-               {
-                   ProcessParameters*  ProcessParams = request->processparameters;
-                   Fresult = HandleProcessParameters(ProcessParams);
-                   //memcpy (&ProcessParametersKeep,ProcessParams,sizeof(ProcessParameters));
-                   upload_process_parameters_request__free_unpacked(request,NULL);
-               }
-               my_free (buffer);
-            }
-            f_close(FileHandle);
-        }
-        else
+        if ((ProcessParams->dryerzone1temp > 0.1)&&(ProcessParams->headzone2temp > 0.1)&&(ProcessParams->headzone3temp > 0.1)&&(ProcessParams->headzone4temp > 0.1))//NOT turning off heaters
         {
-            LOG_ERROR(Fresult,"File open error");
+            Bytes = sizeof(ProcessParameters);
+            ReadAppAndProgram(PROCESS_PARAMETERS_MAP_IN_FLASH, 4,&Bytes);
+            ReadAppAndProgram(PROCESS_PARAMETERS_MAP_IN_FLASH+4, Bytes, ProcessParams);
+            REPORT_MSG(Bytes,"ProcessParameters Bytes write to flash");
+            free (buffer);
         }
-        my_free (FileHandle);
     }
-*/
+
+    return Fresult;
+}
+uint32_t ProcessParamsInit(void)
+{
+    FRESULT Fresult = FR_OK;
+    uint32_t Bytes;
 
     memcpy(&Bytes,(void *)PROCESS_PARAMETERS_MAP_IN_FLASH,sizeof(Bytes));
     REPORT_MSG(Bytes,"Bytes read from flash");
@@ -291,6 +274,20 @@ uint32_t ProcessParamsInit(void)
         ProcessParameters*  ProcessParams = (ProcessParameters *)(PROCESS_PARAMETERS_MAP_IN_FLASH+4);
         Fresult = HandleProcessParameters(ProcessParams);
     }
+    else
+    {
+        if (LoadProcessParamsFromFile()==OK)
+        {
+            memcpy(&Bytes,(void *)PROCESS_PARAMETERS_MAP_IN_FLASH,sizeof(Bytes));
+            REPORT_MSG(Bytes,"ProcessParams Bytes read from flash");
+
+            if ((Bytes)&&(Bytes < 1000))
+            {
+                ProcessParameters*  ProcessParams = (ProcessParameters *)(PROCESS_PARAMETERS_MAP_IN_FLASH+4);
+                Fresult = HandleProcessParameters(ProcessParams);
+            }
+        }
+    }
 
     return Fresult;
 }
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
index c8836a2b4..d5b4867f0 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
@@ -1047,7 +1047,7 @@ uint32_t IDSPreSegmentState(void *SegmentDetails, int SegmentId)
             {
                 MotorSetMicroStep(HW_Motor_Id, MotorsCfg[HW_Motor_Id].microstep);
             }
-            if ((EnableIntersegment == true)&&(IntersegmentLength>0))
+            if ((EnableIntersegment == true)&&(IntersegmentLength>0.1)&&(SegmentId>0))
             {
                 MotorStop(HW_Motor_Id,Soft_Hiz); //26/03/19 test  without valves
                 CurrentDispenserSpeed[DispenserId] = 0;
diff --git a/Software/Embedded_SW/Embedded/Modules/IFS/RfidTagContent.h b/Software/Embedded_SW/Embedded/Modules/IFS/RfidTagContent.h
new file mode 100644
index 000000000..0764f2862
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Modules/IFS/RfidTagContent.h
@@ -0,0 +1,51 @@
+/*
+ * RfidTagContent.h
+ *
+ *  Created on: Jul 8, 2019
+ *      Author: shlomo
+ */
+
+#ifndef MODULES_IFS_RFIDTAGCONTENT_H_
+#define MODULES_IFS_RFIDTAGCONTENT_H_
+
+#include "PMR/Rfid/RfidCartridgeSlot.pb-c.h"
+#include "PMR/Rfid/RfidTagContent.pb-c.h"
+
+#include <DataDef.h>
+#include "include.h"
+
+
+#define MAX_CARTRIDGES (RFID_CARTRIDGE_SLOT__LowerWasteCartridge+1)
+typedef struct RfidTagContent
+{
+    uint32_t  UniqueId;
+    char  SerialNumber[16];
+    char  FactoryId[3];
+    int32_t   FillingSystemId;
+    char  ColorName[12];
+    int32_t   ColorCategory;
+    int32_t   ColorTypeRevision;
+    int32_t   CartridgeSize;
+    int32_t   FilledInkVolume;
+    char  InkBatchNum[10];
+    char  InkMFGDate[6];
+    char  InkEOLDate[6];
+    char  CartridgeFillingDate[6];
+    char  WasteFilledDate[6];
+    int32_t   PlugInCounter;
+    bool    Inkfill;
+    bool    InkUsed;
+    bool    InkEmpty;
+    bool    WasteEmpty;
+    bool    WasteFilling;
+    bool    WasteFull;
+    bool    Blocked;
+    bool    Fail;
+    int32_t   WasteCounter;
+    char  MachineIdInkUsed[16];
+    char  MachineIdWasteUsed[16];
+};
+
+
+
+#endif /* MODULES_IFS_RFIDTAGCONTENT_H_ */
diff --git a/Software/Embedded_SW/Embedded/Modules/IFS/ifs.c b/Software/Embedded_SW/Embedded/Modules/IFS/ifs.c
new file mode 100644
index 000000000..347808d5e
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Modules/IFS/ifs.c
@@ -0,0 +1,31 @@
+/*
+ * ifs.c
+ *
+ *  Created on: Jul 8, 2019
+ *      Author: shlomo
+ */
+#include "PMR/Diagnostics/CartridgeSlot.pb-c.h"
+#include "PMR/Diagnostics/CartridgeTagContent.pb-c.h"
+#include "RfidTagContent.h"
+#include <Drivers/I2C_Communication/RFID_NFC/RFIDTagInfo.h>
+
+#include <DataDef.h>
+#include "include.h"
+
+RfidTagContent TagContent[MAX_CARTRIDGES];
+NFC_Tag NFCTag[MAX_CARTRIDGES];
+void TagInitialize(RfidTagContent* TagContent);
+
+void IFS_Init(void)
+{
+    int i;
+    for (i=0;i<MAX_CARTRIDGES;i++)
+    {
+        TagInitialize(&TagContent[i]);
+        memset(NFCTag[i].Buf,0,sizeof(NFCTag[i]));
+    }
+}
+void TagInitialize(RfidTagContent* TagContent)
+{
+
+}
diff --git a/Software/Embedded_SW/Embedded/Modules/IFS/ifs.h b/Software/Embedded_SW/Embedded/Modules/IFS/ifs.h
new file mode 100644
index 000000000..ade89372d
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Modules/IFS/ifs.h
@@ -0,0 +1,16 @@
+/*
+ * ifs.h
+ *
+ *  Created on: Jul 8, 2019
+ *      Author: shlomo
+ */
+
+#ifndef MODULES_IFS_IFS_H_
+#define MODULES_IFS_IFS_H_
+
+
+
+void IFS_Init(void)
+
+
+#endif /* MODULES_IFS_IFS_H_ */
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread.h b/Software/Embedded_SW/Embedded/Modules/Thread/Thread.h
index 230d06601..e927ae436 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread.h
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread.h
@@ -9,6 +9,7 @@
 #include "PMR/Hardware/HardwareDancerType.pb-c.h"
 #include "PMR/Hardware/HardwareWinder.pb-c.h"
 #include "PMR/Hardware/HardwarePidControl.pb-c.h"
+#include "PMR/Hardware/HardwareConfiguration.pb-c.h"
 #include "PMR/Printing/JobSpool.pb-c.h"
 #include "PMR/Printing/JobSpoolType.pb-c.h"
 
@@ -73,7 +74,7 @@ extern int MotorSpeedSamplePointer[MAX_THREAD_MOTORS_NUM];
 
 
 uint32_t InternalWinderConfigMessage(HardwareWinder* request);
-uint32_t MotorsConfigMessage(HardwareMotor * request);
+uint32_t MotorsConfigMessage( HardwareConfiguration* HW_request);
 uint32_t InternalWindingConfigMessage(JobSpool* request);
 uint32_t ThreadInitialTestStub(HardwareMotor * request);
 uint32_t MotorPidRequestMessage(HardwarePidControl* request);
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
index 66d6baed5..9ef7f3d0d 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
@@ -62,6 +62,7 @@
     uint32_t ControlId = 0xFF;
     uint32_t ThreadLoadStateMachine( THREAD_LOAD_STAGES_ENUM LoadStages);
     uint32_t ThreadLoadControlCBFunction(uint32_t index, uint32_t ReadValue);
+    uint32_t Thread_Load_Dryer_UnLoading(void);
 
     typedef struct
     {
@@ -465,6 +466,74 @@
         REPORT_MSG(LoadStages,"Loading Ended");
         return OK;
     }
+    uint32_t Thread_Load_Dryer_UnLoading(void)
+    {
+        REPORT_MSG(LoadStages, "Thread UnLoad State Machine step");
+        LoadArmInfo.LoadArmRounds = 0;
+        uint32_t numberOfSteps = 0;
+        //Start Feeder Pid, Rotate Loading Arm Counter Thread Direction X Circles According To Rml. Feeder Speed Is 40
+        SetOriginMotorSpeed(20);
+//        OriginalMotorSpd_2PPS[FEEDER_MOTOR] = 1000;
+//        CurrentControlledSpeed[FEEDER_MOTOR] = 1000;
+
+        numberOfSteps = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround*LoadArmInfo.LoadArmRounds*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].microstep*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulleyradius;
+        MotorControlConfig[POOLER_MOTOR].m_params.MAX = 1;
+        MotorControlConfig[POOLER_MOTOR].m_params.MIN = MotorsControl[POOLER_MOTOR].outputproportionalpowerlimit*-1;
+        MotorControlConfig[POOLER_MOTOR].m_params.Kd = MotorsControl[POOLER_MOTOR].derivativetime;
+        MotorControlConfig[POOLER_MOTOR].m_params.Kp = MotorsControl[POOLER_MOTOR].proportionalgain;
+        MotorControlConfig[POOLER_MOTOR].m_params.Ki = MotorsControl[POOLER_MOTOR].integraltime;
+        MotorControlConfig[POOLER_MOTOR].m_params.IntegralErrorMultiplier = MotorsControl[POOLER_MOTOR].setpointramprateorsoftstartramp;
+        MotorControlConfig[POOLER_MOTOR].m_params.ProportionalErrorMultiplier = MotorsControl[POOLER_MOTOR].outputonoffhysteresisvalue;
+        MotorControlConfig[POOLER_MOTOR].m_params.epsilon = MotorsControl[POOLER_MOTOR].epsilon;
+        MotorControlConfig[POOLER_MOTOR].m_params.dt = MotorsControl[POOLER_MOTOR].controloutputtype;
+        MotorControlConfig[POOLER_MOTOR].m_ingnoreValue =  MotorsControl[POOLER_MOTOR].sensorcorrectionadjustment; // the minimal change required to change the motor speed in pulses
+        MotorControlConfig[POOLER_MOTOR].m_calculatedError = 0;
+        MotorControlConfig[POOLER_MOTOR].m_integral = 0;
+        MotorControlConfig[POOLER_MOTOR].m_isEnabled = true;
+        MotorControlConfig[POOLER_MOTOR].m_isReady = true;
+        MotorControlConfig[POOLER_MOTOR].m_mesuredParam = 0;
+        MotorControlConfig[POOLER_MOTOR].m_preError = 0;
+        MotorControlConfig[POOLER_MOTOR].m_SetParam = 0;//need to update SetParams on presegment stage
+        MotorSetDirection(HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LDRIVING].directionthreadwize);
+
+        ControlId = AddControlCallback(ThreadLoadControlCBFunction, eOneMillisecond,Control_Read_Dancer_Position,(IfTypeThread*0x100+POOLER_MOTOR),FEEDER_DANCER,POOLER_MOTOR);
+////////////////////////
+        MotorControlConfig[WINDER_MOTOR].m_params.MAX = 1;
+        MotorControlConfig[WINDER_MOTOR].m_params.MIN = MotorsControl[WINDER_MOTOR].outputproportionalpowerlimit*-1;
+        MotorControlConfig[WINDER_MOTOR].m_params.Kd = MotorsControl[WINDER_MOTOR].derivativetime;
+        MotorControlConfig[WINDER_MOTOR].m_params.Kp = MotorsControl[WINDER_MOTOR].proportionalgain;
+        MotorControlConfig[WINDER_MOTOR].m_params.Ki = MotorsControl[WINDER_MOTOR].integraltime;
+        MotorControlConfig[WINDER_MOTOR].m_params.IntegralErrorMultiplier = MotorsControl[WINDER_MOTOR].setpointramprateorsoftstartramp;
+        MotorControlConfig[WINDER_MOTOR].m_params.ProportionalErrorMultiplier = MotorsControl[WINDER_MOTOR].outputonoffhysteresisvalue;
+        MotorControlConfig[WINDER_MOTOR].m_params.epsilon = MotorsControl[WINDER_MOTOR].epsilon;
+        MotorControlConfig[WINDER_MOTOR].m_params.dt = MotorsControl[WINDER_MOTOR].controloutputtype;
+        MotorControlConfig[WINDER_MOTOR].m_ingnoreValue =  MotorsControl[WINDER_MOTOR].sensorcorrectionadjustment; // the minimal change required to change the motor speed in pulses
+        MotorControlConfig[WINDER_MOTOR].m_calculatedError = 0;
+        MotorControlConfig[WINDER_MOTOR].m_integral = 0;
+        MotorControlConfig[WINDER_MOTOR].m_isEnabled = true;
+        MotorControlConfig[WINDER_MOTOR].m_isReady = true;
+        MotorControlConfig[WINDER_MOTOR].m_mesuredParam = 0;
+        MotorControlConfig[WINDER_MOTOR].m_preError = 0;
+        MotorControlConfig[WINDER_MOTOR].m_SetParam = 0;//need to update SetParams on presegment stage
+        MotorSetDirection(HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LDRIVING].directionthreadwize);
+
+        ControlId = AddControlCallback(ThreadLoadControlCBFunction, eOneMillisecond,Control_Read_Dancer_Position,(IfTypeThread*0x100+WINDER_MOTOR),FEEDER_DANCER,WINDER_MOTOR);
+
+////////////////////////
+
+        CallbackCounter++;
+        //MotorMoveWithCallback (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize,
+        //                       numberOfSteps,    Thread_Load_Dryer_Loading_Callback, 100000);
+        Report("Thread_Load_Set_Load_Arm_To_Start_Position",__FILE__,__LINE__,LoadStages,RpMessage,NumberOfDrierLoaderCycles,0);
+        status |= MotorMoveToStopper(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, (1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize),
+                                        MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround/2, Thread_Load_Set_Load_Arm_To_Stopper_Callback,LoadArmInfo.LoadArmBackLash,1000);
+
+        //Keep Notation How Many Rotations In The Dryer
+        //LoadArmInfo.LoadArmBackLash = 0;
+        LoadArmInfo.LoadArmRounds = 0xFF;
+        FileWrite(&LoadArmInfo, sizeof(LoadArmInfo),LoadArmPath);
+        return OK;
+    }
 
     uint32_t ThreadLoadStateMachine( THREAD_LOAD_STAGES_ENUM ReadValue)
     {
@@ -481,7 +550,8 @@
             break;
         case THREAD_LOAD_SET_LOAD_ARM_TO_START_POSITION://USE NOTATION HOW MANY ROTATIONS IN THE DRYER, OR CHECK AGAINS STOPPER. MOVE SLOWLY
             //LoadStages++;
-            Thread_Load_Set_Load_Arm_To_Start_Position();
+            //Thread_Load_Set_Load_Arm_To_Start_Position();
+            Thread_Load_Dryer_UnLoading();
             break;
         case THREAD_LOAD_CENTER_HEAD_ROCKERS:
             //LoadStages++;
@@ -570,11 +640,11 @@ uint32_t ThreadLoadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
         return 0xFFFFFFFF;
     }
     index = IfIndex&0xFF;
-    /*if (index == POOLER_MOTOR)
+    if (index == POOLER_MOTOR)
     {
         //pooler dancer is right sided: data is opposite
         TranslatedReadValue = (-1*TranslatedReadValue);
-    }*/
+    }
     //TranslatedReadValue = 0;//test
     MotorSamples[index][MotorSamplePointer[index]] = TranslatedReadValue;//(-1 * TranslatedReadValue);
     MotorSamplePointer[index]++;
@@ -589,10 +659,10 @@ uint32_t ThreadLoadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
     MotorControlConfig[index].m_mesuredParam = NormalizedError;
     MotorControlConfig[index].m_calculatedError = AdvancedPIDAlgorithmCalculation((float)MotorControlConfig[index].m_SetParam , (float)MotorControlConfig[index].m_mesuredParam,
                                                                           &MotorControlConfig[index].m_params,   &MotorControlConfig[index].m_preError, &MotorControlConfig[index].m_integral);
-    /*if (index != FEEDER_MOTOR) //feeder unit handles errors opposite to left unit
+    if (index != FEEDER_MOTOR) //feeder unit handles errors opposite to left unit
     {
         MotorControlConfig[index].m_calculatedError = (-1*MotorControlConfig[index].m_calculatedError);
-    }*/
+    }
     calculated_speed = (1-MotorControlConfig[index].m_calculatedError)*OriginalMotorSpd_2PPS[index];
     if (fabs(calculated_speed-CurrentControlledSpeed[index])> MotorControlConfig[index].m_ingnoreValue)
     {
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c
index 529e4d260..78203b236 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c
@@ -40,11 +40,20 @@ int32_t BreakSensordebouncetimemilli = BREAK_SENSOR_LIMIT;
 HardwarePidControlType ThreadMotorIdToControlId[MAX_THREAD_MOTORS_NUM] = {HARDWARE_PID_CONTROL_TYPE__MotorFeeder,HARDWARE_PID_CONTROL_TYPE__MotorDryer,HARDWARE_PID_CONTROL_TYPE__MotorPooler,HARDWARE_PID_CONTROL_TYPE__MotorWinder,0};
 
 //********************************************************************************************************************
-uint32_t MotorsConfigMessage(HardwareMotor * request)
+uint32_t MotorsConfigMessage(HardwareConfiguration * HWrequest)
 {
     uint32_t status = PASSED;
-    TimerMotors_t Motor_i;
-    Motor_i = request->hardwaremotortype;
+    TimerMotors_t Motor_i,MotorId;
+    MOTDRIVER_TYPE DriverType;
+    HardwareMotor *request;
+    if (HWrequest == NULL)
+        return ERROR;
+    for (MotorId = 0; MotorId < HWrequest->n_motors ; MotorId++)
+    {
+        request = HWrequest->motors[MotorId];
+        if (request == NULL)
+            return ERROR;
+        Motor_i = request->hardwaremotortype;
         MotorsCfg[Motor_i].configword = request->configword;
         MotorsCfg[Motor_i].hardwaremotortype = request->hardwaremotortype;
         MotorsCfg[Motor_i].minfrequency = request->minfrequency;
@@ -80,13 +89,21 @@ uint32_t MotorsConfigMessage(HardwareMotor * request)
         MotorsCfg[Motor_i].fnslpdec = request->fnslpdec;
         MotorsCfg[Motor_i].fsspd = request->fsspd;
 
-        status = MotorConfig( Motor_i,  &MotorsCfg[Motor_i]);
+        MotorsCfg[Motor_i].gatecfg1 = request->gatecfg1;
+        MotorsCfg[Motor_i].gatecfg2 = request->gatecfg2;
+        MotorsCfg[Motor_i].tvalhold = request->tvalhold;
+        MotorsCfg[Motor_i].tvalrun  = request->tvalrun ;
+        MotorsCfg[Motor_i].tvalacc  = request->tvalacc ;
+        MotorsCfg[Motor_i].tvaldec  = request->tvaldec ;
+        MotorsCfg[Motor_i].tfast    = request->tfast   ;
+        MotorsCfg[Motor_i].tonmin   = request->tonmin  ;
+        MotorsCfg[Motor_i].toffmin  = request->toffmin ;
+
+            status = MotorConfig( Motor_i,  &MotorsCfg[Motor_i]);
 //        if (Motor_i == MOTOR_RDRIVING)
 //            ThreadInitialTestStub(request);
-
+    }
         return status;
-//    }
-//    else return Motor_i;
 
 }
 uint32_t MotorPidRequestMessage(HardwarePidControl* request)