Properties « Tango.Synchronization « Visual_Studio « Software - Tango

Mode	Name	Size
-rw-r--r--	AssemblyInfo.cs	251	log stats plain
/************************************************************************************************************************
 * 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/MidTankDataSetupRequest.pb-c.h"
#include "PMR/EmbeddedParameters/MidTankDataSetupResponse.pb-c.h"
#include "PMR/EmbeddedParameters/ConfigurationParameters.pb-c.h"
#include "PMR/EmbeddedParameters/MachineCalibrationDataRequest.pb-c.h"
#include "PMR/EmbeddedParameters/MachineCalibrationDataResponse.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 "drivers/Flash_ram/MCU_E2Prom.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>
#include "Modules/General/buttons.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;
    uint8_t* buffer = NULL;

    *NumOfBytes = 0;
    Fresult = f_mkdir(SW_INFO_DIR);
    if ((Fresult == FR_OK)||(Fresult == FR_EXIST))
    {
        Fresult = FileRead(HwConfigPath, NumOfBytes, &buffer);
        REPORT_IF_ERROR(Fresult, "HW Config File Read error", Fresult, RpError, buffer, 0);
    }
//    if (Fresult)
//        Report("HW Config File Read error", __FILE__,__LINE__, Fresult, RpError, buffer, 0);

    return buffer;
}

uint32_t HWConfigurationInit(void)
{
    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))
    {
        buffer = my_malloc (Bytes);
        if (buffer)
        {
            memcpy(buffer, (void *)(GENHWCFG_MAP_IN_FLASH+4),Bytes);
            UploadRequest = upload_hardware_configuration_request__unpack(NULL, Bytes, buffer);
            Report("HWConfigurationInit from flash", __FILE__,__LINE__,Bytes, RpMessage, UploadRequest->hardwareconfiguration->n_dancers, 0);
        }
    }
    else
    {
        buffer = HWConfigurationLoadFromFile(&Bytes); //load hardware config
        if (buffer)
        {
           EraseFlashSection(GENHWCFG_MAP_IN_FLASH,Bytes+4);
           ReadAppAndProgram(GENHWCFG_MAP_IN_FLASH, 4,&Bytes);
           ReadAppAndProgram(GENHWCFG_MAP_IN_FLASH+4, Bytes, buffer);
           UploadRequest = upload_hardware_configuration_request__unpack(NULL, Bytes, buffer);
           Report("HWConfigurationInit from file", __FILE__,__LINE__,Bytes, RpMessage, UploadRequest->hardwareconfiguration->n_dancers, 0);
        }
        else
            Report("HWConfigurationInit Not available", __FILE__,__LINE__,Bytes, RpMessage, 0, 0);

    }

    //buffer = HWConfigurationLoadFromFile(&Bytes);
    //status= memcmp(buffer,buffer1,Bytes);
    //UploadRequest = upload_hardware_configuration_request__unpack(NULL, Bytes, buffer);
    if (UploadRequest)
    {
        status = HWConfiguration(UploadRequest);
        if (status !=OK)
        {
            SetMachineState(MACHINE_STATE_HW_CONFIG_FAILED);
            STATUS_GREEN_LED_OFF;
        }
        else
        {
            STATUS_RED_LED_OFF;
        }
        upload_hardware_configuration_request__free_unpacked(UploadRequest,NULL);
    }
    if (buffer)
        free (buffer);

    //EmbeddedParametersInit();
    IDS_Dispenser_Content_Init();
    //ProcessParamsInit();
    Buttons_Init();
    WHS_init();

    ADC_MUX_Init();
    GeneralHwReady = true;
    return status;
}

char EmbeddedParametersPath[50] = "0://SysInfo//EmbParam.cfg";
ConfigurationParameters *EmbeddedParameters;
bool DataUpdated = false;
void LoadConfigurationParameters(ConfigurationParameters *Params)
{
    if (Params == 0)
        {
            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 = 50;
            EmbeddedParameters->has_openvalvetimeout = true;
            EmbeddedParameters->openvalvetimeout = 50;
            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->n_generalparameters = 8;
            EmbeddedParameters->generalparameters = malloc (sizeof(double)*10);
            if (EmbeddedParameters->generalparameters)
            {
                EmbeddedParameters->generalparameters[0] = 1.0; //CheckHardLimitAlarms
                EmbeddedParameters->generalparameters[1] = 1.0; //CheckCurrentAlarms
                EmbeddedParameters->generalparameters[2] = 0.0; //CheckTamperAlarms
                EmbeddedParameters->generalparameters[3] = 0.0; //CheckMotorAlarms
                EmbeddedParameters->generalparameters[4] = 800.0; //Winder homing time at end of job
                EmbeddedParameters->generalparameters[5] = 1000.0; //Dispenser initial pressure speed
                EmbeddedParameters->generalparameters[6] = Diagnostic_Normal_Mode; //Diagnostic Mode SetDiagnosticMode
                EmbeddedParameters->generalparameters[7] = AutoHoming_JobEnd_PowerOn_off; //
            }
            EmbeddedParameters->has_currentalarmlowlimit = true;
            EmbeddedParameters->currentalarmlowlimit = 0.77;
            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);
                EraseFlashSection(EMBEDDED_PARAMETERS_MAP_IN_FLASH,response_size+4);
                ReadAppAndProgram(EMBEDDED_PARAMETERS_MAP_IN_FLASH, 4,&response_size);
                ReadAppAndProgram(EMBEDDED_PARAMETERS_MAP_IN_FLASH+4, response_size, response_buffer);
                my_free(response_buffer);
            }
        }
        else
        {
            EmbeddedParameters = Params;
        }
}
uint32_t EmbeddedParametersInit(void)
{
    FRESULT Fresult = FR_OK;
    uint32_t Bytes = 0;

    ConfigurationParameters *Params;

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

    if ((Bytes)&&(Bytes < 1000))
    {
        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
    {
        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);
        }
    }

    if (EmbeddedParameters->n_generalparameters >= 6)
    {
        IDS_Dispenser_SetBackLashValues(EmbeddedParameters->initialdispenserpressure, EmbeddedParameters->initialdispensertimeout, EmbeddedParameters->initialdispensertimelag,EmbeddedParameters->generalparameters[5]);
    }
    else
    {
        IDS_Dispenser_SetBackLashValues(EmbeddedParameters->initialdispenserpressure, EmbeddedParameters->initialdispensertimeout, EmbeddedParameters->initialdispensertimelag,900);
    }

    IDS_Dispenser_SetTimeOutValues(EmbeddedParameters->closevalvetimeout, EmbeddedParameters->openvalvetimeout);
    IDS_Dispenser_SetPrepareValues(EmbeddedParameters->dispenserbuildpressurespeed,   EmbeddedParameters->dispenserbuildpressurelimit, EmbeddedParameters->dispenserbuildpressuretimeout, EmbeddedParameters->dispenserbuildpressurelag);
    IDS_Dispenser_SetPreSegmentWFCFValues(EmbeddedParameters->dispenserpresegmentwfcf,  EmbeddedParameters->ids_presegment_wfcf_timebeforesegment);
    IDS_Dispenser_SetPreSegmentCleaningValues(EmbeddedParameters->ids_cleaningspeed,EmbeddedParameters->ids_cleaningstartspraypresegmenttime ,EmbeddedParameters->ids_cleaningstopbeforesegmenttime,EmbeddedParameters->ids_leftcleaningmotorspeed,EmbeddedParameters->ids_rightcleaningmotorspeed);

    Heaters_SetOverHeatTimeOutValues( EmbeddedParameters->overheatcountlimit,  EmbeddedParameters->underheatcountlimit);
    Heaters_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 checkHardLimitAlarms = false, checkCurrentAlarms = false,  checkTamperAlarms = false,  checkMotorAlarms = false;
    if (EmbeddedParameters->n_generalparameters >= 4)
    {
        checkHardLimitAlarms = (EmbeddedParameters->generalparameters[0] < 0.5)?false:true;
        checkCurrentAlarms = (EmbeddedParameters->generalparameters[1] < 0.5)?false:true;
        checkTamperAlarms = (EmbeddedParameters->generalparameters[2] < 0.5)?false:true;
        checkMotorAlarms = (EmbeddedParameters->generalparameters[3] < 0.5)?false:true;
        AlarmHandlingSetFlags(checkHardLimitAlarms,checkCurrentAlarms,checkTamperAlarms,checkMotorAlarms);
        AlarmHandlingSetCurrentLimits(EmbeddedParameters->currentalarmhighlimit,EmbeddedParameters->currentalarmlowlimit);
    }
    if (EmbeddedParameters->n_generalparameters >= 5)
        SetWinderBackToBaseTime((uint32_t) EmbeddedParameters->generalparameters[4]);
    if (EmbeddedParameters->n_generalparameters >= 7)
    {
        if(EmbeddedParameters->generalparameters[6]<0.5)  SetDiagnosticMode(Diagnostic_Minimal_Mode);
        else if(EmbeddedParameters->generalparameters[6]<1.5)  SetDiagnosticMode(Diagnostic_Normal_Mode);
        else if(EmbeddedParameters->generalparameters[6]<2.5)  SetDiagnosticMode(Diagnostic_Extended_Mode);
        else if(EmbeddedParameters->generalparameters[6]<3.5)  SetDiagnosticMode(Diagnostic_Extreme_Mode);
    }
    if (EmbeddedParameters->n_generalparameters >= 8)
    {
        if (EmbeddedParameters->generalparameters[7]< 0.5) IDS_Dispenser_SetAutoHoming_Config(AutoHoming_off);
        else if (EmbeddedParameters->generalparameters[7]< 1.5) IDS_Dispenser_SetAutoHoming_Config(AutoHoming_PowerOff);
        else if (EmbeddedParameters->generalparameters[7]< 2.5) IDS_Dispenser_SetAutoHoming_Config(AutoHoming_PowerOn_off);
        else if (EmbeddedParameters->generalparameters[7]< 3.5) IDS_Dispenser_SetAutoHoming_Config(AutoHoming_JobEnd_PowerOn_off);
        else         Report("SetAutoHoming_Config error", __FILE__,__LINE__,(int)(EmbeddedParameters->generalparameters[7]*100), RpMessage, 0, 0);
    }
    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 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)
    {
        //for (Motor_i = 0; Motor_i < request->n_motors ; Motor_i++)
        status += MotorsConfigMessage(request);
    }
    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(NULL, GenHWInitCallBackFunction, 2* eOneSecond, TemplateDataReadCBFunction,0,0, 0 );
*/
    ControlStart();
    AlarmHandlingStart();
    //ThreadInitialTestStub(request);
    GeneralHwReady = true;
    STATUS_RED_LED_OFF;
    return OK;
}
char Serial[21];
MidTankData MidTankInfo[MAX_SYSTEM_DISPENSERS];

