Software/Visual_Studio/PPC/Tango.PPC.Publisher/App.xaml


1
2
3
4
5
6
7
8
9

/************************************************************************************************************************
 * 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 "drivers/Flash_ram/FlashProgram.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/I2C_Communication/I2C.h"
#include "drivers/Flash_ram/MCU_E2Prom.h"
#include <Drivers/I2C_Communication/WHS_Card/D_Max5805_ADC_Blower/WHS_Blower.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"
#include "Modules/Waste/Waste.h"
#include "Drivers/I2C_Communication/Main_Board_EEPROM/Main_EEPROM.h"
#include <Modules/Waste/newWHS_init.h>
#include <Drivers/I2C_Communication/I2C_Task.h>

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

bool GeneralHwReady = false;

bool PP_Machine = false;

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

char HwConfigPath[50] = "0://SysInfo//GenHwCfg.cfg";
bool Is_PP_Machine(void)
{
    return PP_Machine;
}
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 < 5000))
    {
        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);
        }
    }
    if (UploadRequest == NULL)
    {
        buffer = HWConfigurationLoadFromFile(&Bytes); //load hardware config
        if (buffer)
        {
           EraseFlashSection(GENHWCFG_SECTION_FLASH);
           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)
    {
        AlarmHandlingSetAlarm (EVENT_TYPE__MACHINE_STATE_NO_CFG_FILE,OFF);
        status = HWConfiguration(UploadRequest);
        if (status !=OK)
        {
            AlarmHandlingSetAlarm (EVENT_TYPE__MACHINE_STATE_NO_CFG_FILE,ON);
            status = MACHINE_STATE_HW_CONFIG_FAILED;
            STATUS_GREEN_LED_OFF;
        }
        else
        {
            STATUS_RED_LED_OFF;
            ACTIVITY_GREEN_LED_OFF;
        }
        upload_hardware_configuration_request__free_unpacked(UploadRequest,NULL);
    }
    else
    {
        AlarmHandlingSetAlarm (EVENT_TYPE__MACHINE_STATE_NO_CFG_FILE,ON);
        status = MACHINE_STATE_NO_CFG_FILE;

    }
    if (buffer)
        free (buffer);

    Trigger_Head_Init_PT100();//OK
    //EmbeddedParametersInit();
    IDS_Dispenser_Content_Init();
    //ProcessParamsInit();
    Buttons_Init();
#ifndef DISPESER_TEST
    if (WHS_Type == WHS_TYPE_NEW)
        newWHS_init();
    WHS_init();
#endif
    ADC_MUX_Init();
    GeneralHwReady = true;

    //I2C_NFC_Test();
    //RFID_Test();

    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->has_breaksensorlimit = true;
            EmbeddedParameters->breaksensorlimit = 10;

            EmbeddedParameters->has_closevalvetimeout = true;
            EmbeddedParameters->closevalvetimeout = 52;
            EmbeddedParameters->has_openvalvetimeout = true;
            EmbeddedParameters->openvalvetimeout = 52;

            EmbeddedParameters->has_dispenserbuildpressurespeed = true;
            EmbeddedParameters->dispenserbuildpressurespeed=500;
            EmbeddedParameters->has_dispenserbuildpressurelimit = true;
            EmbeddedParameters->dispenserbuildpressurelimit=1.0 ;
            EmbeddedParameters->has_dispenserbuildpressuretimeout = true;
            EmbeddedParameters->dispenserbuildpressuretimeout=150000;
            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_dispenserpresegmentwfcf = true;
            EmbeddedParameters->dispenserpresegmentwfcf = 40;

            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_Extended_Mode; //Diagnostic Mode SetDiagnosticMode
                EmbeddedParameters->generalparameters[7] = AutoHoming_JobEnd_PowerOn_off; //
            }

            EmbeddedParameters->has_currentalarmlowlimit = true;
            EmbeddedParameters->currentalarmlowlimit = 0.78;
            EmbeddedParameters->has_currentalarmhighlimit = true;
            EmbeddedParameters->currentalarmhighlimit= 1.07;

            EmbeddedParameters->has_ids_presegmentbuilduptime = true;
            EmbeddedParameters->ids_presegmentbuilduptime = 5000;
            EmbeddedParameters->has_ids_cleaningspeed = true;
            EmbeddedParameters->ids_cleaningspeed = 800;
            EmbeddedParameters->has_ids_cleaningstopbeforesegmenttime = true;
            EmbeddedParameters->ids_cleaningstopbeforesegmenttime = 10000;
            EmbeddedParameters->has_ids_cleaningstartspraypresegmenttime = true;
            EmbeddedParameters->ids_cleaningstartspraypresegmenttime = 2000;
            EmbeddedParameters->has_ids_leftcleaningmotorspeed = true;
            EmbeddedParameters->ids_leftcleaningmotorspeed = 52;
            EmbeddedParameters->has_ids_rightcleaningmotorspeed = true;
            EmbeddedParameters->ids_rightcleaningmotorspeed = 52;

            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 = 90;
            EmbeddedParameters->has_ids_presegment_wfcf_timebeforesegment = true;
            EmbeddedParameters->ids_presegment_wfcf_timebeforesegment = 20000;
            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_SECTION_FLASH);
                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;
    uint8_t* buffer = NULL;

    ConfigurationParameters *Params;

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

    if ((Bytes)&&(Bytes < 1000))
    {
        buffer = my_malloc (Bytes);
        if (buffer)
        {
            memcpy(buffer, (void *)(EMBEDDED_PARAMETERS_MAP_IN_FLASH+4),Bytes);

            Params = configuration_parameters__unpack(NULL, Bytes, buffer);
            LoadConfigurationParameters(Params);
            Report("LoadConfigurationParameters from flash", __FILE__,__LINE__,Bytes, RpMessage, Fresult, 0);
            free(buffer);
        }
        else
        {
            LoadConfigurationParameters(0);
            Report("LoadConfigurationParameters default", __FILE__,__LINE__,0, RpMessage, Fresult, 0);
        }
    }
    else
    {
        if (LoadConfigurationParamsFromFile(false)!=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,1000);
    }*/

    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,tempheaterId,DispenserId;
    HardwareBlowerType blowerType = HARDWARE_BLOWER_TYPE__DefaultBlower;

    if (UploadRequest == NULL)
    {
        LOG_ERROR (0, "Wrong Data Allocation");
        return ERROR;
    }
    if (InitFailures > 3)
    {
        Report("HWConfigurationInit repeated failure",__FILE__,__LINE__,(int)InitFailures,RpWarning,(int)EEPROM_INIT_FAILURE_COUNTER,0);
        AlarmHandlingSetAlarm (EVENT_TYPE__POWER_UP_BIT_FAILURE,ON);
        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__HeadBlower_2)
    {
        //IDS_DispenserControlInit();

        for (PID_i = 0; PID_i < request->n_pidcontrols ; PID_i++)
        {
            if (isHeater(request->pidcontrols[PID_i]->hardwarepidcontroltype))
            {
                status += HeaterConfigRequestMessage(request->pidcontrols[PID_i]);
                if ((request->pidcontrols[PID_i]->hardwarepidcontroltype>=HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1)&&
                        (request->pidcontrols[PID_i]->hardwarepidcontroltype<=HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6))
                {
                    tempheaterId = (request->pidcontrols[PID_i]->hardwarepidcontroltype-HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1+HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ7);
                    request->pidcontrols[PID_i]->hardwarepidcontroltype = tempheaterId;
                    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)&&
                (request->pidcontrols[PID_i]->hardwarepidcontroltype < HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ7))
                status += IDS_DispenserPidRequestMessage(request->pidcontrols[PID_i]);
            else if (request->pidcontrols[PID_i]->hardwarepidcontroltype == HARDWARE_PID_CONTROL_TYPE__WasteControl)
                WHS_PidRequestMessage(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++)
        {
            DispenserId = request->dispensers[Dispenser_i]->index;
            Valve_Set(IDS_Id_to_AirValve[DispenserId], Atm_MidTank_OFF );   //Atm_MidTank_OFF/ON
            Valve_Set(IDS_Id_to_CartrideValve[DispenserId], Atm_MidTank_OFF );   //Atm_MidTank_OFF/ON
            status += DispenserConfigMessage(request->dispensers[Dispenser_i]);
            if (Check_Dispenser_Type(DispenserId) == LS_STATUS_ERROR)
            {
                LOG_ERROR (DispenserId, "Dispenser identification failed");
                //return ERROR;
            }
            status |= Dispenser_EEPROM_Read_Data(DispenserId);
        }
        Calculateinit();
    }
    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]);
    }

    BlowerCfg.enabled = true;
    if (WHS_Type == WHS_TYPE_UNKNOWN)
    {
        blowerType = HARDWARE_BLOWER_TYPE__DefaultBlower;
        BlowerCfg.voltage = 3000;
        BlowerCfg.heatingvoltage = 2650;
    }
    else
    {
        blowerType = HARDWARE_BLOWER_TYPE__WHSBlower2;
        BlowerCfg.voltage = 2200;
        BlowerCfg.heatingvoltage = 2000;
    }
    if (request->n_blowers)
    {
        for (Dispenser_i = 0; Dispenser_i < request->n_blowers ; Dispenser_i++)
        {
            if (request->blowers[Dispenser_i]->hardwareblowertype == blowerType)
            {
                if(request->blowers[Dispenser_i]->enabled)
                {
                    BlowerCfg.enabled = true;
                    BlowerCfg.voltage = request->blowers[Dispenser_i]->voltage;
                    BlowerCfg.heatingvoltage = request->blowers[Dispenser_i]->heatingvoltage;
                }
                Report("blower config", __FILE__,Dispenser_i,(int)request->blowers[Dispenser_i]->hardwareblowertype, RpMessage, (int)request->blowers[Dispenser_i]->voltage, 0);

                break;
            }
            if((request->blowers[Dispenser_i]->enabled)&&(request->blowers[Dispenser_i]->hardwareblowertype == HARDWARE_BLOWER_TYPE__WHSSmallFans))
            {
                SmallFansCfg = request->blowers[Dispenser_i]->voltage;
            }
            if((request->blowers[Dispenser_i]->enabled)&&(request->blowers[Dispenser_i]->hardwareblowertype == HARDWARE_BLOWER_TYPE__WHSLargeFans))
            {
                LargeFansCfg = request->blowers[Dispenser_i]->voltage;
            }

        }
    }
    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);
    ADC_MUX_Init();
    for (i = 0;i<8;i++)
    {
        float a=0,b=0;
        a = Initial_Offset_A[i];
        b = Slope_B[i];
        Report("MidTankData Read", __FILE__,__LINE__,(int)(a*1000), RpMessage, (int)(b*1000), 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;
    uint32_t ExistingDataLen  = 0;
    int compare = 0;
    MessageContainer responseContainer;
    UploadHardwareConfigurationResponse response = UPLOAD_HARDWARE_CONFIGURATION_RESPONSE__INIT;
    UploadHardwareConfigurationRequest* UploadRequest = NULL;
    if (JobIsActive())
    {
        LOG_ERROR(1,"JobIsActive");
        status = ERROR;
    }
    else
    {
        GeneralHwReady = false;
        Control_WD(ENABLE,250);
        //compare existing data to new data. update if different
        memcpy(&ExistingDataLen,(void *)GENHWCFG_MAP_IN_FLASH,sizeof(ExistingDataLen));
        if (ExistingDataLen == requestContainer->data.len)
        {
            compare = memcmp (requestContainer->data.data,((void *)(GENHWCFG_MAP_IN_FLASH+4)),requestContainer->data.len);
            Report("!!!!!!!!!data compare hw func", __FILE__,compare,requestContainer->data.len,RpMessage,ExistingDataLen,0);
        }
        else
            compare = ExistingDataLen - requestContainer->data.len;
            //if compare is equal no need to store the data
        if (compare != 0)
        {
            DataLen = requestContainer->data.len;
            EraseFlashSection(GENHWCFG_SECTION_FLASH);
            ReadAppAndProgram(GENHWCFG_MAP_IN_FLASH, 4,&DataLen);
            ReadAppAndProgram(GENHWCFG_MAP_IN_FLASH+4, DataLen, requestContainer->data.data);
            Report("store hw configuration", __FILE__,compare,requestContainer->data.len,RpMessage,ExistingDataLen,0);

            FileWrite(requestContainer->data.data, requestContainer->data.len,HwConfigPath,BIOS_WAIT_FOREVER);
        }
        UploadRequest = upload_hardware_configuration_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);


        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.has_error = true;
        responseContainer.error = ERROR_CODE__INVALID_PARAMETER;
        responseContainer.errormessage = "JOb Active or incorrect parameters";
    }
    else
    {
        AlarmHandlingSetAlarm (EVENT_TYPE__MACHINE_STATE_NO_CFG_FILE,OFF);
    }
    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);
    if (UploadRequest)
        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);
    Report("HWSystemResetRequest before sleep", __FILE__,__LINE__,0, RpMessage, 2, 0);

    //ROM_SysCtlDelay(SYS_CLK_FREQ);
    Task_sleep(2000);
    Report("HWSystemResetRequest after sleep", __FILE__,__LINE__,2, RpMessage, 4, 0);

    //ROM_SysCtlDelay(SYS_CLK_FREQ);
    Task_sleep(2000);

    SysCtlReset();

    HWREG(NVIC_APINT) = NVIC_APINT_VECTKEY |  NVIC_APINT_SYSRESETREQ;

}
uint32_t FlashInitResults[5] = {0,0,0,0,0};
uint32_t LoadConfigurationParamsFromFile(bool Initialize)
{
    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_SECTION_FLASH);
        ReadAppAndProgram(EMBEDDED_PARAMETERS_MAP_IN_FLASH, 4,&Bytes);
        ReadAppAndProgram(EMBEDDED_PARAMETERS_MAP_IN_FLASH+4, Bytes, buffer);
        if (Initialize)
            EmbeddedParametersInit();
    }
    return Fresult;
}
void HWConfigurationLoadFile(void)
{
    uint8_t* buffer = NULL;
    uint32_t Bytes = 0;
    buffer = HWConfigurationLoadFromFile(&Bytes); //load hardware config
    if (buffer)
    {
       EraseFlashSection(GENHWCFG_SECTION_FLASH);
       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);
}
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)
    {
        EraseFlashSection(GENHWCFG_SECTION_FLASH);
        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);
    }*/
    EraseFlashSection(EMBEDDED_PARAMETERS_SECTION_FLASH);

    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);
        if (request)
        {
            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

}