diff options
Diffstat (limited to 'Software/Embedded_SW/Embedded')
44 files changed, 981 insertions, 501 deletions
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 9f5a27eeb..1ec53d6ec 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,5,1,2}; +TangoVersion_t _gTangoVersion = {1,5,1,4}; #define BUILD_DATE __DATE__ char Dat[50] = BUILD_DATE; diff --git a/Software/Embedded_SW/Embedded/Communication/Container.c b/Software/Embedded_SW/Embedded/Communication/Container.c index 5bed0bcdc..b386ae20f 100644 --- a/Software/Embedded_SW/Embedded/Communication/Container.c +++ b/Software/Embedded_SW/Embedded/Communication/Container.c @@ -491,6 +491,9 @@ void receive_callback(char* buffer, size_t length) case MESSAGE_TYPE__StopThreadLoadingRequest: StopThreadLoadingFunc(requestContainer); break; + case MESSAGE_TYPE__AttemptThreadJoggingRequest: + AttemptThreadJoggingFunc(requestContainer); + break; case MESSAGE_TYPE__StubDispenserEEpromRequest: StubDispenserEEpromRequestFunc(requestContainer); break; 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 d7fe911c1..4b8277d75 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[269] = +static const ProtobufCEnumValue message_type__enum_values_by_number[271] = { { "", "", 0 }, { "", "", 1 }, @@ -272,6 +272,8 @@ static const ProtobufCEnumValue message_type__enum_values_by_number[269] = { "", "", 11005 }, { "", "", 11006 }, { "", "", 11007 }, + { "", "", 11008 }, + { "", "", 11009 }, { "", "", 12000 }, { "", "", 12001 }, { "", "", 13000 }, @@ -280,9 +282,9 @@ static const ProtobufCEnumValue message_type__enum_values_by_number[269] = { "", "", 13003 }, }; static const ProtobufCIntRange message_type__value_ranges[] = { -{0, 0},{3, 2},{1000, 114},{2000, 135},{2044, 175},{3000, 177},{4000, 191},{5000, 199},{6000, 203},{7000, 209},{8000, 233},{9000, 241},{10000, 245},{11000, 255},{12000, 263},{13000, 265},{0, 269} +{0, 0},{3, 2},{1000, 114},{2000, 135},{2044, 175},{3000, 177},{4000, 191},{5000, 199},{6000, 203},{7000, 209},{8000, 233},{9000, 241},{10000, 245},{11000, 255},{12000, 265},{13000, 267},{0, 271} }; -static const ProtobufCEnumValueIndex message_type__enum_values_by_name[269] = +static const ProtobufCEnumValueIndex message_type__enum_values_by_name[271] = { { "", 189 }, { "", 190 }, @@ -294,6 +296,8 @@ static const ProtobufCEnumValueIndex message_type__enum_values_by_name[269] = { "", 252 }, { "", 231 }, { "", 232 }, + { "", 263 }, + { "", 264 }, { "", 2 }, { "", 3 }, { "", 175 }, @@ -344,8 +348,8 @@ static const ProtobufCEnumValueIndex message_type__enum_values_by_name[269] = { "", 210 }, { "", 131 }, { "", 132 }, - { "", 267 }, - { "", 268 }, + { "", 269 }, + { "", 270 }, { "", 223 }, { "", 224 }, { "", 221 }, @@ -375,8 +379,8 @@ static const ProtobufCEnumValueIndex message_type__enum_values_by_name[269] = { "", 122 }, { "", 4 }, { "", 5 }, - { "", 265 }, - { "", 266 }, + { "", 267 }, + { "", 268 }, { "", 161 }, { "", 162 }, { "", 185 }, @@ -407,8 +411,8 @@ static const ProtobufCEnumValueIndex message_type__enum_values_by_name[269] = { "", 166 }, { "", 187 }, { "", 188 }, - { "", 263 }, - { "", 264 }, + { "", 265 }, + { "", 266 }, { "", 241 }, { "", 242 }, { "", 245 }, @@ -561,9 +565,9 @@ const ProtobufCEnumDescriptor message_type__descriptor = "", "", "", - 269, + 271, message_type__enum_values_by_number, - 269, + 271, message_type__enum_values_by_name, 16, 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 cacc241b3..133d64f2d 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 @@ -283,6 +283,8 @@ typedef enum _MessageType { MESSAGE_TYPE__StopThreadLoadingResponse = 11005, MESSAGE_TYPE__TryThreadLoadingRequest = 11006, MESSAGE_TYPE__TryThreadLoadingResponse = 11007, + MESSAGE_TYPE__AttemptThreadJoggingRequest = 11008, + MESSAGE_TYPE__AttemptThreadJoggingResponse = 11009, MESSAGE_TYPE__StartInkFillingStatusRequest = 12000, MESSAGE_TYPE__StartInkFillingStatusResponse = 12001, MESSAGE_TYPE__PutDataStoreItemRequest = 13000, 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 7f667ae6d..7aa6f71d4 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[365] = +static const ProtobufCEnumValue event_type__enum_values_by_number[379] = { { "", "", 0 }, { "", "", 1000 }, @@ -46,6 +46,9 @@ static const ProtobufCEnumValue event_type__enum_values_by_number[365] = { "", "", 2019 }, { "", "", 2020 }, { "", "", 2021 }, + { "", "", 2022 }, + { "", "", 2023 }, + { "", "", 2024 }, { "", "", 3000 }, { "", "", 3001 }, { "", "", 3002 }, @@ -374,65 +377,43 @@ static const ProtobufCEnumValue event_type__enum_values_by_number[365] = { "", "", 10003 }, { "", "", 10004 }, { "", "", 10005 }, + { "", "", 10006 }, + { "", "", 10007 }, + { "", "", 10008 }, + { "", "", 10009 }, + { "", "", 10010 }, + { "", "", 10011 }, + { "", "", 10012 }, + { "", "", 10013 }, + { "", "", 10014 }, + { "", "", 10015 }, + { "", "", 10016 }, }; static const ProtobufCIntRange event_type__value_ranges[] = { -{0, 0},{1000, 1},{2000, 15},{3000, 37},{4000, 89},{5000, 111},{6000, 210},{7000, 216},{8000, 304},{9000, 336},{10000, 359},{0, 365} +{0, 0},{1000, 1},{2000, 15},{3000, 40},{4000, 92},{5000, 114},{6000, 213},{7000, 219},{8000, 307},{9000, 339},{10000, 362},{0, 379} }; -static const ProtobufCEnumValueIndex event_type__enum_values_by_name[365] = +static const ProtobufCEnumValueIndex event_type__enum_values_by_name[379] = { - { "", 337 }, - { "", 336 }, - { "", 362 }, + { "", 340 }, + { "", 339 }, + { "", 365 }, { "", 4 }, { "", 5 }, { "", 6 }, { "", 7 }, { "", 22 }, { "", 21 }, - { "", 342 }, - { "", 353 }, - { "", 347 }, - { "", 354 }, - { "", 348 }, - { "", 355 }, - { "", 349 }, + { "", 345 }, { "", 356 }, { "", 350 }, { "", 357 }, + { "", 351 }, { "", 358 }, - { "", 232 }, - { "", 296 }, - { "", 288 }, - { "", 248 }, - { "", 256 }, - { "", 264 }, - { "", 272 }, - { "", 216 }, - { "", 240 }, - { "", 224 }, - { "", 280 }, - { "", 233 }, - { "", 297 }, - { "", 289 }, - { "", 249 }, - { "", 257 }, - { "", 265 }, - { "", 273 }, - { "", 217 }, - { "", 241 }, - { "", 225 }, - { "", 281 }, - { "", 234 }, - { "", 298 }, - { "", 290 }, - { "", 250 }, - { "", 258 }, - { "", 266 }, - { "", 274 }, - { "", 218 }, - { "", 242 }, - { "", 226 }, - { "", 282 }, + { "", 352 }, + { "", 359 }, + { "", 353 }, + { "", 360 }, + { "", 361 }, { "", 235 }, { "", 299 }, { "", 291 }, @@ -488,67 +469,145 @@ static const ProtobufCEnumValueIndex event_type__enum_values_by_name[365] = { "", 247 }, { "", 231 }, { "", 287 }, - { "", 93 }, - { "", 104 }, + { "", 240 }, + { "", 304 }, + { "", 296 }, + { "", 256 }, + { "", 264 }, + { "", 272 }, + { "", 280 }, + { "", 224 }, + { "", 248 }, + { "", 232 }, + { "", 288 }, + { "", 241 }, + { "", 305 }, + { "", 297 }, + { "", 257 }, + { "", 265 }, + { "", 273 }, + { "", 281 }, + { "", 225 }, + { "", 249 }, + { "", 233 }, + { "", 289 }, + { "", 242 }, + { "", 306 }, + { "", 298 }, + { "", 258 }, + { "", 266 }, + { "", 274 }, + { "", 282 }, + { "", 226 }, + { "", 250 }, + { "", 234 }, + { "", 290 }, + { "", 96 }, + { "", 107 }, + { "", 108 }, { "", 105 }, - { "", 102 }, - { "", 100 }, { "", 103 }, - { "", 101 }, { "", 106 }, - { "", 107 }, - { "", 108 }, + { "", 104 }, { "", 109 }, - { "", 89 }, - { "", 90 }, - { "", 91 }, + { "", 110 }, + { "", 111 }, + { "", 112 }, { "", 92 }, - { "", 99 }, + { "", 93 }, { "", 94 }, - { "", 96 }, - { "", 97 }, { "", 95 }, - { "", 110 }, + { "", 102 }, + { "", 97 }, + { "", 99 }, + { "", 100 }, { "", 98 }, - { "", 208 }, - { "", 194 }, - { "", 192 }, - { "", 198 }, - { "", 196 }, - { "", 204 }, - { "", 206 }, - { "", 186 }, - { "", 188 }, - { "", 190 }, + { "", 113 }, + { "", 101 }, + { "", 211 }, + { "", 197 }, { "", 195 }, - { "", 193 }, + { "", 201 }, { "", 199 }, - { "", 197 }, - { "", 205 }, { "", 207 }, - { "", 187 }, + { "", 209 }, { "", 189 }, { "", 191 }, + { "", 193 }, + { "", 198 }, + { "", 196 }, + { "", 202 }, + { "", 200 }, + { "", 208 }, + { "", 210 }, + { "", 190 }, + { "", 192 }, + { "", 194 }, + { "", 153 }, + { "", 154 }, + { "", 155 }, + { "", 156 }, + { "", 149 }, { "", 150 }, { "", 151 }, { "", 152 }, - { "", 153 }, + { "", 144 }, + { "", 145 }, { "", 146 }, { "", 147 }, { "", 148 }, - { "", 149 }, - { "", 141 }, - { "", 142 }, { "", 143 }, - { "", 144 }, - { "", 145 }, - { "", 140 }, + { "", 206 }, + { "", 204 }, + { "", 205 }, { "", 203 }, - { "", 201 }, - { "", 202 }, - { "", 200 }, + { "", 142 }, + { "", 212 }, + { "", 186 }, + { "", 179 }, + { "", 160 }, + { "", 166 }, + { "", 172 }, + { "", 187 }, + { "", 180 }, + { "", 161 }, + { "", 167 }, + { "", 173 }, + { "", 188 }, + { "", 181 }, + { "", 162 }, + { "", 168 }, + { "", 174 }, + { "", 137 }, + { "", 132 }, + { "", 114 }, + { "", 120 }, + { "", 126 }, + { "", 138 }, + { "", 133 }, + { "", 115 }, + { "", 121 }, + { "", 127 }, { "", 139 }, - { "", 209 }, + { "", 134 }, + { "", 116 }, + { "", 122 }, + { "", 128 }, + { "", 140 }, + { "", 135 }, + { "", 117 }, + { "", 123 }, + { "", 129 }, + { "", 141 }, + { "", 136 }, + { "", 118 }, + { "", 124 }, + { "", 130 }, + { "", 182 }, + { "", 175 }, + { "", 119 }, + { "", 125 }, + { "", 131 }, { "", 183 }, { "", 176 }, { "", 157 }, @@ -564,86 +623,47 @@ static const ProtobufCEnumValueIndex event_type__enum_values_by_name[365] = { "", 159 }, { "", 165 }, { "", 171 }, - { "", 134 }, - { "", 129 }, - { "", 111 }, - { "", 117 }, - { "", 123 }, - { "", 135 }, - { "", 130 }, - { "", 112 }, - { "", 118 }, - { "", 124 }, - { "", 136 }, - { "", 131 }, - { "", 113 }, - { "", 119 }, - { "", 125 }, - { "", 137 }, - { "", 132 }, - { "", 114 }, - { "", 120 }, - { "", 126 }, - { "", 138 }, - { "", 133 }, - { "", 115 }, - { "", 121 }, - { "", 127 }, - { "", 179 }, - { "", 172 }, - { "", 116 }, - { "", 122 }, - { "", 128 }, - { "", 180 }, - { "", 173 }, - { "", 154 }, - { "", 160 }, - { "", 166 }, - { "", 181 }, - { "", 174 }, - { "", 155 }, - { "", 161 }, - { "", 167 }, - { "", 182 }, - { "", 175 }, - { "", 156 }, - { "", 162 }, - { "", 168 }, { "", 26 }, { "", 27 }, { "", 33 }, { "", 16 }, - { "", 75 }, { "", 78 }, { "", 81 }, { "", 84 }, - { "", 40 }, - { "", 47 }, - { "", 54 }, - { "", 61 }, + { "", 87 }, + { "", 43 }, + { "", 50 }, + { "", 57 }, + { "", 64 }, { "", 34 }, { "", 17 }, { "", 18 }, { "", 19 }, { "", 20 }, - { "", 359 }, - { "", 360 }, - { "", 343 }, + { "", 372 }, + { "", 374 }, + { "", 362 }, + { "", 368 }, + { "", 376 }, + { "", 370 }, + { "", 363 }, + { "", 378 }, + { "", 346 }, { "", 12 }, { "", 14 }, { "", 13 }, { "", 11 }, { "", 10 }, - { "", 43 }, - { "", 50 }, - { "", 57 }, - { "", 64 }, { "", 46 }, { "", 53 }, { "", 60 }, { "", 67 }, - { "", 69 }, - { "", 68 }, + { "", 49 }, + { "", 56 }, + { "", 63 }, + { "", 70 }, + { "", 72 }, + { "", 71 }, { "", 24 }, { "", 25 }, { "", 23 }, @@ -651,19 +671,7 @@ static const ProtobufCEnumValueIndex event_type__enum_values_by_name[365] = { "", 29 }, { "", 30 }, { "", 28 }, - { "", 87 }, - { "", 312 }, - { "", 328 }, - { "", 304 }, - { "", 320 }, - { "", 313 }, - { "", 329 }, - { "", 305 }, - { "", 321 }, - { "", 314 }, - { "", 330 }, - { "", 306 }, - { "", 322 }, + { "", 90 }, { "", 315 }, { "", 331 }, { "", 307 }, @@ -684,67 +692,87 @@ static const ProtobufCEnumValueIndex event_type__enum_values_by_name[365] = { "", 335 }, { "", 311 }, { "", 327 }, - { "", 215 }, - { "", 214 }, - { "", 210 }, + { "", 320 }, + { "", 336 }, + { "", 312 }, + { "", 328 }, + { "", 321 }, + { "", 337 }, + { "", 313 }, + { "", 329 }, + { "", 322 }, + { "", 338 }, + { "", 314 }, + { "", 330 }, + { "", 218 }, + { "", 217 }, { "", 213 }, - { "", 211 }, - { "", 212 }, - { "", 339 }, - { "", 361 }, + { "", 216 }, + { "", 214 }, + { "", 215 }, + { "", 342 }, + { "", 364 }, { "", 0 }, { "", 15 }, - { "", 351 }, - { "", 345 }, - { "", 352 }, - { "", 346 }, - { "", 74 }, + { "", 354 }, + { "", 348 }, + { "", 355 }, + { "", 349 }, { "", 77 }, { "", 80 }, { "", 83 }, - { "", 42 }, - { "", 49 }, - { "", 56 }, - { "", 63 }, + { "", 86 }, + { "", 45 }, + { "", 52 }, + { "", 59 }, + { "", 66 }, { "", 8 }, { "", 9 }, { "", 3 }, { "", 1 }, { "", 2 }, - { "", 41 }, + { "", 37 }, + { "", 38 }, + { "", 39 }, + { "", 44 }, + { "", 51 }, + { "", 58 }, + { "", 65 }, + { "", 74 }, + { "", 73 }, + { "", 75 }, { "", 48 }, { "", 55 }, { "", 62 }, - { "", 71 }, - { "", 70 }, - { "", 72 }, - { "", 45 }, - { "", 52 }, - { "", 59 }, - { "", 66 }, + { "", 69 }, { "", 36 }, - { "", 37 }, + { "", 40 }, + { "", 91 }, + { "", 41 }, { "", 88 }, - { "", 38 }, - { "", 85 }, - { "", 86 }, + { "", 89 }, { "", 35 }, { "", 31 }, + { "", 347 }, { "", 344 }, + { "", 373 }, + { "", 375 }, + { "", 366 }, + { "", 369 }, + { "", 377 }, + { "", 371 }, + { "", 367 }, { "", 341 }, - { "", 363 }, - { "", 364 }, - { "", 338 }, - { "", 340 }, - { "", 39 }, - { "", 73 }, + { "", 343 }, + { "", 42 }, { "", 76 }, { "", 79 }, { "", 82 }, - { "", 44 }, - { "", 51 }, - { "", 58 }, - { "", 65 }, + { "", 85 }, + { "", 47 }, + { "", 54 }, + { "", 61 }, + { "", 68 }, }; const ProtobufCEnumDescriptor event_type__descriptor = { @@ -753,9 +781,9 @@ const ProtobufCEnumDescriptor event_type__descriptor = "", "", "", - 365, + 379, event_type__enum_values_by_number, - 365, + 379, 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 cfb700260..9b2147774 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 @@ -57,6 +57,9 @@ typedef enum _EventType { EVENT_TYPE__FPGA_WATCHDOG_ACTIVATED = 2019, EVENT_TYPE__UNINTENDED_RESET = 2020, EVENT_TYPE__TEMPERATURE_MEASUREMENT_ERROR = 2021, + EVENT_TYPE__RFID_READER_MALFUNCTION_INK_SLOT = 2022, + EVENT_TYPE__RFID_READER_MALFUNCTION_WASTE_SLOT_1 = 2023, + EVENT_TYPE__RFID_READER_MALFUNCTION_WASTE_SLOT_2 = 2024, EVENT_TYPE__THREAD_BREAK = 3000, EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_FEEDER_DANCER = 3001, EVENT_TYPE__WINDER_CONE_DOES_NOT_EXIST = 3002, @@ -384,7 +387,18 @@ typedef enum _EventType { EVENT_TYPE__NO_WASTE_CARTRIDGE_AVAILABLE = 10002, EVENT_TYPE__ALL_WASTE_CARTRIDGES_FULL = 10003, EVENT_TYPE__WASTE_CARTRIDGE_PRESENCE_SENSOR_TIMEOUT = 10004, - EVENT_TYPE__WASTE_CARTRIDGE_RFID_TIMEOUT = 10005 + EVENT_TYPE__WASTE_CARTRIDGE_RFID_TIMEOUT = 10005, + EVENT_TYPE__INK_CARTRIDGE_RFID_TAG_CANNOT_BE_READ = 10006, + EVENT_TYPE__WASTE_CARTRIDGE_RFID_TAG_CANNOT_BE_READ = 10007, + EVENT_TYPE__INK_CARTRIDGE_RFID_TAG_IS_NOT_VALID = 10008, + EVENT_TYPE__WASTE_CARTRIDGE_RFID_TAG_IS_NOT_VALID = 10009, + EVENT_TYPE__INK_CARTRIDGE_AUTHENTICATION_FAILED = 10010, + EVENT_TYPE__WASTE_CARTRIDGE_AUTHENTICATION_FAILED = 10011, + EVENT_TYPE__INK_CARTRIDGE_IS_BLOCKED = 10012, + EVENT_TYPE__WASTE_CARTRIDGE_IS_BLOCKED = 10013, + EVENT_TYPE__INK_CARTRIDGE_RFID_TAG_CANNOT_BE_UPDATED = 10014, + EVENT_TYPE__WASTE_CARTRIDGE_RFID_TAG_CANNOT_BE_UPDATED = 10015, + EVENT_TYPE__INK_IN_CARTRIDGE_IS_EXPIRED = 10016 PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(EVENT_TYPE) } EventType; diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Printing/HeadCleaningParameters.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/Printing/HeadCleaningParameters.pb-c.c index 699470ded..a5fba86d3 100644 --- a/Software/Embedded_SW/Embedded/Communication/PMR/Printing/HeadCleaningParameters.pb-c.c +++ b/Software/Embedded_SW/Embedded/Communication/PMR/Printing/HeadCleaningParameters.pb-c.c @@ -52,7 +52,7 @@ void head_cleaning_parameters__free_unpacked assert(message->base.descriptor == &head_cleaning_parameters__descriptor); protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); } -static const ProtobufCFieldDescriptor head_cleaning_parameters__field_descriptors[1] = +static const ProtobufCFieldDescriptor head_cleaning_parameters__field_descriptors[2] = { { "", @@ -66,14 +66,27 @@ static const ProtobufCFieldDescriptor head_cleaning_parameters__field_descriptor 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, + { + "", + 2, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_DOUBLE, + offsetof(HeadCleaningParameters, has_archeadcleaningmotorspeed), + offsetof(HeadCleaningParameters, archeadcleaningmotorspeed), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, }; static const unsigned head_cleaning_parameters__field_indices_by_name[] = { + 1, /* field[1] = ArcHeadCleaningMotorSpeed */ 0, /* field[0] = CleanerFlow */ }; static const ProtobufCIntRange head_cleaning_parameters__number_ranges[1 + 1] = { { 1, 0 }, - { 0, 1 } + { 0, 2 } }; const ProtobufCMessageDescriptor head_cleaning_parameters__descriptor = { @@ -83,7 +96,7 @@ const ProtobufCMessageDescriptor head_cleaning_parameters__descriptor = "", "", sizeof(HeadCleaningParameters), - 1, + 2, head_cleaning_parameters__field_descriptors, head_cleaning_parameters__field_indices_by_name, 1, head_cleaning_parameters__number_ranges, diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Printing/HeadCleaningParameters.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/Printing/HeadCleaningParameters.pb-c.h index 9213143bb..08c7b7248 100644 --- a/Software/Embedded_SW/Embedded/Communication/PMR/Printing/HeadCleaningParameters.pb-c.h +++ b/Software/Embedded_SW/Embedded/Communication/PMR/Printing/HeadCleaningParameters.pb-c.h @@ -28,10 +28,12 @@ struct _HeadCleaningParameters ProtobufCMessage base; protobuf_c_boolean has_cleanerflow; double cleanerflow; + protobuf_c_boolean has_archeadcleaningmotorspeed; + double archeadcleaningmotorspeed; }; #define HEAD_CLEANING_PARAMETERS__INIT \ { PROTOBUF_C_MESSAGE_INIT (&head_cleaning_parameters__descriptor) \ - , 0, 0 } + , 0, 0, 0, 0 } /* HeadCleaningParameters methods */ diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Printing/ProcessParameters.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/Printing/ProcessParameters.pb-c.c index 44acaa3ad..a27a2202e 100644 --- a/Software/Embedded_SW/Embedded/Communication/PMR/Printing/ProcessParameters.pb-c.c +++ b/Software/Embedded_SW/Embedded/Communication/PMR/Printing/ProcessParameters.pb-c.c @@ -52,7 +52,7 @@ void process_parameters__free_unpacked assert(message->base.descriptor == &process_parameters__descriptor); protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); } -static const ProtobufCFieldDescriptor process_parameters__field_descriptors[32] = +static const ProtobufCFieldDescriptor process_parameters__field_descriptors[31] = { { "", @@ -426,21 +426,8 @@ static const ProtobufCFieldDescriptor process_parameters__field_descriptors[32] 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, - { - "", - 32, - PROTOBUF_C_LABEL_OPTIONAL, - PROTOBUF_C_TYPE_DOUBLE, - offsetof(ProcessParameters, has_archeadcleaningmotorspeed), - offsetof(ProcessParameters, archeadcleaningmotorspeed), - NULL, - NULL, - 0, /* flags */ - 0,NULL,NULL /* reserved1,reserved2, etc */ - }, }; static const unsigned process_parameters__field_indices_by_name[] = { - 31, /* field[31] = ArcHeadCleaningMotorSpeed */ 13, /* field[13] = DryerAirFlow */ 17, /* field[17] = DryerBufferLength */ 14, /* field[14] = DryerZone1Temp */ @@ -476,7 +463,7 @@ static const unsigned process_parameters__field_indices_by_name[] = { static const ProtobufCIntRange process_parameters__number_ranges[1 + 1] = { { 1, 0 }, - { 0, 32 } + { 0, 31 } }; const ProtobufCMessageDescriptor process_parameters__descriptor = { @@ -486,7 +473,7 @@ const ProtobufCMessageDescriptor process_parameters__descriptor = "", "", sizeof(ProcessParameters), - 32, + 31, process_parameters__field_descriptors, process_parameters__field_indices_by_name, 1, process_parameters__number_ranges, diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Printing/ProcessParameters.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/Printing/ProcessParameters.pb-c.h index aa762a3d6..9a6453221 100644 --- a/Software/Embedded_SW/Embedded/Communication/PMR/Printing/ProcessParameters.pb-c.h +++ b/Software/Embedded_SW/Embedded/Communication/PMR/Printing/ProcessParameters.pb-c.h @@ -88,12 +88,10 @@ struct _ProcessParameters double lblowertemp; protobuf_c_boolean has_pressurebuildup; double pressurebuildup; - protobuf_c_boolean has_archeadcleaningmotorspeed; - double archeadcleaningmotorspeed; }; #define PROCESS_PARAMETERS__INIT \ { PROTOBUF_C_MESSAGE_INIT (&process_parameters__descriptor) \ - , 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 } /* ProcessParameters methods */ diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/ThreadLoading/AttemptThreadJoggingRequest.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/ThreadLoading/AttemptThreadJoggingRequest.pb-c.c new file mode 100644 index 000000000..78659ae90 --- /dev/null +++ b/Software/Embedded_SW/Embedded/Communication/PMR/ThreadLoading/AttemptThreadJoggingRequest.pb-c.c @@ -0,0 +1,72 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: AttemptThreadJoggingRequest.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "AttemptThreadJoggingRequest.pb-c.h" +void attempt_thread_jogging_request__init + (AttemptThreadJoggingRequest *message) +{ + static const AttemptThreadJoggingRequest init_value = ATTEMPT_THREAD_JOGGING_REQUEST__INIT; + *message = init_value; +} +size_t attempt_thread_jogging_request__get_packed_size + (const AttemptThreadJoggingRequest *message) +{ + assert(message->base.descriptor == &attempt_thread_jogging_request__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t attempt_thread_jogging_request__pack + (const AttemptThreadJoggingRequest *message, + uint8_t *out) +{ + assert(message->base.descriptor == &attempt_thread_jogging_request__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t attempt_thread_jogging_request__pack_to_buffer + (const AttemptThreadJoggingRequest *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &attempt_thread_jogging_request__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +AttemptThreadJoggingRequest * + attempt_thread_jogging_request__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (AttemptThreadJoggingRequest *) + protobuf_c_message_unpack (&attempt_thread_jogging_request__descriptor, + allocator, len, data); +} +void attempt_thread_jogging_request__free_unpacked + (AttemptThreadJoggingRequest *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &attempt_thread_jogging_request__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +#define attempt_thread_jogging_request__field_descriptors NULL +#define attempt_thread_jogging_request__field_indices_by_name NULL +#define attempt_thread_jogging_request__number_ranges NULL +const ProtobufCMessageDescriptor attempt_thread_jogging_request__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "", + "", + "", + "", + sizeof(AttemptThreadJoggingRequest), + 0, + attempt_thread_jogging_request__field_descriptors, + attempt_thread_jogging_request__field_indices_by_name, + 0, attempt_thread_jogging_request__number_ranges, + (ProtobufCMessageInit) attempt_thread_jogging_request__init, + NULL,NULL,NULL /* reserved[123] */ +}; diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/ThreadLoading/AttemptThreadJoggingRequest.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/ThreadLoading/AttemptThreadJoggingRequest.pb-c.h new file mode 100644 index 000000000..366498be8 --- /dev/null +++ b/Software/Embedded_SW/Embedded/Communication/PMR/ThreadLoading/AttemptThreadJoggingRequest.pb-c.h @@ -0,0 +1,70 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: AttemptThreadJoggingRequest.proto */ + +#ifndef PROTOBUF_C_AttemptThreadJoggingRequest_2eproto__INCLUDED +#define PROTOBUF_C_AttemptThreadJoggingRequest_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 _AttemptThreadJoggingRequest AttemptThreadJoggingRequest; + + +/* --- enums --- */ + + +/* --- messages --- */ + +struct _AttemptThreadJoggingRequest +{ + ProtobufCMessage base; +}; +#define ATTEMPT_THREAD_JOGGING_REQUEST__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&attempt_thread_jogging_request__descriptor) \ + } + + +/* AttemptThreadJoggingRequest methods */ +void attempt_thread_jogging_request__init + (AttemptThreadJoggingRequest *message); +size_t attempt_thread_jogging_request__get_packed_size + (const AttemptThreadJoggingRequest *message); +size_t attempt_thread_jogging_request__pack + (const AttemptThreadJoggingRequest *message, + uint8_t *out); +size_t attempt_thread_jogging_request__pack_to_buffer + (const AttemptThreadJoggingRequest *message, + ProtobufCBuffer *buffer); +AttemptThreadJoggingRequest * + attempt_thread_jogging_request__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void attempt_thread_jogging_request__free_unpacked + (AttemptThreadJoggingRequest *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*AttemptThreadJoggingRequest_Closure) + (const AttemptThreadJoggingRequest *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCMessageDescriptor attempt_thread_jogging_request__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_AttemptThreadJoggingRequest_2eproto__INCLUDED */ diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/ThreadLoading/AttemptThreadJoggingResponse.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/ThreadLoading/AttemptThreadJoggingResponse.pb-c.c new file mode 100644 index 000000000..d75845c99 --- /dev/null +++ b/Software/Embedded_SW/Embedded/Communication/PMR/ThreadLoading/AttemptThreadJoggingResponse.pb-c.c @@ -0,0 +1,72 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: AttemptThreadJoggingResponse.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "AttemptThreadJoggingResponse.pb-c.h" +void attempt_thread_jogging_response__init + (AttemptThreadJoggingResponse *message) +{ + static const AttemptThreadJoggingResponse init_value = ATTEMPT_THREAD_JOGGING_RESPONSE__INIT; + *message = init_value; +} +size_t attempt_thread_jogging_response__get_packed_size + (const AttemptThreadJoggingResponse *message) +{ + assert(message->base.descriptor == &attempt_thread_jogging_response__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t attempt_thread_jogging_response__pack + (const AttemptThreadJoggingResponse *message, + uint8_t *out) +{ + assert(message->base.descriptor == &attempt_thread_jogging_response__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t attempt_thread_jogging_response__pack_to_buffer + (const AttemptThreadJoggingResponse *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &attempt_thread_jogging_response__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +AttemptThreadJoggingResponse * + attempt_thread_jogging_response__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (AttemptThreadJoggingResponse *) + protobuf_c_message_unpack (&attempt_thread_jogging_response__descriptor, + allocator, len, data); +} +void attempt_thread_jogging_response__free_unpacked + (AttemptThreadJoggingResponse *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &attempt_thread_jogging_response__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +#define attempt_thread_jogging_response__field_descriptors NULL +#define attempt_thread_jogging_response__field_indices_by_name NULL +#define attempt_thread_jogging_response__number_ranges NULL +const ProtobufCMessageDescriptor attempt_thread_jogging_response__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "", + "", + "", + "", + sizeof(AttemptThreadJoggingResponse), + 0, + attempt_thread_jogging_response__field_descriptors, + attempt_thread_jogging_response__field_indices_by_name, + 0, attempt_thread_jogging_response__number_ranges, + (ProtobufCMessageInit) attempt_thread_jogging_response__init, + NULL,NULL,NULL /* reserved[123] */ +}; diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/ThreadLoading/AttemptThreadJoggingResponse.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/ThreadLoading/AttemptThreadJoggingResponse.pb-c.h new file mode 100644 index 000000000..e7324b29b --- /dev/null +++ b/Software/Embedded_SW/Embedded/Communication/PMR/ThreadLoading/AttemptThreadJoggingResponse.pb-c.h @@ -0,0 +1,70 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: AttemptThreadJoggingResponse.proto */ + +#ifndef PROTOBUF_C_AttemptThreadJoggingResponse_2eproto__INCLUDED +#define PROTOBUF_C_AttemptThreadJoggingResponse_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 _AttemptThreadJoggingResponse AttemptThreadJoggingResponse; + + +/* --- enums --- */ + + +/* --- messages --- */ + +struct _AttemptThreadJoggingResponse +{ + ProtobufCMessage base; +}; +#define ATTEMPT_THREAD_JOGGING_RESPONSE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&attempt_thread_jogging_response__descriptor) \ + } + + +/* AttemptThreadJoggingResponse methods */ +void attempt_thread_jogging_response__init + (AttemptThreadJoggingResponse *message); +size_t attempt_thread_jogging_response__get_packed_size + (const AttemptThreadJoggingResponse *message); +size_t attempt_thread_jogging_response__pack + (const AttemptThreadJoggingResponse *message, + uint8_t *out); +size_t attempt_thread_jogging_response__pack_to_buffer + (const AttemptThreadJoggingResponse *message, + ProtobufCBuffer *buffer); +AttemptThreadJoggingResponse * + attempt_thread_jogging_response__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void attempt_thread_jogging_response__free_unpacked + (AttemptThreadJoggingResponse *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*AttemptThreadJoggingResponse_Closure) + (const AttemptThreadJoggingResponse *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCMessageDescriptor attempt_thread_jogging_response__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_AttemptThreadJoggingResponse_2eproto__INCLUDED */ diff --git a/Software/Embedded_SW/Embedded/DataDef.h b/Software/Embedded_SW/Embedded/DataDef.h index e128094a5..755e5a962 100644 --- a/Software/Embedded_SW/Embedded/DataDef.h +++ b/Software/Embedded_SW/Embedded/DataDef.h @@ -26,7 +26,8 @@ //#define FOUR_WINDERS #ifdef FOUR_WINDERS -#define BTSR_NO_TFU +#define BTSR_NO_FEEDER_TFU +#define BTSR_NO_PULLER_TFU #endif //#define USE_POWERSTEP01 -NA @@ -35,7 +36,8 @@ //#define VAC_TEST #define DISPENSER_VALVES_OPEN //#define USE_TUNNEL_PT100 -//#define BTSR_NO_TFU +//#define BTSR_NO_FEEDER_TFU +//#define BTSR_NO_PULLER_TFU //#define IGNORE_SPIKE //#define SPECIAL_DISPENSERS extern bool Special_Dispensers; diff --git a/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA.c b/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA.c index 95651eba2..0b308408c 100644 --- a/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA.c +++ b/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA.c @@ -350,15 +350,15 @@ uint32_t Dryer_Read_Blower_Tach() return RPM; } */ +uint32_t Drayer_Fan_Speed_RPM = 0; +uint32_t Get_Dryer_Fan_Tacho() +{ + return Drayer_Fan_Speed_RPM; +} uint32_t Read_Dryer_Fan_Tacho() { - - uint32_t Drayer_Fan_Speed_RPM = 0; - Drayer_Fan_Speed_RPM = Calculate_Tacho_Fan_Speed(FPGA_Freq, 12, F1_Prescaler1_reg5, F1_Tacho_reg8); - - return Drayer_Fan_Speed_RPM; } diff --git a/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA.h b/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA.h index e660b450a..121211c69 100644 --- a/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA.h +++ b/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA.h @@ -15,6 +15,7 @@ void Control_Dryer_Fan_PWM(uint8_t PWM_Command_Precent); void Machine_Idle_Breathing_Led(); uint32_t Read_Dryer_Fan_Tacho(); +uint32_t Get_Dryer_Fan_Tacho(); void Set_Speed_Sensor_TypeII_Registers(uint32_t Counter, uint32_t Prescaler); uint32_t Read_Speed_Sensor_TypeII(); diff --git a/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_GPIO/FPGA_GPIO.c b/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_GPIO/FPGA_GPIO.c index 495f27652..00502d3ba 100644 --- a/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_GPIO/FPGA_GPIO.c +++ b/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_GPIO/FPGA_GPIO.c @@ -905,8 +905,6 @@ void Pumps_Control(PUMPS_ENUM Pump_Id, bool Direction) //1 - OPEN, 0 - CLOSE ?? //F1_GPO_Reg.bits.F1_GPO_WASTECH_PUMP2 = Direction; SecondaryPumpActive = Direction; } - else - LOG_ERROR(WHS_Type,"Pump activated on new whs"); break; case WHS_WTANKPUMP2: #ifndef EVALUATION_BOARD diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/WHS_Card/D_ADS122_PT100/WHS_PT100_ADC.c b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/WHS_Card/D_ADS122_PT100/WHS_PT100_ADC.c index 6c2d54111..335aab113 100644 --- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/WHS_Card/D_ADS122_PT100/WHS_PT100_ADC.c +++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/WHS_Card/D_ADS122_PT100/WHS_PT100_ADC.c @@ -199,7 +199,7 @@ bool WHS_PT100_config(TEMPERATURE_SENSOR_ID_ENUM SensorId) //ADS122_WriteAllReg(uint8_t i2cbus, WHS_chip_address i2cadd, D_ADS122C04_TempSensConfigStruc *p_writeValue); } -bool WHS_PT100_Get(TEMPERATURE_SENSOR_ID_ENUM SensorId, uint8_t *value ) +bool WHS_PT100_Get(TEMPERATURE_SENSOR_ID_ENUM SensorId, uint32_t *value ) { bool Status = OK; switch (SensorId) @@ -225,7 +225,7 @@ bool WHS_PT100_Get(TEMPERATURE_SENSOR_ID_ENUM SensorId, uint8_t *value ) } -bool WHS_PT100_Read(TEMPERATURE_SENSOR_ID_ENUM SensorId) +uint32_t WHS_PT100_Read(TEMPERATURE_SENSOR_ID_ENUM SensorId) { bool Status = OK; uint32_t Temperatures = 0; @@ -267,7 +267,10 @@ bool WHS_PT100_Read(TEMPERATURE_SENSOR_ID_ENUM SensorId) break; } - return Status; + if (Status == OK) + return Temperatures; + else + return (uint32_t)Status; } bool Test_WHS_PT100_ADC() @@ -277,10 +280,10 @@ bool Test_WHS_PT100_ADC() //status |= WHS_PT100_InitConfigReg(); - status |= WHS_PT100_Read(/*TEMPERATURE_SENSOR_ID_ENUM*/ WHS_PT100_1_0X80_0); - status |= WHS_PT100_Read(/*TEMPERATURE_SENSOR_ID_ENUM*/ WHS_PT100_3_0X82_0); - status |= WHS_PT100_Read(/*TEMPERATURE_SENSOR_ID_ENUM*/ WHS_PT100_2_0X80_1); - status |= WHS_PT100_Read(/*TEMPERATURE_SENSOR_ID_ENUM*/ WHS_PT100_4_0X82_1); + //status |= WHS_PT100_Read(/*TEMPERATURE_SENSOR_ID_ENUM*/ WHS_PT100_1_0X80_0); + //status |= WHS_PT100_Read(/*TEMPERATURE_SENSOR_ID_ENUM*/ WHS_PT100_3_0X82_0); + //status |= WHS_PT100_Read(/*TEMPERATURE_SENSOR_ID_ENUM*/ WHS_PT100_2_0X80_1); + //status |= WHS_PT100_Read(/*TEMPERATURE_SENSOR_ID_ENUM*/ WHS_PT100_4_0X82_1); return status; } diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/WHS_Card/D_ADS122_PT100/WHS_PT100_ADC.h b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/WHS_Card/D_ADS122_PT100/WHS_PT100_ADC.h index ab09f0e9d..78900af52 100644 --- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/WHS_Card/D_ADS122_PT100/WHS_PT100_ADC.h +++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/WHS_Card/D_ADS122_PT100/WHS_PT100_ADC.h @@ -25,8 +25,8 @@ extern uint32_t was_Data_ADC_Head; bool WHS_PT100_InitConfigReg(); bool WHS_PT100_ControlMux_Before_Reading(TEMPERATURE_SENSOR_ID_ENUM SensorId); -bool WHS_PT100_Read(TEMPERATURE_SENSOR_ID_ENUM SensorId); -bool WHS_PT100_Get(TEMPERATURE_SENSOR_ID_ENUM SensorId, uint8_t *value ); +uint32_t WHS_PT100_Read(TEMPERATURE_SENSOR_ID_ENUM SensorId); +bool WHS_PT100_Get(TEMPERATURE_SENSOR_ID_ENUM SensorId, uint32_t *value ); bool Test_WHS_PT100_ADC(); #endif /* DRIVERS_I2C_COMMUNICATION_WHS_CARD_PT100_PT100_ADC_H_ */ diff --git a/Software/Embedded_SW/Embedded/Embedded.cfg b/Software/Embedded_SW/Embedded/Embedded.cfg index cce6b3440..7fdf21819 100644 --- a/Software/Embedded_SW/Embedded/Embedded.cfg +++ b/Software/Embedded_SW/Embedded/Embedded.cfg @@ -19,7 +19,7 @@ var Task = xdc.useModule('ti.sysbios.knl.Task'); var HeapTrack = xdc.useModule('ti.sysbios.heaps.HeapTrack'); //var Memory = xdc.useModule('xdc.runtime.Memory'); -BIOS.heapSize = 60000; // bios heapmem +BIOS.heapSize = 68000; // bios heapmem //Memory.defaultHeapSize = 20000; //Program.heap = 40000; //Program.stack = 4096; diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c index 127ccbabf..e754b0df2 100644 --- a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c +++ b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c @@ -1,3 +1,4 @@ + /* * AlarmHandling.c @@ -491,14 +492,14 @@ uint32_t AlarmHandlingLoadFile(void) { FileAlarmItem[F_count].AlarmDirection = AlarmParametersTable->alarmitem[i]->alarmdirection; FileAlarmItem[F_count].AlarmDirection = AlarmParametersTable->alarmitem[i]->alarmdirection; - FileAlarmItem[F_count].Frequency = AlarmParametersTable->alarmitem[i]->frequency; //1/10/100/1000 + //FileAlarmItem[F_count].Frequency = AlarmParametersTable->alarmitem[i]->frequency; //1/10/100/1000 FileAlarmItem[F_count].AlarmSource = AlarmParametersTable->alarmitem[i]->alarmsource; FileAlarmItem[F_count].DeviceId = AlarmParametersTable->alarmitem[i]->deviceid; FileAlarmItem[F_count].ModuleDeviceId = AlarmParametersTable->alarmitem[i]->moduledeviceid; FileAlarmItem[F_count].AlarmValue = AlarmParametersTable->alarmitem[i]->alarmvalue; FileAlarmItem[F_count].AlarmDirection = AlarmParametersTable->alarmitem[i]->alarmdirection; FileAlarmItem[F_count].Severity = AlarmParametersTable->alarmitem[i]->severity; - FileAlarmItem[F_count].Predecessor = AlarmParametersTable->alarmitem[i]->predecessor; + //FileAlarmItem[F_count].Predecessor = AlarmParametersTable->alarmitem[i]->predecessor; FileAlarmItem[F_count].DebounceValue = AlarmParametersTable->alarmitem[i]->debouncevalue; FileAlarmItem[F_count].EventType = AlarmParametersTable->alarmitem[i]->eventtype; FileAlarmItem[F_count].isPersistent = AlarmParametersTable->alarmitem[i]->ispersistent; @@ -1021,6 +1022,10 @@ JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob) } } } + if (FoundReason == JOB_OK) + { + FoundReason = Winder_Check_Cone(); + } if (FoundReason != JOB_OK) { JobEndReason = getEndReason(AlarmId); @@ -1080,7 +1085,7 @@ void AlarmHandlingInternalSetAlarm(uint32_t AlarmId, bool value) if (AlarmItem[Alarm_i].EventType == AlarmId) { //if (0) // PERSISTENT ALARM - if ((AlarmItem[Alarm_i].isPersistent == true)) // PERSISTENT ALARM simulate + if ((AlarmItem[Alarm_i].isPersistent == true)&&(value == true)) // PERSISTENT ALARM simulate Currently looking for "true" value, otherwise the currently existing OFF event appears { if (PersistentEventsResponse.events == NULL) PersistentEventsResponse.events = (Event **)my_malloc(sizeof(Event*)*(PersistentEventsResponse.n_events+1)); @@ -1213,29 +1218,8 @@ uint32_t AlarmHandlingLoop(uint32_t tick) if (AlarmItem[Alarm_i].AlarmSource > ALARM_SOURCE_TYPE__FluidLevelAlarm) continue; AlarmCounter++; - if (tick%AlarmItem[Alarm_i].Frequency == 0) + switch (AlarmItem[Alarm_i].AlarmSource) { - switch (AlarmItem[Alarm_i].AlarmSource) - { - /*case ALARM_SOURCE_TYPE__TemperatureAlarm: - ivalue = MillisecGetTemperatures((TEMPERATURE_SENSOR_ID_ENUM)AlarmItem[Alarm_i].DeviceId); - if (AlarmItem[Alarm_i].AlarmDirection == true) - { - if (ivalue/100 >= AlarmItem[Alarm_i].AlarmValue) - { - //LOG_ERROR (ivalue/100,"Temperature spike"); - Status = true; - } - } - else - { - if (ivalue/100 <= AlarmItem[Alarm_i].AlarmValue) - { - //LOG_ERROR (ivalue/100,"iTemperature spike"); - Status = true; - } - } - break;*/ case ALARM_SOURCE_TYPE__CoversAlarm: if (CheckTamperAlarms) { @@ -1261,14 +1245,6 @@ uint32_t AlarmHandlingLoop(uint32_t tick) if (CheckHardLimitAlarms) { Status = AlarmState[Alarm_i].Status; - /*if (AlarmItem[Alarm_i].AlarmDirection == true) - { - value = Get_Notification_Disp_UP(AlarmItem[Alarm_i].DeviceId); - } - else - { - value = Get_Notification_Disp_Down(AlarmItem[Alarm_i].DeviceId); - } polling in the safety */ } else { @@ -1422,21 +1398,6 @@ uint32_t AlarmHandlingLoop(uint32_t tick) default: Status = false; } - /*value = MotorGetStatus((TimerMotors_t)AlarmItem[Alarm_i].DeviceId); - if (AlarmItem[Alarm_i].AlarmDirection == true) - { - if (value && AlarmItem[Alarm_i].AlarmValue) - { - Status = true; - } - } - else - { - if ((value && AlarmItem[Alarm_i].AlarmValue)==false) - { - Status = true; - } - }*/ } } else @@ -1473,7 +1434,7 @@ uint32_t AlarmHandlingLoop(uint32_t tick) case ALARM_SOURCE_TYPE__TachoAlarm: // add by shai Status = false; - if (CheckTamperAlarms) + if (CheckMotorAlarms) { // ReportWithPackageFilter(AlarmFilter,"------------FANS_RPM[Alarm_i]----------------", __FILE__,__LINE__,Alarm_i, RpMessage, value, 0); @@ -1560,16 +1521,19 @@ uint32_t AlarmHandlingLoop(uint32_t tick) } else { - value = Read_Dryer_Fan_Tacho(); + + value = Get_Dryer_Fan_Tacho(); if (AlarmItem[Alarm_i].Severity == DEBUG_LOG_CATEGORY__Critical ) - if ((AlarmItem[Alarm_i].AlarmDirection == UNDER_VALUE) && (value == DRYER_FAN_STOP)) + { + if (value == DRYER_FAN_STOP) { Status = true; - //ReportWithPackageFilter(AlarmFilter,"----------- DRYER FAN RPM Error----------------", __FILE__,__LINE__,0, RpMessage, value, 0); } + //ReportWithPackageFilter(AlarmFilter,"----------- DRYER FAN RPM ----------------", __FILE__,__LINE__,msec_millisecondCounter, RpMessage, value, 0); + } else if (AlarmItem[Alarm_i].Severity == DEBUG_LOG_CATEGORY__Warning) { - if ((AlarmItem[Alarm_i].AlarmDirection == UNDER_VALUE) && (value < DRYER_FAN_MIN_RPM)) + if ((value>0)&&(value < DRYER_FAN_MIN_RPM)) { Status = true; //ReportWithPackageFilter(AlarmFilter,"----------- DRYER FAN RPM Error----------------", __FILE__,__LINE__,0, RpMessage, value, 0); @@ -1621,78 +1585,77 @@ uint32_t AlarmHandlingLoop(uint32_t tick) break; default: break; - } //switch - if (AlarmItem[Alarm_i].DebounceValue > 0) //handle debouncing + } //switch + if (AlarmItem[Alarm_i].DebounceValue > 0) //handle debouncing + { + if (Status == true) //increase counter { - if (Status == true) //increase counter + AlarmState[Alarm_i].DebounceCounter++; + if (AlarmState[Alarm_i].Status == false) // alarm is not set yet { - AlarmState[Alarm_i].DebounceCounter++; - if (AlarmState[Alarm_i].Status == false) // alarm is not set yet - { - if (AlarmState[Alarm_i].DebounceCounter < AlarmItem[Alarm_i].DebounceValue) //had not reached the debounce value - { - Status = false; //do not set the alarm - } //else alarm will be set - } - else // alarm is already set + if (AlarmState[Alarm_i].DebounceCounter < AlarmItem[Alarm_i].DebounceValue) //had not reached the debounce value { - AlarmState[Alarm_i].DebounceCounter = AlarmItem[Alarm_i].DebounceValue; // do not go over the debounce value - } + Status = false; //do not set the alarm + } //else alarm will be set } - else //status == false - decrease counter + else // alarm is already set { - AlarmState[Alarm_i].DebounceCounter--; - if (AlarmState[Alarm_i].Status == true) // alarm is set - { - if (AlarmState[Alarm_i].DebounceCounter > 0) // had not reached zero yet - { - Status = true; // do not reset the alarm yet - } // else reset the alarm - } - else // if the alarm is off - { - AlarmState[Alarm_i].DebounceCounter = 0; //do not go below 0 - } + AlarmState[Alarm_i].DebounceCounter = AlarmItem[Alarm_i].DebounceValue; // do not go over the debounce value } } - /*if (AlarmItem[Alarm_i].Predecessor!=0xFF) + else //status == false - decrease counter { - if (AlarmState[AlarmItem[Alarm_i].Predecessor].Status == true) //higher hierarchy alarm is on - Status = false; - }*/ - if (Status != AlarmState[Alarm_i].Status) //change in alarm Status - { - if (Status == true) // alarm on + AlarmState[Alarm_i].DebounceCounter--; + if (AlarmState[Alarm_i].Status == true) // alarm is set { - // report the alarm! - AlarmState[Alarm_i].EventPtr = my_malloc (sizeof(Event)); - if (AlarmState[Alarm_i].EventPtr) + if (AlarmState[Alarm_i].DebounceCounter > 0) // had not reached zero yet { - event__init(AlarmState[Alarm_i].EventPtr); - AlarmState[Alarm_i].EventPtr->has_type = true; - AlarmState[Alarm_i].EventPtr->type = AlarmItem[Alarm_i].EventType; - AlarmState[Alarm_i].EventPtr->message = NULL;//AlarmItem[Alarm_i].EventName; - } - AlarmState[Alarm_i].Status = true; - AlarmHandlingConsequentActions(Alarm_i, AlarmItem[Alarm_i].Severity); - ReportWithPackageFilter(AlarmFilter,"Alarm ON ", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, RpMessage, value, Alarm_i); + Status = true; // do not reset the alarm yet + } // else reset the alarm } - else // alarm off + else // if the alarm is off { - ReportWithPackageFilter(AlarmFilter,"Alarm OFF ", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, RpMessage, 0, Alarm_i); - if (AlarmState[Alarm_i].EventPtr) - { - //ROM_IntMasterDisable(); - Save_Alarm_i = Alarm_i; - Save_Alarm_ptr = AlarmState[Alarm_i].EventPtr; - Save_Alarm_Type = AlarmItem[Alarm_i].EventType; - my_free(AlarmState[Alarm_i].EventPtr); - AlarmState[Alarm_i].EventPtr = NULL; - //ROM_IntMasterEnable(); - } - AlarmState[Alarm_i].Status = false; - AlarmHandlingConsequentActions(Alarm_i, DEBUG_LOG_CATEGORY__Info); + AlarmState[Alarm_i].DebounceCounter = 0; //do not go below 0 + } + } + } + /*if (AlarmItem[Alarm_i].Predecessor!=0xFF) + { + if (AlarmState[AlarmItem[Alarm_i].Predecessor].Status == true) //higher hierarchy alarm is on + Status = false; + }*/ + if (Status != AlarmState[Alarm_i].Status) //change in alarm Status + { + if (Status == true) // alarm on + { + // report the alarm! + AlarmState[Alarm_i].EventPtr = my_malloc (sizeof(Event)); + if (AlarmState[Alarm_i].EventPtr) + { + event__init(AlarmState[Alarm_i].EventPtr); + AlarmState[Alarm_i].EventPtr->has_type = true; + AlarmState[Alarm_i].EventPtr->type = AlarmItem[Alarm_i].EventType; + AlarmState[Alarm_i].EventPtr->message = NULL;//AlarmItem[Alarm_i].EventName; + } + AlarmState[Alarm_i].Status = true; + AlarmHandlingConsequentActions(Alarm_i, AlarmItem[Alarm_i].Severity); + ReportWithPackageFilter(AlarmFilter,"Alarm ON ", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, RpMessage, value, Alarm_i); + } + else // alarm off + { + ReportWithPackageFilter(AlarmFilter,"Alarm OFF ", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, RpMessage, 0, Alarm_i); + if (AlarmState[Alarm_i].EventPtr) + { + //ROM_IntMasterDisable(); + Save_Alarm_i = Alarm_i; + Save_Alarm_ptr = AlarmState[Alarm_i].EventPtr; + Save_Alarm_Type = AlarmItem[Alarm_i].EventType; + my_free(AlarmState[Alarm_i].EventPtr); + AlarmState[Alarm_i].EventPtr = NULL; + //ROM_IntMasterEnable(); } + AlarmState[Alarm_i].Status = false; + AlarmHandlingConsequentActions(Alarm_i, DEBUG_LOG_CATEGORY__Info); } } } diff --git a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c index 689219583..1057ddbc3 100644 --- a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c +++ b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c @@ -610,21 +610,21 @@ uint32_t MillisecLowLoop(uint32_t tick) //call all modules Millisec functions //test dancers and speed encoders //check all callback units (state machine waiting for completion of a change) - bool Ten_msTick, Fifty_msTick, Hundred_msTick , m20msecTick,m70msecTick,m90msecTick, Onesecond_Tick,Tensecond_Tick,OneMinute_Tick,TenMinutes_Tick,OneHourTick,Gradient_Tick; - bool O700Millisecond_Tick,O200Millisecond_Tick,O400Millisecond_Tick,O500Millisecond_Tick,O600Millisecond_Tick; + bool Ten_msTick, Fifty_msTick, Hundred_msTick , m20msecTick,m90msecTick, Onesecond_Tick,Tensecond_Tick,OneMinute_Tick,TenMinutes_Tick,OneHourTick,Gradient_Tick; + bool O700Millisecond_Tick,O200Millisecond_Tick,O400Millisecond_Tick,O500Millisecond_Tick,O600Millisecond_Tick,O800Millisecond_Tick; //bool O100Millisecond_Tick,O200Millisecond_Tick,O400Millisecond_Tick,O500Millisecond_Tick,O600Millisecond_Tick,O800Millisecond_Tick,O900Millisecond_Tick; Ten_msTick = (tick%eTenMillisecond == 0) ?true:false; Fifty_msTick = (tick%eHundredMillisecond == 40) ?true:false; //eFiftyMillisecond Hundred_msTick = (tick%eHundredMillisecond == 0) ?true:false; m20msecTick = (tick%eHundredMillisecond == 20) ?true:false; - m70msecTick = (tick%eHundredMillisecond == 70) ?true:false; + //m70msecTick = (tick%eHundredMillisecond == 70) ?true:false; m90msecTick = (tick%eHundredMillisecond == 90) ?true:false; O700Millisecond_Tick = (tick%eOneSecond == 700) ?true:false; O200Millisecond_Tick = (tick%eOneSecond == 200) ?true:false; O400Millisecond_Tick = (tick%eOneSecond == 400) ?true:false; O500Millisecond_Tick = (tick%eOneSecond == 500) ?true:false; O600Millisecond_Tick = (tick%eOneSecond == 600) ?true:false; - //O800Millisecond_Tick = (tick%eOneSecond == 800) ?true:false; + O800Millisecond_Tick = (tick%eOneSecond == 800) ?true:false; //O900Millisecond_Tick = (tick%eOneSecond == 900) ?true:false; Gradient_Tick = (tick%400 == 0) ?true:false; Onesecond_Tick = (tick%eOneSecond == 0) ?true:false; @@ -660,10 +660,10 @@ uint32_t MillisecLowLoop(uint32_t tick) Trigger_PT100_Read();//call every 50mSec (minimum delay 30mSec) //Set_HeadCard_PT100();//call every 50mSec (minimum delay 30mSec) } - if(m70msecTick) + /*if(m70msecTick) { AlarmHandling_ControlTrigger(0,0); - } + }*/ if (m90msecTick) { for (Sensor_i = StartPT100;Sensor_i < MAX_HEAD_CARD_TEMP_SENS_ID;Sensor_i++) @@ -717,14 +717,11 @@ uint32_t MillisecLowLoop(uint32_t tick) } if (Gradient_Tick) DispensersCollectionCall(); - if (O700Millisecond_Tick) - { - Trigger_Heater_Current_Read(); - } if (O200Millisecond_Tick) { Trigger_WHS_MAX11614_Read_allADC(); FPGA_GetAllDispensersValveBusyOCD(); + Read_Dryer_Fan_Tacho(); temp = Read_Fans_Tacho(); DrawerFansStatus = temp & 0x1F; SystemFansStatus = temp & 0xE0; @@ -755,6 +752,14 @@ uint32_t MillisecLowLoop(uint32_t tick) } } } + if (O700Millisecond_Tick) + { + Trigger_Heater_Current_Read(); + } + if (O800Millisecond_Tick) + { + AlarmHandling_ControlTrigger(0,0); + } if (Onesecond_Tick) { //char Lenstr[160]; diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c index eb855fd4a..b159897aa 100644 --- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c +++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c @@ -923,8 +923,8 @@ void DiagnosticOneSecCollection(void) tempFlow = HeadFlowMeter; }*/ WasteLevel = GetWHSWasteTankLevelMiliLiter()/1000;//change from ml to litter - static double InitCounter = 60.0; - if ((GetMachineState()<MACHINE_STATE_NO_PROCESS_PARAMS) &&(GetMachineState()>=MACHINE_STATE_WAIT_FOR_COOLER)) + static double InitCounter = 85.0; + if (GetMachineState()<=MACHINE_STATE_WAIT_FOR_COOLER) { InitCounter-=1.0; if(InitCounter<0)InitCounter = 0; diff --git a/Software/Embedded_SW/Embedded/Modules/General/MachineStatus.c b/Software/Embedded_SW/Embedded/Modules/General/MachineStatus.c index a0b1b30c2..5c41d03f3 100644 --- a/Software/Embedded_SW/Embedded/Modules/General/MachineStatus.c +++ b/Software/Embedded_SW/Embedded/Modules/General/MachineStatus.c @@ -157,6 +157,7 @@ int MachineUpdateResponseFunc(void) else return ERROR; + // Report("Sending machine state",__FILE__,__LINE__,(int)MachineStatus.state,RpWarning,(int)MachineStatus.overalltemperature,0); responseContainer = /*MachineUpdate*/createContainer(MESSAGE_TYPE__StartMachineStatusUpdateResponse, MachineUpdateToken, false, &response, &start_machine_status_update_response__pack, &start_machine_status_update_response__get_packed_size); responseContainer.has_continuous = true; diff --git a/Software/Embedded_SW/Embedded/Modules/General/process.c b/Software/Embedded_SW/Embedded/Modules/General/process.c index 4538d0336..872f772e2 100644 --- a/Software/Embedded_SW/Embedded/Modules/General/process.c +++ b/Software/Embedded_SW/Embedded/Modules/General/process.c @@ -41,8 +41,7 @@ double dryerairflow = 5.0; double pressurebuildup = 0; double dryerzone1temp = 0; int32_t tableindex = 0; -double headBlowersFlow[2] = {1.0,1.0}; -double ArcCleaningMotorSpeed = 0.0; +double headBlowersFlow[2] = {1.5,1.5}; double dryerbufferMeters = 0; double dryerbufferCentimeters = 0; @@ -134,6 +133,10 @@ uint32_t HandleProcessParameters(ProcessParameters* ProcessParams,bool saveData) { if (ProcessParams->has_headairflow == false) ProcessParams->headairflow = headairflow; + if (ProcessParams->has_lblowerflow == false) + ProcessParams->lblowerflow = headBlowersFlow[HEAD_FAN_LEFT]; + if (ProcessParams->has_rblowerflow == false) + ProcessParams->rblowerflow = headBlowersFlow[HEAD_FAN_RIGHT]; if (ProcessParams->has_feedertension == false) ProcessParams->feedertension = feedertension; if (ProcessParams->has_windertension == false) @@ -159,7 +162,6 @@ uint32_t HandleProcessParameters(ProcessParameters* ProcessParams,bool saveData) dryerairflow = ProcessParams->dryerairflow; pressurebuildup = ProcessParams->pressurebuildup; dryerzone1temp = ProcessParams->dryerzone1temp; - ArcCleaningMotorSpeed = ProcessParams->archeadcleaningmotorspeed; if (MachineReadyForHeating == false) { diff --git a/Software/Embedded_SW/Embedded/Modules/General/process.h b/Software/Embedded_SW/Embedded/Modules/General/process.h index 4a1583aa8..f7f16d11e 100644 --- a/Software/Embedded_SW/Embedded/Modules/General/process.h +++ b/Software/Embedded_SW/Embedded/Modules/General/process.h @@ -20,7 +20,6 @@ extern double dryerairflow; extern double pressurebuildup; extern double dryerzone1temp; extern double headBlowersFlow[2]; -extern double ArcCleaningMotorSpeed; extern int32_t tableindex; diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_Blowers.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_Blowers.c index 4a43485cd..59a0aee51 100644 --- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_Blowers.c +++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_Blowers.c @@ -51,10 +51,11 @@ #define ARC_ALARM_LIMIT 3 #define PRESSURE_SENSOR_CP 0.269 +#define PRESSURE_SENSOR_B 0.45 extern uint16_t Head_Fan_Tach[2]; extern uint8_t Head_Fan_PWM_Command[2]; -double PressureSensorV0[2] = {0.0, 0.0}; +uint32_t PressureSensorV0[2] = {0, 0}; uint8_t HeadBlowersCloseLoopTime[2] = {2, 2}; uint8_t HeadBlowersEnable = 1; uint8_t BlowerIdToSensorId[2] = {HEAD_PT100_ZONE_5_0X84_0, HEAD_PT100_ZONE_7_0X86_0}; //HEAD_FAN_RIGHT, HEAD_FAN_LEFT @@ -315,14 +316,15 @@ void HeadBlowersControlLoop () int blowerId; static int count[2] = {0, 0}; - ArcHeadAlarms(); - if (GetMachineState() < MACHINE_STATE_WAIT_FOR_COOLER) return; //do not start before controller is initialized and running if (!HeadBlowersEnable) { return; } + + ArcHeadAlarms(); + for (blowerId = 0; blowerId <= 1; blowerId++) { if (count[blowerId] == HeadBlowersCloseLoopTime[blowerId]) { count[blowerId] = 0; @@ -343,11 +345,12 @@ void HeadBlowersCfg() } } -double PressureSensorInit(int blowerId) +uint32_t PressureSensorInit(int blowerId) { - PressureSensorV0[blowerId] = MillisecGetTemperatures(BlowerIdToSensorId[blowerId]); - PressureSensorV0[blowerId] /= 10; - return PressureSensorV0[blowerId]; + uint32_t V0; + V0 = MillisecGetTemperatures(BlowerIdToSensorId[blowerId]); + V0 /= 10; + return V0; } int HeadBlowersGetRPM(uint8_t blowerId) @@ -368,15 +371,16 @@ int HeadBlowersGetPWM(uint8_t blowerId) double PressureSensorGetPressure(uint8_t SensorId) { - double V0, Vm, Q, Cp; + double V0, Vm, Q; int FanId; - Cp = PRESSURE_SENSOR_CP; FanId = HeadBlowerSensorIdToFanId(SensorId); V0 = PressureSensorV0[FanId]; Vm = (double)(MillisecGetTemperatures(SensorId)); Vm /= 10.0; - Q = sqrt(Vm - V0 + 22) * Cp; + if ((Vm - V0 + 22)<0) + return 0.0; + Q = sqrt(Vm - V0 + 22) * PRESSURE_SENSOR_CP - PRESSURE_SENSOR_B; return Q; } diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h index 2c675606b..a23abf559 100644 --- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h +++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h @@ -46,7 +46,7 @@ void HeatersControlStop(void); uint32_t Heaters_Init(void); double PressureSensorGetPressure(uint8_t SensorId); int HeadBlowersGetRPM(uint8_t fanId); -double PressureSensorInit(); +uint32_t PressureSensorInit(); void HeadBlowersInit(); uint32_t HeadBlowerPidRequestMessage(void* request, int BlowerId); void HeadBlowersCfg(); diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c index e702d7072..84013add6 100644 --- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c +++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c @@ -560,8 +560,8 @@ uint32_t HeatersSingleHeaterEnd(int HeaterId) } DeActivateHeater(HEATER_TYPE__DryerMainHeater); DeActivateHeater(HEATER_TYPE__DryerSecondaryHeater); - //Disable_Reading_Heaters_Current(HeaterId2CurrentId[HEATER_TYPE__DryerMainHeater]); - //Disable_Reading_Heaters_Current(HeaterId2CurrentId[HEATER_TYPE__DryerSecondaryHeater]); + Disable_Reading_Heaters_Current(HeaterId2CurrentId[HEATER_TYPE__DryerMainHeater]); + Disable_Reading_Heaters_Current(HeaterId2CurrentId[HEATER_TYPE__DryerSecondaryHeater]); HeaterPIDConfig[HeaterId].m_SetParam = 0; HeaterCmd[HeaterId].targettemperatue = 0; HeaterReady[HeaterId] = true; @@ -1449,8 +1449,8 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue) } }*/ HeaterReady[index] = true; - //Disable_Reading_Heaters_Current(HeaterId2CurrentId[HEATER_TYPE__DryerMainHeater]); - //Disable_Reading_Heaters_Current(HeaterId2CurrentId[HEATER_TYPE__DryerSecondaryHeater]); + Disable_Reading_Heaters_Current(HeaterId2CurrentId[HEATER_TYPE__DryerMainHeater]); + Disable_Reading_Heaters_Current(HeaterId2CurrentId[HEATER_TYPE__DryerSecondaryHeater]); } return OK; diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h b/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h index 1c17c4f6b..d86d7ab2d 100644 --- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h +++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h @@ -16,6 +16,7 @@ extern uint32_t InitialDispenserSpeed; extern double InitialDispenserPressure; extern uint32_t InitialDispenserTimeout; +extern double ArcCleaningMotorSpeed; extern uint32_t DispenserIdToMotorId[MAX_SYSTEM_DISPENSERS]; diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_Cleaning.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_Cleaning.c index 0e28134c4..0ae017c13 100644 --- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_Cleaning.c +++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_Cleaning.c @@ -19,7 +19,7 @@ #include "drivers/motors/motor.h" #include "drivers/valves/valve.h" #include "Drivers/I2C_Communication/Head_Card/IO_Ports/Head_IO.h" - +double ArcCleaningMotorSpeed = 750; int SaveLeftRockerSpeed = 50, SaveRightRockerSpeed = 50; typedef enum { diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c index d2fd74256..fcd1c05a2 100644 --- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c +++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c @@ -591,7 +591,10 @@ bool AdjustDispenserSpeedToPressure(int DispenserId, double RefMaxPressure,doubl { DispenserTotalPrepareSteps[i]+=(CurrentDispenserSpeed[i]*PRESSURE_READ_TIME_GAP/eOneSecond); HW_Motor_Id = DispenserIdToMotorId[i]; - + if ((DispenserTotalPrepareSteps[i]>TargetNumberOfStepsPreRun)&&(DispenserTotalPrepareSteps[i]<(TargetNumberOfStepsPreRun+InitialDispenserSpeed))) + { + ReportWithPackageFilter(IDSFilter,"IDS dispenser pre-run ended",__FILE__,i,(int)DispenserTotalPrepareSteps[i],RpWarning,(int)(pressure*100),0); + } if (DispenserTotalPrepareSteps[i]<TargetNumberOfStepsPreRun) { AdjustDispenserSpeedToPressure(i,MaximalPressurePreRun,pressure); @@ -635,8 +638,11 @@ bool AdjustDispenserSpeedToPressure(int DispenserId, double RefMaxPressure,doubl } if (pressureReady == true) { + usnprintf(IdMessage, 80,"pressureReady = true %d K %d,C %d,M %d,Y %d,TI %d",(int)(DispenserPreparePressure*100),(int)(GetDispenserPressure(0)*100),(int)(GetDispenserPressure(1)*100) + ,(int)(GetDispenserPressure(2)*100),(int)(GetDispenserPressure(3)*100),(int)(GetDispenserPressure(4)*100)); + ReportWithPackageFilter(IDSFilter,IdMessage, __FILE__, __LINE__, DispenserBuildTimeCounter, RpWarning, NumofReadyDispensers, 0); DispenserBuildTimeCounter = 0; - ReportWithPackageFilter(IDSFilter,"pressureReady = true",__FILE__,DispenserBuildTimeCounter,NumofReadyDispensers,RpWarning,(int)(DispenserPreparePressure*100),0); + //ReportWithPackageFilter(IDSFilter,"pressureReady = true",__FILE__,DispenserBuildTimeCounter,NumofReadyDispensers,RpWarning,(int)(DispenserPreparePressure*100),0); } if (DispenserBuildTimeCounter >= DispenserPrepareTimeout) { @@ -730,7 +736,7 @@ bool AdjustDispenserSpeedToPressure(int DispenserId, double RefMaxPressure,doubl } } }//for - usnprintf(IdMessage, 80,"WFCF %d D1 %d,D2 %d,D3 %d,D4 %d,D5 %d",WFCF,CurrentDispenserSpeed[0], + usnprintf(IdMessage, 80,"WFCF %d K %d,C %d,M %d,Y %d,TI %d",WFCF,CurrentDispenserSpeed[0], CurrentDispenserSpeed[1],CurrentDispenserSpeed[2],CurrentDispenserSpeed[3],CurrentDispenserSpeed[4]); ReportWithPackageFilter(IDSFilter,IdMessage, __FILE__, __LINE__, DispenserBuildTimeCounter, RpWarning, WFCF, 0); @@ -788,13 +794,15 @@ bool AdjustDispenserSpeedToPressure(int DispenserId, double RefMaxPressure,doubl JobEndSequence = false; if ((pressurebuildup>0.1)&&(pressurebuildup<4.5)) { - ReportWithPackageFilter(IDSFilter,"Setting pressure from RML feeder tension",__FILE__,__LINE__,(int)(pressurebuildup*100),RpWarning,(int)(DispenserPreparePressure*100),0); + ReportWithPackageFilter(IDSFilter,"Setting pressure from RML pressure buildup",__FILE__,__LINE__,(int)(pressurebuildup*100),RpWarning,(int)(DispenserPreparePressure*100),0); DispenserPreparePressure = pressurebuildup; } if (JobTicket->headcleaningparameters) { if (JobTicket->headcleaningparameters->has_cleanerflow) cleanerFlow = JobTicket->headcleaningparameters->cleanerflow; + if (JobTicket->headcleaningparameters->has_archeadcleaningmotorspeed) + ArcCleaningMotorSpeed = JobTicket->headcleaningparameters->archeadcleaningmotorspeed; } if ((cleanerFlow>200)&&(cleanerFlow<1150)) { @@ -1079,7 +1087,7 @@ bool AdjustDispenserSpeedToPressure(int DispenserId, double RefMaxPressure,doubl } } }//for - usnprintf(IdMessage, 80,"Presegment Prepare D1 %d,D2 %d,D3 %d,D4 %d,D5 %d",CurrentDispenserSpeed[0], + usnprintf(IdMessage, 80,"Presegment Prepare K %d,C %d,M %d,Y %d,TI %d",CurrentDispenserSpeed[0], CurrentDispenserSpeed[1],CurrentDispenserSpeed[2],CurrentDispenserSpeed[3],CurrentDispenserSpeed[4]); ReportWithPackageFilter(IDSFilter,IdMessage, __FILE__, __LINE__, Dispenser_i, RpWarning, segmentfirst_speed, 0); @@ -1281,7 +1289,7 @@ uint32_t IDS_Cleaning_Stop_Cleaning_Solution (callback_fptr callback); //SendJobProgress(0.0, 0, false, IdsMessage);*/ } }//for - usnprintf(IdMessage, 80,"Presegment WFCF %d D1 %d,D2 %d,D3 %d,D4 %d,D5 %d",WFCF,CurrentDispenserSpeed[0], + usnprintf(IdMessage, 80,"Presegment WFCF %d K %d,C %d,M %d,Y %d,TI %d",WFCF,CurrentDispenserSpeed[0], CurrentDispenserSpeed[1],CurrentDispenserSpeed[2],CurrentDispenserSpeed[3],CurrentDispenserSpeed[4]); ReportWithPackageFilter(IDSFilter,IdMessage, __FILE__, __LINE__, FileBrushStop->index, RpWarning, lInterSegmentLength, 0); } @@ -1608,9 +1616,9 @@ void IDS_StartBrushStop(int n_dispensers, JobDispenser** Dispensers) } } //for } - usnprintf(IdMessage, 80,"IDS_StartBrushStop %d D1 %d,D2 %d,D3 %d,D4 %d,D5 %d",WFCF,CurrentDispenserSpeed[0], + usnprintf(IdMessage, 80,"IDS_StartBrushStop %d/%d K %d,C %d,M %d,Y %d,TI %d",FileBrushStop->index,SegmentNumOfBrushStops,CurrentDispenserSpeed[0], CurrentDispenserSpeed[1],CurrentDispenserSpeed[2],CurrentDispenserSpeed[3],CurrentDispenserSpeed[4]); - ReportWithPackageFilter(IDSFilter,IdMessage, __FILE__, __LINE__, FileBrushStop->index, RpWarning,n_dispensers, 0); + ReportWithPackageFilter(IDSFilter,IdMessage, __FILE__, SegmentNumOfBrushStops, FileBrushStop->index, RpWarning,(int)FileBrushStop->offsetmeters, 0); } uint32_t IDSBrushStopRestartCallback(uint32_t IfIndex, uint32_t readValue) @@ -1676,7 +1684,7 @@ uint32_t IDSBrushStopRestartCallback(uint32_t IfIndex, uint32_t readValue) IDS_StartBrushStop(n_dispensers, Dispensers); } JobBrushStopId++; - ReportWithPackageFilter(IDSFilter,"brushstop",__FILE__,__LINE__,(int)JobBrushStopId,RpMessage,(int)SegmentNumOfBrushStops,0); + //ReportWithPackageFilter(IDSFilter,"brushstop",__FILE__,__LINE__,(int)JobBrushStopId,RpMessage,(int)SegmentNumOfBrushStops,0); if (JobBrushStopId >= SegmentNumOfBrushStops) { ReportWithPackageFilter(IDSFilter,"last brushstop",__FILE__,__LINE__,(int)JobBrushStopId,RpWarning,(int)SegmentNumOfBrushStops,0); diff --git a/Software/Embedded_SW/Embedded/Modules/IFS/ifs.c b/Software/Embedded_SW/Embedded/Modules/IFS/ifs.c index b2498ee7f..329357ed4 100644 --- a/Software/Embedded_SW/Embedded/Modules/IFS/ifs.c +++ b/Software/Embedded_SW/Embedded/Modules/IFS/ifs.c @@ -335,7 +335,7 @@ void midTankStateMachine(void) if (midTankCartColor == MIDTANK_8) { - CartridgeInkTimeout = CARTRIDGE_INK_TIMEOUT*4; + CartridgeInkTimeout = CARTRIDGE_INK_TIMEOUT*10; CartridgeCheckTime = FIVE_SECONDS*3; } // set valve selection diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c index b9b916eb6..c6cfbb1d1 100644 --- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c +++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c @@ -1233,6 +1233,27 @@ void Stub_ProgressRequest(MessageContainer* requestContainer) response.has_progress = true; } else + if(request->amount == 0xB23) //Set loading arm cycles + { + REPORT_MSG(request->delay,"Control dryer fan tacho"); + if (request->delay>0) + Control_Dryer_Fan(START,request->delay);//use START or STOP, 0 - 100%(); + else + Control_Dryer_Fan(STOP,0);//use START or STOP, 0 - 100%(); + Task_sleep(1000); + + response.progress = (double)Get_Dryer_Fan_Tacho(); + response.has_progress = true; + } + else + if(request->amount == 0xB24) //Set loading arm cycles + { + REPORT_MSG(request->delay,"AttemptThreadJoggingFunc"); + AttemptThreadJoggingFunc(NULL); + response.progress = 0xb24; + response.has_progress = true; + } + else if(request->amount == 0xC3) //suspend I2C task { if (request->delay == 0) diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c index 63072e4d8..cdb726b5e 100644 --- a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c +++ b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c @@ -49,6 +49,7 @@ #include "PMR/ThreadLoading/TryThreadLoadingResponse.pb-c.h" #include "PMR/ThreadLoading/StopThreadLoadingRequest.pb-c.h" #include "PMR/ThreadLoading/StopThreadLoadingResponse.pb-c.h" +#include "PMR/ThreadLoading/AttemptThreadJoggingResponse.pb-c.h" //#include <stdint.h> //#include <stdbool.h> @@ -1597,3 +1598,52 @@ uint32_t StopThreadLoadingFunc(MessageContainer* requestContainer) return OK; } +uint8_t attemptJogCounter = 0; +#define ATTEMPT_JOG_TIMEOUT 18 +char AttemptJoggingToken[36+1] = {0}; + +uint32_t AttemptThreadJoggingCallback(uint32_t index, uint32_t ReadValue) +{ + AttemptThreadJoggingResponse response = ATTEMPT_THREAD_JOGGING_RESPONSE__INIT; + MessageContainer responseContainer; + + attemptJogCounter++; + Report("AttemptThreadJoggingCallback",__FILE__,attemptJogCounter,JobEndReason,RpWarning,(int)JobIsActive(),0); + if (attemptJogCounter<ATTEMPT_JOG_TIMEOUT) + { + if (JobIsActive() == true)//jog still preparing/running + return OK; + } + if (JobEndReason == JOB_OK) + ThreadAbortJoggingFunc(); + else + { + responseContainer.has_error = true; + responseContainer.error = getJobError_to_ErrorCode(JobEndReason); + } + SafeRemoveControlCallback(LoadingControlId, AttemptThreadJoggingCallback ); + LoadingControlId = 0xFF; + + if (AttemptJoggingToken[0]) + { + responseContainer = createContainer(MESSAGE_TYPE__AttemptThreadJoggingResponse, AttemptJoggingToken, true, &response, &attempt_thread_jogging_response__pack, &attempt_thread_jogging_response__get_packed_size); + responseContainer.continuous = false; + uint8_t* container_buffer = my_malloc(message_container__get_packed_size(&responseContainer)); + size_t container_size = message_container__pack(&responseContainer, container_buffer); + my_free(responseContainer.data.data); + SendChars((char*)container_buffer, container_size); + } + return OK; + +} +uint32_t AttemptThreadJoggingFunc(MessageContainer* requestContainer) +{ + attemptJogCounter = 0; + if(requestContainer) + ustrncpy (AttemptJoggingToken, requestContainer->token,36); + Report("AttemptThreadJoggingFunc",__FILE__,__LINE__,0xFF,RpWarning,(int)ATTEMPT_JOG_TIMEOUT,0); + LoadingControlId = AddControlCallback("Load jog",AttemptThreadJoggingCallback, eOneSecond,TemplateDataReadCBFunction,0,0,0); + ThreadJoggingFunc(30); + return OK; +} + diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c index a6cb25c45..8ecb3f404 100644 --- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c +++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c @@ -141,6 +141,25 @@ uint32_t InternalWindingConfigMessage(JobSpool* request) * report ready to the job STM */ int Screw_wait_counter; +uint32_t Winder_Check_Cone(void) +{ + if (FPGA_Read_limit_Switches(GPI_SW_SPOOL_EXISTS)==LIMIT) + { + REPORT_MSG(LIMIT, "No cone in winder"); + if (Is_PP_Machine()) + { + if (IgnoreConeMissing == false) + { + //JobEndReason = JOB_THREAD_BREAK; + usnprintf(AlarmReasonStr, 100, "No cone in winder"); + //PrepareReady(Module_Winder,ModuleFail); + AlarmHandlingSetAlarm(EVENT_TYPE__WINDER_CONE_DOES_NOT_EXIST,true); + return JOB_THREAD_BREAK; + } + } + } + return JOB_OK; +} uint32_t Winder_Prepare(void *JobDetails) { JobTicket* JobTicket = JobDetails; @@ -159,7 +178,7 @@ uint32_t Winder_Prepare(void *JobDetails) * report ready to the job STM */ - if (FPGA_Read_limit_Switches(GPI_SW_SPOOL_EXISTS)==LIMIT) + /*if (FPGA_Read_limit_Switches(GPI_SW_SPOOL_EXISTS)==LIMIT) { REPORT_MSG(LIMIT, "No cone in winder"); if (Is_PP_Machine()) @@ -173,7 +192,7 @@ uint32_t Winder_Prepare(void *JobDetails) return ERROR; } } - } + }*/ #ifdef READ_SCREW_ENCODER ScrewLocationRun[0] = 0; diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h index 0861b677b..07ecf5d0b 100644 --- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h +++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h @@ -53,6 +53,7 @@ uint32_t LoadDancerConfigMessage(void); extern float NumberOfRotationPerPassage; //debug for rotation per passage trials uint32_t Winder_Init(void); +uint32_t Winder_Check_Cone(void); uint32_t Winder_Prepare(void *JobDetails); uint32_t Winder_Presegment(void *JobDetails, uint32_t SegmentId); uint32_t WinderDistanceToSpoolState(void ); @@ -88,6 +89,8 @@ uint32_t StartThreadLoadingFunc(MessageContainer* requestContainer); uint32_t ContinueThreadLoadingFunc(MessageContainer* requestContainer); uint32_t StopThreadLoadingFunc(MessageContainer* requestContainer); uint32_t TryThreadLoadingFunc(MessageContainer* requestContainer); +uint32_t AttemptThreadJoggingFunc(MessageContainer* requestContainer); + void ThreadCheckArcHeadCovers(void); uint32_t Thread_Load_End(void); uint32_t ThreadLoadingRestartReport(void); //sending after a failure in the finalizing stage diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c index bc4e6cb8f..8d41f3b9a 100644 --- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c +++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c @@ -337,7 +337,7 @@ uint32_t PoolerThreadLengthCBFunction(uint32_t IfIndex, uint32_t ReadValue) }**/ //} -#ifdef BTSR_NO_TFU +#ifdef BTSR_NO_PULLER_TFU if (CurrentControlledSpeed[WINDER_MOTOR]>100) length = dyeingspeed/10; #endif @@ -917,7 +917,7 @@ uint32_t Release_Right_TFU_TensionCallback(uint32_t deviceID, uint32_t BusyFlag) uint32_t Release_Right_TFU_Tension() { uint32_t status = OK; -#ifndef BTSR_NO_TFU +#ifndef BTSR_NO_FEEDER_TFU if (RTFU_Up == true) { Report("Release_Right_TFU_Tension",__FILE__,__LINE__,HARDWARE_MOTOR_TYPE__MOTO_RDANCER,RpMessage,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDANCER].pulseperround/4,0); @@ -931,7 +931,7 @@ int SecondFeederCorrection = 4; int PrepareWaitCount = 0; uint32_t Adjust_Right_TFU_Tension_2nd_Callback(uint32_t MotorId, uint32_t ReadValue) { -#ifndef BTSR_NO_TFU +#ifndef BTSR_NO_FEEDER_TFU MotorStop (HARDWARE_MOTOR_TYPE__MOTO_RDANCER,Soft_Stop); //per L6470 errata between mov and run commands Report("Adjust_Right_TFU_Tension_2ndCallback x more steps",__FILE__,__LINE__,MotorId,RpMessage,SecondFeederCorrection,0); if (JobIsActive()==false) @@ -955,7 +955,7 @@ uint32_t Adjust_Right_TFU_Tension_2nd_Callback(uint32_t MotorId, uint32_t ReadVa } uint32_t Adjust_Right_TFU_Tension_Callback(uint32_t MotorId, uint32_t ReadValue) { -#ifndef BTSR_NO_TFU +#ifndef BTSR_NO_FEEDER_TFU Report("Adjust_Right_TFU_Tension_Callback",__FILE__,__LINE__,MotorId,RpMessage,0,0); MotorMoveWithCallback(HARDWARE_MOTOR_TYPE__MOTO_RDANCER, 1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDANCER].directionthreadwize,SecondFeederCorrection* MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDANCER].microstep, Adjust_Right_TFU_Tension_2nd_Callback,1000); RTFU_Up = true; @@ -966,7 +966,7 @@ uint32_t Adjust_Right_TFU_Tension_Callback(uint32_t MotorId, uint32_t ReadValue) uint32_t Adjust_Right_TFU_Tension(double tension) { uint32_t status = OK; -#ifndef BTSR_NO_TFU +#ifndef BTSR_NO_FEEDER_TFU if (tension > 0.5) //0 = lower position, 1 = high position { if (FPGA_Read_limit_Switches(GPI_LS_RDANCER_UP) == NO_LIMIT) @@ -1093,11 +1093,13 @@ uint32_t ThreadPrepareState(void *JobDetails) IntersegmentLength = JobTicket->intersegmentlength; PrepareWaitCount = 0; -#ifndef BTSR_NO_TFU status = ThreadPrepare_Tension (HARDWARE_DANCER_TYPE__LeftDancer, windertension); ReportWithPackageFilter(ThreadFilter,"ThreadPrepare_Tension Winder",__FILE__,HARDWARE_DANCER_TYPE__LeftDancer,PrepareWaitCount,RpWarning,(int)windertension,0); +#ifndef BTSR_NO_PULLER_TFU status = ThreadPrepare_Tension (HARDWARE_DANCER_TYPE__MiddleDancer, pullertension); ReportWithPackageFilter(ThreadFilter,"ThreadPrepare_Tension Puller",__FILE__,HARDWARE_DANCER_TYPE__MiddleDancer,PrepareWaitCount,RpWarning,(int)pullertension,0); +#endif +#ifndef BTSR_NO_FEEDER_TFU status = ThreadPrepare_Tension (HARDWARE_DANCER_TYPE__RightDancer, feedertension); ReportWithPackageFilter(ThreadFilter,"ThreadPrepare_Tension Feeder",__FILE__,HARDWARE_DANCER_TYPE__RightDancer,PrepareWaitCount,RpWarning,(int)feedertension,0); #endif @@ -1219,7 +1221,7 @@ uint32_t ThreadPrepareState(void *JobDetails) ///////////////////////////////////////////////////// MotorSetDirection((TimerMotors_t)HW_Motor_Id,MotorsCfg[HW_Motor_Id].directionthreadwize); -#ifndef BTSR_NO_TFU +#ifndef BTSR_NO_FEEDER_TFU if (Motor_i == FEEDER_MOTOR) // dryer motor is speed controlled. later a speed sensor will be utilized, but for now it will not be controlled { ReportWithPackageFilter(ThreadFilter,"Feeder Control",__FILE__,Motor_i,MotorControlConfig[Motor_i].m_params.Kp,RpWarning,MotorControlConfig[Motor_i].m_params.Ki,0); @@ -1233,6 +1235,7 @@ uint32_t ThreadPrepareState(void *JobDetails) SpeedControlId = AddControlCallback(NULL,ThreadLengthCBFunction, eHundredMillisecond,MotorGetPositionFromFPGA,(IfTypeThread*0x100+Motor_i),ThreadMotorIdToMotorId[Motor_i],Motor_i); } #endif +#ifndef BTSR_NO_PULLER_TFU if (Motor_i == POOLER_MOTOR) // dryer motor is speed controlled. later a speed sensor will be utilized, but for now it will not be controlled { ReportWithPackageFilter(ThreadFilter,"Puller Control",__FILE__,Motor_i,MotorControlConfig[Motor_i].m_params.Kp,RpWarning,MotorControlConfig[Motor_i].m_params.Ki,0); @@ -1246,7 +1249,8 @@ uint32_t ThreadPrepareState(void *JobDetails) PoolerLengthCalculationMultiplier = (MotorsCfg[ThreadMotorIdToMotorId[Motor_i]].pulleyradius*2*PI)/(MotorsCfg[ThreadMotorIdToMotorId[Motor_i]].pulseperround*MotorsCfg[ThreadMotorIdToMotorId[Motor_i]].microstep); PoolerSpeedControlId = AddControlCallback(NULL,PoolerThreadLengthCBFunction, eHundredMillisecond,MotorGetPositionFromFPGA,(IfTypeThread*0x100+Motor_i),ThreadMotorIdToMotorId[Motor_i],Motor_i); } -#ifndef BTSR_NO_TFU +#endif +#ifndef BTSR_NO_FEEDER_TFU if (Motor_i == FEEDER_MOTOR) // dryer motor is speed controlled. later a speed sensor will be utilized, but for now it will not be controlled { if (ControlIdtoMotorId[Motor_i] != 0xFF) @@ -1261,6 +1265,8 @@ uint32_t ThreadPrepareState(void *JobDetails) //AddControlCallback(NULL,ThreadControlSpeedReadFunction, eHundredMillisecond,MotorGetSpeedFromFPGA,(IfTypeThread*0x100+Motor_i),ThreadMotorIdToMotorId[Motor_i],Motor_i); #endif } +#endif +#ifndef BTSR_NO_PULLER_TFU if (Motor_i == POOLER_MOTOR) // dryer motor is speed controlled. later a speed sensor will be utilized, but for now it will n//ot be controlled { if (ControlIdtoMotorId[Motor_i] != 0xFF) diff --git a/Software/Embedded_SW/Embedded/Modules/Waste/Waste_maint.c b/Software/Embedded_SW/Embedded/Modules/Waste/Waste_maint.c index 5471397aa..25fb8e962 100644 --- a/Software/Embedded_SW/Embedded/Modules/Waste/Waste_maint.c +++ b/Software/Embedded_SW/Embedded/Modules/Waste/Waste_maint.c @@ -608,6 +608,8 @@ uint32_t Waste_PrepareCallbak(uint32_t IfIndex, uint32_t ReadValue) { SafeRemoveControlCallback(WasteReadyControlId,Waste_PrepareCallbak); WasteReadyControlId = 0xFF; + JobEndReason = JOB_PRESSURE_ALARM; + usnprintf(AlarmReasonStr, 100, "Module waste prepare - air flow not stabilized"); Report("Module waste prepare failed!", __FILE__, __LINE__, headready, RpMessage, headready, 0); PrepareReady(Module_Waste,ModuleFail); } diff --git a/Software/Embedded_SW/Embedded/Software Release Notes.txt b/Software/Embedded_SW/Embedded/Software Release Notes.txt index 341cf3a48..4e1f7104f 100644 --- a/Software/Embedded_SW/Embedded/Software Release Notes.txt +++ b/Software/Embedded_SW/Embedded/Software Release Notes.txt @@ -1,3 +1,12 @@ +Embedded SW Release note - Version 1.5.1(4) - Pack 3 +============================================================= +fix tunnel pressure calculation +support standby request +waste prepare failure - fix report +fix fan alarms +improve event handling +fix StartPowerUpResponse handling + Embedded SW Release note - Version 1.5.1(3) - Pack 3 ============================================================= preparations for persistent alarms diff --git a/Software/Embedded_SW/Embedded/StateMachines/Initialization/InitSequence.c b/Software/Embedded_SW/Embedded/StateMachines/Initialization/InitSequence.c index 0c007f755..d5e125337 100644 --- a/Software/Embedded_SW/Embedded/StateMachines/Initialization/InitSequence.c +++ b/Software/Embedded_SW/Embedded/StateMachines/Initialization/InitSequence.c @@ -83,6 +83,7 @@ uint32_t InitSequenceMachineReadyToDye(void); uint32_t InitSequenceStateMachine( INIT_SEQUENCE_STAGES_ENUM ReadValue); uint32_t PowerUpUpdate(MACHINE_STATE_STAGES_ENUM stage); int InitFailures = 0; +extern uint32_t PressureSensorV0[2]; MACHINE_STATE_STAGES_ENUM GetMachineState(void) { @@ -90,8 +91,11 @@ MACHINE_STATE_STAGES_ENUM GetMachineState(void) } void SetMachineState(MACHINE_STATE_STAGES_ENUM NewState) { - MachineStateDetail = NewState; - PowerUpUpdate(NewState); + if (MachineStateDetail != NewState) + { + MachineStateDetail = NewState; + PowerUpUpdate(NewState); + } } void StopInitSequence(void) { @@ -145,7 +149,7 @@ uint32_t InitScheduler(uint32_t IfIndex, uint32_t BusyFlag) StoredInitStages = InitStages; InitSequenceStateMachine(InitStages); } - PowerUpUpdate(MachineStateDetail); + //PowerUpUpdate(MachineStateDetail); return OK; } /*******************************************************************************************************/ @@ -230,12 +234,13 @@ uint32_t InitSequenceMidTankCallBackFunction(uint32_t IfIndex, uint32_t BusyFlag } uint32_t InitSequenceBlowerCallBackFunction(uint32_t IfIndex, uint32_t BusyFlag) { - double V0[2] = {0.0, 0.0}; if (SafeRemoveControlCallback(HWControlId, InitSequenceBlowerCallBackFunction )==OK) HWControlId = 0xFF; else Report("Remove control callback failed",__FILE__,__LINE__,(int)HWControlId,RpWarning,(int)InitSequenceBlowerCallBackFunction,0); + + Turn_the_Blower_On();//Turn on with the Default_Voltage if (BlowerCfg.heatingvoltage) Control_Voltage_To_Blower(BlowerCfg.heatingvoltage); @@ -244,35 +249,10 @@ uint32_t InitSequenceBlowerCallBackFunction(uint32_t IfIndex, uint32_t BusyFlag) WHS_enable_control_loop(true); WHS_Set_SetPoint_Q_value(headairflow); - AlarmHandlingSetAlarm (EVENT_TYPE__MACHINE_STATE_INITIAL_BLOWER_FAILED,OFF); //handle alarm detection and operation + //AlarmHandlingSetAlarm (EVENT_TYPE__MACHINE_STATE_INITIAL_BLOWER_FAILED,OFF); //handle alarm detection and operation waste_seq_step1();// include 1Sec delay <- to open !!!! - if (Head_Type == HEAD_TYPE_ARC) { - if (ResetReason & SYSCTL_CAUSE_POR) { - V0[0] = PressureSensorInit(0); - V0[1] = PressureSensorInit(1); - ReportWithPackageFilter(InitFilter,"read pressure sensor v0[0],v0[1]", __FILE__,__LINE__, (int)V0[0], RpMessage, (int)V0[1], 0); - if (V0[0] > 1000) { - MCU_E2PromProgram(EEPROM_ORIFICE1_ZERO_VALUE, V0[0]); - ReportWithPackageFilter(InitFilter,"store pressure sensor v0[0]", __FILE__,__LINE__, (int)V0[0], RpMessage, 0, 0); - } else { - MCU_E2PromRead(EEPROM_ORIFICE1_ZERO_VALUE, &V0[0]); - ReportWithPackageFilter(InitFilter,"load from EEPROM", __FILE__,__LINE__, (int)V0[0], RpMessage, 0, 0); - } - if (V0[1] > 1000) { - MCU_E2PromProgram(EEPROM_ORIFICE1_ZERO_VALUE, V0[1]); - ReportWithPackageFilter(InitFilter,"store pressure sensor v0[1]", __FILE__,__LINE__, (int)V0[1], RpMessage, 0, 0); - } else { - MCU_E2PromRead(EEPROM_ORIFICE1_ZERO_VALUE, &V0[1]); - ReportWithPackageFilter(InitFilter,"load from EEPROM", __FILE__,__LINE__, (int)V0[1], RpMessage, 0, 0); - } - } else { - MCU_E2PromRead(EEPROM_ORIFICE1_ZERO_VALUE, &V0[0]); - MCU_E2PromRead(EEPROM_ORIFICE1_ZERO_VALUE, &V0[1]); - ReportWithPackageFilter(InitFilter,"load initial values from EEPROM", __FILE__,__LINE__, (int)V0[0], RpMessage, (int)V0[1], 0); - } - } Safety_Init(); InitStages++; @@ -433,70 +413,109 @@ uint32_t InitSequencePowerManagementInit(void) // InitStages++; return OK; } -uint32_t InitSequenceInitialBlowerActivation(void) +uint32_t InitSequenceWHSAirFlowCalibration(void) { - SetMachineState(MACHINE_STATE_INITIAL_BLOWER_ACTIVATION); int i,total1=0,total2=0,total3=0; uint32_t ZeroValue; uint16_t value = 0; - //WHS_Start_Blower_Control_Closed_Loop(0.0); - WHS_enable_control_loop(false); - if (WHS_Type == WHS_TYPE_NEW) + + if (ResetReason & SYSCTL_CAUSE_POR) { - if (ResetReason & SYSCTL_CAUSE_POR) + for (i=0;i<8;i++) { - Control_Voltage_To_Blower(1); //stop the blower - Task_sleep (1000); - for (i=0;i<8;i++) - { - Trigger_WHS_MAX11614_Read_allADC(); - Task_sleep (100); - get_orf_1(&value); - total1+=value; - get_orf_2(&value); - total2+=value; - get_orf_3(&value); - total3+=value; - ReportWithPackageFilter(InitFilter,"load initial orifice value", __FILE__,total1,total2, RpMessage, total3, 0); - Task_sleep(100); - } - total1/=8; - total2/=8; - total3/=8; - MCU_E2PromRead(EEPROM_ORIFICE1_ZERO_VALUE,&ZeroValue); - if ((total1>800)&&(total1<2000)) - { - MCU_E2PromProgram(EEPROM_ORIFICE1_ZERO_VALUE,total1); - } - else - total1 = ZeroValue; - ReportWithPackageFilter(InitFilter,"store initial orifice 1 value", __FILE__,EEPROM_ORIFICE1_ZERO_VALUE,total1, RpMessage, ZeroValue, 0); - MCU_E2PromRead(EEPROM_ORIFICE3_ZERO_VALUE,&ZeroValue); - if ((total3>1000)&&(total3<1500)) - { - MCU_E2PromProgram(EEPROM_ORIFICE3_ZERO_VALUE,total3); - } - else - total3 = ZeroValue; - ReportWithPackageFilter(InitFilter,"store initial orifice 3 value", __FILE__,EEPROM_ORIFICE3_ZERO_VALUE,total3, RpMessage, ZeroValue, 0); - WHS_MAX11614_Load_OrificeZeroValue(total1,total2,total3); + Trigger_WHS_MAX11614_Read_allADC(); + Task_sleep (100); + get_orf_1(&value); + total1+=value; + get_orf_2(&value); + total2+=value; + get_orf_3(&value); + total3+=value; + ReportWithPackageFilter(InitFilter,"load initial orifice value", __FILE__,total1,total2, RpMessage, total3, 0); + Task_sleep(100); + } + total1/=8; + total2/=8; + total3/=8; + MCU_E2PromRead(EEPROM_ORIFICE1_ZERO_VALUE,&ZeroValue); + if ((total1>800)&&(total1<2000)) + { + MCU_E2PromProgram(EEPROM_ORIFICE1_ZERO_VALUE,total1); } else + total1 = ZeroValue; + ReportWithPackageFilter(InitFilter,"store initial orifice 1 value", __FILE__,EEPROM_ORIFICE1_ZERO_VALUE,total1, RpMessage, ZeroValue, 0); + MCU_E2PromRead(EEPROM_ORIFICE3_ZERO_VALUE,&ZeroValue); + if ((total3>1000)&&(total3<1500)) { - MCU_E2PromRead(EEPROM_ORIFICE1_ZERO_VALUE,&total1); - MCU_E2PromRead(EEPROM_ORIFICE3_ZERO_VALUE,&total3); - ReportWithPackageFilter(InitFilter,"load initial values from EEPROM", __FILE__,0,total3, RpMessage, total1, 0); - WHS_MAX11614_Load_OrificeZeroValue(total1,total1,total3); + MCU_E2PromProgram(EEPROM_ORIFICE3_ZERO_VALUE,total3); } + else + total3 = ZeroValue; + ReportWithPackageFilter(InitFilter,"store initial orifice 3 value", __FILE__,EEPROM_ORIFICE3_ZERO_VALUE,total3, RpMessage, ZeroValue, 0); + WHS_MAX11614_Load_OrificeZeroValue(total1,total2,total3); + } + else + { + MCU_E2PromRead(EEPROM_ORIFICE1_ZERO_VALUE,&total1); + MCU_E2PromRead(EEPROM_ORIFICE3_ZERO_VALUE,&total3); + ReportWithPackageFilter(InitFilter,"load initial values from EEPROM", __FILE__,0,total3, RpMessage, total1, 0); + WHS_MAX11614_Load_OrificeZeroValue(total1,total1,total3); } + return OK; + +} +uint32_t InitSequenceArcAirflowCalibration(void) +{ + uint32_t V0[2] = {0, 0}; + if (ResetReason & SYSCTL_CAUSE_POR) { + V0[0] = PressureSensorInit(0); + V0[1] = PressureSensorInit(1); + ReportWithPackageFilter(InitFilter,"read pressure sensor v0[0],v0[1]", __FILE__,__LINE__, (int)V0[0], RpMessage, (int)V0[1], 0); + if (V0[0] > 1000) { + MCU_E2PromProgram(EEPROM_PRESSURE_SENSOR_V0_0, V0[0]); + ReportWithPackageFilter(InitFilter,"store pressure sensor v0[0]", __FILE__,__LINE__, (int)V0[0], RpMessage, 0, 0); + } else { + MCU_E2PromRead(EEPROM_PRESSURE_SENSOR_V0_0, &V0[0]); + ReportWithPackageFilter(InitFilter,"load from EEPROM", __FILE__,__LINE__, (int)V0[0], RpMessage, 0, 0); + } + if (V0[1] > 1000) { + MCU_E2PromProgram(EEPROM_PRESSURE_SENSOR_V0_1, V0[1]); + ReportWithPackageFilter(InitFilter,"store pressure sensor v0[1]", __FILE__,__LINE__, (int)V0[1], RpMessage, 0, 0); + } else { + MCU_E2PromRead(EEPROM_PRESSURE_SENSOR_V0_1, &V0[1]); + ReportWithPackageFilter(InitFilter,"load from EEPROM", __FILE__,__LINE__, (int)V0[1], RpMessage, 0, 0); + } + } else { + MCU_E2PromRead(EEPROM_PRESSURE_SENSOR_V0_0, &V0[0]); + MCU_E2PromRead(EEPROM_PRESSURE_SENSOR_V0_1, &V0[1]); + ReportWithPackageFilter(InitFilter,"load initial values from EEPROM", __FILE__,__LINE__, (int)V0[0], RpMessage, (int)V0[1], 0); + } + PressureSensorV0[0] = V0[0]; + PressureSensorV0[1] = V0[1]; + return OK; +} +uint32_t InitSequenceInitialBlowerActivation(void) +{ + WHS_enable_control_loop(false); + Turn_the_Blower_On();//Turn on with the Default_Voltage + Control_Voltage_To_Blower(1); //stop the blower HeadBlowersInit(); + Task_sleep (1000); + + if (WHS_Type == WHS_TYPE_NEW) + { + InitSequenceWHSAirFlowCalibration(); + } + if (Head_Type == HEAD_TYPE_ARC) + { + InitSequenceArcAirflowCalibration(); + } + Voc_Sensor_Zero_Calibration(); + SetMachineState(MACHINE_STATE_INITIAL_BLOWER_ACTIVATION); - Turn_the_Blower_On();//Turn on with the Default_Voltage -// if (BlowerCfg.voltage) -// Control_Voltage_To_Blower(BlowerCfg.voltage); -// else - Control_Voltage_To_Blower(4200); + Control_Voltage_To_Blower(4200); Set_All_WHS_Fans(200); Report("AddControlCallback INIT",__FILE__,__LINE__,(int)HWControlId,RpWarning,(int)InitStages,0); HWControlId = AddControlCallback("Init Blower", InitSequenceBlowerCallBackFunction, 10* eOneSecond, TemplateDataReadCBFunction,0,0, 0 ); @@ -732,6 +751,14 @@ uint32_t InitSequenceStateMachine( INIT_SEQUENCE_STAGES_ENUM ReadValue) return OK; } char PowerUpToken[36+1] = {0}; +//char init_string[100]; +uint32_t PowerUpLoadControlId = 0xFF; +uint32_t PowerUpUpdateCallBackFunction(uint32_t IfIndex, uint32_t BusyFlag) +{ + + PowerUpUpdate(MachineStateDetail); + return OK; +} uint32_t PowerUpUpdate(MACHINE_STATE_STAGES_ENUM stage) { uint32_t status = NOT_SUPPORTED; @@ -746,7 +773,7 @@ uint32_t PowerUpUpdate(MACHINE_STATE_STAGES_ENUM stage) if (PowerUpToken[0] == 0) return OK; - Report("PowerUpUpdate",__FILE__,last,InitStages,RpWarning,(int)stage,0); + //Report("PowerUpUpdate",__FILE__,last,InitStages,RpWarning,(int)stage,0); response.has_state = true; response.has_progresspercentage = true; @@ -858,7 +885,8 @@ uint32_t PowerUpUpdate(MACHINE_STATE_STAGES_ENUM stage) Error = ERROR_CODE__POWER_UP_NO_CFG_FILE; break; } - //Report("PowerUpUpdate",__FILE__,last,(int)response.progresspercentage,RpWarning,(int)stage,0); + //usnprintf(init_string, 80, "PowerUpUpdate token %s",PowerUpToken); + Report("PowerUpUpdate",__FILE__,InitStages,(int)response.progresspercentage,RpWarning,(int)stage,0); responseContainer = createContainer(MESSAGE_TYPE__StartPowerUpResponse, PowerUpToken, last, &response, &start_power_up_response__pack, &start_power_up_response__get_packed_size); responseContainer.has_continuous = true; responseContainer.continuous = true; @@ -875,8 +903,18 @@ uint32_t PowerUpUpdate(MACHINE_STATE_STAGES_ENUM stage) SendChars((char*)container_buffer, container_size); //MessageContainer responseContainer; + if (last == true) + { + if (PowerUpLoadControlId!= 0xFF) + { + RemoveControlCallback(PowerUpLoadControlId, PowerUpUpdateCallBackFunction); + PowerUpLoadControlId = 0xFF; + } + } return status; } + + uint32_t PowerUpUpdateFunc(MessageContainer* requestContainer) { uint32_t status = NOT_SUPPORTED; @@ -884,11 +922,13 @@ uint32_t PowerUpUpdateFunc(MessageContainer* requestContainer) // MachineUpdateInitParams InitParams; - Report("PowerUpUpdateFunc",__FILE__,__LINE__,(int)0,RpWarning,(int)0,0); StartPowerUpRequest* request = start_power_up_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data); ustrncpy (PowerUpToken, requestContainer->token,36); + //usnprintf(init_string, 80, "PowerUpUpdateFunc token %s",PowerUpToken); + Report("PowerUpUpdateFunc",__FILE__,__LINE__,(int)0,RpWarning,(int)0,0); + PowerUpLoadControlId = AddControlCallback("PowerUpLoad", PowerUpUpdateCallBackFunction, 2* eOneSecond, TemplateDataReadCBFunction,0,0, 0 ); - PowerUpUpdate(MachineStateDetail); + //PowerUpUpdate(MachineStateDetail); start_power_up_request__free_unpacked(request,NULL); return status; } diff --git a/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c b/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c index 155d84fdb..82601a162 100644 --- a/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c +++ b/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c @@ -184,6 +184,13 @@ bool JobIsActive(void) return retcode; }*/ +ErrorCode getJobError_to_ErrorCode(JobEndReasonEnum JobError) +{ + if (JobError<JOB_ERRORS_MAX) + return JobError_to_ErrorCode[JobError]; + else + return ERROR_CODE__KEY_NOT_FOUND; +} //******************************************************************************************************************** bool GetHeatersPrepareWaiting(void) { @@ -1193,7 +1200,7 @@ void SendJobProgress(double ProcessedLength, int SegmentId, bool done, char *Mes switch (JobEndReason) { case JOB_THREAD_BREAK: - AlarmHandlingSetAlarm(EVENT_TYPE__THREAD_BREAK,true); + //AlarmHandlingSetAlarm(EVENT_TYPE__THREAD_BREAK,true); break; case JOB_POOLER_DANCER_FAIL: AlarmHandlingSetAlarm(EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_PULLER_DANCER,true); diff --git a/Software/Embedded_SW/Embedded/StateMachines/Printing/PrintingSTM.h b/Software/Embedded_SW/Embedded/StateMachines/Printing/PrintingSTM.h index 9fdd7b85f..dde582749 100644 --- a/Software/Embedded_SW/Embedded/StateMachines/Printing/PrintingSTM.h +++ b/Software/Embedded_SW/Embedded/StateMachines/Printing/PrintingSTM.h @@ -106,6 +106,7 @@ typedef enum JOB_ERRORS_MAX }JobEndReasonEnum; extern JobEndReasonEnum JobEndReason; +ErrorCode getJobError_to_ErrorCode(JobEndReasonEnum JobError); #define MAX_JOB_NAME_LEN 40 #define MAX_SEGMENT_NUM 30 |