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

3 files changed, 183 insertions, 160 deletions

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