aboutsummaryrefslogtreecommitdiffstats
path: root/Software/Embedded_SW/Embedded/Common/Utilities/idle_task.h
blob: 9260756ddd7c1129b02876f22603340843e9afe2 (plain) 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

/*
 * idle_task.h
 *
 *  Created on: 2 april 2018
 *      Author: shlomo
 */

#ifndef COMMON_UTILITIES_IDLE_TASK_H_
#define COMMON_UTILITIES_IDLE_TASK_H_

extern void    IDLE_TASK_package_init(void);
extern void    IDLE_change_parameters(uint32_t new_interval);  /*time interval by ticks*/
extern int     IDLE_TASK_get_load(void);
extern int     IDLE_TASK_get_current_load(void);
extern uint32_t IDLE_TASK_monitor_init(void);

extern IdleTaskGetLoadTable(uint32_t *);


#endif /* COMMON_UTILITIES_IDLE_TASK_H_ */
generated by cgit v1.3.1 (git 2.54.0) at 2026-07-24 01:33:51 +0000
/************************************************************************************************************************
 * control.c
 * Control module
 *
************************************************************************************************************************/
#include <Container.h>
#include <DataDef.h>
#include "include.h"
#include "GeneralHardware.h"
#include "thread/thread.h"
#include "ids/ids.h"
#include "control/control.h"
#include "Control/MillisecTask.h"
#include "AlarmHandling/AlarmHandling.h"
#include "heaters/heaters_ex.h"

#include "Diagnostics/Diagnostics.h"

#include "heaters/heaters_ex.h"

#include "third_party/fatfs/src/ffconf.h"
#include "third_party/fatfs/src/diskio.h"
#include "drivers/Flash_Memory/Flash_Memory.h"
#include "drivers/Flash_Memory/fatfs/ff.h"
#include "drivers/Flash_ram/FlashProgram.h"

#include "third_party/fatfs/src/ffconf.h"
#include "Common/SWUpdate/FileSystem.h"

#include "PMR/common/MessageContainer.pb-c.h"
#include "PMR/Hardware/UploadHardWareConfigurationRequest.pb-c.h"
#include "PMR/Hardware/UploadHardWareConfigurationResponse.pb-c.h"
#include "PMR/EmbeddedParameters/ConfigurationParameters.pb-c.h"
#include "PMR/Hardware/SystemResetRequest.pb-c.h"
#include "PMR/Hardware/SystemResetResponse.pb-c.h"

#include "PMR/Printing/ProcessParameters.pb-c.h"
#include "PMR/Printing/UploadProcessParametersRequest.pb-c.h"
#include "PMR/Printing/UploadProcessParametersResponse.pb-c.h"

#include "drivers/I2C_Communication/DAC/Blower.h"
#include "drivers/Valves/Valve.h"
#include "drivers/I2C_Communication/ADC_MUX/ADC_MUX.h"

#include "StateMachines/Printing/PrintingSTM.h"
#include "StateMachines/Initialization/InitSequence.h"
#include "StateMachines/Initialization/PowerIdle.h"
#include "StateMachines/Initialization/PowerOffSequence.h"
#include "Drivers/I2C_Communication/Dispenser_Card/EEPROM/Dispenser_EEPROM.h"
#include <Drivers/I2C_Communication/Dispenser_Card/IO_Ports/Dispenser_IO.h>

uint32_t EmbeddedParametersInit(void);
uint32_t EmbeddedParametersWrite(void * buffer, uint16_t size);
uint32_t HWConfiguration(UploadHardwareConfigurationRequest* UploadRequest);

bool GeneralHwReady = false;

HardwareBlower BlowerCfg;
char *SW_INFO_DIR = "0://SysInfo";

