diff options
Diffstat (limited to 'Software/Embedded_SW/Embedded')
45 files changed, 2824 insertions, 560 deletions
diff --git a/Software/Embedded_SW/Embedded/.cproject b/Software/Embedded_SW/Embedded/.cproject index 0f253578d..6007737b7 100644 --- a/Software/Embedded_SW/Embedded/.cproject +++ b/Software/Embedded_SW/Embedded/.cproject @@ -170,7 +170,7 @@ </toolChain> </folderInfo> <sourceEntries> - <entry excluding="Modules/Stubs_Handler/Stub_OptLimitSwitch.c|Modules/Stubs_Handler/Stub_Cartridge.c|Modules/Stubs_Handler/Stub_FPGAReadBackReg.c|Modules/Stubs_Handler/Stub_HW_Version.c|Modules/Stubs_Handler/Stub_SpeedSensor.c|Modules/Stubs_Handler/Stub_SteperMotor.c|Modules/Stubs_Handler/Stub_TivaReg.c|Modules/Stubs_Handler/Stub_L6470.c|Drivers/I2C_Communication/RFID_NFC|Drivers/I2C_Communication/Thermo_K|Drivers/Heater/ADS1220.c|Modules/Stubs_Handler/User_Leds.c|Modules/Stubs_Handler/temperature_sensor.c|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=""/> + <entry excluding="Modules/Stubs_Handler/Stub_OptLimitSwitch.c|Modules/Stubs_Handler/Stub_Cartridge.c|Modules/Stubs_Handler/Stub_FPGAReadBackReg.c|Modules/Stubs_Handler/Stub_HW_Version.c|Modules/Stubs_Handler/Stub_SpeedSensor.c|Modules/Stubs_Handler/Stub_SteperMotor.c|Modules/Stubs_Handler/Stub_TivaReg.c|Modules/Stubs_Handler/Stub_L6470.c|Drivers/I2C_Communication/Thermo_K|Drivers/Heater/ADS1220.c|Modules/Stubs_Handler/User_Leds.c|Modules/Stubs_Handler/temperature_sensor.c|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> diff --git a/Software/Embedded_SW/Embedded/Common/SWUpdate/FirmwareUpgrade.c b/Software/Embedded_SW/Embedded/Common/SWUpdate/FirmwareUpgrade.c index 273dfb49d..77056213f 100644 --- a/Software/Embedded_SW/Embedded/Common/SWUpdate/FirmwareUpgrade.c +++ b/Software/Embedded_SW/Embedded/Common/SWUpdate/FirmwareUpgrade.c @@ -120,7 +120,6 @@ uint32_t ActivateVersionRequestFunc(MessageContainer* requestContainer) } for (File_i = 0;File_i<VersionPackage->n_filedescriptors;File_i++) { - CurrentRunningFile = 0; CurrentFileSize = -1; vme_index = 0; switch(VersionPackage->filedescriptors[File_i]->destination) @@ -156,6 +155,7 @@ uint32_t ActivateVersionRequestFunc(MessageContainer* requestContainer) usnprintf(FullPath, 50, "%s%s%s", request->path,"/", VersionPackage->filedescriptors[File_i]->filename); Fresult = f_unlink("//SYSINFO//ALARMPRM.CFG"); Fresult |= f_rename (FullPath, "//SYSINFO//ALARMPRM.CFG"); + AlarmHandlingLoadFile(); CurrentRunningFile++; break; case VERSION_FILE_DESTINATION__GeneralHWConfigParams: 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 ba601e283..ad0191ab4 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,4,1,1}; +TangoVersion_t _gTangoVersion = {1,4,2,0}; #define BUILD_DATE __DATE__ char Dat[50] = BUILD_DATE; char _gTangoName [MAX_STRING_LEN] = "Tango01 ";//d diff --git a/Software/Embedded_SW/Embedded/Communication/Container.c b/Software/Embedded_SW/Embedded/Communication/Container.c index ca253c5be..86e1b06c4 100644 --- a/Software/Embedded_SW/Embedded/Communication/Container.c +++ b/Software/Embedded_SW/Embedded/Communication/Container.c @@ -424,6 +424,15 @@ void receive_callback(char* buffer, size_t length) case MESSAGE_TYPE__DispenserDataRequest: DispenserDataRequestFunc(requestContainer); break; + case MESSAGE_TYPE__StartCartridgesUpdateRequest: + LOG_ERROR (requestContainer->type,"MESSAGE_TYPE__StartCartridgesUpdateRequest"); + break; + case MESSAGE_TYPE__StopCartridgesUpdateRequest: + LOG_ERROR (requestContainer->type,"MESSAGE_TYPE__StopCartridgesUpdateRequest"); + break; + case MESSAGE_TYPE__CartridgeValidationResponse: + LOG_ERROR (requestContainer->type,"MESSAGE_TYPE__CartridgeValidationResponse"); + break; default: //unsupported message type !! LOG_ERROR (requestContainer->type,"unsupported message type"); diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Common/MessageType.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/Common/MessageType.pb-c.c index 48bc98319..2ca8c9192 100644 --- a/Software/Embedded_SW/Embedded/Communication/PMR/Common/MessageType.pb-c.c +++ b/Software/Embedded_SW/Embedded/Communication/PMR/Common/MessageType.pb-c.c @@ -7,7 +7,7 @@ #endif #include "MessageType.pb-c.h" -static const ProtobufCEnumValue message_type__enum_values_by_number[207] = +static const ProtobufCEnumValue message_type__enum_values_by_number[215] = { { "None", "MESSAGE_TYPE__None", 0 }, { "ErrorResponse", "MESSAGE_TYPE__ErrorResponse", 1 }, @@ -126,6 +126,8 @@ static const ProtobufCEnumValue message_type__enum_values_by_number[207] = { "StartApplicationLogsResponse", "MESSAGE_TYPE__StartApplicationLogsResponse", 1010 }, { "StopApplicationLogsRequest", "MESSAGE_TYPE__StopApplicationLogsRequest", 1011 }, { "StopApplicationLogsResponse", "MESSAGE_TYPE__StopApplicationLogsResponse", 1012 }, + { "ColorProfileRequest", "MESSAGE_TYPE__ColorProfileRequest", 1013 }, + { "ColorProfileResponse", "MESSAGE_TYPE__ColorProfileResponse", 1014 }, { "StartDiagnosticsRequest", "MESSAGE_TYPE__StartDiagnosticsRequest", 2000 }, { "StartDiagnosticsResponse", "MESSAGE_TYPE__StartDiagnosticsResponse", 2001 }, { "MotorAbortHomingRequest", "MESSAGE_TYPE__MotorAbortHomingRequest", 2002 }, @@ -166,6 +168,12 @@ static const ProtobufCEnumValue message_type__enum_values_by_number[207] = { "SetBlowerStateResponse", "MESSAGE_TYPE__SetBlowerStateResponse", 2037 }, { "SetValveStateRequest", "MESSAGE_TYPE__SetValveStateRequest", 2038 }, { "SetValveStateResponse", "MESSAGE_TYPE__SetValveStateResponse", 2039 }, + { "StartCartridgesUpdateRequest", "MESSAGE_TYPE__StartCartridgesUpdateRequest", 2040 }, + { "StartCartridgesUpdateResponse", "MESSAGE_TYPE__StartCartridgesUpdateResponse", 2041 }, + { "StopCartridgesUpdateRequest", "MESSAGE_TYPE__StopCartridgesUpdateRequest", 2042 }, + { "StopCartridgesUpdateResponse", "MESSAGE_TYPE__StopCartridgesUpdateResponse", 2043 }, + { "CartridgeValidationRequest", "MESSAGE_TYPE__CartridgeValidationRequest", 2044 }, + { "CartridgeValidationResponse", "MESSAGE_TYPE__CartridgeValidationResponse", 2045 }, { "JobRequest", "MESSAGE_TYPE__JobRequest", 3000 }, { "JobResponse", "MESSAGE_TYPE__JobResponse", 3001 }, { "AbortJobRequest", "MESSAGE_TYPE__AbortJobRequest", 3002 }, @@ -218,107 +226,115 @@ static const ProtobufCEnumValue message_type__enum_values_by_number[207] = { "DispenserDataResponse", "MESSAGE_TYPE__DispenserDataResponse", 8001 }, }; static const ProtobufCIntRange message_type__value_ranges[] = { -{0, 0},{3, 2},{1000, 104},{2000, 117},{3000, 157},{4000, 167},{5000, 171},{6000, 175},{7000, 181},{8000, 205},{0, 207} +{0, 0},{3, 2},{1000, 104},{2000, 119},{3000, 165},{4000, 175},{5000, 179},{6000, 183},{7000, 189},{8000, 213},{0, 215} }; -static const ProtobufCEnumValueIndex message_type__enum_values_by_name[207] = +static const ProtobufCEnumValueIndex message_type__enum_values_by_name[215] = { - { "AbortJobRequest", 159 }, - { "AbortJobResponse", 160 }, - { "ActivateVersionRequest", 203 }, - { "ActivateVersionResponse", 204 }, + { "AbortJobRequest", 167 }, + { "AbortJobResponse", 168 }, + { "ActivateVersionRequest", 211 }, + { "ActivateVersionResponse", 212 }, { "CalculateRequest", 2 }, { "CalculateResponse", 3 }, - { "ConnectRequest", 177 }, - { "ConnectResponse", 178 }, - { "CreateRequest", 189 }, - { "CreateResponse", 190 }, - { "CurrentJobRequest", 163 }, - { "CurrentJobResponse", 164 }, - { "DeleteRequest", 191 }, - { "DeleteResponse", 192 }, + { "CartridgeValidationRequest", 163 }, + { "CartridgeValidationResponse", 164 }, + { "ColorProfileRequest", 117 }, + { "ColorProfileResponse", 118 }, + { "ConnectRequest", 185 }, + { "ConnectResponse", 186 }, + { "CreateRequest", 197 }, + { "CreateResponse", 198 }, + { "CurrentJobRequest", 171 }, + { "CurrentJobResponse", 172 }, + { "DeleteRequest", 199 }, + { "DeleteResponse", 200 }, { "DirectSynchronizationRequest", 109 }, { "DirectSynchronizationResponse", 110 }, - { "DisconnectRequest", 179 }, - { "DisconnectResponse", 180 }, - { "DispenserAbortHomingRequest", 127 }, - { "DispenserAbortHomingResponse", 128 }, - { "DispenserAbortJoggingRequest", 133 }, - { "DispenserAbortJoggingResponse", 134 }, - { "DispenserDataRequest", 205 }, - { "DispenserDataResponse", 206 }, - { "DispenserHomingRequest", 129 }, - { "DispenserHomingResponse", 130 }, - { "DispenserJoggingRequest", 131 }, - { "DispenserJoggingResponse", 132 }, + { "DisconnectRequest", 187 }, + { "DisconnectResponse", 188 }, + { "DispenserAbortHomingRequest", 129 }, + { "DispenserAbortHomingResponse", 130 }, + { "DispenserAbortJoggingRequest", 135 }, + { "DispenserAbortJoggingResponse", 136 }, + { "DispenserDataRequest", 213 }, + { "DispenserDataResponse", 214 }, + { "DispenserHomingRequest", 131 }, + { "DispenserHomingResponse", 132 }, + { "DispenserJoggingRequest", 133 }, + { "DispenserJoggingResponse", 134 }, { "ErrorResponse", 1 }, - { "ExecuteProcessRequest", 185 }, - { "ExecuteProcessResponse", 186 }, + { "ExecuteProcessRequest", 193 }, + { "ExecuteProcessResponse", 194 }, { "ExternalBridgeLoginRequest", 105 }, { "ExternalBridgeLoginResponse", 106 }, { "ExternalBridgeLogoutRequest", 107 }, { "ExternalBridgeLogoutResponse", 108 }, { "ExternalBridgeUdpDiscoveryPacket", 104 }, - { "FileChunkDownloadRequest", 199 }, - { "FileChunkDownloadResponse", 200 }, - { "FileChunkUploadRequest", 183 }, - { "FileChunkUploadResponse", 184 }, - { "FileDownloadRequest", 197 }, - { "FileDownloadResponse", 198 }, - { "FileUploadRequest", 181 }, - { "FileUploadResponse", 182 }, - { "GetFilesRequest", 195 }, - { "GetFilesResponse", 196 }, - { "GetStorageInfoRequest", 193 }, - { "GetStorageInfoResponse", 194 }, - { "JobRequest", 157 }, - { "JobResponse", 158 }, - { "KeepAliveRequest", 175 }, - { "KeepAliveResponse", 176 }, - { "KillProcessRequest", 187 }, - { "KillProcessResponse", 188 }, - { "MotorAbortHomingRequest", 119 }, - { "MotorAbortHomingResponse", 120 }, - { "MotorAbortJoggingRequest", 125 }, - { "MotorAbortJoggingResponse", 126 }, - { "MotorHomingRequest", 121 }, - { "MotorHomingResponse", 122 }, - { "MotorJoggingRequest", 123 }, - { "MotorJoggingResponse", 124 }, + { "FileChunkDownloadRequest", 207 }, + { "FileChunkDownloadResponse", 208 }, + { "FileChunkUploadRequest", 191 }, + { "FileChunkUploadResponse", 192 }, + { "FileDownloadRequest", 205 }, + { "FileDownloadResponse", 206 }, + { "FileUploadRequest", 189 }, + { "FileUploadResponse", 190 }, + { "GetFilesRequest", 203 }, + { "GetFilesResponse", 204 }, + { "GetStorageInfoRequest", 201 }, + { "GetStorageInfoResponse", 202 }, + { "JobRequest", 165 }, + { "JobResponse", 166 }, + { "KeepAliveRequest", 183 }, + { "KeepAliveResponse", 184 }, + { "KillProcessRequest", 195 }, + { "KillProcessResponse", 196 }, + { "MotorAbortHomingRequest", 121 }, + { "MotorAbortHomingResponse", 122 }, + { "MotorAbortJoggingRequest", 127 }, + { "MotorAbortJoggingResponse", 128 }, + { "MotorHomingRequest", 123 }, + { "MotorHomingResponse", 124 }, + { "MotorJoggingRequest", 125 }, + { "MotorJoggingResponse", 126 }, { "None", 0 }, { "OverrideDataBaseRequest", 111 }, { "OverrideDataBaseResponse", 112 }, { "ProgressRequest", 4 }, { "ProgressResponse", 5 }, - { "ResolveEventRequest", 143 }, - { "ResolveEventResponse", 144 }, - { "ResumeCurrentJobRequest", 165 }, - { "ResumeCurrentJobResponse", 166 }, - { "SetBlowerStateRequest", 153 }, - { "SetBlowerStateResponse", 154 }, - { "SetComponentValueRequest", 141 }, - { "SetComponentValueResponse", 142 }, - { "SetDigitalOutRequest", 135 }, - { "SetDigitalOutResponse", 136 }, - { "SetHeaterStateRequest", 151 }, - { "SetHeaterStateResponse", 152 }, - { "SetValveStateRequest", 155 }, - { "SetValveStateResponse", 156 }, + { "ResolveEventRequest", 145 }, + { "ResolveEventResponse", 146 }, + { "ResumeCurrentJobRequest", 173 }, + { "ResumeCurrentJobResponse", 174 }, + { "SetBlowerStateRequest", 155 }, + { "SetBlowerStateResponse", 156 }, + { "SetComponentValueRequest", 143 }, + { "SetComponentValueResponse", 144 }, + { "SetDigitalOutRequest", 137 }, + { "SetDigitalOutResponse", 138 }, + { "SetHeaterStateRequest", 153 }, + { "SetHeaterStateResponse", 154 }, + { "SetValveStateRequest", 157 }, + { "SetValveStateResponse", 158 }, { "StartApplicationLogsRequest", 113 }, { "StartApplicationLogsResponse", 114 }, - { "StartDebugLogRequest", 167 }, - { "StartDebugLogResponse", 168 }, - { "StartDiagnosticsRequest", 117 }, - { "StartDiagnosticsResponse", 118 }, - { "StartEventsNotificationRequest", 147 }, - { "StartEventsNotificationResponse", 148 }, + { "StartCartridgesUpdateRequest", 159 }, + { "StartCartridgesUpdateResponse", 160 }, + { "StartDebugLogRequest", 175 }, + { "StartDebugLogResponse", 176 }, + { "StartDiagnosticsRequest", 119 }, + { "StartDiagnosticsResponse", 120 }, + { "StartEventsNotificationRequest", 149 }, + { "StartEventsNotificationResponse", 150 }, { "StopApplicationLogsRequest", 115 }, { "StopApplicationLogsResponse", 116 }, - { "StopDebugLogRequest", 169 }, - { "StopDebugLogResponse", 170 }, - { "StopDiagnosticsRequest", 145 }, - { "StopDiagnosticsResponse", 146 }, - { "StopEventsNotificationRequest", 149 }, - { "StopEventsNotificationResponse", 150 }, + { "StopCartridgesUpdateRequest", 161 }, + { "StopCartridgesUpdateResponse", 162 }, + { "StopDebugLogRequest", 177 }, + { "StopDebugLogResponse", 178 }, + { "StopDiagnosticsRequest", 147 }, + { "StopDiagnosticsResponse", 148 }, + { "StopEventsNotificationRequest", 151 }, + { "StopEventsNotificationResponse", 152 }, { "StubAbortJobRequest", 100 }, { "StubAbortJobResponse", 101 }, { "StubCartridgeReadRequest", 6 }, @@ -417,18 +433,18 @@ static const ProtobufCEnumValueIndex message_type__enum_values_by_name[207] = { "StubTivaWriteRegResponse", 79 }, { "StubValveRequest", 30 }, { "StubValveResponse", 31 }, - { "SystemResetRequest", 173 }, - { "SystemResetResponse", 174 }, - { "ThreadAbortJoggingRequest", 139 }, - { "ThreadAbortJoggingResponse", 140 }, - { "ThreadJoggingRequest", 137 }, - { "ThreadJoggingResponse", 138 }, - { "UploadHardwareConfigurationRequest", 171 }, - { "UploadHardwareConfigurationResponse", 172 }, - { "UploadProcessParametersRequest", 161 }, - { "UploadProcessParametersResponse", 162 }, - { "ValidateVersionRequest", 201 }, - { "ValidateVersionResponse", 202 }, + { "SystemResetRequest", 181 }, + { "SystemResetResponse", 182 }, + { "ThreadAbortJoggingRequest", 141 }, + { "ThreadAbortJoggingResponse", 142 }, + { "ThreadJoggingRequest", 139 }, + { "ThreadJoggingResponse", 140 }, + { "UploadHardwareConfigurationRequest", 179 }, + { "UploadHardwareConfigurationResponse", 180 }, + { "UploadProcessParametersRequest", 169 }, + { "UploadProcessParametersResponse", 170 }, + { "ValidateVersionRequest", 209 }, + { "ValidateVersionResponse", 210 }, }; const ProtobufCEnumDescriptor message_type__descriptor = { @@ -437,9 +453,9 @@ const ProtobufCEnumDescriptor message_type__descriptor = "MessageType", "MessageType", "", - 207, + 215, message_type__enum_values_by_number, - 207, + 215, message_type__enum_values_by_name, 10, message_type__value_ranges, diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Common/MessageType.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/Common/MessageType.pb-c.h index 7fde64335..5ca19030f 100644 --- a/Software/Embedded_SW/Embedded/Communication/PMR/Common/MessageType.pb-c.h +++ b/Software/Embedded_SW/Embedded/Communication/PMR/Common/MessageType.pb-c.h @@ -137,6 +137,8 @@ typedef enum _MessageType { MESSAGE_TYPE__StartApplicationLogsResponse = 1010, MESSAGE_TYPE__StopApplicationLogsRequest = 1011, MESSAGE_TYPE__StopApplicationLogsResponse = 1012, + MESSAGE_TYPE__ColorProfileRequest = 1013, + MESSAGE_TYPE__ColorProfileResponse = 1014, MESSAGE_TYPE__StartDiagnosticsRequest = 2000, MESSAGE_TYPE__StartDiagnosticsResponse = 2001, MESSAGE_TYPE__MotorAbortHomingRequest = 2002, @@ -177,6 +179,12 @@ typedef enum _MessageType { MESSAGE_TYPE__SetBlowerStateResponse = 2037, MESSAGE_TYPE__SetValveStateRequest = 2038, MESSAGE_TYPE__SetValveStateResponse = 2039, + MESSAGE_TYPE__StartCartridgesUpdateRequest = 2040, + MESSAGE_TYPE__StartCartridgesUpdateResponse = 2041, + MESSAGE_TYPE__StopCartridgesUpdateRequest = 2042, + MESSAGE_TYPE__StopCartridgesUpdateResponse = 2043, + MESSAGE_TYPE__CartridgeValidationRequest = 2044, + MESSAGE_TYPE__CartridgeValidationResponse = 2045, MESSAGE_TYPE__JobRequest = 3000, MESSAGE_TYPE__JobResponse = 3001, MESSAGE_TYPE__AbortJobRequest = 3002, diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/Cartridge.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/Cartridge.pb-c.c new file mode 100644 index 000000000..fc27894ce --- /dev/null +++ b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/Cartridge.pb-c.c @@ -0,0 +1,118 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: Cartridge.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "Cartridge.pb-c.h" +void cartridge__init + (Cartridge *message) +{ + static const Cartridge init_value = CARTRIDGE__INIT; + *message = init_value; +} +size_t cartridge__get_packed_size + (const Cartridge *message) +{ + assert(message->base.descriptor == &cartridge__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t cartridge__pack + (const Cartridge *message, + uint8_t *out) +{ + assert(message->base.descriptor == &cartridge__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t cartridge__pack_to_buffer + (const Cartridge *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &cartridge__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Cartridge * + cartridge__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Cartridge *) + protobuf_c_message_unpack (&cartridge__descriptor, + allocator, len, data); +} +void cartridge__free_unpacked + (Cartridge *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &cartridge__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +static const ProtobufCFieldDescriptor cartridge__field_descriptors[3] = +{ + { + "Slot", + 1, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_ENUM, + offsetof(Cartridge, has_slot), + offsetof(Cartridge, slot), + &cartridge_slot__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "Tag", + 2, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Cartridge, tag), + &cartridge_tag_content__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "Index", + 3, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_INT32, + offsetof(Cartridge, has_index), + offsetof(Cartridge, index), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned cartridge__field_indices_by_name[] = { + 2, /* field[2] = Index */ + 0, /* field[0] = Slot */ + 1, /* field[1] = Tag */ +}; +static const ProtobufCIntRange cartridge__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 3 } +}; +const ProtobufCMessageDescriptor cartridge__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Cartridge", + "Cartridge", + "Cartridge", + "", + sizeof(Cartridge), + 3, + cartridge__field_descriptors, + cartridge__field_indices_by_name, + 1, cartridge__number_ranges, + (ProtobufCMessageInit) cartridge__init, + NULL,NULL,NULL /* reserved[123] */ +}; diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/Cartridge.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/Cartridge.pb-c.h new file mode 100644 index 000000000..1f4446b48 --- /dev/null +++ b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/Cartridge.pb-c.h @@ -0,0 +1,77 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: Cartridge.proto */ + +#ifndef PROTOBUF_C_Cartridge_2eproto__INCLUDED +#define PROTOBUF_C_Cartridge_2eproto__INCLUDED + +#include <protobuf-c/protobuf-c.h> + +PROTOBUF_C__BEGIN_DECLS + +#if PROTOBUF_C_VERSION_NUMBER < 1003000 +# error This file was generated by a newer version of protoc-c which is incompatible with your libprotobuf-c headers. Please update your headers. +#elif 1003000 < PROTOBUF_C_MIN_COMPILER_VERSION +# error This file was generated by an older version of protoc-c which is incompatible with your libprotobuf-c headers. Please regenerate this file with a newer version of protoc-c. +#endif + +#include "CartridgeSlot.pb-c.h" +#include "CartridgeTagContent.pb-c.h" + +typedef struct _Cartridge Cartridge; + + +/* --- enums --- */ + + +/* --- messages --- */ + +struct _Cartridge +{ + ProtobufCMessage base; + protobuf_c_boolean has_slot; + CartridgeSlot slot; + CartridgeTagContent *tag; + protobuf_c_boolean has_index; + int32_t index; +}; +#define CARTRIDGE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&cartridge__descriptor) \ + , 0, CARTRIDGE_SLOT__Ink, NULL, 0, 0 } + + +/* Cartridge methods */ +void cartridge__init + (Cartridge *message); +size_t cartridge__get_packed_size + (const Cartridge *message); +size_t cartridge__pack + (const Cartridge *message, + uint8_t *out); +size_t cartridge__pack_to_buffer + (const Cartridge *message, + ProtobufCBuffer *buffer); +Cartridge * + cartridge__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void cartridge__free_unpacked + (Cartridge *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*Cartridge_Closure) + (const Cartridge *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCMessageDescriptor cartridge__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_Cartridge_2eproto__INCLUDED */ diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/CartridgeAction.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/CartridgeAction.pb-c.c new file mode 100644 index 000000000..b0a681376 --- /dev/null +++ b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/CartridgeAction.pb-c.c @@ -0,0 +1,37 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: CartridgeAction.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "CartridgeAction.pb-c.h" +static const ProtobufCEnumValue cartridge_action__enum_values_by_number[2] = +{ + { "Inserted", "CARTRIDGE_ACTION__Inserted", 0 }, + { "Ejected", "CARTRIDGE_ACTION__Ejected", 1 }, +}; +static const ProtobufCIntRange cartridge_action__value_ranges[] = { +{0, 0},{0, 2} +}; +static const ProtobufCEnumValueIndex cartridge_action__enum_values_by_name[2] = +{ + { "Ejected", 1 }, + { "Inserted", 0 }, +}; +const ProtobufCEnumDescriptor cartridge_action__descriptor = +{ + PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC, + "CartridgeAction", + "CartridgeAction", + "CartridgeAction", + "", + 2, + cartridge_action__enum_values_by_number, + 2, + cartridge_action__enum_values_by_name, + 1, + cartridge_action__value_ranges, + NULL,NULL,NULL,NULL /* reserved[1234] */ +}; diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/CartridgeAction.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/CartridgeAction.pb-c.h new file mode 100644 index 000000000..9664d8b1f --- /dev/null +++ b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/CartridgeAction.pb-c.h @@ -0,0 +1,43 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: CartridgeAction.proto */ + +#ifndef PROTOBUF_C_CartridgeAction_2eproto__INCLUDED +#define PROTOBUF_C_CartridgeAction_2eproto__INCLUDED + +#include <protobuf-c/protobuf-c.h> + +PROTOBUF_C__BEGIN_DECLS + +#if PROTOBUF_C_VERSION_NUMBER < 1003000 +# error This file was generated by a newer version of protoc-c which is incompatible with your libprotobuf-c headers. Please update your headers. +#elif 1003000 < PROTOBUF_C_MIN_COMPILER_VERSION +# error This file was generated by an older version of protoc-c which is incompatible with your libprotobuf-c headers. Please regenerate this file with a newer version of protoc-c. +#endif + + + + +/* --- enums --- */ + +typedef enum _CartridgeAction { + CARTRIDGE_ACTION__Inserted = 0, + CARTRIDGE_ACTION__Ejected = 1 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(CARTRIDGE_ACTION) +} CartridgeAction; + +/* --- messages --- */ + +/* --- per-message closures --- */ + + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCEnumDescriptor cartridge_action__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_CartridgeAction_2eproto__INCLUDED */ diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/CartridgeSlot.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/CartridgeSlot.pb-c.c new file mode 100644 index 000000000..370c41dc2 --- /dev/null +++ b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/CartridgeSlot.pb-c.c @@ -0,0 +1,39 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: CartridgeSlot.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "CartridgeSlot.pb-c.h" +static const ProtobufCEnumValue cartridge_slot__enum_values_by_number[3] = +{ + { "Ink", "CARTRIDGE_SLOT__Ink", 0 }, + { "WasteMiddle", "CARTRIDGE_SLOT__WasteMiddle", 1 }, + { "WasteLower", "CARTRIDGE_SLOT__WasteLower", 2 }, +}; +static const ProtobufCIntRange cartridge_slot__value_ranges[] = { +{0, 0},{0, 3} +}; +static const ProtobufCEnumValueIndex cartridge_slot__enum_values_by_name[3] = +{ + { "Ink", 0 }, + { "WasteLower", 2 }, + { "WasteMiddle", 1 }, +}; +const ProtobufCEnumDescriptor cartridge_slot__descriptor = +{ + PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC, + "CartridgeSlot", + "CartridgeSlot", + "CartridgeSlot", + "", + 3, + cartridge_slot__enum_values_by_number, + 3, + cartridge_slot__enum_values_by_name, + 1, + cartridge_slot__value_ranges, + NULL,NULL,NULL,NULL /* reserved[1234] */ +}; diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/CartridgeSlot.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/CartridgeSlot.pb-c.h new file mode 100644 index 000000000..8036073ba --- /dev/null +++ b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/CartridgeSlot.pb-c.h @@ -0,0 +1,44 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: CartridgeSlot.proto */ + +#ifndef PROTOBUF_C_CartridgeSlot_2eproto__INCLUDED +#define PROTOBUF_C_CartridgeSlot_2eproto__INCLUDED + +#include <protobuf-c/protobuf-c.h> + +PROTOBUF_C__BEGIN_DECLS + +#if PROTOBUF_C_VERSION_NUMBER < 1003000 +# error This file was generated by a newer version of protoc-c which is incompatible with your libprotobuf-c headers. Please update your headers. +#elif 1003000 < PROTOBUF_C_MIN_COMPILER_VERSION +# error This file was generated by an older version of protoc-c which is incompatible with your libprotobuf-c headers. Please regenerate this file with a newer version of protoc-c. +#endif + + + + +/* --- enums --- */ + +typedef enum _CartridgeSlot { + CARTRIDGE_SLOT__Ink = 0, + CARTRIDGE_SLOT__WasteMiddle = 1, + CARTRIDGE_SLOT__WasteLower = 2 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(CARTRIDGE_SLOT) +} CartridgeSlot; + +/* --- messages --- */ + +/* --- per-message closures --- */ + + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCEnumDescriptor cartridge_slot__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_CartridgeSlot_2eproto__INCLUDED */ diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/CartridgeTagContent.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/CartridgeTagContent.pb-c.c new file mode 100644 index 000000000..66c11df51 --- /dev/null +++ b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/CartridgeTagContent.pb-c.c @@ -0,0 +1,417 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: CartridgeTagContent.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "CartridgeTagContent.pb-c.h" +void cartridge_tag_content__init + (CartridgeTagContent *message) +{ + static const CartridgeTagContent init_value = CARTRIDGE_TAG_CONTENT__INIT; + *message = init_value; +} +size_t cartridge_tag_content__get_packed_size + (const CartridgeTagContent *message) +{ + assert(message->base.descriptor == &cartridge_tag_content__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t cartridge_tag_content__pack + (const CartridgeTagContent *message, + uint8_t *out) +{ + assert(message->base.descriptor == &cartridge_tag_content__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t cartridge_tag_content__pack_to_buffer + (const CartridgeTagContent *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &cartridge_tag_content__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +CartridgeTagContent * + cartridge_tag_content__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (CartridgeTagContent *) + protobuf_c_message_unpack (&cartridge_tag_content__descriptor, + allocator, len, data); +} +void cartridge_tag_content__free_unpacked + (CartridgeTagContent *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &cartridge_tag_content__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +static const ProtobufCFieldDescriptor cartridge_tag_content__field_descriptors[26] = +{ + { + "UniqueId", + 1, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(CartridgeTagContent, has_uniqueid), + offsetof(CartridgeTagContent, uniqueid), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "SerialNumber", + 2, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(CartridgeTagContent, serialnumber), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "FactoryId", + 3, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(CartridgeTagContent, factoryid), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "FillingSystemId", + 4, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_INT32, + offsetof(CartridgeTagContent, has_fillingsystemid), + offsetof(CartridgeTagContent, fillingsystemid), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ColorName", + 5, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(CartridgeTagContent, colorname), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ColorCategory", + 6, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_INT32, + offsetof(CartridgeTagContent, has_colorcategory), + offsetof(CartridgeTagContent, colorcategory), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ColorTypeRevision", + 7, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_INT32, + offsetof(CartridgeTagContent, has_colortyperevision), + offsetof(CartridgeTagContent, colortyperevision), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "CartridgeSize", + 8, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_INT32, + offsetof(CartridgeTagContent, has_cartridgesize), + offsetof(CartridgeTagContent, cartridgesize), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "FilledInkVolume", + 9, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_INT32, + offsetof(CartridgeTagContent, has_filledinkvolume), + offsetof(CartridgeTagContent, filledinkvolume), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "InkBatchNum", + 10, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(CartridgeTagContent, inkbatchnum), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "InkMFGDate", + 11, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(CartridgeTagContent, inkmfgdate), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "InkEOLDate", + 12, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(CartridgeTagContent, inkeoldate), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "CartridgeFillingDate", + 13, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(CartridgeTagContent, cartridgefillingdate), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "WasteFilledDate", + 14, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(CartridgeTagContent, wastefilleddate), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "PlugInCounter", + 15, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_INT32, + offsetof(CartridgeTagContent, has_plugincounter), + offsetof(CartridgeTagContent, plugincounter), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "Inkfill", + 16, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_BOOL, + offsetof(CartridgeTagContent, has_inkfill), + offsetof(CartridgeTagContent, inkfill), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "InkUsed", + 17, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_BOOL, + offsetof(CartridgeTagContent, has_inkused), + offsetof(CartridgeTagContent, inkused), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "InkEmpty", + 18, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_BOOL, + offsetof(CartridgeTagContent, has_inkempty), + offsetof(CartridgeTagContent, inkempty), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "WasteEmpty", + 19, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_BOOL, + offsetof(CartridgeTagContent, has_wasteempty), + offsetof(CartridgeTagContent, wasteempty), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "WasteFilling", + 20, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_BOOL, + offsetof(CartridgeTagContent, has_wastefilling), + offsetof(CartridgeTagContent, wastefilling), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "WasteFull", + 21, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_BOOL, + offsetof(CartridgeTagContent, has_wastefull), + offsetof(CartridgeTagContent, wastefull), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "Blocked", + 22, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_BOOL, + offsetof(CartridgeTagContent, has_blocked), + offsetof(CartridgeTagContent, blocked), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "Fail", + 23, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_BOOL, + offsetof(CartridgeTagContent, has_fail), + offsetof(CartridgeTagContent, fail), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "WasteCounter", + 24, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_INT32, + offsetof(CartridgeTagContent, has_wastecounter), + offsetof(CartridgeTagContent, wastecounter), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "MachineIdInkUsed", + 25, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(CartridgeTagContent, machineidinkused), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "MachineIdWasteUsed", + 26, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(CartridgeTagContent, machineidwasteused), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned cartridge_tag_content__field_indices_by_name[] = { + 21, /* field[21] = Blocked */ + 12, /* field[12] = CartridgeFillingDate */ + 7, /* field[7] = CartridgeSize */ + 5, /* field[5] = ColorCategory */ + 4, /* field[4] = ColorName */ + 6, /* field[6] = ColorTypeRevision */ + 2, /* field[2] = FactoryId */ + 22, /* field[22] = Fail */ + 8, /* field[8] = FilledInkVolume */ + 3, /* field[3] = FillingSystemId */ + 9, /* field[9] = InkBatchNum */ + 11, /* field[11] = InkEOLDate */ + 17, /* field[17] = InkEmpty */ + 10, /* field[10] = InkMFGDate */ + 16, /* field[16] = InkUsed */ + 15, /* field[15] = Inkfill */ + 24, /* field[24] = MachineIdInkUsed */ + 25, /* field[25] = MachineIdWasteUsed */ + 14, /* field[14] = PlugInCounter */ + 1, /* field[1] = SerialNumber */ + 0, /* field[0] = UniqueId */ + 23, /* field[23] = WasteCounter */ + 18, /* field[18] = WasteEmpty */ + 13, /* field[13] = WasteFilledDate */ + 19, /* field[19] = WasteFilling */ + 20, /* field[20] = WasteFull */ +}; +static const ProtobufCIntRange cartridge_tag_content__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 26 } +}; +const ProtobufCMessageDescriptor cartridge_tag_content__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "CartridgeTagContent", + "CartridgeTagContent", + "CartridgeTagContent", + "", + sizeof(CartridgeTagContent), + 26, + cartridge_tag_content__field_descriptors, + cartridge_tag_content__field_indices_by_name, + 1, cartridge_tag_content__number_ranges, + (ProtobufCMessageInit) cartridge_tag_content__init, + NULL,NULL,NULL /* reserved[123] */ +}; diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/CartridgeTagContent.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/CartridgeTagContent.pb-c.h new file mode 100644 index 000000000..116bea117 --- /dev/null +++ b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/CartridgeTagContent.pb-c.h @@ -0,0 +1,112 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: CartridgeTagContent.proto */ + +#ifndef PROTOBUF_C_CartridgeTagContent_2eproto__INCLUDED +#define PROTOBUF_C_CartridgeTagContent_2eproto__INCLUDED + +#include <protobuf-c/protobuf-c.h> + +PROTOBUF_C__BEGIN_DECLS + +#if PROTOBUF_C_VERSION_NUMBER < 1003000 +# error This file was generated by a newer version of protoc-c which is incompatible with your libprotobuf-c headers. Please update your headers. +#elif 1003000 < PROTOBUF_C_MIN_COMPILER_VERSION +# error This file was generated by an older version of protoc-c which is incompatible with your libprotobuf-c headers. Please regenerate this file with a newer version of protoc-c. +#endif + + +typedef struct _CartridgeTagContent CartridgeTagContent; + + +/* --- enums --- */ + + +/* --- messages --- */ + +struct _CartridgeTagContent +{ + ProtobufCMessage base; + protobuf_c_boolean has_uniqueid; + uint32_t uniqueid; + char *serialnumber; + char *factoryid; + protobuf_c_boolean has_fillingsystemid; + int32_t fillingsystemid; + char *colorname; + protobuf_c_boolean has_colorcategory; + int32_t colorcategory; + protobuf_c_boolean has_colortyperevision; + int32_t colortyperevision; + protobuf_c_boolean has_cartridgesize; + int32_t cartridgesize; + protobuf_c_boolean has_filledinkvolume; + int32_t filledinkvolume; + char *inkbatchnum; + char *inkmfgdate; + char *inkeoldate; + char *cartridgefillingdate; + char *wastefilleddate; + protobuf_c_boolean has_plugincounter; + int32_t plugincounter; + protobuf_c_boolean has_inkfill; + protobuf_c_boolean inkfill; + protobuf_c_boolean has_inkused; + protobuf_c_boolean inkused; + protobuf_c_boolean has_inkempty; + protobuf_c_boolean inkempty; + protobuf_c_boolean has_wasteempty; + protobuf_c_boolean wasteempty; + protobuf_c_boolean has_wastefilling; + protobuf_c_boolean wastefilling; + protobuf_c_boolean has_wastefull; + protobuf_c_boolean wastefull; + protobuf_c_boolean has_blocked; + protobuf_c_boolean blocked; + protobuf_c_boolean has_fail; + protobuf_c_boolean fail; + protobuf_c_boolean has_wastecounter; + int32_t wastecounter; + char *machineidinkused; + char *machineidwasteused; +}; +#define CARTRIDGE_TAG_CONTENT__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&cartridge_tag_content__descriptor) \ + , 0, 0, NULL, NULL, 0, 0, NULL, 0, 0, 0, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL, NULL } + + +/* CartridgeTagContent methods */ +void cartridge_tag_content__init + (CartridgeTagContent *message); +size_t cartridge_tag_content__get_packed_size + (const CartridgeTagContent *message); +size_t cartridge_tag_content__pack + (const CartridgeTagContent *message, + uint8_t *out); +size_t cartridge_tag_content__pack_to_buffer + (const CartridgeTagContent *message, + ProtobufCBuffer *buffer); +CartridgeTagContent * + cartridge_tag_content__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void cartridge_tag_content__free_unpacked + (CartridgeTagContent *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*CartridgeTagContent_Closure) + (const CartridgeTagContent *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCMessageDescriptor cartridge_tag_content__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_CartridgeTagContent_2eproto__INCLUDED */ diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/CartridgeValidationRequest.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/CartridgeValidationRequest.pb-c.c new file mode 100644 index 000000000..e78b31d4b --- /dev/null +++ b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/CartridgeValidationRequest.pb-c.c @@ -0,0 +1,105 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: CartridgeValidationRequest.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "CartridgeValidationRequest.pb-c.h" +void cartridge_validation_request__init + (CartridgeValidationRequest *message) +{ + static const CartridgeValidationRequest init_value = CARTRIDGE_VALIDATION_REQUEST__INIT; + *message = init_value; +} +size_t cartridge_validation_request__get_packed_size + (const CartridgeValidationRequest *message) +{ + assert(message->base.descriptor == &cartridge_validation_request__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t cartridge_validation_request__pack + (const CartridgeValidationRequest *message, + uint8_t *out) +{ + assert(message->base.descriptor == &cartridge_validation_request__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t cartridge_validation_request__pack_to_buffer + (const CartridgeValidationRequest *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &cartridge_validation_request__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +CartridgeValidationRequest * + cartridge_validation_request__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (CartridgeValidationRequest *) + protobuf_c_message_unpack (&cartridge_validation_request__descriptor, + allocator, len, data); +} +void cartridge_validation_request__free_unpacked + (CartridgeValidationRequest *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &cartridge_validation_request__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +static const ProtobufCFieldDescriptor cartridge_validation_request__field_descriptors[2] = +{ + { + "Cartridge", + 1, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(CartridgeValidationRequest, cartridge), + &cartridge__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "Action", + 2, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_ENUM, + offsetof(CartridgeValidationRequest, has_action), + offsetof(CartridgeValidationRequest, action), + &cartridge_action__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned cartridge_validation_request__field_indices_by_name[] = { + 1, /* field[1] = Action */ + 0, /* field[0] = Cartridge */ +}; +static const ProtobufCIntRange cartridge_validation_request__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor cartridge_validation_request__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "CartridgeValidationRequest", + "CartridgeValidationRequest", + "CartridgeValidationRequest", + "", + sizeof(CartridgeValidationRequest), + 2, + cartridge_validation_request__field_descriptors, + cartridge_validation_request__field_indices_by_name, + 1, cartridge_validation_request__number_ranges, + (ProtobufCMessageInit) cartridge_validation_request__init, + NULL,NULL,NULL /* reserved[123] */ +}; diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/CartridgeValidationRequest.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/CartridgeValidationRequest.pb-c.h new file mode 100644 index 000000000..568baa8ce --- /dev/null +++ b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/CartridgeValidationRequest.pb-c.h @@ -0,0 +1,75 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: CartridgeValidationRequest.proto */ + +#ifndef PROTOBUF_C_CartridgeValidationRequest_2eproto__INCLUDED +#define PROTOBUF_C_CartridgeValidationRequest_2eproto__INCLUDED + +#include <protobuf-c/protobuf-c.h> + +PROTOBUF_C__BEGIN_DECLS + +#if PROTOBUF_C_VERSION_NUMBER < 1003000 +# error This file was generated by a newer version of protoc-c which is incompatible with your libprotobuf-c headers. Please update your headers. +#elif 1003000 < PROTOBUF_C_MIN_COMPILER_VERSION +# error This file was generated by an older version of protoc-c which is incompatible with your libprotobuf-c headers. Please regenerate this file with a newer version of protoc-c. +#endif + +#include "Cartridge.pb-c.h" +#include "CartridgeAction.pb-c.h" + +typedef struct _CartridgeValidationRequest CartridgeValidationRequest; + + +/* --- enums --- */ + + +/* --- messages --- */ + +struct _CartridgeValidationRequest +{ + ProtobufCMessage base; + Cartridge *cartridge; + protobuf_c_boolean has_action; + CartridgeAction action; +}; +#define CARTRIDGE_VALIDATION_REQUEST__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&cartridge_validation_request__descriptor) \ + , NULL, 0, CARTRIDGE_ACTION__Inserted } + + +/* CartridgeValidationRequest methods */ +void cartridge_validation_request__init + (CartridgeValidationRequest *message); +size_t cartridge_validation_request__get_packed_size + (const CartridgeValidationRequest *message); +size_t cartridge_validation_request__pack + (const CartridgeValidationRequest *message, + uint8_t *out); +size_t cartridge_validation_request__pack_to_buffer + (const CartridgeValidationRequest *message, + ProtobufCBuffer *buffer); +CartridgeValidationRequest * + cartridge_validation_request__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void cartridge_validation_request__free_unpacked + (CartridgeValidationRequest *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*CartridgeValidationRequest_Closure) + (const CartridgeValidationRequest *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCMessageDescriptor cartridge_validation_request__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_CartridgeValidationRequest_2eproto__INCLUDED */ diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/CartridgeValidationResponse.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/CartridgeValidationResponse.pb-c.c new file mode 100644 index 000000000..835be6765 --- /dev/null +++ b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/CartridgeValidationResponse.pb-c.c @@ -0,0 +1,105 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: CartridgeValidationResponse.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "CartridgeValidationResponse.pb-c.h" +void cartridge_validation_response__init + (CartridgeValidationResponse *message) +{ + static const CartridgeValidationResponse init_value = CARTRIDGE_VALIDATION_RESPONSE__INIT; + *message = init_value; +} +size_t cartridge_validation_response__get_packed_size + (const CartridgeValidationResponse *message) +{ + assert(message->base.descriptor == &cartridge_validation_response__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t cartridge_validation_response__pack + (const CartridgeValidationResponse *message, + uint8_t *out) +{ + assert(message->base.descriptor == &cartridge_validation_response__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t cartridge_validation_response__pack_to_buffer + (const CartridgeValidationResponse *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &cartridge_validation_response__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +CartridgeValidationResponse * + cartridge_validation_response__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (CartridgeValidationResponse *) + protobuf_c_message_unpack (&cartridge_validation_response__descriptor, + allocator, len, data); +} +void cartridge_validation_response__free_unpacked + (CartridgeValidationResponse *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &cartridge_validation_response__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +static const ProtobufCFieldDescriptor cartridge_validation_response__field_descriptors[2] = +{ + { + "IsValid", + 1, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_BOOL, + offsetof(CartridgeValidationResponse, has_isvalid), + offsetof(CartridgeValidationResponse, isvalid), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "Cartridge", + 2, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(CartridgeValidationResponse, cartridge), + &cartridge__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned cartridge_validation_response__field_indices_by_name[] = { + 1, /* field[1] = Cartridge */ + 0, /* field[0] = IsValid */ +}; +static const ProtobufCIntRange cartridge_validation_response__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor cartridge_validation_response__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "CartridgeValidationResponse", + "CartridgeValidationResponse", + "CartridgeValidationResponse", + "", + sizeof(CartridgeValidationResponse), + 2, + cartridge_validation_response__field_descriptors, + cartridge_validation_response__field_indices_by_name, + 1, cartridge_validation_response__number_ranges, + (ProtobufCMessageInit) cartridge_validation_response__init, + NULL,NULL,NULL /* reserved[123] */ +}; diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/CartridgeValidationResponse.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/CartridgeValidationResponse.pb-c.h new file mode 100644 index 000000000..8803b6307 --- /dev/null +++ b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/CartridgeValidationResponse.pb-c.h @@ -0,0 +1,74 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: CartridgeValidationResponse.proto */ + +#ifndef PROTOBUF_C_CartridgeValidationResponse_2eproto__INCLUDED +#define PROTOBUF_C_CartridgeValidationResponse_2eproto__INCLUDED + +#include <protobuf-c/protobuf-c.h> + +PROTOBUF_C__BEGIN_DECLS + +#if PROTOBUF_C_VERSION_NUMBER < 1003000 +# error This file was generated by a newer version of protoc-c which is incompatible with your libprotobuf-c headers. Please update your headers. +#elif 1003000 < PROTOBUF_C_MIN_COMPILER_VERSION +# error This file was generated by an older version of protoc-c which is incompatible with your libprotobuf-c headers. Please regenerate this file with a newer version of protoc-c. +#endif + +#include "Cartridge.pb-c.h" + +typedef struct _CartridgeValidationResponse CartridgeValidationResponse; + + +/* --- enums --- */ + + +/* --- messages --- */ + +struct _CartridgeValidationResponse +{ + ProtobufCMessage base; + protobuf_c_boolean has_isvalid; + protobuf_c_boolean isvalid; + Cartridge *cartridge; +}; +#define CARTRIDGE_VALIDATION_RESPONSE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&cartridge_validation_response__descriptor) \ + , 0, 0, NULL } + + +/* CartridgeValidationResponse methods */ +void cartridge_validation_response__init + (CartridgeValidationResponse *message); +size_t cartridge_validation_response__get_packed_size + (const CartridgeValidationResponse *message); +size_t cartridge_validation_response__pack + (const CartridgeValidationResponse *message, + uint8_t *out); +size_t cartridge_validation_response__pack_to_buffer + (const CartridgeValidationResponse *message, + ProtobufCBuffer *buffer); +CartridgeValidationResponse * + cartridge_validation_response__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void cartridge_validation_response__free_unpacked + (CartridgeValidationResponse *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*CartridgeValidationResponse_Closure) + (const CartridgeValidationResponse *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCMessageDescriptor cartridge_validation_response__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_CartridgeValidationResponse_2eproto__INCLUDED */ 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 d5b888912..11ae78d92 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,7 +7,7 @@ #endif #include "EventType.pb-c.h" -static const ProtobufCEnumValue event_type__enum_values_by_number[285] = +static const ProtobufCEnumValue event_type__enum_values_by_number[289] = { { "None", "EVENT_TYPE__None", 0 }, { "REQUEST_SENT", "EVENT_TYPE__REQUEST_SENT", 1000 }, @@ -20,6 +20,10 @@ static const ProtobufCEnumValue event_type__enum_values_by_number[285] = { "RECORDING_STARTED", "EVENT_TYPE__RECORDING_STARTED", 1007 }, { "RECORDING_STOPPED", "EVENT_TYPE__RECORDING_STOPPED", 1008 }, { "JOB_STATUS", "EVENT_TYPE__JOB_STATUS", 1009 }, + { "JOB_STARTED", "EVENT_TYPE__JOB_STARTED", 1010 }, + { "JOB_ABORTED", "EVENT_TYPE__JOB_ABORTED", 1011 }, + { "JOB_FAILED", "EVENT_TYPE__JOB_FAILED", 1012 }, + { "JOB_COMPLETED", "EVENT_TYPE__JOB_COMPLETED", 1013 }, { "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 }, @@ -296,295 +300,299 @@ static const ProtobufCEnumValue event_type__enum_values_by_number[285] = { "WASTE_CARTRIDGE_RFID_TIMEOUT", "EVENT_TYPE__WASTE_CARTRIDGE_RFID_TIMEOUT", 10005 }, }; static const ProtobufCIntRange event_type__value_ranges[] = { -{0, 0},{1000, 1},{2000, 11},{3000, 28},{4000, 79},{5000, 101},{6000, 144},{7000, 150},{8000, 238},{9000, 270},{10000, 279},{0, 285} +{0, 0},{1000, 1},{2000, 15},{3000, 32},{4000, 83},{5000, 105},{6000, 148},{7000, 154},{8000, 242},{9000, 274},{10000, 283},{0, 289} }; -static const ProtobufCEnumValueIndex event_type__enum_values_by_name[285] = +static const ProtobufCEnumValueIndex event_type__enum_values_by_name[289] = { - { "AIR_FILTER_CLOGGED", 271 }, - { "AIR_FILTER_NOT_INSTALLED", 270 }, - { "ALL_WASTE_CARTRIDGES_FULL", 282 }, + { "AIR_FILTER_CLOGGED", 275 }, + { "AIR_FILTER_NOT_INSTALLED", 274 }, + { "ALL_WASTE_CARTRIDGES_FULL", 286 }, { "APPLICATION_EXCEPTION", 4 }, { "APPLICATION_INFORMATION", 5 }, { "APPLICATION_STARTED", 6 }, { "APPLICATION_TERMINATED", 7 }, - { "CARTRIDGES_COVER_OPEN", 17 }, - { "CHILLER_DRY_CONTACT", 276 }, - { "DISPENSER_1_EMPTY", 166 }, - { "DISPENSER_1_HIGH_PRESSURE", 230 }, - { "DISPENSER_1_LOWER_HARD_LIMIT", 222 }, - { "DISPENSER_1_MOTOR_OVERCURRENT", 182 }, - { "DISPENSER_1_MOTOR_OVERTEMPERATURE", 190 }, - { "DISPENSER_1_MOTOR_STALL", 198 }, - { "DISPENSER_1_MOTOR_UNDERVOLTAGE", 206 }, - { "DISPENSER_1_OVERPRESSURE", 150 }, - { "DISPENSER_1_REFILL_FAILURE", 174 }, - { "DISPENSER_1_UNDERPRESSURE", 158 }, - { "DISPENSER_1_UPPER_HARD_LIMIT", 214 }, - { "DISPENSER_2_EMPTY", 167 }, - { "DISPENSER_2_HIGH_PRESSURE", 231 }, - { "DISPENSER_2_LOWER_HARD_LIMIT", 223 }, - { "DISPENSER_2_MOTOR_OVERCURRENT", 183 }, - { "DISPENSER_2_MOTOR_OVERTEMPERATURE", 191 }, - { "DISPENSER_2_MOTOR_STALL", 199 }, - { "DISPENSER_2_MOTOR_UNDERVOLTAGE", 207 }, - { "DISPENSER_2_OVERPRESSURE", 151 }, - { "DISPENSER_2_REFILL_FAILURE", 175 }, - { "DISPENSER_2_UNDERPRESSURE", 159 }, - { "DISPENSER_2_UPPER_HARD_LIMIT", 215 }, - { "DISPENSER_3_EMPTY", 168 }, - { "DISPENSER_3_HIGH_PRESSURE", 232 }, - { "DISPENSER_3_LOWER_HARD_LIMIT", 224 }, - { "DISPENSER_3_MOTOR_OVERCURRENT", 184 }, - { "DISPENSER_3_MOTOR_OVERTEMPERATURE", 192 }, - { "DISPENSER_3_MOTOR_STALL", 200 }, - { "DISPENSER_3_MOTOR_UNDERVOLTAGE", 208 }, - { "DISPENSER_3_OVERPRESSURE", 152 }, - { "DISPENSER_3_REFILL_FAILURE", 176 }, - { "DISPENSER_3_UNDERPRESSURE", 160 }, - { "DISPENSER_3_UPPER_HARD_LIMIT", 216 }, - { "DISPENSER_4_EMPTY", 169 }, - { "DISPENSER_4_HIGH_PRESSURE", 233 }, - { "DISPENSER_4_LOWER_HARD_LIMIT", 225 }, - { "DISPENSER_4_MOTOR_OVERCURRENT", 185 }, - { "DISPENSER_4_MOTOR_OVERTEMPERATURE", 193 }, - { "DISPENSER_4_MOTOR_STALL", 201 }, - { "DISPENSER_4_MOTOR_UNDERVOLTAGE", 209 }, - { "DISPENSER_4_OVERPRESSURE", 153 }, - { "DISPENSER_4_REFILL_FAILURE", 177 }, - { "DISPENSER_4_UNDERPRESSURE", 161 }, - { "DISPENSER_4_UPPER_HARD_LIMIT", 217 }, - { "DISPENSER_5_EMPTY", 170 }, - { "DISPENSER_5_HIGH_PRESSURE", 234 }, - { "DISPENSER_5_LOWER_HARD_LIMIT", 226 }, - { "DISPENSER_5_MOTOR_OVERCURRENT", 186 }, - { "DISPENSER_5_MOTOR_OVERTEMPERATURE", 194 }, - { "DISPENSER_5_MOTOR_STALL", 202 }, - { "DISPENSER_5_MOTOR_UNDERVOLTAGE", 210 }, - { "DISPENSER_5_OVERPRESSURE", 154 }, - { "DISPENSER_5_REFILL_FAILURE", 178 }, - { "DISPENSER_5_UNDERPRESSURE", 162 }, - { "DISPENSER_5_UPPER_HARD_LIMIT", 218 }, - { "DISPENSER_6_EMPTY", 171 }, - { "DISPENSER_6_HIGH_PRESSURE", 235 }, - { "DISPENSER_6_LOWER_HARD_LIMIT", 227 }, - { "DISPENSER_6_MOTOR_OVERCURRENT", 187 }, - { "DISPENSER_6_MOTOR_OVERTEMPERATURE", 195 }, - { "DISPENSER_6_MOTOR_STALL", 203 }, - { "DISPENSER_6_MOTOR_UNDERVOLTAGE", 211 }, - { "DISPENSER_6_OVERPRESSURE", 155 }, - { "DISPENSER_6_REFILL_FAILURE", 179 }, - { "DISPENSER_6_UNDERPRESSURE", 163 }, - { "DISPENSER_6_UPPER_HARD_LIMIT", 219 }, - { "DISPENSER_7_EMPTY", 172 }, - { "DISPENSER_7_HIGH_PRESSURE", 236 }, - { "DISPENSER_7_LOWER_HARD_LIMIT", 228 }, - { "DISPENSER_7_MOTOR_OVERCURRENT", 188 }, - { "DISPENSER_7_MOTOR_OVERTEMPERATURE", 196 }, - { "DISPENSER_7_MOTOR_STALL", 204 }, - { "DISPENSER_7_MOTOR_UNDERVOLTAGE", 212 }, - { "DISPENSER_7_OVERPRESSURE", 156 }, - { "DISPENSER_7_REFILL_FAILURE", 180 }, - { "DISPENSER_7_UNDERPRESSURE", 164 }, - { "DISPENSER_7_UPPER_HARD_LIMIT", 220 }, - { "DISPENSER_8_EMPTY", 173 }, - { "DISPENSER_8_HIGH_PRESSURE", 237 }, - { "DISPENSER_8_LOWER_HARD_LIMIT", 229 }, - { "DISPENSER_8_MOTOR_OVERCURRENT", 189 }, - { "DISPENSER_8_MOTOR_OVERTEMPERATURE", 197 }, - { "DISPENSER_8_MOTOR_STALL", 205 }, - { "DISPENSER_8_MOTOR_UNDERVOLTAGE", 213 }, - { "DISPENSER_8_OVERPRESSURE", 157 }, - { "DISPENSER_8_REFILL_FAILURE", 181 }, - { "DISPENSER_8_UNDERPRESSURE", 165 }, - { "DISPENSER_8_UPPER_HARD_LIMIT", 221 }, - { "DRYER_DOOR_OPEN", 83 }, - { "DRYER_FAN_RPM_TOO_LOW", 94 }, - { "DRYER_FAN_STOPPED", 95 }, - { "DRYER_HEATERS_ZONE_1_CURRENT_LOOP_BREAK", 92 }, - { "DRYER_HEATERS_ZONE_1_CURRENT_OUT_OF_RANGE", 90 }, - { "DRYER_HEATERS_ZONE_2_CURRENT_LOOP_BREAK", 93 }, - { "DRYER_HEATERS_ZONE_2_CURRENT_OUT_OF_RANGE", 91 }, - { "DRYER_LID_MOTOR_OVERCURRENT", 96 }, - { "DRYER_LID_MOTOR_OVERTEMPERATURE", 97 }, - { "DRYER_LID_MOTOR_STALL", 98 }, - { "DRYER_LID_MOTOR_UNDERVOLTAGE", 99 }, - { "DRYER_MOTOR_OVERCURRENT", 79 }, - { "DRYER_MOTOR_OVERTEMPERATURE", 80 }, - { "DRYER_MOTOR_STALL", 81 }, - { "DRYER_MOTOR_UNDERVOLTAGE", 82 }, - { "DRYER_THERMAL_CUTOFF", 89 }, - { "DRYER_ZONE_1_OVERTEMPERATURE", 84 }, - { "DRYER_ZONE_1_UNDERTEMPERATURE_A", 86 }, - { "DRYER_ZONE_1_UNDERTEMPERATURE_B", 87 }, - { "DRYER_ZONE_2_OVERTEMPERATURE", 85 }, - { "DRYER_ZONE_2_UNDERTEMPERATURE_A", 100 }, - { "DRYER_ZONE_2_UNDERTEMPERATURE_B", 88 }, - { "DYEING_HEAD_CLEANING_HEAD_MOTOR_OVERCURRENT", 140 }, - { "DYEING_HEAD_CLEANING_HEAD_MOTOR_OVERTEMPERATURE", 141 }, - { "DYEING_HEAD_CLEANING_HEAD_MOTOR_STALL", 142 }, - { "DYEING_HEAD_CLEANING_HEAD_MOTOR_UNDERVOLTAGE", 143 }, - { "DYEING_HEAD_CLEANING_MECHANISM_MOTOR_OVERCURRENT", 136 }, - { "DYEING_HEAD_CLEANING_MECHANISM_MOTOR_OVERTEMPERATURE", 137 }, - { "DYEING_HEAD_CLEANING_MECHANISM_MOTOR_STALL", 138 }, - { "DYEING_HEAD_CLEANING_MECHANISM_MOTOR_UNDERVOLTAGE", 139 }, - { "DYEING_HEAD_COVER_CLOSE_TIMEOUT", 131 }, - { "DYEING_HEAD_COVER_MOTOR_OVERCURRENT", 132 }, - { "DYEING_HEAD_COVER_MOTOR_OVERTEMPERATURE", 133 }, - { "DYEING_HEAD_COVER_MOTOR_STALL", 134 }, - { "DYEING_HEAD_COVER_MOTOR_UNDERVOLTAGE", 135 }, - { "DYEING_HEAD_COVER_OPEN_TIMEOUT", 130 }, - { "DYEING_HEAD_THERMAL_CUTOFF", 129 }, - { "DYEING_HEAD_ZONE_1_CURRENT_LOOP_BREAK", 124 }, - { "DYEING_HEAD_ZONE_1_CURRENT_OUT_OF_RANGE", 119 }, - { "DYEING_HEAD_ZONE_1_OVERTEMPERATURE", 101 }, - { "DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_A", 107 }, - { "DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_B", 113 }, - { "DYEING_HEAD_ZONE_2_CURRENT_LOOP_BREAK", 125 }, - { "DYEING_HEAD_ZONE_2_CURRENT_OUT_OF_RANGE", 120 }, - { "DYEING_HEAD_ZONE_2_OVERTEMPERATURE", 102 }, - { "DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_A", 108 }, - { "DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_B", 114 }, - { "DYEING_HEAD_ZONE_3_CURRENT_LOOP_BREAK", 126 }, - { "DYEING_HEAD_ZONE_3_CURRENT_OUT_OF_RANGE", 121 }, - { "DYEING_HEAD_ZONE_3_OVERTEMPERATURE", 103 }, - { "DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_A", 109 }, - { "DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_B", 115 }, - { "DYEING_HEAD_ZONE_4_CURRENT_LOOP_BREAK", 127 }, - { "DYEING_HEAD_ZONE_4_CURRENT_OUT_OF_RANGE", 122 }, - { "DYEING_HEAD_ZONE_4_OVERTEMPERATURE", 104 }, - { "DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_A", 110 }, - { "DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_B", 116 }, - { "DYEING_HEAD_ZONE_5_6_CURRENT_LOOP_BREAK", 128 }, - { "DYEING_HEAD_ZONE_5_6_CURRENT_OUT_OF_RANGE", 123 }, - { "DYEING_HEAD_ZONE_5_OVERTEMPERATURE", 105 }, - { "DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_A", 111 }, - { "DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_B", 117 }, - { "DYEING_HEAD_ZONE_6_OVERTEMPERATURE", 106 }, - { "DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_A", 112 }, - { "DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_B", 118 }, - { "ELECTRICAL_CABINET_FANS_RPM_TOO_LOW", 22 }, - { "ELECTRICAL_CABINET_FANS_STOPPED", 23 }, - { "EMERGENCY_PUSH_BUTTON_PRESSED", 12 }, - { "FEEDER_DANCER_MOTOR_OVERCURRENT", 66 }, - { "FEEDER_DANCER_MOTOR_OVERTEMPERATURE", 69 }, - { "FEEDER_DANCER_MOTOR_STALL", 72 }, - { "FEEDER_DANCER_MOTOR_UNDERVOLTAGE", 75 }, - { "FEEDER_MOTOR_OVERCURRENT", 31 }, - { "FEEDER_MOTOR_OVERTEMPERATURE", 38 }, - { "FEEDER_MOTOR_STALL", 45 }, - { "FEEDER_MOTOR_UNDERVOLTAGE", 52 }, - { "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", 279 }, - { "INK_CARTRIDGE_RFID_TIMEOUT", 280 }, - { "INSUFFICIENT_AIR_FLOW", 277 }, + { "CARTRIDGES_COVER_OPEN", 21 }, + { "CHILLER_DRY_CONTACT", 280 }, + { "DISPENSER_1_EMPTY", 170 }, + { "DISPENSER_1_HIGH_PRESSURE", 234 }, + { "DISPENSER_1_LOWER_HARD_LIMIT", 226 }, + { "DISPENSER_1_MOTOR_OVERCURRENT", 186 }, + { "DISPENSER_1_MOTOR_OVERTEMPERATURE", 194 }, + { "DISPENSER_1_MOTOR_STALL", 202 }, + { "DISPENSER_1_MOTOR_UNDERVOLTAGE", 210 }, + { "DISPENSER_1_OVERPRESSURE", 154 }, + { "DISPENSER_1_REFILL_FAILURE", 178 }, + { "DISPENSER_1_UNDERPRESSURE", 162 }, + { "DISPENSER_1_UPPER_HARD_LIMIT", 218 }, + { "DISPENSER_2_EMPTY", 171 }, + { "DISPENSER_2_HIGH_PRESSURE", 235 }, + { "DISPENSER_2_LOWER_HARD_LIMIT", 227 }, + { "DISPENSER_2_MOTOR_OVERCURRENT", 187 }, + { "DISPENSER_2_MOTOR_OVERTEMPERATURE", 195 }, + { "DISPENSER_2_MOTOR_STALL", 203 }, + { "DISPENSER_2_MOTOR_UNDERVOLTAGE", 211 }, + { "DISPENSER_2_OVERPRESSURE", 155 }, + { "DISPENSER_2_REFILL_FAILURE", 179 }, + { "DISPENSER_2_UNDERPRESSURE", 163 }, + { "DISPENSER_2_UPPER_HARD_LIMIT", 219 }, + { "DISPENSER_3_EMPTY", 172 }, + { "DISPENSER_3_HIGH_PRESSURE", 236 }, + { "DISPENSER_3_LOWER_HARD_LIMIT", 228 }, + { "DISPENSER_3_MOTOR_OVERCURRENT", 188 }, + { "DISPENSER_3_MOTOR_OVERTEMPERATURE", 196 }, + { "DISPENSER_3_MOTOR_STALL", 204 }, + { "DISPENSER_3_MOTOR_UNDERVOLTAGE", 212 }, + { "DISPENSER_3_OVERPRESSURE", 156 }, + { "DISPENSER_3_REFILL_FAILURE", 180 }, + { "DISPENSER_3_UNDERPRESSURE", 164 }, + { "DISPENSER_3_UPPER_HARD_LIMIT", 220 }, + { "DISPENSER_4_EMPTY", 173 }, + { "DISPENSER_4_HIGH_PRESSURE", 237 }, + { "DISPENSER_4_LOWER_HARD_LIMIT", 229 }, + { "DISPENSER_4_MOTOR_OVERCURRENT", 189 }, + { "DISPENSER_4_MOTOR_OVERTEMPERATURE", 197 }, + { "DISPENSER_4_MOTOR_STALL", 205 }, + { "DISPENSER_4_MOTOR_UNDERVOLTAGE", 213 }, + { "DISPENSER_4_OVERPRESSURE", 157 }, + { "DISPENSER_4_REFILL_FAILURE", 181 }, + { "DISPENSER_4_UNDERPRESSURE", 165 }, + { "DISPENSER_4_UPPER_HARD_LIMIT", 221 }, + { "DISPENSER_5_EMPTY", 174 }, + { "DISPENSER_5_HIGH_PRESSURE", 238 }, + { "DISPENSER_5_LOWER_HARD_LIMIT", 230 }, + { "DISPENSER_5_MOTOR_OVERCURRENT", 190 }, + { "DISPENSER_5_MOTOR_OVERTEMPERATURE", 198 }, + { "DISPENSER_5_MOTOR_STALL", 206 }, + { "DISPENSER_5_MOTOR_UNDERVOLTAGE", 214 }, + { "DISPENSER_5_OVERPRESSURE", 158 }, + { "DISPENSER_5_REFILL_FAILURE", 182 }, + { "DISPENSER_5_UNDERPRESSURE", 166 }, + { "DISPENSER_5_UPPER_HARD_LIMIT", 222 }, + { "DISPENSER_6_EMPTY", 175 }, + { "DISPENSER_6_HIGH_PRESSURE", 239 }, + { "DISPENSER_6_LOWER_HARD_LIMIT", 231 }, + { "DISPENSER_6_MOTOR_OVERCURRENT", 191 }, + { "DISPENSER_6_MOTOR_OVERTEMPERATURE", 199 }, + { "DISPENSER_6_MOTOR_STALL", 207 }, + { "DISPENSER_6_MOTOR_UNDERVOLTAGE", 215 }, + { "DISPENSER_6_OVERPRESSURE", 159 }, + { "DISPENSER_6_REFILL_FAILURE", 183 }, + { "DISPENSER_6_UNDERPRESSURE", 167 }, + { "DISPENSER_6_UPPER_HARD_LIMIT", 223 }, + { "DISPENSER_7_EMPTY", 176 }, + { "DISPENSER_7_HIGH_PRESSURE", 240 }, + { "DISPENSER_7_LOWER_HARD_LIMIT", 232 }, + { "DISPENSER_7_MOTOR_OVERCURRENT", 192 }, + { "DISPENSER_7_MOTOR_OVERTEMPERATURE", 200 }, + { "DISPENSER_7_MOTOR_STALL", 208 }, + { "DISPENSER_7_MOTOR_UNDERVOLTAGE", 216 }, + { "DISPENSER_7_OVERPRESSURE", 160 }, + { "DISPENSER_7_REFILL_FAILURE", 184 }, + { "DISPENSER_7_UNDERPRESSURE", 168 }, + { "DISPENSER_7_UPPER_HARD_LIMIT", 224 }, + { "DISPENSER_8_EMPTY", 177 }, + { "DISPENSER_8_HIGH_PRESSURE", 241 }, + { "DISPENSER_8_LOWER_HARD_LIMIT", 233 }, + { "DISPENSER_8_MOTOR_OVERCURRENT", 193 }, + { "DISPENSER_8_MOTOR_OVERTEMPERATURE", 201 }, + { "DISPENSER_8_MOTOR_STALL", 209 }, + { "DISPENSER_8_MOTOR_UNDERVOLTAGE", 217 }, + { "DISPENSER_8_OVERPRESSURE", 161 }, + { "DISPENSER_8_REFILL_FAILURE", 185 }, + { "DISPENSER_8_UNDERPRESSURE", 169 }, + { "DISPENSER_8_UPPER_HARD_LIMIT", 225 }, + { "DRYER_DOOR_OPEN", 87 }, + { "DRYER_FAN_RPM_TOO_LOW", 98 }, + { "DRYER_FAN_STOPPED", 99 }, + { "DRYER_HEATERS_ZONE_1_CURRENT_LOOP_BREAK", 96 }, + { "DRYER_HEATERS_ZONE_1_CURRENT_OUT_OF_RANGE", 94 }, + { "DRYER_HEATERS_ZONE_2_CURRENT_LOOP_BREAK", 97 }, + { "DRYER_HEATERS_ZONE_2_CURRENT_OUT_OF_RANGE", 95 }, + { "DRYER_LID_MOTOR_OVERCURRENT", 100 }, + { "DRYER_LID_MOTOR_OVERTEMPERATURE", 101 }, + { "DRYER_LID_MOTOR_STALL", 102 }, + { "DRYER_LID_MOTOR_UNDERVOLTAGE", 103 }, + { "DRYER_MOTOR_OVERCURRENT", 83 }, + { "DRYER_MOTOR_OVERTEMPERATURE", 84 }, + { "DRYER_MOTOR_STALL", 85 }, + { "DRYER_MOTOR_UNDERVOLTAGE", 86 }, + { "DRYER_THERMAL_CUTOFF", 93 }, + { "DRYER_ZONE_1_OVERTEMPERATURE", 88 }, + { "DRYER_ZONE_1_UNDERTEMPERATURE_A", 90 }, + { "DRYER_ZONE_1_UNDERTEMPERATURE_B", 91 }, + { "DRYER_ZONE_2_OVERTEMPERATURE", 89 }, + { "DRYER_ZONE_2_UNDERTEMPERATURE_A", 104 }, + { "DRYER_ZONE_2_UNDERTEMPERATURE_B", 92 }, + { "DYEING_HEAD_CLEANING_HEAD_MOTOR_OVERCURRENT", 144 }, + { "DYEING_HEAD_CLEANING_HEAD_MOTOR_OVERTEMPERATURE", 145 }, + { "DYEING_HEAD_CLEANING_HEAD_MOTOR_STALL", 146 }, + { "DYEING_HEAD_CLEANING_HEAD_MOTOR_UNDERVOLTAGE", 147 }, + { "DYEING_HEAD_CLEANING_MECHANISM_MOTOR_OVERCURRENT", 140 }, + { "DYEING_HEAD_CLEANING_MECHANISM_MOTOR_OVERTEMPERATURE", 141 }, + { "DYEING_HEAD_CLEANING_MECHANISM_MOTOR_STALL", 142 }, + { "DYEING_HEAD_CLEANING_MECHANISM_MOTOR_UNDERVOLTAGE", 143 }, + { "DYEING_HEAD_COVER_CLOSE_TIMEOUT", 135 }, + { "DYEING_HEAD_COVER_MOTOR_OVERCURRENT", 136 }, + { "DYEING_HEAD_COVER_MOTOR_OVERTEMPERATURE", 137 }, + { "DYEING_HEAD_COVER_MOTOR_STALL", 138 }, + { "DYEING_HEAD_COVER_MOTOR_UNDERVOLTAGE", 139 }, + { "DYEING_HEAD_COVER_OPEN_TIMEOUT", 134 }, + { "DYEING_HEAD_THERMAL_CUTOFF", 133 }, + { "DYEING_HEAD_ZONE_1_CURRENT_LOOP_BREAK", 128 }, + { "DYEING_HEAD_ZONE_1_CURRENT_OUT_OF_RANGE", 123 }, + { "DYEING_HEAD_ZONE_1_OVERTEMPERATURE", 105 }, + { "DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_A", 111 }, + { "DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_B", 117 }, + { "DYEING_HEAD_ZONE_2_CURRENT_LOOP_BREAK", 129 }, + { "DYEING_HEAD_ZONE_2_CURRENT_OUT_OF_RANGE", 124 }, + { "DYEING_HEAD_ZONE_2_OVERTEMPERATURE", 106 }, + { "DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_A", 112 }, + { "DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_B", 118 }, + { "DYEING_HEAD_ZONE_3_CURRENT_LOOP_BREAK", 130 }, + { "DYEING_HEAD_ZONE_3_CURRENT_OUT_OF_RANGE", 125 }, + { "DYEING_HEAD_ZONE_3_OVERTEMPERATURE", 107 }, + { "DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_A", 113 }, + { "DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_B", 119 }, + { "DYEING_HEAD_ZONE_4_CURRENT_LOOP_BREAK", 131 }, + { "DYEING_HEAD_ZONE_4_CURRENT_OUT_OF_RANGE", 126 }, + { "DYEING_HEAD_ZONE_4_OVERTEMPERATURE", 108 }, + { "DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_A", 114 }, + { "DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_B", 120 }, + { "DYEING_HEAD_ZONE_5_6_CURRENT_LOOP_BREAK", 132 }, + { "DYEING_HEAD_ZONE_5_6_CURRENT_OUT_OF_RANGE", 127 }, + { "DYEING_HEAD_ZONE_5_OVERTEMPERATURE", 109 }, + { "DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_A", 115 }, + { "DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_B", 121 }, + { "DYEING_HEAD_ZONE_6_OVERTEMPERATURE", 110 }, + { "DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_A", 116 }, + { "DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_B", 122 }, + { "ELECTRICAL_CABINET_FANS_RPM_TOO_LOW", 26 }, + { "ELECTRICAL_CABINET_FANS_STOPPED", 27 }, + { "EMERGENCY_PUSH_BUTTON_PRESSED", 16 }, + { "FEEDER_DANCER_MOTOR_OVERCURRENT", 70 }, + { "FEEDER_DANCER_MOTOR_OVERTEMPERATURE", 73 }, + { "FEEDER_DANCER_MOTOR_STALL", 76 }, + { "FEEDER_DANCER_MOTOR_UNDERVOLTAGE", 79 }, + { "FEEDER_MOTOR_OVERCURRENT", 35 }, + { "FEEDER_MOTOR_OVERTEMPERATURE", 42 }, + { "FEEDER_MOTOR_STALL", 49 }, + { "FEEDER_MOTOR_UNDERVOLTAGE", 56 }, + { "FRONT_COVER_1_OPEN", 17 }, + { "FRONT_COVER_2_OPEN", 18 }, + { "FRONT_COVER_3_OPEN", 19 }, + { "FRONT_COVER_4_OPEN", 20 }, + { "INK_CARTRIDGE_PRESENCE_SENSOR_TIMEOUT", 283 }, + { "INK_CARTRIDGE_RFID_TIMEOUT", 284 }, + { "INSUFFICIENT_AIR_FLOW", 281 }, + { "JOB_ABORTED", 12 }, + { "JOB_COMPLETED", 14 }, + { "JOB_FAILED", 13 }, + { "JOB_STARTED", 11 }, { "JOB_STATUS", 10 }, - { "LEFT_LOADER_MOTOR_OVERCURRENT", 34 }, - { "LEFT_LOADER_MOTOR_OVERTEMPERATURE", 41 }, - { "LEFT_LOADER_MOTOR_STALL", 48 }, - { "LEFT_LOADER_MOTOR_UNDERVOLTAGE", 55 }, - { "LOADING_ARM_MOTOR_OVERCURRENT", 37 }, - { "LOADING_ARM_MOTOR_OVERTEMPERATURE", 44 }, - { "LOADING_ARM_MOTOR_STALL", 51 }, - { "LOADING_ARM_MOTOR_UNDERVOLTAGE", 58 }, - { "LTFU_DOWN_TIMEOUT", 60 }, - { "LTFU_UP_TIMEOUT", 59 }, - { "MACHINE_FANS_RPM_TOO_LOW", 20 }, - { "MACHINE_FANS_STOPPED", 21 }, - { "MACHINE_INTERNAL_OVERTEMPERATURE", 19 }, - { "MACHINE_STATE_HW_CONFIG_FAILED", 25 }, - { "MACHINE_STATE_INITIAL_BLOWER_FAILED", 26 }, - { "MACHINE_STATE_NO_CFG_FILE", 24 }, - { "MACHINE_STATE_NO_THREAD_DETECTED", 78 }, - { "MID_TANK_1_EMPTY", 246 }, - { "MID_TANK_1_FILL_TIMEOUT", 262 }, - { "MID_TANK_1_LOW_LEVEL", 238 }, - { "MID_TANK_1_OVERFLOW", 254 }, - { "MID_TANK_2_EMPTY", 247 }, - { "MID_TANK_2_FILL_TIMEOUT", 263 }, - { "MID_TANK_2_LOW_LEVEL", 239 }, - { "MID_TANK_2_OVERFLOW", 255 }, - { "MID_TANK_3_EMPTY", 248 }, - { "MID_TANK_3_FILL_TIMEOUT", 264 }, - { "MID_TANK_3_LOW_LEVEL", 240 }, - { "MID_TANK_3_OVERFLOW", 256 }, - { "MID_TANK_4_EMPTY", 249 }, - { "MID_TANK_4_FILL_TIMEOUT", 265 }, - { "MID_TANK_4_LOW_LEVEL", 241 }, - { "MID_TANK_4_OVERFLOW", 257 }, - { "MID_TANK_5_EMPTY", 250 }, - { "MID_TANK_5_FILL_TIMEOUT", 266 }, - { "MID_TANK_5_LOW_LEVEL", 242 }, - { "MID_TANK_5_OVERFLOW", 258 }, - { "MID_TANK_6_EMPTY", 251 }, - { "MID_TANK_6_FILL_TIMEOUT", 267 }, - { "MID_TANK_6_LOW_LEVEL", 243 }, - { "MID_TANK_6_OVERFLOW", 259 }, - { "MID_TANK_7_EMPTY", 252 }, - { "MID_TANK_7_FILL_TIMEOUT", 268 }, - { "MID_TANK_7_LOW_LEVEL", 244 }, - { "MID_TANK_7_OVERFLOW", 260 }, - { "MID_TANK_8_EMPTY", 253 }, - { "MID_TANK_8_FILL_TIMEOUT", 269 }, - { "MID_TANK_8_LOW_LEVEL", 245 }, - { "MID_TANK_8_OVERFLOW", 261 }, - { "MIXER_CURRENT_LOOP_BREAK", 149 }, - { "MIXER_CURRENT_OUT_OF_RANGE", 148 }, - { "MIXER_OVERTEMPERATURE", 144 }, - { "MIXER_THERMAL_CUTOFF", 147 }, - { "MIXER_UNDERTEMPERATURE_A", 145 }, - { "MIXER_UNDERTEMPERATURE_B", 146 }, - { "NO_AIR_PRESSURE", 273 }, - { "NO_WASTE_CARTRIDGE_AVAILABLE", 281 }, + { "LEFT_LOADER_MOTOR_OVERCURRENT", 38 }, + { "LEFT_LOADER_MOTOR_OVERTEMPERATURE", 45 }, + { "LEFT_LOADER_MOTOR_STALL", 52 }, + { "LEFT_LOADER_MOTOR_UNDERVOLTAGE", 59 }, + { "LOADING_ARM_MOTOR_OVERCURRENT", 41 }, + { "LOADING_ARM_MOTOR_OVERTEMPERATURE", 48 }, + { "LOADING_ARM_MOTOR_STALL", 55 }, + { "LOADING_ARM_MOTOR_UNDERVOLTAGE", 62 }, + { "LTFU_DOWN_TIMEOUT", 64 }, + { "LTFU_UP_TIMEOUT", 63 }, + { "MACHINE_FANS_RPM_TOO_LOW", 24 }, + { "MACHINE_FANS_STOPPED", 25 }, + { "MACHINE_INTERNAL_OVERTEMPERATURE", 23 }, + { "MACHINE_STATE_HW_CONFIG_FAILED", 29 }, + { "MACHINE_STATE_INITIAL_BLOWER_FAILED", 30 }, + { "MACHINE_STATE_NO_CFG_FILE", 28 }, + { "MACHINE_STATE_NO_THREAD_DETECTED", 82 }, + { "MID_TANK_1_EMPTY", 250 }, + { "MID_TANK_1_FILL_TIMEOUT", 266 }, + { "MID_TANK_1_LOW_LEVEL", 242 }, + { "MID_TANK_1_OVERFLOW", 258 }, + { "MID_TANK_2_EMPTY", 251 }, + { "MID_TANK_2_FILL_TIMEOUT", 267 }, + { "MID_TANK_2_LOW_LEVEL", 243 }, + { "MID_TANK_2_OVERFLOW", 259 }, + { "MID_TANK_3_EMPTY", 252 }, + { "MID_TANK_3_FILL_TIMEOUT", 268 }, + { "MID_TANK_3_LOW_LEVEL", 244 }, + { "MID_TANK_3_OVERFLOW", 260 }, + { "MID_TANK_4_EMPTY", 253 }, + { "MID_TANK_4_FILL_TIMEOUT", 269 }, + { "MID_TANK_4_LOW_LEVEL", 245 }, + { "MID_TANK_4_OVERFLOW", 261 }, + { "MID_TANK_5_EMPTY", 254 }, + { "MID_TANK_5_FILL_TIMEOUT", 270 }, + { "MID_TANK_5_LOW_LEVEL", 246 }, + { "MID_TANK_5_OVERFLOW", 262 }, + { "MID_TANK_6_EMPTY", 255 }, + { "MID_TANK_6_FILL_TIMEOUT", 271 }, + { "MID_TANK_6_LOW_LEVEL", 247 }, + { "MID_TANK_6_OVERFLOW", 263 }, + { "MID_TANK_7_EMPTY", 256 }, + { "MID_TANK_7_FILL_TIMEOUT", 272 }, + { "MID_TANK_7_LOW_LEVEL", 248 }, + { "MID_TANK_7_OVERFLOW", 264 }, + { "MID_TANK_8_EMPTY", 257 }, + { "MID_TANK_8_FILL_TIMEOUT", 273 }, + { "MID_TANK_8_LOW_LEVEL", 249 }, + { "MID_TANK_8_OVERFLOW", 265 }, + { "MIXER_CURRENT_LOOP_BREAK", 153 }, + { "MIXER_CURRENT_OUT_OF_RANGE", 152 }, + { "MIXER_OVERTEMPERATURE", 148 }, + { "MIXER_THERMAL_CUTOFF", 151 }, + { "MIXER_UNDERTEMPERATURE_A", 149 }, + { "MIXER_UNDERTEMPERATURE_B", 150 }, + { "NO_AIR_PRESSURE", 277 }, + { "NO_WASTE_CARTRIDGE_AVAILABLE", 285 }, { "None", 0 }, - { "POWER_UP_BIT_FAILURE", 11 }, - { "PULLER_DANCER_MOTOR_OVERCURRENT", 65 }, - { "PULLER_DANCER_MOTOR_OVERTEMPERATURE", 68 }, - { "PULLER_DANCER_MOTOR_STALL", 71 }, - { "PULLER_DANCER_MOTOR_UNDERVOLTAGE", 74 }, - { "PULLER_MOTOR_OVERCURRENT", 33 }, - { "PULLER_MOTOR_OVERTEMPERATURE", 40 }, - { "PULLER_MOTOR_STALL", 47 }, - { "PULLER_MOTOR_UNDERVOLTAGE", 54 }, - { "REAR_COVER_OPEN", 18 }, + { "POWER_UP_BIT_FAILURE", 15 }, + { "PULLER_DANCER_MOTOR_OVERCURRENT", 69 }, + { "PULLER_DANCER_MOTOR_OVERTEMPERATURE", 72 }, + { "PULLER_DANCER_MOTOR_STALL", 75 }, + { "PULLER_DANCER_MOTOR_UNDERVOLTAGE", 78 }, + { "PULLER_MOTOR_OVERCURRENT", 37 }, + { "PULLER_MOTOR_OVERTEMPERATURE", 44 }, + { "PULLER_MOTOR_STALL", 51 }, + { "PULLER_MOTOR_UNDERVOLTAGE", 58 }, + { "REAR_COVER_OPEN", 22 }, { "RECORDING_STARTED", 8 }, { "RECORDING_STOPPED", 9 }, { "REQUEST_FAILED", 3 }, { "REQUEST_SENT", 1 }, { "RESPONSE_RECEIVED", 2 }, - { "RIGHT_LOADER_MOTOR_OVERCURRENT", 32 }, - { "RIGHT_LOADER_MOTOR_OVERTEMPERATURE", 39 }, - { "RIGHT_LOADER_MOTOR_STALL", 46 }, - { "RIGHT_LOADER_MOTOR_UNDERVOLTAGE", 53 }, - { "RTFU_DOWN_TIMEOUT", 62 }, - { "RTFU_UP_TIMEOUT", 61 }, - { "SCREW_MOTOR_LIMIT_TIMEOUT", 63 }, - { "SCREW_MOTOR_OVERCURRENT", 36 }, - { "SCREW_MOTOR_OVERTEMPERATURE", 43 }, - { "SCREW_MOTOR_STALL", 50 }, - { "SCREW_MOTOR_UNDERVOLTAGE", 57 }, - { "THREAD_BREAK", 28 }, - { "THREAD_TENSION_CONTROL_FAILURE_FEEDER_DANCER", 29 }, - { "THREAD_TENSION_CONTROL_FAILURE_PULLER_DANCER", 76 }, - { "THREAD_TENSION_CONTROL_FAILURE_WINDER_DANCER", 77 }, - { "UNSPECIFIED", 27 }, - { "VOC_SENSOR_ALARM_SLOPE", 278 }, - { "VOC_SENSOR_ALARM_TIME", 275 }, - { "WASTE_CARTRIDGE_PRESENCE_SENSOR_TIMEOUT", 283 }, - { "WASTE_CARTRIDGE_RFID_TIMEOUT", 284 }, - { "WASTE_CONTAINER_EMPTYING_TIMEOUT", 272 }, - { "WASTE_CONTAINER_OVERFLOW", 274 }, - { "WINDER_CONE_DOES_NOT_EXIST", 30 }, - { "WINDER_DANCER_MOTOR_OVERCURRENT", 64 }, - { "WINDER_DANCER_MOTOR_OVERTEMPERATURE", 67 }, - { "WINDER_DANCER_MOTOR_STALL", 70 }, - { "WINDER_DANCER_MOTOR_UNDERVOLTAGE", 73 }, - { "WINDER_MOTOR_OVERCURRENT", 35 }, - { "WINDER_MOTOR_OVERTEMPERATURE", 42 }, - { "WINDER_MOTOR_STALL", 49 }, - { "WINDER_MOTOR_UNDERVOLTAGE", 56 }, + { "RIGHT_LOADER_MOTOR_OVERCURRENT", 36 }, + { "RIGHT_LOADER_MOTOR_OVERTEMPERATURE", 43 }, + { "RIGHT_LOADER_MOTOR_STALL", 50 }, + { "RIGHT_LOADER_MOTOR_UNDERVOLTAGE", 57 }, + { "RTFU_DOWN_TIMEOUT", 66 }, + { "RTFU_UP_TIMEOUT", 65 }, + { "SCREW_MOTOR_LIMIT_TIMEOUT", 67 }, + { "SCREW_MOTOR_OVERCURRENT", 40 }, + { "SCREW_MOTOR_OVERTEMPERATURE", 47 }, + { "SCREW_MOTOR_STALL", 54 }, + { "SCREW_MOTOR_UNDERVOLTAGE", 61 }, + { "THREAD_BREAK", 32 }, + { "THREAD_TENSION_CONTROL_FAILURE_FEEDER_DANCER", 33 }, + { "THREAD_TENSION_CONTROL_FAILURE_PULLER_DANCER", 80 }, + { "THREAD_TENSION_CONTROL_FAILURE_WINDER_DANCER", 81 }, + { "UNSPECIFIED", 31 }, + { "VOC_SENSOR_ALARM_SLOPE", 282 }, + { "VOC_SENSOR_ALARM_TIME", 279 }, + { "WASTE_CARTRIDGE_PRESENCE_SENSOR_TIMEOUT", 287 }, + { "WASTE_CARTRIDGE_RFID_TIMEOUT", 288 }, + { "WASTE_CONTAINER_EMPTYING_TIMEOUT", 276 }, + { "WASTE_CONTAINER_OVERFLOW", 278 }, + { "WINDER_CONE_DOES_NOT_EXIST", 34 }, + { "WINDER_DANCER_MOTOR_OVERCURRENT", 68 }, + { "WINDER_DANCER_MOTOR_OVERTEMPERATURE", 71 }, + { "WINDER_DANCER_MOTOR_STALL", 74 }, + { "WINDER_DANCER_MOTOR_UNDERVOLTAGE", 77 }, + { "WINDER_MOTOR_OVERCURRENT", 39 }, + { "WINDER_MOTOR_OVERTEMPERATURE", 46 }, + { "WINDER_MOTOR_STALL", 53 }, + { "WINDER_MOTOR_UNDERVOLTAGE", 60 }, }; const ProtobufCEnumDescriptor event_type__descriptor = { @@ -593,9 +601,9 @@ const ProtobufCEnumDescriptor event_type__descriptor = "EventType", "EventType", "", - 285, + 289, event_type__enum_values_by_number, - 285, + 289, event_type__enum_values_by_name, 11, event_type__value_ranges, 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 f8aecc24f..3a2ffd071 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 @@ -31,6 +31,10 @@ typedef enum _EventType { EVENT_TYPE__RECORDING_STARTED = 1007, EVENT_TYPE__RECORDING_STOPPED = 1008, EVENT_TYPE__JOB_STATUS = 1009, + EVENT_TYPE__JOB_STARTED = 1010, + EVENT_TYPE__JOB_ABORTED = 1011, + EVENT_TYPE__JOB_FAILED = 1012, + EVENT_TYPE__JOB_COMPLETED = 1013, EVENT_TYPE__POWER_UP_BIT_FAILURE = 2000, EVENT_TYPE__EMERGENCY_PUSH_BUTTON_PRESSED = 2001, EVENT_TYPE__FRONT_COVER_1_OPEN = 2002, diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/StartCartridgesUpdateRequest.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/StartCartridgesUpdateRequest.pb-c.c new file mode 100644 index 000000000..1e96547cf --- /dev/null +++ b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/StartCartridgesUpdateRequest.pb-c.c @@ -0,0 +1,72 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StartCartridgesUpdateRequest.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "StartCartridgesUpdateRequest.pb-c.h" +void start_cartridges_update_request__init + (StartCartridgesUpdateRequest *message) +{ + static const StartCartridgesUpdateRequest init_value = START_CARTRIDGES_UPDATE_REQUEST__INIT; + *message = init_value; +} +size_t start_cartridges_update_request__get_packed_size + (const StartCartridgesUpdateRequest *message) +{ + assert(message->base.descriptor == &start_cartridges_update_request__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t start_cartridges_update_request__pack + (const StartCartridgesUpdateRequest *message, + uint8_t *out) +{ + assert(message->base.descriptor == &start_cartridges_update_request__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t start_cartridges_update_request__pack_to_buffer + (const StartCartridgesUpdateRequest *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &start_cartridges_update_request__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +StartCartridgesUpdateRequest * + start_cartridges_update_request__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (StartCartridgesUpdateRequest *) + protobuf_c_message_unpack (&start_cartridges_update_request__descriptor, + allocator, len, data); +} +void start_cartridges_update_request__free_unpacked + (StartCartridgesUpdateRequest *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &start_cartridges_update_request__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +#define start_cartridges_update_request__field_descriptors NULL +#define start_cartridges_update_request__field_indices_by_name NULL +#define start_cartridges_update_request__number_ranges NULL +const ProtobufCMessageDescriptor start_cartridges_update_request__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "StartCartridgesUpdateRequest", + "StartCartridgesUpdateRequest", + "StartCartridgesUpdateRequest", + "", + sizeof(StartCartridgesUpdateRequest), + 0, + start_cartridges_update_request__field_descriptors, + start_cartridges_update_request__field_indices_by_name, + 0, start_cartridges_update_request__number_ranges, + (ProtobufCMessageInit) start_cartridges_update_request__init, + NULL,NULL,NULL /* reserved[123] */ +}; diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/StartCartridgesUpdateRequest.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/StartCartridgesUpdateRequest.pb-c.h new file mode 100644 index 000000000..f8f2dcf3b --- /dev/null +++ b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/StartCartridgesUpdateRequest.pb-c.h @@ -0,0 +1,70 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StartCartridgesUpdateRequest.proto */ + +#ifndef PROTOBUF_C_StartCartridgesUpdateRequest_2eproto__INCLUDED +#define PROTOBUF_C_StartCartridgesUpdateRequest_2eproto__INCLUDED + +#include <protobuf-c/protobuf-c.h> + +PROTOBUF_C__BEGIN_DECLS + +#if PROTOBUF_C_VERSION_NUMBER < 1003000 +# error This file was generated by a newer version of protoc-c which is incompatible with your libprotobuf-c headers. Please update your headers. +#elif 1003000 < PROTOBUF_C_MIN_COMPILER_VERSION +# error This file was generated by an older version of protoc-c which is incompatible with your libprotobuf-c headers. Please regenerate this file with a newer version of protoc-c. +#endif + + +typedef struct _StartCartridgesUpdateRequest StartCartridgesUpdateRequest; + + +/* --- enums --- */ + + +/* --- messages --- */ + +struct _StartCartridgesUpdateRequest +{ + ProtobufCMessage base; +}; +#define START_CARTRIDGES_UPDATE_REQUEST__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&start_cartridges_update_request__descriptor) \ + } + + +/* StartCartridgesUpdateRequest methods */ +void start_cartridges_update_request__init + (StartCartridgesUpdateRequest *message); +size_t start_cartridges_update_request__get_packed_size + (const StartCartridgesUpdateRequest *message); +size_t start_cartridges_update_request__pack + (const StartCartridgesUpdateRequest *message, + uint8_t *out); +size_t start_cartridges_update_request__pack_to_buffer + (const StartCartridgesUpdateRequest *message, + ProtobufCBuffer *buffer); +StartCartridgesUpdateRequest * + start_cartridges_update_request__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void start_cartridges_update_request__free_unpacked + (StartCartridgesUpdateRequest *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*StartCartridgesUpdateRequest_Closure) + (const StartCartridgesUpdateRequest *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCMessageDescriptor start_cartridges_update_request__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_StartCartridgesUpdateRequest_2eproto__INCLUDED */ diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/StartCartridgesUpdateResponse.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/StartCartridgesUpdateResponse.pb-c.c new file mode 100644 index 000000000..683e28ee2 --- /dev/null +++ b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/StartCartridgesUpdateResponse.pb-c.c @@ -0,0 +1,105 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StartCartridgesUpdateResponse.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "StartCartridgesUpdateResponse.pb-c.h" +void start_cartridges_update_response__init + (StartCartridgesUpdateResponse *message) +{ + static const StartCartridgesUpdateResponse init_value = START_CARTRIDGES_UPDATE_RESPONSE__INIT; + *message = init_value; +} +size_t start_cartridges_update_response__get_packed_size + (const StartCartridgesUpdateResponse *message) +{ + assert(message->base.descriptor == &start_cartridges_update_response__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t start_cartridges_update_response__pack + (const StartCartridgesUpdateResponse *message, + uint8_t *out) +{ + assert(message->base.descriptor == &start_cartridges_update_response__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t start_cartridges_update_response__pack_to_buffer + (const StartCartridgesUpdateResponse *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &start_cartridges_update_response__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +StartCartridgesUpdateResponse * + start_cartridges_update_response__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (StartCartridgesUpdateResponse *) + protobuf_c_message_unpack (&start_cartridges_update_response__descriptor, + allocator, len, data); +} +void start_cartridges_update_response__free_unpacked + (StartCartridgesUpdateResponse *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &start_cartridges_update_response__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +static const ProtobufCFieldDescriptor start_cartridges_update_response__field_descriptors[2] = +{ + { + "Cartridge", + 1, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(StartCartridgesUpdateResponse, cartridge), + &cartridge__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "Action", + 2, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_ENUM, + offsetof(StartCartridgesUpdateResponse, has_action), + offsetof(StartCartridgesUpdateResponse, action), + &cartridge_action__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned start_cartridges_update_response__field_indices_by_name[] = { + 1, /* field[1] = Action */ + 0, /* field[0] = Cartridge */ +}; +static const ProtobufCIntRange start_cartridges_update_response__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor start_cartridges_update_response__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "StartCartridgesUpdateResponse", + "StartCartridgesUpdateResponse", + "StartCartridgesUpdateResponse", + "", + sizeof(StartCartridgesUpdateResponse), + 2, + start_cartridges_update_response__field_descriptors, + start_cartridges_update_response__field_indices_by_name, + 1, start_cartridges_update_response__number_ranges, + (ProtobufCMessageInit) start_cartridges_update_response__init, + NULL,NULL,NULL /* reserved[123] */ +}; diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/StartCartridgesUpdateResponse.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/StartCartridgesUpdateResponse.pb-c.h new file mode 100644 index 000000000..409c8ff3f --- /dev/null +++ b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/StartCartridgesUpdateResponse.pb-c.h @@ -0,0 +1,75 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StartCartridgesUpdateResponse.proto */ + +#ifndef PROTOBUF_C_StartCartridgesUpdateResponse_2eproto__INCLUDED +#define PROTOBUF_C_StartCartridgesUpdateResponse_2eproto__INCLUDED + +#include <protobuf-c/protobuf-c.h> + +PROTOBUF_C__BEGIN_DECLS + +#if PROTOBUF_C_VERSION_NUMBER < 1003000 +# error This file was generated by a newer version of protoc-c which is incompatible with your libprotobuf-c headers. Please update your headers. +#elif 1003000 < PROTOBUF_C_MIN_COMPILER_VERSION +# error This file was generated by an older version of protoc-c which is incompatible with your libprotobuf-c headers. Please regenerate this file with a newer version of protoc-c. +#endif + +#include "Cartridge.pb-c.h" +#include "CartridgeAction.pb-c.h" + +typedef struct _StartCartridgesUpdateResponse StartCartridgesUpdateResponse; + + +/* --- enums --- */ + + +/* --- messages --- */ + +struct _StartCartridgesUpdateResponse +{ + ProtobufCMessage base; + Cartridge *cartridge; + protobuf_c_boolean has_action; + CartridgeAction action; +}; +#define START_CARTRIDGES_UPDATE_RESPONSE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&start_cartridges_update_response__descriptor) \ + , NULL, 0, CARTRIDGE_ACTION__Inserted } + + +/* StartCartridgesUpdateResponse methods */ +void start_cartridges_update_response__init + (StartCartridgesUpdateResponse *message); +size_t start_cartridges_update_response__get_packed_size + (const StartCartridgesUpdateResponse *message); +size_t start_cartridges_update_response__pack + (const StartCartridgesUpdateResponse *message, + uint8_t *out); +size_t start_cartridges_update_response__pack_to_buffer + (const StartCartridgesUpdateResponse *message, + ProtobufCBuffer *buffer); +StartCartridgesUpdateResponse * + start_cartridges_update_response__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void start_cartridges_update_response__free_unpacked + (StartCartridgesUpdateResponse *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*StartCartridgesUpdateResponse_Closure) + (const StartCartridgesUpdateResponse *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCMessageDescriptor start_cartridges_update_response__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_StartCartridgesUpdateResponse_2eproto__INCLUDED */ diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/StopCartridgesUpdateRequest.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/StopCartridgesUpdateRequest.pb-c.c new file mode 100644 index 000000000..265f663a7 --- /dev/null +++ b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/StopCartridgesUpdateRequest.pb-c.c @@ -0,0 +1,72 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StopCartridgesUpdateRequest.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "StopCartridgesUpdateRequest.pb-c.h" +void stop_cartridges_update_request__init + (StopCartridgesUpdateRequest *message) +{ + static const StopCartridgesUpdateRequest init_value = STOP_CARTRIDGES_UPDATE_REQUEST__INIT; + *message = init_value; +} +size_t stop_cartridges_update_request__get_packed_size + (const StopCartridgesUpdateRequest *message) +{ + assert(message->base.descriptor == &stop_cartridges_update_request__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t stop_cartridges_update_request__pack + (const StopCartridgesUpdateRequest *message, + uint8_t *out) +{ + assert(message->base.descriptor == &stop_cartridges_update_request__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t stop_cartridges_update_request__pack_to_buffer + (const StopCartridgesUpdateRequest *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &stop_cartridges_update_request__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +StopCartridgesUpdateRequest * + stop_cartridges_update_request__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (StopCartridgesUpdateRequest *) + protobuf_c_message_unpack (&stop_cartridges_update_request__descriptor, + allocator, len, data); +} +void stop_cartridges_update_request__free_unpacked + (StopCartridgesUpdateRequest *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &stop_cartridges_update_request__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +#define stop_cartridges_update_request__field_descriptors NULL +#define stop_cartridges_update_request__field_indices_by_name NULL +#define stop_cartridges_update_request__number_ranges NULL +const ProtobufCMessageDescriptor stop_cartridges_update_request__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "StopCartridgesUpdateRequest", + "StopCartridgesUpdateRequest", + "StopCartridgesUpdateRequest", + "", + sizeof(StopCartridgesUpdateRequest), + 0, + stop_cartridges_update_request__field_descriptors, + stop_cartridges_update_request__field_indices_by_name, + 0, stop_cartridges_update_request__number_ranges, + (ProtobufCMessageInit) stop_cartridges_update_request__init, + NULL,NULL,NULL /* reserved[123] */ +}; diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/StopCartridgesUpdateRequest.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/StopCartridgesUpdateRequest.pb-c.h new file mode 100644 index 000000000..5a1b486c9 --- /dev/null +++ b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/StopCartridgesUpdateRequest.pb-c.h @@ -0,0 +1,70 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StopCartridgesUpdateRequest.proto */ + +#ifndef PROTOBUF_C_StopCartridgesUpdateRequest_2eproto__INCLUDED +#define PROTOBUF_C_StopCartridgesUpdateRequest_2eproto__INCLUDED + +#include <protobuf-c/protobuf-c.h> + +PROTOBUF_C__BEGIN_DECLS + +#if PROTOBUF_C_VERSION_NUMBER < 1003000 +# error This file was generated by a newer version of protoc-c which is incompatible with your libprotobuf-c headers. Please update your headers. +#elif 1003000 < PROTOBUF_C_MIN_COMPILER_VERSION +# error This file was generated by an older version of protoc-c which is incompatible with your libprotobuf-c headers. Please regenerate this file with a newer version of protoc-c. +#endif + + +typedef struct _StopCartridgesUpdateRequest StopCartridgesUpdateRequest; + + +/* --- enums --- */ + + +/* --- messages --- */ + +struct _StopCartridgesUpdateRequest +{ + ProtobufCMessage base; +}; +#define STOP_CARTRIDGES_UPDATE_REQUEST__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&stop_cartridges_update_request__descriptor) \ + } + + +/* StopCartridgesUpdateRequest methods */ +void stop_cartridges_update_request__init + (StopCartridgesUpdateRequest *message); +size_t stop_cartridges_update_request__get_packed_size + (const StopCartridgesUpdateRequest *message); +size_t stop_cartridges_update_request__pack + (const StopCartridgesUpdateRequest *message, + uint8_t *out); +size_t stop_cartridges_update_request__pack_to_buffer + (const StopCartridgesUpdateRequest *message, + ProtobufCBuffer *buffer); +StopCartridgesUpdateRequest * + stop_cartridges_update_request__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void stop_cartridges_update_request__free_unpacked + (StopCartridgesUpdateRequest *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*StopCartridgesUpdateRequest_Closure) + (const StopCartridgesUpdateRequest *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCMessageDescriptor stop_cartridges_update_request__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_StopCartridgesUpdateRequest_2eproto__INCLUDED */ diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/StopCartridgesUpdateResponse.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/StopCartridgesUpdateResponse.pb-c.c new file mode 100644 index 000000000..5c514a9ed --- /dev/null +++ b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/StopCartridgesUpdateResponse.pb-c.c @@ -0,0 +1,72 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StopCartridgesUpdateResponse.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "StopCartridgesUpdateResponse.pb-c.h" +void stop_cartridges_update_response__init + (StopCartridgesUpdateResponse *message) +{ + static const StopCartridgesUpdateResponse init_value = STOP_CARTRIDGES_UPDATE_RESPONSE__INIT; + *message = init_value; +} +size_t stop_cartridges_update_response__get_packed_size + (const StopCartridgesUpdateResponse *message) +{ + assert(message->base.descriptor == &stop_cartridges_update_response__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t stop_cartridges_update_response__pack + (const StopCartridgesUpdateResponse *message, + uint8_t *out) +{ + assert(message->base.descriptor == &stop_cartridges_update_response__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t stop_cartridges_update_response__pack_to_buffer + (const StopCartridgesUpdateResponse *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &stop_cartridges_update_response__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +StopCartridgesUpdateResponse * + stop_cartridges_update_response__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (StopCartridgesUpdateResponse *) + protobuf_c_message_unpack (&stop_cartridges_update_response__descriptor, + allocator, len, data); +} +void stop_cartridges_update_response__free_unpacked + (StopCartridgesUpdateResponse *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &stop_cartridges_update_response__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +#define stop_cartridges_update_response__field_descriptors NULL +#define stop_cartridges_update_response__field_indices_by_name NULL +#define stop_cartridges_update_response__number_ranges NULL +const ProtobufCMessageDescriptor stop_cartridges_update_response__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "StopCartridgesUpdateResponse", + "StopCartridgesUpdateResponse", + "StopCartridgesUpdateResponse", + "", + sizeof(StopCartridgesUpdateResponse), + 0, + stop_cartridges_update_response__field_descriptors, + stop_cartridges_update_response__field_indices_by_name, + 0, stop_cartridges_update_response__number_ranges, + (ProtobufCMessageInit) stop_cartridges_update_response__init, + NULL,NULL,NULL /* reserved[123] */ +}; diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/StopCartridgesUpdateResponse.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/StopCartridgesUpdateResponse.pb-c.h new file mode 100644 index 000000000..f173eaa69 --- /dev/null +++ b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/StopCartridgesUpdateResponse.pb-c.h @@ -0,0 +1,70 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: StopCartridgesUpdateResponse.proto */ + +#ifndef PROTOBUF_C_StopCartridgesUpdateResponse_2eproto__INCLUDED +#define PROTOBUF_C_StopCartridgesUpdateResponse_2eproto__INCLUDED + +#include <protobuf-c/protobuf-c.h> + +PROTOBUF_C__BEGIN_DECLS + +#if PROTOBUF_C_VERSION_NUMBER < 1003000 +# error This file was generated by a newer version of protoc-c which is incompatible with your libprotobuf-c headers. Please update your headers. +#elif 1003000 < PROTOBUF_C_MIN_COMPILER_VERSION +# error This file was generated by an older version of protoc-c which is incompatible with your libprotobuf-c headers. Please regenerate this file with a newer version of protoc-c. +#endif + + +typedef struct _StopCartridgesUpdateResponse StopCartridgesUpdateResponse; + + +/* --- enums --- */ + + +/* --- messages --- */ + +struct _StopCartridgesUpdateResponse +{ + ProtobufCMessage base; +}; +#define STOP_CARTRIDGES_UPDATE_RESPONSE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&stop_cartridges_update_response__descriptor) \ + } + + +/* StopCartridgesUpdateResponse methods */ +void stop_cartridges_update_response__init + (StopCartridgesUpdateResponse *message); +size_t stop_cartridges_update_response__get_packed_size + (const StopCartridgesUpdateResponse *message); +size_t stop_cartridges_update_response__pack + (const StopCartridgesUpdateResponse *message, + uint8_t *out); +size_t stop_cartridges_update_response__pack_to_buffer + (const StopCartridgesUpdateResponse *message, + ProtobufCBuffer *buffer); +StopCartridgesUpdateResponse * + stop_cartridges_update_response__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void stop_cartridges_update_response__free_unpacked + (StopCartridgesUpdateResponse *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*StopCartridgesUpdateResponse_Closure) + (const StopCartridgesUpdateResponse *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCMessageDescriptor stop_cartridges_update_response__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_StopCartridgesUpdateResponse_2eproto__INCLUDED */ diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Hardware/HardwareMotor.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/Hardware/HardwareMotor.pb-c.c index d6f9d3347..bfda97424 100644 --- a/Software/Embedded_SW/Embedded/Communication/PMR/Hardware/HardwareMotor.pb-c.c +++ b/Software/Embedded_SW/Embedded/Communication/PMR/Hardware/HardwareMotor.pb-c.c @@ -52,7 +52,7 @@ void hardware_motor__free_unpacked assert(message->base.descriptor == &hardware_motor__descriptor); protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); } -static const ProtobufCFieldDescriptor hardware_motor__field_descriptors[25] = +static const ProtobufCFieldDescriptor hardware_motor__field_descriptors[34] = { { "HardwareMotorType", @@ -354,6 +354,114 @@ static const ProtobufCFieldDescriptor hardware_motor__field_descriptors[25] = 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, + { + "GateCfg1", + 26, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(HardwareMotor, has_gatecfg1), + offsetof(HardwareMotor, gatecfg1), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "GateCfg2", + 27, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(HardwareMotor, has_gatecfg2), + offsetof(HardwareMotor, gatecfg2), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "TvalHold", + 28, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(HardwareMotor, has_tvalhold), + offsetof(HardwareMotor, tvalhold), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "TvalRun", + 29, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(HardwareMotor, has_tvalrun), + offsetof(HardwareMotor, tvalrun), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "TvalAcc", + 30, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(HardwareMotor, has_tvalacc), + offsetof(HardwareMotor, tvalacc), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "TvalDec", + 31, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(HardwareMotor, has_tvaldec), + offsetof(HardwareMotor, tvaldec), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "TFast", + 32, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(HardwareMotor, has_tfast), + offsetof(HardwareMotor, tfast), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "TOnMin", + 33, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(HardwareMotor, has_tonmin), + offsetof(HardwareMotor, tonmin), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "TOffMin", + 34, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(HardwareMotor, has_toffmin), + offsetof(HardwareMotor, toffmin), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, }; static const unsigned hardware_motor__field_indices_by_name[] = { 10, /* field[10] = ConfigWord */ @@ -361,6 +469,8 @@ static const unsigned hardware_motor__field_indices_by_name[] = { 22, /* field[22] = FnSlpAcc */ 23, /* field[23] = FnSlpDec */ 24, /* field[24] = FsSpd */ + 25, /* field[25] = GateCfg1 */ + 26, /* field[26] = GateCfg2 */ 0, /* field[0] = HardwareMotorType */ 6, /* field[6] = HighLengthMicroSecond */ 21, /* field[21] = IntSpd */ @@ -380,12 +490,19 @@ static const unsigned hardware_motor__field_indices_by_name[] = { 7, /* field[7] = SpeedMaster */ 20, /* field[20] = StSlp */ 17, /* field[17] = StallThreshold */ + 31, /* field[31] = TFast */ + 33, /* field[33] = TOffMin */ + 32, /* field[32] = TOnMin */ 18, /* field[18] = ThermalCompensationFactor */ + 29, /* field[29] = TvalAcc */ + 30, /* field[30] = TvalDec */ + 27, /* field[27] = TvalHold */ + 28, /* field[28] = TvalRun */ }; static const ProtobufCIntRange hardware_motor__number_ranges[1 + 1] = { { 1, 0 }, - { 0, 25 } + { 0, 34 } }; const ProtobufCMessageDescriptor hardware_motor__descriptor = { @@ -395,7 +512,7 @@ const ProtobufCMessageDescriptor hardware_motor__descriptor = "HardwareMotor", "", sizeof(HardwareMotor), - 25, + 34, hardware_motor__field_descriptors, hardware_motor__field_indices_by_name, 1, hardware_motor__number_ranges, diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Hardware/HardwareMotor.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/Hardware/HardwareMotor.pb-c.h index 04ef5ba5c..789e1e139 100644 --- a/Software/Embedded_SW/Embedded/Communication/PMR/Hardware/HardwareMotor.pb-c.h +++ b/Software/Embedded_SW/Embedded/Communication/PMR/Hardware/HardwareMotor.pb-c.h @@ -77,10 +77,28 @@ struct _HardwareMotor int32_t fnslpdec; protobuf_c_boolean has_fsspd; int32_t fsspd; + protobuf_c_boolean has_gatecfg1; + uint32_t gatecfg1; + protobuf_c_boolean has_gatecfg2; + uint32_t gatecfg2; + protobuf_c_boolean has_tvalhold; + uint32_t tvalhold; + protobuf_c_boolean has_tvalrun; + uint32_t tvalrun; + protobuf_c_boolean has_tvalacc; + uint32_t tvalacc; + protobuf_c_boolean has_tvaldec; + uint32_t tvaldec; + protobuf_c_boolean has_tfast; + uint32_t tfast; + protobuf_c_boolean has_tonmin; + uint32_t tonmin; + protobuf_c_boolean has_toffmin; + uint32_t toffmin; }; #define HARDWARE_MOTOR__INIT \ { PROTOBUF_C_MESSAGE_INIT (&hardware_motor__descriptor) \ - , 0, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD, 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, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD, 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, 0, 0, 0, 0 } /* HardwareMotor methods */ diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Hardware/HardwareMotorType.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/Hardware/HardwareMotorType.pb-c.c index be7dcf517..c6943acfa 100644 --- a/Software/Embedded_SW/Embedded/Communication/PMR/Hardware/HardwareMotorType.pb-c.c +++ b/Software/Embedded_SW/Embedded/Communication/PMR/Hardware/HardwareMotorType.pb-c.c @@ -7,7 +7,7 @@ #endif #include "HardwareMotorType.pb-c.h" -static const ProtobufCEnumValue hardware_motor_type__enum_values_by_number[29] = +static const ProtobufCEnumValue hardware_motor_type__enum_values_by_number[30] = { { "MOTO_DH_CLEANHEAD", "HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD", 0 }, { "MOTO_DH_CLEANMECH", "HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH", 1 }, @@ -38,11 +38,12 @@ static const ProtobufCEnumValue hardware_motor_type__enum_values_by_number[29] = { "MOTO_SPARE1_2", "HARDWARE_MOTOR_TYPE__MOTO_SPARE1_2", 26 }, { "MOTO_SPARE2_1", "HARDWARE_MOTOR_TYPE__MOTO_SPARE2_1", 27 }, { "MOTO_SPARE2_2", "HARDWARE_MOTOR_TYPE__MOTO_SPARE2_2", 28 }, + { "MOTO_SPARE3_1", "HARDWARE_MOTOR_TYPE__MOTO_SPARE3_1", 29 }, }; static const ProtobufCIntRange hardware_motor_type__value_ranges[] = { -{0, 0},{0, 29} +{0, 0},{0, 30} }; -static const ProtobufCEnumValueIndex hardware_motor_type__enum_values_by_name[29] = +static const ProtobufCEnumValueIndex hardware_motor_type__enum_values_by_name[30] = { { "MOTO_DH_CLEANHEAD", 0 }, { "MOTO_DH_CLEANMECH", 1 }, @@ -72,6 +73,7 @@ static const ProtobufCEnumValueIndex hardware_motor_type__enum_values_by_name[29 { "MOTO_SPARE1_2", 26 }, { "MOTO_SPARE2_1", 27 }, { "MOTO_SPARE2_2", 28 }, + { "MOTO_SPARE3_1", 29 }, { "MOTO_WINDER", 15 }, }; const ProtobufCEnumDescriptor hardware_motor_type__descriptor = @@ -81,9 +83,9 @@ const ProtobufCEnumDescriptor hardware_motor_type__descriptor = "HardwareMotorType", "HardwareMotorType", "", - 29, + 30, hardware_motor_type__enum_values_by_number, - 29, + 30, hardware_motor_type__enum_values_by_name, 1, hardware_motor_type__value_ranges, diff --git a/Software/Embedded_SW/Embedded/Drivers/Motors/Motor.h b/Software/Embedded_SW/Embedded/Drivers/Motors/Motor.h index c9a3a4f38..f0cfb109c 100644 --- a/Software/Embedded_SW/Embedded/Drivers/Motors/Motor.h +++ b/Software/Embedded_SW/Embedded/Drivers/Motors/Motor.h @@ -76,6 +76,16 @@ typedef struct int32_t fnslpacc; int32_t fnslpdec; int32_t fsspd; + uint32_t gatecfg1; + uint32_t gatecfg2; + uint32_t tvalhold; + uint32_t tvalrun; + uint32_t tvalacc; + uint32_t tvaldec; + uint32_t tfast; + uint32_t tonmin; + uint32_t toffmin; + }MotorDriverConfigStruc; //#define MotorDriverConfigStruc HardwareMotor diff --git a/Software/Embedded_SW/Embedded/Main.c b/Software/Embedded_SW/Embedded/Main.c index 6c561a303..5667d4f48 100644 --- a/Software/Embedded_SW/Embedded/Main.c +++ b/Software/Embedded_SW/Embedded/Main.c @@ -293,6 +293,7 @@ int main(void) LOG_ERROR (iFResult, "Error during init Flash File System"); assert(iFResult); } + //FlashInitAndLoad(); //Control_File_System();// test file system //IDS_ModuleInit(); diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c index c67f50705..84c232ffc 100644 --- a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c +++ b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c @@ -382,6 +382,8 @@ uint32_t AlarmHandlingLoadFile(void) { ReadAppAndProgram(AlarmItem, Bytes,buffer); free (buffer); + Report("AlarmHandlingLoadFile", __FILE__,__LINE__,Bytes, RpMessage, Fresult, 0); + } return Bytes; } diff --git a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c index 2871a31c8..627ef84cd 100644 --- a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c +++ b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c @@ -149,116 +149,113 @@ uint32_t HWConfigurationInit(void) } char EmbeddedParametersPath[50] = "0://SysInfo//EmbParam.cfg"; -ConfigurationParameters EmbeddedParameters; +ConfigurationParameters *EmbeddedParameters; bool DataUpdated = false; void LoadConfigurationParameters(ConfigurationParameters *Params) { if (Params == 0) { - configuration_parameters__init(&EmbeddedParameters); - EmbeddedParameters.has_breaksensorlimit = true; - EmbeddedParameters.breaksensorlimit = 10; - EmbeddedParameters.has_diagnosticcollectionlimit = true; - EmbeddedParameters.diagnosticcollectionlimit = 1; - EmbeddedParameters.has_overheatcountlimit = true; - EmbeddedParameters.overheatcountlimit = 3; - EmbeddedParameters.has_underheatcountlimit = true; - EmbeddedParameters.underheatcountlimit = 3; - EmbeddedParameters.has_closevalvetimeout = true; - EmbeddedParameters.closevalvetimeout = 250; - EmbeddedParameters.has_openvalvetimeout = true; - EmbeddedParameters.openvalvetimeout = 250; - EmbeddedParameters.has_initialdispenserpressure = true; - EmbeddedParameters.initialdispenserpressure = 1.08; - EmbeddedParameters.has_initialdispensertimeout = true; - EmbeddedParameters.initialdispensertimeout = 60000; - EmbeddedParameters.has_initialdispensertimelag = true; - EmbeddedParameters.initialdispensertimelag = 100; - EmbeddedParameters.has_dispenserbuildpressurespeed = true; - EmbeddedParameters.dispenserbuildpressurespeed=500; - EmbeddedParameters.has_dispenserbuildpressurelimit = true; - EmbeddedParameters.dispenserbuildpressurelimit=0.8 ; - EmbeddedParameters.has_dispenserbuildpressuretimeout = true; - EmbeddedParameters.dispenserbuildpressuretimeout=60000; - EmbeddedParameters.has_dispenserbuildpressurelag = true; - EmbeddedParameters.dispenserbuildpressurelag=50; - EmbeddedParameters.has_acheatersloweroperationlimit = true; - EmbeddedParameters.acheatersloweroperationlimit = 980; - EmbeddedParameters.has_acheatersupperoperationlimit = true; - EmbeddedParameters.acheatersupperoperationlimit = 1005; - EmbeddedParameters.has_dcheatersloweroperationlimit = true; - EmbeddedParameters.dcheatersloweroperationlimit = 978; - EmbeddedParameters.has_dcheatersupperoperationlimit = true; - EmbeddedParameters.dcheatersupperoperationlimit = 1002; - EmbeddedParameters.has_midtankpressurecorrection = true; - EmbeddedParameters.midtankpressurecorrection = 0.0; - EmbeddedParameters.has_dispenserpresegmentwfcf = true; - EmbeddedParameters.dispenserpresegmentwfcf = 80; - EmbeddedParameters.has_startheatingoninitsequence = true; - EmbeddedParameters.startheatingoninitsequence = true; //set to true shlomo 14/5/2019 -//size_t n_generalparameters; -// EmbeddedParameters.*generalparameters; - EmbeddedParameters.generalparameters = malloc (sizeof(double)*10); - if (EmbeddedParameters.generalparameters) + EmbeddedParameters = my_malloc(sizeof(ConfigurationParameters)); + configuration_parameters__init(EmbeddedParameters); + EmbeddedParameters->breaksensorlimit = 10; + EmbeddedParameters->has_diagnosticcollectionlimit = true; + EmbeddedParameters->diagnosticcollectionlimit = 1; + EmbeddedParameters->has_overheatcountlimit = true; + EmbeddedParameters->overheatcountlimit = 3; + EmbeddedParameters->has_underheatcountlimit = true; + EmbeddedParameters->underheatcountlimit = 3; + EmbeddedParameters->has_closevalvetimeout = true; + EmbeddedParameters->closevalvetimeout = 250; + EmbeddedParameters->has_openvalvetimeout = true; + EmbeddedParameters->openvalvetimeout = 250; + EmbeddedParameters->has_initialdispenserpressure = true; + EmbeddedParameters->initialdispenserpressure = 1.08; + EmbeddedParameters->has_initialdispensertimeout = true; + EmbeddedParameters->initialdispensertimeout = 60000; + EmbeddedParameters->has_initialdispensertimelag = true; + EmbeddedParameters->initialdispensertimelag = 100; + EmbeddedParameters->has_dispenserbuildpressurespeed = true; + EmbeddedParameters->dispenserbuildpressurespeed=500; + EmbeddedParameters->has_dispenserbuildpressurelimit = true; + EmbeddedParameters->dispenserbuildpressurelimit=0.8 ; + EmbeddedParameters->has_dispenserbuildpressuretimeout = true; + EmbeddedParameters->dispenserbuildpressuretimeout=60000; + EmbeddedParameters->has_dispenserbuildpressurelag = true; + EmbeddedParameters->dispenserbuildpressurelag=50; + EmbeddedParameters->has_acheatersloweroperationlimit = true; + EmbeddedParameters->acheatersloweroperationlimit = 980; + EmbeddedParameters->has_acheatersupperoperationlimit = true; + EmbeddedParameters->acheatersupperoperationlimit = 1005; + EmbeddedParameters->has_dcheatersloweroperationlimit = true; + EmbeddedParameters->dcheatersloweroperationlimit = 978; + EmbeddedParameters->has_dcheatersupperoperationlimit = true; + EmbeddedParameters->dcheatersupperoperationlimit = 1002; + EmbeddedParameters->has_midtankpressurecorrection = true; + EmbeddedParameters->midtankpressurecorrection = 0.0; + EmbeddedParameters->has_dispenserpresegmentwfcf = true; + EmbeddedParameters->dispenserpresegmentwfcf = 80; + EmbeddedParameters->has_startheatingoninitsequence = true; + EmbeddedParameters->startheatingoninitsequence = true; //set to true shlomo 14/5/2019 + EmbeddedParameters->generalparameters = malloc (sizeof(double)*10); + if (EmbeddedParameters->generalparameters) { - EmbeddedParameters.generalparameters[0] = 1.0; //CheckHardLimitAlarms - EmbeddedParameters.generalparameters[1] = 0.0; //CheckCurrentAlarms - EmbeddedParameters.generalparameters[2] = 0.0; //CheckTamperAlarms - EmbeddedParameters.generalparameters[3] = 800.0; //Winder homing time at end of job - //EmbeddedParameters.generalparameters[4] = 1.0; //Dispenser initial pressure limit - //EmbeddedParameters.generalparameters[5] = 1.0; //Dispenser initial pressure speed + EmbeddedParameters->generalparameters[0] = 1.0; //CheckHardLimitAlarms + EmbeddedParameters->generalparameters[1] = 0.0; //CheckCurrentAlarms + EmbeddedParameters->generalparameters[2] = 0.0; //CheckTamperAlarms + EmbeddedParameters->generalparameters[3] = 800.0; //Winder homing time at end of job + //EmbeddedParameters->generalparameters[4] = 1.0; //Dispenser initial pressure limit + //EmbeddedParameters->generalparameters[5] = 1.0; //Dispenser initial pressure speed } - EmbeddedParameters.has_currentalarmlowlimit = true; - EmbeddedParameters.currentalarmlowlimit = 0.80; - EmbeddedParameters.has_currentalarmhighlimit = true; - EmbeddedParameters.currentalarmhighlimit= 1.07; - EmbeddedParameters.has_ids_segmentrefilltimeout = true; - EmbeddedParameters.ids_segmentrefilltimeout = 5000; - EmbeddedParameters.has_ids_presegmentbuilduptime = true; - EmbeddedParameters.ids_presegmentbuilduptime = 5000; - EmbeddedParameters.has_ids_cleaningspeed = true; - EmbeddedParameters.ids_cleaningspeed = 50; - EmbeddedParameters.has_ids_cleaningstopbeforesegmenttime = true; - EmbeddedParameters.ids_cleaningstopbeforesegmenttime = 3000; - EmbeddedParameters.has_ids_cleaningstartspraypresegmenttime = true; - EmbeddedParameters.ids_cleaningstartspraypresegmenttime = 1000; - EmbeddedParameters.has_ids_leftcleaningmotorspeed = true; - EmbeddedParameters.ids_leftcleaningmotorspeed = 30; - EmbeddedParameters.has_ids_rightcleaningmotorspeed = true; - EmbeddedParameters.ids_rightcleaningmotorspeed = 23; - EmbeddedParameters.has_switchtoidletimeinseconds = true; - EmbeddedParameters.switchtoidletimeinseconds = 3600; - EmbeddedParameters.has_idledriertemperature = true; - EmbeddedParameters.idledriertemperature = 80; - EmbeddedParameters.has_idleheadtemperature = true; - EmbeddedParameters.idleheadtemperature = 80; - EmbeddedParameters.has_idlemixertemperature = true; - EmbeddedParameters.idlemixertemperature = 0; - EmbeddedParameters.has_powerofftemperaturelimit = true; - EmbeddedParameters.powerofftemperaturelimit = 50; - EmbeddedParameters.has_ids_presegment_wfcf_timebeforesegment = true; - EmbeddedParameters.ids_presegment_wfcf_timebeforesegment = 1500; - uint8_t* response_buffer = my_malloc(configuration_parameters__get_packed_size(&EmbeddedParameters)); + EmbeddedParameters->has_currentalarmlowlimit = true; + EmbeddedParameters->currentalarmlowlimit = 0.80; + EmbeddedParameters->has_currentalarmhighlimit = true; + EmbeddedParameters->currentalarmhighlimit= 1.07; + EmbeddedParameters->has_ids_segmentrefilltimeout = true; + EmbeddedParameters->ids_segmentrefilltimeout = 5000; + EmbeddedParameters->has_ids_presegmentbuilduptime = true; + EmbeddedParameters->ids_presegmentbuilduptime = 5000; + EmbeddedParameters->has_ids_cleaningspeed = true; + EmbeddedParameters->ids_cleaningspeed = 50; + EmbeddedParameters->has_ids_cleaningstopbeforesegmenttime = true; + EmbeddedParameters->ids_cleaningstopbeforesegmenttime = 3000; + EmbeddedParameters->has_ids_cleaningstartspraypresegmenttime = true; + EmbeddedParameters->ids_cleaningstartspraypresegmenttime = 1000; + EmbeddedParameters->has_ids_leftcleaningmotorspeed = true; + EmbeddedParameters->ids_leftcleaningmotorspeed = 30; + EmbeddedParameters->has_ids_rightcleaningmotorspeed = true; + EmbeddedParameters->ids_rightcleaningmotorspeed = 23; + EmbeddedParameters->has_switchtoidletimeinseconds = true; + EmbeddedParameters->switchtoidletimeinseconds = 3600; + EmbeddedParameters->has_idledriertemperature = true; + EmbeddedParameters->idledriertemperature = 80; + EmbeddedParameters->has_idleheadtemperature = true; + EmbeddedParameters->idleheadtemperature = 80; + EmbeddedParameters->has_idlemixertemperature = true; + EmbeddedParameters->idlemixertemperature = 0; + EmbeddedParameters->has_powerofftemperaturelimit = true; + EmbeddedParameters->powerofftemperaturelimit = 50; + EmbeddedParameters->has_ids_presegment_wfcf_timebeforesegment = true; + EmbeddedParameters->ids_presegment_wfcf_timebeforesegment = 1500; + uint8_t* response_buffer = my_malloc(configuration_parameters__get_packed_size(EmbeddedParameters)); size_t response_size = 0; if (response_buffer) { - response_size = configuration_parameters__pack(&EmbeddedParameters, response_buffer); + response_size = configuration_parameters__pack(EmbeddedParameters, response_buffer); + //FileWrite(response_buffer,response_size,EmbeddedParametersPath); + ReadAppAndProgram(EMBEDDED_PARAMETERS_MAP_IN_FLASH, 4,&response_size); + ReadAppAndProgram(EMBEDDED_PARAMETERS_MAP_IN_FLASH+4, response_size, response_buffer); + my_free(response_buffer); } - FileWrite(response_buffer,response_size,EmbeddedParametersPath); - my_free(response_buffer); } else { - memcpy (&EmbeddedParameters,Params,sizeof(EmbeddedParameters)); + EmbeddedParameters = Params; } - uint32_t Bytes = sizeof(EmbeddedParameters); - ReadAppAndProgram(EMBEDDED_PARAMETERS_MAP_IN_FLASH, 4,&Bytes); - ReadAppAndProgram(EMBEDDED_PARAMETERS_MAP_IN_FLASH+4, Bytes, &EmbeddedParameters); } uint32_t EmbeddedParametersInit(void) { FRESULT Fresult = FR_OK; - //void* buffer = NULL; + void* buffer = NULL; uint32_t Bytes = 0; ConfigurationParameters *Params; @@ -267,35 +264,44 @@ uint32_t EmbeddedParametersInit(void) if ((Bytes)&&(Bytes < 1000)) { - Params = (ConfigurationParameters *)(EMBEDDED_PARAMETERS_MAP_IN_FLASH+4); - memcpy (&EmbeddedParameters,Params,sizeof(EmbeddedParameters)); + Params = configuration_parameters__unpack(NULL, Bytes, (void *)(EMBEDDED_PARAMETERS_MAP_IN_FLASH+4)); + LoadConfigurationParameters(Params); + Report("LoadConfigurationParameters from flash", __FILE__,__LINE__,Bytes, RpMessage, Fresult, 0); } else { - LoadConfigurationParameters(0); + if (LoadConfigurationParamsFromFile()!=OK) + { + LoadConfigurationParameters(0); + Report("LoadConfigurationParameters default", __FILE__,__LINE__,0, RpMessage, Fresult, 0); + } + else + { + Report("LoadConfigurationParameters from file", __FILE__,__LINE__,EmbeddedParameters->closevalvetimeout, RpMessage, Fresult, 0); + } } - IDS_Dispenser_SetTimeOutValues(EmbeddedParameters.closevalvetimeout, EmbeddedParameters.openvalvetimeout); - IDS_Dispenser_SetBackLashValues(EmbeddedParameters.initialdispenserpressure, EmbeddedParameters.initialdispensertimeout, EmbeddedParameters.initialdispensertimelag); - IDS_Dispenser_SetPrepareValues(EmbeddedParameters.dispenserbuildpressurespeed, EmbeddedParameters.dispenserbuildpressurelimit, EmbeddedParameters.dispenserbuildpressuretimeout, EmbeddedParameters.dispenserbuildpressurelag); - IDS_Dispenser_SetPreSegmentWFCFValues(EmbeddedParameters.dispenserpresegmentwfcf, EmbeddedParameters.ids_presegment_wfcf_timebeforesegment); - IDS_Dispenser_SetPreSegmentCleaningValues(EmbeddedParameters.ids_cleaningspeed,EmbeddedParameters.ids_cleaningstartspraypresegmenttime ,EmbeddedParameters.ids_cleaningstopbeforesegmenttime,EmbeddedParameters.ids_leftcleaningmotorspeed,EmbeddedParameters.ids_rightcleaningmotorspeed); + IDS_Dispenser_SetTimeOutValues(EmbeddedParameters->closevalvetimeout, EmbeddedParameters->openvalvetimeout); + IDS_Dispenser_SetBackLashValues(EmbeddedParameters->initialdispenserpressure, EmbeddedParameters->initialdispensertimeout, EmbeddedParameters->initialdispensertimelag); + IDS_Dispenser_SetPrepareValues(EmbeddedParameters->dispenserbuildpressurespeed, EmbeddedParameters->dispenserbuildpressurelimit, EmbeddedParameters->dispenserbuildpressuretimeout, EmbeddedParameters->dispenserbuildpressurelag); + IDS_Dispenser_SetPreSegmentWFCFValues(EmbeddedParameters->dispenserpresegmentwfcf, EmbeddedParameters->ids_presegment_wfcf_timebeforesegment); + IDS_Dispenser_SetPreSegmentCleaningValues(EmbeddedParameters->ids_cleaningspeed,EmbeddedParameters->ids_cleaningstartspraypresegmenttime ,EmbeddedParameters->ids_cleaningstopbeforesegmenttime,EmbeddedParameters->ids_leftcleaningmotorspeed,EmbeddedParameters->ids_rightcleaningmotorspeed); - Heaters_SetOverHeatTimeOutValues( EmbeddedParameters.overheatcountlimit, EmbeddedParameters.underheatcountlimit); - Heaters_SetOperationLimits(EmbeddedParameters.acheatersloweroperationlimit,EmbeddedParameters.acheatersupperoperationlimit,EmbeddedParameters.dcheatersloweroperationlimit,EmbeddedParameters.dcheatersupperoperationlimit); - MidTankPressureCorrection(EmbeddedParameters.midtankpressurecorrection); - SetDiagnosticCollectionLimit(EmbeddedParameters.diagnosticcollectionlimit); - ThreadSetBreakSensorLimit(EmbeddedParameters.breaksensorlimit); - PowerOffSetTemperatureThreshold(EmbeddedParameters.powerofftemperaturelimit); + Heaters_SetOverHeatTimeOutValues( EmbeddedParameters->overheatcountlimit, EmbeddedParameters->underheatcountlimit); + Heaters_SetOperationLimits(EmbeddedParameters->acheatersloweroperationlimit,EmbeddedParameters->acheatersupperoperationlimit,EmbeddedParameters->dcheatersloweroperationlimit,EmbeddedParameters->dcheatersupperoperationlimit); + MidTankPressureCorrection(EmbeddedParameters->midtankpressurecorrection); + SetDiagnosticCollectionLimit(EmbeddedParameters->diagnosticcollectionlimit); + ThreadSetBreakSensorLimit(EmbeddedParameters->breaksensorlimit); + PowerOffSetTemperatureThreshold(EmbeddedParameters->powerofftemperaturelimit); - InitSequenceSetStartHeating (EmbeddedParameters.startheatingoninitsequence); + InitSequenceSetStartHeating (EmbeddedParameters->startheatingoninitsequence); bool a1,a2,a3; - a1 = (EmbeddedParameters.generalparameters[0] < 0.5)?false:true; - a2 = (EmbeddedParameters.generalparameters[1] < 0.5)?false:true; - a3 = (EmbeddedParameters.generalparameters[2] < 0.5)?false:true; + a1 = (EmbeddedParameters->generalparameters[0] < 0.5)?false:true; + a2 = (EmbeddedParameters->generalparameters[1] < 0.5)?false:true; + a3 = (EmbeddedParameters->generalparameters[2] < 0.5)?false:true; AlarmHandlingSetFlags(a1,a2,a3); - PowerIdleSetParameters(EmbeddedParameters.switchtoidletimeinseconds,EmbeddedParameters.idledriertemperature,EmbeddedParameters.idleheadtemperature,EmbeddedParameters.idlemixertemperature); + PowerIdleSetParameters(EmbeddedParameters->switchtoidletimeinseconds,EmbeddedParameters->idledriertemperature,EmbeddedParameters->idleheadtemperature,EmbeddedParameters->idlemixertemperature); return Fresult; } @@ -347,10 +353,8 @@ uint32_t HWConfiguration(UploadHardwareConfigurationRequest* UploadRequest) if (request->n_motors < NUM_OF_MOTORS) { - //EraseFlashSection(GENHWCFG_MAP_IN_FLASH + 0x2000,sizeof(HardwareMotor)*request->n_motors); - - for (Motor_i = 0; Motor_i < request->n_motors ; Motor_i++) - status += MotorsConfigMessage(request->motors[Motor_i]); + //for (Motor_i = 0; Motor_i < request->n_motors ; Motor_i++) + status += MotorsConfigMessage(request); } else { @@ -521,6 +525,28 @@ void HWSystemResetRequest(MessageContainer* requestContainer) } uint32_t FlashInitResults[5] = {0,0,0,0,0}; +uint32_t LoadConfigurationParamsFromFile(void) +{ + FRESULT Fresult = FR_OK; + uint8_t* buffer = NULL; + uint32_t Bytes = 0; + + ConfigurationParameters *Params = NULL; + + Fresult = FileRead(EmbeddedParametersPath, &Bytes, &buffer); + if (Fresult == FR_OK) + { + Params = configuration_parameters__unpack(NULL, Bytes, buffer); + LoadConfigurationParameters(Params); + free (buffer); + //configuration_parameters__free_unpacked(Params,NULL); + FlashInitResults[1] = true; + Report("Parameters Initialized from file", __FILE__,__LINE__,Bytes, RpMessage, EMBEDDED_PARAMETERS_MAP_IN_FLASH, 0); + ReadAppAndProgram(EMBEDDED_PARAMETERS_MAP_IN_FLASH, 4,&Bytes); + ReadAppAndProgram(EMBEDDED_PARAMETERS_MAP_IN_FLASH+4, Bytes, buffer); + } + return Fresult; +} void FlashInitAndLoad(void) { FRESULT Fresult = FR_OK; @@ -534,7 +560,7 @@ void FlashInitAndLoad(void) char ProcessParamsPath[50] = "0://SysInfo//ProcessP.cfg"; #ifdef WATCHDOG ROM_WatchdogResetDisable(WATCHDOG0_BASE); - uint32_t timeout = 120000000*35; + uint32_t timeout = 0xFFFFFFFFU; ROM_WatchdogReloadSet(WATCHDOG0_BASE, timeout); #endif @@ -569,8 +595,11 @@ void FlashInitAndLoad(void) { Params = configuration_parameters__unpack(NULL, Bytes, buffer); LoadConfigurationParameters(Params); + //Bytes = sizeof(EmbeddedParameters); + ReadAppAndProgram(EMBEDDED_PARAMETERS_MAP_IN_FLASH, 4,&Bytes); + ReadAppAndProgram(EMBEDDED_PARAMETERS_MAP_IN_FLASH+4, Bytes, buffer); free (buffer); - configuration_parameters__free_unpacked(Params,NULL); + //configuration_parameters__free_unpacked(Params,NULL); FlashInitResults[1] = true; Report("Parameters Initialized from file", __FILE__,__LINE__,sizeof(EmbeddedParameters), RpMessage, EMBEDDED_PARAMETERS_MAP_IN_FLASH, 0); } @@ -580,9 +609,6 @@ void FlashInitAndLoad(void) FlashInitResults[1] = 2; Report("Parameters Initialized from default", __FILE__,__LINE__,sizeof(EmbeddedParameters), RpMessage, EMBEDDED_PARAMETERS_MAP_IN_FLASH, 0); } - Bytes = sizeof(EmbeddedParameters); - ReadAppAndProgram(EMBEDDED_PARAMETERS_MAP_IN_FLASH, 4,&Bytes); - ReadAppAndProgram(EMBEDDED_PARAMETERS_MAP_IN_FLASH+4, Bytes, &EmbeddedParameters); Fresult = FileRead(ProcessParamsPath, &Bytes, &buffer); if (Fresult == FR_OK) diff --git a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.h b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.h index 86f164977..338217e74 100644 --- a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.h +++ b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.h @@ -7,13 +7,13 @@ #include "PMR/common/MessageContainer.pb-c.h" #include "PMR/Hardware/HardwareBlower.pb-c.h" #include "PMR/EmbeddedParameters/ConfigurationParameters.pb-c.h" -extern ConfigurationParameters EmbeddedParameters; +extern ConfigurationParameters *EmbeddedParameters; extern uint32_t HWConfigurationFunc(MessageContainer* requestContainer); extern void HWSystemResetRequest(MessageContainer* requestContainer); uint32_t HWConfigurationInit(void); void FlashInitAndLoad(void); - +uint32_t LoadConfigurationParamsFromFile(void); extern HardwareBlower BlowerCfg; extern bool DataUpdated; diff --git a/Software/Embedded_SW/Embedded/Modules/General/process.c b/Software/Embedded_SW/Embedded/Modules/General/process.c index aafc1c5a9..6ee11105f 100644 --- a/Software/Embedded_SW/Embedded/Modules/General/process.c +++ b/Software/Embedded_SW/Embedded/Modules/General/process.c @@ -195,7 +195,7 @@ void ProcessRequestFunc(MessageContainer* requestContainer) Bytes = sizeof(ProcessParameters); ReadAppAndProgram(PROCESS_PARAMETERS_MAP_IN_FLASH, 4,&Bytes); ReadAppAndProgram(PROCESS_PARAMETERS_MAP_IN_FLASH+4, Bytes, ProcessParams); - REPORT_MSG(Bytes,"Bytes wrtie to flash"); + REPORT_MSG(Bytes,"Bytes write to flash"); } //////////////////////////////////////////////////////////////////////// @@ -237,51 +237,34 @@ void ProcessRequestFunc(MessageContainer* requestContainer) upload_process_parameters_request__free_unpacked(request,NULL); } -uint32_t ProcessParamsInit(void) +uint32_t LoadProcessParamsFromFile(void) { FRESULT Fresult = FR_OK; - //FIL *FileHandle = 0; //the system supports a single active file - //uint8_t* buffer = NULL; - uint32_t Bytes;// = 0,i,j,k=0; - //UploadProcessParametersRequest* request; -/* - FileHandle = my_malloc(sizeof(FIL)); - if (FileHandle) + uint8_t* buffer = NULL; + uint32_t Bytes = 0; + + Fresult = FileRead(ProcessParamsConfigPath, &Bytes, &buffer); + if (Fresult == FR_OK) { - Fresult = FileOpen(ProcessParamsConfigPath, &Bytes, FileHandle); - if (Fresult == FR_OK) - { - buffer = my_malloc (Bytes); - if (buffer) - { - for (i=0;i<=(Bytes/100);i++) - { - Fresult = f_read(FileHandle,&buffer[i*100],100,&j ); - k+=j; - } - if (k!=Bytes) - LOG_ERROR(k,"File read error"); + UploadProcessParametersRequest* request = upload_process_parameters_request__unpack(NULL, Bytes, buffer); + ProcessParameters* ProcessParams = request->processparameters; - request = upload_process_parameters_request__unpack(NULL, Bytes, buffer); - // ProcessParameters* ProcessParams = process_parameters__unpack(NULL, Bytes, buffer); - if (request) - { - ProcessParameters* ProcessParams = request->processparameters; - Fresult = HandleProcessParameters(ProcessParams); - //memcpy (&ProcessParametersKeep,ProcessParams,sizeof(ProcessParameters)); - upload_process_parameters_request__free_unpacked(request,NULL); - } - my_free (buffer); - } - f_close(FileHandle); - } - else + if ((ProcessParams->dryerzone1temp > 0.1)&&(ProcessParams->headzone2temp > 0.1)&&(ProcessParams->headzone3temp > 0.1)&&(ProcessParams->headzone4temp > 0.1))//NOT turning off heaters { - LOG_ERROR(Fresult,"File open error"); + Bytes = sizeof(ProcessParameters); + ReadAppAndProgram(PROCESS_PARAMETERS_MAP_IN_FLASH, 4,&Bytes); + ReadAppAndProgram(PROCESS_PARAMETERS_MAP_IN_FLASH+4, Bytes, ProcessParams); + REPORT_MSG(Bytes,"ProcessParameters Bytes write to flash"); + free (buffer); } - my_free (FileHandle); } -*/ + + return Fresult; +} +uint32_t ProcessParamsInit(void) +{ + FRESULT Fresult = FR_OK; + uint32_t Bytes; memcpy(&Bytes,(void *)PROCESS_PARAMETERS_MAP_IN_FLASH,sizeof(Bytes)); REPORT_MSG(Bytes,"Bytes read from flash"); @@ -291,6 +274,20 @@ uint32_t ProcessParamsInit(void) ProcessParameters* ProcessParams = (ProcessParameters *)(PROCESS_PARAMETERS_MAP_IN_FLASH+4); Fresult = HandleProcessParameters(ProcessParams); } + else + { + if (LoadProcessParamsFromFile()==OK) + { + memcpy(&Bytes,(void *)PROCESS_PARAMETERS_MAP_IN_FLASH,sizeof(Bytes)); + REPORT_MSG(Bytes,"ProcessParams Bytes read from flash"); + + if ((Bytes)&&(Bytes < 1000)) + { + ProcessParameters* ProcessParams = (ProcessParameters *)(PROCESS_PARAMETERS_MAP_IN_FLASH+4); + Fresult = HandleProcessParameters(ProcessParams); + } + } + } return Fresult; } diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c index c8836a2b4..d5b4867f0 100644 --- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c +++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c @@ -1047,7 +1047,7 @@ uint32_t IDSPreSegmentState(void *SegmentDetails, int SegmentId) { MotorSetMicroStep(HW_Motor_Id, MotorsCfg[HW_Motor_Id].microstep); } - if ((EnableIntersegment == true)&&(IntersegmentLength>0)) + if ((EnableIntersegment == true)&&(IntersegmentLength>0.1)&&(SegmentId>0)) { MotorStop(HW_Motor_Id,Soft_Hiz); //26/03/19 test without valves CurrentDispenserSpeed[DispenserId] = 0; diff --git a/Software/Embedded_SW/Embedded/Modules/IFS/RfidTagContent.h b/Software/Embedded_SW/Embedded/Modules/IFS/RfidTagContent.h new file mode 100644 index 000000000..0764f2862 --- /dev/null +++ b/Software/Embedded_SW/Embedded/Modules/IFS/RfidTagContent.h @@ -0,0 +1,51 @@ +/* + * RfidTagContent.h + * + * Created on: Jul 8, 2019 + * Author: shlomo + */ + +#ifndef MODULES_IFS_RFIDTAGCONTENT_H_ +#define MODULES_IFS_RFIDTAGCONTENT_H_ + +#include "PMR/Rfid/RfidCartridgeSlot.pb-c.h" +#include "PMR/Rfid/RfidTagContent.pb-c.h" + +#include <DataDef.h> +#include "include.h" + + +#define MAX_CARTRIDGES (RFID_CARTRIDGE_SLOT__LowerWasteCartridge+1) +typedef struct RfidTagContent +{ + uint32_t UniqueId; + char SerialNumber[16]; + char FactoryId[3]; + int32_t FillingSystemId; + char ColorName[12]; + int32_t ColorCategory; + int32_t ColorTypeRevision; + int32_t CartridgeSize; + int32_t FilledInkVolume; + char InkBatchNum[10]; + char InkMFGDate[6]; + char InkEOLDate[6]; + char CartridgeFillingDate[6]; + char WasteFilledDate[6]; + int32_t PlugInCounter; + bool Inkfill; + bool InkUsed; + bool InkEmpty; + bool WasteEmpty; + bool WasteFilling; + bool WasteFull; + bool Blocked; + bool Fail; + int32_t WasteCounter; + char MachineIdInkUsed[16]; + char MachineIdWasteUsed[16]; +}; + + + +#endif /* MODULES_IFS_RFIDTAGCONTENT_H_ */ diff --git a/Software/Embedded_SW/Embedded/Modules/IFS/ifs.c b/Software/Embedded_SW/Embedded/Modules/IFS/ifs.c new file mode 100644 index 000000000..347808d5e --- /dev/null +++ b/Software/Embedded_SW/Embedded/Modules/IFS/ifs.c @@ -0,0 +1,31 @@ +/* + * ifs.c + * + * Created on: Jul 8, 2019 + * Author: shlomo + */ +#include "PMR/Diagnostics/CartridgeSlot.pb-c.h" +#include "PMR/Diagnostics/CartridgeTagContent.pb-c.h" +#include "RfidTagContent.h" +#include <Drivers/I2C_Communication/RFID_NFC/RFIDTagInfo.h> + +#include <DataDef.h> +#include "include.h" + +RfidTagContent TagContent[MAX_CARTRIDGES]; +NFC_Tag NFCTag[MAX_CARTRIDGES]; +void TagInitialize(RfidTagContent* TagContent); + +void IFS_Init(void) +{ + int i; + for (i=0;i<MAX_CARTRIDGES;i++) + { + TagInitialize(&TagContent[i]); + memset(NFCTag[i].Buf,0,sizeof(NFCTag[i])); + } +} +void TagInitialize(RfidTagContent* TagContent) +{ + +} diff --git a/Software/Embedded_SW/Embedded/Modules/IFS/ifs.h b/Software/Embedded_SW/Embedded/Modules/IFS/ifs.h new file mode 100644 index 000000000..ade89372d --- /dev/null +++ b/Software/Embedded_SW/Embedded/Modules/IFS/ifs.h @@ -0,0 +1,16 @@ +/* + * ifs.h + * + * Created on: Jul 8, 2019 + * Author: shlomo + */ + +#ifndef MODULES_IFS_IFS_H_ +#define MODULES_IFS_IFS_H_ + + + +void IFS_Init(void) + + +#endif /* MODULES_IFS_IFS_H_ */ diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread.h b/Software/Embedded_SW/Embedded/Modules/Thread/Thread.h index 230d06601..e927ae436 100644 --- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread.h +++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread.h @@ -9,6 +9,7 @@ #include "PMR/Hardware/HardwareDancerType.pb-c.h" #include "PMR/Hardware/HardwareWinder.pb-c.h" #include "PMR/Hardware/HardwarePidControl.pb-c.h" +#include "PMR/Hardware/HardwareConfiguration.pb-c.h" #include "PMR/Printing/JobSpool.pb-c.h" #include "PMR/Printing/JobSpoolType.pb-c.h" @@ -73,7 +74,7 @@ extern int MotorSpeedSamplePointer[MAX_THREAD_MOTORS_NUM]; uint32_t InternalWinderConfigMessage(HardwareWinder* request); -uint32_t MotorsConfigMessage(HardwareMotor * request); +uint32_t MotorsConfigMessage( HardwareConfiguration* HW_request); uint32_t InternalWindingConfigMessage(JobSpool* request); uint32_t ThreadInitialTestStub(HardwareMotor * request); uint32_t MotorPidRequestMessage(HardwarePidControl* request); diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c index 66d6baed5..9ef7f3d0d 100644 --- a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c +++ b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c @@ -62,6 +62,7 @@ uint32_t ControlId = 0xFF; uint32_t ThreadLoadStateMachine( THREAD_LOAD_STAGES_ENUM LoadStages); uint32_t ThreadLoadControlCBFunction(uint32_t index, uint32_t ReadValue); + uint32_t Thread_Load_Dryer_UnLoading(void); typedef struct { @@ -465,6 +466,74 @@ REPORT_MSG(LoadStages,"Loading Ended"); return OK; } + uint32_t Thread_Load_Dryer_UnLoading(void) + { + REPORT_MSG(LoadStages, "Thread UnLoad State Machine step"); + LoadArmInfo.LoadArmRounds = 0; + uint32_t numberOfSteps = 0; + //Start Feeder Pid, Rotate Loading Arm Counter Thread Direction X Circles According To Rml. Feeder Speed Is 40 + SetOriginMotorSpeed(20); +// OriginalMotorSpd_2PPS[FEEDER_MOTOR] = 1000; +// CurrentControlledSpeed[FEEDER_MOTOR] = 1000; + + numberOfSteps = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround*LoadArmInfo.LoadArmRounds*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].microstep*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulleyradius; + MotorControlConfig[POOLER_MOTOR].m_params.MAX = 1; + MotorControlConfig[POOLER_MOTOR].m_params.MIN = MotorsControl[POOLER_MOTOR].outputproportionalpowerlimit*-1; + MotorControlConfig[POOLER_MOTOR].m_params.Kd = MotorsControl[POOLER_MOTOR].derivativetime; + MotorControlConfig[POOLER_MOTOR].m_params.Kp = MotorsControl[POOLER_MOTOR].proportionalgain; + MotorControlConfig[POOLER_MOTOR].m_params.Ki = MotorsControl[POOLER_MOTOR].integraltime; + MotorControlConfig[POOLER_MOTOR].m_params.IntegralErrorMultiplier = MotorsControl[POOLER_MOTOR].setpointramprateorsoftstartramp; + MotorControlConfig[POOLER_MOTOR].m_params.ProportionalErrorMultiplier = MotorsControl[POOLER_MOTOR].outputonoffhysteresisvalue; + MotorControlConfig[POOLER_MOTOR].m_params.epsilon = MotorsControl[POOLER_MOTOR].epsilon; + MotorControlConfig[POOLER_MOTOR].m_params.dt = MotorsControl[POOLER_MOTOR].controloutputtype; + MotorControlConfig[POOLER_MOTOR].m_ingnoreValue = MotorsControl[POOLER_MOTOR].sensorcorrectionadjustment; // the minimal change required to change the motor speed in pulses + MotorControlConfig[POOLER_MOTOR].m_calculatedError = 0; + MotorControlConfig[POOLER_MOTOR].m_integral = 0; + MotorControlConfig[POOLER_MOTOR].m_isEnabled = true; + MotorControlConfig[POOLER_MOTOR].m_isReady = true; + MotorControlConfig[POOLER_MOTOR].m_mesuredParam = 0; + MotorControlConfig[POOLER_MOTOR].m_preError = 0; + MotorControlConfig[POOLER_MOTOR].m_SetParam = 0;//need to update SetParams on presegment stage + MotorSetDirection(HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LDRIVING].directionthreadwize); + + ControlId = AddControlCallback(ThreadLoadControlCBFunction, eOneMillisecond,Control_Read_Dancer_Position,(IfTypeThread*0x100+POOLER_MOTOR),FEEDER_DANCER,POOLER_MOTOR); +//////////////////////// + MotorControlConfig[WINDER_MOTOR].m_params.MAX = 1; + MotorControlConfig[WINDER_MOTOR].m_params.MIN = MotorsControl[WINDER_MOTOR].outputproportionalpowerlimit*-1; + MotorControlConfig[WINDER_MOTOR].m_params.Kd = MotorsControl[WINDER_MOTOR].derivativetime; + MotorControlConfig[WINDER_MOTOR].m_params.Kp = MotorsControl[WINDER_MOTOR].proportionalgain; + MotorControlConfig[WINDER_MOTOR].m_params.Ki = MotorsControl[WINDER_MOTOR].integraltime; + MotorControlConfig[WINDER_MOTOR].m_params.IntegralErrorMultiplier = MotorsControl[WINDER_MOTOR].setpointramprateorsoftstartramp; + MotorControlConfig[WINDER_MOTOR].m_params.ProportionalErrorMultiplier = MotorsControl[WINDER_MOTOR].outputonoffhysteresisvalue; + MotorControlConfig[WINDER_MOTOR].m_params.epsilon = MotorsControl[WINDER_MOTOR].epsilon; + MotorControlConfig[WINDER_MOTOR].m_params.dt = MotorsControl[WINDER_MOTOR].controloutputtype; + MotorControlConfig[WINDER_MOTOR].m_ingnoreValue = MotorsControl[WINDER_MOTOR].sensorcorrectionadjustment; // the minimal change required to change the motor speed in pulses + MotorControlConfig[WINDER_MOTOR].m_calculatedError = 0; + MotorControlConfig[WINDER_MOTOR].m_integral = 0; + MotorControlConfig[WINDER_MOTOR].m_isEnabled = true; + MotorControlConfig[WINDER_MOTOR].m_isReady = true; + MotorControlConfig[WINDER_MOTOR].m_mesuredParam = 0; + MotorControlConfig[WINDER_MOTOR].m_preError = 0; + MotorControlConfig[WINDER_MOTOR].m_SetParam = 0;//need to update SetParams on presegment stage + MotorSetDirection(HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LDRIVING].directionthreadwize); + + ControlId = AddControlCallback(ThreadLoadControlCBFunction, eOneMillisecond,Control_Read_Dancer_Position,(IfTypeThread*0x100+WINDER_MOTOR),FEEDER_DANCER,WINDER_MOTOR); + +//////////////////////// + + CallbackCounter++; + //MotorMoveWithCallback (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize, + // numberOfSteps, Thread_Load_Dryer_Loading_Callback, 100000); + Report("Thread_Load_Set_Load_Arm_To_Start_Position",__FILE__,__LINE__,LoadStages,RpMessage,NumberOfDrierLoaderCycles,0); + status |= MotorMoveToStopper(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, (1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize), + MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround/2, Thread_Load_Set_Load_Arm_To_Stopper_Callback,LoadArmInfo.LoadArmBackLash,1000); + + //Keep Notation How Many Rotations In The Dryer + //LoadArmInfo.LoadArmBackLash = 0; + LoadArmInfo.LoadArmRounds = 0xFF; + FileWrite(&LoadArmInfo, sizeof(LoadArmInfo),LoadArmPath); + return OK; + } uint32_t ThreadLoadStateMachine( THREAD_LOAD_STAGES_ENUM ReadValue) { @@ -481,7 +550,8 @@ break; case THREAD_LOAD_SET_LOAD_ARM_TO_START_POSITION://USE NOTATION HOW MANY ROTATIONS IN THE DRYER, OR CHECK AGAINS STOPPER. MOVE SLOWLY //LoadStages++; - Thread_Load_Set_Load_Arm_To_Start_Position(); + //Thread_Load_Set_Load_Arm_To_Start_Position(); + Thread_Load_Dryer_UnLoading(); break; case THREAD_LOAD_CENTER_HEAD_ROCKERS: //LoadStages++; @@ -570,11 +640,11 @@ uint32_t ThreadLoadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue) return 0xFFFFFFFF; } index = IfIndex&0xFF; - /*if (index == POOLER_MOTOR) + if (index == POOLER_MOTOR) { //pooler dancer is right sided: data is opposite TranslatedReadValue = (-1*TranslatedReadValue); - }*/ + } //TranslatedReadValue = 0;//test MotorSamples[index][MotorSamplePointer[index]] = TranslatedReadValue;//(-1 * TranslatedReadValue); MotorSamplePointer[index]++; @@ -589,10 +659,10 @@ uint32_t ThreadLoadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue) MotorControlConfig[index].m_mesuredParam = NormalizedError; MotorControlConfig[index].m_calculatedError = AdvancedPIDAlgorithmCalculation((float)MotorControlConfig[index].m_SetParam , (float)MotorControlConfig[index].m_mesuredParam, &MotorControlConfig[index].m_params, &MotorControlConfig[index].m_preError, &MotorControlConfig[index].m_integral); - /*if (index != FEEDER_MOTOR) //feeder unit handles errors opposite to left unit + if (index != FEEDER_MOTOR) //feeder unit handles errors opposite to left unit { MotorControlConfig[index].m_calculatedError = (-1*MotorControlConfig[index].m_calculatedError); - }*/ + } calculated_speed = (1-MotorControlConfig[index].m_calculatedError)*OriginalMotorSpd_2PPS[index]; if (fabs(calculated_speed-CurrentControlledSpeed[index])> MotorControlConfig[index].m_ingnoreValue) { diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c index 529e4d260..78203b236 100644 --- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c +++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c @@ -40,11 +40,20 @@ int32_t BreakSensordebouncetimemilli = BREAK_SENSOR_LIMIT; HardwarePidControlType ThreadMotorIdToControlId[MAX_THREAD_MOTORS_NUM] = {HARDWARE_PID_CONTROL_TYPE__MotorFeeder,HARDWARE_PID_CONTROL_TYPE__MotorDryer,HARDWARE_PID_CONTROL_TYPE__MotorPooler,HARDWARE_PID_CONTROL_TYPE__MotorWinder,0}; //******************************************************************************************************************** -uint32_t MotorsConfigMessage(HardwareMotor * request) +uint32_t MotorsConfigMessage(HardwareConfiguration * HWrequest) { uint32_t status = PASSED; - TimerMotors_t Motor_i; - Motor_i = request->hardwaremotortype; + TimerMotors_t Motor_i,MotorId; + MOTDRIVER_TYPE DriverType; + HardwareMotor *request; + if (HWrequest == NULL) + return ERROR; + for (MotorId = 0; MotorId < HWrequest->n_motors ; MotorId++) + { + request = HWrequest->motors[MotorId]; + if (request == NULL) + return ERROR; + Motor_i = request->hardwaremotortype; MotorsCfg[Motor_i].configword = request->configword; MotorsCfg[Motor_i].hardwaremotortype = request->hardwaremotortype; MotorsCfg[Motor_i].minfrequency = request->minfrequency; @@ -80,13 +89,21 @@ uint32_t MotorsConfigMessage(HardwareMotor * request) MotorsCfg[Motor_i].fnslpdec = request->fnslpdec; MotorsCfg[Motor_i].fsspd = request->fsspd; - status = MotorConfig( Motor_i, &MotorsCfg[Motor_i]); + MotorsCfg[Motor_i].gatecfg1 = request->gatecfg1; + MotorsCfg[Motor_i].gatecfg2 = request->gatecfg2; + MotorsCfg[Motor_i].tvalhold = request->tvalhold; + MotorsCfg[Motor_i].tvalrun = request->tvalrun ; + MotorsCfg[Motor_i].tvalacc = request->tvalacc ; + MotorsCfg[Motor_i].tvaldec = request->tvaldec ; + MotorsCfg[Motor_i].tfast = request->tfast ; + MotorsCfg[Motor_i].tonmin = request->tonmin ; + MotorsCfg[Motor_i].toffmin = request->toffmin ; + + status = MotorConfig( Motor_i, &MotorsCfg[Motor_i]); // if (Motor_i == MOTOR_RDRIVING) // ThreadInitialTestStub(request); - + } return status; -// } -// else return Motor_i; } uint32_t MotorPidRequestMessage(HardwarePidControl* request) diff --git a/Software/Embedded_SW/Embedded/Software Release Notes.txt b/Software/Embedded_SW/Embedded/Software Release Notes.txt index a03ab04b0..dbbcd64b4 100644 --- a/Software/Embedded_SW/Embedded/Software Release Notes.txt +++ b/Software/Embedded_SW/Embedded/Software Release Notes.txt @@ -1,3 +1,11 @@ +Embedded SW Release note - Version 1.4.2.0 +============================================================= +some bugs fixed in file download +fixed some problems in flash handling +new events - jobs (not yet handled +RFID preparation - IFS module, protobuf, driver - NOT IN GIT yet +combined driver - protobuf. NOT IN GIT yet +thread load - thread unload with winding - not tested yet Embedded SW Release note - Version 1.4.1.0 ============================================================= Move to length calculation FROM PULLER |