/************************************************************************************************************************ * control.c * Control module * ************************************************************************************************************************/ #include #include #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 #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; ACTIVITY_GREEN_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 = 52; EmbeddedParameters->has_openvalvetimeout = true; EmbeddedParameters->openvalvetimeout = 52; EmbeddedParameters->has_initialdispenserpressure = true; EmbeddedParameters->initialdispenserpressure = 0.25; 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=1.0 ; 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_Extended_Mode; //Diagnostic Mode SetDiagnosticMode EmbeddedParameters->generalparameters[7] = AutoHoming_PowerOn_off; // } EmbeddedParameters->has_currentalarmlowlimit = true; EmbeddedParameters->currentalarmlowlimit = 0.78; 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 = 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 = 50; 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_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;in_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;in_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 }