char HwConfigPath[50] = "0://SysInfo//GenHwCfg.cfg";
void *HWConfigurationLoadFromFile( uint32_t *NumOfBytes)
{
    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;

    *NumOfBytes = 0;
    Fresult = f_mkdir(SW_INFO_DIR);
    if ((Fresult == FR_OK)||(Fresult == FR_EXIST))
    {
        FileHandle = my_malloc(sizeof(FIL));

        Fresult = FileOpen(HwConfigPath, &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");
                    free (buffer);
                    buffer = NULL;
                }
                else
                    *NumOfBytes = Bytes;
            }
        }
        f_close(FileHandle);
        free (FileHandle);
    }

    return buffer;
}

uint32_t HWConfigurationInit(void)
{
    void* buffer1 = NULL;
    uint32_t status = OK;
    UploadHardwareConfigurationRequest* UploadRequest=0;
    uint8_t* buffer = NULL;
    uint32_t Bytes = 0;

    GeneralHwReady = false;
    Control_WD(ENABLE,250);

    memcpy(&Bytes,(void *)GENHWCFG_MAP_IN_FLASH,sizeof(Bytes));

    if ((Bytes)&&(Bytes < 4000))
    {
        buffer1 = my_malloc (Bytes);
        if (buffer1)
        {
            memcpy(buffer1, (void *)(GENHWCFG_MAP_IN_FLASH+4),Bytes);
            UploadRequest = upload_hardware_configuration_request__unpack(NULL, Bytes, buffer1);
        }
    }
    //buffer = HWConfigurationLoadFromFile(&Bytes);
    //status= memcmp(buffer,buffer1,Bytes);
    //UploadRequest = upload_hardware_configuration_request__unpack(NULL, Bytes, buffer);
    status = HWConfiguration(UploadRequest);
    if (status ==OK)
    {
       upload_hardware_configuration_request__free_unpacked(UploadRequest,NULL);
       //EraseFlashSection(GENHWCFG_MAP_IN_FLASH,Bytes+4);
       //ReadAppAndProgram(GENHWCFG_MAP_IN_FLASH, 4,Bytes);
       //ReadAppAndProgram(GENHWCFG_MAP_IN_FLASH+4, Bytes, buffer);
    }
    else
    {
        SetMachineState(MACHINE_STATE_HW_CONFIG_FAILED);
    }
    if (buffer)
        free (buffer);

    //EmbeddedParametersInit();
    IDS_Dispenser_Content_Init();
    //ProcessParamsInit();
    GeneralHwReady = true;
    STATUS_RED_LED_OFF;
    return status;
}

char EmbeddedParametersPath[50] = "0://SysInfo//EmbParam.cfg";
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.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));
            size_t response_size = 0;
            if (response_buffer)
            {
                response_size = configuration_parameters__pack(&EmbeddedParameters, response_buffer);
            }
            FileWrite(response_buffer,response_size,EmbeddedParametersPath);
            my_free(response_buffer);
        }
        else
        {
            memcpy (&EmbeddedParameters,Params,sizeof(EmbeddedParameters));
        }
    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;
    uint32_t Bytes = 0;

    ConfigurationParameters *Params;

    memcpy(&Bytes,(void *)EMBEDDED_PARAMETERS_MAP_IN_FLASH,sizeof(Bytes));

    if ((Bytes)&&(Bytes < 1000))
    {
        Params = (ConfigurationParameters *)(EMBEDDED_PARAMETERS_MAP_IN_FLASH+4);
        memcpy (&EmbeddedParameters,Params,sizeof(EmbeddedParameters));
    }
    else
    {
        LoadConfigurationParameters(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);

    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);
    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;
    AlarmHandlingSetFlags(a1,a2,a3);

    PowerIdleSetParameters(EmbeddedParameters.switchtoidletimeinseconds,EmbeddedParameters.idledriertemperature,EmbeddedParameters.idleheadtemperature,EmbeddedParameters.idlemixertemperature);

    return Fresult;
}
uint32_t GenHWControlId;