uint32_t MachineCalibrationDataRequestFunc(MessageContainer* requestContainer)
{
    MessageContainer responseContainer;
    MachineCalibrationDataRequest *request = machine_calibration_data_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
    uint32_t *DancersData = my_malloc(MAX_SYSTEM_DANCERS*sizeof(uint32_t));
    MidTankData ** MidTankDataCollect = my_malloc(sizeof(MidTankData *)*MAX_SYSTEM_DISPENSERS);

    int i;
    for (i = 0;i<MAX_SYSTEM_DANCERS;i++)
        DancersData[i] = DancersCfg[i].zeropoint;
    for (i = 0;i<MAX_SYSTEM_DISPENSERS;i++)
    {
        MidTankDataCollect[i] = &MidTankInfo[i];
        mid_tank_data__init(&MidTankInfo[i]);
        MidTankInfo[i].has_midtankid = true;
        MidTankInfo[i].midtankid = i;
        MidTankInfo[i].has_initialoffseta = true;
        MidTankInfo[i].initialoffseta = MCU_E2PromReadMidtank_A(i);
        MidTankInfo[i].has_slopeb = true;
        MidTankInfo[i].slopeb = MCU_E2PromReadMidtank_B(i);
    }
    memset (Serial,0,20);
    MCU_E2PromSerialNumRead(&Serial);

    MachineCalibrationDataResponse response = MACHINE_CALIBRATION_DATA_RESPONSE__INIT;
    machine_calibration_data__init(&response.machinecalibrationdata);
    response.machinecalibrationdata->n_dancermiddlepoint = MAX_SYSTEM_DANCERS;
    response.machinecalibrationdata->dancermiddlepoint = DancersData;
    response.machinecalibrationdata->machineserialnumber = Serial;
    response.machinecalibrationdata->midtankinfo = &MidTankDataCollect[0];
    response.machinecalibrationdata->n_midtankinfo = MAX_SYSTEM_DISPENSERS;
    response.machinecalibrationdata->macaddress = NULL;


    responseContainer = createContainer(MESSAGE_TYPE__MachineCalibrationDataResponse, requestContainer->token, true, &response, &machine_calibration_data_response__pack, &machine_calibration_data_response__get_packed_size);
    //-------------------------------------------------------------------------------------------
    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);
    SendChars((char*)container_buffer, container_size);

    my_free(DancersData);
    my_free(MidTankDataCollect);

    return OK;

}
uint32_t MidTankDataSetupFunc(MessageContainer* requestContainer)
{
    MessageContainer responseContainer;
    MidTankDataSetupRequest *request = mid_tank_data_setup_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
    int i;
    for (i = 0;i<request->n_midtankinfo;i++)
    {
        Report("MidTankDataSetupFunc", __FILE__,request->midtankinfo[i]->midtankid,(int)(request->midtankinfo[i]->initialoffseta*1000), RpMessage, (int)(request->midtankinfo[i]->slopeb*1000), 0);
        MCU_E2PromProgramMidTank(request->midtankinfo[i]->midtankid,request->midtankinfo[i]->initialoffseta,request->midtankinfo[i]->slopeb);
    }
    //debug only
    Task_sleep(1000);
    for (i = 0;i<8;i++)
    {
        float a=0,b=0;
        a = MCU_E2PromReadMidtank_A(i);
        b = MCU_E2PromReadMidtank_B(i);
        Report("MidTankData Read", __FILE__,__LINE__,(int)(a*1000), RpMessage, (int)(b*1000), 0);
    }
    //debug only
    Task_sleep(1000);
    MCU_E2PromSerialNumProgram ("Take me to the sky");
    memset (Serial,0,20);
    MCU_E2PromSerialNumRead(&Serial);
    Report(Serial, __FILE__,__LINE__,22, RpMessage, 21, 0);


    MidTankDataSetupResponse response = MID_TANK_DATA_SETUP_RESPONSE__INIT;

    responseContainer = createContainer(MESSAGE_TYPE__MidTankDataSetupResponse, requestContainer->token, true, &response, &mid_tank_data_setup_response__pack, &mid_tank_data_setup_response__get_packed_size);
    //-------------------------------------------------------------------------------------------
    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);
    SendChars((char*)container_buffer, container_size);

    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, DataLen, requestContainer->data.data);

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

    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};
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);
        EraseFlashSection(EMBEDDED_PARAMETERS_MAP_IN_FLASH,Bytes+4);
        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;
    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 = 0xFFFFFFFFU;
        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);
        //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);
        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);
    }

    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

}