/* * process.c * * Created on: 4 במרץ 2018 * Author: shlomo */ //******************************************************************************************************************** #include #include "include.h" #include "process.h" #include "heaters/heaters_ex.h" #include "PMR/Printing/ProcessParameters.pb-c.h" #include "PMR/Printing/UploadProcessParametersRequest.pb-c.h" #include "PMR/Printing/UploadProcessParametersResponse.pb-c.h" #include "PMR/Hardware/HardwarePidControlType.pb-c.h" #include "PMR/common/MessageContainer.pb-c.h" #include "drivers/Valves/Valve.h" #include "drivers/I2C_Communication/ADC_MUX/ADC_MUX.h" #include "modules/ids/ids_ex.h" #include "Common/SWUpdate/FileSystem.h" #include "StateMachines/Initialization/PowerIdle.h" #include "StateMachines/Initialization/InitSequence.h" #include "drivers/Flash_ram/FlashProgram.h" #include #include "drivers/Flash_ram/MCU_E2Prom.h" #include double dyeingspeed = 0; double dryerbufferlength = 0; double mininkuptake = 0; double feedertension = 0; double pullertension = 0; double windertension = 0; double headairflow = 5.0; double dryerairflow = 5.0; double pressurebuildup = 0; double dryerzone1temp = 0; int32_t tableindex = 0; double headBlowersFlow[2] = {1.5,1.5}; double dryerbufferMeters = 0; double dryerbufferCentimeters = 0; #define MAX_ALLOWED_TEMPERATURE 280 int MaxAllowedTemperature = MAX_ALLOWED_TEMPERATURE; char ProcessParamsConfigPath[50] = "0://SysInfo//ProcessP.cfg"; bool MachineReadyForHeating = false; void SetMachineReadyForHeating(bool value) { MachineReadyForHeating = value; } ProcessParameters ProcessParametersKeep; void HeatersStopControlOnHeatersOff(ProcessParameters* ProcessParams) { uint32_t temp_sum = 0; temp_sum += ProcessParams->dryerzone1temp; temp_sum += ProcessParams->dryerzone2temp; temp_sum += ProcessParams->dryerzone3temp; temp_sum += ProcessParams->mixertemp; temp_sum += ProcessParams->headzone1temp; temp_sum += ProcessParams->headzone2temp; temp_sum += ProcessParams->headzone3temp; temp_sum += ProcessParams->headzone4temp; temp_sum += ProcessParams->headzone5temp; temp_sum += ProcessParams->headzone6temp; temp_sum += ProcessParams->headzone7temp; temp_sum += ProcessParams->headzone8temp; temp_sum += ProcessParams->headzone9temp; temp_sum += ProcessParams->headzone10temp; temp_sum += ProcessParams->headzone11temp; temp_sum += ProcessParams->headzone12temp; if (temp_sum == 0)// heating off { HeatersControlStop(); REPORT_MSG(temp_sum,"Heating control off - temperatures off"); } else { HeatersControlStart(); } } char ProcessErrorMsg[50]; uint32_t HandleProcessParameters(ProcessParameters* ProcessParams,bool saveData) { uint32_t status = 0,Bytes = 0; if (ProcessParams==NULL) { status = ERROR_CODE__INVALID_PARAMETER; ReportWithPackageFilter(InitFilter,"HandleProcessParameters NULL",__FILE__,(int)__LINE__,(int)0,RpWarning,(int)0,0); usnprintf(ProcessErrorMsg, 50, "ProcessParameters NULL"); return status; } if (ProcessParams->dryerzone1temp > MaxAllowedTemperature) status = ERROR_CODE__INVALID_PARAMETER; if (ProcessParams->dryerzone2temp > MaxAllowedTemperature) status = ERROR_CODE__INVALID_PARAMETER; if (ProcessParams->dryerzone3temp > MaxAllowedTemperature) status = ERROR_CODE__INVALID_PARAMETER; if (ProcessParams->mixertemp > MaxAllowedTemperature) status = ERROR_CODE__INVALID_PARAMETER; if (ProcessParams->headzone1temp > MaxAllowedTemperature) status = ERROR_CODE__INVALID_PARAMETER; if (ProcessParams->headzone2temp > MaxAllowedTemperature) status = ERROR_CODE__INVALID_PARAMETER; if (ProcessParams->headzone3temp > MaxAllowedTemperature) status = ERROR_CODE__INVALID_PARAMETER; if (ProcessParams->headzone4temp > MaxAllowedTemperature) status = ERROR_CODE__INVALID_PARAMETER; if (ProcessParams->headzone5temp > MaxAllowedTemperature) status = ERROR_CODE__INVALID_PARAMETER; if (ProcessParams->headzone6temp > MaxAllowedTemperature) status = ERROR_CODE__INVALID_PARAMETER; if (status != 0) { status = ERROR_CODE__INVALID_PARAMETER; ReportWithPackageFilter(InitFilter,"HandleProcessParameters Temperature too high",__FILE__,(int)__LINE__,(int)status,RpWarning,(int)0,0); usnprintf(ProcessErrorMsg, 50, "ProcessParameters Temperature too high"); return status; } if (ProcessParams) { memcpy (&ProcessParametersKeep,ProcessParams,sizeof(ProcessParameters)); } if (saveData == true) { if ((ProcessParams->dryerzone1temp > 0.1)||(ProcessParams->headzone2temp > 0.1)||(ProcessParams->headzone3temp > 0.1)||(ProcessParams->headzone1temp > 0.1))//NOT turning off heaters { Bytes = sizeof(ProcessParameters); FileWrite(ProcessParams,Bytes,ProcessParamsConfigPath,BIOS_WAIT_FOREVER); MCU_E2PromProgramChunk(PROCESS_PARAMATERS_IN_EEPROM,4,&Bytes); MCU_E2PromProgramChunk(PROCESS_PARAMATERS_IN_EEPROM+4, Bytes, ProcessParams); /*EraseFlashSection(PROCESS_PARAMETERS_MAP_IN_FLASH); ReadAppAndProgram(PROCESS_PARAMETERS_MAP_IN_FLASH, 4,&Bytes); ReadAppAndProgram(PROCESS_PARAMETERS_MAP_IN_FLASH+4, Bytes, ProcessParams);*/ REPORT_MSG(Bytes,"Bytes write to flash"); } else { if (ProcessParams->has_headairflow == false) ProcessParams->headairflow = headairflow; if (ProcessParams->has_lblowerflow == false) ProcessParams->lblowerflow = headBlowersFlow[HEAD_FAN_LEFT]; if (ProcessParams->has_rblowerflow == false) ProcessParams->rblowerflow = headBlowersFlow[HEAD_FAN_RIGHT]; if (ProcessParams->has_feedertension == false) ProcessParams->feedertension = feedertension; if (ProcessParams->has_windertension == false) ProcessParams->windertension = windertension; if (ProcessParams->has_pullertension == false) ProcessParams->pullertension = pullertension; ReportWithPackageFilter(InitFilter,"HandleProcessParameters temp off blower on",__FILE__,(int)__LINE__,(int)ProcessParams->headairflow,RpWarning,(int)ProcessParametersKeep.headairflow,0); } } HeatersStopControlOnHeatersOff(ProcessParams); dyeingspeed = ProcessParams->dyeingspeed; dryerbufferlength = ProcessParams->dryerbufferlength; dryerbufferMeters = dryerbufferlength*0.76+0.9; dryerbufferCentimeters = dryerbufferlength*76+90; mininkuptake = ProcessParams->mininkuptake; feedertension = ProcessParams->feedertension; pullertension = ProcessParams->pullertension; windertension = ProcessParams->windertension; headairflow = ProcessParams->headairflow; dryerairflow = ProcessParams->dryerairflow; pressurebuildup = ProcessParams->pressurebuildup; dryerzone1temp = ProcessParams->dryerzone1temp; if (MachineReadyForHeating == false) { ReportWithPackageFilter(InitFilter,"HandleProcessParameters Init not ready",__FILE__,(int)__LINE__,(int)status,RpWarning,(int)GetMachineState(),0); status = ERROR_CODE__GENERAL_ERROR; usnprintf(ProcessErrorMsg, 50, "ProcessParameters Init not ready"); return status; } //Report("drier buffer length",__FILE__,(int)dryerbufferlength,(int)dryerbufferMeters*100,RpWarning,(int)dryerbufferCentimeters,0); ReportWithPackageFilter(InitFilter,"HandleProcessParameters Head type",__FILE__,(int)headairflow,(int)Head_Type,RpWarning,(int)dryerbufferCentimeters,0); WHS_Set_SetPoint_Q_value(headairflow); if (ProcessParams->mixertemp>1) status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__MixerHeater, true,ProcessParams->mixertemp); else status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__MixerHeater, false,ProcessParams->mixertemp); if (ProcessParams->headzone1temp>1) { status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1, true,ProcessParams->headzone1temp); } else { status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1, false,ProcessParams->headzone1temp); } if (ProcessParams->headzone2temp>1) { status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2, true,ProcessParams->headzone2temp); } else { status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2, false,ProcessParams->headzone2temp); } if (ProcessParams->headzone3temp>1) { status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3, true,ProcessParams->headzone3temp); } else { status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3, false,ProcessParams->headzone3temp); } if(Head_Type != HEAD_TYPE_ARC) { Trigger_HeaterWriting(); if (ProcessParams->headzone4temp>1) { status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4, true,ProcessParams->headzone4temp); } else { status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4, false,ProcessParams->headzone4temp); } if (ProcessParams->headzone5temp>1) { status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5, true,ProcessParams->headzone5temp); } else { status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5, false,ProcessParams->headzone5temp); } if (ProcessParams->headzone6temp>1) { status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6, true,ProcessParams->headzone6temp); } else { status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6, false,ProcessParams->headzone6temp); } } if (ProcessParams->dryerzone1temp>1) status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature, true,ProcessParams->dryerzone1temp); else status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature, false,ProcessParams->dryerzone1temp); if(Head_Type == HEAD_TYPE_FLAT) { if (ProcessParams->headzone7temp>1) { status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ7, true,ProcessParams->headzone7temp); } else { status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ7, false,ProcessParams->headzone7temp); } Trigger_HeaterWriting(); if (ProcessParams->headzone8temp>1) { status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ8, true,ProcessParams->headzone8temp); } else { status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ8, false,ProcessParams->headzone8temp); } if (ProcessParams->headzone9temp>1) { status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ9, true,ProcessParams->headzone9temp); } else { status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ9, false,ProcessParams->headzone9temp); } if (ProcessParams->headzone10temp>1) { status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ10, true,ProcessParams->headzone10temp); } else { status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ10, false,ProcessParams->headzone10temp); } Trigger_HeaterWriting(); if (ProcessParams->headzone11temp>1) { status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ11, true,ProcessParams->headzone11temp); } else { status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ11, false,ProcessParams->headzone11temp); } if (ProcessParams->headzone12temp>1) { status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ12, true,ProcessParams->headzone12temp); } else { status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ12, false,ProcessParams->headzone12temp); } } if(Head_Type == HEAD_TYPE_ARC) { Trigger_HeaterWriting(); if (ProcessParams->rblowertemp>1) { status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadCoverHeater1, true,ProcessParams->rblowertemp); } else { status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadCoverHeater1, false,ProcessParams->rblowertemp); } Trigger_HeaterWriting(); if (ProcessParams->lblowertemp>1) { status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadCoverHeater2, true,ProcessParams->lblowertemp); } else { status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadCoverHeater2, false,ProcessParams->lblowertemp); } status |= HeadBlowerCommandRequestMessage(HEAD_FAN_RIGHT, ProcessParams->rblowerflow); status |= HeadBlowerCommandRequestMessage(HEAD_FAN_LEFT, ProcessParams->lblowerflow); Trigger_HeaterWriting(); } if (status) { ReportWithPackageFilter(InitFilter,"HandleProcessParameters start heaters error",__FILE__,(int)__LINE__,(int)status,RpWarning,(int)GetMachineState(),0); status = ERROR_CODE__JOB_TEMPERATURE_ALARM; usnprintf(ProcessErrorMsg, 50, "ProcessParameters start heaters error"); } return status;//status; } void ProcessRequestFunc(MessageContainer* requestContainer) { MessageContainer responseContainer; uint8_t* container_buffer; uint32_t status = 0; UploadProcessParametersRequest* request = upload_process_parameters_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data); ProcessParameters* ProcessParams = request->processparameters; //////////////////////////////////////////////////////////////////////// /*UploadProcessParametersRequest* requesttest; uint8_t* buffer = NULL; uint32_t Bytes = 0; ProcessParameters* ProcessParamsTest; FileRead(ProcessParamsConfigPath, &Bytes, &buffer); requesttest = upload_process_parameters_request__unpack(NULL, Bytes, buffer); // ProcessParameters* ProcessParams = process_parameters__unpack(NULL, Bytes, buffer); if (requesttest) { ProcessParamsTest = request->processparameters; } free (buffer); upload_process_parameters_request__free_unpacked(requesttest,NULL); */ ///////////////////////////////////////////////////////// UploadProcessParametersResponse response = UPLOAD_PROCESS_PARAMETERS_RESPONSE__INIT; responseContainer = createContainer(MESSAGE_TYPE__UploadProcessParametersResponse, requestContainer->token, true, &response, &upload_process_parameters_response__pack, &upload_process_parameters_response__get_packed_size); //REPORT_MSG (ProcessParams->dryerzone1temp,"Process Params Dryer"); PowerIdleOutOfIdleState(); if (status == 0) status = HandleProcessParameters(ProcessParams,true); if ((status)&&(status != ERROR_CODE__GENERAL_ERROR)) //ignore init not ready result { responseContainer.has_error = true; responseContainer.error = (ErrorCode)status; responseContainer.errormessage = ProcessErrorMsg; } 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(container_buffer, container_size); upload_process_parameters_request__free_unpacked(request,NULL); } uint32_t LoadProcessParamsFromFile(void) { FRESULT Fresult = FR_OK; uint8_t* buffer = NULL; uint32_t Bytes = 0; Fresult = FileRead(ProcessParamsConfigPath, &Bytes, &buffer); if (Fresult == FR_OK) { ProcessParameters* ProcessParams = (ProcessParameters*)buffer; if (ProcessParams!=NULL) { if ((ProcessParams->dryerzone1temp > 0.1)||(ProcessParams->headzone2temp > 0.1)||(ProcessParams->headzone3temp > 0.1)||(ProcessParams->headzone4temp > 0.1))//NOT turning off heaters { Bytes = sizeof(ProcessParameters); MCU_E2PromProgramChunk(PROCESS_PARAMATERS_IN_EEPROM,4,&Bytes); MCU_E2PromProgramChunk(PROCESS_PARAMATERS_IN_EEPROM+4, Bytes, ProcessParams); /*EraseFlashSection(PROCESS_PARAMETERS_MAP_IN_FLASH); ReadAppAndProgram(PROCESS_PARAMETERS_MAP_IN_FLASH, 4,&Bytes); ReadAppAndProgram(PROCESS_PARAMETERS_MAP_IN_FLASH+4, Bytes, ProcessParams);*/ REPORT_MSG(Bytes,"ProcessParameters Bytes write to flash"); free (buffer); } } else { Report("process parameters not loaded",__FILE__,__LINE__,(int)0,RpWarning,(int)0,0); return ERROR; } } return Fresult; } uint32_t ProcessParamsInit(void) { FRESULT Fresult = FR_NOT_READY; uint32_t Bytes; ProcessParameters ProcessParams; //memcpy(&Bytes,(void *)PROCESS_PARAMETERS_MAP_IN_FLASH,sizeof(Bytes)); MCU_E2PromReadChunk(PROCESS_PARAMATERS_IN_EEPROM,4,&Bytes); REPORT_MSG(Bytes,"Bytes read from EEPROM"); if ((Bytes)&&(Bytes < 1000)) { //ProcessParameters* ProcessParams = (ProcessParameters *)(PROCESS_PARAMETERS_MAP_IN_FLASH+4); MCU_E2PromReadChunk(PROCESS_PARAMATERS_IN_EEPROM+4,Bytes,&ProcessParams); Fresult = HandleProcessParameters(&ProcessParams,false); } else { if (LoadProcessParamsFromFile()==OK) { MCU_E2PromReadChunk(PROCESS_PARAMATERS_IN_EEPROM,4,&Bytes); //memcpy(&Bytes,(void *)PROCESS_PARAMETERS_MAP_IN_FLASH,sizeof(Bytes)); REPORT_MSG(Bytes,"ProcessParams Bytes read from EEPROM"); if ((Bytes)&&(Bytes < 1000)) { MCU_E2PromReadChunk(PROCESS_PARAMATERS_IN_EEPROM+4,Bytes,&ProcessParams); //ProcessParameters* ProcessParams = (ProcessParameters *)(PROCESS_PARAMETERS_MAP_IN_FLASH+4); Fresult = HandleProcessParameters(&ProcessParams,false); } } } return Fresult; }