/************************************************************************************************************************ * 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 "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 #include "drivers/FPGA/Full_Vme/FPGA_Programming_Up.h" #include #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" #include "Modules/Waste/Waste_ex.h" #include "Drivers/I2C_Communication/Main_Board_EEPROM/Main_EEPROM.h" #include #include #include "drivers/Uart_Comm/WHS_Controller_Comm/WHS_UART/WHS_Uart.h" #include "Modules/heaters/heaters_ex.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; HardwareBlower HeadBlowerCfg[2]; 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); 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); //AlarmHandlingLoadFile(); } 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 if (Head_Type > HEAD_TYPE_FLAT_WITHOUT_CARD) { //Activation the heaters latch + sensors card Trigger_OutputsLatchWriting();//need to be done ~ at least 100uSec after Trigger_Head_io_Init if (Head_Type == HEAD_TYPE_ARC) { Trigger_Head_Config_Fans();//Initialization } } //EmbeddedParametersInit(); IDS_Dispenser_Content_Init(); //ProcessParamsInit(); Buttons_Init(); #ifndef DISPESER_TEST if (WHS_Type == WHS_TYPE_NEW) newWHS_init(); //WHS_init(); // remove call to old WHS #endif // Waste Init (WHS) Waste_Init(); 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_initialdispenserpressure = true; EmbeddedParameters->initialdispenserpressure=3.85; EmbeddedParameters->has_initialdispensertimeout = true; EmbeddedParameters->initialdispensertimeout=119999.0 ; EmbeddedParameters->has_initialdispensertimelag = true; EmbeddedParameters->initialdispensertimelag=100.0 ; EmbeddedParameters->has_dispenserbuildpressurespeed = true; EmbeddedParameters->dispenserbuildpressurespeed=500; EmbeddedParameters->has_dispenserbuildpressurelimit = true; EmbeddedParameters->dispenserbuildpressurelimit=1.0 ; EmbeddedParameters->has_dispenserbuildpressuretimeout = true; EmbeddedParameters->dispenserbuildpressuretimeout=419999.0; 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 = 13; EmbeddedParameters->generalparameters = malloc (sizeof(double)*14); 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->generalparameters[8] = false; //PowerOffDisableCleaning EmbeddedParameters->generalparameters[9] = 30; // sublimation EmbeddedParameters->generalparameters[10] = 0.07; // AllowedRangeForHeadBlowerDeviation; EmbeddedParameters->generalparameters[11] = 0.2; // AllowedRangeForWasteBlowerDeviation = WasteLimit; EmbeddedParameters->generalparameters[12] = 4; // Voltage hysteresis (bug #2970) } 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; EmbeddedParameters->description = "default embedded parameters"; uint8_t* response_buffer = my_malloc(configuration_parameters__get_packed_size(EmbeddedParameters)); 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; if (EmbeddedParameters->description) Report(EmbeddedParameters->description, __FILE__,__LINE__,112233, RpMessage, 445566, 0); } } uint32_t EmbeddedParametersInit(void) { FRESULT Fresult = FR_OK; uint32_t Bytes = 0; uint8_t* buffer = NULL; bool success=false; ConfigurationParameters *Params; // try loading from flash 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); success = true; } } if (success == false) { if (LoadConfigurationParamsFromFile(false)==OK) { success = true; Report("LoadConfigurationParameters from file", __FILE__,__LINE__,EmbeddedParameters->closevalvetimeout, RpMessage, Fresult, 0); } } if (success == false) { LoadConfigurationParameters(0); Report("LoadConfigurationParameters default. flash and file error!!!", __FILE__,__LINE__,0, RpMessage, Fresult, 0); AlarmHandlingSetAlarm (EVENT_TYPE__POWER_UP_BIT_FAILURE,ON); } 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); } if (EmbeddedParameters->n_generalparameters >= 9) { if (EmbeddedParameters->generalparameters[8]< 0.5) setPowerOffDisableCleaning(false); else setPowerOffDisableCleaning(true); } if (EmbeddedParameters->n_generalparameters >= 10) { setSublimationBlowTime(EmbeddedParameters->generalparameters[9]); } if (EmbeddedParameters->n_generalparameters >= 12) { setWastePrepareValues(EmbeddedParameters->generalparameters[10],EmbeddedParameters->generalparameters[11]); } if (EmbeddedParameters->n_generalparameters >= 13) { Set_Voltage_Hysteresis (EmbeddedParameters->generalparameters[12]); } if (EmbeddedParameters->n_generalparameters >= 15) { Set_Head_Blowers_Parameters(EmbeddedParameters->generalparameters[13],EmbeddedParameters->generalparameters[14]); } 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 > REPEATED_INIT_FAILURE_LIMIT) { 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; } else { if (InitFailures > 2) { Report("HWConfigurationInit repeated failure going up",__FILE__,__LINE__,(int)InitFailures,RpWarning,(int)EEPROM_INIT_FAILURE_COUNTER,0); } }*/ HardwareConfiguration *request = UploadRequest->hardwareconfiguration; if (JobIsActive()) { LOG_ERROR(1,"JobIsActive"); return ERROR; } if (FPGABurningActive == true) { LOG_ERROR(1,"FPGABurningActive"); 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); MotorConfiguredTimeout = 100; 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 if (request->pidcontrols[PID_i]->hardwarepidcontroltype == HARDWARE_PID_CONTROL_TYPE__HeadBlower_1) HeadBlowerPidRequestMessage(request->pidcontrols[PID_i], HEAD_FAN_RIGHT); else if (request->pidcontrols[PID_i]->hardwarepidcontroltype == HARDWARE_PID_CONTROL_TYPE__HeadBlower_2) HeadBlowerPidRequestMessage(request->pidcontrols[PID_i], HEAD_FAN_LEFT); } } 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; } Trigger_Dispenser_ReadData(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; } if((request->blowers[Dispenser_i]->enabled)&&(request->blowers[Dispenser_i]->hardwareblowertype == HARDWARE_BLOWER_TYPE__HeadBlower1)) { HeadBlowerCfg[0].enabled = true; HeadBlowerCfg[0].voltage = request->blowers[Dispenser_i]->voltage; HeadBlowerCfg[0].heatingvoltage = request->blowers[Dispenser_i]->heatingvoltage; } if((request->blowers[Dispenser_i]->enabled)&&(request->blowers[Dispenser_i]->hardwareblowertype == HARDWARE_BLOWER_TYPE__HeadBlower2)) { HeadBlowerCfg[1].enabled = true; HeadBlowerCfg[1].voltage = request->blowers[Dispenser_i]->voltage; HeadBlowerCfg[1].heatingvoltage = request->blowers[Dispenser_i]->heatingvoltage; } } } ControlStart(); AlarmHandlingStart(); GeneralHwReady = true; STATUS_RED_LED_OFF; return OK; } char Serial[21]; 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); MidTankData MidTankInfo[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); 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; 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); AlarmHandlingLoadFile(); FileWrite(requestContainer->data.data, requestContainer->data.len,HwConfigPath,BIOS_WAIT_FOREVER); }*/ UploadRequest = upload_hardware_configuration_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data); if (UploadRequest) { FileWrite(requestContainer->data.data, requestContainer->data.len,HwConfigPath,BIOS_WAIT_FOREVER); Report("store hw configuration", __FILE__,__LINE__,requestContainer->data.len,RpMessage,UploadRequest->hardwareconfiguration->n_motors,0); 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(); 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; UploadHardwareConfigurationRequest* UploadRequest = NULL; buffer = HWConfigurationLoadFromFile(&Bytes); //load hardware config if (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); } 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(0); StoreDancerConfigMessage(1); StoreDancerConfigMessage(2); 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(); 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); Report("Parameters Initialized from file", __FILE__,__LINE__,sizeof(EmbeddedParameters), RpMessage, EMBEDDED_PARAMETERS_MAP_IN_FLASH, 0); } else { LoadConfigurationParameters(0); Report("Parameters Initialized from default", __FILE__,__LINE__,sizeof(EmbeddedParameters), RpMessage, EMBEDDED_PARAMETERS_MAP_IN_FLASH, 0); } #ifdef WATCHDOG ROM_WatchdogResetEnable(WATCHDOG0_BASE); timeout = 120000000*3; ROM_WatchdogReloadSet(WATCHDOG0_BASE, timeout); #endif }