uint32_t GenHWInitCallBackFunction(uint32_t IfIndex, uint32_t BusyFlag)
{
    int   Dispenser_i;
    SafeRemoveControlCallback(GenHWControlId, GenHWInitCallBackFunction );
    for (Dispenser_i = 0;Dispenser_i < MAX_SYSTEM_DISPENSERS;Dispenser_i++)
    {
        Read_MidTank_Pressure_Sensor(Dispenser_i);
        Valve_Set(IDS_Id_to_AirValve[Dispenser_i], Atm_MidTank_OFF );   //Atm_MidTank_OFF/ON
            Disable_MidTank_Pressure_Reading(Dispenser_i);
    }
    return OK;
}

uint32_t HWConfiguration(UploadHardwareConfigurationRequest* UploadRequest)
{
    uint32_t status  = 0;
    int Motor_i, Dancer_i, Dispenser_i,PID_i;

    if (UploadRequest == NULL)
    {
        LOG_ERROR (0, "Wrong Data Allocation");
        return ERROR;
    }
    HardwareConfiguration *request =    UploadRequest->hardwareconfiguration;

    if (JobIsActive())
    {
        LOG_ERROR(1,"JobIsActive");
        return ERROR;
    }
    if (watchdogCriticalAlarm == true)
    {
        LOG_ERROR(1,"Critical Alarm cleared - Watchdog de-activated");
        watchdogCriticalAlarm = false;
    }
    EmbeddedParametersInit();

    PrintingHWConfiguration(request);
    if (request->n_winders == 1)
        status += InternalWinderConfigMessage(request->winders);


    status += MotorsInit();
 
    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]);
    }
    else
    {
        LOG_ERROR (request->n_motors, "Wrong Data");
        upload_hardware_configuration_request__free_unpacked(UploadRequest,NULL);
        return ERROR;
    }
    if (request->n_dancers <= NUM_OF_DANCERS)
    {
        for (Dancer_i = 0; Dancer_i < request->n_dancers ; Dancer_i++)
            status += DancerConfigMessage(request->dancers[Dancer_i]);
    }
    else
    {
        LOG_ERROR (request->n_dancers, "Wrong Data");
        upload_hardware_configuration_request__free_unpacked(UploadRequest,NULL);
        return ERROR;
    }
    LoadDancerConfigMessage();
    //StoreDancerConfigMessage();
    if (request->n_pidcontrols <= HARDWARE_PID_CONTROL_TYPE__Dispenser8)
    {
        IDS_DispenserControlInit();

        for (PID_i = 0; PID_i < request->n_pidcontrols ; PID_i++)
        {
            if (request->pidcontrols[PID_i]->hardwarepidcontroltype <= HARDWARE_PID_CONTROL_TYPE__MixerHeater)
                status += HeaterConfigRequestMessage(request->pidcontrols[PID_i]);
            else if ((request->pidcontrols[PID_i]->hardwarepidcontroltype >= HARDWARE_PID_CONTROL_TYPE__MotorDryer)&&
                    (request->pidcontrols[PID_i]->hardwarepidcontroltype < HARDWARE_PID_CONTROL_TYPE__Dispenser1))
                status += MotorPidRequestMessage(request->pidcontrols[PID_i]);
            else if (request->pidcontrols[PID_i]->hardwarepidcontroltype >= HARDWARE_PID_CONTROL_TYPE__Dispenser1)
                status += IDS_DispenserPidRequestMessage(request->pidcontrols[PID_i]);
        }
    }
    else
    {
        LOG_ERROR (request->n_pidcontrols, "Wrong Data");
        upload_hardware_configuration_request__free_unpacked(UploadRequest,NULL);
        return ERROR;
    }
    if (request->n_dispensers <= MAX_SYSTEM_DISPENSERS)
    {
        for (Dispenser_i = 0; Dispenser_i < request->n_dispensers ; Dispenser_i++)
        {
            status += DispenserConfigMessage(request->dispensers[Dispenser_i]);
            if (Check_Dispenser_Type(request->dispensers[Dispenser_i]->index) == LS_STATUS_ERROR)
            {
                LOG_ERROR (Dispenser_i, "Dispenser identification failed");
                //return ERROR;
            }
        }
    }
    else
    {
        LOG_ERROR (request->n_dispensers, "Wrong Data");
        upload_hardware_configuration_request__free_unpacked(UploadRequest,NULL);
        return ERROR;
    }
    Init_Dispensers_IO_Registers(&Disp_IO_Reg);
    if (request->n_breaksensors == 1)
    {
        ThreadConfigBreakSensor(request->breaksensors[0]);
    }

    if(request->blowers[0]->enabled)
    {
        BlowerCfg.enabled = true;
        BlowerCfg.voltage = request->blowers[0]->voltage;
        BlowerCfg.heatingvoltage = request->blowers[0]->heatingvoltage;
    }
    else
    {
        BlowerCfg.enabled = true;
        BlowerCfg.voltage = 3000;
        BlowerCfg.heatingvoltage = 3000;
    }
    //from now on starting blower on INIT, so that the chiller does not freeze
    /*if (BlowerCfg.enabled == true)
    {
        Turn_the_Blower_On();//Turn on with the Default_Voltage
        if (BlowerCfg.heatingvoltage)
            Control_Voltage_To_Blower(BlowerCfg.heatingvoltage);
        else
            Control_Voltage_To_Blower(BlowerCfg.voltage-500);

    }*/

