diff options
| author | Shlomo Hecht <shlomo@twine-s.com> | 2019-02-10 18:28:41 +0200 |
|---|---|---|
| committer | Shlomo Hecht <shlomo@twine-s.com> | 2019-02-10 18:28:41 +0200 |
| commit | a65868d1d77b1929b855abd0c19bdc08bc9cee9d (patch) | |
| tree | 09486bed718fb096914780f33313fb82a0207c87 /Software/Embedded_SW/Embedded | |
| parent | 82179e1b69b62b971a04af571979e7d10c60fd7a (diff) | |
| parent | ac9678197fc6142595089155d98442239a64e6d7 (diff) | |
| download | Tango-a65868d1d77b1929b855abd0c19bdc08bc9cee9d.tar.gz Tango-a65868d1d77b1929b855abd0c19bdc08bc9cee9d.zip | |
merge
Diffstat (limited to 'Software/Embedded_SW/Embedded')
44 files changed, 1651 insertions, 976 deletions
diff --git a/Software/Embedded_SW/Embedded/.cproject b/Software/Embedded_SW/Embedded/.cproject index 38422568f..d1abfd6c1 100644 --- a/Software/Embedded_SW/Embedded/.cproject +++ b/Software/Embedded_SW/Embedded/.cproject @@ -169,7 +169,7 @@ </toolChain> </folderInfo> <sourceEntries> - <entry excluding="JigCommands.c|PWM.c|USBCDCD.c|Message.c|Pin_config.c|src|Configuration.c|SlowMotors.c|Timer.c|Communication.c|FastMotors.c|ADCUtils.c|Drivers/L6470|Pin.c|ADCLogger.c|Flashstore.c|Profile.c" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/> + <entry excluding="PWM.c|USBCDCD.c|Message.c|Pin_config.c|src|Configuration.c|Timer.c|Communication.c|FastMotors.c|ADCUtils.c|Drivers/L6470|Pin.c|ADCLogger.c|Flashstore.c|Profile.c" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/> </sourceEntries> </configuration> </storageModule> @@ -335,6 +335,7 @@ <listOptionValue builtIn="false" value=""${workspace_loc:/${ProjName}}/Communication/PMR/Hardware""/> <listOptionValue builtIn="false" value=""${workspace_loc:/${ProjName}}/Communication/PMR/Printing""/> <listOptionValue builtIn="false" value=""${workspace_loc:/${ProjName}}/Communication/PMR/Common""/> + <listOptionValue builtIn="false" value=""${workspace_loc:/${ProjName}}/Communication/PMR/Debugging""/> <listOptionValue builtIn="false" value=""${workspace_loc:/${ProjName}}/Communication/PMR""/> <listOptionValue builtIn="false" value=""${workspace_loc:/${ProjName}/Communication}""/> <listOptionValue builtIn="false" value=""${workspace_loc:/${ProjName}/Common}""/> diff --git a/Software/Embedded_SW/Embedded/Common/SWUpdate/FileSystem.c b/Software/Embedded_SW/Embedded/Common/SWUpdate/FileSystem.c index 11fbf86c4..60873243c 100644 --- a/Software/Embedded_SW/Embedded/Common/SWUpdate/FileSystem.c +++ b/Software/Embedded_SW/Embedded/Common/SWUpdate/FileSystem.c @@ -48,7 +48,7 @@ FIL *UploadFileHandle = 0; //the system supports a single active file FIL *DownloadFileHandle = 0; //the system supports a single active file char FileHandleChar[5]; char ErrorMsg[100]; -#define MAX_CHUNK_LENGTH 2000 +#define MAX_CHUNK_LENGTH 4000 int32_t FileLength = 0; int32_t FileReceivedLength = 0; int32_t FileSentLength = 0; @@ -422,51 +422,10 @@ uint32_t DeleteRequestFunc(MessageContainer* requestContainer) DeleteResponse response = DELETE_RESPONSE__INIT; - DIR dir; FILINFO* fno = 0; //int NumOfFiles = 0; FRESULT Fresult = FR_OK; - /*Fresult |= f_opendir(&dir, g_cCwdBuf); - if(Fresult != FR_OK) - { - LOG_ERROR (Fresult,"f_write error"); - } - else - { - - fno = my_malloc(sizeof(FILINFO)); - memset (fno,0,sizeof(FILINFO)); - Fresult = f_stat(request->path,fno); - if (Fresult == FR_OK) - { - if (isDirectory(fno->fattrib)) - { - //============================ - Fresult = f_opendir(&dir, request->path); - if (Fresult == FR_OK) - { - Fresult = f_readdir(&dir, &fno); - if (Fresult == FR_OK) - { - if(fno->fname[0] ==0) - { - //no files - Fresult = f_unlink(request->path); - } - else - { - LOG_ERROR (fno,"Directory not empty"); - } - } - } - } - else - { - Fresult = f_unlink(request->path); - } - } - }*/ Fresult = f_unlink(request->path); responseContainer = createContainer(MESSAGE_TYPE__DeleteResponse, requestContainer->token, false, &response, &delete_response__pack, &delete_response__get_packed_size); @@ -509,9 +468,9 @@ uint32_t GetStorageInfoRequestFunc(MessageContainer* requestContainer) tot_sect = (fs->n_fatent - 2) * fs->csize; fre_sect = fre_clust * fs->csize; response.has_capacity = true; - response.capacity = tot_sect/2; + response.capacity = tot_sect/2*1024; response.has_freespace = true; - response.freespace = fre_sect/2; + response.freespace = fre_sect/2*1024; response.root = "/"; } @@ -588,16 +547,11 @@ uint32_t GetFilesRequestFunc(MessageContainer* requestContainer) FilesInfo[i] = &Data[i]; Data[i].has_attribute = true; Data[i].attribute = fno[i]->fattrib; - Data[i].has_length = true; Data[i].name = fno[i]->fname; Data[i].has_length = true; Data[i].length = fno[i]->fsize; Data[i].lastmodifieddate = fno[i]->fdate; Data[i].lastmodifiedtime = fno[i]->ftime; - //strcpy(FullPath[i],request->path); - //strcat(FullPath[i],'\\'); - //strcat(FullPath[i],&fno[i]->fname); - //sprintf (FullPath[i], "%s/%s", request->path, &fno[i]->fname); if (i==0) usnprintf(&FullPath[i], 50, "%s", request->path); else diff --git a/Software/Embedded_SW/Embedded/Common/SWUpdate/FirmwareUpgrade.c b/Software/Embedded_SW/Embedded/Common/SWUpdate/FirmwareUpgrade.c index 35bde3636..e029bf2ce 100644 --- a/Software/Embedded_SW/Embedded/Common/SWUpdate/FirmwareUpgrade.c +++ b/Software/Embedded_SW/Embedded/Common/SWUpdate/FirmwareUpgrade.c @@ -24,16 +24,15 @@ #include "drivers/FPGA/Full_Vme/FPGA_Programming_Up.h" #include "Common/SWUpdate/FileSystem.h" - uint32_t ActivateVersionRequestFunc(MessageContainer* requestContainer) { - uint32_t status = OK; void* buffer = NULL; uint32_t Bytes = 0; char SWINFOPath[100]; + char FullPath[50]; FRESULT Fresult = FR_OK; int File_i; - + bool Reboot = false; MessageContainer responseContainer; ActivateVersionRequest* request = activate_version_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data); @@ -41,12 +40,13 @@ uint32_t ActivateVersionRequestFunc(MessageContainer* requestContainer) ActivateVersionResponse response = ACTIVATE_VERSION_RESPONSE__INIT; VersionPackageDescriptor* VersionPackage;// = VERSION_PACKAGE_DESCRIPTOR__INIT; + FPGA_ID FileDestinationToFPGAId[VERSION_FILE_DESTINATION__FPGA3+1] = {MAX_FPGA,FPGA1,FPGA2,FPGA3}; + strcpy (SWINFOPath,request->path); - strcat(SWINFOPath,"//SWINFO.DAT"); + strcat(SWINFOPath,"/file1.pck"); Fresult = FileRead(SWINFOPath, &Bytes, &buffer); - if (Fresult == FR_OK) { VersionPackage = version_package_descriptor__unpack(NULL,Bytes,buffer); @@ -61,17 +61,22 @@ uint32_t ActivateVersionRequestFunc(MessageContainer* requestContainer) case VERSION_FILE_DESTINATION__FPGA3: //validate //update - Fresult = FPGA_Programming_Up( VersionPackage->filedescriptors[File_i]->destination, VersionPackage->filedescriptors[File_i]->filename, false); + usnprintf(FullPath, 50, "%s%s%s", request->path,"/", VersionPackage->filedescriptors[File_i]->filename); + if (VersionPackage->filedescriptors[File_i]->destination == VERSION_FILE_DESTINATION__FPGA3) + Reboot = true; + else + Reboot = false; + Fresult = FPGA_Programming_Request( FileDestinationToFPGAId[VersionPackage->filedescriptors[File_i]->destination], FullPath, Reboot); break; default: - LOG_ERROR (VersionPackage->filedescriptors[File_i]->destination,"wrong fule update Destination"); + LOG_ERROR (VersionPackage->filedescriptors[File_i]->destination,"wrong file update Destination"); Fresult = FR_INVALID_NAME; break; } } } responseContainer = createContainer(MESSAGE_TYPE__ActivateVersionResponse, requestContainer->token, false, &response, &activate_version_response__pack, &activate_version_response__get_packed_size); - if (status!= OK) + if (Fresult!= OK) { responseContainer.error = FileError_to_ErrorCode[Fresult]; responseContainer.errormessage = "Activate Version Request error"; diff --git a/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c b/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c index 40e13f142..7dece0d08 100644 --- a/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c +++ b/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c @@ -20,7 +20,7 @@ typedef struct } TangoVersion_t; -TangoVersion_t _gTangoVersion = {1,3,6,0}; +TangoVersion_t _gTangoVersion = {1,3,6,1}; #define BUILD_DATE __DATE__ char Dat[50] = BUILD_DATE; char _gTangoName [MAX_STRING_LEN] = "Tango01 ";//d diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/EventType.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/EventType.pb-c.c index 91d230a44..785da53e2 100644 --- a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/EventType.pb-c.c +++ b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/EventType.pb-c.c @@ -7,215 +7,9 @@ #endif #include "EventType.pb-c.h" -static const ProtobufCEnumValue event_type__enum_values_by_number[217] = +static const ProtobufCEnumValue event_type__enum_values_by_number[279] = { { "None", "EVENT_TYPE__None", 0 }, - { "POWER_UP_BIT_FAILURE", "EVENT_TYPE__POWER_UP_BIT_FAILURE", 1 }, - { "EMERGENCY_PUSH_BUTTON_PRESSED", "EVENT_TYPE__EMERGENCY_PUSH_BUTTON_PRESSED", 2 }, - { "FRONT_COVER_1_OPEN", "EVENT_TYPE__FRONT_COVER_1_OPEN", 3 }, - { "FRONT_COVER_2_OPEN", "EVENT_TYPE__FRONT_COVER_2_OPEN", 4 }, - { "FRONT_COVER_3_OPEN", "EVENT_TYPE__FRONT_COVER_3_OPEN", 5 }, - { "FRONT_COVER_4_OPEN", "EVENT_TYPE__FRONT_COVER_4_OPEN", 6 }, - { "CARTRIDGES_COVER_OPEN", "EVENT_TYPE__CARTRIDGES_COVER_OPEN", 7 }, - { "REAR_COVER_OPEN", "EVENT_TYPE__REAR_COVER_OPEN", 8 }, - { "MACHINE_INTERNAL_OVERTEMPERATURE", "EVENT_TYPE__MACHINE_INTERNAL_OVERTEMPERATURE", 9 }, - { "MACHINE_FANS_RPM_TOO_LOW", "EVENT_TYPE__MACHINE_FANS_RPM_TOO_LOW", 10 }, - { "MACHINE_FANS_STOPPED", "EVENT_TYPE__MACHINE_FANS_STOPPED", 11 }, - { "THREAD_BREAK", "EVENT_TYPE__THREAD_BREAK", 12 }, - { "THREAD_TENSION_CONTROL_FAILURE", "EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE", 13 }, - { "WINDER_CONE_DOES_NOT_EXIST", "EVENT_TYPE__WINDER_CONE_DOES_NOT_EXIST", 14 }, - { "FEEDER_MOTOR_OVERCURRENT", "EVENT_TYPE__FEEDER_MOTOR_OVERCURRENT", 15 }, - { "RIGHT_LOADER_MOTOR_OVERCURRENT", "EVENT_TYPE__RIGHT_LOADER_MOTOR_OVERCURRENT", 16 }, - { "PULLER_MOTOR_OVERCURRENT", "EVENT_TYPE__PULLER_MOTOR_OVERCURRENT", 17 }, - { "LEFT_LOADER_MOTOR_OVERCURRENT", "EVENT_TYPE__LEFT_LOADER_MOTOR_OVERCURRENT", 18 }, - { "WINDER_MOTOR_OVERCURRENT", "EVENT_TYPE__WINDER_MOTOR_OVERCURRENT", 19 }, - { "SCREW_MOTOR_OVERCURRENT", "EVENT_TYPE__SCREW_MOTOR_OVERCURRENT", 20 }, - { "LOADING_ARM_MOTOR_OVERCURRENT", "EVENT_TYPE__LOADING_ARM_MOTOR_OVERCURRENT", 21 }, - { "FEEDER_MOTOR_OVERTEMPERATURE", "EVENT_TYPE__FEEDER_MOTOR_OVERTEMPERATURE", 22 }, - { "RIGHT_LOADER_MOTOR_OVERTEMPERATURE", "EVENT_TYPE__RIGHT_LOADER_MOTOR_OVERTEMPERATURE", 23 }, - { "PULLER_MOTOR_OVERTEMPERATURE", "EVENT_TYPE__PULLER_MOTOR_OVERTEMPERATURE", 24 }, - { "LEFT_LOADER_MOTOR_OVERTEMPERATURE", "EVENT_TYPE__LEFT_LOADER_MOTOR_OVERTEMPERATURE", 25 }, - { "WINDER_MOTOR_OVERTEMPERATURE", "EVENT_TYPE__WINDER_MOTOR_OVERTEMPERATURE", 26 }, - { "SCREW_MOTOR_OVERTEMPERATURE", "EVENT_TYPE__SCREW_MOTOR_OVERTEMPERATURE", 27 }, - { "LOADING_ARM_MOTOR_OVERTEMPERATURE", "EVENT_TYPE__LOADING_ARM_MOTOR_OVERTEMPERATURE", 28 }, - { "FEEDER_MOTOR_STALL", "EVENT_TYPE__FEEDER_MOTOR_STALL", 29 }, - { "RIGHT_LOADER_MOTOR_STALL", "EVENT_TYPE__RIGHT_LOADER_MOTOR_STALL", 30 }, - { "PULLER_MOTOR_STALL", "EVENT_TYPE__PULLER_MOTOR_STALL", 31 }, - { "LEFT_LOADER_MOTOR_STALL", "EVENT_TYPE__LEFT_LOADER_MOTOR_STALL", 32 }, - { "WINDER_MOTOR_STALL", "EVENT_TYPE__WINDER_MOTOR_STALL", 33 }, - { "SCREW_MOTOR_STALL", "EVENT_TYPE__SCREW_MOTOR_STALL", 34 }, - { "LOADING_ARM_MOTOR_STALL", "EVENT_TYPE__LOADING_ARM_MOTOR_STALL", 35 }, - { "FEEDER_MOTOR_UNDERVOLTAGE", "EVENT_TYPE__FEEDER_MOTOR_UNDERVOLTAGE", 36 }, - { "RIGHT_LOADER_MOTOR_UNDERVOLTAGE", "EVENT_TYPE__RIGHT_LOADER_MOTOR_UNDERVOLTAGE", 37 }, - { "PULLER_MOTOR_UNDERVOLTAGE", "EVENT_TYPE__PULLER_MOTOR_UNDERVOLTAGE", 38 }, - { "LEFT_LOADER_MOTOR_UNDERVOLTAGE", "EVENT_TYPE__LEFT_LOADER_MOTOR_UNDERVOLTAGE", 39 }, - { "WINDER_MOTOR_UNDERVOLTAGE", "EVENT_TYPE__WINDER_MOTOR_UNDERVOLTAGE", 40 }, - { "SCREW_MOTOR_UNDERVOLTAGE", "EVENT_TYPE__SCREW_MOTOR_UNDERVOLTAGE", 41 }, - { "LOADING_ARM_MOTOR_UNDERVOLTAGE", "EVENT_TYPE__LOADING_ARM_MOTOR_UNDERVOLTAGE", 42 }, - { "LTFU_UP_TIMEOUT", "EVENT_TYPE__LTFU_UP_TIMEOUT", 43 }, - { "LTFU_DOWN_TIMEOUT", "EVENT_TYPE__LTFU_DOWN_TIMEOUT", 44 }, - { "RTFU_UP_TIMEOUT", "EVENT_TYPE__RTFU_UP_TIMEOUT", 45 }, - { "RTFU_DOWN_TIMEOUT", "EVENT_TYPE__RTFU_DOWN_TIMEOUT", 46 }, - { "SCREW_MOTOR_LIMIT_TIMEOUT", "EVENT_TYPE__SCREW_MOTOR_LIMIT_TIMEOUT", 47 }, - { "DRYER_MOTOR_OVERCURRENT", "EVENT_TYPE__DRYER_MOTOR_OVERCURRENT", 48 }, - { "DRYER_MOTOR_OVERTEMPERATURE", "EVENT_TYPE__DRYER_MOTOR_OVERTEMPERATURE", 49 }, - { "DRYER_MOTOR_STALL", "EVENT_TYPE__DRYER_MOTOR_STALL", 50 }, - { "DRYER_MOTOR_UNDERVOLTAGE", "EVENT_TYPE__DRYER_MOTOR_UNDERVOLTAGE", 51 }, - { "DRYER_DOOR_OPEN", "EVENT_TYPE__DRYER_DOOR_OPEN", 52 }, - { "DRYER_ZONE_1_OVERTEMPERATURE", "EVENT_TYPE__DRYER_ZONE_1_OVERTEMPERATURE", 53 }, - { "DRYER_ZONE_2_OVERTEMPERATURE", "EVENT_TYPE__DRYER_ZONE_2_OVERTEMPERATURE", 54 }, - { "DRYER_ZONE_1_UNDERTEMPERATURE_A", "EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_A", 55 }, - { "DRYER_ZONE_2_UNDERTEMPERATURE_A", "EVENT_TYPE__DRYER_ZONE_2_UNDERTEMPERATURE_A", 56 }, - { "DRYER_ZONE_1_UNDERTEMPERATURE_B", "EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_B", 57 }, - { "DRYER_ZONE_2_UNDERTEMPERATURE_B", "EVENT_TYPE__DRYER_ZONE_2_UNDERTEMPERATURE_B", 58 }, - { "DRYER_THERMAL_CUTOFF", "EVENT_TYPE__DRYER_THERMAL_CUTOFF", 59 }, - { "DRYER_HEATERS_ZONE_1_CURRENT_OUT_OF_RANGE", "EVENT_TYPE__DRYER_HEATERS_ZONE_1_CURRENT_OUT_OF_RANGE", 60 }, - { "DRYER_HEATERS_ZONE_2_CURRENT_OUT_OF_RANGE", "EVENT_TYPE__DRYER_HEATERS_ZONE_2_CURRENT_OUT_OF_RANGE", 61 }, - { "DRYER_HEATERS_ZONE_1_CURRENT_LOOP_BREAK", "EVENT_TYPE__DRYER_HEATERS_ZONE_1_CURRENT_LOOP_BREAK", 62 }, - { "DRYER_HEATERS_ZONE_2_CURRENT_LOOP_BREAK", "EVENT_TYPE__DRYER_HEATERS_ZONE_2_CURRENT_LOOP_BREAK", 63 }, - { "DRYER_FAN_RPM_TOO_LOW", "EVENT_TYPE__DRYER_FAN_RPM_TOO_LOW", 64 }, - { "DRYER_FAN_STOPPED", "EVENT_TYPE__DRYER_FAN_STOPPED", 65 }, - { "DYEING_HEAD_ZONE_1_OVERTEMPERATURE", "EVENT_TYPE__DYEING_HEAD_ZONE_1_OVERTEMPERATURE", 66 }, - { "DYEING_HEAD_ZONE_2_OVERTEMPERATURE", "EVENT_TYPE__DYEING_HEAD_ZONE_2_OVERTEMPERATURE", 67 }, - { "DYEING_HEAD_ZONE_3_OVERTEMPERATURE", "EVENT_TYPE__DYEING_HEAD_ZONE_3_OVERTEMPERATURE", 68 }, - { "DYEING_HEAD_ZONE_4_OVERTEMPERATURE", "EVENT_TYPE__DYEING_HEAD_ZONE_4_OVERTEMPERATURE", 69 }, - { "DYEING_HEAD_ZONE_5_OVERTEMPERATURE", "EVENT_TYPE__DYEING_HEAD_ZONE_5_OVERTEMPERATURE", 70 }, - { "DYEING_HEAD_ZONE_6_OVERTEMPERATURE", "EVENT_TYPE__DYEING_HEAD_ZONE_6_OVERTEMPERATURE", 71 }, - { "DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_A", "EVENT_TYPE__DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_A", 72 }, - { "DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_A", "EVENT_TYPE__DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_A", 73 }, - { "DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_A", "EVENT_TYPE__DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_A", 74 }, - { "DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_A", "EVENT_TYPE__DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_A", 75 }, - { "DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_A", "EVENT_TYPE__DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_A", 76 }, - { "DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_A", "EVENT_TYPE__DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_A", 77 }, - { "DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_B", "EVENT_TYPE__DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_B", 78 }, - { "DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_B", "EVENT_TYPE__DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_B", 79 }, - { "DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_B", "EVENT_TYPE__DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_B", 80 }, - { "DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_B", "EVENT_TYPE__DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_B", 81 }, - { "DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_B", "EVENT_TYPE__DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_B", 82 }, - { "DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_B", "EVENT_TYPE__DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_B", 83 }, - { "DYEING_HEAD_ZONE_1_CURRENT_OUT_OF_RANGE", "EVENT_TYPE__DYEING_HEAD_ZONE_1_CURRENT_OUT_OF_RANGE", 84 }, - { "DYEING_HEAD_ZONE_2_CURRENT_OUT_OF_RANGE", "EVENT_TYPE__DYEING_HEAD_ZONE_2_CURRENT_OUT_OF_RANGE", 85 }, - { "DYEING_HEAD_ZONE_3_CURRENT_OUT_OF_RANGE", "EVENT_TYPE__DYEING_HEAD_ZONE_3_CURRENT_OUT_OF_RANGE", 86 }, - { "DYEING_HEAD_ZONE_4_CURRENT_OUT_OF_RANGE", "EVENT_TYPE__DYEING_HEAD_ZONE_4_CURRENT_OUT_OF_RANGE", 87 }, - { "DYEING_HEAD_ZONE_5_6_CURRENT_OUT_OF_RANGE", "EVENT_TYPE__DYEING_HEAD_ZONE_5_6_CURRENT_OUT_OF_RANGE", 88 }, - { "DYEING_HEAD_ZONE_1_CURRENT_LOOP_BREAK", "EVENT_TYPE__DYEING_HEAD_ZONE_1_CURRENT_LOOP_BREAK", 89 }, - { "DYEING_HEAD_ZONE_2_CURRENT_LOOP_BREAK", "EVENT_TYPE__DYEING_HEAD_ZONE_2_CURRENT_LOOP_BREAK", 90 }, - { "DYEING_HEAD_ZONE_3_CURRENT_LOOP_BREAK", "EVENT_TYPE__DYEING_HEAD_ZONE_3_CURRENT_LOOP_BREAK", 91 }, - { "DYEING_HEAD_ZONE_4_CURRENT_LOOP_BREAK", "EVENT_TYPE__DYEING_HEAD_ZONE_4_CURRENT_LOOP_BREAK", 92 }, - { "DYEING_HEAD_ZONE_5_6_CURRENT_LOOP_BREAK", "EVENT_TYPE__DYEING_HEAD_ZONE_5_6_CURRENT_LOOP_BREAK", 93 }, - { "DYEING_HEAD_THERMAL_CUTOFF", "EVENT_TYPE__DYEING_HEAD_THERMAL_CUTOFF", 94 }, - { "DYEING_HEAD_COVER_OPEN_TIMEOUT", "EVENT_TYPE__DYEING_HEAD_COVER_OPEN_TIMEOUT", 95 }, - { "DYEING_HEAD_COVER_CLOSE_TIMEOUT", "EVENT_TYPE__DYEING_HEAD_COVER_CLOSE_TIMEOUT", 96 }, - { "MIXER_OVERTEMPERATURE", "EVENT_TYPE__MIXER_OVERTEMPERATURE", 97 }, - { "MIXER_UNDERTEMPERATURE_A", "EVENT_TYPE__MIXER_UNDERTEMPERATURE_A", 98 }, - { "MIXER_UNDERTEMPERATURE_B", "EVENT_TYPE__MIXER_UNDERTEMPERATURE_B", 99 }, - { "MIXER_THERMAL_CUTOFF", "EVENT_TYPE__MIXER_THERMAL_CUTOFF", 100 }, - { "MIXER_CURRENT_OUT_OF_RANGE", "EVENT_TYPE__MIXER_CURRENT_OUT_OF_RANGE", 101 }, - { "MIXER_CURRENT_LOOP_BREAK", "EVENT_TYPE__MIXER_CURRENT_LOOP_BREAK", 102 }, - { "DISPENSER_1_OVERPRESSURE", "EVENT_TYPE__DISPENSER_1_OVERPRESSURE", 103 }, - { "DISPENSER_2_OVERPRESSURE", "EVENT_TYPE__DISPENSER_2_OVERPRESSURE", 104 }, - { "DISPENSER_3_OVERPRESSURE", "EVENT_TYPE__DISPENSER_3_OVERPRESSURE", 105 }, - { "DISPENSER_4_OVERPRESSURE", "EVENT_TYPE__DISPENSER_4_OVERPRESSURE", 106 }, - { "DISPENSER_5_OVERPRESSURE", "EVENT_TYPE__DISPENSER_5_OVERPRESSURE", 107 }, - { "DISPENSER_6_OVERPRESSURE", "EVENT_TYPE__DISPENSER_6_OVERPRESSURE", 108 }, - { "DISPENSER_7_OVERPRESSURE", "EVENT_TYPE__DISPENSER_7_OVERPRESSURE", 109 }, - { "DISPENSER_8_OVERPRESSURE", "EVENT_TYPE__DISPENSER_8_OVERPRESSURE", 110 }, - { "DISPENSER_1_UNDERPRESSURE", "EVENT_TYPE__DISPENSER_1_UNDERPRESSURE", 111 }, - { "DISPENSER_2_UNDERPRESSURE", "EVENT_TYPE__DISPENSER_2_UNDERPRESSURE", 112 }, - { "DISPENSER_3_UNDERPRESSURE", "EVENT_TYPE__DISPENSER_3_UNDERPRESSURE", 113 }, - { "DISPENSER_4_UNDERPRESSURE", "EVENT_TYPE__DISPENSER_4_UNDERPRESSURE", 114 }, - { "DISPENSER_5_UNDERPRESSURE", "EVENT_TYPE__DISPENSER_5_UNDERPRESSURE", 115 }, - { "DISPENSER_6_UNDERPRESSURE", "EVENT_TYPE__DISPENSER_6_UNDERPRESSURE", 116 }, - { "DISPENSER_7_UNDERPRESSURE", "EVENT_TYPE__DISPENSER_7_UNDERPRESSURE", 117 }, - { "DISPENSER_8_UNDERPRESSURE", "EVENT_TYPE__DISPENSER_8_UNDERPRESSURE", 118 }, - { "DISPENSER_1_EMPTY", "EVENT_TYPE__DISPENSER_1_EMPTY", 119 }, - { "DISPENSER_2_EMPTY", "EVENT_TYPE__DISPENSER_2_EMPTY", 120 }, - { "DISPENSER_3_EMPTY", "EVENT_TYPE__DISPENSER_3_EMPTY", 121 }, - { "DISPENSER_4_EMPTY", "EVENT_TYPE__DISPENSER_4_EMPTY", 122 }, - { "DISPENSER_5_EMPTY", "EVENT_TYPE__DISPENSER_5_EMPTY", 123 }, - { "DISPENSER_6_EMPTY", "EVENT_TYPE__DISPENSER_6_EMPTY", 124 }, - { "DISPENSER_7_EMPTY", "EVENT_TYPE__DISPENSER_7_EMPTY", 125 }, - { "DISPENSER_8_EMPTY", "EVENT_TYPE__DISPENSER_8_EMPTY", 126 }, - { "DISPENSER_1_REFILL_FAILURE", "EVENT_TYPE__DISPENSER_1_REFILL_FAILURE", 127 }, - { "DISPENSER_2_REFILL_FAILURE", "EVENT_TYPE__DISPENSER_2_REFILL_FAILURE", 128 }, - { "DISPENSER_3_REFILL_FAILURE", "EVENT_TYPE__DISPENSER_3_REFILL_FAILURE", 129 }, - { "DISPENSER_4_REFILL_FAILURE", "EVENT_TYPE__DISPENSER_4_REFILL_FAILURE", 130 }, - { "DISPENSER_5_REFILL_FAILURE", "EVENT_TYPE__DISPENSER_5_REFILL_FAILURE", 131 }, - { "DISPENSER_6_REFILL_FAILURE", "EVENT_TYPE__DISPENSER_6_REFILL_FAILURE", 132 }, - { "DISPENSER_7_REFILL_FAILURE", "EVENT_TYPE__DISPENSER_7_REFILL_FAILURE", 133 }, - { "DISPENSER_8_REFILL_FAILURE", "EVENT_TYPE__DISPENSER_8_REFILL_FAILURE", 134 }, - { "DISPENSER_1_MOTOR_OVERCURRENT", "EVENT_TYPE__DISPENSER_1_MOTOR_OVERCURRENT", 135 }, - { "DISPENSER_2_MOTOR_OVERCURRENT", "EVENT_TYPE__DISPENSER_2_MOTOR_OVERCURRENT", 136 }, - { "DISPENSER_3_MOTOR_OVERCURRENT", "EVENT_TYPE__DISPENSER_3_MOTOR_OVERCURRENT", 137 }, - { "DISPENSER_4_MOTOR_OVERCURRENT", "EVENT_TYPE__DISPENSER_4_MOTOR_OVERCURRENT", 138 }, - { "DISPENSER_5_MOTOR_OVERCURRENT", "EVENT_TYPE__DISPENSER_5_MOTOR_OVERCURRENT", 139 }, - { "DISPENSER_6_MOTOR_OVERCURRENT", "EVENT_TYPE__DISPENSER_6_MOTOR_OVERCURRENT", 140 }, - { "DISPENSER_7_MOTOR_OVERCURRENT", "EVENT_TYPE__DISPENSER_7_MOTOR_OVERCURRENT", 141 }, - { "DISPENSER_8_MOTOR_OVERCURRENT", "EVENT_TYPE__DISPENSER_8_MOTOR_OVERCURRENT", 142 }, - { "DISPENSER_1_MOTOR_OVERTEMPERATURE", "EVENT_TYPE__DISPENSER_1_MOTOR_OVERTEMPERATURE", 143 }, - { "DISPENSER_2_MOTOR_OVERTEMPERATURE", "EVENT_TYPE__DISPENSER_2_MOTOR_OVERTEMPERATURE", 144 }, - { "DISPENSER_3_MOTOR_OVERTEMPERATURE", "EVENT_TYPE__DISPENSER_3_MOTOR_OVERTEMPERATURE", 145 }, - { "DISPENSER_4_MOTOR_OVERTEMPERATURE", "EVENT_TYPE__DISPENSER_4_MOTOR_OVERTEMPERATURE", 146 }, - { "DISPENSER_5_MOTOR_OVERTEMPERATURE", "EVENT_TYPE__DISPENSER_5_MOTOR_OVERTEMPERATURE", 147 }, - { "DISPENSER_6_MOTOR_OVERTEMPERATURE", "EVENT_TYPE__DISPENSER_6_MOTOR_OVERTEMPERATURE", 148 }, - { "DISPENSER_7_MOTOR_OVERTEMPERATURE", "EVENT_TYPE__DISPENSER_7_MOTOR_OVERTEMPERATURE", 149 }, - { "DISPENSER_8_MOTOR_OVERTEMPERATURE", "EVENT_TYPE__DISPENSER_8_MOTOR_OVERTEMPERATURE", 150 }, - { "DISPENSER_1_MOTOR_STALL", "EVENT_TYPE__DISPENSER_1_MOTOR_STALL", 151 }, - { "DISPENSER_2_MOTOR_STALL", "EVENT_TYPE__DISPENSER_2_MOTOR_STALL", 152 }, - { "DISPENSER_3_MOTOR_STALL", "EVENT_TYPE__DISPENSER_3_MOTOR_STALL", 153 }, - { "DISPENSER_4_MOTOR_STALL", "EVENT_TYPE__DISPENSER_4_MOTOR_STALL", 154 }, - { "DISPENSER_5_MOTOR_STALL", "EVENT_TYPE__DISPENSER_5_MOTOR_STALL", 155 }, - { "DISPENSER_6_MOTOR_STALL", "EVENT_TYPE__DISPENSER_6_MOTOR_STALL", 156 }, - { "DISPENSER_7_MOTOR_STALL", "EVENT_TYPE__DISPENSER_7_MOTOR_STALL", 157 }, - { "DISPENSER_8_MOTOR_STALL", "EVENT_TYPE__DISPENSER_8_MOTOR_STALL", 158 }, - { "DISPENSER_1_MOTOR_UNDERVOLTAGE", "EVENT_TYPE__DISPENSER_1_MOTOR_UNDERVOLTAGE", 159 }, - { "DISPENSER_2_MOTOR_UNDERVOLTAGE", "EVENT_TYPE__DISPENSER_2_MOTOR_UNDERVOLTAGE", 160 }, - { "DISPENSER_3_MOTOR_UNDERVOLTAGE", "EVENT_TYPE__DISPENSER_3_MOTOR_UNDERVOLTAGE", 161 }, - { "DISPENSER_4_MOTOR_UNDERVOLTAGE", "EVENT_TYPE__DISPENSER_4_MOTOR_UNDERVOLTAGE", 162 }, - { "DISPENSER_5_MOTOR_UNDERVOLTAGE", "EVENT_TYPE__DISPENSER_5_MOTOR_UNDERVOLTAGE", 163 }, - { "DISPENSER_6_MOTOR_UNDERVOLTAGE", "EVENT_TYPE__DISPENSER_6_MOTOR_UNDERVOLTAGE", 164 }, - { "DISPENSER_7_MOTOR_UNDERVOLTAGE", "EVENT_TYPE__DISPENSER_7_MOTOR_UNDERVOLTAGE", 165 }, - { "DISPENSER_8_MOTOR_UNDERVOLTAGE", "EVENT_TYPE__DISPENSER_8_MOTOR_UNDERVOLTAGE", 166 }, - { "MID_TANK_1_LOW_LEVEL", "EVENT_TYPE__MID_TANK_1_LOW_LEVEL", 167 }, - { "MID_TANK_2_LOW_LEVEL", "EVENT_TYPE__MID_TANK_2_LOW_LEVEL", 168 }, - { "MID_TANK_3_LOW_LEVEL", "EVENT_TYPE__MID_TANK_3_LOW_LEVEL", 169 }, - { "MID_TANK_4_LOW_LEVEL", "EVENT_TYPE__MID_TANK_4_LOW_LEVEL", 170 }, - { "MID_TANK_5_LOW_LEVEL", "EVENT_TYPE__MID_TANK_5_LOW_LEVEL", 171 }, - { "MID_TANK_6_LOW_LEVEL", "EVENT_TYPE__MID_TANK_6_LOW_LEVEL", 172 }, - { "MID_TANK_7_LOW_LEVEL", "EVENT_TYPE__MID_TANK_7_LOW_LEVEL", 173 }, - { "MID_TANK_8_LOW_LEVEL", "EVENT_TYPE__MID_TANK_8_LOW_LEVEL", 174 }, - { "MID_TANK_1_EMPTY", "EVENT_TYPE__MID_TANK_1_EMPTY", 175 }, - { "MID_TANK_2_EMPTY", "EVENT_TYPE__MID_TANK_2_EMPTY", 176 }, - { "MID_TANK_3_EMPTY", "EVENT_TYPE__MID_TANK_3_EMPTY", 177 }, - { "MID_TANK_4_EMPTY", "EVENT_TYPE__MID_TANK_4_EMPTY", 178 }, - { "MID_TANK_5_EMPTY", "EVENT_TYPE__MID_TANK_5_EMPTY", 179 }, - { "MID_TANK_6_EMPTY", "EVENT_TYPE__MID_TANK_6_EMPTY", 180 }, - { "MID_TANK_7_EMPTY", "EVENT_TYPE__MID_TANK_7_EMPTY", 181 }, - { "MID_TANK_8_EMPTY", "EVENT_TYPE__MID_TANK_8_EMPTY", 182 }, - { "MID_TANK_1_OVERFLOW", "EVENT_TYPE__MID_TANK_1_OVERFLOW", 183 }, - { "MID_TANK_2_OVERFLOW", "EVENT_TYPE__MID_TANK_2_OVERFLOW", 184 }, - { "MID_TANK_3_OVERFLOW", "EVENT_TYPE__MID_TANK_3_OVERFLOW", 185 }, - { "MID_TANK_4_OVERFLOW", "EVENT_TYPE__MID_TANK_4_OVERFLOW", 186 }, - { "MID_TANK_5_OVERFLOW", "EVENT_TYPE__MID_TANK_5_OVERFLOW", 187 }, - { "MID_TANK_6_OVERFLOW", "EVENT_TYPE__MID_TANK_6_OVERFLOW", 188 }, - { "MID_TANK_7_OVERFLOW", "EVENT_TYPE__MID_TANK_7_OVERFLOW", 189 }, - { "MID_TANK_8_OVERFLOW", "EVENT_TYPE__MID_TANK_8_OVERFLOW", 190 }, - { "AIR_FILTER_NOT_INSTALLED", "EVENT_TYPE__AIR_FILTER_NOT_INSTALLED", 191 }, - { "AIR_FILTER_CLOGGED", "EVENT_TYPE__AIR_FILTER_CLOGGED", 192 }, - { "WASTE_CONTAINER_EMPTYING_TIMEOUT", "EVENT_TYPE__WASTE_CONTAINER_EMPTYING_TIMEOUT", 193 }, - { "NO_AIR_PRESSURE", "EVENT_TYPE__NO_AIR_PRESSURE", 194 }, - { "WASTE_CONTAINER_OVERFLOW", "EVENT_TYPE__WASTE_CONTAINER_OVERFLOW", 195 }, - { "VOC_SENSOR_ALARM", "EVENT_TYPE__VOC_SENSOR_ALARM", 196 }, - { "CHILLER_DRY_CONTACT", "EVENT_TYPE__CHILLER_DRY_CONTACT", 197 }, - { "INSUFFICIENT_AIR_FLOW", "EVENT_TYPE__INSUFFICIENT_AIR_FLOW", 198 }, - { "INK_CARTRIDGE_PRESENCE_SENSOR_TIMEOUT", "EVENT_TYPE__INK_CARTRIDGE_PRESENCE_SENSOR_TIMEOUT", 199 }, - { "INK_CARTRIDGE_RFID_TIMEOUT", "EVENT_TYPE__INK_CARTRIDGE_RFID_TIMEOUT", 200 }, - { "NO_WASTE_CARTRIDGE_AVAILABLE", "EVENT_TYPE__NO_WASTE_CARTRIDGE_AVAILABLE", 201 }, - { "ALL_WASTE_CARTRIDGES_FULL", "EVENT_TYPE__ALL_WASTE_CARTRIDGES_FULL", 202 }, - { "WASTE_CARTRIDGE_PRESENCE_SENSOR_TIMEOUT", "EVENT_TYPE__WASTE_CARTRIDGE_PRESENCE_SENSOR_TIMEOUT", 203 }, - { "WASTE_CARTRIDGE_RFID_TIMEOUT", "EVENT_TYPE__WASTE_CARTRIDGE_RFID_TIMEOUT", 204 }, - { "ELECTRICAL_CABINET_FANS_RPM_TOO_LOW", "EVENT_TYPE__ELECTRICAL_CABINET_FANS_RPM_TOO_LOW", 205 }, - { "ELECTRICAL_CABINET_FANS_STOPPED", "EVENT_TYPE__ELECTRICAL_CABINET_FANS_STOPPED", 206 }, { "REQUEST_SENT", "EVENT_TYPE__REQUEST_SENT", 1000 }, { "RESPONSE_RECEIVED", "EVENT_TYPE__RESPONSE_RECEIVED", 1001 }, { "REQUEST_FAILED", "EVENT_TYPE__REQUEST_FAILED", 1002 }, @@ -226,229 +20,559 @@ static const ProtobufCEnumValue event_type__enum_values_by_number[217] = { "RECORDING_STARTED", "EVENT_TYPE__RECORDING_STARTED", 1007 }, { "RECORDING_STOPPED", "EVENT_TYPE__RECORDING_STOPPED", 1008 }, { "JOB_STATUS", "EVENT_TYPE__JOB_STATUS", 1009 }, + { "POWER_UP_BIT_FAILURE", "EVENT_TYPE__POWER_UP_BIT_FAILURE", 2000 }, + { "EMERGENCY_PUSH_BUTTON_PRESSED", "EVENT_TYPE__EMERGENCY_PUSH_BUTTON_PRESSED", 2001 }, + { "FRONT_COVER_1_OPEN", "EVENT_TYPE__FRONT_COVER_1_OPEN", 2002 }, + { "FRONT_COVER_2_OPEN", "EVENT_TYPE__FRONT_COVER_2_OPEN", 2003 }, + { "FRONT_COVER_3_OPEN", "EVENT_TYPE__FRONT_COVER_3_OPEN", 2004 }, + { "FRONT_COVER_4_OPEN", "EVENT_TYPE__FRONT_COVER_4_OPEN", 2005 }, + { "CARTRIDGES_COVER_OPEN", "EVENT_TYPE__CARTRIDGES_COVER_OPEN", 2006 }, + { "REAR_COVER_OPEN", "EVENT_TYPE__REAR_COVER_OPEN", 2007 }, + { "MACHINE_INTERNAL_OVERTEMPERATURE", "EVENT_TYPE__MACHINE_INTERNAL_OVERTEMPERATURE", 2008 }, + { "MACHINE_FANS_RPM_TOO_LOW", "EVENT_TYPE__MACHINE_FANS_RPM_TOO_LOW", 2009 }, + { "MACHINE_FANS_STOPPED", "EVENT_TYPE__MACHINE_FANS_STOPPED", 2010 }, + { "ELECTRICAL_CABINET_FANS_RPM_TOO_LOW", "EVENT_TYPE__ELECTRICAL_CABINET_FANS_RPM_TOO_LOW", 2011 }, + { "ELECTRICAL_CABINET_FANS_STOPPED", "EVENT_TYPE__ELECTRICAL_CABINET_FANS_STOPPED", 2012 }, + { "THREAD_BREAK", "EVENT_TYPE__THREAD_BREAK", 3000 }, + { "THREAD_TENSION_CONTROL_FAILURE_FEEDER_DANCER", "EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_FEEDER_DANCER", 3001 }, + { "WINDER_CONE_DOES_NOT_EXIST", "EVENT_TYPE__WINDER_CONE_DOES_NOT_EXIST", 3002 }, + { "FEEDER_MOTOR_OVERCURRENT", "EVENT_TYPE__FEEDER_MOTOR_OVERCURRENT", 3003 }, + { "RIGHT_LOADER_MOTOR_OVERCURRENT", "EVENT_TYPE__RIGHT_LOADER_MOTOR_OVERCURRENT", 3004 }, + { "PULLER_MOTOR_OVERCURRENT", "EVENT_TYPE__PULLER_MOTOR_OVERCURRENT", 3005 }, + { "LEFT_LOADER_MOTOR_OVERCURRENT", "EVENT_TYPE__LEFT_LOADER_MOTOR_OVERCURRENT", 3006 }, + { "WINDER_MOTOR_OVERCURRENT", "EVENT_TYPE__WINDER_MOTOR_OVERCURRENT", 3007 }, + { "SCREW_MOTOR_OVERCURRENT", "EVENT_TYPE__SCREW_MOTOR_OVERCURRENT", 3008 }, + { "LOADING_ARM_MOTOR_OVERCURRENT", "EVENT_TYPE__LOADING_ARM_MOTOR_OVERCURRENT", 3009 }, + { "FEEDER_MOTOR_OVERTEMPERATURE", "EVENT_TYPE__FEEDER_MOTOR_OVERTEMPERATURE", 3010 }, + { "RIGHT_LOADER_MOTOR_OVERTEMPERATURE", "EVENT_TYPE__RIGHT_LOADER_MOTOR_OVERTEMPERATURE", 3011 }, + { "PULLER_MOTOR_OVERTEMPERATURE", "EVENT_TYPE__PULLER_MOTOR_OVERTEMPERATURE", 3012 }, + { "LEFT_LOADER_MOTOR_OVERTEMPERATURE", "EVENT_TYPE__LEFT_LOADER_MOTOR_OVERTEMPERATURE", 3013 }, + { "WINDER_MOTOR_OVERTEMPERATURE", "EVENT_TYPE__WINDER_MOTOR_OVERTEMPERATURE", 3014 }, + { "SCREW_MOTOR_OVERTEMPERATURE", "EVENT_TYPE__SCREW_MOTOR_OVERTEMPERATURE", 3015 }, + { "LOADING_ARM_MOTOR_OVERTEMPERATURE", "EVENT_TYPE__LOADING_ARM_MOTOR_OVERTEMPERATURE", 3016 }, + { "FEEDER_MOTOR_STALL", "EVENT_TYPE__FEEDER_MOTOR_STALL", 3017 }, + { "RIGHT_LOADER_MOTOR_STALL", "EVENT_TYPE__RIGHT_LOADER_MOTOR_STALL", 3018 }, + { "PULLER_MOTOR_STALL", "EVENT_TYPE__PULLER_MOTOR_STALL", 3019 }, + { "LEFT_LOADER_MOTOR_STALL", "EVENT_TYPE__LEFT_LOADER_MOTOR_STALL", 3020 }, + { "WINDER_MOTOR_STALL", "EVENT_TYPE__WINDER_MOTOR_STALL", 3021 }, + { "SCREW_MOTOR_STALL", "EVENT_TYPE__SCREW_MOTOR_STALL", 3022 }, + { "LOADING_ARM_MOTOR_STALL", "EVENT_TYPE__LOADING_ARM_MOTOR_STALL", 3023 }, + { "FEEDER_MOTOR_UNDERVOLTAGE", "EVENT_TYPE__FEEDER_MOTOR_UNDERVOLTAGE", 3024 }, + { "RIGHT_LOADER_MOTOR_UNDERVOLTAGE", "EVENT_TYPE__RIGHT_LOADER_MOTOR_UNDERVOLTAGE", 3025 }, + { "PULLER_MOTOR_UNDERVOLTAGE", "EVENT_TYPE__PULLER_MOTOR_UNDERVOLTAGE", 3026 }, + { "LEFT_LOADER_MOTOR_UNDERVOLTAGE", "EVENT_TYPE__LEFT_LOADER_MOTOR_UNDERVOLTAGE", 3027 }, + { "WINDER_MOTOR_UNDERVOLTAGE", "EVENT_TYPE__WINDER_MOTOR_UNDERVOLTAGE", 3028 }, + { "SCREW_MOTOR_UNDERVOLTAGE", "EVENT_TYPE__SCREW_MOTOR_UNDERVOLTAGE", 3029 }, + { "LOADING_ARM_MOTOR_UNDERVOLTAGE", "EVENT_TYPE__LOADING_ARM_MOTOR_UNDERVOLTAGE", 3030 }, + { "LTFU_UP_TIMEOUT", "EVENT_TYPE__LTFU_UP_TIMEOUT", 3031 }, + { "LTFU_DOWN_TIMEOUT", "EVENT_TYPE__LTFU_DOWN_TIMEOUT", 3032 }, + { "RTFU_UP_TIMEOUT", "EVENT_TYPE__RTFU_UP_TIMEOUT", 3033 }, + { "RTFU_DOWN_TIMEOUT", "EVENT_TYPE__RTFU_DOWN_TIMEOUT", 3034 }, + { "SCREW_MOTOR_LIMIT_TIMEOUT", "EVENT_TYPE__SCREW_MOTOR_LIMIT_TIMEOUT", 3035 }, + { "WINDER_DANCER_MOTOR_OVERCURRENT", "EVENT_TYPE__WINDER_DANCER_MOTOR_OVERCURRENT", 3036 }, + { "PULLER_DANCER_MOTOR_OVERCURRENT", "EVENT_TYPE__PULLER_DANCER_MOTOR_OVERCURRENT", 3037 }, + { "FEEDER_DANCER_MOTOR_OVERCURRENT", "EVENT_TYPE__FEEDER_DANCER_MOTOR_OVERCURRENT", 3038 }, + { "WINDER_DANCER_MOTOR_OVERTEMPERATURE", "EVENT_TYPE__WINDER_DANCER_MOTOR_OVERTEMPERATURE", 3039 }, + { "PULLER_DANCER_MOTOR_OVERTEMPERATURE", "EVENT_TYPE__PULLER_DANCER_MOTOR_OVERTEMPERATURE", 3040 }, + { "FEEDER_DANCER_MOTOR_OVERTEMPERATURE", "EVENT_TYPE__FEEDER_DANCER_MOTOR_OVERTEMPERATURE", 3041 }, + { "WINDER_DANCER_MOTOR_STALL", "EVENT_TYPE__WINDER_DANCER_MOTOR_STALL", 3042 }, + { "PULLER_DANCER_MOTOR_STALL", "EVENT_TYPE__PULLER_DANCER_MOTOR_STALL", 3043 }, + { "FEEDER_DANCER_MOTOR_STALL", "EVENT_TYPE__FEEDER_DANCER_MOTOR_STALL", 3044 }, + { "WINDER_DANCER_MOTOR_UNDERVOLTAGE", "EVENT_TYPE__WINDER_DANCER_MOTOR_UNDERVOLTAGE", 3045 }, + { "PULLER_DANCER_MOTOR_UNDERVOLTAGE", "EVENT_TYPE__PULLER_DANCER_MOTOR_UNDERVOLTAGE", 3046 }, + { "FEEDER_DANCER_MOTOR_UNDERVOLTAGE", "EVENT_TYPE__FEEDER_DANCER_MOTOR_UNDERVOLTAGE", 3047 }, + { "THREAD_TENSION_CONTROL_FAILURE_PULLER_DANCER", "EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_PULLER_DANCER", 3048 }, + { "THREAD_TENSION_CONTROL_FAILURE_WINDER_DANCER", "EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_WINDER_DANCER", 3049 }, + { "DRYER_MOTOR_OVERCURRENT", "EVENT_TYPE__DRYER_MOTOR_OVERCURRENT", 4000 }, + { "DRYER_MOTOR_OVERTEMPERATURE", "EVENT_TYPE__DRYER_MOTOR_OVERTEMPERATURE", 4001 }, + { "DRYER_MOTOR_STALL", "EVENT_TYPE__DRYER_MOTOR_STALL", 4002 }, + { "DRYER_MOTOR_UNDERVOLTAGE", "EVENT_TYPE__DRYER_MOTOR_UNDERVOLTAGE", 4003 }, + { "DRYER_DOOR_OPEN", "EVENT_TYPE__DRYER_DOOR_OPEN", 4004 }, + { "DRYER_ZONE_1_OVERTEMPERATURE", "EVENT_TYPE__DRYER_ZONE_1_OVERTEMPERATURE", 4005 }, + { "DRYER_ZONE_2_OVERTEMPERATURE", "EVENT_TYPE__DRYER_ZONE_2_OVERTEMPERATURE", 4006 }, + { "DRYER_ZONE_1_UNDERTEMPERATURE_A", "EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_A", 4007 }, + { "DRYER_ZONE_1_UNDERTEMPERATURE_B", "EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_B", 4008 }, + { "DRYER_ZONE_2_UNDERTEMPERATURE_B", "EVENT_TYPE__DRYER_ZONE_2_UNDERTEMPERATURE_B", 4009 }, + { "DRYER_THERMAL_CUTOFF", "EVENT_TYPE__DRYER_THERMAL_CUTOFF", 4010 }, + { "DRYER_HEATERS_ZONE_1_CURRENT_OUT_OF_RANGE", "EVENT_TYPE__DRYER_HEATERS_ZONE_1_CURRENT_OUT_OF_RANGE", 4011 }, + { "DRYER_HEATERS_ZONE_2_CURRENT_OUT_OF_RANGE", "EVENT_TYPE__DRYER_HEATERS_ZONE_2_CURRENT_OUT_OF_RANGE", 4012 }, + { "DRYER_HEATERS_ZONE_1_CURRENT_LOOP_BREAK", "EVENT_TYPE__DRYER_HEATERS_ZONE_1_CURRENT_LOOP_BREAK", 4013 }, + { "DRYER_HEATERS_ZONE_2_CURRENT_LOOP_BREAK", "EVENT_TYPE__DRYER_HEATERS_ZONE_2_CURRENT_LOOP_BREAK", 4014 }, + { "DRYER_FAN_RPM_TOO_LOW", "EVENT_TYPE__DRYER_FAN_RPM_TOO_LOW", 4015 }, + { "DRYER_FAN_STOPPED", "EVENT_TYPE__DRYER_FAN_STOPPED", 4016 }, + { "DRYER_LID_MOTOR_OVERCURRENT", "EVENT_TYPE__DRYER_LID_MOTOR_OVERCURRENT", 4017 }, + { "DRYER_LID_MOTOR_OVERTEMPERATURE", "EVENT_TYPE__DRYER_LID_MOTOR_OVERTEMPERATURE", 4018 }, + { "DRYER_LID_MOTOR_STALL", "EVENT_TYPE__DRYER_LID_MOTOR_STALL", 4019 }, + { "DRYER_LID_MOTOR_UNDERVOLTAGE", "EVENT_TYPE__DRYER_LID_MOTOR_UNDERVOLTAGE", 4020 }, + { "DRYER_ZONE_2_UNDERTEMPERATURE_A", "EVENT_TYPE__DRYER_ZONE_2_UNDERTEMPERATURE_A", 4021 }, + { "DYEING_HEAD_ZONE_1_OVERTEMPERATURE", "EVENT_TYPE__DYEING_HEAD_ZONE_1_OVERTEMPERATURE", 5000 }, + { "DYEING_HEAD_ZONE_2_OVERTEMPERATURE", "EVENT_TYPE__DYEING_HEAD_ZONE_2_OVERTEMPERATURE", 5001 }, + { "DYEING_HEAD_ZONE_3_OVERTEMPERATURE", "EVENT_TYPE__DYEING_HEAD_ZONE_3_OVERTEMPERATURE", 5002 }, + { "DYEING_HEAD_ZONE_4_OVERTEMPERATURE", "EVENT_TYPE__DYEING_HEAD_ZONE_4_OVERTEMPERATURE", 5003 }, + { "DYEING_HEAD_ZONE_5_OVERTEMPERATURE", "EVENT_TYPE__DYEING_HEAD_ZONE_5_OVERTEMPERATURE", 5004 }, + { "DYEING_HEAD_ZONE_6_OVERTEMPERATURE", "EVENT_TYPE__DYEING_HEAD_ZONE_6_OVERTEMPERATURE", 5005 }, + { "DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_A", "EVENT_TYPE__DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_A", 5006 }, + { "DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_A", "EVENT_TYPE__DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_A", 5007 }, + { "DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_A", "EVENT_TYPE__DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_A", 5008 }, + { "DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_A", "EVENT_TYPE__DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_A", 5009 }, + { "DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_A", "EVENT_TYPE__DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_A", 5010 }, + { "DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_A", "EVENT_TYPE__DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_A", 5011 }, + { "DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_B", "EVENT_TYPE__DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_B", 5012 }, + { "DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_B", "EVENT_TYPE__DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_B", 5013 }, + { "DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_B", "EVENT_TYPE__DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_B", 5014 }, + { "DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_B", "EVENT_TYPE__DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_B", 5015 }, + { "DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_B", "EVENT_TYPE__DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_B", 5016 }, + { "DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_B", "EVENT_TYPE__DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_B", 5017 }, + { "DYEING_HEAD_ZONE_1_CURRENT_OUT_OF_RANGE", "EVENT_TYPE__DYEING_HEAD_ZONE_1_CURRENT_OUT_OF_RANGE", 5018 }, + { "DYEING_HEAD_ZONE_2_CURRENT_OUT_OF_RANGE", "EVENT_TYPE__DYEING_HEAD_ZONE_2_CURRENT_OUT_OF_RANGE", 5019 }, + { "DYEING_HEAD_ZONE_3_CURRENT_OUT_OF_RANGE", "EVENT_TYPE__DYEING_HEAD_ZONE_3_CURRENT_OUT_OF_RANGE", 5020 }, + { "DYEING_HEAD_ZONE_4_CURRENT_OUT_OF_RANGE", "EVENT_TYPE__DYEING_HEAD_ZONE_4_CURRENT_OUT_OF_RANGE", 5021 }, + { "DYEING_HEAD_ZONE_5_6_CURRENT_OUT_OF_RANGE", "EVENT_TYPE__DYEING_HEAD_ZONE_5_6_CURRENT_OUT_OF_RANGE", 5022 }, + { "DYEING_HEAD_ZONE_1_CURRENT_LOOP_BREAK", "EVENT_TYPE__DYEING_HEAD_ZONE_1_CURRENT_LOOP_BREAK", 5023 }, + { "DYEING_HEAD_ZONE_2_CURRENT_LOOP_BREAK", "EVENT_TYPE__DYEING_HEAD_ZONE_2_CURRENT_LOOP_BREAK", 5024 }, + { "DYEING_HEAD_ZONE_3_CURRENT_LOOP_BREAK", "EVENT_TYPE__DYEING_HEAD_ZONE_3_CURRENT_LOOP_BREAK", 5025 }, + { "DYEING_HEAD_ZONE_4_CURRENT_LOOP_BREAK", "EVENT_TYPE__DYEING_HEAD_ZONE_4_CURRENT_LOOP_BREAK", 5026 }, + { "DYEING_HEAD_ZONE_5_6_CURRENT_LOOP_BREAK", "EVENT_TYPE__DYEING_HEAD_ZONE_5_6_CURRENT_LOOP_BREAK", 5027 }, + { "DYEING_HEAD_THERMAL_CUTOFF", "EVENT_TYPE__DYEING_HEAD_THERMAL_CUTOFF", 5028 }, + { "DYEING_HEAD_COVER_OPEN_TIMEOUT", "EVENT_TYPE__DYEING_HEAD_COVER_OPEN_TIMEOUT", 5029 }, + { "DYEING_HEAD_COVER_CLOSE_TIMEOUT", "EVENT_TYPE__DYEING_HEAD_COVER_CLOSE_TIMEOUT", 5030 }, + { "DYEING_HEAD_COVER_MOTOR_OVERCURRENT", "EVENT_TYPE__DYEING_HEAD_COVER_MOTOR_OVERCURRENT", 5031 }, + { "DYEING_HEAD_COVER_MOTOR_OVERTEMPERATURE", "EVENT_TYPE__DYEING_HEAD_COVER_MOTOR_OVERTEMPERATURE", 5032 }, + { "DYEING_HEAD_COVER_MOTOR_STALL", "EVENT_TYPE__DYEING_HEAD_COVER_MOTOR_STALL", 5033 }, + { "DYEING_HEAD_COVER_MOTOR_UNDERVOLTAGE", "EVENT_TYPE__DYEING_HEAD_COVER_MOTOR_UNDERVOLTAGE", 5034 }, + { "DYEING_HEAD_CLEANING_MECHANISM_MOTOR_OVERCURRENT", "EVENT_TYPE__DYEING_HEAD_CLEANING_MECHANISM_MOTOR_OVERCURRENT", 5035 }, + { "DYEING_HEAD_CLEANING_MECHANISM_MOTOR_OVERTEMPERATURE", "EVENT_TYPE__DYEING_HEAD_CLEANING_MECHANISM_MOTOR_OVERTEMPERATURE", 5036 }, + { "DYEING_HEAD_CLEANING_MECHANISM_MOTOR_STALL", "EVENT_TYPE__DYEING_HEAD_CLEANING_MECHANISM_MOTOR_STALL", 5037 }, + { "DYEING_HEAD_CLEANING_MECHANISM_MOTOR_UNDERVOLTAGE", "EVENT_TYPE__DYEING_HEAD_CLEANING_MECHANISM_MOTOR_UNDERVOLTAGE", 5038 }, + { "DYEING_HEAD_CLEANING_HEAD_MOTOR_OVERCURRENT", "EVENT_TYPE__DYEING_HEAD_CLEANING_HEAD_MOTOR_OVERCURRENT", 5039 }, + { "DYEING_HEAD_CLEANING_HEAD_MOTOR_OVERTEMPERATURE", "EVENT_TYPE__DYEING_HEAD_CLEANING_HEAD_MOTOR_OVERTEMPERATURE", 5040 }, + { "DYEING_HEAD_CLEANING_HEAD_MOTOR_STALL", "EVENT_TYPE__DYEING_HEAD_CLEANING_HEAD_MOTOR_STALL", 5041 }, + { "DYEING_HEAD_CLEANING_HEAD_MOTOR_UNDERVOLTAGE", "EVENT_TYPE__DYEING_HEAD_CLEANING_HEAD_MOTOR_UNDERVOLTAGE", 5042 }, + { "MIXER_OVERTEMPERATURE", "EVENT_TYPE__MIXER_OVERTEMPERATURE", 6000 }, + { "MIXER_UNDERTEMPERATURE_A", "EVENT_TYPE__MIXER_UNDERTEMPERATURE_A", 6001 }, + { "MIXER_UNDERTEMPERATURE_B", "EVENT_TYPE__MIXER_UNDERTEMPERATURE_B", 6002 }, + { "MIXER_THERMAL_CUTOFF", "EVENT_TYPE__MIXER_THERMAL_CUTOFF", 6003 }, + { "MIXER_CURRENT_OUT_OF_RANGE", "EVENT_TYPE__MIXER_CURRENT_OUT_OF_RANGE", 6004 }, + { "MIXER_CURRENT_LOOP_BREAK", "EVENT_TYPE__MIXER_CURRENT_LOOP_BREAK", 6005 }, + { "DISPENSER_1_OVERPRESSURE", "EVENT_TYPE__DISPENSER_1_OVERPRESSURE", 7000 }, + { "DISPENSER_2_OVERPRESSURE", "EVENT_TYPE__DISPENSER_2_OVERPRESSURE", 7001 }, + { "DISPENSER_3_OVERPRESSURE", "EVENT_TYPE__DISPENSER_3_OVERPRESSURE", 7002 }, + { "DISPENSER_4_OVERPRESSURE", "EVENT_TYPE__DISPENSER_4_OVERPRESSURE", 7003 }, + { "DISPENSER_5_OVERPRESSURE", "EVENT_TYPE__DISPENSER_5_OVERPRESSURE", 7004 }, + { "DISPENSER_6_OVERPRESSURE", "EVENT_TYPE__DISPENSER_6_OVERPRESSURE", 7005 }, + { "DISPENSER_7_OVERPRESSURE", "EVENT_TYPE__DISPENSER_7_OVERPRESSURE", 7006 }, + { "DISPENSER_8_OVERPRESSURE", "EVENT_TYPE__DISPENSER_8_OVERPRESSURE", 7007 }, + { "DISPENSER_1_UNDERPRESSURE", "EVENT_TYPE__DISPENSER_1_UNDERPRESSURE", 7008 }, + { "DISPENSER_2_UNDERPRESSURE", "EVENT_TYPE__DISPENSER_2_UNDERPRESSURE", 7009 }, + { "DISPENSER_3_UNDERPRESSURE", "EVENT_TYPE__DISPENSER_3_UNDERPRESSURE", 7010 }, + { "DISPENSER_4_UNDERPRESSURE", "EVENT_TYPE__DISPENSER_4_UNDERPRESSURE", 7011 }, + { "DISPENSER_5_UNDERPRESSURE", "EVENT_TYPE__DISPENSER_5_UNDERPRESSURE", 7012 }, + { "DISPENSER_6_UNDERPRESSURE", "EVENT_TYPE__DISPENSER_6_UNDERPRESSURE", 7013 }, + { "DISPENSER_7_UNDERPRESSURE", "EVENT_TYPE__DISPENSER_7_UNDERPRESSURE", 7014 }, + { "DISPENSER_8_UNDERPRESSURE", "EVENT_TYPE__DISPENSER_8_UNDERPRESSURE", 7015 }, + { "DISPENSER_1_EMPTY", "EVENT_TYPE__DISPENSER_1_EMPTY", 7016 }, + { "DISPENSER_2_EMPTY", "EVENT_TYPE__DISPENSER_2_EMPTY", 7017 }, + { "DISPENSER_3_EMPTY", "EVENT_TYPE__DISPENSER_3_EMPTY", 7018 }, + { "DISPENSER_4_EMPTY", "EVENT_TYPE__DISPENSER_4_EMPTY", 7019 }, + { "DISPENSER_5_EMPTY", "EVENT_TYPE__DISPENSER_5_EMPTY", 7020 }, + { "DISPENSER_6_EMPTY", "EVENT_TYPE__DISPENSER_6_EMPTY", 7021 }, + { "DISPENSER_7_EMPTY", "EVENT_TYPE__DISPENSER_7_EMPTY", 7022 }, + { "DISPENSER_8_EMPTY", "EVENT_TYPE__DISPENSER_8_EMPTY", 7023 }, + { "DISPENSER_1_REFILL_FAILURE", "EVENT_TYPE__DISPENSER_1_REFILL_FAILURE", 7024 }, + { "DISPENSER_2_REFILL_FAILURE", "EVENT_TYPE__DISPENSER_2_REFILL_FAILURE", 7025 }, + { "DISPENSER_3_REFILL_FAILURE", "EVENT_TYPE__DISPENSER_3_REFILL_FAILURE", 7026 }, + { "DISPENSER_4_REFILL_FAILURE", "EVENT_TYPE__DISPENSER_4_REFILL_FAILURE", 7027 }, + { "DISPENSER_5_REFILL_FAILURE", "EVENT_TYPE__DISPENSER_5_REFILL_FAILURE", 7028 }, + { "DISPENSER_6_REFILL_FAILURE", "EVENT_TYPE__DISPENSER_6_REFILL_FAILURE", 7029 }, + { "DISPENSER_7_REFILL_FAILURE", "EVENT_TYPE__DISPENSER_7_REFILL_FAILURE", 7030 }, + { "DISPENSER_8_REFILL_FAILURE", "EVENT_TYPE__DISPENSER_8_REFILL_FAILURE", 7031 }, + { "DISPENSER_1_MOTOR_OVERCURRENT", "EVENT_TYPE__DISPENSER_1_MOTOR_OVERCURRENT", 7032 }, + { "DISPENSER_2_MOTOR_OVERCURRENT", "EVENT_TYPE__DISPENSER_2_MOTOR_OVERCURRENT", 7033 }, + { "DISPENSER_3_MOTOR_OVERCURRENT", "EVENT_TYPE__DISPENSER_3_MOTOR_OVERCURRENT", 7034 }, + { "DISPENSER_4_MOTOR_OVERCURRENT", "EVENT_TYPE__DISPENSER_4_MOTOR_OVERCURRENT", 7035 }, + { "DISPENSER_5_MOTOR_OVERCURRENT", "EVENT_TYPE__DISPENSER_5_MOTOR_OVERCURRENT", 7036 }, + { "DISPENSER_6_MOTOR_OVERCURRENT", "EVENT_TYPE__DISPENSER_6_MOTOR_OVERCURRENT", 7037 }, + { "DISPENSER_7_MOTOR_OVERCURRENT", "EVENT_TYPE__DISPENSER_7_MOTOR_OVERCURRENT", 7038 }, + { "DISPENSER_8_MOTOR_OVERCURRENT", "EVENT_TYPE__DISPENSER_8_MOTOR_OVERCURRENT", 7039 }, + { "DISPENSER_1_MOTOR_OVERTEMPERATURE", "EVENT_TYPE__DISPENSER_1_MOTOR_OVERTEMPERATURE", 7040 }, + { "DISPENSER_2_MOTOR_OVERTEMPERATURE", "EVENT_TYPE__DISPENSER_2_MOTOR_OVERTEMPERATURE", 7041 }, + { "DISPENSER_3_MOTOR_OVERTEMPERATURE", "EVENT_TYPE__DISPENSER_3_MOTOR_OVERTEMPERATURE", 7042 }, + { "DISPENSER_4_MOTOR_OVERTEMPERATURE", "EVENT_TYPE__DISPENSER_4_MOTOR_OVERTEMPERATURE", 7043 }, + { "DISPENSER_5_MOTOR_OVERTEMPERATURE", "EVENT_TYPE__DISPENSER_5_MOTOR_OVERTEMPERATURE", 7044 }, + { "DISPENSER_6_MOTOR_OVERTEMPERATURE", "EVENT_TYPE__DISPENSER_6_MOTOR_OVERTEMPERATURE", 7045 }, + { "DISPENSER_7_MOTOR_OVERTEMPERATURE", "EVENT_TYPE__DISPENSER_7_MOTOR_OVERTEMPERATURE", 7046 }, + { "DISPENSER_8_MOTOR_OVERTEMPERATURE", "EVENT_TYPE__DISPENSER_8_MOTOR_OVERTEMPERATURE", 7047 }, + { "DISPENSER_1_MOTOR_STALL", "EVENT_TYPE__DISPENSER_1_MOTOR_STALL", 7048 }, + { "DISPENSER_2_MOTOR_STALL", "EVENT_TYPE__DISPENSER_2_MOTOR_STALL", 7049 }, + { "DISPENSER_3_MOTOR_STALL", "EVENT_TYPE__DISPENSER_3_MOTOR_STALL", 7050 }, + { "DISPENSER_4_MOTOR_STALL", "EVENT_TYPE__DISPENSER_4_MOTOR_STALL", 7051 }, + { "DISPENSER_5_MOTOR_STALL", "EVENT_TYPE__DISPENSER_5_MOTOR_STALL", 7052 }, + { "DISPENSER_6_MOTOR_STALL", "EVENT_TYPE__DISPENSER_6_MOTOR_STALL", 7053 }, + { "DISPENSER_7_MOTOR_STALL", "EVENT_TYPE__DISPENSER_7_MOTOR_STALL", 7054 }, + { "DISPENSER_8_MOTOR_STALL", "EVENT_TYPE__DISPENSER_8_MOTOR_STALL", 7055 }, + { "DISPENSER_1_MOTOR_UNDERVOLTAGE", "EVENT_TYPE__DISPENSER_1_MOTOR_UNDERVOLTAGE", 7056 }, + { "DISPENSER_2_MOTOR_UNDERVOLTAGE", "EVENT_TYPE__DISPENSER_2_MOTOR_UNDERVOLTAGE", 7057 }, + { "DISPENSER_3_MOTOR_UNDERVOLTAGE", "EVENT_TYPE__DISPENSER_3_MOTOR_UNDERVOLTAGE", 7058 }, + { "DISPENSER_4_MOTOR_UNDERVOLTAGE", "EVENT_TYPE__DISPENSER_4_MOTOR_UNDERVOLTAGE", 7059 }, + { "DISPENSER_5_MOTOR_UNDERVOLTAGE", "EVENT_TYPE__DISPENSER_5_MOTOR_UNDERVOLTAGE", 7060 }, + { "DISPENSER_6_MOTOR_UNDERVOLTAGE", "EVENT_TYPE__DISPENSER_6_MOTOR_UNDERVOLTAGE", 7061 }, + { "DISPENSER_7_MOTOR_UNDERVOLTAGE", "EVENT_TYPE__DISPENSER_7_MOTOR_UNDERVOLTAGE", 7062 }, + { "DISPENSER_8_MOTOR_UNDERVOLTAGE", "EVENT_TYPE__DISPENSER_8_MOTOR_UNDERVOLTAGE", 7063 }, + { "DISPENSER_1_UPPER_HARD_LIMIT", "EVENT_TYPE__DISPENSER_1_UPPER_HARD_LIMIT", 7064 }, + { "DISPENSER_2_UPPER_HARD_LIMIT", "EVENT_TYPE__DISPENSER_2_UPPER_HARD_LIMIT", 7065 }, + { "DISPENSER_3_UPPER_HARD_LIMIT", "EVENT_TYPE__DISPENSER_3_UPPER_HARD_LIMIT", 7066 }, + { "DISPENSER_4_UPPER_HARD_LIMIT", "EVENT_TYPE__DISPENSER_4_UPPER_HARD_LIMIT", 7067 }, + { "DISPENSER_5_UPPER_HARD_LIMIT", "EVENT_TYPE__DISPENSER_5_UPPER_HARD_LIMIT", 7068 }, + { "DISPENSER_6_UPPER_HARD_LIMIT", "EVENT_TYPE__DISPENSER_6_UPPER_HARD_LIMIT", 7069 }, + { "DISPENSER_7_UPPER_HARD_LIMIT", "EVENT_TYPE__DISPENSER_7_UPPER_HARD_LIMIT", 7070 }, + { "DISPENSER_8_UPPER_HARD_LIMIT", "EVENT_TYPE__DISPENSER_8_UPPER_HARD_LIMIT", 7071 }, + { "DISPENSER_1_LOWER_HARD_LIMIT", "EVENT_TYPE__DISPENSER_1_LOWER_HARD_LIMIT", 7072 }, + { "DISPENSER_2_LOWER_HARD_LIMIT", "EVENT_TYPE__DISPENSER_2_LOWER_HARD_LIMIT", 7073 }, + { "DISPENSER_3_LOWER_HARD_LIMIT", "EVENT_TYPE__DISPENSER_3_LOWER_HARD_LIMIT", 7074 }, + { "DISPENSER_4_LOWER_HARD_LIMIT", "EVENT_TYPE__DISPENSER_4_LOWER_HARD_LIMIT", 7075 }, + { "DISPENSER_5_LOWER_HARD_LIMIT", "EVENT_TYPE__DISPENSER_5_LOWER_HARD_LIMIT", 7076 }, + { "DISPENSER_6_LOWER_HARD_LIMIT", "EVENT_TYPE__DISPENSER_6_LOWER_HARD_LIMIT", 7077 }, + { "DISPENSER_7_LOWER_HARD_LIMIT", "EVENT_TYPE__DISPENSER_7_LOWER_HARD_LIMIT", 7078 }, + { "DISPENSER_8_LOWER_HARD_LIMIT", "EVENT_TYPE__DISPENSER_8_LOWER_HARD_LIMIT", 7079 }, + { "DISPENSER_1_HIGH_PRESSURE", "EVENT_TYPE__DISPENSER_1_HIGH_PRESSURE", 7080 }, + { "DISPENSER_2_HIGH_PRESSURE", "EVENT_TYPE__DISPENSER_2_HIGH_PRESSURE", 7081 }, + { "DISPENSER_3_HIGH_PRESSURE", "EVENT_TYPE__DISPENSER_3_HIGH_PRESSURE", 7082 }, + { "DISPENSER_4_HIGH_PRESSURE", "EVENT_TYPE__DISPENSER_4_HIGH_PRESSURE", 7083 }, + { "DISPENSER_5_HIGH_PRESSURE", "EVENT_TYPE__DISPENSER_5_HIGH_PRESSURE", 7084 }, + { "DISPENSER_6_HIGH_PRESSURE", "EVENT_TYPE__DISPENSER_6_HIGH_PRESSURE", 7085 }, + { "DISPENSER_8_HIGH_PRESSURE", "EVENT_TYPE__DISPENSER_8_HIGH_PRESSURE", 7086 }, + { "DISPENSER_7_HIGH_PRESSURE", "EVENT_TYPE__DISPENSER_7_HIGH_PRESSURE", 7087 }, + { "MID_TANK_1_LOW_LEVEL", "EVENT_TYPE__MID_TANK_1_LOW_LEVEL", 8000 }, + { "MID_TANK_2_LOW_LEVEL", "EVENT_TYPE__MID_TANK_2_LOW_LEVEL", 8001 }, + { "MID_TANK_3_LOW_LEVEL", "EVENT_TYPE__MID_TANK_3_LOW_LEVEL", 8002 }, + { "MID_TANK_4_LOW_LEVEL", "EVENT_TYPE__MID_TANK_4_LOW_LEVEL", 8003 }, + { "MID_TANK_5_LOW_LEVEL", "EVENT_TYPE__MID_TANK_5_LOW_LEVEL", 8004 }, + { "MID_TANK_6_LOW_LEVEL", "EVENT_TYPE__MID_TANK_6_LOW_LEVEL", 8005 }, + { "MID_TANK_7_LOW_LEVEL", "EVENT_TYPE__MID_TANK_7_LOW_LEVEL", 8006 }, + { "MID_TANK_8_LOW_LEVEL", "EVENT_TYPE__MID_TANK_8_LOW_LEVEL", 8007 }, + { "MID_TANK_1_EMPTY", "EVENT_TYPE__MID_TANK_1_EMPTY", 8008 }, + { "MID_TANK_2_EMPTY", "EVENT_TYPE__MID_TANK_2_EMPTY", 8009 }, + { "MID_TANK_3_EMPTY", "EVENT_TYPE__MID_TANK_3_EMPTY", 8010 }, + { "MID_TANK_4_EMPTY", "EVENT_TYPE__MID_TANK_4_EMPTY", 8011 }, + { "MID_TANK_5_EMPTY", "EVENT_TYPE__MID_TANK_5_EMPTY", 8012 }, + { "MID_TANK_6_EMPTY", "EVENT_TYPE__MID_TANK_6_EMPTY", 8013 }, + { "MID_TANK_7_EMPTY", "EVENT_TYPE__MID_TANK_7_EMPTY", 8014 }, + { "MID_TANK_8_EMPTY", "EVENT_TYPE__MID_TANK_8_EMPTY", 8015 }, + { "MID_TANK_1_OVERFLOW", "EVENT_TYPE__MID_TANK_1_OVERFLOW", 8016 }, + { "MID_TANK_2_OVERFLOW", "EVENT_TYPE__MID_TANK_2_OVERFLOW", 8017 }, + { "MID_TANK_3_OVERFLOW", "EVENT_TYPE__MID_TANK_3_OVERFLOW", 8018 }, + { "MID_TANK_4_OVERFLOW", "EVENT_TYPE__MID_TANK_4_OVERFLOW", 8019 }, + { "MID_TANK_5_OVERFLOW", "EVENT_TYPE__MID_TANK_5_OVERFLOW", 8020 }, + { "MID_TANK_6_OVERFLOW", "EVENT_TYPE__MID_TANK_6_OVERFLOW", 8021 }, + { "MID_TANK_7_OVERFLOW", "EVENT_TYPE__MID_TANK_7_OVERFLOW", 8022 }, + { "MID_TANK_8_OVERFLOW", "EVENT_TYPE__MID_TANK_8_OVERFLOW", 8023 }, + { "MID_TANK_1_FILL_TIMEOUT", "EVENT_TYPE__MID_TANK_1_FILL_TIMEOUT", 8024 }, + { "MID_TANK_2_FILL_TIMEOUT", "EVENT_TYPE__MID_TANK_2_FILL_TIMEOUT", 8025 }, + { "MID_TANK_3_FILL_TIMEOUT", "EVENT_TYPE__MID_TANK_3_FILL_TIMEOUT", 8026 }, + { "MID_TANK_4_FILL_TIMEOUT", "EVENT_TYPE__MID_TANK_4_FILL_TIMEOUT", 8027 }, + { "MID_TANK_5_FILL_TIMEOUT", "EVENT_TYPE__MID_TANK_5_FILL_TIMEOUT", 8028 }, + { "MID_TANK_6_FILL_TIMEOUT", "EVENT_TYPE__MID_TANK_6_FILL_TIMEOUT", 8029 }, + { "MID_TANK_7_FILL_TIMEOUT", "EVENT_TYPE__MID_TANK_7_FILL_TIMEOUT", 8030 }, + { "MID_TANK_8_FILL_TIMEOUT", "EVENT_TYPE__MID_TANK_8_FILL_TIMEOUT", 8031 }, + { "AIR_FILTER_NOT_INSTALLED", "EVENT_TYPE__AIR_FILTER_NOT_INSTALLED", 9000 }, + { "AIR_FILTER_CLOGGED", "EVENT_TYPE__AIR_FILTER_CLOGGED", 9001 }, + { "WASTE_CONTAINER_EMPTYING_TIMEOUT", "EVENT_TYPE__WASTE_CONTAINER_EMPTYING_TIMEOUT", 9002 }, + { "NO_AIR_PRESSURE", "EVENT_TYPE__NO_AIR_PRESSURE", 9003 }, + { "WASTE_CONTAINER_OVERFLOW", "EVENT_TYPE__WASTE_CONTAINER_OVERFLOW", 9004 }, + { "VOC_SENSOR_ALARM", "EVENT_TYPE__VOC_SENSOR_ALARM", 9005 }, + { "CHILLER_DRY_CONTACT", "EVENT_TYPE__CHILLER_DRY_CONTACT", 9006 }, + { "INSUFFICIENT_AIR_FLOW", "EVENT_TYPE__INSUFFICIENT_AIR_FLOW", 9007 }, + { "INK_CARTRIDGE_PRESENCE_SENSOR_TIMEOUT", "EVENT_TYPE__INK_CARTRIDGE_PRESENCE_SENSOR_TIMEOUT", 10000 }, + { "INK_CARTRIDGE_RFID_TIMEOUT", "EVENT_TYPE__INK_CARTRIDGE_RFID_TIMEOUT", 10001 }, + { "NO_WASTE_CARTRIDGE_AVAILABLE", "EVENT_TYPE__NO_WASTE_CARTRIDGE_AVAILABLE", 10002 }, + { "ALL_WASTE_CARTRIDGES_FULL", "EVENT_TYPE__ALL_WASTE_CARTRIDGES_FULL", 10003 }, + { "WASTE_CARTRIDGE_PRESENCE_SENSOR_TIMEOUT", "EVENT_TYPE__WASTE_CARTRIDGE_PRESENCE_SENSOR_TIMEOUT", 10004 }, + { "WASTE_CARTRIDGE_RFID_TIMEOUT", "EVENT_TYPE__WASTE_CARTRIDGE_RFID_TIMEOUT", 10005 }, }; static const ProtobufCIntRange event_type__value_ranges[] = { -{0, 0},{1000, 207},{0, 217} +{0, 0},{1000, 1},{2000, 11},{3000, 24},{4000, 74},{5000, 96},{6000, 139},{7000, 145},{8000, 233},{9000, 265},{10000, 273},{0, 279} }; -static const ProtobufCEnumValueIndex event_type__enum_values_by_name[217] = +static const ProtobufCEnumValueIndex event_type__enum_values_by_name[279] = { - { "AIR_FILTER_CLOGGED", 192 }, - { "AIR_FILTER_NOT_INSTALLED", 191 }, - { "ALL_WASTE_CARTRIDGES_FULL", 202 }, - { "APPLICATION_EXCEPTION", 210 }, - { "APPLICATION_INFORMATION", 211 }, - { "APPLICATION_STARTED", 212 }, - { "APPLICATION_TERMINATED", 213 }, - { "CARTRIDGES_COVER_OPEN", 7 }, - { "CHILLER_DRY_CONTACT", 197 }, - { "DISPENSER_1_EMPTY", 119 }, - { "DISPENSER_1_MOTOR_OVERCURRENT", 135 }, - { "DISPENSER_1_MOTOR_OVERTEMPERATURE", 143 }, - { "DISPENSER_1_MOTOR_STALL", 151 }, - { "DISPENSER_1_MOTOR_UNDERVOLTAGE", 159 }, - { "DISPENSER_1_OVERPRESSURE", 103 }, - { "DISPENSER_1_REFILL_FAILURE", 127 }, - { "DISPENSER_1_UNDERPRESSURE", 111 }, - { "DISPENSER_2_EMPTY", 120 }, - { "DISPENSER_2_MOTOR_OVERCURRENT", 136 }, - { "DISPENSER_2_MOTOR_OVERTEMPERATURE", 144 }, - { "DISPENSER_2_MOTOR_STALL", 152 }, - { "DISPENSER_2_MOTOR_UNDERVOLTAGE", 160 }, - { "DISPENSER_2_OVERPRESSURE", 104 }, - { "DISPENSER_2_REFILL_FAILURE", 128 }, - { "DISPENSER_2_UNDERPRESSURE", 112 }, - { "DISPENSER_3_EMPTY", 121 }, - { "DISPENSER_3_MOTOR_OVERCURRENT", 137 }, - { "DISPENSER_3_MOTOR_OVERTEMPERATURE", 145 }, - { "DISPENSER_3_MOTOR_STALL", 153 }, - { "DISPENSER_3_MOTOR_UNDERVOLTAGE", 161 }, - { "DISPENSER_3_OVERPRESSURE", 105 }, - { "DISPENSER_3_REFILL_FAILURE", 129 }, - { "DISPENSER_3_UNDERPRESSURE", 113 }, - { "DISPENSER_4_EMPTY", 122 }, - { "DISPENSER_4_MOTOR_OVERCURRENT", 138 }, - { "DISPENSER_4_MOTOR_OVERTEMPERATURE", 146 }, - { "DISPENSER_4_MOTOR_STALL", 154 }, - { "DISPENSER_4_MOTOR_UNDERVOLTAGE", 162 }, - { "DISPENSER_4_OVERPRESSURE", 106 }, - { "DISPENSER_4_REFILL_FAILURE", 130 }, - { "DISPENSER_4_UNDERPRESSURE", 114 }, - { "DISPENSER_5_EMPTY", 123 }, - { "DISPENSER_5_MOTOR_OVERCURRENT", 139 }, - { "DISPENSER_5_MOTOR_OVERTEMPERATURE", 147 }, - { "DISPENSER_5_MOTOR_STALL", 155 }, - { "DISPENSER_5_MOTOR_UNDERVOLTAGE", 163 }, - { "DISPENSER_5_OVERPRESSURE", 107 }, - { "DISPENSER_5_REFILL_FAILURE", 131 }, - { "DISPENSER_5_UNDERPRESSURE", 115 }, - { "DISPENSER_6_EMPTY", 124 }, - { "DISPENSER_6_MOTOR_OVERCURRENT", 140 }, - { "DISPENSER_6_MOTOR_OVERTEMPERATURE", 148 }, - { "DISPENSER_6_MOTOR_STALL", 156 }, - { "DISPENSER_6_MOTOR_UNDERVOLTAGE", 164 }, - { "DISPENSER_6_OVERPRESSURE", 108 }, - { "DISPENSER_6_REFILL_FAILURE", 132 }, - { "DISPENSER_6_UNDERPRESSURE", 116 }, - { "DISPENSER_7_EMPTY", 125 }, - { "DISPENSER_7_MOTOR_OVERCURRENT", 141 }, - { "DISPENSER_7_MOTOR_OVERTEMPERATURE", 149 }, - { "DISPENSER_7_MOTOR_STALL", 157 }, - { "DISPENSER_7_MOTOR_UNDERVOLTAGE", 165 }, - { "DISPENSER_7_OVERPRESSURE", 109 }, - { "DISPENSER_7_REFILL_FAILURE", 133 }, - { "DISPENSER_7_UNDERPRESSURE", 117 }, - { "DISPENSER_8_EMPTY", 126 }, - { "DISPENSER_8_MOTOR_OVERCURRENT", 142 }, - { "DISPENSER_8_MOTOR_OVERTEMPERATURE", 150 }, - { "DISPENSER_8_MOTOR_STALL", 158 }, - { "DISPENSER_8_MOTOR_UNDERVOLTAGE", 166 }, - { "DISPENSER_8_OVERPRESSURE", 110 }, - { "DISPENSER_8_REFILL_FAILURE", 134 }, - { "DISPENSER_8_UNDERPRESSURE", 118 }, - { "DRYER_DOOR_OPEN", 52 }, - { "DRYER_FAN_RPM_TOO_LOW", 64 }, - { "DRYER_FAN_STOPPED", 65 }, - { "DRYER_HEATERS_ZONE_1_CURRENT_LOOP_BREAK", 62 }, - { "DRYER_HEATERS_ZONE_1_CURRENT_OUT_OF_RANGE", 60 }, - { "DRYER_HEATERS_ZONE_2_CURRENT_LOOP_BREAK", 63 }, - { "DRYER_HEATERS_ZONE_2_CURRENT_OUT_OF_RANGE", 61 }, - { "DRYER_MOTOR_OVERCURRENT", 48 }, - { "DRYER_MOTOR_OVERTEMPERATURE", 49 }, - { "DRYER_MOTOR_STALL", 50 }, - { "DRYER_MOTOR_UNDERVOLTAGE", 51 }, - { "DRYER_THERMAL_CUTOFF", 59 }, - { "DRYER_ZONE_1_OVERTEMPERATURE", 53 }, - { "DRYER_ZONE_1_UNDERTEMPERATURE_A", 55 }, - { "DRYER_ZONE_1_UNDERTEMPERATURE_B", 57 }, - { "DRYER_ZONE_2_OVERTEMPERATURE", 54 }, - { "DRYER_ZONE_2_UNDERTEMPERATURE_A", 56 }, - { "DRYER_ZONE_2_UNDERTEMPERATURE_B", 58 }, - { "DYEING_HEAD_COVER_CLOSE_TIMEOUT", 96 }, - { "DYEING_HEAD_COVER_OPEN_TIMEOUT", 95 }, - { "DYEING_HEAD_THERMAL_CUTOFF", 94 }, - { "DYEING_HEAD_ZONE_1_CURRENT_LOOP_BREAK", 89 }, - { "DYEING_HEAD_ZONE_1_CURRENT_OUT_OF_RANGE", 84 }, - { "DYEING_HEAD_ZONE_1_OVERTEMPERATURE", 66 }, - { "DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_A", 72 }, - { "DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_B", 78 }, - { "DYEING_HEAD_ZONE_2_CURRENT_LOOP_BREAK", 90 }, - { "DYEING_HEAD_ZONE_2_CURRENT_OUT_OF_RANGE", 85 }, - { "DYEING_HEAD_ZONE_2_OVERTEMPERATURE", 67 }, - { "DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_A", 73 }, - { "DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_B", 79 }, - { "DYEING_HEAD_ZONE_3_CURRENT_LOOP_BREAK", 91 }, - { "DYEING_HEAD_ZONE_3_CURRENT_OUT_OF_RANGE", 86 }, - { "DYEING_HEAD_ZONE_3_OVERTEMPERATURE", 68 }, - { "DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_A", 74 }, - { "DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_B", 80 }, - { "DYEING_HEAD_ZONE_4_CURRENT_LOOP_BREAK", 92 }, - { "DYEING_HEAD_ZONE_4_CURRENT_OUT_OF_RANGE", 87 }, - { "DYEING_HEAD_ZONE_4_OVERTEMPERATURE", 69 }, - { "DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_A", 75 }, - { "DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_B", 81 }, - { "DYEING_HEAD_ZONE_5_6_CURRENT_LOOP_BREAK", 93 }, - { "DYEING_HEAD_ZONE_5_6_CURRENT_OUT_OF_RANGE", 88 }, - { "DYEING_HEAD_ZONE_5_OVERTEMPERATURE", 70 }, - { "DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_A", 76 }, - { "DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_B", 82 }, - { "DYEING_HEAD_ZONE_6_OVERTEMPERATURE", 71 }, - { "DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_A", 77 }, - { "DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_B", 83 }, - { "ELECTRICAL_CABINET_FANS_RPM_TOO_LOW", 205 }, - { "ELECTRICAL_CABINET_FANS_STOPPED", 206 }, - { "EMERGENCY_PUSH_BUTTON_PRESSED", 2 }, - { "FEEDER_MOTOR_OVERCURRENT", 15 }, - { "FEEDER_MOTOR_OVERTEMPERATURE", 22 }, - { "FEEDER_MOTOR_STALL", 29 }, - { "FEEDER_MOTOR_UNDERVOLTAGE", 36 }, - { "FRONT_COVER_1_OPEN", 3 }, - { "FRONT_COVER_2_OPEN", 4 }, - { "FRONT_COVER_3_OPEN", 5 }, - { "FRONT_COVER_4_OPEN", 6 }, - { "INK_CARTRIDGE_PRESENCE_SENSOR_TIMEOUT", 199 }, - { "INK_CARTRIDGE_RFID_TIMEOUT", 200 }, - { "INSUFFICIENT_AIR_FLOW", 198 }, - { "JOB_STATUS", 216 }, - { "LEFT_LOADER_MOTOR_OVERCURRENT", 18 }, - { "LEFT_LOADER_MOTOR_OVERTEMPERATURE", 25 }, - { "LEFT_LOADER_MOTOR_STALL", 32 }, - { "LEFT_LOADER_MOTOR_UNDERVOLTAGE", 39 }, - { "LOADING_ARM_MOTOR_OVERCURRENT", 21 }, - { "LOADING_ARM_MOTOR_OVERTEMPERATURE", 28 }, - { "LOADING_ARM_MOTOR_STALL", 35 }, - { "LOADING_ARM_MOTOR_UNDERVOLTAGE", 42 }, - { "LTFU_DOWN_TIMEOUT", 44 }, - { "LTFU_UP_TIMEOUT", 43 }, - { "MACHINE_FANS_RPM_TOO_LOW", 10 }, - { "MACHINE_FANS_STOPPED", 11 }, - { "MACHINE_INTERNAL_OVERTEMPERATURE", 9 }, - { "MID_TANK_1_EMPTY", 175 }, - { "MID_TANK_1_LOW_LEVEL", 167 }, - { "MID_TANK_1_OVERFLOW", 183 }, - { "MID_TANK_2_EMPTY", 176 }, - { "MID_TANK_2_LOW_LEVEL", 168 }, - { "MID_TANK_2_OVERFLOW", 184 }, - { "MID_TANK_3_EMPTY", 177 }, - { "MID_TANK_3_LOW_LEVEL", 169 }, - { "MID_TANK_3_OVERFLOW", 185 }, - { "MID_TANK_4_EMPTY", 178 }, - { "MID_TANK_4_LOW_LEVEL", 170 }, - { "MID_TANK_4_OVERFLOW", 186 }, - { "MID_TANK_5_EMPTY", 179 }, - { "MID_TANK_5_LOW_LEVEL", 171 }, - { "MID_TANK_5_OVERFLOW", 187 }, - { "MID_TANK_6_EMPTY", 180 }, - { "MID_TANK_6_LOW_LEVEL", 172 }, - { "MID_TANK_6_OVERFLOW", 188 }, - { "MID_TANK_7_EMPTY", 181 }, - { "MID_TANK_7_LOW_LEVEL", 173 }, - { "MID_TANK_7_OVERFLOW", 189 }, - { "MID_TANK_8_EMPTY", 182 }, - { "MID_TANK_8_LOW_LEVEL", 174 }, - { "MID_TANK_8_OVERFLOW", 190 }, - { "MIXER_CURRENT_LOOP_BREAK", 102 }, - { "MIXER_CURRENT_OUT_OF_RANGE", 101 }, - { "MIXER_OVERTEMPERATURE", 97 }, - { "MIXER_THERMAL_CUTOFF", 100 }, - { "MIXER_UNDERTEMPERATURE_A", 98 }, - { "MIXER_UNDERTEMPERATURE_B", 99 }, - { "NO_AIR_PRESSURE", 194 }, - { "NO_WASTE_CARTRIDGE_AVAILABLE", 201 }, + { "AIR_FILTER_CLOGGED", 266 }, + { "AIR_FILTER_NOT_INSTALLED", 265 }, + { "ALL_WASTE_CARTRIDGES_FULL", 276 }, + { "APPLICATION_EXCEPTION", 4 }, + { "APPLICATION_INFORMATION", 5 }, + { "APPLICATION_STARTED", 6 }, + { "APPLICATION_TERMINATED", 7 }, + { "CARTRIDGES_COVER_OPEN", 17 }, + { "CHILLER_DRY_CONTACT", 271 }, + { "DISPENSER_1_EMPTY", 161 }, + { "DISPENSER_1_HIGH_PRESSURE", 225 }, + { "DISPENSER_1_LOWER_HARD_LIMIT", 217 }, + { "DISPENSER_1_MOTOR_OVERCURRENT", 177 }, + { "DISPENSER_1_MOTOR_OVERTEMPERATURE", 185 }, + { "DISPENSER_1_MOTOR_STALL", 193 }, + { "DISPENSER_1_MOTOR_UNDERVOLTAGE", 201 }, + { "DISPENSER_1_OVERPRESSURE", 145 }, + { "DISPENSER_1_REFILL_FAILURE", 169 }, + { "DISPENSER_1_UNDERPRESSURE", 153 }, + { "DISPENSER_1_UPPER_HARD_LIMIT", 209 }, + { "DISPENSER_2_EMPTY", 162 }, + { "DISPENSER_2_HIGH_PRESSURE", 226 }, + { "DISPENSER_2_LOWER_HARD_LIMIT", 218 }, + { "DISPENSER_2_MOTOR_OVERCURRENT", 178 }, + { "DISPENSER_2_MOTOR_OVERTEMPERATURE", 186 }, + { "DISPENSER_2_MOTOR_STALL", 194 }, + { "DISPENSER_2_MOTOR_UNDERVOLTAGE", 202 }, + { "DISPENSER_2_OVERPRESSURE", 146 }, + { "DISPENSER_2_REFILL_FAILURE", 170 }, + { "DISPENSER_2_UNDERPRESSURE", 154 }, + { "DISPENSER_2_UPPER_HARD_LIMIT", 210 }, + { "DISPENSER_3_EMPTY", 163 }, + { "DISPENSER_3_HIGH_PRESSURE", 227 }, + { "DISPENSER_3_LOWER_HARD_LIMIT", 219 }, + { "DISPENSER_3_MOTOR_OVERCURRENT", 179 }, + { "DISPENSER_3_MOTOR_OVERTEMPERATURE", 187 }, + { "DISPENSER_3_MOTOR_STALL", 195 }, + { "DISPENSER_3_MOTOR_UNDERVOLTAGE", 203 }, + { "DISPENSER_3_OVERPRESSURE", 147 }, + { "DISPENSER_3_REFILL_FAILURE", 171 }, + { "DISPENSER_3_UNDERPRESSURE", 155 }, + { "DISPENSER_3_UPPER_HARD_LIMIT", 211 }, + { "DISPENSER_4_EMPTY", 164 }, + { "DISPENSER_4_HIGH_PRESSURE", 228 }, + { "DISPENSER_4_LOWER_HARD_LIMIT", 220 }, + { "DISPENSER_4_MOTOR_OVERCURRENT", 180 }, + { "DISPENSER_4_MOTOR_OVERTEMPERATURE", 188 }, + { "DISPENSER_4_MOTOR_STALL", 196 }, + { "DISPENSER_4_MOTOR_UNDERVOLTAGE", 204 }, + { "DISPENSER_4_OVERPRESSURE", 148 }, + { "DISPENSER_4_REFILL_FAILURE", 172 }, + { "DISPENSER_4_UNDERPRESSURE", 156 }, + { "DISPENSER_4_UPPER_HARD_LIMIT", 212 }, + { "DISPENSER_5_EMPTY", 165 }, + { "DISPENSER_5_HIGH_PRESSURE", 229 }, + { "DISPENSER_5_LOWER_HARD_LIMIT", 221 }, + { "DISPENSER_5_MOTOR_OVERCURRENT", 181 }, + { "DISPENSER_5_MOTOR_OVERTEMPERATURE", 189 }, + { "DISPENSER_5_MOTOR_STALL", 197 }, + { "DISPENSER_5_MOTOR_UNDERVOLTAGE", 205 }, + { "DISPENSER_5_OVERPRESSURE", 149 }, + { "DISPENSER_5_REFILL_FAILURE", 173 }, + { "DISPENSER_5_UNDERPRESSURE", 157 }, + { "DISPENSER_5_UPPER_HARD_LIMIT", 213 }, + { "DISPENSER_6_EMPTY", 166 }, + { "DISPENSER_6_HIGH_PRESSURE", 230 }, + { "DISPENSER_6_LOWER_HARD_LIMIT", 222 }, + { "DISPENSER_6_MOTOR_OVERCURRENT", 182 }, + { "DISPENSER_6_MOTOR_OVERTEMPERATURE", 190 }, + { "DISPENSER_6_MOTOR_STALL", 198 }, + { "DISPENSER_6_MOTOR_UNDERVOLTAGE", 206 }, + { "DISPENSER_6_OVERPRESSURE", 150 }, + { "DISPENSER_6_REFILL_FAILURE", 174 }, + { "DISPENSER_6_UNDERPRESSURE", 158 }, + { "DISPENSER_6_UPPER_HARD_LIMIT", 214 }, + { "DISPENSER_7_EMPTY", 167 }, + { "DISPENSER_7_HIGH_PRESSURE", 232 }, + { "DISPENSER_7_LOWER_HARD_LIMIT", 223 }, + { "DISPENSER_7_MOTOR_OVERCURRENT", 183 }, + { "DISPENSER_7_MOTOR_OVERTEMPERATURE", 191 }, + { "DISPENSER_7_MOTOR_STALL", 199 }, + { "DISPENSER_7_MOTOR_UNDERVOLTAGE", 207 }, + { "DISPENSER_7_OVERPRESSURE", 151 }, + { "DISPENSER_7_REFILL_FAILURE", 175 }, + { "DISPENSER_7_UNDERPRESSURE", 159 }, + { "DISPENSER_7_UPPER_HARD_LIMIT", 215 }, + { "DISPENSER_8_EMPTY", 168 }, + { "DISPENSER_8_HIGH_PRESSURE", 231 }, + { "DISPENSER_8_LOWER_HARD_LIMIT", 224 }, + { "DISPENSER_8_MOTOR_OVERCURRENT", 184 }, + { "DISPENSER_8_MOTOR_OVERTEMPERATURE", 192 }, + { "DISPENSER_8_MOTOR_STALL", 200 }, + { "DISPENSER_8_MOTOR_UNDERVOLTAGE", 208 }, + { "DISPENSER_8_OVERPRESSURE", 152 }, + { "DISPENSER_8_REFILL_FAILURE", 176 }, + { "DISPENSER_8_UNDERPRESSURE", 160 }, + { "DISPENSER_8_UPPER_HARD_LIMIT", 216 }, + { "DRYER_DOOR_OPEN", 78 }, + { "DRYER_FAN_RPM_TOO_LOW", 89 }, + { "DRYER_FAN_STOPPED", 90 }, + { "DRYER_HEATERS_ZONE_1_CURRENT_LOOP_BREAK", 87 }, + { "DRYER_HEATERS_ZONE_1_CURRENT_OUT_OF_RANGE", 85 }, + { "DRYER_HEATERS_ZONE_2_CURRENT_LOOP_BREAK", 88 }, + { "DRYER_HEATERS_ZONE_2_CURRENT_OUT_OF_RANGE", 86 }, + { "DRYER_LID_MOTOR_OVERCURRENT", 91 }, + { "DRYER_LID_MOTOR_OVERTEMPERATURE", 92 }, + { "DRYER_LID_MOTOR_STALL", 93 }, + { "DRYER_LID_MOTOR_UNDERVOLTAGE", 94 }, + { "DRYER_MOTOR_OVERCURRENT", 74 }, + { "DRYER_MOTOR_OVERTEMPERATURE", 75 }, + { "DRYER_MOTOR_STALL", 76 }, + { "DRYER_MOTOR_UNDERVOLTAGE", 77 }, + { "DRYER_THERMAL_CUTOFF", 84 }, + { "DRYER_ZONE_1_OVERTEMPERATURE", 79 }, + { "DRYER_ZONE_1_UNDERTEMPERATURE_A", 81 }, + { "DRYER_ZONE_1_UNDERTEMPERATURE_B", 82 }, + { "DRYER_ZONE_2_OVERTEMPERATURE", 80 }, + { "DRYER_ZONE_2_UNDERTEMPERATURE_A", 95 }, + { "DRYER_ZONE_2_UNDERTEMPERATURE_B", 83 }, + { "DYEING_HEAD_CLEANING_HEAD_MOTOR_OVERCURRENT", 135 }, + { "DYEING_HEAD_CLEANING_HEAD_MOTOR_OVERTEMPERATURE", 136 }, + { "DYEING_HEAD_CLEANING_HEAD_MOTOR_STALL", 137 }, + { "DYEING_HEAD_CLEANING_HEAD_MOTOR_UNDERVOLTAGE", 138 }, + { "DYEING_HEAD_CLEANING_MECHANISM_MOTOR_OVERCURRENT", 131 }, + { "DYEING_HEAD_CLEANING_MECHANISM_MOTOR_OVERTEMPERATURE", 132 }, + { "DYEING_HEAD_CLEANING_MECHANISM_MOTOR_STALL", 133 }, + { "DYEING_HEAD_CLEANING_MECHANISM_MOTOR_UNDERVOLTAGE", 134 }, + { "DYEING_HEAD_COVER_CLOSE_TIMEOUT", 126 }, + { "DYEING_HEAD_COVER_MOTOR_OVERCURRENT", 127 }, + { "DYEING_HEAD_COVER_MOTOR_OVERTEMPERATURE", 128 }, + { "DYEING_HEAD_COVER_MOTOR_STALL", 129 }, + { "DYEING_HEAD_COVER_MOTOR_UNDERVOLTAGE", 130 }, + { "DYEING_HEAD_COVER_OPEN_TIMEOUT", 125 }, + { "DYEING_HEAD_THERMAL_CUTOFF", 124 }, + { "DYEING_HEAD_ZONE_1_CURRENT_LOOP_BREAK", 119 }, + { "DYEING_HEAD_ZONE_1_CURRENT_OUT_OF_RANGE", 114 }, + { "DYEING_HEAD_ZONE_1_OVERTEMPERATURE", 96 }, + { "DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_A", 102 }, + { "DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_B", 108 }, + { "DYEING_HEAD_ZONE_2_CURRENT_LOOP_BREAK", 120 }, + { "DYEING_HEAD_ZONE_2_CURRENT_OUT_OF_RANGE", 115 }, + { "DYEING_HEAD_ZONE_2_OVERTEMPERATURE", 97 }, + { "DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_A", 103 }, + { "DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_B", 109 }, + { "DYEING_HEAD_ZONE_3_CURRENT_LOOP_BREAK", 121 }, + { "DYEING_HEAD_ZONE_3_CURRENT_OUT_OF_RANGE", 116 }, + { "DYEING_HEAD_ZONE_3_OVERTEMPERATURE", 98 }, + { "DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_A", 104 }, + { "DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_B", 110 }, + { "DYEING_HEAD_ZONE_4_CURRENT_LOOP_BREAK", 122 }, + { "DYEING_HEAD_ZONE_4_CURRENT_OUT_OF_RANGE", 117 }, + { "DYEING_HEAD_ZONE_4_OVERTEMPERATURE", 99 }, + { "DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_A", 105 }, + { "DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_B", 111 }, + { "DYEING_HEAD_ZONE_5_6_CURRENT_LOOP_BREAK", 123 }, + { "DYEING_HEAD_ZONE_5_6_CURRENT_OUT_OF_RANGE", 118 }, + { "DYEING_HEAD_ZONE_5_OVERTEMPERATURE", 100 }, + { "DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_A", 106 }, + { "DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_B", 112 }, + { "DYEING_HEAD_ZONE_6_OVERTEMPERATURE", 101 }, + { "DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_A", 107 }, + { "DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_B", 113 }, + { "ELECTRICAL_CABINET_FANS_RPM_TOO_LOW", 22 }, + { "ELECTRICAL_CABINET_FANS_STOPPED", 23 }, + { "EMERGENCY_PUSH_BUTTON_PRESSED", 12 }, + { "FEEDER_DANCER_MOTOR_OVERCURRENT", 62 }, + { "FEEDER_DANCER_MOTOR_OVERTEMPERATURE", 65 }, + { "FEEDER_DANCER_MOTOR_STALL", 68 }, + { "FEEDER_DANCER_MOTOR_UNDERVOLTAGE", 71 }, + { "FEEDER_MOTOR_OVERCURRENT", 27 }, + { "FEEDER_MOTOR_OVERTEMPERATURE", 34 }, + { "FEEDER_MOTOR_STALL", 41 }, + { "FEEDER_MOTOR_UNDERVOLTAGE", 48 }, + { "FRONT_COVER_1_OPEN", 13 }, + { "FRONT_COVER_2_OPEN", 14 }, + { "FRONT_COVER_3_OPEN", 15 }, + { "FRONT_COVER_4_OPEN", 16 }, + { "INK_CARTRIDGE_PRESENCE_SENSOR_TIMEOUT", 273 }, + { "INK_CARTRIDGE_RFID_TIMEOUT", 274 }, + { "INSUFFICIENT_AIR_FLOW", 272 }, + { "JOB_STATUS", 10 }, + { "LEFT_LOADER_MOTOR_OVERCURRENT", 30 }, + { "LEFT_LOADER_MOTOR_OVERTEMPERATURE", 37 }, + { "LEFT_LOADER_MOTOR_STALL", 44 }, + { "LEFT_LOADER_MOTOR_UNDERVOLTAGE", 51 }, + { "LOADING_ARM_MOTOR_OVERCURRENT", 33 }, + { "LOADING_ARM_MOTOR_OVERTEMPERATURE", 40 }, + { "LOADING_ARM_MOTOR_STALL", 47 }, + { "LOADING_ARM_MOTOR_UNDERVOLTAGE", 54 }, + { "LTFU_DOWN_TIMEOUT", 56 }, + { "LTFU_UP_TIMEOUT", 55 }, + { "MACHINE_FANS_RPM_TOO_LOW", 20 }, + { "MACHINE_FANS_STOPPED", 21 }, + { "MACHINE_INTERNAL_OVERTEMPERATURE", 19 }, + { "MID_TANK_1_EMPTY", 241 }, + { "MID_TANK_1_FILL_TIMEOUT", 257 }, + { "MID_TANK_1_LOW_LEVEL", 233 }, + { "MID_TANK_1_OVERFLOW", 249 }, + { "MID_TANK_2_EMPTY", 242 }, + { "MID_TANK_2_FILL_TIMEOUT", 258 }, + { "MID_TANK_2_LOW_LEVEL", 234 }, + { "MID_TANK_2_OVERFLOW", 250 }, + { "MID_TANK_3_EMPTY", 243 }, + { "MID_TANK_3_FILL_TIMEOUT", 259 }, + { "MID_TANK_3_LOW_LEVEL", 235 }, + { "MID_TANK_3_OVERFLOW", 251 }, + { "MID_TANK_4_EMPTY", 244 }, + { "MID_TANK_4_FILL_TIMEOUT", 260 }, + { "MID_TANK_4_LOW_LEVEL", 236 }, + { "MID_TANK_4_OVERFLOW", 252 }, + { "MID_TANK_5_EMPTY", 245 }, + { "MID_TANK_5_FILL_TIMEOUT", 261 }, + { "MID_TANK_5_LOW_LEVEL", 237 }, + { "MID_TANK_5_OVERFLOW", 253 }, + { "MID_TANK_6_EMPTY", 246 }, + { "MID_TANK_6_FILL_TIMEOUT", 262 }, + { "MID_TANK_6_LOW_LEVEL", 238 }, + { "MID_TANK_6_OVERFLOW", 254 }, + { "MID_TANK_7_EMPTY", 247 }, + { "MID_TANK_7_FILL_TIMEOUT", 263 }, + { "MID_TANK_7_LOW_LEVEL", 239 }, + { "MID_TANK_7_OVERFLOW", 255 }, + { "MID_TANK_8_EMPTY", 248 }, + { "MID_TANK_8_FILL_TIMEOUT", 264 }, + { "MID_TANK_8_LOW_LEVEL", 240 }, + { "MID_TANK_8_OVERFLOW", 256 }, + { "MIXER_CURRENT_LOOP_BREAK", 144 }, + { "MIXER_CURRENT_OUT_OF_RANGE", 143 }, + { "MIXER_OVERTEMPERATURE", 139 }, + { "MIXER_THERMAL_CUTOFF", 142 }, + { "MIXER_UNDERTEMPERATURE_A", 140 }, + { "MIXER_UNDERTEMPERATURE_B", 141 }, + { "NO_AIR_PRESSURE", 268 }, + { "NO_WASTE_CARTRIDGE_AVAILABLE", 275 }, { "None", 0 }, - { "POWER_UP_BIT_FAILURE", 1 }, - { "PULLER_MOTOR_OVERCURRENT", 17 }, - { "PULLER_MOTOR_OVERTEMPERATURE", 24 }, - { "PULLER_MOTOR_STALL", 31 }, - { "PULLER_MOTOR_UNDERVOLTAGE", 38 }, - { "REAR_COVER_OPEN", 8 }, - { "RECORDING_STARTED", 214 }, - { "RECORDING_STOPPED", 215 }, - { "REQUEST_FAILED", 209 }, - { "REQUEST_SENT", 207 }, - { "RESPONSE_RECEIVED", 208 }, - { "RIGHT_LOADER_MOTOR_OVERCURRENT", 16 }, - { "RIGHT_LOADER_MOTOR_OVERTEMPERATURE", 23 }, - { "RIGHT_LOADER_MOTOR_STALL", 30 }, - { "RIGHT_LOADER_MOTOR_UNDERVOLTAGE", 37 }, - { "RTFU_DOWN_TIMEOUT", 46 }, - { "RTFU_UP_TIMEOUT", 45 }, - { "SCREW_MOTOR_LIMIT_TIMEOUT", 47 }, - { "SCREW_MOTOR_OVERCURRENT", 20 }, - { "SCREW_MOTOR_OVERTEMPERATURE", 27 }, - { "SCREW_MOTOR_STALL", 34 }, - { "SCREW_MOTOR_UNDERVOLTAGE", 41 }, - { "THREAD_BREAK", 12 }, - { "THREAD_TENSION_CONTROL_FAILURE", 13 }, - { "VOC_SENSOR_ALARM", 196 }, - { "WASTE_CARTRIDGE_PRESENCE_SENSOR_TIMEOUT", 203 }, - { "WASTE_CARTRIDGE_RFID_TIMEOUT", 204 }, - { "WASTE_CONTAINER_EMPTYING_TIMEOUT", 193 }, - { "WASTE_CONTAINER_OVERFLOW", 195 }, - { "WINDER_CONE_DOES_NOT_EXIST", 14 }, - { "WINDER_MOTOR_OVERCURRENT", 19 }, - { "WINDER_MOTOR_OVERTEMPERATURE", 26 }, - { "WINDER_MOTOR_STALL", 33 }, - { "WINDER_MOTOR_UNDERVOLTAGE", 40 }, + { "POWER_UP_BIT_FAILURE", 11 }, + { "PULLER_DANCER_MOTOR_OVERCURRENT", 61 }, + { "PULLER_DANCER_MOTOR_OVERTEMPERATURE", 64 }, + { "PULLER_DANCER_MOTOR_STALL", 67 }, + { "PULLER_DANCER_MOTOR_UNDERVOLTAGE", 70 }, + { "PULLER_MOTOR_OVERCURRENT", 29 }, + { "PULLER_MOTOR_OVERTEMPERATURE", 36 }, + { "PULLER_MOTOR_STALL", 43 }, + { "PULLER_MOTOR_UNDERVOLTAGE", 50 }, + { "REAR_COVER_OPEN", 18 }, + { "RECORDING_STARTED", 8 }, + { "RECORDING_STOPPED", 9 }, + { "REQUEST_FAILED", 3 }, + { "REQUEST_SENT", 1 }, + { "RESPONSE_RECEIVED", 2 }, + { "RIGHT_LOADER_MOTOR_OVERCURRENT", 28 }, + { "RIGHT_LOADER_MOTOR_OVERTEMPERATURE", 35 }, + { "RIGHT_LOADER_MOTOR_STALL", 42 }, + { "RIGHT_LOADER_MOTOR_UNDERVOLTAGE", 49 }, + { "RTFU_DOWN_TIMEOUT", 58 }, + { "RTFU_UP_TIMEOUT", 57 }, + { "SCREW_MOTOR_LIMIT_TIMEOUT", 59 }, + { "SCREW_MOTOR_OVERCURRENT", 32 }, + { "SCREW_MOTOR_OVERTEMPERATURE", 39 }, + { "SCREW_MOTOR_STALL", 46 }, + { "SCREW_MOTOR_UNDERVOLTAGE", 53 }, + { "THREAD_BREAK", 24 }, + { "THREAD_TENSION_CONTROL_FAILURE_FEEDER_DANCER", 25 }, + { "THREAD_TENSION_CONTROL_FAILURE_PULLER_DANCER", 72 }, + { "THREAD_TENSION_CONTROL_FAILURE_WINDER_DANCER", 73 }, + { "VOC_SENSOR_ALARM", 270 }, + { "WASTE_CARTRIDGE_PRESENCE_SENSOR_TIMEOUT", 277 }, + { "WASTE_CARTRIDGE_RFID_TIMEOUT", 278 }, + { "WASTE_CONTAINER_EMPTYING_TIMEOUT", 267 }, + { "WASTE_CONTAINER_OVERFLOW", 269 }, + { "WINDER_CONE_DOES_NOT_EXIST", 26 }, + { "WINDER_DANCER_MOTOR_OVERCURRENT", 60 }, + { "WINDER_DANCER_MOTOR_OVERTEMPERATURE", 63 }, + { "WINDER_DANCER_MOTOR_STALL", 66 }, + { "WINDER_DANCER_MOTOR_UNDERVOLTAGE", 69 }, + { "WINDER_MOTOR_OVERCURRENT", 31 }, + { "WINDER_MOTOR_OVERTEMPERATURE", 38 }, + { "WINDER_MOTOR_STALL", 45 }, + { "WINDER_MOTOR_UNDERVOLTAGE", 52 }, }; const ProtobufCEnumDescriptor event_type__descriptor = { @@ -457,11 +581,11 @@ const ProtobufCEnumDescriptor event_type__descriptor = "EventType", "EventType", "", - 217, + 279, event_type__enum_values_by_number, - 217, + 279, event_type__enum_values_by_name, - 2, + 11, event_type__value_ranges, NULL,NULL,NULL,NULL /* reserved[1234] */ }; diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/EventType.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/EventType.pb-c.h index 365493b19..ae437f66c 100644 --- a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/EventType.pb-c.h +++ b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/EventType.pb-c.h @@ -21,212 +21,6 @@ PROTOBUF_C__BEGIN_DECLS typedef enum _EventType { EVENT_TYPE__None = 0, - EVENT_TYPE__POWER_UP_BIT_FAILURE = 1, - EVENT_TYPE__EMERGENCY_PUSH_BUTTON_PRESSED = 2, - EVENT_TYPE__FRONT_COVER_1_OPEN = 3, - EVENT_TYPE__FRONT_COVER_2_OPEN = 4, - EVENT_TYPE__FRONT_COVER_3_OPEN = 5, - EVENT_TYPE__FRONT_COVER_4_OPEN = 6, - EVENT_TYPE__CARTRIDGES_COVER_OPEN = 7, - EVENT_TYPE__REAR_COVER_OPEN = 8, - EVENT_TYPE__MACHINE_INTERNAL_OVERTEMPERATURE = 9, - EVENT_TYPE__MACHINE_FANS_RPM_TOO_LOW = 10, - EVENT_TYPE__MACHINE_FANS_STOPPED = 11, - EVENT_TYPE__THREAD_BREAK = 12, - EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE = 13, - EVENT_TYPE__WINDER_CONE_DOES_NOT_EXIST = 14, - EVENT_TYPE__FEEDER_MOTOR_OVERCURRENT = 15, - EVENT_TYPE__RIGHT_LOADER_MOTOR_OVERCURRENT = 16, - EVENT_TYPE__PULLER_MOTOR_OVERCURRENT = 17, - EVENT_TYPE__LEFT_LOADER_MOTOR_OVERCURRENT = 18, - EVENT_TYPE__WINDER_MOTOR_OVERCURRENT = 19, - EVENT_TYPE__SCREW_MOTOR_OVERCURRENT = 20, - EVENT_TYPE__LOADING_ARM_MOTOR_OVERCURRENT = 21, - EVENT_TYPE__FEEDER_MOTOR_OVERTEMPERATURE = 22, - EVENT_TYPE__RIGHT_LOADER_MOTOR_OVERTEMPERATURE = 23, - EVENT_TYPE__PULLER_MOTOR_OVERTEMPERATURE = 24, - EVENT_TYPE__LEFT_LOADER_MOTOR_OVERTEMPERATURE = 25, - EVENT_TYPE__WINDER_MOTOR_OVERTEMPERATURE = 26, - EVENT_TYPE__SCREW_MOTOR_OVERTEMPERATURE = 27, - EVENT_TYPE__LOADING_ARM_MOTOR_OVERTEMPERATURE = 28, - EVENT_TYPE__FEEDER_MOTOR_STALL = 29, - EVENT_TYPE__RIGHT_LOADER_MOTOR_STALL = 30, - EVENT_TYPE__PULLER_MOTOR_STALL = 31, - EVENT_TYPE__LEFT_LOADER_MOTOR_STALL = 32, - EVENT_TYPE__WINDER_MOTOR_STALL = 33, - EVENT_TYPE__SCREW_MOTOR_STALL = 34, - EVENT_TYPE__LOADING_ARM_MOTOR_STALL = 35, - EVENT_TYPE__FEEDER_MOTOR_UNDERVOLTAGE = 36, - EVENT_TYPE__RIGHT_LOADER_MOTOR_UNDERVOLTAGE = 37, - EVENT_TYPE__PULLER_MOTOR_UNDERVOLTAGE = 38, - EVENT_TYPE__LEFT_LOADER_MOTOR_UNDERVOLTAGE = 39, - EVENT_TYPE__WINDER_MOTOR_UNDERVOLTAGE = 40, - EVENT_TYPE__SCREW_MOTOR_UNDERVOLTAGE = 41, - EVENT_TYPE__LOADING_ARM_MOTOR_UNDERVOLTAGE = 42, - EVENT_TYPE__LTFU_UP_TIMEOUT = 43, - EVENT_TYPE__LTFU_DOWN_TIMEOUT = 44, - EVENT_TYPE__RTFU_UP_TIMEOUT = 45, - EVENT_TYPE__RTFU_DOWN_TIMEOUT = 46, - EVENT_TYPE__SCREW_MOTOR_LIMIT_TIMEOUT = 47, - EVENT_TYPE__DRYER_MOTOR_OVERCURRENT = 48, - EVENT_TYPE__DRYER_MOTOR_OVERTEMPERATURE = 49, - EVENT_TYPE__DRYER_MOTOR_STALL = 50, - EVENT_TYPE__DRYER_MOTOR_UNDERVOLTAGE = 51, - EVENT_TYPE__DRYER_DOOR_OPEN = 52, - EVENT_TYPE__DRYER_ZONE_1_OVERTEMPERATURE = 53, - EVENT_TYPE__DRYER_ZONE_2_OVERTEMPERATURE = 54, - EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_A = 55, - EVENT_TYPE__DRYER_ZONE_2_UNDERTEMPERATURE_A = 56, - EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_B = 57, - EVENT_TYPE__DRYER_ZONE_2_UNDERTEMPERATURE_B = 58, - EVENT_TYPE__DRYER_THERMAL_CUTOFF = 59, - EVENT_TYPE__DRYER_HEATERS_ZONE_1_CURRENT_OUT_OF_RANGE = 60, - EVENT_TYPE__DRYER_HEATERS_ZONE_2_CURRENT_OUT_OF_RANGE = 61, - EVENT_TYPE__DRYER_HEATERS_ZONE_1_CURRENT_LOOP_BREAK = 62, - EVENT_TYPE__DRYER_HEATERS_ZONE_2_CURRENT_LOOP_BREAK = 63, - EVENT_TYPE__DRYER_FAN_RPM_TOO_LOW = 64, - EVENT_TYPE__DRYER_FAN_STOPPED = 65, - EVENT_TYPE__DYEING_HEAD_ZONE_1_OVERTEMPERATURE = 66, - EVENT_TYPE__DYEING_HEAD_ZONE_2_OVERTEMPERATURE = 67, - EVENT_TYPE__DYEING_HEAD_ZONE_3_OVERTEMPERATURE = 68, - EVENT_TYPE__DYEING_HEAD_ZONE_4_OVERTEMPERATURE = 69, - EVENT_TYPE__DYEING_HEAD_ZONE_5_OVERTEMPERATURE = 70, - EVENT_TYPE__DYEING_HEAD_ZONE_6_OVERTEMPERATURE = 71, - EVENT_TYPE__DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_A = 72, - EVENT_TYPE__DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_A = 73, - EVENT_TYPE__DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_A = 74, - EVENT_TYPE__DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_A = 75, - EVENT_TYPE__DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_A = 76, - EVENT_TYPE__DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_A = 77, - EVENT_TYPE__DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_B = 78, - EVENT_TYPE__DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_B = 79, - EVENT_TYPE__DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_B = 80, - EVENT_TYPE__DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_B = 81, - EVENT_TYPE__DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_B = 82, - EVENT_TYPE__DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_B = 83, - EVENT_TYPE__DYEING_HEAD_ZONE_1_CURRENT_OUT_OF_RANGE = 84, - EVENT_TYPE__DYEING_HEAD_ZONE_2_CURRENT_OUT_OF_RANGE = 85, - EVENT_TYPE__DYEING_HEAD_ZONE_3_CURRENT_OUT_OF_RANGE = 86, - EVENT_TYPE__DYEING_HEAD_ZONE_4_CURRENT_OUT_OF_RANGE = 87, - EVENT_TYPE__DYEING_HEAD_ZONE_5_6_CURRENT_OUT_OF_RANGE = 88, - EVENT_TYPE__DYEING_HEAD_ZONE_1_CURRENT_LOOP_BREAK = 89, - EVENT_TYPE__DYEING_HEAD_ZONE_2_CURRENT_LOOP_BREAK = 90, - EVENT_TYPE__DYEING_HEAD_ZONE_3_CURRENT_LOOP_BREAK = 91, - EVENT_TYPE__DYEING_HEAD_ZONE_4_CURRENT_LOOP_BREAK = 92, - EVENT_TYPE__DYEING_HEAD_ZONE_5_6_CURRENT_LOOP_BREAK = 93, - EVENT_TYPE__DYEING_HEAD_THERMAL_CUTOFF = 94, - EVENT_TYPE__DYEING_HEAD_COVER_OPEN_TIMEOUT = 95, - EVENT_TYPE__DYEING_HEAD_COVER_CLOSE_TIMEOUT = 96, - EVENT_TYPE__MIXER_OVERTEMPERATURE = 97, - EVENT_TYPE__MIXER_UNDERTEMPERATURE_A = 98, - EVENT_TYPE__MIXER_UNDERTEMPERATURE_B = 99, - EVENT_TYPE__MIXER_THERMAL_CUTOFF = 100, - EVENT_TYPE__MIXER_CURRENT_OUT_OF_RANGE = 101, - EVENT_TYPE__MIXER_CURRENT_LOOP_BREAK = 102, - EVENT_TYPE__DISPENSER_1_OVERPRESSURE = 103, - EVENT_TYPE__DISPENSER_2_OVERPRESSURE = 104, - EVENT_TYPE__DISPENSER_3_OVERPRESSURE = 105, - EVENT_TYPE__DISPENSER_4_OVERPRESSURE = 106, - EVENT_TYPE__DISPENSER_5_OVERPRESSURE = 107, - EVENT_TYPE__DISPENSER_6_OVERPRESSURE = 108, - EVENT_TYPE__DISPENSER_7_OVERPRESSURE = 109, - EVENT_TYPE__DISPENSER_8_OVERPRESSURE = 110, - EVENT_TYPE__DISPENSER_1_UNDERPRESSURE = 111, - EVENT_TYPE__DISPENSER_2_UNDERPRESSURE = 112, - EVENT_TYPE__DISPENSER_3_UNDERPRESSURE = 113, - EVENT_TYPE__DISPENSER_4_UNDERPRESSURE = 114, - EVENT_TYPE__DISPENSER_5_UNDERPRESSURE = 115, - EVENT_TYPE__DISPENSER_6_UNDERPRESSURE = 116, - EVENT_TYPE__DISPENSER_7_UNDERPRESSURE = 117, - EVENT_TYPE__DISPENSER_8_UNDERPRESSURE = 118, - EVENT_TYPE__DISPENSER_1_EMPTY = 119, - EVENT_TYPE__DISPENSER_2_EMPTY = 120, - EVENT_TYPE__DISPENSER_3_EMPTY = 121, - EVENT_TYPE__DISPENSER_4_EMPTY = 122, - EVENT_TYPE__DISPENSER_5_EMPTY = 123, - EVENT_TYPE__DISPENSER_6_EMPTY = 124, - EVENT_TYPE__DISPENSER_7_EMPTY = 125, - EVENT_TYPE__DISPENSER_8_EMPTY = 126, - EVENT_TYPE__DISPENSER_1_REFILL_FAILURE = 127, - EVENT_TYPE__DISPENSER_2_REFILL_FAILURE = 128, - EVENT_TYPE__DISPENSER_3_REFILL_FAILURE = 129, - EVENT_TYPE__DISPENSER_4_REFILL_FAILURE = 130, - EVENT_TYPE__DISPENSER_5_REFILL_FAILURE = 131, - EVENT_TYPE__DISPENSER_6_REFILL_FAILURE = 132, - EVENT_TYPE__DISPENSER_7_REFILL_FAILURE = 133, - EVENT_TYPE__DISPENSER_8_REFILL_FAILURE = 134, - EVENT_TYPE__DISPENSER_1_MOTOR_OVERCURRENT = 135, - EVENT_TYPE__DISPENSER_2_MOTOR_OVERCURRENT = 136, - EVENT_TYPE__DISPENSER_3_MOTOR_OVERCURRENT = 137, - EVENT_TYPE__DISPENSER_4_MOTOR_OVERCURRENT = 138, - EVENT_TYPE__DISPENSER_5_MOTOR_OVERCURRENT = 139, - EVENT_TYPE__DISPENSER_6_MOTOR_OVERCURRENT = 140, - EVENT_TYPE__DISPENSER_7_MOTOR_OVERCURRENT = 141, - EVENT_TYPE__DISPENSER_8_MOTOR_OVERCURRENT = 142, - EVENT_TYPE__DISPENSER_1_MOTOR_OVERTEMPERATURE = 143, - EVENT_TYPE__DISPENSER_2_MOTOR_OVERTEMPERATURE = 144, - EVENT_TYPE__DISPENSER_3_MOTOR_OVERTEMPERATURE = 145, - EVENT_TYPE__DISPENSER_4_MOTOR_OVERTEMPERATURE = 146, - EVENT_TYPE__DISPENSER_5_MOTOR_OVERTEMPERATURE = 147, - EVENT_TYPE__DISPENSER_6_MOTOR_OVERTEMPERATURE = 148, - EVENT_TYPE__DISPENSER_7_MOTOR_OVERTEMPERATURE = 149, - EVENT_TYPE__DISPENSER_8_MOTOR_OVERTEMPERATURE = 150, - EVENT_TYPE__DISPENSER_1_MOTOR_STALL = 151, - EVENT_TYPE__DISPENSER_2_MOTOR_STALL = 152, - EVENT_TYPE__DISPENSER_3_MOTOR_STALL = 153, - EVENT_TYPE__DISPENSER_4_MOTOR_STALL = 154, - EVENT_TYPE__DISPENSER_5_MOTOR_STALL = 155, - EVENT_TYPE__DISPENSER_6_MOTOR_STALL = 156, - EVENT_TYPE__DISPENSER_7_MOTOR_STALL = 157, - EVENT_TYPE__DISPENSER_8_MOTOR_STALL = 158, - EVENT_TYPE__DISPENSER_1_MOTOR_UNDERVOLTAGE = 159, - EVENT_TYPE__DISPENSER_2_MOTOR_UNDERVOLTAGE = 160, - EVENT_TYPE__DISPENSER_3_MOTOR_UNDERVOLTAGE = 161, - EVENT_TYPE__DISPENSER_4_MOTOR_UNDERVOLTAGE = 162, - EVENT_TYPE__DISPENSER_5_MOTOR_UNDERVOLTAGE = 163, - EVENT_TYPE__DISPENSER_6_MOTOR_UNDERVOLTAGE = 164, - EVENT_TYPE__DISPENSER_7_MOTOR_UNDERVOLTAGE = 165, - EVENT_TYPE__DISPENSER_8_MOTOR_UNDERVOLTAGE = 166, - EVENT_TYPE__MID_TANK_1_LOW_LEVEL = 167, - EVENT_TYPE__MID_TANK_2_LOW_LEVEL = 168, - EVENT_TYPE__MID_TANK_3_LOW_LEVEL = 169, - EVENT_TYPE__MID_TANK_4_LOW_LEVEL = 170, - EVENT_TYPE__MID_TANK_5_LOW_LEVEL = 171, - EVENT_TYPE__MID_TANK_6_LOW_LEVEL = 172, - EVENT_TYPE__MID_TANK_7_LOW_LEVEL = 173, - EVENT_TYPE__MID_TANK_8_LOW_LEVEL = 174, - EVENT_TYPE__MID_TANK_1_EMPTY = 175, - EVENT_TYPE__MID_TANK_2_EMPTY = 176, - EVENT_TYPE__MID_TANK_3_EMPTY = 177, - EVENT_TYPE__MID_TANK_4_EMPTY = 178, - EVENT_TYPE__MID_TANK_5_EMPTY = 179, - EVENT_TYPE__MID_TANK_6_EMPTY = 180, - EVENT_TYPE__MID_TANK_7_EMPTY = 181, - EVENT_TYPE__MID_TANK_8_EMPTY = 182, - EVENT_TYPE__MID_TANK_1_OVERFLOW = 183, - EVENT_TYPE__MID_TANK_2_OVERFLOW = 184, - EVENT_TYPE__MID_TANK_3_OVERFLOW = 185, - EVENT_TYPE__MID_TANK_4_OVERFLOW = 186, - EVENT_TYPE__MID_TANK_5_OVERFLOW = 187, - EVENT_TYPE__MID_TANK_6_OVERFLOW = 188, - EVENT_TYPE__MID_TANK_7_OVERFLOW = 189, - EVENT_TYPE__MID_TANK_8_OVERFLOW = 190, - EVENT_TYPE__AIR_FILTER_NOT_INSTALLED = 191, - EVENT_TYPE__AIR_FILTER_CLOGGED = 192, - EVENT_TYPE__WASTE_CONTAINER_EMPTYING_TIMEOUT = 193, - EVENT_TYPE__NO_AIR_PRESSURE = 194, - EVENT_TYPE__WASTE_CONTAINER_OVERFLOW = 195, - EVENT_TYPE__VOC_SENSOR_ALARM = 196, - EVENT_TYPE__CHILLER_DRY_CONTACT = 197, - EVENT_TYPE__INSUFFICIENT_AIR_FLOW = 198, - EVENT_TYPE__INK_CARTRIDGE_PRESENCE_SENSOR_TIMEOUT = 199, - EVENT_TYPE__INK_CARTRIDGE_RFID_TIMEOUT = 200, - EVENT_TYPE__NO_WASTE_CARTRIDGE_AVAILABLE = 201, - EVENT_TYPE__ALL_WASTE_CARTRIDGES_FULL = 202, - EVENT_TYPE__WASTE_CARTRIDGE_PRESENCE_SENSOR_TIMEOUT = 203, - EVENT_TYPE__WASTE_CARTRIDGE_RFID_TIMEOUT = 204, - EVENT_TYPE__ELECTRICAL_CABINET_FANS_RPM_TOO_LOW = 205, - EVENT_TYPE__ELECTRICAL_CABINET_FANS_STOPPED = 206, EVENT_TYPE__REQUEST_SENT = 1000, EVENT_TYPE__RESPONSE_RECEIVED = 1001, EVENT_TYPE__REQUEST_FAILED = 1002, @@ -236,7 +30,275 @@ typedef enum _EventType { EVENT_TYPE__APPLICATION_TERMINATED = 1006, EVENT_TYPE__RECORDING_STARTED = 1007, EVENT_TYPE__RECORDING_STOPPED = 1008, - EVENT_TYPE__JOB_STATUS = 1009 + EVENT_TYPE__JOB_STATUS = 1009, + EVENT_TYPE__POWER_UP_BIT_FAILURE = 2000, + EVENT_TYPE__EMERGENCY_PUSH_BUTTON_PRESSED = 2001, + EVENT_TYPE__FRONT_COVER_1_OPEN = 2002, + EVENT_TYPE__FRONT_COVER_2_OPEN = 2003, + EVENT_TYPE__FRONT_COVER_3_OPEN = 2004, + EVENT_TYPE__FRONT_COVER_4_OPEN = 2005, + EVENT_TYPE__CARTRIDGES_COVER_OPEN = 2006, + EVENT_TYPE__REAR_COVER_OPEN = 2007, + EVENT_TYPE__MACHINE_INTERNAL_OVERTEMPERATURE = 2008, + EVENT_TYPE__MACHINE_FANS_RPM_TOO_LOW = 2009, + EVENT_TYPE__MACHINE_FANS_STOPPED = 2010, + EVENT_TYPE__ELECTRICAL_CABINET_FANS_RPM_TOO_LOW = 2011, + EVENT_TYPE__ELECTRICAL_CABINET_FANS_STOPPED = 2012, + EVENT_TYPE__THREAD_BREAK = 3000, + EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_FEEDER_DANCER = 3001, + EVENT_TYPE__WINDER_CONE_DOES_NOT_EXIST = 3002, + EVENT_TYPE__FEEDER_MOTOR_OVERCURRENT = 3003, + EVENT_TYPE__RIGHT_LOADER_MOTOR_OVERCURRENT = 3004, + EVENT_TYPE__PULLER_MOTOR_OVERCURRENT = 3005, + EVENT_TYPE__LEFT_LOADER_MOTOR_OVERCURRENT = 3006, + EVENT_TYPE__WINDER_MOTOR_OVERCURRENT = 3007, + EVENT_TYPE__SCREW_MOTOR_OVERCURRENT = 3008, + EVENT_TYPE__LOADING_ARM_MOTOR_OVERCURRENT = 3009, + EVENT_TYPE__FEEDER_MOTOR_OVERTEMPERATURE = 3010, + EVENT_TYPE__RIGHT_LOADER_MOTOR_OVERTEMPERATURE = 3011, + EVENT_TYPE__PULLER_MOTOR_OVERTEMPERATURE = 3012, + EVENT_TYPE__LEFT_LOADER_MOTOR_OVERTEMPERATURE = 3013, + EVENT_TYPE__WINDER_MOTOR_OVERTEMPERATURE = 3014, + EVENT_TYPE__SCREW_MOTOR_OVERTEMPERATURE = 3015, + EVENT_TYPE__LOADING_ARM_MOTOR_OVERTEMPERATURE = 3016, + EVENT_TYPE__FEEDER_MOTOR_STALL = 3017, + EVENT_TYPE__RIGHT_LOADER_MOTOR_STALL = 3018, + EVENT_TYPE__PULLER_MOTOR_STALL = 3019, + EVENT_TYPE__LEFT_LOADER_MOTOR_STALL = 3020, + EVENT_TYPE__WINDER_MOTOR_STALL = 3021, + EVENT_TYPE__SCREW_MOTOR_STALL = 3022, + EVENT_TYPE__LOADING_ARM_MOTOR_STALL = 3023, + EVENT_TYPE__FEEDER_MOTOR_UNDERVOLTAGE = 3024, + EVENT_TYPE__RIGHT_LOADER_MOTOR_UNDERVOLTAGE = 3025, + EVENT_TYPE__PULLER_MOTOR_UNDERVOLTAGE = 3026, + EVENT_TYPE__LEFT_LOADER_MOTOR_UNDERVOLTAGE = 3027, + EVENT_TYPE__WINDER_MOTOR_UNDERVOLTAGE = 3028, + EVENT_TYPE__SCREW_MOTOR_UNDERVOLTAGE = 3029, + EVENT_TYPE__LOADING_ARM_MOTOR_UNDERVOLTAGE = 3030, + EVENT_TYPE__LTFU_UP_TIMEOUT = 3031, + EVENT_TYPE__LTFU_DOWN_TIMEOUT = 3032, + EVENT_TYPE__RTFU_UP_TIMEOUT = 3033, + EVENT_TYPE__RTFU_DOWN_TIMEOUT = 3034, + EVENT_TYPE__SCREW_MOTOR_LIMIT_TIMEOUT = 3035, + EVENT_TYPE__WINDER_DANCER_MOTOR_OVERCURRENT = 3036, + EVENT_TYPE__PULLER_DANCER_MOTOR_OVERCURRENT = 3037, + EVENT_TYPE__FEEDER_DANCER_MOTOR_OVERCURRENT = 3038, + EVENT_TYPE__WINDER_DANCER_MOTOR_OVERTEMPERATURE = 3039, + EVENT_TYPE__PULLER_DANCER_MOTOR_OVERTEMPERATURE = 3040, + EVENT_TYPE__FEEDER_DANCER_MOTOR_OVERTEMPERATURE = 3041, + EVENT_TYPE__WINDER_DANCER_MOTOR_STALL = 3042, + EVENT_TYPE__PULLER_DANCER_MOTOR_STALL = 3043, + EVENT_TYPE__FEEDER_DANCER_MOTOR_STALL = 3044, + EVENT_TYPE__WINDER_DANCER_MOTOR_UNDERVOLTAGE = 3045, + EVENT_TYPE__PULLER_DANCER_MOTOR_UNDERVOLTAGE = 3046, + EVENT_TYPE__FEEDER_DANCER_MOTOR_UNDERVOLTAGE = 3047, + EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_PULLER_DANCER = 3048, + EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_WINDER_DANCER = 3049, + EVENT_TYPE__DRYER_MOTOR_OVERCURRENT = 4000, + EVENT_TYPE__DRYER_MOTOR_OVERTEMPERATURE = 4001, + EVENT_TYPE__DRYER_MOTOR_STALL = 4002, + EVENT_TYPE__DRYER_MOTOR_UNDERVOLTAGE = 4003, + EVENT_TYPE__DRYER_DOOR_OPEN = 4004, + EVENT_TYPE__DRYER_ZONE_1_OVERTEMPERATURE = 4005, + EVENT_TYPE__DRYER_ZONE_2_OVERTEMPERATURE = 4006, + EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_A = 4007, + EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_B = 4008, + EVENT_TYPE__DRYER_ZONE_2_UNDERTEMPERATURE_B = 4009, + EVENT_TYPE__DRYER_THERMAL_CUTOFF = 4010, + EVENT_TYPE__DRYER_HEATERS_ZONE_1_CURRENT_OUT_OF_RANGE = 4011, + EVENT_TYPE__DRYER_HEATERS_ZONE_2_CURRENT_OUT_OF_RANGE = 4012, + EVENT_TYPE__DRYER_HEATERS_ZONE_1_CURRENT_LOOP_BREAK = 4013, + EVENT_TYPE__DRYER_HEATERS_ZONE_2_CURRENT_LOOP_BREAK = 4014, + EVENT_TYPE__DRYER_FAN_RPM_TOO_LOW = 4015, + EVENT_TYPE__DRYER_FAN_STOPPED = 4016, + EVENT_TYPE__DRYER_LID_MOTOR_OVERCURRENT = 4017, + EVENT_TYPE__DRYER_LID_MOTOR_OVERTEMPERATURE = 4018, + EVENT_TYPE__DRYER_LID_MOTOR_STALL = 4019, + EVENT_TYPE__DRYER_LID_MOTOR_UNDERVOLTAGE = 4020, + EVENT_TYPE__DRYER_ZONE_2_UNDERTEMPERATURE_A = 4021, + EVENT_TYPE__DYEING_HEAD_ZONE_1_OVERTEMPERATURE = 5000, + EVENT_TYPE__DYEING_HEAD_ZONE_2_OVERTEMPERATURE = 5001, + EVENT_TYPE__DYEING_HEAD_ZONE_3_OVERTEMPERATURE = 5002, + EVENT_TYPE__DYEING_HEAD_ZONE_4_OVERTEMPERATURE = 5003, + EVENT_TYPE__DYEING_HEAD_ZONE_5_OVERTEMPERATURE = 5004, + EVENT_TYPE__DYEING_HEAD_ZONE_6_OVERTEMPERATURE = 5005, + EVENT_TYPE__DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_A = 5006, + EVENT_TYPE__DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_A = 5007, + EVENT_TYPE__DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_A = 5008, + EVENT_TYPE__DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_A = 5009, + EVENT_TYPE__DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_A = 5010, + EVENT_TYPE__DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_A = 5011, + EVENT_TYPE__DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_B = 5012, + EVENT_TYPE__DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_B = 5013, + EVENT_TYPE__DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_B = 5014, + EVENT_TYPE__DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_B = 5015, + EVENT_TYPE__DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_B = 5016, + EVENT_TYPE__DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_B = 5017, + EVENT_TYPE__DYEING_HEAD_ZONE_1_CURRENT_OUT_OF_RANGE = 5018, + EVENT_TYPE__DYEING_HEAD_ZONE_2_CURRENT_OUT_OF_RANGE = 5019, + EVENT_TYPE__DYEING_HEAD_ZONE_3_CURRENT_OUT_OF_RANGE = 5020, + EVENT_TYPE__DYEING_HEAD_ZONE_4_CURRENT_OUT_OF_RANGE = 5021, + EVENT_TYPE__DYEING_HEAD_ZONE_5_6_CURRENT_OUT_OF_RANGE = 5022, + EVENT_TYPE__DYEING_HEAD_ZONE_1_CURRENT_LOOP_BREAK = 5023, + EVENT_TYPE__DYEING_HEAD_ZONE_2_CURRENT_LOOP_BREAK = 5024, + EVENT_TYPE__DYEING_HEAD_ZONE_3_CURRENT_LOOP_BREAK = 5025, + EVENT_TYPE__DYEING_HEAD_ZONE_4_CURRENT_LOOP_BREAK = 5026, + EVENT_TYPE__DYEING_HEAD_ZONE_5_6_CURRENT_LOOP_BREAK = 5027, + EVENT_TYPE__DYEING_HEAD_THERMAL_CUTOFF = 5028, + EVENT_TYPE__DYEING_HEAD_COVER_OPEN_TIMEOUT = 5029, + EVENT_TYPE__DYEING_HEAD_COVER_CLOSE_TIMEOUT = 5030, + EVENT_TYPE__DYEING_HEAD_COVER_MOTOR_OVERCURRENT = 5031, + EVENT_TYPE__DYEING_HEAD_COVER_MOTOR_OVERTEMPERATURE = 5032, + EVENT_TYPE__DYEING_HEAD_COVER_MOTOR_STALL = 5033, + EVENT_TYPE__DYEING_HEAD_COVER_MOTOR_UNDERVOLTAGE = 5034, + EVENT_TYPE__DYEING_HEAD_CLEANING_MECHANISM_MOTOR_OVERCURRENT = 5035, + EVENT_TYPE__DYEING_HEAD_CLEANING_MECHANISM_MOTOR_OVERTEMPERATURE = 5036, + EVENT_TYPE__DYEING_HEAD_CLEANING_MECHANISM_MOTOR_STALL = 5037, + EVENT_TYPE__DYEING_HEAD_CLEANING_MECHANISM_MOTOR_UNDERVOLTAGE = 5038, + EVENT_TYPE__DYEING_HEAD_CLEANING_HEAD_MOTOR_OVERCURRENT = 5039, + EVENT_TYPE__DYEING_HEAD_CLEANING_HEAD_MOTOR_OVERTEMPERATURE = 5040, + EVENT_TYPE__DYEING_HEAD_CLEANING_HEAD_MOTOR_STALL = 5041, + EVENT_TYPE__DYEING_HEAD_CLEANING_HEAD_MOTOR_UNDERVOLTAGE = 5042, + EVENT_TYPE__MIXER_OVERTEMPERATURE = 6000, + EVENT_TYPE__MIXER_UNDERTEMPERATURE_A = 6001, + EVENT_TYPE__MIXER_UNDERTEMPERATURE_B = 6002, + EVENT_TYPE__MIXER_THERMAL_CUTOFF = 6003, + EVENT_TYPE__MIXER_CURRENT_OUT_OF_RANGE = 6004, + EVENT_TYPE__MIXER_CURRENT_LOOP_BREAK = 6005, + EVENT_TYPE__DISPENSER_1_OVERPRESSURE = 7000, + EVENT_TYPE__DISPENSER_2_OVERPRESSURE = 7001, + EVENT_TYPE__DISPENSER_3_OVERPRESSURE = 7002, + EVENT_TYPE__DISPENSER_4_OVERPRESSURE = 7003, + EVENT_TYPE__DISPENSER_5_OVERPRESSURE = 7004, + EVENT_TYPE__DISPENSER_6_OVERPRESSURE = 7005, + EVENT_TYPE__DISPENSER_7_OVERPRESSURE = 7006, + EVENT_TYPE__DISPENSER_8_OVERPRESSURE = 7007, + EVENT_TYPE__DISPENSER_1_UNDERPRESSURE = 7008, + EVENT_TYPE__DISPENSER_2_UNDERPRESSURE = 7009, + EVENT_TYPE__DISPENSER_3_UNDERPRESSURE = 7010, + EVENT_TYPE__DISPENSER_4_UNDERPRESSURE = 7011, + EVENT_TYPE__DISPENSER_5_UNDERPRESSURE = 7012, + EVENT_TYPE__DISPENSER_6_UNDERPRESSURE = 7013, + EVENT_TYPE__DISPENSER_7_UNDERPRESSURE = 7014, + EVENT_TYPE__DISPENSER_8_UNDERPRESSURE = 7015, + EVENT_TYPE__DISPENSER_1_EMPTY = 7016, + EVENT_TYPE__DISPENSER_2_EMPTY = 7017, + EVENT_TYPE__DISPENSER_3_EMPTY = 7018, + EVENT_TYPE__DISPENSER_4_EMPTY = 7019, + EVENT_TYPE__DISPENSER_5_EMPTY = 7020, + EVENT_TYPE__DISPENSER_6_EMPTY = 7021, + EVENT_TYPE__DISPENSER_7_EMPTY = 7022, + EVENT_TYPE__DISPENSER_8_EMPTY = 7023, + EVENT_TYPE__DISPENSER_1_REFILL_FAILURE = 7024, + EVENT_TYPE__DISPENSER_2_REFILL_FAILURE = 7025, + EVENT_TYPE__DISPENSER_3_REFILL_FAILURE = 7026, + EVENT_TYPE__DISPENSER_4_REFILL_FAILURE = 7027, + EVENT_TYPE__DISPENSER_5_REFILL_FAILURE = 7028, + EVENT_TYPE__DISPENSER_6_REFILL_FAILURE = 7029, + EVENT_TYPE__DISPENSER_7_REFILL_FAILURE = 7030, + EVENT_TYPE__DISPENSER_8_REFILL_FAILURE = 7031, + EVENT_TYPE__DISPENSER_1_MOTOR_OVERCURRENT = 7032, + EVENT_TYPE__DISPENSER_2_MOTOR_OVERCURRENT = 7033, + EVENT_TYPE__DISPENSER_3_MOTOR_OVERCURRENT = 7034, + EVENT_TYPE__DISPENSER_4_MOTOR_OVERCURRENT = 7035, + EVENT_TYPE__DISPENSER_5_MOTOR_OVERCURRENT = 7036, + EVENT_TYPE__DISPENSER_6_MOTOR_OVERCURRENT = 7037, + EVENT_TYPE__DISPENSER_7_MOTOR_OVERCURRENT = 7038, + EVENT_TYPE__DISPENSER_8_MOTOR_OVERCURRENT = 7039, + EVENT_TYPE__DISPENSER_1_MOTOR_OVERTEMPERATURE = 7040, + EVENT_TYPE__DISPENSER_2_MOTOR_OVERTEMPERATURE = 7041, + EVENT_TYPE__DISPENSER_3_MOTOR_OVERTEMPERATURE = 7042, + EVENT_TYPE__DISPENSER_4_MOTOR_OVERTEMPERATURE = 7043, + EVENT_TYPE__DISPENSER_5_MOTOR_OVERTEMPERATURE = 7044, + EVENT_TYPE__DISPENSER_6_MOTOR_OVERTEMPERATURE = 7045, + EVENT_TYPE__DISPENSER_7_MOTOR_OVERTEMPERATURE = 7046, + EVENT_TYPE__DISPENSER_8_MOTOR_OVERTEMPERATURE = 7047, + EVENT_TYPE__DISPENSER_1_MOTOR_STALL = 7048, + EVENT_TYPE__DISPENSER_2_MOTOR_STALL = 7049, + EVENT_TYPE__DISPENSER_3_MOTOR_STALL = 7050, + EVENT_TYPE__DISPENSER_4_MOTOR_STALL = 7051, + EVENT_TYPE__DISPENSER_5_MOTOR_STALL = 7052, + EVENT_TYPE__DISPENSER_6_MOTOR_STALL = 7053, + EVENT_TYPE__DISPENSER_7_MOTOR_STALL = 7054, + EVENT_TYPE__DISPENSER_8_MOTOR_STALL = 7055, + EVENT_TYPE__DISPENSER_1_MOTOR_UNDERVOLTAGE = 7056, + EVENT_TYPE__DISPENSER_2_MOTOR_UNDERVOLTAGE = 7057, + EVENT_TYPE__DISPENSER_3_MOTOR_UNDERVOLTAGE = 7058, + EVENT_TYPE__DISPENSER_4_MOTOR_UNDERVOLTAGE = 7059, + EVENT_TYPE__DISPENSER_5_MOTOR_UNDERVOLTAGE = 7060, + EVENT_TYPE__DISPENSER_6_MOTOR_UNDERVOLTAGE = 7061, + EVENT_TYPE__DISPENSER_7_MOTOR_UNDERVOLTAGE = 7062, + EVENT_TYPE__DISPENSER_8_MOTOR_UNDERVOLTAGE = 7063, + EVENT_TYPE__DISPENSER_1_UPPER_HARD_LIMIT = 7064, + EVENT_TYPE__DISPENSER_2_UPPER_HARD_LIMIT = 7065, + EVENT_TYPE__DISPENSER_3_UPPER_HARD_LIMIT = 7066, + EVENT_TYPE__DISPENSER_4_UPPER_HARD_LIMIT = 7067, + EVENT_TYPE__DISPENSER_5_UPPER_HARD_LIMIT = 7068, + EVENT_TYPE__DISPENSER_6_UPPER_HARD_LIMIT = 7069, + EVENT_TYPE__DISPENSER_7_UPPER_HARD_LIMIT = 7070, + EVENT_TYPE__DISPENSER_8_UPPER_HARD_LIMIT = 7071, + EVENT_TYPE__DISPENSER_1_LOWER_HARD_LIMIT = 7072, + EVENT_TYPE__DISPENSER_2_LOWER_HARD_LIMIT = 7073, + EVENT_TYPE__DISPENSER_3_LOWER_HARD_LIMIT = 7074, + EVENT_TYPE__DISPENSER_4_LOWER_HARD_LIMIT = 7075, + EVENT_TYPE__DISPENSER_5_LOWER_HARD_LIMIT = 7076, + EVENT_TYPE__DISPENSER_6_LOWER_HARD_LIMIT = 7077, + EVENT_TYPE__DISPENSER_7_LOWER_HARD_LIMIT = 7078, + EVENT_TYPE__DISPENSER_8_LOWER_HARD_LIMIT = 7079, + EVENT_TYPE__DISPENSER_1_HIGH_PRESSURE = 7080, + EVENT_TYPE__DISPENSER_2_HIGH_PRESSURE = 7081, + EVENT_TYPE__DISPENSER_3_HIGH_PRESSURE = 7082, + EVENT_TYPE__DISPENSER_4_HIGH_PRESSURE = 7083, + EVENT_TYPE__DISPENSER_5_HIGH_PRESSURE = 7084, + EVENT_TYPE__DISPENSER_6_HIGH_PRESSURE = 7085, + EVENT_TYPE__DISPENSER_8_HIGH_PRESSURE = 7086, + EVENT_TYPE__DISPENSER_7_HIGH_PRESSURE = 7087, + EVENT_TYPE__MID_TANK_1_LOW_LEVEL = 8000, + EVENT_TYPE__MID_TANK_2_LOW_LEVEL = 8001, + EVENT_TYPE__MID_TANK_3_LOW_LEVEL = 8002, + EVENT_TYPE__MID_TANK_4_LOW_LEVEL = 8003, + EVENT_TYPE__MID_TANK_5_LOW_LEVEL = 8004, + EVENT_TYPE__MID_TANK_6_LOW_LEVEL = 8005, + EVENT_TYPE__MID_TANK_7_LOW_LEVEL = 8006, + EVENT_TYPE__MID_TANK_8_LOW_LEVEL = 8007, + EVENT_TYPE__MID_TANK_1_EMPTY = 8008, + EVENT_TYPE__MID_TANK_2_EMPTY = 8009, + EVENT_TYPE__MID_TANK_3_EMPTY = 8010, + EVENT_TYPE__MID_TANK_4_EMPTY = 8011, + EVENT_TYPE__MID_TANK_5_EMPTY = 8012, + EVENT_TYPE__MID_TANK_6_EMPTY = 8013, + EVENT_TYPE__MID_TANK_7_EMPTY = 8014, + EVENT_TYPE__MID_TANK_8_EMPTY = 8015, + EVENT_TYPE__MID_TANK_1_OVERFLOW = 8016, + EVENT_TYPE__MID_TANK_2_OVERFLOW = 8017, + EVENT_TYPE__MID_TANK_3_OVERFLOW = 8018, + EVENT_TYPE__MID_TANK_4_OVERFLOW = 8019, + EVENT_TYPE__MID_TANK_5_OVERFLOW = 8020, + EVENT_TYPE__MID_TANK_6_OVERFLOW = 8021, + EVENT_TYPE__MID_TANK_7_OVERFLOW = 8022, + EVENT_TYPE__MID_TANK_8_OVERFLOW = 8023, + EVENT_TYPE__MID_TANK_1_FILL_TIMEOUT = 8024, + EVENT_TYPE__MID_TANK_2_FILL_TIMEOUT = 8025, + EVENT_TYPE__MID_TANK_3_FILL_TIMEOUT = 8026, + EVENT_TYPE__MID_TANK_4_FILL_TIMEOUT = 8027, + EVENT_TYPE__MID_TANK_5_FILL_TIMEOUT = 8028, + EVENT_TYPE__MID_TANK_6_FILL_TIMEOUT = 8029, + EVENT_TYPE__MID_TANK_7_FILL_TIMEOUT = 8030, + EVENT_TYPE__MID_TANK_8_FILL_TIMEOUT = 8031, + EVENT_TYPE__AIR_FILTER_NOT_INSTALLED = 9000, + EVENT_TYPE__AIR_FILTER_CLOGGED = 9001, + EVENT_TYPE__WASTE_CONTAINER_EMPTYING_TIMEOUT = 9002, + EVENT_TYPE__NO_AIR_PRESSURE = 9003, + EVENT_TYPE__WASTE_CONTAINER_OVERFLOW = 9004, + EVENT_TYPE__VOC_SENSOR_ALARM = 9005, + EVENT_TYPE__CHILLER_DRY_CONTACT = 9006, + EVENT_TYPE__INSUFFICIENT_AIR_FLOW = 9007, + EVENT_TYPE__INK_CARTRIDGE_PRESENCE_SENSOR_TIMEOUT = 10000, + EVENT_TYPE__INK_CARTRIDGE_RFID_TIMEOUT = 10001, + EVENT_TYPE__NO_WASTE_CARTRIDGE_AVAILABLE = 10002, + EVENT_TYPE__ALL_WASTE_CARTRIDGES_FULL = 10003, + EVENT_TYPE__WASTE_CARTRIDGE_PRESENCE_SENSOR_TIMEOUT = 10004, + EVENT_TYPE__WASTE_CARTRIDGE_RFID_TIMEOUT = 10005 PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(EVENT_TYPE) } EventType; diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/EmbeddedParameters/ConfigurationParameters.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/EmbeddedParameters/ConfigurationParameters.pb-c.c index 979f18c95..5e36720c9 100644 --- a/Software/Embedded_SW/Embedded/Communication/PMR/EmbeddedParameters/ConfigurationParameters.pb-c.c +++ b/Software/Embedded_SW/Embedded/Communication/PMR/EmbeddedParameters/ConfigurationParameters.pb-c.c @@ -52,7 +52,7 @@ void configuration_parameters__free_unpacked assert(message->base.descriptor == &configuration_parameters__descriptor); protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); } -static const ProtobufCFieldDescriptor configuration_parameters__field_descriptors[13] = +static const ProtobufCFieldDescriptor configuration_parameters__field_descriptors[18] = { { "BreakSensorLimit", @@ -210,10 +210,74 @@ static const ProtobufCFieldDescriptor configuration_parameters__field_descriptor 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, + { + "ACHeatersLowerOperationLimit", + 14, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(ConfigurationParameters, has_acheatersloweroperationlimit), + offsetof(ConfigurationParameters, acheatersloweroperationlimit), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ACHeatersUpperOperationLimit", + 15, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(ConfigurationParameters, has_acheatersupperoperationlimit), + offsetof(ConfigurationParameters, acheatersupperoperationlimit), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "DCHeatersLowerOperationLimit", + 16, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(ConfigurationParameters, has_dcheatersloweroperationlimit), + offsetof(ConfigurationParameters, dcheatersloweroperationlimit), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "DCHeatersUpperOperationLimit", + 17, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(ConfigurationParameters, has_dcheatersupperoperationlimit), + offsetof(ConfigurationParameters, dcheatersupperoperationlimit), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "MidTankPressureCorrection", + 18, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_DOUBLE, + offsetof(ConfigurationParameters, has_midtankpressurecorrection), + offsetof(ConfigurationParameters, midtankpressurecorrection), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, }; static const unsigned configuration_parameters__field_indices_by_name[] = { + 13, /* field[13] = ACHeatersLowerOperationLimit */ + 14, /* field[14] = ACHeatersUpperOperationLimit */ 0, /* field[0] = BreakSensorLimit */ 4, /* field[4] = CloseValveTimeout */ + 15, /* field[15] = DCHeatersLowerOperationLimit */ + 16, /* field[16] = DCHeatersUpperOperationLimit */ 1, /* field[1] = DiagnosticCollectionLimit */ 12, /* field[12] = DispenserBuildPressureLag */ 10, /* field[10] = DispenserBuildPressureLimit */ @@ -222,6 +286,7 @@ static const unsigned configuration_parameters__field_indices_by_name[] = { 6, /* field[6] = InitialDispenserPressure */ 8, /* field[8] = InitialDispenserTimeLag */ 7, /* field[7] = InitialDispenserTimeout */ + 17, /* field[17] = MidTankPressureCorrection */ 5, /* field[5] = OpenValveTimeout */ 2, /* field[2] = OverHeatCountLimit */ 3, /* field[3] = UnderHeatCountLimit */ @@ -229,7 +294,7 @@ static const unsigned configuration_parameters__field_indices_by_name[] = { static const ProtobufCIntRange configuration_parameters__number_ranges[1 + 1] = { { 1, 0 }, - { 0, 13 } + { 0, 18 } }; const ProtobufCMessageDescriptor configuration_parameters__descriptor = { @@ -239,7 +304,7 @@ const ProtobufCMessageDescriptor configuration_parameters__descriptor = "ConfigurationParameters", "", sizeof(ConfigurationParameters), - 13, + 18, configuration_parameters__field_descriptors, configuration_parameters__field_indices_by_name, 1, configuration_parameters__number_ranges, diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/EmbeddedParameters/ConfigurationParameters.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/EmbeddedParameters/ConfigurationParameters.pb-c.h index 9aadd2aa9..307352efd 100644 --- a/Software/Embedded_SW/Embedded/Communication/PMR/EmbeddedParameters/ConfigurationParameters.pb-c.h +++ b/Software/Embedded_SW/Embedded/Communication/PMR/EmbeddedParameters/ConfigurationParameters.pb-c.h @@ -52,10 +52,20 @@ struct _ConfigurationParameters uint32_t dispenserbuildpressuretimeout; protobuf_c_boolean has_dispenserbuildpressurelag; uint32_t dispenserbuildpressurelag; + protobuf_c_boolean has_acheatersloweroperationlimit; + uint32_t acheatersloweroperationlimit; + protobuf_c_boolean has_acheatersupperoperationlimit; + uint32_t acheatersupperoperationlimit; + protobuf_c_boolean has_dcheatersloweroperationlimit; + uint32_t dcheatersloweroperationlimit; + protobuf_c_boolean has_dcheatersupperoperationlimit; + uint32_t dcheatersupperoperationlimit; + protobuf_c_boolean has_midtankpressurecorrection; + double midtankpressurecorrection; }; #define CONFIGURATION_PARAMETERS__INIT \ { PROTOBUF_C_MESSAGE_INIT (&configuration_parameters__descriptor) \ - , 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } + , 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } /* ConfigurationParameters methods */ diff --git a/Software/Embedded_SW/Embedded/DataDef.h b/Software/Embedded_SW/Embedded/DataDef.h index 4c7698c1b..041240264 100644 --- a/Software/Embedded_SW/Embedded/DataDef.h +++ b/Software/Embedded_SW/Embedded/DataDef.h @@ -14,7 +14,7 @@ //#define WithTempSensorFiltrer (to use the function Filter_Temparature_Measurement) //#define DEBUG_TEST_FUNCTIONS #define HIZ_TIMEOUT 1000 -#define DEMO_TEMPERATURE +//#define DEMO_TEMPERATURE //#define TEST_LONGER_PID_THREAD #define MAX_STRING_LEN 255 //Embedded version + filter.c @@ -198,12 +198,26 @@ enum #define BIT31 0x80000000 //0x01 << 31 +#define MAX_PWM_Command 100 + +typedef enum +{ + //Don't change the value - keep it according to the bits in F3_GPO_02_bus + CART_1 = 1, + CART_2 = 2, + CART_3 = 3, + //------------- + POWER_ON_OFF, + THREAD_JOGGING , + THREAD_LOAD , +}PANEL_BUTTONS_LEDS_ID; + typedef enum { MODE_OFF = 0, MODE_ON = 1, }OPERATION_MODE; - +/* typedef enum { //according to the bits of the leds in F3_GPO_01_bus @@ -211,7 +225,8 @@ typedef enum THREAD_LOADING = 2, JOGGING = 3, }BUTTON; - +*/ +/* typedef enum { //According to the bits of the leds in F3_GPO_02_bus @@ -219,7 +234,7 @@ typedef enum CART2 = 2, CART3 = 3, }CARTREGE; - +*/ //--------------------- #define MaxFlashWords 128 //1K #define MaxFlashBytes MaxFlashWords*4 //4K Byte diff --git a/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA.c b/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA.c index 09cd03a26..fdcf33587 100644 --- a/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA.c +++ b/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA.c @@ -199,7 +199,7 @@ uint32_t Read_Fans_Tacho() #ifndef EVALUATION_BOARD // The big Fan in the drawer - Drawer_Fan_Speed_RPM = Calculate_Tacho_Fan_Speed(25000000, 0X02, F1_Prescaler1_reg5, F1_Tacho_reg0); + Drawer_Fan_Speed_RPM = Calculate_Tacho_Fan_Speed(29166666, 0X02, F1_Prescaler1_reg5, F1_Tacho_reg0); if( Drawer_Fan_Speed_RPM < 1000 ) // need to work around 3000 RPM Status|= 0x01;// not working / Low Speed @@ -246,31 +246,31 @@ uint32_t Read_Fans_Tacho() } //------------------------- WHS ---------------------- -uint32_t WHS_Read_Blower_Tach() -{ - //TODO: check if we need to change the Prescaler - //F2_Prescaler1_reg10 - prescaled clocks for counter of signal Blower Tacho. 8 bits - - - /* - RPM=60* (Sys_clk/PreScalar)/ F2_Tacho_reg0 - - Where : - - Sys_clk =25*10^6 (25Mhz) - PresScalar(default) =250 - - Mati - */ - uint32_t RPM; - uint32_t Temp = 6000000; // 60* (Sys_clk/PreScalar) - RPM = Temp / GPI_BLOWER_TACH; - - return RPM; -} +//uint32_t WHS_Read_Blower_Tach() +//{ +// //TODO: check if we need to change the Prescaler +// //F2_Prescaler1_reg10 - prescaled clocks for counter of signal Blower Tacho. 8 bits +// +// +// /* +// RPM=60* (Sys_clk/PreScalar)/ F2_Tacho_reg0 +// +// Where : +// +// Sys_clk =25*10^6 (25Mhz) +// PresScalar(default) =250 +// +// Mati +// */ +// uint32_t RPM; +// uint32_t Temp = 6000000; // 60* (Sys_clk/PreScalar) +// RPM = Temp / GPI_BLOWER_TACH; +// +// return RPM; +//} //------------------------- Dryer Blower ---------------------- - +/* uint32_t Dryer_Read_Blower_Tach() { uint32_t RPM; @@ -278,76 +278,66 @@ uint32_t Dryer_Read_Blower_Tach() RPM = WHS_Read_Blower_Tach(); // Temporary using WHS Tacho return RPM; } +*/ + +uint32_t Read_Dryer_Fan_Tacho() +{ + + uint32_t Drayer_Fan_Speed_RPM = 0; + + Drayer_Fan_Speed_RPM = Calculate_Tacho_Fan_Speed(25000000, 12, F1_Prescaler1_reg5, F1_Tacho_reg8); -void Control_Dryer_Fan_PWM(uint8_t PWN_Command_Precent)// 0 - 100% + return Drayer_Fan_Speed_RPM; +} + +void Control_Dryer_Fan_PWM(uint8_t PWM_Command_Precent)// 0 - 100% { // change to cycle to 100 in order to work with %, with constant FREQ uint8_t Freq = 0xFF;//divider Clock = 25M/divider - if(PWN_Command_Precent > 100) - PWN_Command_Precent = 100; + if(PWM_Command_Precent > 100) + PWM_Command_Precent = 100; GPO_BLOWER_PWM_FREQ = Freq; - GPO_BLOWER_PWM_LOW = PWN_Command_Precent + 1; - GPO_BLOWER_PWM_HIGH = 101 - PWN_Command_Precent; + GPO_BLOWER_PWM_LOW = PWM_Command_Precent + 1; + GPO_BLOWER_PWM_HIGH = 101 - PWM_Command_Precent; // low + high = 0xFF in order use the same freq (and change the freq only by Add 0x112). // there is option to change only the high (low + freq constasnt) this will chnga the freq } -void Control_LED1_PWM() //if (Ten_msTick) +void Machine_Idle_Breathing_Led() //if (Ten_msTick) { - // change to cycle to 100 in order to work with %, with constant FREQ - - F3_Prescaler1_reg5 = 0x03; - - //uint8_t Freq = 0x3;//divider Clock = 25M/divider - - static uint8_t PWN_Command_Precent = 0;// 0 - 100% + static uint8_t PWM_Command_Precent = 0;// 0 - 100% static uint8_t direction = UP; -/* if(PWN_Command_Precent > 100) - PWN_Command_Precent = 100;*/ - - // GPO_BLOWER_PWM_FREQ = Freq; - - - F3_Prescaler1_reg9 = PWN_Command_Precent + 1; - F3_Prescaler1_reg10 = 101 - PWN_Command_Precent; + F3_low_var_LED1 = PWM_Command_Precent + 1; + F3_high_var_LED1 = MAX_PWM_Command + 1 - PWM_Command_Precent; if(direction == UP) { - if (PWN_Command_Precent == 100) + if (PWM_Command_Precent == MAX_PWM_Command) { direction = DOWN; //"0" - //PWN_Command_Precent--; - //delayms(20); } else { - PWN_Command_Precent++; + PWM_Command_Precent++; } } else if(direction == DOWN) { - if (PWN_Command_Precent == 0) + if (PWM_Command_Precent == 0) { direction = UP;//"1" - //PWN_Command_Precent++; - //delayms(20); } else { - PWN_Command_Precent--; + PWM_Command_Precent--; } - } - //delayms(10); - - // low + high = 0xFF in order use the same freq (and change the freq only by Add 0x112). - // there is option to change only the high (low + freq constasnt) this will chnga the freq } diff --git a/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA.h b/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA.h index b1cfa3735..93e0046b6 100644 --- a/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA.h +++ b/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA.h @@ -8,10 +8,13 @@ void FPGA_Init(); //void FPGA_Read_limit_Switches(void); uint32_t Read_Fans_Tacho(); -uint32_t WHS_Read_Blower_Tach(); +//uint32_t WHS_Read_Blower_Tach(); -uint32_t Dryer_Read_Blower_Tach(); -void Control_Dryer_Fan_PWM(uint8_t PWN_Command_Precent); +//uint32_t Dryer_Read_Blower_Tach(); +void Control_Dryer_Fan_PWM(uint8_t PWM_Command_Precent); +void Machine_Idle_Breathing_Led(); + +uint32_t Read_Dryer_Fan_Tacho(); diff --git a/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_Comm.h b/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_Comm.h index bfd21eb92..942846679 100644 --- a/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_Comm.h +++ b/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_Comm.h @@ -146,6 +146,11 @@ #define F1_LDANCER1_ROTENC_DATA_p_RX_msb (*((volatile short *)(FPGA1_BASE | 0x1C2))) //16 bit MSB if nessesary #define F1_LDANCER1_ROTENC_DATA_p_TX (*((volatile short *)(FPGA1_BASE | 0x1CE))) //This register triggers a TX transmission +//FPGA VER 050219 +#define F1_GPO_02_bus (*((volatile short *)(FPGA3_BASE | 0x1D0))) //General purpose GPIO register +#define F1_Tacho_reg8 (*((volatile short *)(FPGA3_BASE | 0x1E0))) //This Register stores the Tacho counter +#define F1_Tacho_reg9 (*((volatile short *)(FPGA3_BASE | 0x1E2))) //This Register stores the Tacho counter A to A +// //SPI_MOTO_RLOADING_A1 #define F1_MOTO_RLOADING_A1_TX_00 (*((volatile short *)(FPGA1_BASE | 0x200))) //The second register to be shifted out of the spi. The msb bit of this register is shifted out first. #define F1_MOTO_RLOADING_A1_TX_01 (*((volatile short *)(FPGA1_BASE | 0x202))) //The first register to be shifted out of the spi. The msb bit of this register is shifted out first. @@ -265,7 +270,8 @@ #define F1_MOTO_LPIVOT1_A1_RX_01 (*((volatile short *)(FPGA1_BASE | 0x306))) //The 16 Lsb bits of the shifted in data. #define F1_MOTO_LPIVOT1_A1_WORDS (*((volatile short *)(FPGA1_BASE | 0x308))) //The amount of spi words (usually byte sized) per transmission. - +//FPGA VER 050219 +#define F1_gpo_cnt_A_reg (*((volatile short *)(FPGA1_BASE | 0x3B0))) //This Register stores the costumer Tacho counter A to A ( F1_gpo_cnt_A_reg must be greater than 1 => F1_gpo_cnt_A_reg>=1) #define F1_Tacho_reg0 (*((volatile short *)(FPGA1_BASE | 0x3C0))) //This Register stores the Tacho counter #define F1_Tacho_reg1 (*((volatile short *)(FPGA1_BASE | 0x3C2))) //This Register stores the Tacho counter @@ -284,7 +290,7 @@ #define F1_Prescaler1_reg2 (*((volatile short *)(FPGA1_BASE | 0x3E2))) //Parameter for prescaler divisions - 6bit ssi low duty cycle value for prescaler #define F1_Prescaler1_reg3 (*((volatile short *)(FPGA1_BASE | 0x3E4))) //Parameter for prescaler divisions - 3bit spi moto low duty cycle value for pmw #define F1_Prescaler1_reg4 (*((volatile short *)(FPGA1_BASE | 0x3E6))) //Parameter for prescaler divisions - 3bit spi moto high duty cycle value for pmw -#define F1_Prescaler1_reg5 (*((volatile short *)(FPGA1_BASE | 0x3E8))) //Parameter for prescaler divisions - amount of prescaled clocks for counter of signal All Tachos +#define F1_Prescaler1_reg5 (*((volatile short *)(FPGA1_BASE | 0x3E8))) //Parameter for prescaler divisions - Parameter for prescaler divisions -amount of prescaled clocks for counter of signal All Tachos. ####8_Bit##### #define F1_Prescaler1_reg6 (*((volatile short *)(FPGA1_BASE | 0x3EA))) //Parameter for prescaler divisions #define F1_Prescaler1_reg7 (*((volatile short *)(FPGA1_BASE | 0x3EC))) //Parameter for prescaler divisions #define F1_Prescaler1_reg8 (*((volatile short *)(FPGA1_BASE | 0x3EE))) //Parameter for prescaler divisions @@ -358,7 +364,7 @@ //GPO_REGISTER #define F2_GPO_REGISTER (*((volatile short *)(FPGA2_BASE | 0x0F2))) //Writes to values. Readback thevaluessthat are currently in the GPO register -#define F2_Prescaler1_reg10 (*((volatile short *)(FPGA2_BASE | 0x102))) //Parameter for prescaler divisions -amount of prescaled clocks for counter of signal Blower Tacho. +#define F2_Prescaler1_reg10 (*((volatile short *)(FPGA2_BASE | 0x102))) //Variable for prescaler divisions -amount of prescaled clocks for counter of signal Blower Tacho. 8 bits #define F2_Prescaler1_reg11 (*((volatile short *)(FPGA2_BASE | 0x112))) //Parameter for prescaler divisions -amount of prescaled clocks clk input of pwm of signal F2_GPO_BLOWER_PWM. 8bits #define F2_Prescaler1_reg12 (*((volatile short *)(FPGA2_BASE | 0x122))) //Variable for prescaler divisions -amount of prescaled clocks clk input of prescaler of signal VALVE registers. 16bits #define F2_Prescaler1_reg13 (*((volatile short *)(FPGA2_BASE | 0x132))) //Variable for prescaler divisions -amount of prescaled clocks clk input of prescaler of signal debouncer of the limit switch. 14bits @@ -682,6 +688,25 @@ #define F3_SPARE2_ROTENC_DATA_p_2_RX_msb (*((volatile short *)(FPGA3_BASE | 0x2D2))) //16 bit MSB if nessesary #define F3_SPARE2_ROTENC_DATA_p_2_TX (*((volatile short *)(FPGA3_BASE | 0x2DE))) //This register triggers a TX transmission +//PWM LEDS FPGA VER 050219 +#define F3_low_var_LED1 (*((volatile short *)(FPGA3_BASE | 0x390))) //Parameter for prescaler divisions - 8bit low duty cycle value for pmw +#define F3_high_var_LED1 (*((volatile short *)(FPGA3_BASE | 0x392))) //Parameter for prescaler divisions - 8bit high duty cycle value for pmw +#define F3_low_var_LED2 (*((volatile short *)(FPGA3_BASE | 0x394))) //Parameter for prescaler divisions - 8bit low duty cycle value for pmw +#define F3_high_var_LED2 (*((volatile short *)(FPGA3_BASE | 0x396))) //Parameter for prescaler divisions - 8bit high duty cycle value for pmw +#define F3_low_var_LED3 (*((volatile short *)(FPGA3_BASE | 0x398))) //Parameter for prescaler divisions - 8bit low duty cycle value for pmw +#define F3_high_var_LED3 (*((volatile short *)(FPGA3_BASE | 0x39A))) //Parameter for prescaler divisions - 8bit high duty cycle value for pmw +#define F3_low_var_LED4 (*((volatile short *)(FPGA3_BASE | 0x39C))) //Parameter for prescaler divisions - 8bit low duty cycle value for pmw +#define F3_high_var_LED4 (*((volatile short *)(FPGA3_BASE | 0x39E))) //Parameter for prescaler divisions - 8bit high duty cycle value for pmw +#define F3_low_var_SPARE1_1 (*((volatile short *)(FPGA3_BASE | 0x3A0))) //Parameter for prescaler divisions - 8bit low duty cycle value for pmw - unused according the costumer request +#define F3_high_var_SPARE1_1 (*((volatile short *)(FPGA3_BASE | 0x3A2))) //Parameter for prescaler divisions - 8bit high duty cycle value for pmw - unused according the costumer reques +#define F3_low_var_SPARE1_2 (*((volatile short *)(FPGA3_BASE | 0x3A4))) //Parameter for prescaler divisions - 8bit low duty cycle value for pmw +#define F3_high_var_SPARE1_2 (*((volatile short *)(FPGA3_BASE | 0x3A6))) //Parameter for prescaler divisions - 8bit high duty cycle value for pmw +#define F3_low_var_SPARE2_1 (*((volatile short *)(FPGA3_BASE | 0x3A8))) //Parameter for prescaler divisions - 8bit low duty cycle value for pmw +#define F3_high_var_SPARE2_1 (*((volatile short *)(FPGA3_BASE | 0x3AA))) //Parameter for prescaler divisions - 8bit high duty cycle value for pmw +#define F3_low_var_SPARE2_2 (*((volatile short *)(FPGA3_BASE | 0x3AC))) //Parameter for prescaler divisions - 8bit low duty cycle value for pmw +#define F3_high_var_SPARE2_2 (*((volatile short *)(FPGA3_BASE | 0x3AE))) //Parameter for prescaler divisions - 8bit high duty cycle value for pmw +// + #define F3_Prescaler1_reg9 (*((volatile short *)(FPGA3_BASE | 0x3C2))) //Variable for prescaler divisions -amount of prescaled clocks clk input of prescaler of signal debouncer of the limit switch. 14bits. The value inserted here is multiply by 8 before being set. #define F3_SW_RESET_reg (*((volatile short *)(FPGA3_BASE | 0x3D0))) //This register resets the MCU @@ -699,9 +724,23 @@ //Test #define F3_Test (*((volatile short *)(FPGA3_BASE | 0x3F0))) //Readback not - gives the inverse of the written to value -//LEDS -#define F3_Prescaler1_reg9 (*((volatile short *)(FPGA3_BASE | 0x390))) //Parameter for prescaler divisions -#define F3_Prescaler1_reg10 (*((volatile short *)(FPGA3_BASE | 0x392))) //Parameter for prescaler divisions + +// ----------------------- BLOWER ----------------------- +#define GPI_BLOWER_TACH F2_Tacho_reg0 + +//WHS GPO_BLOWER_PWM - See the stub "GPO_BLOWER_PWM.cs" +#define GPO_BLOWER_PWM_FREQ F2_Prescaler1_reg11 +#define GPO_BLOWER_PWM_LOW F2_Prescaler1_reg6 +#define GPO_BLOWER_PWM_HIGH F2_Prescaler1_reg7 + +// ----------------------- LEDS ----------------------- +#define F3_LOw_Cart_Led1 F3_low_var_SPARE1_2 +#define F3_High_Cart_Led1 F3_high_var_SPARE1_2 +#define F3_LOw_Cart_Led2 F3_low_var_SPARE2_1 +#define F3_High_Cart_Led2 F3_high_var_SPARE2_1 +#define F3_LOw_Cart_Led3 F3_low_var_SPARE2_2 +#define F3_High_Cart_Led3 F3_high_var_SPARE2_2 + //1 Version1_Direct typedef union diff --git a/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_GPIO/FPGA_GPIO.c b/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_GPIO/FPGA_GPIO.c index 77273a52d..49b1ce649 100644 --- a/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_GPIO/FPGA_GPIO.c +++ b/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_GPIO/FPGA_GPIO.c @@ -20,6 +20,8 @@ FPGA_GPI FPGA_Gpi; bool FPGA_Gpi_Buf[MAX_GPI] = {0}; +extern bool Machine_Idle_Mode; + void Read_FPGA_GPI_Rgisters() { uint32_t i; @@ -646,7 +648,7 @@ void Pumps_Control(PUMPS_ENUM Pump_Id, bool Direction) //1 - OPEN, 0 - CLOSE ?? F1_gpo_01 = F1_GPO_Reg.ushort; } - +/* uint8_t Buttons_LEDS(BUTTON Button, OPERATION_MODE LED_Mode) { uint8_t Status = OK; @@ -666,7 +668,7 @@ uint8_t Buttons_LEDS(BUTTON Button, OPERATION_MODE LED_Mode) return Status; } - +*/ uint8_t Buzzer(OPERATION_MODE Buzzer_Mode) { uint8_t Status = OK; @@ -697,7 +699,7 @@ bool Read_PWR_Button()//TODO move to GPIO folder return IsPowerPressed; } - +/* uint8_t Cartridges_LEDS(CARTREGE Cartridge, OPERATION_MODE LED_Mode) // CART1_LAMP, CART2_LAMP,CART3_LAMP { uint8_t Status = OK; @@ -717,24 +719,102 @@ uint8_t Cartridges_LEDS(CARTREGE Cartridge, OPERATION_MODE LED_Mode) // CART1_LA return Status; } +*/ +uint8_t Pannel_Leds(PANEL_BUTTONS_LEDS_ID Pannel_Led_Id, OPERATION_MODE LED_Mode) +{ + uint8_t Status = OK; + + short Low_Reg; + short High_Reg; + + switch(LED_Mode) + { + case MODE_ON: + Low_Reg = 1; + High_Reg = MAX_PWM_Command +1; + break; + case MODE_OFF: + Low_Reg = MAX_PWM_Command +1; + High_Reg = 1; + break; + default: + Status = ERROR; + break; + } + + if(Status == OK) + { + switch(Pannel_Led_Id) + { + case POWER_ON_OFF: + F3_low_var_LED1 = Low_Reg; + F3_high_var_LED1 = High_Reg; + Machine_Idle_Mode = false; + break; + case THREAD_JOGGING: + F3_low_var_LED2 = Low_Reg; + F3_high_var_LED2 = High_Reg; + break; + case THREAD_LOAD: + F3_low_var_LED3 = Low_Reg; + F3_high_var_LED3 = High_Reg; + break; + case CART_1: + F3_LOw_Cart_Led1 = Low_Reg; + F3_High_Cart_Led1 = High_Reg; + break; + case CART_2: + F3_LOw_Cart_Led2 = Low_Reg; + F3_High_Cart_Led2 = High_Reg; + break; + case CART_3: + F3_LOw_Cart_Led3 = Low_Reg; + F3_High_Cart_Led3 = High_Reg; + break; + default: + Status = ERROR; + break; + } + } + return Status; +} + +uint8_t Init_Machine_Leds() +{ + uint8_t Status = OK; + + F3_Prescaler1_reg5 = 0x03; // PWM LED Prescaler default in FPGA just to verify + + Status |= Pannel_Leds(POWER_ON_OFF,MODE_ON); + + Status |= Pannel_Leds(THREAD_JOGGING,MODE_OFF); + Status |= Pannel_Leds(THREAD_LOAD,MODE_OFF); + + Status |= Pannel_Leds(CART_1,MODE_OFF); + Status |= Pannel_Leds(CART_2,MODE_OFF); + Status |= Pannel_Leds(CART_3,MODE_OFF); + + return Status; +} + -bool Read_Cartridge_Button(CARTREGE Cartridge)//TODO Update the polarity!!! +bool Read_Cartridge_Button(PANEL_BUTTONS_LEDS_ID Cartridge)//TODO Update the polarity!!! { bool IsCartPressed = false; - if((Cartridge == CART1) && (F3_CARTx_PRES_02_Direct & BIT7)) + if((Cartridge == CART_1) && (F3_CARTx_PRES_02_Direct & BIT7)) IsCartPressed = true; else - if((Cartridge == CART2) && (F3_CARTx_PRES_02_Direct & BIT6)) + if((Cartridge == CART_2) && (F3_CARTx_PRES_02_Direct & BIT6)) IsCartPressed = true; else - if((Cartridge == CART3) && (F3_CARTx_PRES_02_Direct & BIT5)) + if((Cartridge == CART_3) && (F3_CARTx_PRES_02_Direct & BIT5)) IsCartPressed = true; return IsCartPressed; } -uint32_t Control_Dryer_Fan(bool StartStop, uint8_t PWN_Command_Precent)//use START or STOP, 0 - 100% +uint32_t Control_Dryer_Fan(bool StartStop, uint8_t PWM_Command_Precent)//use START or STOP, 0 - 100% { uint32_t status = OK; @@ -745,7 +825,7 @@ uint32_t Control_Dryer_Fan(bool StartStop, uint8_t PWN_Command_Precent)//use STA F1_gpo_01 = F1_GPO_Reg.ushort; if(StartStop == START) - Control_Dryer_Fan_PWM(PWN_Command_Precent);// 0 - 100% + Control_Dryer_Fan_PWM(PWM_Command_Precent);// 0 - 100% return status; } diff --git a/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_GPIO/FPGA_GPIO.h b/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_GPIO/FPGA_GPIO.h index 71f14afa5..1def86036 100644 --- a/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_GPIO/FPGA_GPIO.h +++ b/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_GPIO/FPGA_GPIO.h @@ -187,7 +187,7 @@ uint32_t ActivateDilutorPump(); uint32_t DeActivateDilutorPump(); void Power_Off(); void Power_Reset(); -uint8_t Buttons_LEDS(BUTTON Button, OPERATION_MODE LED_Mode); +//uint8_t Buttons_LEDS(BUTTON Button, OPERATION_MODE LED_Mode); uint8_t Buzzer(OPERATION_MODE Buzzer_Mode); bool Read_PWR_Button();//TODO move to GPIO folder @@ -230,10 +230,11 @@ typedef enum void Pumps_Control(PUMPS_ENUM Pump_Id, bool Direction); -uint32_t Control_Dryer_Fan(bool StartStop, uint8_t PWN_Command_Precent); +uint32_t Control_Dryer_Fan(bool StartStop, uint8_t PWM_Command_Precent); bool Check_Disp_Sfaty_Stop_Indication(uint8_t Dispenser_ID); bool Emergency_Push_Button_Report(); bool Dryer_Door_Switch(); - +uint8_t Pannel_Leds(PANEL_BUTTONS_LEDS_ID Pannel_Led_Id, OPERATION_MODE LED_Mode); +uint8_t Init_Machine_Leds(); #endif /* DRIVERS_FPGA_FPGA_GPIO_FPGA_GPIO_H_ */ diff --git a/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_Rename.h b/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_Rename.h index 4675dad9f..8a7ce08c1 100644 --- a/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_Rename.h +++ b/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_Rename.h @@ -45,10 +45,7 @@ //#define CART3_RST aaaaaaaa #define GPO_DH_MAGNET GPO_TFEED_BREAK_1 -// ----------------------- BLOWER ----------------------- -#define GPI_BLOWER_TACH F2_Tacho_reg0 -//WHS GPO_BLOWER_PWM - See the stub "GPO_BLOWER_PWM.cs" -#define GPO_BLOWER_PWM_FREQ F2_Prescaler1_reg11 -#define GPO_BLOWER_PWM_LOW F2_Prescaler1_reg6 -#define GPO_BLOWER_PWM_HIGH F2_Prescaler1_reg7 + + + diff --git a/Software/Embedded_SW/Embedded/Drivers/FPGA/Full_Vme/FPGA_Programming_Up.c b/Software/Embedded_SW/Embedded/Drivers/FPGA/Full_Vme/FPGA_Programming_Up.c index 534e2fb44..cb4b413e5 100644 --- a/Software/Embedded_SW/Embedded/Drivers/FPGA/Full_Vme/FPGA_Programming_Up.c +++ b/Software/Embedded_SW/Embedded/Drivers/FPGA/Full_Vme/FPGA_Programming_Up.c @@ -14,8 +14,8 @@ #include "FPGA_Programming_Up.h" #include <inc/hw_memmap.h> - - +#include "Modules/Control/Control.h" +#include "Modules/Control/MillisecTask.h" extern short int main_vme(); @@ -69,8 +69,8 @@ FRESULT FPGA_Programming_Up(FPGA_ID FPGA_Id, char * FullPath, bool IncludeReboot FPGA_JTAG.GPI_TDO.Pin = GPIO_PIN_7; break; default: - //return error - break; + return FR_INVALID_OBJECT; + //break; } FileHandlevme = malloc(sizeof(FIL)); @@ -79,7 +79,7 @@ FRESULT FPGA_Programming_Up(FPGA_ID FPGA_Id, char * FullPath, bool IncludeReboot { return(fresult); } - main_vme(); + fresult = main_vme(); @@ -91,4 +91,64 @@ FRESULT FPGA_Programming_Up(FPGA_ID FPGA_Id, char * FullPath, bool IncludeReboot return fresult; } +/****************************************************************************** + * ======== messageTsk ======== + * Task for this function is created statically. See the project's .cfg file. + * this message task is created statically in system initialization, + ******************************************************************************/ +Mailbox_Handle FPGALoadMsgQ = NULL; +typedef enum +{ + OneFPGALoad, +}FPGALoadMessages; + +typedef struct FPGALoadMessage{ + uint16_t messageId; + FPGA_ID FPGA_Id; + char * FullPath; + bool IncludeReboot; +}FPGALoadMessageStruc; +char FPGAFullPath[MAX_FPGA][50]; + +FRESULT FPGA_Programming_Request(FPGA_ID FPGA_Id, char * FullPath, bool IncludeReboot) +{ + FPGALoadMessageStruc FPGALoadMessage; + + strcpy(FPGAFullPath[FPGA_Id],FullPath); + FPGALoadMessage.messageId = OneFPGALoad; + FPGALoadMessage.FPGA_Id = FPGA_Id; + FPGALoadMessage.FullPath = FPGAFullPath[FPGA_Id]; + FPGALoadMessage.IncludeReboot = IncludeReboot; + if (FPGALoadMsgQ != NULL) + Mailbox_post(FPGALoadMsgQ , &FPGALoadMessage, BIOS_NO_WAIT); + return FR_OK; +} + + +void FPGALoadTask(UArg arg0, UArg arg1) +{ + FPGALoadMessageStruc FPGALoadMessage; + Error_Block eb; + Error_init(&eb); + + FPGALoadMsgQ = Mailbox_create(sizeof(FPGALoadMessageStruc), 4, NULL,&eb); + + while(1) + { + Mailbox_pend(FPGALoadMsgQ , &FPGALoadMessage, BIOS_WAIT_FOREVER); + switch (FPGALoadMessage.messageId) + { + case OneFPGALoad: + //ControlStop(); + //MillisecStop(); + FPGA_Programming_Up(FPGALoadMessage.FPGA_Id,FPGALoadMessage.FullPath,FPGALoadMessage.IncludeReboot); + //ControlStart(); + //MillisecStart(); + //printf( "Finished Load FPGA %d File %s\n", FPGALoadMessage.FPGA_Id,FPGALoadMessage.FullPath ); + break; + default: + break; + } + } +} diff --git a/Software/Embedded_SW/Embedded/Drivers/FPGA/Full_Vme/FPGA_Programming_Up.h b/Software/Embedded_SW/Embedded/Drivers/FPGA/Full_Vme/FPGA_Programming_Up.h index 91ad2a61a..b752f24b3 100644 --- a/Software/Embedded_SW/Embedded/Drivers/FPGA/Full_Vme/FPGA_Programming_Up.h +++ b/Software/Embedded_SW/Embedded/Drivers/FPGA/Full_Vme/FPGA_Programming_Up.h @@ -32,8 +32,10 @@ typedef struct GPIO GPI_TDO; //GPI FPGA->MCU }FPGA_JTAG_GPIO; +//Independent task non blocking call +FRESULT FPGA_Programming_Request(FPGA_ID FPGA_Id, char * FullPath, bool IncludeReboot); +//direct blocking call FRESULT FPGA_Programming_Up(FPGA_ID FPGA_Id, char * FullPath, bool IncludeReboot); - #endif /* DRIVERS_FPGA_FULL_VME_FPGA_PROGRAMMING_UP_H_ */ diff --git a/Software/Embedded_SW/Embedded/Drivers/FPGA/Full_Vme/ispvme/ispvm_ui.c b/Software/Embedded_SW/Embedded/Drivers/FPGA/Full_Vme/ispvme/ispvm_ui.c index 0a94f4afd..c216b9aad 100644 --- a/Software/Embedded_SW/Embedded/Drivers/FPGA/Full_Vme/ispvme/ispvm_ui.c +++ b/Software/Embedded_SW/Embedded/Drivers/FPGA/Full_Vme/ispvme/ispvm_ui.c @@ -237,7 +237,7 @@ unsigned char GetByte() ***************************************************************/ void vme_out_char(unsigned char charOut) { - printf("%c",charOut); + //printf("%c",charOut); } /*************************************************************** * @@ -250,7 +250,7 @@ void vme_out_char(unsigned char charOut) ***************************************************************/ void vme_out_hex(unsigned char hexOut) { - printf("%.2X",hexOut); + //printf("%.2X",hexOut); } /*************************************************************** * @@ -265,7 +265,7 @@ void vme_out_string(char *stringOut) { if(stringOut) { - printf("%s",stringOut); + //printf("%s",stringOut); } } @@ -653,8 +653,8 @@ signed char ispVM( /*const char * a_pszFilename*/ ) //AVI- ***************************************************************/ if ( cRetCode == 0 && g_usExpectedCRC != 0 && ( g_usExpectedCRC != g_usCalculatedCRC ) ) { - printf( "Expected CRC: 0x%.4X\n", g_usExpectedCRC ); - printf( "Calculated CRC: 0x%.4X\n", g_usCalculatedCRC ); + //printf( "Expected CRC: 0x%.4X\n", g_usExpectedCRC ); + //printf( "Calculated CRC: 0x%.4X\n", g_usCalculatedCRC ); return VME_CRC_FAILURE; } diff --git a/Software/Embedded_SW/Embedded/Drivers/FPGA/Full_Vme/ispvme/ivm_core.c b/Software/Embedded_SW/Embedded/Drivers/FPGA/Full_Vme/ispvme/ivm_core.c index d57f44c37..7afad1f1f 100644 --- a/Software/Embedded_SW/Embedded/Drivers/FPGA/Full_Vme/ispvme/ivm_core.c +++ b/Software/Embedded_SW/Embedded/Drivers/FPGA/Full_Vme/ispvme/ivm_core.c @@ -379,7 +379,7 @@ void PrintData( unsigned short a_iDataSize, unsigned char * a_pucData ) //09/11/07 NN Type cast mismatch variables usByteSize = (unsigned short)(a_iDataSize / 8); } - printf( "(" ); + //printf( "(" ); //09/11/07 NN Type cast mismatch variables for ( usByteIndex = (signed short)(usByteSize - 1); usByteIndex >= 0; usByteIndex-- ) { ucByte = a_pucData[ usByteIndex ]; @@ -406,14 +406,14 @@ void PrintData( unsigned short a_iDataSize, unsigned char * a_pucData ) * ***************************************************************/ - printf( "%.02X", ucFlipByte ); + //printf( "%.02X", ucFlipByte ); if ( ( usByteSize - usByteIndex ) % 40 == 39 ) { - printf( "\n\t\t" ); + //printf( "\n\t\t" ); } if(usByteIndex < 0) break; } - printf( ")" ); + //printf( ")" ); } #endif //VME_DEBUG @@ -520,10 +520,10 @@ signed char ispVMCode() #ifdef VME_DEBUG if ( g_usDataType & LHEAP_IN ) { - printf( "LDELAY %s ", GetState( ucState ) ); + //printf( "LDELAY %s ", GetState( ucState ) ); } else { - printf( "STATE %s;\n", GetState( ucState ) ); + //printf( "STATE %s;\n", GetState( ucState ) ); } #endif //VME_DEBUG break; @@ -534,15 +534,15 @@ signed char ispVMCode() #ifdef VME_DEBUG switch( cOpcode ) { case SIR: - printf( "SIR " ); + //printf( "SIR " ); break; case SDR: case XSDR: if ( g_usDataType & LHEAP_IN ) { - printf( "LSDR " ); + //printf( "LSDR " ); } else { - printf( "SDR " ); + //printf( "SDR " ); } break; } @@ -583,10 +583,10 @@ signed char ispVMCode() usDelay &= ~0x8000; if ( g_usDataType & LHEAP_IN ) { - printf( "%.2E SEC;\n", ( float ) usDelay / 1000 ); + //printf( "%.2E SEC;\n", ( float ) usDelay / 1000 ); } else { - printf( "RUNTEST %.2E SEC;\n", ( float ) usDelay / 1000 ); + //printf( "RUNTEST %.2E SEC;\n", ( float ) usDelay / 1000 ); } } else { @@ -598,10 +598,10 @@ signed char ispVMCode() ***************************************************************/ if ( g_usDataType & LHEAP_IN ) { - printf( "%.2E SEC;\n", ( float ) usDelay / 1000000 ); + //printf( "%.2E SEC;\n", ( float ) usDelay / 1000000 ); } else { - printf( "RUNTEST %.2E SEC;\n", ( float ) usDelay / 1000000 ); + //printf( "RUNTEST %.2E SEC;\n", ( float ) usDelay / 1000000 ); } } #endif //VME_DEBUG @@ -619,7 +619,7 @@ signed char ispVMCode() ispVMClocks( usToggle ); #ifdef VME_DEBUG - printf( "RUNTEST %d TCK;\n", usToggle ); + //printf( "RUNTEST %d TCK;\n", usToggle ); #endif //VME_DEBUG break; case ENDDR: @@ -633,7 +633,7 @@ signed char ispVMCode() g_ucEndDR = GetByte(); #ifdef VME_DEBUG - printf( "ENDDR %s;\n", GetState( g_ucEndDR ) ); + //printf( "ENDDR %s;\n", GetState( g_ucEndDR ) ); #endif //VME_DEBUG break; case ENDIR: @@ -647,7 +647,7 @@ signed char ispVMCode() g_ucEndIR = GetByte(); #ifdef VME_DEBUG - printf( "ENDIR %s;\n", GetState( g_ucEndIR ) ); + //printf( "ENDIR %s;\n", GetState( g_ucEndIR ) ); #endif //VME_DEBUG break; case HIR: @@ -658,16 +658,16 @@ signed char ispVMCode() #ifdef VME_DEBUG switch( cOpcode ) { case HIR: - printf( "HIR " ); + //printf( "HIR " ); break; case TIR: - printf( "TIR " ); + //printf( "TIR " ); break; case HDR: - printf( "HDR " ); + //printf( "HDR " ); break; case TDR: - printf( "TDR " ); + //printf( "TDR " ); break; } #endif //VME_DEBUG @@ -685,7 +685,7 @@ signed char ispVMCode() } #ifdef VME_DEBUG - printf( ";\n" ); + //printf( ";\n" ); #endif //VME_DEBUG break; case MEM: @@ -701,7 +701,7 @@ signed char ispVMCode() g_usMaxSize = (unsigned short) ispVMDataSize(); #ifdef VME_DEBUG - printf( "// MEMSIZE %d\n", g_usMaxSize ); + //printf( "// MEMSIZE %d\n", g_usMaxSize ); #endif //VME_DEBUG break; case VENDOR: @@ -716,19 +716,19 @@ signed char ispVMCode() switch ( cOpcode ) { case LATTICE: #ifdef VME_DEBUG - printf( "// VENDOR LATTICE\n" ); + //printf( "// VENDOR LATTICE\n" ); #endif //VME_DEBUG g_cVendor = LATTICE; break; case ALTERA: #ifdef VME_DEBUG - printf( "// VENDOR ALTERA\n" ); + //printf( "// VENDOR ALTERA\n" ); #endif //VME_DEBUG g_cVendor = ALTERA; break; case XILINX: #ifdef VME_DEBUG - printf( "// VENDOR XILINX\n" ); + //printf( "// VENDOR XILINX\n" ); #endif //VME_DEBUG g_cVendor = XILINX; break; @@ -865,7 +865,7 @@ signed char ispVMCode() if(g_iFrequency == 1) g_iFrequency = 1000; #ifdef VME_DEBUG - printf( "FREQUENCY %.2E HZ;\n", ( float ) g_iFrequency * 1000 ); + //printf( "FREQUENCY %.2E HZ;\n", ( float ) g_iFrequency * 1000 ); #endif //VME_DEBUG } else @@ -873,7 +873,7 @@ signed char ispVMCode() if(g_iFrequency == 0) g_iFrequency = 1000; #ifdef VME_DEBUG - printf( "FREQUENCY %.2E HZ;\n", ( float ) g_iFrequency ); + //printf( "FREQUENCY %.2E HZ;\n", ( float ) g_iFrequency ); #endif //VME_DEBUG } break; @@ -957,7 +957,7 @@ signed char ispVMCode() ***************************************************************/ #ifdef VME_DEBUG - printf( "\nINVALID OPCODE: 0x%.2X\n", cOpcode ); + //printf( "\nINVALID OPCODE: 0x%.2X\n", cOpcode ); #endif //VME_DEBUG return VME_INVALID_FILE; @@ -1455,29 +1455,29 @@ signed char ispVMShift( signed char a_cCode ) } #ifdef VME_DEBUG - printf( "%d ", g_usiDataSize ); + //printf( "%d ", g_usiDataSize ); if ( g_usDataType & TDI_DATA ) { - printf( "TDI " ); + //printf( "TDI " ); PrintData( g_usiDataSize, g_pucInData ); } if ( g_usDataType & TDO_DATA ) { - printf( "\n\t\tTDO " ); + //printf( "\n\t\tTDO " ); PrintData( g_usiDataSize, g_pucOutData ); } if ( g_usDataType & MASK_DATA ) { - printf( "\n\t\tMASK " ); + //printf( "\n\t\tMASK " ); PrintData( g_usiDataSize, g_pucOutMaskData ); } if ( g_usDataType & DMASK_DATA ) { - printf( "\n\t\tDMASK " ); + //printf( "\n\t\tDMASK " ); PrintData( g_usiDataSize, g_pucOutDMaskData ); } - printf( ";\n" ); + //printf( ";\n" ); #endif //VME_DEBUG if ( g_usDataType & TDO_DATA || g_usDataType & DMASK_DATA ) { @@ -1586,7 +1586,7 @@ signed char ispVMAmble( signed char Code ) g_usiDataSize = (unsigned short)ispVMDataSize(); #ifdef VME_DEBUG - printf( "%d", g_usiDataSize ); + //printf( "%d", g_usiDataSize ); #endif //VME_DEBUG if ( g_usiDataSize ) { @@ -1631,7 +1631,7 @@ signed char ispVMAmble( signed char Code ) ispVMData( g_pucHIRData ); #ifdef VME_DEBUG - printf( " TDI " ); + //printf( " TDI " ); PrintData( g_usHeadIR, g_pucHIRData ); #endif //VME_DEBUG } @@ -1660,7 +1660,7 @@ signed char ispVMAmble( signed char Code ) ispVMData( g_pucTIRData ); #ifdef VME_DEBUG - printf( " TDI " ); + //printf( " TDI " ); PrintData( g_usTailIR, g_pucTIRData ); #endif //VME_DEBUG } @@ -1689,7 +1689,7 @@ signed char ispVMAmble( signed char Code ) ispVMData( g_pucHDRData ); #ifdef VME_DEBUG - printf( " TDI " ); + //printf( " TDI " ); PrintData( g_usHeadDR, g_pucHDRData ); #endif //VME_DEBUG } @@ -1718,7 +1718,7 @@ signed char ispVMAmble( signed char Code ) ispVMData( g_pucTDRData ); #ifdef VME_DEBUG - printf( " TDI " ); + //printf( " TDI " ); PrintData( g_usTailDR, g_pucTDRData ); #endif //VME_DEBUG } @@ -2017,7 +2017,7 @@ signed char ispVMLCOUNT( unsigned short a_usCountSize ) } #ifdef VME_DEBUG - printf( "LCOUNT %d;\n", a_usCountSize ); + //printf( "LCOUNT %d;\n", a_usCountSize ); #endif //VME_DEBUG /**************************************************************************** @@ -2092,12 +2092,12 @@ signed char ispVMLCOUNT( unsigned short a_usCountSize ) } ispVMStateMachine( ucState ); #ifdef VME_DEBUG - printf( "LDELAY %s ", GetState( ucState ) ); + //printf( "LDELAY %s ", GetState( ucState ) ); #endif //VME_DEBUG break; case SIR: #ifdef VME_DEBUG - printf( "SIR " ); + //printf( "SIR " ); #endif //VME_DEBUG /*************************************************************** * @@ -2110,7 +2110,7 @@ signed char ispVMLCOUNT( unsigned short a_usCountSize ) case SDR: #ifdef VME_DEBUG - printf( "LSDR " ); + //printf( "LSDR " ); #endif //VME_DEBUG /*************************************************************** * @@ -2143,7 +2143,7 @@ signed char ispVMLCOUNT( unsigned short a_usCountSize ) ***************************************************************/ usDelay &= ~0x8000; - printf( "%.2E SEC;\n", ( float ) usDelay / 1000 ); + //printf( "%.2E SEC;\n", ( float ) usDelay / 1000 ); } else { @@ -2153,7 +2153,7 @@ signed char ispVMLCOUNT( unsigned short a_usCountSize ) * ***************************************************************/ - printf( "%.2E SEC;\n", ( float ) usDelay / 1000000 ); + //printf( "%.2E SEC;\n", ( float ) usDelay / 1000000 ); } #endif //VME_DEBUG break; @@ -2169,7 +2169,7 @@ signed char ispVMLCOUNT( unsigned short a_usCountSize ) ispVMClocks( usToggle ); #ifdef VME_DEBUG - printf( "RUNTEST %d TCK;\n", usToggle ); + //printf( "RUNTEST %d TCK;\n", usToggle ); #endif //VME_DEBUG break; case ENDLOOP: @@ -2216,7 +2216,7 @@ signed char ispVMLCOUNT( unsigned short a_usCountSize ) ***************************************************************/ #ifdef VME_DEBUG - printf( "\nINVALID OPCODE: 0x%.2X\n", cOpcode ); + //printf( "\nINVALID OPCODE: 0x%.2X\n", cOpcode ); #endif //VME_DEBUG return VME_INVALID_FILE; @@ -2391,8 +2391,8 @@ void ispVMStateMachine( signed char cNextJTAGState ) void ispVMStart() { #ifdef VME_DEBUG - printf( "// ISPVM EMBEDDED ADDED\n" ); - printf( "STATE RESET;\n" ); + //printf( "// ISPVM EMBEDDED ADDED\n" ); + //printf( "STATE RESET;\n" ); #endif ispVMStateMachine( RESET ); /*step devices to RESET state*/ @@ -2410,9 +2410,9 @@ void ispVMStart() void ispVMEnd() { #ifdef VME_DEBUG - printf( "// ISPVM EMBEDDED ADDED\n" ); - printf( "STATE RESET;\n" ); - printf( "RUNTEST 1.00E-001 SEC;\n" ); + //printf( "// ISPVM EMBEDDED ADDED\n" ); + //printf( "STATE RESET;\n" ); + //printf( "RUNTEST 1.00E-001 SEC;\n" ); #endif ispVMStateMachine( RESET ); /*step devices to RESET state */ @@ -2704,7 +2704,7 @@ signed char ispVMRead( unsigned short a_usiDataSize ) *****************************************************************************/ #ifdef VME_DEBUG - printf( "RECEIVED TDO (" ); + //printf( "RECEIVED TDO (" ); #else vme_out_string( "Display Data: 0x" ); #endif //VME_DEBUG @@ -2728,9 +2728,9 @@ signed char ispVMRead( unsigned short a_usiDataSize ) cMaskByte >>= 1; } #ifdef VME_DEBUG - printf( "%.2X", cDataByte ); + //printf( "%.2X", cDataByte ); if ( ( ( ( a_usiDataSize + 7 ) / 8 ) - usDataSizeIndex ) % 40 == 39 ) { - printf( "\n\t\t" ); + //printf( "\n\t\t" ); } #else vme_out_hex( cDataByte ); @@ -2738,7 +2738,7 @@ signed char ispVMRead( unsigned short a_usiDataSize ) } #ifdef VME_DEBUG - printf( ")\n\n" ); + //printf( ")\n\n" ); #else vme_out_string( "\n\n" ); #endif //VME_DEBUG @@ -2761,7 +2761,7 @@ signed char ispVMRead( unsigned short a_usiDataSize ) else { #ifdef VME_DEBUG - printf( "TOTAL ERRORS: %d\n", usErrorCount ); + //printf( "TOTAL ERRORS: %d\n", usErrorCount ); #endif //VME_DEBUG return VME_VERIFICATION_FAILURE; @@ -3039,7 +3039,7 @@ signed char ispVMProcessLVDS( unsigned short a_usLVDSCount ) g_usLVDSPairCount = a_usLVDSCount; #ifdef VME_DEBUG - printf( "LVDS %d (", a_usLVDSCount ); + //printf( "LVDS %d (", a_usLVDSCount ); #endif //VME_DEBUG /*************************************************************** @@ -3063,17 +3063,17 @@ signed char ispVMProcessLVDS( unsigned short a_usLVDSCount ) #ifdef VME_DEBUG if ( usLVDSIndex < g_usLVDSPairCount - 1 ) { - printf( "%d:%d, ", g_pLVDSList[ usLVDSIndex ].usPositiveIndex, g_pLVDSList[ usLVDSIndex ].usNegativeIndex ); + //printf( "%d:%d, ", g_pLVDSList[ usLVDSIndex ].usPositiveIndex, g_pLVDSList[ usLVDSIndex ].usNegativeIndex ); } else { - printf( "%d:%d", g_pLVDSList[ usLVDSIndex ].usPositiveIndex, g_pLVDSList[ usLVDSIndex ].usNegativeIndex ); + //printf( "%d:%d", g_pLVDSList[ usLVDSIndex ].usPositiveIndex, g_pLVDSList[ usLVDSIndex ].usNegativeIndex ); } #endif //VME_DEBUG } #ifdef VME_DEBUG - printf( ");\n", a_usLVDSCount ); + //printf( ");\n", a_usLVDSCount ); #endif //VME_DEBUG return( 0 ); diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/ADC_MUX/ADC_MUX.c b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/ADC_MUX/ADC_MUX.c index 5f75d7d34..a65a1cf57 100644 --- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/ADC_MUX/ADC_MUX.c +++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/ADC_MUX/ADC_MUX.c @@ -28,6 +28,8 @@ uint32_t MidTank_Pressure_Bits[8];//just for debug static uint8_t Config_Buf[3]; +static double MidThankReadingOffset = 0; + uint32_t I2C_ADC_Config(uint32_t I2C_Slave_Add,uint32_t channel ) { uint32_t Status = OK; @@ -118,6 +120,11 @@ double Calculate_Pressure(uint32_t VsampleInBits ) } */ +void MidTankPressureCorrection(double Offset) +{ + MidThankReadingOffset = Offset; +} + double Calculate_Pressure(uint32_t VsampleInBits ) { double temp, VADC = 0.0 ,PKpa,VSensor,HighMeter,LiquidLitter; @@ -209,7 +216,7 @@ uint32_t Read_MidTank_Pressure_Sensor(MidTank_t MidTank_ID) //0-7 MidTank_Pressure_Bits[MidTank_ID] = VsampleInBits;//just for debug - MidTank_Pressure[MidTank_ID] = Calculate_Pressure(VsampleInBits); + MidTank_Pressure[MidTank_ID] = Calculate_Pressure(VsampleInBits) - MidThankReadingOffset; return Status; } diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/ADC_MUX/ADC_MUX.h b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/ADC_MUX/ADC_MUX.h index 41ba78ffc..c88bfc7a1 100644 --- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/ADC_MUX/ADC_MUX.h +++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/ADC_MUX/ADC_MUX.h @@ -25,5 +25,6 @@ typedef enum uint32_t Read_MidTank_Pressure_Sensor(MidTank_t MidTank_ID); double Get_MidTank_Pressure_Sensor(MidTank_t MidTank_ID); //0-7 +void MidTankPressureCorrection(double Offset); #endif /* DRIVERS_I2C_COMMUNICATION_ADC_MUX_ADC_MUX_H_ */ diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/DAC/Blower.c b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/DAC/Blower.c index 37789abb1..eced74d16 100644 --- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/DAC/Blower.c +++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/DAC/Blower.c @@ -213,11 +213,12 @@ uint32_t Gradual_Increase_Blower(uint32_t Initial_mV,uint32_t Target_mV) Report("Add control callback failed",__FILE__,__LINE__,(int)0,RpWarning,(int)BlowerControlId,0); return ERROR; } + return OK; } uint32_t Cancel_Gradual_Increase_Blower(uint32_t Initial_mV) { Control_Voltage_To_Blower(Initial_mV); - Report("Finished Increasing blower",__FILE__,__LINE__,(int)Initial_mV,RpWarning,(int)millisecondCounter,0); + Report("Cancelled Increasing blower",__FILE__,__LINE__,(int)Initial_mV,RpWarning,(int)millisecondCounter,0); if (RemoveControlCallback(BlowerControlId, Gradual_Increase_Blower_Callback )==OK) { Report("Remove control callback",__FILE__,__LINE__,(int)1,RpWarning,(int)BlowerControlId,0); diff --git a/Software/Embedded_SW/Embedded/Drivers/USB_Communication/USBCDCD.c b/Software/Embedded_SW/Embedded/Drivers/USB_Communication/USBCDCD.c index 4c6b18030..b3ab21f0a 100644 --- a/Software/Embedded_SW/Embedded/Drivers/USB_Communication/USBCDCD.c +++ b/Software/Embedded_SW/Embedded/Drivers/USB_Communication/USBCDCD.c @@ -810,6 +810,13 @@ void USBCDCD_init(void) /* State specific variables */ state = USBCDCD_STATE_UNCONFIGURED; + /*added lines for drivers version 4.178*/ + uint32_t g_ui32SysClock = MAP_SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ |SYSCTL_OSC_MAIN |SYSCTL_USE_PLL |SYSCTL_CFG_VCO_480), 120000000); + USBDCDFeatureSet(0, USBLIB_FEATURE_CPUCLK, &g_ui32SysClock); + //uint32_t ui32PLLRate; + //SysCtlVCOGet(SYSCTL_XTAL_25MHZ, &ui32PLLRate); + //USBDCDFeatureSet(0, USBLIB_FEATURE_USBPLL, &ui32PLLRate); + /* Set the USB stack mode to Device mode with VBUS monitoring */ USBStackModeSet(0, eUSBModeForceDevice, 0); diff --git a/Software/Embedded_SW/Embedded/Embedded.cfg b/Software/Embedded_SW/Embedded/Embedded.cfg index 97c95a452..45ed20a54 100644 --- a/Software/Embedded_SW/Embedded/Embedded.cfg +++ b/Software/Embedded_SW/Embedded/Embedded.cfg @@ -116,6 +116,12 @@ MillisecTaskParams.stackSize = 2048; MillisecTaskParams.priority = 12; Program.global.millisec = Task.create("&MillisecTask", MillisecTaskParams); +var FPGALoad = new Task.Params(); +FPGALoad.instance.name = "FPGALoad"; +FPGALoad.stackSize = 4096; +FPGALoad.priority = 5; +Program.global.FPGALoad = Task.create("&FPGALoadTask", FPGALoad); + var ControlTaskParams = new Task.Params(); ControlTaskParams.instance.name = "control"; ControlTaskParams.stackSize = 2048; diff --git a/Software/Embedded_SW/Embedded/Main.c b/Software/Embedded_SW/Embedded/Main.c index 430bb1181..64505193d 100644 --- a/Software/Embedded_SW/Embedded/Main.c +++ b/Software/Embedded_SW/Embedded/Main.c @@ -83,6 +83,8 @@ static volatile uint32_t g_ui32SysTickCount = 0; // Flags used to pass commands from interrupt context to the main loop. static volatile uint32_t g_ui32Flags; +bool Machine_Idle_Mode = false; + //MessageContainer createContainer(MessageType type, char* token, protobuf_c_boolean completed, void* response, size_t (*packPtr)(void*, uint8_t*), size_t (*sizePtr)(void*)); uint32_t MainDummyFunction(uint32_t IfIndex, uint32_t ReadValue) { @@ -205,7 +207,13 @@ int main(void) //GetFiles(); - to start jtag //GetVmeByte(); - //////////////////////////// + // + //test_avi(); //example for shai + + #ifndef EVALUATION_BOARD + Init_Machine_Leds(); + #endif + // Enable interrupts to the processor. // diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c index 7a9f8fd37..cf8684ddb 100644 --- a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c +++ b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c @@ -79,7 +79,7 @@ typedef struct AlarmHandlingMessage{ // uint32_t Data; }AlarmHandlingMessageStruc; -#define MAX_SYSTEM_ALARMS EVENT_TYPE__ELECTRICAL_CABINET_FANS_STOPPED+1 +#define MAX_SYSTEM_ALARMS 300+1 typedef enum { TemperatureAlarm, @@ -215,8 +215,53 @@ const AlarmHandlingItemStruc AlarmItem[MAX_SYSTEM_ALARMS]={ {eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5 ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_B,"DyeingHead 5 PT100 Heating Failure"}, {eOneSecond,TemperatureAlarm,TEMP_SENSE_AN_ENCLOSURETEMP3, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6 ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_B,"DyeingHead 6 PT100 Heating Failure"}, {eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1, HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_B,"Dryer PT100 Heating Failure"}, + { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RLOADING , HARDWARE_MOTOR_TYPE__MOTO_RLOADING , x_STATUS_OCD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__RIGHT_LOADER_MOTOR_OVERCURRENT ," MotorRightLoaderOverCurrent " }, /* 3004 */ + { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LLOADING , HARDWARE_MOTOR_TYPE__MOTO_LLOADING , x_STATUS_OCD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LEFT_LOADER_MOTOR_OVERCURRENT ," MotorLeftLoaderOverCurrent " }, /* 3006 */ + { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM , x_STATUS_OCD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LOADING_ARM_MOTOR_OVERCURRENT ," MotorLoadindARMOverCurrent " }, /* 3009 */ + { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER2 , HARDWARE_MOTOR_TYPE__MOTO_LDANCER2 , x_STATUS_OCD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__WINDER_MOTOR_OVERCURRENT /*EVENT_TYPE__WINDER_DANCER_MOTOR_OVERCURRENT*/ ," MotorWinderDancerOverCurrent " }, /* 3036 */ + { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER1 , HARDWARE_MOTOR_TYPE__MOTO_LDANCER1 , x_STATUS_OCD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__PULLER_MOTOR_OVERCURRENT /*EVENT_TYPE__PULLER_DANCER_MOTOR_OVERCURRENT*/ ," MotorPullerDancerOverCurrent " }, /* 3037 */ + { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RDANCER , HARDWARE_MOTOR_TYPE__MOTO_RDANCER , x_STATUS_OCD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__FEEDER_MOTOR_OVERCURRENT /*EVENT_TYPE__FEEDER_DANCER_MOTOR_OVERCURRENT*/ ," MotorFeederDancerOverCurrent " }, /* 3038 */ + { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID , x_STATUS_OCD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DRYER_MOTOR_OVERCURRENT /*EVENT_TYPE__DRYER_LID_MOTOR_OVERCURRENT*/ ," MotorDryerLidOverCurrent " }, /* 4017 */ + { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_LID , HARDWARE_MOTOR_TYPE__MOTO_DH_LID , x_STATUS_OCD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_COVER_MOTOR_OVERCURRENT ," MotorDyeingHeadCoverOverCurrent " }, /* 5031 */ + { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH , x_STATUS_OCD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_MECHANISM_MOTOR_OVERCURRENT ," MotorDyeingHeadCleaningMechanismOverCurrent "}, /* 5035 */ + { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD , x_STATUS_OCD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_HEAD_MOTOR_OVERCURRENT ," MotorDyeingHeadCleaningHeadOverCurrent " }, /* 5039 */ + + { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RLOADING , HARDWARE_MOTOR_TYPE__MOTO_RLOADING , x_STATUS_TH_SD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__RIGHT_LOADER_MOTOR_OVERTEMPERATURE ," MotorRightLoaderOverTemperature " }, /* 3011 */ + { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LLOADING , HARDWARE_MOTOR_TYPE__MOTO_LLOADING , x_STATUS_TH_SD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LEFT_LOADER_MOTOR_OVERTEMPERATURE ," MotorLeftLoaderOverTemperature " }, /* 3013 */ + { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM , x_STATUS_TH_SD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LOADING_ARM_MOTOR_OVERTEMPERATURE ," MotorLoadArmOverTemperature " }, /* 3016 */ + { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER2 , HARDWARE_MOTOR_TYPE__MOTO_LDANCER2 , x_STATUS_TH_SD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__WINDER_DANCER_MOTOR_OVERTEMPERATURE ," MotorWinderDancerOverTemperature " }, /* 3039 */ + { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER1 , HARDWARE_MOTOR_TYPE__MOTO_LDANCER1 , x_STATUS_TH_SD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__PULLER_DANCER_MOTOR_OVERTEMPERATURE ," MotorPullerDancerOverTemperature " }, /* 3040 */ + { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RDANCER , HARDWARE_MOTOR_TYPE__MOTO_RDANCER , x_STATUS_TH_SD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__FEEDER_DANCER_MOTOR_OVERTEMPERATURE ," MotorFeederDancerOverTemperature " }, /* 3041 */ + { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID , x_STATUS_TH_SD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DRYER_LID_MOTOR_OVERTEMPERATURE ," MotorDryerLidOverTemperature " }, /* 4018 */ + { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_LID , HARDWARE_MOTOR_TYPE__MOTO_DH_LID , x_STATUS_TH_SD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_COVER_MOTOR_OVERTEMPERATURE ," MotorDyeingHeadCoverOverTemperature " }, /* 5032 */ + { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH , x_STATUS_TH_SD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_MECHANISM_MOTOR_OVERTEMPERATURE ," MotorDyeingHeadCleaningOverTemperature " }, /* 5036 */ + { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD , x_STATUS_TH_SD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_HEAD_MOTOR_OVERTEMPERATURE ," MotorDyeingHeadCleaningHeadOverTemperature "}, /* 5040 */ + + { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RLOADING , HARDWARE_MOTOR_TYPE__MOTO_RLOADING ,x_STATUS_STEP_LOSS_A , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LOADING_ARM_MOTOR_STALL ," MotorLoadingARMStall " }, /* 3018 */ + { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LLOADING , HARDWARE_MOTOR_TYPE__MOTO_LLOADING ,x_STATUS_STEP_LOSS_A , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__WINDER_DANCER_MOTOR_STALL ," MotorWinderDancesStall " }, /* 3020 */ + { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM ,x_STATUS_STEP_LOSS_A , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LOADING_ARM_MOTOR_STALL ," MotorLoadingARMStall " }, /* 3023 */ + { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER2 , HARDWARE_MOTOR_TYPE__MOTO_LDANCER2 ,x_STATUS_STEP_LOSS_A , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__WINDER_DANCER_MOTOR_STALL ," MotorWinderDancesStall " }, /* 3042 */ + { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER1 , HARDWARE_MOTOR_TYPE__MOTO_LDANCER1 ,x_STATUS_STEP_LOSS_A , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__PULLER_DANCER_MOTOR_STALL ," MotorPullerDancerStall " }, /* 3043 */ + { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RDANCER , HARDWARE_MOTOR_TYPE__MOTO_RDANCER ,x_STATUS_STEP_LOSS_A , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__FEEDER_DANCER_MOTOR_STALL ," MotorFeederDancerStall " }, /* 3044 */ + { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID ,x_STATUS_STEP_LOSS_A , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DRYER_LID_MOTOR_STALL ," MotorDryerLidStall " }, /* 4019 */ + { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_LID , HARDWARE_MOTOR_TYPE__MOTO_DH_LID ,x_STATUS_STEP_LOSS_A , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_COVER_MOTOR_STALL ," MotorDyeingHeadCoverStall " }, /* 5033 */ + { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH ,x_STATUS_STEP_LOSS_A , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_MECHANISM_MOTOR_STALL ," MotorDyeingHeadCleaningMechanismStall " }, /* 5037 */ + { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD ,x_STATUS_STEP_LOSS_A , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_HEAD_MOTOR_STALL ," MotorDryeingHeadCleaningStall " }, /* 5041 */ + + { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RLOADING , HARDWARE_MOTOR_TYPE__MOTO_RLOADING , x_STATUS_UVLO , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__RIGHT_LOADER_MOTOR_UNDERVOLTAGE ," MotorRightLoaderUnderVoltage " }, /* 3025 */ + { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LLOADING , HARDWARE_MOTOR_TYPE__MOTO_LLOADING , x_STATUS_UVLO , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LEFT_LOADER_MOTOR_UNDERVOLTAGE ," MotorLeftLoaderUnderVoltage " }, /* 3027 */ + { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM , x_STATUS_UVLO , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LOADING_ARM_MOTOR_UNDERVOLTAGE ," MotorLoaderARMUnderVoltage " }, /* 3030 */ + { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER2 , HARDWARE_MOTOR_TYPE__MOTO_LDANCER2 , x_STATUS_UVLO , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__WINDER_DANCER_MOTOR_UNDERVOLTAGE ," MotorWinderDancerUnderVoltage " }, /* 3045 */ + { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER1 , HARDWARE_MOTOR_TYPE__MOTO_LDANCER1 , x_STATUS_UVLO , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__PULLER_DANCER_MOTOR_UNDERVOLTAGE ," MotorPullerDancerUnderVoltage " }, /* 3046 */ + { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RDANCER , HARDWARE_MOTOR_TYPE__MOTO_RDANCER , x_STATUS_UVLO , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__FEEDER_DANCER_MOTOR_UNDERVOLTAGE ," MotorFeederDancerUnderVoltage " }, /* 3047 */ + { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID , x_STATUS_UVLO , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DRYER_LID_MOTOR_UNDERVOLTAGE ," MotorDryerLidUnderVoltage " }, /* 4020 */ + { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_LID , HARDWARE_MOTOR_TYPE__MOTO_DH_LID , x_STATUS_UVLO , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_COVER_MOTOR_UNDERVOLTAGE ," MotorDyeingHeadCoverUnderVoltage " }, /* 5034 */ + { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH , x_STATUS_UVLO , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_MECHANISM_MOTOR_UNDERVOLTAGE ," MotorDyeingHeadCleaningUnderVoltage " }, /* 5038 */ + { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD , x_STATUS_UVLO , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_HEAD_MOTOR_UNDERVOLTAGE ," MotorDyeingHeadCleaningHeadUnderVoltage " }, /* 5042 */ {eOneSecond,DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__THREAD_BREAK,"Thread Break"}, - {eOneSecond,DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE,"Thread Tension Control Failure"}, + {eOneSecond,DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_FEEDER_DANCER,"Thread Feeder Tension Control Failure"}, + {eOneSecond,DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_PULLER_DANCER,"Thread Puller Tension Control Failure"}, + {eOneSecond,DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_WINDER_DANCER,"Thread Winder Tension Control Failure"}, {eOneSecond,DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__WINDER_CONE_DOES_NOT_EXIST,"No cone in winder"} }; diff --git a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c index 10286853e..4f78d2134 100644 --- a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c +++ b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c @@ -83,6 +83,8 @@ bool watchdogCriticalAlarm = false; uint32_t msec_millisecondCounter = 0; +extern bool Machine_Idle_Mode; + MillisecMotorDataStruc ScrewSetMaxSpeedPending = {0}; MillisecMotorDataStruc ScrewMovePending = {0}; MillisecMotorDataStruc MotorData[NUM_OF_MOTORS] = {0}; @@ -446,7 +448,8 @@ uint32_t MillisecLowLoop(uint32_t tick) //Speed_Data = Calculate_Speed_Sensor_Velocity(); //MillisecReadFromTempSensor(Sensor_Read, NULL); //if (Sensor_Read++ >= MAX_TEMPERATURE_SENSOR_ID) Sensor_Read = 0; - //Control_LED1_PWM(); + if(Machine_Idle_Mode == true) + Machine_Idle_Breathing_Led(); } if (Hundred_msTick) { diff --git a/Software/Embedded_SW/Embedded/Modules/Control/PIDAlgo.c b/Software/Embedded_SW/Embedded/Modules/Control/PIDAlgo.c index f9aee7929..a443b4785 100644 --- a/Software/Embedded_SW/Embedded/Modules/Control/PIDAlgo.c +++ b/Software/Embedded_SW/Embedded/Modules/Control/PIDAlgo.c @@ -71,3 +71,51 @@ float AdvancedPIDAlgorithmCalculation(float _setPoint,float _mesuredParam , PID_ return output; } +float TestPIDAlgorithmCalculation(float _setPoint,float _mesuredParam , PID_Config_Params *params, float *_pre_error, float *_integral) +{ + float error; + float derivative; + float output; + + //double error = *mySetpoint - input; + error = _setPoint - _mesuredParam; + //ITerm+= (ki * error); + *_integral = *_integral + (error*params->Ki); + /* if(ITerm > outMax) + { + ITerm= outMax; + } + else if(ITerm < outMin) + { + ITerm= outMin; + } */ + if(*_integral > params->MAX) + { + *_integral = params->MAX; + } + else if(*_integral < params->MIN) + { + *_integral = params->MIN; + } + // double dInput = (input - lastInput); + derivative = error - *_pre_error; + + /*Compute PID Output*/ + // double output = kp * error + ITerm- kd * dInput; + output = params->Kp*error/params->ProportionalErrorMultiplier + *_integral/params->IntegralErrorMultiplier + params->Kd*derivative; + + //Saturation Filter + if(output > params->MAX) + { + output = params->MAX; + } + else if(output < params->MIN) + { + output = params->MIN; + } + + //Update error + *_pre_error = error; + + return output; +} diff --git a/Software/Embedded_SW/Embedded/Modules/Control/control.c b/Software/Embedded_SW/Embedded/Modules/Control/control.c index 538e251ef..69820e306 100644 --- a/Software/Embedded_SW/Embedded/Modules/Control/control.c +++ b/Software/Embedded_SW/Embedded/Modules/Control/control.c @@ -51,6 +51,7 @@ #include <inc/hw_ints.h> #include "drivers/adc_sampling/adc.h" +#include "Modules/General/buttons.h" #include "control.h" #include "MillisecTask.h" @@ -98,7 +99,7 @@ uint32_t ControlDatalog[MAX_TANGO_CONTROL_DEVICES]; uint16_t ControlBacklog[MAX_BACKLOG_SIZE]={0}; uint16_t backlogindex = 0; uint32_t Control_timerBase = TIMER0_BASE; //Timer handle -uint32_t MaxHighDevices = 0xFF; +uint32_t MaxHighDevices = 0; /******************** Functions ********************************************/ void OneMilliSecondFunction(UArg arg0); @@ -124,7 +125,7 @@ void ControlInit(void) ControlRestart = false; memset(ControlDatalog,0,sizeof(uint32_t)*MAX_TANGO_CONTROL_DEVICES); - MaxHighDevices = 0xFF; + MaxHighDevices = 0; for (Device_i = 0; Device_i < MAX_TANGO_CONTROL_DEVICES; Device_i++) { ControlArray[Device_i].ControlActive = false; @@ -157,10 +158,20 @@ void ControlStop(void) uint32_t ControlActivityLed( uint32_t Parameter1) { static bool flag = false; + static uint8_t counter; + const uint8_t Blink_Freq = 15;//odd number + if (flag==true) { COMM_RED_LED_ON; ACTIVITY_RED_LED_OFF; // Heaters indication - all the Heaters OFF + if(power.color == fastBILNK) + Pannel_Leds(POWER_ON_OFF,MODE_OFF); + + if((power.color == BLINK) && (counter % Blink_Freq == 0) ) + { + Pannel_Leds(POWER_ON_OFF,MODE_OFF); + } flag = false; } else @@ -168,8 +179,22 @@ uint32_t ControlActivityLed( uint32_t Parameter1) COMM_RED_LED_OFF; if (HeaterActive > 0)// Blink the led on heating ACTIVITY_RED_LED_ON;// Heaters indication - at least one of the Heaters is ON + + if(power.color == fastBILNK) + Pannel_Leds(POWER_ON_OFF,MODE_ON); + + if((power.color == BLINK) && (counter % Blink_Freq == 0) ) + { + Pannel_Leds(POWER_ON_OFF,MODE_ON); + } + flag = true; } + + if (counter < 0xFF) + counter++; + else + counter = Blink_Freq + 1; return OK; } uint32_t ControlEmptyCBFunction(uint32_t IfIndex, uint32_t ReadValue) @@ -218,13 +243,8 @@ uint32_t AddControlCallback( ControlCBFunction Callback, CTRL_TIMING_ENUM CtrlF break; } } -/* if (MaxHighDevices == 0xFF) - MaxHighDevices = deviceId; - else - { - if ((deviceId!=0xFF )&&(deviceId> MaxHighDevices)) - MaxHighDevices = deviceId; - } + /* if ((deviceId!=0xFF )&&(deviceId> MaxHighDevices)) + // MaxHighDevices = deviceId; } else { @@ -339,23 +359,7 @@ uint32_t GetControlLowDevice_i(void) } uint32_t ControlLoop(uint32_t tick) { - //call all modules control functions - //test dancers and speed encoders - //check all callback units (state machine waiting for completion of a change) - //uint32_t ControlDevice_i; - /*bool Ten_msTick, Hundred_msTick, Onesecond_Tick,Tick98,Tick998; - Ten_msTick = (tick%eTenMillisecond == 0) ?true:false; - Hundred_msTick = (tick%eHundredMillisecond == 0) ?true:false; -// Hundred_msTick = (tick%200 == 0) ?true:false; - Onesecond_Tick = (tick%eOneSecond == 0) ?true:false; - Tick98 = (tick%eHundredMillisecond == 98) ?true:false; -// Tick98 = (tick%200 == 199) ?true:false; - Tick998 = (tick%eOneSecond == 996) ?true:false; -*/ - //ROM_IntMasterDisable(); - //if (MaxHighDevices == 0xFF) - // return OK; - //for (ControlDevice_i = 0; ControlDevice_i <= MaxHighDevices;ControlDevice_i++) + //for (ControlDevice_i = 0; ControlDevice_i < MaxHighDevices;ControlDevice_i++) for (ControlDevice_i = 0; ControlDevice_i < MAX_TANGO_CONTROL_DEVICES;ControlDevice_i++) { if (ControlArray[ControlDevice_i].ControlActive) @@ -386,18 +390,6 @@ uint32_t ControlLoop(uint32_t tick) } uint32_t ControlLowLoop(uint32_t tick) { - //call all modules control functions - //test dancers and speed encoders - //check all callback units (state machine waiting for completion of a change) - //uint32_t Device_i; - //bool Ten_msTick, Hundred_msTick, Onesecond_Tick,Tick98,Tick998; - //Ten_msTick = (tick%eTenMillisecond == 0) ?true:false; - //Hundred_msTick = (tick%eHundredMillisecond == 0) ?true:false; - //Onesecond_Tick = (tick%eOneSecond == 0) ?true:false; - //Tick98 = (tick%eHundredMillisecond == 98) ?true:false; - //Tick998 = (tick%eOneSecond == 996) ?true:false; - - //ROM_IntMasterDisable(); for (ControlLowDevice_i = 0; ControlLowDevice_i < MAX_TANGO_CONTROL_DEVICES;ControlLowDevice_i++) { if (ControlArray[ControlLowDevice_i].ControlActive) diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsJogging.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsJogging.c index 42f02556e..48f2e1e20 100644 --- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsJogging.c +++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsJogging.c @@ -145,10 +145,12 @@ uint32_t DispenserJoggingRequestFunc(MessageContainer* requestContainer) { case MOTOR_DIRECTION__Forward: Control3WayValvesWithCallback ((Valves_t) request->index, Dispenser_Mixer, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer + SysCtlDelay(180000); direction = MotorsCfg[MotorId].directionthreadwize; break; case MOTOR_DIRECTION__Backward: Control3WayValvesWithCallback ((Valves_t) request->index, MidTank_Dispenser, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer + SysCtlDelay(180000); direction = 1-MotorsCfg[MotorId].directionthreadwize; break; } diff --git a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c index a884c3e21..6d64bdf66 100644 --- a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c +++ b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c @@ -109,10 +109,24 @@ void LoadConfigurationParameters(ConfigurationParameters *Params) EmbeddedParameters.initialdispensertimeout = 10000; EmbeddedParameters.has_initialdispensertimelag = true; EmbeddedParameters.initialdispensertimelag = 100; + EmbeddedParameters.has_dispenserbuildpressurespeed = true; EmbeddedParameters.dispenserbuildpressurespeed=500; + EmbeddedParameters.has_dispenserbuildpressurelimit = true; EmbeddedParameters.dispenserbuildpressurelimit=1.5 ; + EmbeddedParameters.has_dispenserbuildpressuretimeout = true; EmbeddedParameters.dispenserbuildpressuretimeout=20000; + EmbeddedParameters.has_dispenserbuildpressurelag = true; EmbeddedParameters.dispenserbuildpressurelag=50; + EmbeddedParameters.has_acheatersloweroperationlimit = true; + EmbeddedParameters.acheatersloweroperationlimit = 995; + 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.5; FileWrite(&EmbeddedParameters,sizeof(EmbeddedParameters),EmbeddedParametersPath); } @@ -138,6 +152,8 @@ uint32_t EmbeddedParametersInit(void) IDS_Dispenser_SetBackLashValues(EmbeddedParameters.initialdispenserpressure, EmbeddedParameters.initialdispensertimeout, EmbeddedParameters.initialdispensertimelag); IDS_Dispenser_SetPrepareValues(EmbeddedParameters.dispenserbuildpressurespeed, EmbeddedParameters.dispenserbuildpressurelimit, EmbeddedParameters.dispenserbuildpressuretimeout, EmbeddedParameters.dispenserbuildpressurelag); 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); @@ -188,6 +204,8 @@ uint32_t HWConfiguration(UploadHardwareConfigurationRequest* UploadRequest) upload_hardware_configuration_request__free_unpacked(UploadRequest,NULL); return ERROR; } + // LoadDancerConfigMessage(); + //StoreDancerConfigMessage(); if (request->n_pidcontrols <= HARDWARE_PID_CONTROL_TYPE__Dispenser8) { for (PID_i = 0; PID_i < request->n_pidcontrols ; PID_i++) diff --git a/Software/Embedded_SW/Embedded/Modules/General/buttons.c b/Software/Embedded_SW/Embedded/Modules/General/buttons.c index 68199d19f..f80727dfc 100644 --- a/Software/Embedded_SW/Embedded/Modules/General/buttons.c +++ b/Software/Embedded_SW/Embedded/Modules/General/buttons.c @@ -10,8 +10,9 @@ #include "drivers/FPGA/FPGA_GPIO/FPGA_GPIO.h"//#include "FPGA_GPIO.h" // use for FPGA IO #include "DataDef.h" // use for FPGA IO #include "Modules/Control/control.h" // use for FPGA IO - +#include "Modules/General/buttons.h" #include "StateMachines/Printing/PrintingSTM.h" +#include "drivers/FPGA/FPGA_GPIO/FPGA_GPIO.h" #include <stdlib.h> #include <stdint.h> @@ -26,15 +27,8 @@ int ch_to_power_down(); int ch_to_power_up(); int thredJog(); -typedef enum -{ - colorOFF = 0, - BLUE, - BLINK, - fastBILNK, - BREATHING -} PBcolor; +/* typedef enum { OFFPB = 0, @@ -43,7 +37,7 @@ typedef enum LONGPB , REPLONGPB //repeat long PB }PBstat; - +*/ typedef enum { MSEC = 0, @@ -53,47 +47,26 @@ typedef enum MORE5000 }timems; -typedef enum -{ - sttOFF = 0, - sttON, - sttDISABLE, - sttENABLE, - sttIDLE, - sttJOGGING, - sttRDY, - sttPRELOAD, - sttLOADING, - sttLOADSUCSESS, - sttLOADFAIL -} PBmachinState; + //enum PBstat OnOffPBstate = OFFPB; //enum PBstat ret //enum PBstat threadPB = OFFPB; -struct button -{ - char bttn_name[10]; //option - int bttn_status; // 0=release 1=press - /* enum */ PBstat Action; //offPB,shortPB,longPB,countPB,replongPB - /* enum */ PBcolor color; //off, blue, blink, bithing - /* enum */ PBmachinState state; //sttOFF, sttON, sttDISABLE, sttENABLE, sttIDLE, sttJOGGING - uint32_t count; -}; -struct button power , jog, load; + +button power , jog, load; uint32_t ButtonsCallBackFunction(uint32_t IfIndex, uint32_t ReadValue); uint32_t ButtonsCBFunction(uint32_t IfIndex, uint32_t ReadValue); -uint32_t ShortLongOffPB(uint8_t OnOffPB, struct button *pBtn); -uint32_t StateMachine(struct button *pBtn); +uint32_t ShortLongOffPB(uint8_t OnOffPB, button *pBtn); +uint32_t StateMachine( button *pBtn); uint32_t ButtonJogCallBackFunction(uint32_t IfIndex, uint32_t ReadValue); uint32_t ButtonJogCBFunction(uint32_t IfIndex, uint32_t ReadValue); uint8_t thraedJogging(uint8_t off); -uint32_t setJoggingEnableCondition(struct button *pBtn); -uint32_t joggingMachine(uint8_t OnOffPB, struct button *pBtn); +uint32_t setJoggingEnableCondition( button *pBtn); +uint32_t joggingMachine(uint8_t OnOffPB, button *pBtn); uint32_t ButtonLoadCallBackFunction(uint32_t IfIndex, uint32_t ReadValue); @@ -251,7 +224,7 @@ int StopTimer() //ShortLongOffPB( OnOffPB, &ret) -uint32_t ShortLongOffPB(uint8_t OnOffPB, struct button *pBtn) +uint32_t ShortLongOffPB(uint8_t OnOffPB, button *pBtn) { uint8_t parameter = 0 ; // why we need it!!!! @@ -333,7 +306,7 @@ uint32_t ShortLongOffPB(uint8_t OnOffPB, struct button *pBtn) -uint32_t StateMachine(struct button *pBtn) //short press(=0)/long press(=1) +uint32_t StateMachine( button *pBtn) //short press(=0)/long press(=1) { uint8_t parameter = 1; @@ -373,10 +346,12 @@ uint32_t StateMachine(struct button *pBtn) //short press(=0)/long press(=1) { case LONGPB: //Power off from idle pBtn->state = sttOFF; // todo + Pannel_Leds(POWER_ON_OFF,MODE_OFF); //AVI+ - TODO option MODE_ON to stop Breathing and the led will turn off in power down REPORT_MSG(parameter,"Power state is OFF "); break; case SHORTPB: //Wake up from idle pBtn->state = sttON;// to do ? + Pannel_Leds(POWER_ON_OFF,MODE_ON); //AVI+ REPORT_MSG(parameter,"Power state is ON "); break; default: @@ -406,7 +381,7 @@ return 0; -uint32_t setJoggingEnableCondition(struct button *pBtn) +uint32_t setJoggingEnableCondition( button *pBtn) { if (0 // 1. @@ -443,12 +418,13 @@ return 0; */ -uint32_t joggingMachine(uint8_t OnOffPB, struct button *pBtn) +uint32_t joggingMachine(uint8_t OnOffPB, button *pBtn) { if (sttDISABLE == pBtn->state) { // jogging is disable pBtn->color = colorOFF; + Pannel_Leds(THREAD_JOGGING,MODE_OFF);//AVI+ } else { @@ -456,6 +432,7 @@ uint32_t joggingMachine(uint8_t OnOffPB, struct button *pBtn) { ThreadAbortJoggingFunc(); // to do!!!! pBtn->color = BLUE; + Pannel_Leds(THREAD_JOGGING,MODE_ON);//AVI+ } else { @@ -534,5 +511,13 @@ ShortLongOffPB( threadPB, ret,struct button *pBtn); } */ +void test_avi() +{ + + power.color = BLINK; + //power.color = fastBILNK + //Machine_Idle_Mode = true; + +} diff --git a/Software/Embedded_SW/Embedded/Modules/General/buttons.h b/Software/Embedded_SW/Embedded/Modules/General/buttons.h index 897fb6031..e7a611e9b 100644 --- a/Software/Embedded_SW/Embedded/Modules/General/buttons.h +++ b/Software/Embedded_SW/Embedded/Modules/General/buttons.h @@ -1,6 +1,51 @@ #ifndef BUTTONS_H #define BUTTONS_H +typedef enum +{ + colorOFF = 0, + BLUE, + BLINK, + fastBILNK, + BREATHING +} PBcolor; + +typedef enum +{ + OFFPB = 0, + COUNTPB , + SHORTPB , + LONGPB , + REPLONGPB //repeat long PB +}PBstat; + +typedef enum +{ + sttOFF = 0, + sttON, + sttDISABLE, + sttENABLE, + sttIDLE, + sttJOGGING, + sttRDY, + sttPRELOAD, + sttLOADING, + sttLOADSUCSESS, + sttLOADFAIL +} PBmachinState; + +typedef struct +{ + char bttn_name[10]; //option + int bttn_status; // 0=release 1=press + /* enum */ PBstat Action; //offPB,shortPB,longPB,countPB,replongPB + /* enum */ PBcolor color; //off, blue, blink, bithing + /* enum */ PBmachinState state; //sttOFF, sttON, sttDISABLE, sttENABLE, sttIDLE, sttJOGGING + uint32_t count; +}button; + +extern button power , jog, load; + uint32_t Buttons_Init(void); uint32_t Button_load_Init(void); uint32_t Button_JOG_Init(void); diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h index d8c4e287d..8a77f98a2 100644 --- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h +++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h @@ -23,6 +23,7 @@ void LoadHeaterState(HeaterType HeaterType,HeaterState *HeaterState); uint32_t LoadHeaterSetPoint(HeaterType HeaterType); void Heaters_SetOverHeatTimeOutValues(uint32_t OverHeatTimeout, uint32_t UnderHeatTimeout); +void Heaters_SetOperationLimits(int acheatersloweroperationlimit,int acheatersupperoperationlimit,int dcheatersloweroperationlimit,int dcheatersupperoperationlimit); uint32_t HeatersEnd(void); diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c index aa9e4df4a..50b4658c1 100644 --- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c +++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c @@ -40,6 +40,10 @@ int Overheat_Count_Limit = OVERHEAT_COUNT_LIMIT; int Underheat_Count_Limit = UNDERHEAT_COUNT_LIMIT; + int AcHeatersLoweroperationLimit = 995; + int AcHeatersUpperoperationLimit = 1005; + int DcHeatersLoweroperationLimit = 978; + int DcHeatersUpperoperationLimit = 1002; typedef enum { @@ -94,6 +98,7 @@ char TimeSliceAllocation[MAX_TIMESLICES] = {0xFF}; int DCTimeSliceAllocation[MAX_HEATERS_NUM] = {0}; bool TimerActivated = false; +char ACheatstr[100]; Mailbox_Handle HeatersControlMsgQ = NULL; //bool InitialHeating = true; @@ -155,6 +160,13 @@ void Heaters_SetOverHeatTimeOutValues(uint32_t OverHeatTimeout, uint32_t UnderHe Overheat_Count_Limit = OverHeatTimeout; Underheat_Count_Limit = UnderHeatTimeout; } +void Heaters_SetOperationLimits(acheatersloweroperationlimit,acheatersupperoperationlimit,dcheatersloweroperationlimit,dcheatersupperoperationlimit) +{ + AcHeatersLoweroperationLimit = acheatersloweroperationlimit; + AcHeatersUpperoperationLimit = acheatersupperoperationlimit; + DcHeatersLoweroperationLimit = dcheatersloweroperationlimit; + DcHeatersUpperoperationLimit = dcheatersupperoperationlimit; +} void HeatersControlStop(void) { @@ -190,8 +202,6 @@ void LoadHeaterState(HeaterType HeaterType,HeaterState *HeaterState) double temp = TemperatureSensorRead(HeaterId2PT100Id[HeaterId]); //double temp = HeaterPreviousRead[HeaterId];//TemperatureSensorRead(HeaterId2PT100Id[HeaterId]); - - HeaterState->has_heatertype = true; HeaterState->heatertype = HeaterType; HeaterState->has_setpoint = true; @@ -215,6 +225,7 @@ void LoadHeaterState(HeaterType HeaterType,HeaterState *HeaterState) uint32_t HeatersSingleHeaterEnd(HardwarePidControlType HeaterId) { int status = OK; + Report("HeatersSingleHeaterEnd ", __FILE__,__LINE__,HeaterId, RpMessage, 0, 0); if (HeaterId >= MAX_AC_HEATERS) //DC Heaters { if (ControlIdtoHeaterId [HeaterId]!=0xFF) @@ -348,7 +359,7 @@ uint32_t HeaterCommandRequestMessage(int HeaterId, bool OnOff, int Temperature) } else if ((HeaterState == HEATER_ON)&& (OnOff == HEATER_ON)) //set temperature { - if (HeaterPIDConfig[HeaterId].m_SetParam < HeaterCmd[HeaterId].targettemperatue) //#bug 221 + //if (HeaterPIDConfig[HeaterId].m_SetParam < HeaterCmd[HeaterId].targettemperatue) //#bug 221 { PrepareHeater(HeaterId,Temperature); //prepare the heaters control info } @@ -364,13 +375,10 @@ uint32_t HeaterCommandRequestMessage(int HeaterId, bool OnOff, int Temperature) //turn off the heater HeatersSingleHeaterEnd(HeaterId); } - /*else //heater off, and the heater is not ready yet - { - //turn off the heater - HeatersSingleHeaterEnd(HeaterId); - //stop the control - HeaterPIDConfig[HeaterId].m_SetParam = 0; - }*/ + + //usnprintf(ACheatstr, 254, "HeaterCommandRequestMessage(Id %d,OnOff %d,Temperature %d)",HeaterId, OnOff, Temperature); + Report("HeaterCommandRequestMessage",__FILE__,Temperature,HeaterId,RpWarning,HeaterState, 0); + //Report("HeatersSingleHeaterEnd ", __FILE__,__LINE__,HeaterId, RpMessage, 0, 0); return OK; } @@ -389,6 +397,8 @@ uint32_t PrepareHeater(int HeaterId, uint32_t SetTemperatue) return ERROR; } + Report("PrepareHeater ", __FILE__,__LINE__,HeaterId, SetTemperatue, 0, 0); + //start thread control for all motors HeaterPIDConfig[HeaterId].m_params.MAX = HeaterControl[HeaterId].outputproportionalpowerlimit*100; HeaterPIDConfig[HeaterId].m_params.MIN = 0.0; @@ -656,7 +666,6 @@ uint32_t DcHeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue) } return ERROR; } -char ACheatstr[100]; uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue) { int index=MAX_HEATERS_NUM; @@ -702,7 +711,7 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue) return OK; } - if ((readValue > (HeaterCmd[index].targettemperatue * 995/1000))&&(readValue < (HeaterCmd[index].targettemperatue * 1005/1000)))//read value within 0.5 percent from target + if ((readValue > (HeaterCmd[index].targettemperatue * AcHeatersLoweroperationLimit/1000))&&(readValue < (HeaterCmd[index].targettemperatue * AcHeatersUpperoperationLimit/1000)))//read value within 0.5 percent from target { ////////////////// //InitialHeating = false; @@ -822,7 +831,7 @@ uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue) return OK; } - if ((readValue > (HeaterCmd[index].targettemperatue * 978/1000))&&(readValue < (HeaterCmd[index].targettemperatue * 1002/1000)))//read value within 0.5 percent from target + if ((readValue > (HeaterCmd[index].targettemperatue * DcHeatersLoweroperationLimit/1000))&&(readValue < (HeaterCmd[index].targettemperatue * DcHeatersUpperoperationLimit/1000)))//read value within 0.5 percent from target { //DCInitialHeating[index] = false; HeatersControlStart(); diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c index f701d0878..f71cdc71f 100644 --- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c +++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c @@ -153,6 +153,7 @@ uint32_t IDS_HomeDispenser (uint32_t deviceID, uint32_t speed , callback_fptr ca Control3WayValvesWithCallback ((Valves_t)deviceID, MidTank_Dispenser, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer //Valve_Set((Valves_t) request->index, MidTank_Dispenser); MotorSetMicroStep(deviceID, 1); + SysCtlDelay(180000); //open dry air valve in the dispenser Valve_Set(IDS_Id_to_AirValve[deviceID], Atm_MidTank_ON); @@ -234,6 +235,7 @@ uint32_t IDS_EmptyDispenser (uint32_t deviceID, uint32_t speed , callback_fptr c Control3WayValvesWithCallback ((Valves_t)deviceID, Dispenser_Mixer, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer //Valve_Set((Valves_t) request->index, Dispenser_Mixer); MotorSetMicroStep(deviceID, 1); + SysCtlDelay(180000); //open dry air valve in the dispenser //Valve_Set(IDS_Id_to_AirValve[deviceID], Atm_MidTank_ON); IDS_Dispenser_RefillStarted(deviceID); diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c index 119624e3d..5ee8a150d 100644 --- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c +++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c @@ -319,6 +319,15 @@ uint32_t IDSPreSegmentState(void *JobDetails, int SegmentId) DispenserPreSegmentReady[DispenserId] = false; REPORT_MSG(DispenserId,"IDS_Valve_Presegment start"); IDS_Dispenser_Set_Flow_Params(DispenserId,0,0); + if (JobTicket->segments[DispenserId]->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->dispenserstepdivision != DISPENSER_STEP_DIVISION__Auto) + { + MotorSetMicroStep(HW_Motor_Id, JobTicket->segments[DispenserId]->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->dispenserstepdivision); + } + else + { + MotorSetMicroStep(HW_Motor_Id, MotorsCfg[HW_Motor_Id].microstep); + } + if (JobTicket->segments[SegmentId]->brushstops[0]->dispensers[Dispenser_i]->nanolitterpersecond==0) { //MotorStop(HW_Motor_Id,Hard_Hiz); @@ -397,14 +406,14 @@ uint32_t IDSPreSegmentState(void *JobDetails, int SegmentId) JobTicket->segments[CurrentSegment]->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->nanoliterperpulse; if (JobTicket->segments[CurrentSegment]->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->dispenserstepdivision != DISPENSER_STEP_DIVISION__Auto) { - MotorSetMicroStep(HW_Motor_Id, JobTicket->segments[CurrentSegment]->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->dispenserstepdivision); + //MotorSetMicroStep(HW_Motor_Id, JobTicket->segments[CurrentSegment]->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->dispenserstepdivision); segmentfirst_speed/=JobTicket->segments[CurrentSegment]->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->dispenserstepdivision; //the dye supply is calculated based on a 1/8 microstep IDS_Dispenser_Set_Flow_Params ( DispenserId, JobTicket->segments[CurrentSegment]->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->nanoliterperpulse , JobTicket->segments[CurrentSegment]->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->dispenserstepdivision); } else { - segmentfirst_speed/=MotorsCfg[HW_Motor_Id].microstep; //the dye supply is calculated based on a 1/8 microstep + //segmentfirst_speed/=MotorsCfg[HW_Motor_Id].microstep; //the dye supply is calculated based on a 1/8 microstep IDS_Dispenser_Set_Flow_Params ( DispenserId, JobTicket->segments[CurrentSegment]->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->nanoliterperpulse ,MotorsCfg[HW_Motor_Id].microstep); } diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Dancer.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Dancer.c index b7f6a387f..61c7afe74 100644 --- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Dancer.c +++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Dancer.c @@ -73,7 +73,7 @@ void Stub_DancerPositionRequest(MessageContainer* requestContainer) response.detailed_status = ERROR; // use the Reserved bits to send our errors response.has_general_status = true; } - + StoreDancerConfigMessage(); responseContainer = createContainer(MESSAGE_TYPE__StubDancerPositionResponse, requestContainer->token, true, &response, &stub_dancer_position_response__pack, &stub_dancer_position_response__get_packed_size); //free(request); diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c index e2f97d970..3af29a043 100644 --- a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c +++ b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c @@ -219,8 +219,8 @@ CallbackCounter++; MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_DH_LID,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DH_LID].directionthreadwize, 200, Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_DH_LID], Thread_Load_HomingCallback,10000); CallbackCounter++; - MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID].directionthreadwize, 200, Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID], Thread_Load_HomingCallback,10000); - + //MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID].directionthreadwize, 200, Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID], Thread_Load_HomingCallback,10000); + MotorMoveWithCallback(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID].directionthreadwize, 2, Thread_Load_HomingCallback,10000); return OK; } uint32_t Thread_Load_Lift_Dancers(void) @@ -283,7 +283,8 @@ CallbackCounter++; MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_DH_LID,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DH_LID].directionthreadwize, 200, Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_DH_LID], Thread_Load_HomingCallback,10000); CallbackCounter++; - MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID].directionthreadwize, 200, Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID], Thread_Load_HomingCallback,10000); +// MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID].directionthreadwize, 200, Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID], Thread_Load_HomingCallback,10000); + MotorMoveWithCallback(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID].directionthreadwize, 0, Thread_Load_HomingCallback,10000); return OK; } diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h index 56b229ea8..a22be25dc 100644 --- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h +++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h @@ -37,6 +37,9 @@ uint32_t ThreadDistanceToSpoolState(void); uint32_t ThreadEndState(void *JobDetails); uint32_t ThreadInitialTestStub(); +uint32_t StoreDancerConfigMessage(void); +uint32_t LoadDancerConfigMessage(void); + //uint32_t MotorPidRequestMessage(HardwarePidControl* request); uint32_t Winder_Init(void); uint32_t Winder_Prepare(void); diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c index 04a0026bd..b414611ff 100644 --- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c +++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c @@ -4,6 +4,8 @@ #include <DataDef.h> #include "include.h" +#include "PMR/Hardware/UploadHardWareConfigurationRequest.pb-c.h" +#include "PMR/Hardware/HardWareConfiguration.pb-c.h" #include "PMR/Hardware/HardwareMotor.pb-c.h" #include "PMR/Hardware/HardwareDancer.pb-c.h" #include "PMR/Hardware/HardwareWinder.pb-c.h" @@ -11,6 +13,10 @@ #include "PMR/Printing/JobSpool.pb-c.h" #include "PMR/common/MessageContainer.pb-c.h" +#include "Common/SWUpdate/FileSystem.h" +#include "drivers/Flash_Memory/fatfs/ff.h" +#include "drivers/SSI_Comm/Dancer/Dancer.h" + #include "thread.h" MotorDriverConfigStruc MotorsCfg[NUM_OF_MOTORS]={0}; HardwarePidControl MotorsControl[MAX_THREAD_MOTORS_NUM] = {0}; @@ -100,6 +106,63 @@ uint32_t MotorPidRequestMessage(HardwarePidControl* request) DancerStopActivityLimit[Motor_i] = temp/(2*PI*DancersCfg[ThreadMotorIdToDancerId[Motor_i]].armlength); return OK; } +char DancerConfigPath[50] = "0://SWInfo//DancCfg.msg"; + +uint32_t StoreDancerConfigMessage() +{ + FRESULT Fresult = FR_OK; + HardwareConfiguration DancerConfig; + HardwareDancer Dancers[MAX_SYSTEM_DANCERS]; + uint8_t* response_buffer; + size_t response_size = 0; + int Dancer_i; + + hardware_configuration__init(&DancerConfig); + DancerConfig.dancers = (HardwareDancer**)my_malloc(sizeof(HardwareDancer*)*MAX_SYSTEM_DANCERS); + for (Dancer_i = 0; Dancer_i < MAX_SYSTEM_DANCERS; Dancer_i++) + { + hardware_dancer__init(&Dancers[Dancer_i]); + DancerConfig.dancers[Dancer_i] = &Dancers[Dancer_i]; + Dancers[Dancer_i].has_zeropoint = true; + Dancers[Dancer_i].hardwaredancertype = Dancer_i; + Dancers[Dancer_i].has_hardwaredancertype = true; + DancerConfig.dancers[Dancer_i]->zeropoint=Control_Read_Dancer_Position(Dancer_i,0,0); + DancerConfig.n_dancers++; + } + response_buffer = my_malloc(hardware_configuration__get_packed_size(&DancerConfig)); + if (response_buffer) + { + response_size = hardware_configuration__pack(&DancerConfig, response_buffer); + } + Fresult = FileWrite(response_buffer,response_size,DancerConfigPath); + my_free(response_buffer); + + return Fresult; +} +uint32_t LoadDancerConfigMessage() +{ + void* buffer = NULL; + uint32_t Bytes = 0; + FRESULT Fresult = FR_OK; + + HardwareConfiguration *DancerConfig; + int Dancer_i; + + Fresult = FileRead(DancerConfigPath, &Bytes, &buffer); + if (Fresult == FR_OK) + { + DancerConfig = hardware_configuration__unpack(NULL, Bytes, buffer); + for (Dancer_i = 0; Dancer_i < DancerConfig->n_dancers ; Dancer_i++) + { + DancersCfg[Dancer_i].zeropoint = DancerConfig->dancers[Dancer_i]->zeropoint; + } + hardware_configuration__free_unpacked(DancerConfig,NULL); + free (buffer); + } + return Fresult; + +} + uint32_t DancerConfigMessage(HardwareDancer * request) { uint32_t status = PASSED; diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c index 1cb854f87..76d4b090a 100644 --- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c +++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c @@ -458,7 +458,18 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue) SendJobProgress(0.0,0,false, TMessage); //EndState(CurrentJob,TMessage ); SegmentReady(Module_Thread,ModuleFail); - AlarmHandlingSetAlarm(EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE,true); + switch (index) + { + case POOLER_MOTOR: + AlarmHandlingSetAlarm(EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_PULLER_DANCER,true); + break; + case WINDER_MOTOR: + AlarmHandlingSetAlarm(EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_FEEDER_DANCER,true); + break; + case FEEDER_MOTOR: + AlarmHandlingSetAlarm(EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_WINDER_DANCER,true); + break; + } LOG_ERROR (DancerId, "Dancer Failure"); return OK; } @@ -551,10 +562,11 @@ uint32_t ThreadEmptyCBFunction(uint32_t IfIndex, uint32_t ReadValue) PoolerTotalProcessedLength = 0.0; PrepareState = true; AlarmHandlingSetAlarm(EVENT_TYPE__THREAD_BREAK,false); - AlarmHandlingSetAlarm(EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE,false); + AlarmHandlingSetAlarm(EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_PULLER_DANCER,false); + AlarmHandlingSetAlarm(EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_FEEDER_DANCER,false); + AlarmHandlingSetAlarm(EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_WINDER_DANCER,false); AlarmHandlingSetAlarm(EVENT_TYPE__WINDER_CONE_DOES_NOT_EXIST,false); - //start thread control for all motors for (Motor_i = 0;Motor_i < MAX_THREAD_MOTORS_NUM;Motor_i++) { diff --git a/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c b/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c index ed004d250..fd7500606 100644 --- a/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c +++ b/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c @@ -359,6 +359,7 @@ uint32_t ThreadJoggingFunc(int speed) if (JobIsActive() == true) { status = ERROR; + LOG_ERROR(JobIsActive(),"Jog JobIsActive"); } else { @@ -431,8 +432,8 @@ void ThreadJoggingRequestFunc(MessageContainer* requestContainer) void ThreadAbortJoggingFunc(void) { AbortJob(0); - //set the job handler to handle heaters, ids and waste in the state machine + Task_sleep(100); //let the job end procedure role before returning the configuration to normal. memcpy(&Configured,&CopyConfigured,sizeof(CopyConfigured)); my_free(Ticket.segments); my_free(TSegment); @@ -592,8 +593,6 @@ void JobRequestFunc(MessageContainer* requestContainer) uint8_t* container_buffer; ErrorCode error = ERROR_CODE__NONE; JobEndReasonEnum JobAlarmReason = JOB_OK; - int len; - len = usnprintf(ErrorMsg, 100, "GJM"); JobRequest* request = job_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data); if (request != NULL) @@ -607,7 +606,7 @@ void JobRequestFunc(MessageContainer* requestContainer) LOG_ERROR (TicketSize, "job ticket message too long"); status = FAILED; error = ERROR_CODE__BAD_CRC; - len = usnprintf(ErrorMsg, 100, "job ticket message too long"); + usnprintf(ErrorMsg, 100, "job ticket message too long"); } else { @@ -628,7 +627,7 @@ void JobRequestFunc(MessageContainer* requestContainer) { status = FAILED; error = ERROR_CODE__INVALID_PARAMETER; - len = usnprintf(ErrorMsg, 100, "Hardware Parameters Not Set"); + usnprintf(ErrorMsg, 100, "Hardware Parameters Not Set"); } } if (Ticket->spool) @@ -637,7 +636,7 @@ void JobRequestFunc(MessageContainer* requestContainer) { status = FAILED; error = ERROR_CODE__INVALID_PARAMETER; - len = usnprintf(ErrorMsg, 100, "spool parameters error"); + usnprintf(ErrorMsg, 100, "spool parameters error"); } } @@ -646,7 +645,7 @@ void JobRequestFunc(MessageContainer* requestContainer) { status = FAILED; error = JobError_to_ErrorCode[JobAlarmReason]; - len = usnprintf(ErrorMsg, 100, "Existing alarms prevent running"); + usnprintf(ErrorMsg, 100, "Existing alarms prevent running"); } } if (status == PASSED) @@ -663,7 +662,7 @@ void JobRequestFunc(MessageContainer* requestContainer) if (status == PASSED) { JobResumed = false; - len = usnprintf(ErrorMsg, 100, "Job Accepted"); + usnprintf(ErrorMsg, 100, "Job Accepted"); jobStatus.message =ErrorMsg; jobStatus.has_progress = true; diff --git a/Software/Embedded_SW/Embedded/tm4c129xnczad.cmd b/Software/Embedded_SW/Embedded/tm4c129xnczad.cmd index d63d890cd..25916dae2 100644 --- a/Software/Embedded_SW/Embedded/tm4c129xnczad.cmd +++ b/Software/Embedded_SW/Embedded/tm4c129xnczad.cmd @@ -42,7 +42,7 @@ MEMORY { /* Application stored in and executes from internal flash */ - FLASH (RX) : origin = APP_BASE, length = 0x000B0000 + FLASH (RX) : origin = APP_BASE, length = 0x000D0000 /* Application stored in and executes from internal flash */ FLASH_RAM (RWX) : origin = FLASH_RAM_BASE, length = 0x00030000 /* Application uses internal RAM for data */ |