/*
    for (Dispenser_i = 0;Dispenser_i < MAX_SYSTEM_DISPENSERS;Dispenser_i++)
    {
        Enable_MidTank_Pressure_Reading(Dispenser_i);
        Valve_Set(IDS_Id_to_AirValve[Dispenser_i], Atm_MidTank_ON );   //Atm_MidTank_OFF/ON
    }
    GenHWControlId = AddControlCallback( GenHWInitCallBackFunction, 2* eOneSecond, TemplateDataReadCBFunction,0,0, 0 );
*/
    ControlStart();
    AlarmHandlingStart();
    //ThreadInitialTestStub(request);
    GeneralHwReady = true;
    STATUS_RED_LED_OFF;
    return OK;
}
uint32_t HWConfigurationFunc(MessageContainer* requestContainer)
{
    uint32_t status  = 0;
    uint32_t DataLen  = 0;
    MessageContainer responseContainer;
    UploadHardwareConfigurationResponse response = UPLOAD_HARDWARE_CONFIGURATION_RESPONSE__INIT;

    EraseFlashSection(GENHWCFG_MAP_IN_FLASH,requestContainer->data.len+4);
    DataLen = requestContainer->data.len;
    ReadAppAndProgram(GENHWCFG_MAP_IN_FLASH, 4,&DataLen);
    ReadAppAndProgram(GENHWCFG_MAP_IN_FLASH+4, requestContainer->data.len, requestContainer->data.data);

    FileWrite(requestContainer->data.data, requestContainer->data.len,HwConfigPath);

    UploadHardwareConfigurationRequest* UploadRequest = upload_hardware_configuration_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);

    GeneralHwReady = false;
    Control_WD(ENABLE,250);

    status = HWConfiguration(UploadRequest);

    GeneralHwReady = true;

    responseContainer = createContainer(MESSAGE_TYPE__UploadHardwareConfigurationResponse, requestContainer->token, true, &response, &upload_hardware_configuration_response__pack, &upload_hardware_configuration_response__get_packed_size);
    if (status!= OK)
    {
        responseContainer.error = ERROR_CODE__INVALID_PARAMETER;
        responseContainer.errormessage = "JOb Active or incorrect parameters";
    }
    uint8_t* container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
    size_t container_size = message_container__pack(&responseContainer, container_buffer);
    my_free(responseContainer.data.data);
    upload_hardware_configuration_request__free_unpacked(UploadRequest,NULL);
    SendChars(container_buffer, container_size);

    return OK;



}

void HWSystemResetRequest(MessageContainer* requestContainer)
{
    //uint32_t status = FAILED;

    MessageContainer responseContainer;
    SystemResetRequest* request = system_reset_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);

    SystemResetResponse response =   SYSTEM_RESET_RESPONSE__INIT;


    responseContainer = createContainer(MESSAGE_TYPE__SystemResetResponse, requestContainer->token, true, &response, &system_reset_response__pack, &system_reset_response__get_packed_size);

    system_reset_request__free_unpacked(request,NULL);
    //-------------------------------------------------------------------------------------------
    uint8_t* container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
    size_t container_size = message_container__pack(&responseContainer, container_buffer);
    SendChars((char*)container_buffer, container_size);

    ROM_SysCtlDelay(SYS_CLK_FREQ);

    SysCtlReset();

    HWREG(NVIC_APINT) = NVIC_APINT_VECTKEY |  NVIC_APINT_SYSRESETREQ;

}
uint32_t FlashInitResults[5] = {0,0,0,0,0};
void FlashInitAndLoad(void)
{
    FRESULT Fresult = FR_OK;
    uint8_t* buffer = NULL;
    uint32_t Bytes = 0;

    ConfigurationParameters *Params = NULL;
    ProcessParameters*  ProcessParams = NULL;
    UploadProcessParametersRequest* request = NULL;

    char ProcessParamsPath[50] = "0://SysInfo//ProcessP.cfg";
#ifdef WATCHDOG
        ROM_WatchdogResetDisable(WATCHDOG0_BASE);
        uint32_t timeout = 120000000*35;
        ROM_WatchdogReloadSet(WATCHDOG0_BASE, timeout);
#endif

    FlashInit(); //initialize flash
    Report("Flash Initialized", __FILE__,__LINE__,FLASH_SIZE, RpMessage, FLASH_RAM_BASE, 0);

    buffer = HWConfigurationLoadFromFile(&Bytes); //load hardware config
    if (buffer)
    {
       ReadAppAndProgram(GENHWCFG_MAP_IN_FLASH, 4,&Bytes);
       ReadAppAndProgram(GENHWCFG_MAP_IN_FLASH+4, Bytes, buffer);
       free (buffer);
       FlashInitResults[0] = true;
    }
    Report("Hardware Initialized", __FILE__,__LINE__,Bytes, RpMessage, GENHWCFG_MAP_IN_FLASH, 0);

    StoreDancerConfigMessage();
    Report("Dancer Initialized", __FILE__,DancersCfg[0].zeropoint,DancersCfg[1].zeropoint, RpMessage, DancersCfg[2].zeropoint, 0);
    Bytes = AlarmHandlingLoadFile();
    if (Bytes>0)
    {
        Report("Alarm Initialized from file", __FILE__,__LINE__,Bytes, RpMessage, ALARM_MAP_IN_FLASH, 0);
    }
    else
    {
        Bytes = AlarmHandlingFlashLoad();
        Report("Alarm Initialized hard coded", __FILE__,__LINE__,Bytes, RpMessage, ALARM_MAP_IN_FLASH, 0);
    }

    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__,sizeof(EmbeddedParameters), RpMessage, EMBEDDED_PARAMETERS_MAP_IN_FLASH, 0);
    }
    else
    {
        LoadConfigurationParameters(0);
        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)
    {
        request = upload_process_parameters_request__unpack(NULL, Bytes, buffer);
        ProcessParams = request->processparameters;
        Bytes = sizeof(ProcessParams);
        ReadAppAndProgram(PROCESS_PARAMETERS_MAP_IN_FLASH, 4,&Bytes);
        ReadAppAndProgram(PROCESS_PARAMETERS_MAP_IN_FLASH+4, Bytes, &ProcessParams);
        upload_process_parameters_request__free_unpacked(request,NULL);
        FlashInitResults[2] = true;
        Report("Process Initialized", __FILE__,__LINE__,Bytes, RpMessage, (int)ProcessParams->dryerzone1temp, 0);
    }
    else
        Report("Process not Initialized", __FILE__,__LINE__,0, RpMessage, 0, 0);
#ifdef WATCHDOG
        ROM_WatchdogResetEnable(WATCHDOG0_BASE);
        timeout = 120000000*3;
        ROM_WatchdogReloadSet(WATCHDOG0_BASE, timeout);
#endif

}
generated by cgit v1.3.1 (git 2.54.0) at 2026-07-24 01:33:51 +0000