From 363603ac89278995f8c7730c6fc92a8e19ed1f92 Mon Sep 17 00:00:00 2001 From: Avi Levkovich Date: Sun, 28 Apr 2019 15:55:09 +0300 Subject: change the blinking frequency of the machine panel leds to 300msec --- Software/Embedded_SW/Embedded/Modules/Control/control.c | 2 +- .../Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c | 5 +++-- 2 files changed, 4 insertions(+), 3 deletions(-) (limited to 'Software/Embedded_SW/Embedded/Modules') diff --git a/Software/Embedded_SW/Embedded/Modules/Control/control.c b/Software/Embedded_SW/Embedded/Modules/Control/control.c index b316fd73f..f1e19d851 100644 --- a/Software/Embedded_SW/Embedded/Modules/Control/control.c +++ b/Software/Embedded_SW/Embedded/Modules/Control/control.c @@ -158,7 +158,7 @@ uint32_t ControlActivityLed( uint32_t Parameter1) { static bool flag = false; static uint8_t counter; - const uint8_t Blink_Freq = 15;//odd number + const uint8_t Blink_Freq = 3;//odd number if (flag==true) { diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c index b0a1945db..6a1821f4b 100644 --- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c +++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c @@ -26,6 +26,7 @@ #include "drivers/I2C_Communication/ADC_MUX/ADC_MUX.h" #include "drivers/Valves/Valve.h" #include "drivers/Heater/Heater.h" +#include "modules/waste/waste.h" #include "modules/ids/ids_ex.h" @@ -243,12 +244,12 @@ uint32_t SetDigitalOutRequestRequestFunc(MessageContainer* requestContainer) /* case INTERFACE_IOS__GPO_LED4: DataUpdated = request->value; break;*/ - case INTERFACE_IOS__GPO_BLOWER_PWM: +/* case INTERFACE_IOS__GPO_BLOWER_PWM: if (request->value == true) Control_Dryer_Fan(START,75); else Control_Dryer_Fan(STOP, 0); - break; + break;*/ case INTERFACE_IOS__VALVE_WASTE_TANK: if (request->value == true) Valve_Set(VALVE_MIXCHIP_WASTECH,1); -- cgit v1.3.1 From 3bed1b881037c06d160573583be4d85dc186d3a7 Mon Sep 17 00:00:00 2001 From: Shlomo Hecht Date: Sun, 28 Apr 2019 19:35:39 +0300 Subject: version 1.3.9.3: segments and gradients handling, diagnostics is faster. code faiure handling --- .../Embedded_SW/Embedded/Common/SW_Info/SW_Info.c | 2 +- .../Communication/PMR/Diagnostics/EventType.pb-c.c | 538 +++++++++++---------- .../Communication/PMR/Diagnostics/EventType.pb-c.h | 12 +- .../Dispenser_Card/IO_Ports/Dispenser_IO.c | 39 ++ .../Dispenser_Card/IO_Ports/Dispenser_IO.h | 4 + Software/Embedded_SW/Embedded/Main.c | 94 +++- .../Embedded/Modules/AlarmHandling/AlarmHandling.c | 38 +- .../Modules/Diagnostics/DiagnosticActions.c | 12 +- .../Embedded/Modules/Diagnostics/Diagnostics.c | 2 +- .../Embedded/Modules/General/GeneralHardware.c | 8 +- .../Embedded_SW/Embedded/Modules/General/Safety.c | 43 +- .../Embedded_SW/Embedded/Modules/IDS/IDS_print.c | 44 +- .../Embedded/Modules/Stubs_Handler/Progress.c | 50 +- 13 files changed, 551 insertions(+), 335 deletions(-) (limited to 'Software/Embedded_SW/Embedded/Modules') 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 07fbf3ddd..c8ec2a487 100644 --- a/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c +++ b/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c @@ -20,7 +20,7 @@ typedef struct } TangoVersion_t; -TangoVersion_t _gTangoVersion = {1,3,8,51}; +TangoVersion_t _gTangoVersion = {1,3,9,3}; #define BUILD_DATE __DATE__ char Dat[50] = BUILD_DATE; char _gTangoName [MAX_STRING_LEN] = "Tango01 ";//d diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/EventType.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/EventType.pb-c.c index 785da53e2..d5b888912 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[279] = +static const ProtobufCEnumValue event_type__enum_values_by_number[285] = { { "None", "EVENT_TYPE__None", 0 }, { "REQUEST_SENT", "EVENT_TYPE__REQUEST_SENT", 1000 }, @@ -33,6 +33,10 @@ static const ProtobufCEnumValue event_type__enum_values_by_number[279] = { "MACHINE_FANS_STOPPED", "EVENT_TYPE__MACHINE_FANS_STOPPED", 2010 }, { "ELECTRICAL_CABINET_FANS_RPM_TOO_LOW", "EVENT_TYPE__ELECTRICAL_CABINET_FANS_RPM_TOO_LOW", 2011 }, { "ELECTRICAL_CABINET_FANS_STOPPED", "EVENT_TYPE__ELECTRICAL_CABINET_FANS_STOPPED", 2012 }, + { "MACHINE_STATE_NO_CFG_FILE", "EVENT_TYPE__MACHINE_STATE_NO_CFG_FILE", 2013 }, + { "MACHINE_STATE_HW_CONFIG_FAILED", "EVENT_TYPE__MACHINE_STATE_HW_CONFIG_FAILED", 2014 }, + { "MACHINE_STATE_INITIAL_BLOWER_FAILED", "EVENT_TYPE__MACHINE_STATE_INITIAL_BLOWER_FAILED", 2015 }, + { "UNSPECIFIED", "EVENT_TYPE__UNSPECIFIED", 2016 }, { "THREAD_BREAK", "EVENT_TYPE__THREAD_BREAK", 3000 }, { "THREAD_TENSION_CONTROL_FAILURE_FEEDER_DANCER", "EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_FEEDER_DANCER", 3001 }, { "WINDER_CONE_DOES_NOT_EXIST", "EVENT_TYPE__WINDER_CONE_DOES_NOT_EXIST", 3002 }, @@ -83,6 +87,7 @@ static const ProtobufCEnumValue event_type__enum_values_by_number[279] = { "FEEDER_DANCER_MOTOR_UNDERVOLTAGE", "EVENT_TYPE__FEEDER_DANCER_MOTOR_UNDERVOLTAGE", 3047 }, { "THREAD_TENSION_CONTROL_FAILURE_PULLER_DANCER", "EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_PULLER_DANCER", 3048 }, { "THREAD_TENSION_CONTROL_FAILURE_WINDER_DANCER", "EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_WINDER_DANCER", 3049 }, + { "MACHINE_STATE_NO_THREAD_DETECTED", "EVENT_TYPE__MACHINE_STATE_NO_THREAD_DETECTED", 3050 }, { "DRYER_MOTOR_OVERCURRENT", "EVENT_TYPE__DRYER_MOTOR_OVERCURRENT", 4000 }, { "DRYER_MOTOR_OVERTEMPERATURE", "EVENT_TYPE__DRYER_MOTOR_OVERTEMPERATURE", 4001 }, { "DRYER_MOTOR_STALL", "EVENT_TYPE__DRYER_MOTOR_STALL", 4002 }, @@ -240,8 +245,8 @@ static const ProtobufCEnumValue event_type__enum_values_by_number[279] = { "DISPENSER_4_HIGH_PRESSURE", "EVENT_TYPE__DISPENSER_4_HIGH_PRESSURE", 7083 }, { "DISPENSER_5_HIGH_PRESSURE", "EVENT_TYPE__DISPENSER_5_HIGH_PRESSURE", 7084 }, { "DISPENSER_6_HIGH_PRESSURE", "EVENT_TYPE__DISPENSER_6_HIGH_PRESSURE", 7085 }, - { "DISPENSER_8_HIGH_PRESSURE", "EVENT_TYPE__DISPENSER_8_HIGH_PRESSURE", 7086 }, - { "DISPENSER_7_HIGH_PRESSURE", "EVENT_TYPE__DISPENSER_7_HIGH_PRESSURE", 7087 }, + { "DISPENSER_7_HIGH_PRESSURE", "EVENT_TYPE__DISPENSER_7_HIGH_PRESSURE", 7086 }, + { "DISPENSER_8_HIGH_PRESSURE", "EVENT_TYPE__DISPENSER_8_HIGH_PRESSURE", 7087 }, { "MID_TANK_1_LOW_LEVEL", "EVENT_TYPE__MID_TANK_1_LOW_LEVEL", 8000 }, { "MID_TANK_2_LOW_LEVEL", "EVENT_TYPE__MID_TANK_2_LOW_LEVEL", 8001 }, { "MID_TANK_3_LOW_LEVEL", "EVENT_TYPE__MID_TANK_3_LOW_LEVEL", 8002 }, @@ -279,9 +284,10 @@ static const ProtobufCEnumValue event_type__enum_values_by_number[279] = { "WASTE_CONTAINER_EMPTYING_TIMEOUT", "EVENT_TYPE__WASTE_CONTAINER_EMPTYING_TIMEOUT", 9002 }, { "NO_AIR_PRESSURE", "EVENT_TYPE__NO_AIR_PRESSURE", 9003 }, { "WASTE_CONTAINER_OVERFLOW", "EVENT_TYPE__WASTE_CONTAINER_OVERFLOW", 9004 }, - { "VOC_SENSOR_ALARM", "EVENT_TYPE__VOC_SENSOR_ALARM", 9005 }, + { "VOC_SENSOR_ALARM_TIME", "EVENT_TYPE__VOC_SENSOR_ALARM_TIME", 9005 }, { "CHILLER_DRY_CONTACT", "EVENT_TYPE__CHILLER_DRY_CONTACT", 9006 }, { "INSUFFICIENT_AIR_FLOW", "EVENT_TYPE__INSUFFICIENT_AIR_FLOW", 9007 }, + { "VOC_SENSOR_ALARM_SLOPE", "EVENT_TYPE__VOC_SENSOR_ALARM_SLOPE", 9008 }, { "INK_CARTRIDGE_PRESENCE_SENSOR_TIMEOUT", "EVENT_TYPE__INK_CARTRIDGE_PRESENCE_SENSOR_TIMEOUT", 10000 }, { "INK_CARTRIDGE_RFID_TIMEOUT", "EVENT_TYPE__INK_CARTRIDGE_RFID_TIMEOUT", 10001 }, { "NO_WASTE_CARTRIDGE_AVAILABLE", "EVENT_TYPE__NO_WASTE_CARTRIDGE_AVAILABLE", 10002 }, @@ -290,289 +296,295 @@ static const ProtobufCEnumValue event_type__enum_values_by_number[279] = { "WASTE_CARTRIDGE_RFID_TIMEOUT", "EVENT_TYPE__WASTE_CARTRIDGE_RFID_TIMEOUT", 10005 }, }; static const ProtobufCIntRange event_type__value_ranges[] = { -{0, 0},{1000, 1},{2000, 11},{3000, 24},{4000, 74},{5000, 96},{6000, 139},{7000, 145},{8000, 233},{9000, 265},{10000, 273},{0, 279} +{0, 0},{1000, 1},{2000, 11},{3000, 28},{4000, 79},{5000, 101},{6000, 144},{7000, 150},{8000, 238},{9000, 270},{10000, 279},{0, 285} }; -static const ProtobufCEnumValueIndex event_type__enum_values_by_name[279] = +static const ProtobufCEnumValueIndex event_type__enum_values_by_name[285] = { - { "AIR_FILTER_CLOGGED", 266 }, - { "AIR_FILTER_NOT_INSTALLED", 265 }, - { "ALL_WASTE_CARTRIDGES_FULL", 276 }, + { "AIR_FILTER_CLOGGED", 271 }, + { "AIR_FILTER_NOT_INSTALLED", 270 }, + { "ALL_WASTE_CARTRIDGES_FULL", 282 }, { "APPLICATION_EXCEPTION", 4 }, { "APPLICATION_INFORMATION", 5 }, { "APPLICATION_STARTED", 6 }, { "APPLICATION_TERMINATED", 7 }, { "CARTRIDGES_COVER_OPEN", 17 }, - { "CHILLER_DRY_CONTACT", 271 }, - { "DISPENSER_1_EMPTY", 161 }, - { "DISPENSER_1_HIGH_PRESSURE", 225 }, - { "DISPENSER_1_LOWER_HARD_LIMIT", 217 }, - { "DISPENSER_1_MOTOR_OVERCURRENT", 177 }, - { "DISPENSER_1_MOTOR_OVERTEMPERATURE", 185 }, - { "DISPENSER_1_MOTOR_STALL", 193 }, - { "DISPENSER_1_MOTOR_UNDERVOLTAGE", 201 }, - { "DISPENSER_1_OVERPRESSURE", 145 }, - { "DISPENSER_1_REFILL_FAILURE", 169 }, - { "DISPENSER_1_UNDERPRESSURE", 153 }, - { "DISPENSER_1_UPPER_HARD_LIMIT", 209 }, - { "DISPENSER_2_EMPTY", 162 }, - { "DISPENSER_2_HIGH_PRESSURE", 226 }, - { "DISPENSER_2_LOWER_HARD_LIMIT", 218 }, - { "DISPENSER_2_MOTOR_OVERCURRENT", 178 }, - { "DISPENSER_2_MOTOR_OVERTEMPERATURE", 186 }, - { "DISPENSER_2_MOTOR_STALL", 194 }, - { "DISPENSER_2_MOTOR_UNDERVOLTAGE", 202 }, - { "DISPENSER_2_OVERPRESSURE", 146 }, - { "DISPENSER_2_REFILL_FAILURE", 170 }, - { "DISPENSER_2_UNDERPRESSURE", 154 }, - { "DISPENSER_2_UPPER_HARD_LIMIT", 210 }, - { "DISPENSER_3_EMPTY", 163 }, - { "DISPENSER_3_HIGH_PRESSURE", 227 }, - { "DISPENSER_3_LOWER_HARD_LIMIT", 219 }, - { "DISPENSER_3_MOTOR_OVERCURRENT", 179 }, - { "DISPENSER_3_MOTOR_OVERTEMPERATURE", 187 }, - { "DISPENSER_3_MOTOR_STALL", 195 }, - { "DISPENSER_3_MOTOR_UNDERVOLTAGE", 203 }, - { "DISPENSER_3_OVERPRESSURE", 147 }, - { "DISPENSER_3_REFILL_FAILURE", 171 }, - { "DISPENSER_3_UNDERPRESSURE", 155 }, - { "DISPENSER_3_UPPER_HARD_LIMIT", 211 }, - { "DISPENSER_4_EMPTY", 164 }, - { "DISPENSER_4_HIGH_PRESSURE", 228 }, - { "DISPENSER_4_LOWER_HARD_LIMIT", 220 }, - { "DISPENSER_4_MOTOR_OVERCURRENT", 180 }, - { "DISPENSER_4_MOTOR_OVERTEMPERATURE", 188 }, - { "DISPENSER_4_MOTOR_STALL", 196 }, - { "DISPENSER_4_MOTOR_UNDERVOLTAGE", 204 }, - { "DISPENSER_4_OVERPRESSURE", 148 }, - { "DISPENSER_4_REFILL_FAILURE", 172 }, - { "DISPENSER_4_UNDERPRESSURE", 156 }, - { "DISPENSER_4_UPPER_HARD_LIMIT", 212 }, - { "DISPENSER_5_EMPTY", 165 }, - { "DISPENSER_5_HIGH_PRESSURE", 229 }, - { "DISPENSER_5_LOWER_HARD_LIMIT", 221 }, - { "DISPENSER_5_MOTOR_OVERCURRENT", 181 }, - { "DISPENSER_5_MOTOR_OVERTEMPERATURE", 189 }, - { "DISPENSER_5_MOTOR_STALL", 197 }, - { "DISPENSER_5_MOTOR_UNDERVOLTAGE", 205 }, - { "DISPENSER_5_OVERPRESSURE", 149 }, - { "DISPENSER_5_REFILL_FAILURE", 173 }, - { "DISPENSER_5_UNDERPRESSURE", 157 }, - { "DISPENSER_5_UPPER_HARD_LIMIT", 213 }, - { "DISPENSER_6_EMPTY", 166 }, - { "DISPENSER_6_HIGH_PRESSURE", 230 }, - { "DISPENSER_6_LOWER_HARD_LIMIT", 222 }, - { "DISPENSER_6_MOTOR_OVERCURRENT", 182 }, - { "DISPENSER_6_MOTOR_OVERTEMPERATURE", 190 }, - { "DISPENSER_6_MOTOR_STALL", 198 }, - { "DISPENSER_6_MOTOR_UNDERVOLTAGE", 206 }, - { "DISPENSER_6_OVERPRESSURE", 150 }, - { "DISPENSER_6_REFILL_FAILURE", 174 }, - { "DISPENSER_6_UNDERPRESSURE", 158 }, - { "DISPENSER_6_UPPER_HARD_LIMIT", 214 }, - { "DISPENSER_7_EMPTY", 167 }, - { "DISPENSER_7_HIGH_PRESSURE", 232 }, - { "DISPENSER_7_LOWER_HARD_LIMIT", 223 }, - { "DISPENSER_7_MOTOR_OVERCURRENT", 183 }, - { "DISPENSER_7_MOTOR_OVERTEMPERATURE", 191 }, - { "DISPENSER_7_MOTOR_STALL", 199 }, - { "DISPENSER_7_MOTOR_UNDERVOLTAGE", 207 }, - { "DISPENSER_7_OVERPRESSURE", 151 }, - { "DISPENSER_7_REFILL_FAILURE", 175 }, - { "DISPENSER_7_UNDERPRESSURE", 159 }, - { "DISPENSER_7_UPPER_HARD_LIMIT", 215 }, - { "DISPENSER_8_EMPTY", 168 }, - { "DISPENSER_8_HIGH_PRESSURE", 231 }, - { "DISPENSER_8_LOWER_HARD_LIMIT", 224 }, - { "DISPENSER_8_MOTOR_OVERCURRENT", 184 }, - { "DISPENSER_8_MOTOR_OVERTEMPERATURE", 192 }, - { "DISPENSER_8_MOTOR_STALL", 200 }, - { "DISPENSER_8_MOTOR_UNDERVOLTAGE", 208 }, - { "DISPENSER_8_OVERPRESSURE", 152 }, - { "DISPENSER_8_REFILL_FAILURE", 176 }, - { "DISPENSER_8_UNDERPRESSURE", 160 }, - { "DISPENSER_8_UPPER_HARD_LIMIT", 216 }, - { "DRYER_DOOR_OPEN", 78 }, - { "DRYER_FAN_RPM_TOO_LOW", 89 }, - { "DRYER_FAN_STOPPED", 90 }, - { "DRYER_HEATERS_ZONE_1_CURRENT_LOOP_BREAK", 87 }, - { "DRYER_HEATERS_ZONE_1_CURRENT_OUT_OF_RANGE", 85 }, - { "DRYER_HEATERS_ZONE_2_CURRENT_LOOP_BREAK", 88 }, - { "DRYER_HEATERS_ZONE_2_CURRENT_OUT_OF_RANGE", 86 }, - { "DRYER_LID_MOTOR_OVERCURRENT", 91 }, - { "DRYER_LID_MOTOR_OVERTEMPERATURE", 92 }, - { "DRYER_LID_MOTOR_STALL", 93 }, - { "DRYER_LID_MOTOR_UNDERVOLTAGE", 94 }, - { "DRYER_MOTOR_OVERCURRENT", 74 }, - { "DRYER_MOTOR_OVERTEMPERATURE", 75 }, - { "DRYER_MOTOR_STALL", 76 }, - { "DRYER_MOTOR_UNDERVOLTAGE", 77 }, - { "DRYER_THERMAL_CUTOFF", 84 }, - { "DRYER_ZONE_1_OVERTEMPERATURE", 79 }, - { "DRYER_ZONE_1_UNDERTEMPERATURE_A", 81 }, - { "DRYER_ZONE_1_UNDERTEMPERATURE_B", 82 }, - { "DRYER_ZONE_2_OVERTEMPERATURE", 80 }, - { "DRYER_ZONE_2_UNDERTEMPERATURE_A", 95 }, - { "DRYER_ZONE_2_UNDERTEMPERATURE_B", 83 }, - { "DYEING_HEAD_CLEANING_HEAD_MOTOR_OVERCURRENT", 135 }, - { "DYEING_HEAD_CLEANING_HEAD_MOTOR_OVERTEMPERATURE", 136 }, - { "DYEING_HEAD_CLEANING_HEAD_MOTOR_STALL", 137 }, - { "DYEING_HEAD_CLEANING_HEAD_MOTOR_UNDERVOLTAGE", 138 }, - { "DYEING_HEAD_CLEANING_MECHANISM_MOTOR_OVERCURRENT", 131 }, - { "DYEING_HEAD_CLEANING_MECHANISM_MOTOR_OVERTEMPERATURE", 132 }, - { "DYEING_HEAD_CLEANING_MECHANISM_MOTOR_STALL", 133 }, - { "DYEING_HEAD_CLEANING_MECHANISM_MOTOR_UNDERVOLTAGE", 134 }, - { "DYEING_HEAD_COVER_CLOSE_TIMEOUT", 126 }, - { "DYEING_HEAD_COVER_MOTOR_OVERCURRENT", 127 }, - { "DYEING_HEAD_COVER_MOTOR_OVERTEMPERATURE", 128 }, - { "DYEING_HEAD_COVER_MOTOR_STALL", 129 }, - { "DYEING_HEAD_COVER_MOTOR_UNDERVOLTAGE", 130 }, - { "DYEING_HEAD_COVER_OPEN_TIMEOUT", 125 }, - { "DYEING_HEAD_THERMAL_CUTOFF", 124 }, - { "DYEING_HEAD_ZONE_1_CURRENT_LOOP_BREAK", 119 }, - { "DYEING_HEAD_ZONE_1_CURRENT_OUT_OF_RANGE", 114 }, - { "DYEING_HEAD_ZONE_1_OVERTEMPERATURE", 96 }, - { "DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_A", 102 }, - { "DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_B", 108 }, - { "DYEING_HEAD_ZONE_2_CURRENT_LOOP_BREAK", 120 }, - { "DYEING_HEAD_ZONE_2_CURRENT_OUT_OF_RANGE", 115 }, - { "DYEING_HEAD_ZONE_2_OVERTEMPERATURE", 97 }, - { "DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_A", 103 }, - { "DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_B", 109 }, - { "DYEING_HEAD_ZONE_3_CURRENT_LOOP_BREAK", 121 }, - { "DYEING_HEAD_ZONE_3_CURRENT_OUT_OF_RANGE", 116 }, - { "DYEING_HEAD_ZONE_3_OVERTEMPERATURE", 98 }, - { "DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_A", 104 }, - { "DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_B", 110 }, - { "DYEING_HEAD_ZONE_4_CURRENT_LOOP_BREAK", 122 }, - { "DYEING_HEAD_ZONE_4_CURRENT_OUT_OF_RANGE", 117 }, - { "DYEING_HEAD_ZONE_4_OVERTEMPERATURE", 99 }, - { "DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_A", 105 }, - { "DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_B", 111 }, - { "DYEING_HEAD_ZONE_5_6_CURRENT_LOOP_BREAK", 123 }, - { "DYEING_HEAD_ZONE_5_6_CURRENT_OUT_OF_RANGE", 118 }, - { "DYEING_HEAD_ZONE_5_OVERTEMPERATURE", 100 }, - { "DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_A", 106 }, - { "DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_B", 112 }, - { "DYEING_HEAD_ZONE_6_OVERTEMPERATURE", 101 }, - { "DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_A", 107 }, - { "DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_B", 113 }, + { "CHILLER_DRY_CONTACT", 276 }, + { "DISPENSER_1_EMPTY", 166 }, + { "DISPENSER_1_HIGH_PRESSURE", 230 }, + { "DISPENSER_1_LOWER_HARD_LIMIT", 222 }, + { "DISPENSER_1_MOTOR_OVERCURRENT", 182 }, + { "DISPENSER_1_MOTOR_OVERTEMPERATURE", 190 }, + { "DISPENSER_1_MOTOR_STALL", 198 }, + { "DISPENSER_1_MOTOR_UNDERVOLTAGE", 206 }, + { "DISPENSER_1_OVERPRESSURE", 150 }, + { "DISPENSER_1_REFILL_FAILURE", 174 }, + { "DISPENSER_1_UNDERPRESSURE", 158 }, + { "DISPENSER_1_UPPER_HARD_LIMIT", 214 }, + { "DISPENSER_2_EMPTY", 167 }, + { "DISPENSER_2_HIGH_PRESSURE", 231 }, + { "DISPENSER_2_LOWER_HARD_LIMIT", 223 }, + { "DISPENSER_2_MOTOR_OVERCURRENT", 183 }, + { "DISPENSER_2_MOTOR_OVERTEMPERATURE", 191 }, + { "DISPENSER_2_MOTOR_STALL", 199 }, + { "DISPENSER_2_MOTOR_UNDERVOLTAGE", 207 }, + { "DISPENSER_2_OVERPRESSURE", 151 }, + { "DISPENSER_2_REFILL_FAILURE", 175 }, + { "DISPENSER_2_UNDERPRESSURE", 159 }, + { "DISPENSER_2_UPPER_HARD_LIMIT", 215 }, + { "DISPENSER_3_EMPTY", 168 }, + { "DISPENSER_3_HIGH_PRESSURE", 232 }, + { "DISPENSER_3_LOWER_HARD_LIMIT", 224 }, + { "DISPENSER_3_MOTOR_OVERCURRENT", 184 }, + { "DISPENSER_3_MOTOR_OVERTEMPERATURE", 192 }, + { "DISPENSER_3_MOTOR_STALL", 200 }, + { "DISPENSER_3_MOTOR_UNDERVOLTAGE", 208 }, + { "DISPENSER_3_OVERPRESSURE", 152 }, + { "DISPENSER_3_REFILL_FAILURE", 176 }, + { "DISPENSER_3_UNDERPRESSURE", 160 }, + { "DISPENSER_3_UPPER_HARD_LIMIT", 216 }, + { "DISPENSER_4_EMPTY", 169 }, + { "DISPENSER_4_HIGH_PRESSURE", 233 }, + { "DISPENSER_4_LOWER_HARD_LIMIT", 225 }, + { "DISPENSER_4_MOTOR_OVERCURRENT", 185 }, + { "DISPENSER_4_MOTOR_OVERTEMPERATURE", 193 }, + { "DISPENSER_4_MOTOR_STALL", 201 }, + { "DISPENSER_4_MOTOR_UNDERVOLTAGE", 209 }, + { "DISPENSER_4_OVERPRESSURE", 153 }, + { "DISPENSER_4_REFILL_FAILURE", 177 }, + { "DISPENSER_4_UNDERPRESSURE", 161 }, + { "DISPENSER_4_UPPER_HARD_LIMIT", 217 }, + { "DISPENSER_5_EMPTY", 170 }, + { "DISPENSER_5_HIGH_PRESSURE", 234 }, + { "DISPENSER_5_LOWER_HARD_LIMIT", 226 }, + { "DISPENSER_5_MOTOR_OVERCURRENT", 186 }, + { "DISPENSER_5_MOTOR_OVERTEMPERATURE", 194 }, + { "DISPENSER_5_MOTOR_STALL", 202 }, + { "DISPENSER_5_MOTOR_UNDERVOLTAGE", 210 }, + { "DISPENSER_5_OVERPRESSURE", 154 }, + { "DISPENSER_5_REFILL_FAILURE", 178 }, + { "DISPENSER_5_UNDERPRESSURE", 162 }, + { "DISPENSER_5_UPPER_HARD_LIMIT", 218 }, + { "DISPENSER_6_EMPTY", 171 }, + { "DISPENSER_6_HIGH_PRESSURE", 235 }, + { "DISPENSER_6_LOWER_HARD_LIMIT", 227 }, + { "DISPENSER_6_MOTOR_OVERCURRENT", 187 }, + { "DISPENSER_6_MOTOR_OVERTEMPERATURE", 195 }, + { "DISPENSER_6_MOTOR_STALL", 203 }, + { "DISPENSER_6_MOTOR_UNDERVOLTAGE", 211 }, + { "DISPENSER_6_OVERPRESSURE", 155 }, + { "DISPENSER_6_REFILL_FAILURE", 179 }, + { "DISPENSER_6_UNDERPRESSURE", 163 }, + { "DISPENSER_6_UPPER_HARD_LIMIT", 219 }, + { "DISPENSER_7_EMPTY", 172 }, + { "DISPENSER_7_HIGH_PRESSURE", 236 }, + { "DISPENSER_7_LOWER_HARD_LIMIT", 228 }, + { "DISPENSER_7_MOTOR_OVERCURRENT", 188 }, + { "DISPENSER_7_MOTOR_OVERTEMPERATURE", 196 }, + { "DISPENSER_7_MOTOR_STALL", 204 }, + { "DISPENSER_7_MOTOR_UNDERVOLTAGE", 212 }, + { "DISPENSER_7_OVERPRESSURE", 156 }, + { "DISPENSER_7_REFILL_FAILURE", 180 }, + { "DISPENSER_7_UNDERPRESSURE", 164 }, + { "DISPENSER_7_UPPER_HARD_LIMIT", 220 }, + { "DISPENSER_8_EMPTY", 173 }, + { "DISPENSER_8_HIGH_PRESSURE", 237 }, + { "DISPENSER_8_LOWER_HARD_LIMIT", 229 }, + { "DISPENSER_8_MOTOR_OVERCURRENT", 189 }, + { "DISPENSER_8_MOTOR_OVERTEMPERATURE", 197 }, + { "DISPENSER_8_MOTOR_STALL", 205 }, + { "DISPENSER_8_MOTOR_UNDERVOLTAGE", 213 }, + { "DISPENSER_8_OVERPRESSURE", 157 }, + { "DISPENSER_8_REFILL_FAILURE", 181 }, + { "DISPENSER_8_UNDERPRESSURE", 165 }, + { "DISPENSER_8_UPPER_HARD_LIMIT", 221 }, + { "DRYER_DOOR_OPEN", 83 }, + { "DRYER_FAN_RPM_TOO_LOW", 94 }, + { "DRYER_FAN_STOPPED", 95 }, + { "DRYER_HEATERS_ZONE_1_CURRENT_LOOP_BREAK", 92 }, + { "DRYER_HEATERS_ZONE_1_CURRENT_OUT_OF_RANGE", 90 }, + { "DRYER_HEATERS_ZONE_2_CURRENT_LOOP_BREAK", 93 }, + { "DRYER_HEATERS_ZONE_2_CURRENT_OUT_OF_RANGE", 91 }, + { "DRYER_LID_MOTOR_OVERCURRENT", 96 }, + { "DRYER_LID_MOTOR_OVERTEMPERATURE", 97 }, + { "DRYER_LID_MOTOR_STALL", 98 }, + { "DRYER_LID_MOTOR_UNDERVOLTAGE", 99 }, + { "DRYER_MOTOR_OVERCURRENT", 79 }, + { "DRYER_MOTOR_OVERTEMPERATURE", 80 }, + { "DRYER_MOTOR_STALL", 81 }, + { "DRYER_MOTOR_UNDERVOLTAGE", 82 }, + { "DRYER_THERMAL_CUTOFF", 89 }, + { "DRYER_ZONE_1_OVERTEMPERATURE", 84 }, + { "DRYER_ZONE_1_UNDERTEMPERATURE_A", 86 }, + { "DRYER_ZONE_1_UNDERTEMPERATURE_B", 87 }, + { "DRYER_ZONE_2_OVERTEMPERATURE", 85 }, + { "DRYER_ZONE_2_UNDERTEMPERATURE_A", 100 }, + { "DRYER_ZONE_2_UNDERTEMPERATURE_B", 88 }, + { "DYEING_HEAD_CLEANING_HEAD_MOTOR_OVERCURRENT", 140 }, + { "DYEING_HEAD_CLEANING_HEAD_MOTOR_OVERTEMPERATURE", 141 }, + { "DYEING_HEAD_CLEANING_HEAD_MOTOR_STALL", 142 }, + { "DYEING_HEAD_CLEANING_HEAD_MOTOR_UNDERVOLTAGE", 143 }, + { "DYEING_HEAD_CLEANING_MECHANISM_MOTOR_OVERCURRENT", 136 }, + { "DYEING_HEAD_CLEANING_MECHANISM_MOTOR_OVERTEMPERATURE", 137 }, + { "DYEING_HEAD_CLEANING_MECHANISM_MOTOR_STALL", 138 }, + { "DYEING_HEAD_CLEANING_MECHANISM_MOTOR_UNDERVOLTAGE", 139 }, + { "DYEING_HEAD_COVER_CLOSE_TIMEOUT", 131 }, + { "DYEING_HEAD_COVER_MOTOR_OVERCURRENT", 132 }, + { "DYEING_HEAD_COVER_MOTOR_OVERTEMPERATURE", 133 }, + { "DYEING_HEAD_COVER_MOTOR_STALL", 134 }, + { "DYEING_HEAD_COVER_MOTOR_UNDERVOLTAGE", 135 }, + { "DYEING_HEAD_COVER_OPEN_TIMEOUT", 130 }, + { "DYEING_HEAD_THERMAL_CUTOFF", 129 }, + { "DYEING_HEAD_ZONE_1_CURRENT_LOOP_BREAK", 124 }, + { "DYEING_HEAD_ZONE_1_CURRENT_OUT_OF_RANGE", 119 }, + { "DYEING_HEAD_ZONE_1_OVERTEMPERATURE", 101 }, + { "DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_A", 107 }, + { "DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_B", 113 }, + { "DYEING_HEAD_ZONE_2_CURRENT_LOOP_BREAK", 125 }, + { "DYEING_HEAD_ZONE_2_CURRENT_OUT_OF_RANGE", 120 }, + { "DYEING_HEAD_ZONE_2_OVERTEMPERATURE", 102 }, + { "DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_A", 108 }, + { "DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_B", 114 }, + { "DYEING_HEAD_ZONE_3_CURRENT_LOOP_BREAK", 126 }, + { "DYEING_HEAD_ZONE_3_CURRENT_OUT_OF_RANGE", 121 }, + { "DYEING_HEAD_ZONE_3_OVERTEMPERATURE", 103 }, + { "DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_A", 109 }, + { "DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_B", 115 }, + { "DYEING_HEAD_ZONE_4_CURRENT_LOOP_BREAK", 127 }, + { "DYEING_HEAD_ZONE_4_CURRENT_OUT_OF_RANGE", 122 }, + { "DYEING_HEAD_ZONE_4_OVERTEMPERATURE", 104 }, + { "DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_A", 110 }, + { "DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_B", 116 }, + { "DYEING_HEAD_ZONE_5_6_CURRENT_LOOP_BREAK", 128 }, + { "DYEING_HEAD_ZONE_5_6_CURRENT_OUT_OF_RANGE", 123 }, + { "DYEING_HEAD_ZONE_5_OVERTEMPERATURE", 105 }, + { "DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_A", 111 }, + { "DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_B", 117 }, + { "DYEING_HEAD_ZONE_6_OVERTEMPERATURE", 106 }, + { "DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_A", 112 }, + { "DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_B", 118 }, { "ELECTRICAL_CABINET_FANS_RPM_TOO_LOW", 22 }, { "ELECTRICAL_CABINET_FANS_STOPPED", 23 }, { "EMERGENCY_PUSH_BUTTON_PRESSED", 12 }, - { "FEEDER_DANCER_MOTOR_OVERCURRENT", 62 }, - { "FEEDER_DANCER_MOTOR_OVERTEMPERATURE", 65 }, - { "FEEDER_DANCER_MOTOR_STALL", 68 }, - { "FEEDER_DANCER_MOTOR_UNDERVOLTAGE", 71 }, - { "FEEDER_MOTOR_OVERCURRENT", 27 }, - { "FEEDER_MOTOR_OVERTEMPERATURE", 34 }, - { "FEEDER_MOTOR_STALL", 41 }, - { "FEEDER_MOTOR_UNDERVOLTAGE", 48 }, + { "FEEDER_DANCER_MOTOR_OVERCURRENT", 66 }, + { "FEEDER_DANCER_MOTOR_OVERTEMPERATURE", 69 }, + { "FEEDER_DANCER_MOTOR_STALL", 72 }, + { "FEEDER_DANCER_MOTOR_UNDERVOLTAGE", 75 }, + { "FEEDER_MOTOR_OVERCURRENT", 31 }, + { "FEEDER_MOTOR_OVERTEMPERATURE", 38 }, + { "FEEDER_MOTOR_STALL", 45 }, + { "FEEDER_MOTOR_UNDERVOLTAGE", 52 }, { "FRONT_COVER_1_OPEN", 13 }, { "FRONT_COVER_2_OPEN", 14 }, { "FRONT_COVER_3_OPEN", 15 }, { "FRONT_COVER_4_OPEN", 16 }, - { "INK_CARTRIDGE_PRESENCE_SENSOR_TIMEOUT", 273 }, - { "INK_CARTRIDGE_RFID_TIMEOUT", 274 }, - { "INSUFFICIENT_AIR_FLOW", 272 }, + { "INK_CARTRIDGE_PRESENCE_SENSOR_TIMEOUT", 279 }, + { "INK_CARTRIDGE_RFID_TIMEOUT", 280 }, + { "INSUFFICIENT_AIR_FLOW", 277 }, { "JOB_STATUS", 10 }, - { "LEFT_LOADER_MOTOR_OVERCURRENT", 30 }, - { "LEFT_LOADER_MOTOR_OVERTEMPERATURE", 37 }, - { "LEFT_LOADER_MOTOR_STALL", 44 }, - { "LEFT_LOADER_MOTOR_UNDERVOLTAGE", 51 }, - { "LOADING_ARM_MOTOR_OVERCURRENT", 33 }, - { "LOADING_ARM_MOTOR_OVERTEMPERATURE", 40 }, - { "LOADING_ARM_MOTOR_STALL", 47 }, - { "LOADING_ARM_MOTOR_UNDERVOLTAGE", 54 }, - { "LTFU_DOWN_TIMEOUT", 56 }, - { "LTFU_UP_TIMEOUT", 55 }, + { "LEFT_LOADER_MOTOR_OVERCURRENT", 34 }, + { "LEFT_LOADER_MOTOR_OVERTEMPERATURE", 41 }, + { "LEFT_LOADER_MOTOR_STALL", 48 }, + { "LEFT_LOADER_MOTOR_UNDERVOLTAGE", 55 }, + { "LOADING_ARM_MOTOR_OVERCURRENT", 37 }, + { "LOADING_ARM_MOTOR_OVERTEMPERATURE", 44 }, + { "LOADING_ARM_MOTOR_STALL", 51 }, + { "LOADING_ARM_MOTOR_UNDERVOLTAGE", 58 }, + { "LTFU_DOWN_TIMEOUT", 60 }, + { "LTFU_UP_TIMEOUT", 59 }, { "MACHINE_FANS_RPM_TOO_LOW", 20 }, { "MACHINE_FANS_STOPPED", 21 }, { "MACHINE_INTERNAL_OVERTEMPERATURE", 19 }, - { "MID_TANK_1_EMPTY", 241 }, - { "MID_TANK_1_FILL_TIMEOUT", 257 }, - { "MID_TANK_1_LOW_LEVEL", 233 }, - { "MID_TANK_1_OVERFLOW", 249 }, - { "MID_TANK_2_EMPTY", 242 }, - { "MID_TANK_2_FILL_TIMEOUT", 258 }, - { "MID_TANK_2_LOW_LEVEL", 234 }, - { "MID_TANK_2_OVERFLOW", 250 }, - { "MID_TANK_3_EMPTY", 243 }, - { "MID_TANK_3_FILL_TIMEOUT", 259 }, - { "MID_TANK_3_LOW_LEVEL", 235 }, - { "MID_TANK_3_OVERFLOW", 251 }, - { "MID_TANK_4_EMPTY", 244 }, - { "MID_TANK_4_FILL_TIMEOUT", 260 }, - { "MID_TANK_4_LOW_LEVEL", 236 }, - { "MID_TANK_4_OVERFLOW", 252 }, - { "MID_TANK_5_EMPTY", 245 }, - { "MID_TANK_5_FILL_TIMEOUT", 261 }, - { "MID_TANK_5_LOW_LEVEL", 237 }, - { "MID_TANK_5_OVERFLOW", 253 }, - { "MID_TANK_6_EMPTY", 246 }, - { "MID_TANK_6_FILL_TIMEOUT", 262 }, - { "MID_TANK_6_LOW_LEVEL", 238 }, - { "MID_TANK_6_OVERFLOW", 254 }, - { "MID_TANK_7_EMPTY", 247 }, - { "MID_TANK_7_FILL_TIMEOUT", 263 }, - { "MID_TANK_7_LOW_LEVEL", 239 }, - { "MID_TANK_7_OVERFLOW", 255 }, - { "MID_TANK_8_EMPTY", 248 }, - { "MID_TANK_8_FILL_TIMEOUT", 264 }, - { "MID_TANK_8_LOW_LEVEL", 240 }, - { "MID_TANK_8_OVERFLOW", 256 }, - { "MIXER_CURRENT_LOOP_BREAK", 144 }, - { "MIXER_CURRENT_OUT_OF_RANGE", 143 }, - { "MIXER_OVERTEMPERATURE", 139 }, - { "MIXER_THERMAL_CUTOFF", 142 }, - { "MIXER_UNDERTEMPERATURE_A", 140 }, - { "MIXER_UNDERTEMPERATURE_B", 141 }, - { "NO_AIR_PRESSURE", 268 }, - { "NO_WASTE_CARTRIDGE_AVAILABLE", 275 }, + { "MACHINE_STATE_HW_CONFIG_FAILED", 25 }, + { "MACHINE_STATE_INITIAL_BLOWER_FAILED", 26 }, + { "MACHINE_STATE_NO_CFG_FILE", 24 }, + { "MACHINE_STATE_NO_THREAD_DETECTED", 78 }, + { "MID_TANK_1_EMPTY", 246 }, + { "MID_TANK_1_FILL_TIMEOUT", 262 }, + { "MID_TANK_1_LOW_LEVEL", 238 }, + { "MID_TANK_1_OVERFLOW", 254 }, + { "MID_TANK_2_EMPTY", 247 }, + { "MID_TANK_2_FILL_TIMEOUT", 263 }, + { "MID_TANK_2_LOW_LEVEL", 239 }, + { "MID_TANK_2_OVERFLOW", 255 }, + { "MID_TANK_3_EMPTY", 248 }, + { "MID_TANK_3_FILL_TIMEOUT", 264 }, + { "MID_TANK_3_LOW_LEVEL", 240 }, + { "MID_TANK_3_OVERFLOW", 256 }, + { "MID_TANK_4_EMPTY", 249 }, + { "MID_TANK_4_FILL_TIMEOUT", 265 }, + { "MID_TANK_4_LOW_LEVEL", 241 }, + { "MID_TANK_4_OVERFLOW", 257 }, + { "MID_TANK_5_EMPTY", 250 }, + { "MID_TANK_5_FILL_TIMEOUT", 266 }, + { "MID_TANK_5_LOW_LEVEL", 242 }, + { "MID_TANK_5_OVERFLOW", 258 }, + { "MID_TANK_6_EMPTY", 251 }, + { "MID_TANK_6_FILL_TIMEOUT", 267 }, + { "MID_TANK_6_LOW_LEVEL", 243 }, + { "MID_TANK_6_OVERFLOW", 259 }, + { "MID_TANK_7_EMPTY", 252 }, + { "MID_TANK_7_FILL_TIMEOUT", 268 }, + { "MID_TANK_7_LOW_LEVEL", 244 }, + { "MID_TANK_7_OVERFLOW", 260 }, + { "MID_TANK_8_EMPTY", 253 }, + { "MID_TANK_8_FILL_TIMEOUT", 269 }, + { "MID_TANK_8_LOW_LEVEL", 245 }, + { "MID_TANK_8_OVERFLOW", 261 }, + { "MIXER_CURRENT_LOOP_BREAK", 149 }, + { "MIXER_CURRENT_OUT_OF_RANGE", 148 }, + { "MIXER_OVERTEMPERATURE", 144 }, + { "MIXER_THERMAL_CUTOFF", 147 }, + { "MIXER_UNDERTEMPERATURE_A", 145 }, + { "MIXER_UNDERTEMPERATURE_B", 146 }, + { "NO_AIR_PRESSURE", 273 }, + { "NO_WASTE_CARTRIDGE_AVAILABLE", 281 }, { "None", 0 }, { "POWER_UP_BIT_FAILURE", 11 }, - { "PULLER_DANCER_MOTOR_OVERCURRENT", 61 }, - { "PULLER_DANCER_MOTOR_OVERTEMPERATURE", 64 }, - { "PULLER_DANCER_MOTOR_STALL", 67 }, - { "PULLER_DANCER_MOTOR_UNDERVOLTAGE", 70 }, - { "PULLER_MOTOR_OVERCURRENT", 29 }, - { "PULLER_MOTOR_OVERTEMPERATURE", 36 }, - { "PULLER_MOTOR_STALL", 43 }, - { "PULLER_MOTOR_UNDERVOLTAGE", 50 }, + { "PULLER_DANCER_MOTOR_OVERCURRENT", 65 }, + { "PULLER_DANCER_MOTOR_OVERTEMPERATURE", 68 }, + { "PULLER_DANCER_MOTOR_STALL", 71 }, + { "PULLER_DANCER_MOTOR_UNDERVOLTAGE", 74 }, + { "PULLER_MOTOR_OVERCURRENT", 33 }, + { "PULLER_MOTOR_OVERTEMPERATURE", 40 }, + { "PULLER_MOTOR_STALL", 47 }, + { "PULLER_MOTOR_UNDERVOLTAGE", 54 }, { "REAR_COVER_OPEN", 18 }, { "RECORDING_STARTED", 8 }, { "RECORDING_STOPPED", 9 }, { "REQUEST_FAILED", 3 }, { "REQUEST_SENT", 1 }, { "RESPONSE_RECEIVED", 2 }, - { "RIGHT_LOADER_MOTOR_OVERCURRENT", 28 }, - { "RIGHT_LOADER_MOTOR_OVERTEMPERATURE", 35 }, - { "RIGHT_LOADER_MOTOR_STALL", 42 }, - { "RIGHT_LOADER_MOTOR_UNDERVOLTAGE", 49 }, - { "RTFU_DOWN_TIMEOUT", 58 }, - { "RTFU_UP_TIMEOUT", 57 }, - { "SCREW_MOTOR_LIMIT_TIMEOUT", 59 }, - { "SCREW_MOTOR_OVERCURRENT", 32 }, - { "SCREW_MOTOR_OVERTEMPERATURE", 39 }, - { "SCREW_MOTOR_STALL", 46 }, - { "SCREW_MOTOR_UNDERVOLTAGE", 53 }, - { "THREAD_BREAK", 24 }, - { "THREAD_TENSION_CONTROL_FAILURE_FEEDER_DANCER", 25 }, - { "THREAD_TENSION_CONTROL_FAILURE_PULLER_DANCER", 72 }, - { "THREAD_TENSION_CONTROL_FAILURE_WINDER_DANCER", 73 }, - { "VOC_SENSOR_ALARM", 270 }, - { "WASTE_CARTRIDGE_PRESENCE_SENSOR_TIMEOUT", 277 }, - { "WASTE_CARTRIDGE_RFID_TIMEOUT", 278 }, - { "WASTE_CONTAINER_EMPTYING_TIMEOUT", 267 }, - { "WASTE_CONTAINER_OVERFLOW", 269 }, - { "WINDER_CONE_DOES_NOT_EXIST", 26 }, - { "WINDER_DANCER_MOTOR_OVERCURRENT", 60 }, - { "WINDER_DANCER_MOTOR_OVERTEMPERATURE", 63 }, - { "WINDER_DANCER_MOTOR_STALL", 66 }, - { "WINDER_DANCER_MOTOR_UNDERVOLTAGE", 69 }, - { "WINDER_MOTOR_OVERCURRENT", 31 }, - { "WINDER_MOTOR_OVERTEMPERATURE", 38 }, - { "WINDER_MOTOR_STALL", 45 }, - { "WINDER_MOTOR_UNDERVOLTAGE", 52 }, + { "RIGHT_LOADER_MOTOR_OVERCURRENT", 32 }, + { "RIGHT_LOADER_MOTOR_OVERTEMPERATURE", 39 }, + { "RIGHT_LOADER_MOTOR_STALL", 46 }, + { "RIGHT_LOADER_MOTOR_UNDERVOLTAGE", 53 }, + { "RTFU_DOWN_TIMEOUT", 62 }, + { "RTFU_UP_TIMEOUT", 61 }, + { "SCREW_MOTOR_LIMIT_TIMEOUT", 63 }, + { "SCREW_MOTOR_OVERCURRENT", 36 }, + { "SCREW_MOTOR_OVERTEMPERATURE", 43 }, + { "SCREW_MOTOR_STALL", 50 }, + { "SCREW_MOTOR_UNDERVOLTAGE", 57 }, + { "THREAD_BREAK", 28 }, + { "THREAD_TENSION_CONTROL_FAILURE_FEEDER_DANCER", 29 }, + { "THREAD_TENSION_CONTROL_FAILURE_PULLER_DANCER", 76 }, + { "THREAD_TENSION_CONTROL_FAILURE_WINDER_DANCER", 77 }, + { "UNSPECIFIED", 27 }, + { "VOC_SENSOR_ALARM_SLOPE", 278 }, + { "VOC_SENSOR_ALARM_TIME", 275 }, + { "WASTE_CARTRIDGE_PRESENCE_SENSOR_TIMEOUT", 283 }, + { "WASTE_CARTRIDGE_RFID_TIMEOUT", 284 }, + { "WASTE_CONTAINER_EMPTYING_TIMEOUT", 272 }, + { "WASTE_CONTAINER_OVERFLOW", 274 }, + { "WINDER_CONE_DOES_NOT_EXIST", 30 }, + { "WINDER_DANCER_MOTOR_OVERCURRENT", 64 }, + { "WINDER_DANCER_MOTOR_OVERTEMPERATURE", 67 }, + { "WINDER_DANCER_MOTOR_STALL", 70 }, + { "WINDER_DANCER_MOTOR_UNDERVOLTAGE", 73 }, + { "WINDER_MOTOR_OVERCURRENT", 35 }, + { "WINDER_MOTOR_OVERTEMPERATURE", 42 }, + { "WINDER_MOTOR_STALL", 49 }, + { "WINDER_MOTOR_UNDERVOLTAGE", 56 }, }; const ProtobufCEnumDescriptor event_type__descriptor = { @@ -581,9 +593,9 @@ const ProtobufCEnumDescriptor event_type__descriptor = "EventType", "EventType", "", - 279, + 285, event_type__enum_values_by_number, - 279, + 285, 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 ae437f66c..f8aecc24f 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 @@ -44,6 +44,10 @@ typedef enum _EventType { EVENT_TYPE__MACHINE_FANS_STOPPED = 2010, EVENT_TYPE__ELECTRICAL_CABINET_FANS_RPM_TOO_LOW = 2011, EVENT_TYPE__ELECTRICAL_CABINET_FANS_STOPPED = 2012, + EVENT_TYPE__MACHINE_STATE_NO_CFG_FILE = 2013, + EVENT_TYPE__MACHINE_STATE_HW_CONFIG_FAILED = 2014, + EVENT_TYPE__MACHINE_STATE_INITIAL_BLOWER_FAILED = 2015, + EVENT_TYPE__UNSPECIFIED = 2016, EVENT_TYPE__THREAD_BREAK = 3000, EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_FEEDER_DANCER = 3001, EVENT_TYPE__WINDER_CONE_DOES_NOT_EXIST = 3002, @@ -94,6 +98,7 @@ typedef enum _EventType { EVENT_TYPE__FEEDER_DANCER_MOTOR_UNDERVOLTAGE = 3047, EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_PULLER_DANCER = 3048, EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_WINDER_DANCER = 3049, + EVENT_TYPE__MACHINE_STATE_NO_THREAD_DETECTED = 3050, EVENT_TYPE__DRYER_MOTOR_OVERCURRENT = 4000, EVENT_TYPE__DRYER_MOTOR_OVERTEMPERATURE = 4001, EVENT_TYPE__DRYER_MOTOR_STALL = 4002, @@ -251,8 +256,8 @@ typedef enum _EventType { EVENT_TYPE__DISPENSER_4_HIGH_PRESSURE = 7083, EVENT_TYPE__DISPENSER_5_HIGH_PRESSURE = 7084, EVENT_TYPE__DISPENSER_6_HIGH_PRESSURE = 7085, - EVENT_TYPE__DISPENSER_8_HIGH_PRESSURE = 7086, - EVENT_TYPE__DISPENSER_7_HIGH_PRESSURE = 7087, + EVENT_TYPE__DISPENSER_7_HIGH_PRESSURE = 7086, + EVENT_TYPE__DISPENSER_8_HIGH_PRESSURE = 7087, EVENT_TYPE__MID_TANK_1_LOW_LEVEL = 8000, EVENT_TYPE__MID_TANK_2_LOW_LEVEL = 8001, EVENT_TYPE__MID_TANK_3_LOW_LEVEL = 8002, @@ -290,9 +295,10 @@ typedef enum _EventType { EVENT_TYPE__WASTE_CONTAINER_EMPTYING_TIMEOUT = 9002, EVENT_TYPE__NO_AIR_PRESSURE = 9003, EVENT_TYPE__WASTE_CONTAINER_OVERFLOW = 9004, - EVENT_TYPE__VOC_SENSOR_ALARM = 9005, + EVENT_TYPE__VOC_SENSOR_ALARM_TIME = 9005, EVENT_TYPE__CHILLER_DRY_CONTACT = 9006, EVENT_TYPE__INSUFFICIENT_AIR_FLOW = 9007, + EVENT_TYPE__VOC_SENSOR_ALARM_SLOPE = 9008, EVENT_TYPE__INK_CARTRIDGE_PRESENCE_SENSOR_TIMEOUT = 10000, EVENT_TYPE__INK_CARTRIDGE_RFID_TIMEOUT = 10001, EVENT_TYPE__NO_WASTE_CARTRIDGE_AVAILABLE = 10002, diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Dispenser_Card/IO_Ports/Dispenser_IO.c b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Dispenser_Card/IO_Ports/Dispenser_IO.c index 790f77f8a..3d1ad4f8c 100644 --- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Dispenser_Card/IO_Ports/Dispenser_IO.c +++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Dispenser_Card/IO_Ports/Dispenser_IO.c @@ -15,6 +15,8 @@ #include #include +TCA9534Regs* Disp_IO_Reg; + uint8_t TCA9534Init(uint8_t Dispenser_ID, TCA9534Regs* Regs)//1 { uint8_t status = PASSED; @@ -267,6 +269,43 @@ uint8_t TCA9534ByPass(uint8_t Dispenser_ID, TCA9534Regs* Regs, bool EnableByPass } +uint8_t Init_Dispensers_IO_Registers(TCA9534Regs* Regs) +{ + uint8_t status = PASSED; + + uint8_t i; + + for(i=0;i<8;i++) + { + if(Dispenser_struct[i].Type == DISP_TYPE_EEPROM128KB) + { + status |= TCA9534Init(i, &Regs); + } + } + + return status; +} + +uint8_t Read_Dispensers_IO_Registers(TCA9534Regs* Regs) +{ + uint8_t status = PASSED; + + uint8_t i; + + for(i=0;i<8;i++) + { + if(Dispenser_struct[i].Type == DISP_TYPE_EEPROM128KB) + { + status |= TCA9534SetReadInputReg(i); + status |= TCA9534ReadInputReg(i, &Regs); + } + } + + return status; +} + + + bool Read_Notification_Disp_UP(uint8_t Dispenser_ID, TCA9534Regs* Regs) { return Regs->Input[Dispenser_ID].bit.DISP_UP; diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Dispenser_Card/IO_Ports/Dispenser_IO.h b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Dispenser_Card/IO_Ports/Dispenser_IO.h index af1470da5..e8784a2ff 100644 --- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Dispenser_Card/IO_Ports/Dispenser_IO.h +++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Dispenser_Card/IO_Ports/Dispenser_IO.h @@ -50,6 +50,8 @@ typedef struct { TCA9534_union Config[8]; } TCA9534Regs; +extern TCA9534Regs* Disp_IO_Reg; + uint8_t TCA9534Init(uint8_t Dispenser_ID, TCA9534Regs* Regs); uint8_t TCA9534SetReadInputReg(uint8_t Dispenser_ID); uint8_t TCA9534ReadInputReg(uint8_t Dispenser_ID, TCA9534Regs* Regs); @@ -61,5 +63,7 @@ bool Read_Notification_Disp_Down(uint8_t Dispenser_ID, TCA9534Regs* Regs); bool Read_Notification_Realy_On(uint8_t Dispenser_ID, TCA9534Regs* Regs); bool Read_Notification_Over_Press(uint8_t Dispenser_ID, TCA9534Regs* Regs); uint8_t test_IO(); +uint8_t Init_Dispensers_IO_Registers(TCA9534Regs* Regs); +uint8_t Read_Dispensers_IO_Registers(TCA9534Regs* Regs); #endif /* DRIVERS_I2C_COMMUNICATION_DISPENSERS_IO_PORT_IO_H_ */ diff --git a/Software/Embedded_SW/Embedded/Main.c b/Software/Embedded_SW/Embedded/Main.c index a125ef10c..64bac419e 100644 --- a/Software/Embedded_SW/Embedded/Main.c +++ b/Software/Embedded_SW/Embedded/Main.c @@ -25,6 +25,12 @@ #include "Communication/CommunicationTask.h" +#include +#include +#include + +#include +#include #include #include "drivers/Flash_ram/FlashProgram.h" @@ -67,7 +73,10 @@ #include "Modules/General/buttons.h" #include "Modules/Waste/Waste.h" +#include //#define WATCHDOG + + //***************************************************************************** // // The system tick rate expressed both as ticks per second and a millisecond @@ -76,6 +85,7 @@ //***************************************************************************** #define TICKS_PER_SECOND 1000 + //***************************************************************************** // // Global system tick counter @@ -94,19 +104,75 @@ F1_GPO_REG F1_GPO_Reg; F3_GPO_01_REG F3_GPO_01_Reg; -//MessageContainer createContainer(MessageType type, char* token, protobuf_c_boolean completed, void* response, size_t (*packPtr)(void*, uint8_t*), size_t (*sizePtr)(void*)); -uint32_t MainDummyFunction(uint32_t IfIndex, uint32_t ReadValue) -{ - return OK; -} -uint32_t HWControlId; +Types_Site *site; +Error_Id eid; +int eCode; -uint32_t MainHWInitCallBackFunction(uint32_t IfIndex, uint32_t BusyFlag) +/* ======== errHook ======== */ +Void errHook(Error_Block *eb) { - RemoveControlCallback(HWControlId, MainHWInitCallBackFunction ); - HWConfigurationInit(); - return OK; + FRESULT Fresult = FR_OK; + FIL *FileHandle = 0; //the system supports a single active file + uint32_t Bytes = 0; + char ErrorPath[50] = "0://ErrorFile.txt"; + char File[50] = ""; + char message[300]; + int len; + + STATUS_GREEN_LED_OFF; + ACTIVITY_GREEN_LED_OFF; + COMM_GREEN_LED_OFF; + + STATUS_RED_LED_ON; + ACTIVITY_RED_LED_ON; + COMM_RED_LED_ON; + + site = Error_getSite(eb); + eid = Error_getId(eb); + eCode = Error_getCode(eb); + FileHandle = my_malloc(sizeof(FIL)); + if (FileHandle == 0) + Fresult = FR_DENIED; + else + { + Fresult = f_open(FileHandle,ErrorPath,FA_OPEN_ALWAYS | FA_WRITE | FA_READ); + if (Fresult == FR_OK) + { + strcpy(File,site->file); + len = usnprintf(message, 80, "\r\n%s %s %s",__DATE__, __TIME__,File); + Fresult = f_write(FileHandle,message,len,&Bytes ); + /* print user supplied error code */ + len = usnprintf(message, 300, "\r\nerror %d, eid %d file %s line %d mod %d", + eCode, eid, site->file, + site->line, + site->mod); + Fresult = f_write(FileHandle,message,len,&Bytes ); + + LOG_ERROR (eCode, "error # "); + /* check originator's mod id against known mods */ + if (site->mod == Main_Module_id()) { + Fresult = f_write(FileHandle,"\r\napp error: ",12,&Bytes ); + } + + /* check error id against known errors */ + if (eid == Error_E_generic) { + Fresult = f_write(FileHandle,"generic: ",10,&Bytes ); + } + else if (eid == Assert_E_assertFailed) { + System_printf("assertion violation: "); + Fresult = f_write(FileHandle,"\r\nassertion violation: ",22,&Bytes ); + } + + /* perform default error output */ + f_close(FileHandle); + } + Task_sleep (200); + my_free(FileHandle); + } + //Power_Reset(); + SysCtlReset(); } + //***************************************************************************** // // Interrupt handler for the system tick counter. @@ -177,7 +243,7 @@ int main(void) #endif #ifdef WATCHDOG - InitWatchdog(ui32SysClock); + InitWatchdog(ui32SysClock*2); #endif CommunicationTaskInit(); @@ -196,8 +262,8 @@ int main(void) Heaters_Init(); MotorsInit(); //Shai WHS_HW_test(); // for WHS sensor test - WHS_init(); - Buttons_Init(); + //WHS_init(); + //Buttons_Init(); //IDS_ModuleInit(); Valve_Set(VALVE_MIXCHIP_WASTECH, Mixer_Waste); @@ -224,6 +290,8 @@ int main(void) //I2C_NFC_Test(); // //test_avi(); //example for shai + Init_Dispensers_IO_Registers(&Disp_IO_Reg); + Set_Speed_Sensor_TypeII_Registers(2,2);//set default values //Read_Speed_Sensor_TypeII();//must be delay between Set_Speed_Sensor_TypeII_Registers to Read_Speed_Sensor_TypeII diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c index 13f0515f9..2256ebd34 100644 --- a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c +++ b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c @@ -243,14 +243,14 @@ const AlarmHandlingItemStruc HardCodedAlarmItem[MAX_SYSTEM_ALARMS]={ {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,RearDoor ,1,false,true,DEBUG_LOG_CATEGORY__Error, 0xFF,5,EVENT_TYPE__REAR_COVER_OPEN,"Rear door Open"}, {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,CartridgesDoor,1,false,true,DEBUG_LOG_CATEGORY__Warning,0xFF,5,EVENT_TYPE__CARTRIDGES_COVER_OPEN,"Cartridges door Open"}, - {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,MIXER_PT100, HARDWARE_PID_CONTROL_TYPE__MixerHeater ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MIXER_UNDERTEMPERATURE_A,"Mixer PT100 Not Heating"}, - {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1 ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_A,"DyeingHead 1 PT100 Not Heating"}, - {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2 ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_A,"DyeingHead 2 PT100 Not Heating"}, - {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3 ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_A,"DyeingHead 3 PT100 Not Heating"}, - {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4 ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_A,"DyeingHead 4 PT100 Not Heating"}, - {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5 ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_A,"DyeingHead 5 PT100 Not Heating"}, - {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,HEAD6_PT100, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6 ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_A,"DyeingHead 6 PT100 Not Heating"}, - {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1, HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_A,"Dryer PT100 Not Heating"}, + {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,MIXER_PT100, HARDWARE_PID_CONTROL_TYPE__MixerHeater ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__MIXER_UNDERTEMPERATURE_A,"Mixer PT100 Not Heating"}, + {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1 ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_A,"DyeingHead 1 PT100 Not Heating"}, + {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2 ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_A,"DyeingHead 2 PT100 Not Heating"}, + {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3 ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_A,"DyeingHead 3 PT100 Not Heating"}, + {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4 ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_A,"DyeingHead 4 PT100 Not Heating"}, + {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5 ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_A,"DyeingHead 5 PT100 Not Heating"}, + {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,HEAD6_PT100, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6 ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_A,"DyeingHead 6 PT100 Not Heating"}, + {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1, HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_A,"Dryer PT100 Not Heating"}, {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,MIXER_PT100, HARDWARE_PID_CONTROL_TYPE__MixerHeater ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MIXER_UNDERTEMPERATURE_B,"Mixer PT100 Heating Failure"}, {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1 ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_B,"DyeingHead 1 PT100 Heating Failure"}, {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2 ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_B,"DyeingHead 2 PT100 Heating Failure"}, @@ -674,21 +674,25 @@ void AlarmHandlingInternalSetAlarm(uint32_t AlarmId, bool value) AlarmState[Alarm_i].EventPtr = my_malloc (sizeof(Event)); if (AlarmState[Alarm_i].EventPtr) { + //ROM_IntMasterDisable(); 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 = AlarmItem[Alarm_i].EventName; - AlarmState[Alarm_i].Status = value; - Report("Alarm ON ", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, RpMessage, value, Alarm_i); + AlarmState[Alarm_i].Status = value; } + //ROM_IntMasterEnable(); + Report("Alarm ON ", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, RpMessage, value, Alarm_i); } else { Report("Alarm OFF ", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, RpMessage, value, Alarm_i); if (AlarmState[Alarm_i].EventPtr) { + //ROM_IntMasterDisable(); my_free(AlarmState[Alarm_i].EventPtr); AlarmState[Alarm_i].EventPtr = NULL; + //ROM_IntMasterEnable(); } AlarmState[Alarm_i].Status = value; } @@ -923,8 +927,6 @@ uint32_t AlarmHandlingLoop(uint32_t tick) { if (Status == true) // alarm on { - AlarmState[Alarm_i].Status = true; - AlarmHandlingConsequentActions(Alarm_i, AlarmItem[Alarm_i].Severity); // report the alarm! AlarmState[Alarm_i].EventPtr = my_malloc (sizeof(Event)); if (AlarmState[Alarm_i].EventPtr) @@ -934,15 +936,21 @@ uint32_t AlarmHandlingLoop(uint32_t tick) AlarmState[Alarm_i].EventPtr->type = AlarmItem[Alarm_i].EventType; AlarmState[Alarm_i].EventPtr->message = AlarmItem[Alarm_i].EventName; } + AlarmState[Alarm_i].Status = true; + AlarmHandlingConsequentActions(Alarm_i, AlarmItem[Alarm_i].Severity); Report("Alarm ON ", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, RpMessage, value, Alarm_i); } else // alarm off { - AlarmState[Alarm_i].Status = false; - AlarmHandlingConsequentActions(Alarm_i, DEBUG_LOG_CATEGORY__Info); - // report the alarm! if (AlarmState[Alarm_i].EventPtr) + { + //ROM_IntMasterDisable(); 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); Report("Alarm OFF ", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, RpMessage, 0, Alarm_i); } } diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c index 97489f431..da16df729 100644 --- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c +++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c @@ -243,17 +243,17 @@ uint32_t SetDigitalOutRequestRequestFunc(MessageContainer* requestContainer) /* case INTERFACE_IOS__GPO_LED4: DataUpdated = request->value; break;*/ - case INTERFACE_IOS__VALVE_WASTE_TANK: + case INTERFACE_IOS__GPO_BLOWER_PWM: if (request->value == true) - Valve_Set(VALVE_MIXCHIP_WASTECH,1); + Control_Dryer_Fan(START,75); else - Valve_Set(VALVE_MIXCHIP_WASTECH,0); + Control_Dryer_Fan(STOP, 0); break; - case INTERFACE_IOS__GPO_BLOWER_PWM: + case INTERFACE_IOS__VALVE_WASTE_TANK: if (request->value == true) - Control_Dryer_Fan(START,75);//use START or STOP, 0 - 100%(); + Valve_Set(VALVE_MIXCHIP_WASTECH,1); else - Control_Dryer_Fan(STOP,0);//use START or STOP, 0 - 100%(); + Valve_Set(VALVE_MIXCHIP_WASTECH,0); break; case INTERFACE_IOS__GPO_WASTECH_PUMP2://valve Valve_Set(VALVE_WASTE_TANK, request->value); diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c index 5ef216264..b09e47b45 100644 --- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c +++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c @@ -152,7 +152,7 @@ void DiagnosticsInit(void) Error_init(&eb); - DiagnosticsMsgQ = Mailbox_create(sizeof(DiagnosticsMessageStruc), 20, NULL,&eb); + DiagnosticsMsgQ = Mailbox_create(sizeof(DiagnosticsMessageStruc), 40, NULL,&eb); DiagnosticsMonitor.dispensersmotorsfrequency = (DoubleArray**)my_malloc(sizeof(DoubleArray *)*8); DiagnosticsMonitor.dispenserspressure = (DoubleArray**)my_malloc(sizeof(DoubleArray)*8); diff --git a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c index 6f1dc2052..f0ce7397c 100644 --- a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c +++ b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c @@ -118,7 +118,7 @@ void LoadConfigurationParameters(ConfigurationParameters *Params) EmbeddedParameters.has_breaksensorlimit = true; EmbeddedParameters.breaksensorlimit = 10; EmbeddedParameters.has_diagnosticcollectionlimit = true; - EmbeddedParameters.diagnosticcollectionlimit = 2; + EmbeddedParameters.diagnosticcollectionlimit = 1; EmbeddedParameters.has_overheatcountlimit = true; EmbeddedParameters.overheatcountlimit = 3; EmbeddedParameters.has_underheatcountlimit = true; @@ -130,7 +130,7 @@ void LoadConfigurationParameters(ConfigurationParameters *Params) EmbeddedParameters.has_initialdispenserpressure = true; EmbeddedParameters.initialdispenserpressure = 0.08; EmbeddedParameters.has_initialdispensertimeout = true; - EmbeddedParameters.initialdispensertimeout = 10000; + EmbeddedParameters.initialdispensertimeout = 60000; EmbeddedParameters.has_initialdispensertimelag = true; EmbeddedParameters.initialdispensertimelag = 100; EmbeddedParameters.has_dispenserbuildpressurespeed = true; @@ -138,7 +138,7 @@ void LoadConfigurationParameters(ConfigurationParameters *Params) EmbeddedParameters.has_dispenserbuildpressurelimit = true; EmbeddedParameters.dispenserbuildpressurelimit=1.5 ; EmbeddedParameters.has_dispenserbuildpressuretimeout = true; - EmbeddedParameters.dispenserbuildpressuretimeout=20000; + EmbeddedParameters.dispenserbuildpressuretimeout=50000; EmbeddedParameters.has_dispenserbuildpressurelag = true; EmbeddedParameters.dispenserbuildpressurelag=50; EmbeddedParameters.has_acheatersloweroperationlimit = true; @@ -150,7 +150,7 @@ void LoadConfigurationParameters(ConfigurationParameters *Params) EmbeddedParameters.has_dcheatersupperoperationlimit = true; EmbeddedParameters.dcheatersupperoperationlimit = 1002; EmbeddedParameters.has_midtankpressurecorrection = true; - EmbeddedParameters.midtankpressurecorrection = 0.2; + EmbeddedParameters.midtankpressurecorrection = 0.0; EmbeddedParameters.has_dispenserpresegmentwfcf = true; EmbeddedParameters.dispenserpresegmentwfcf = 80; EmbeddedParameters.has_startheatingoninitsequence = true; diff --git a/Software/Embedded_SW/Embedded/Modules/General/Safety.c b/Software/Embedded_SW/Embedded/Modules/General/Safety.c index 840898db7..f54a4be19 100644 --- a/Software/Embedded_SW/Embedded/Modules/General/Safety.c +++ b/Software/Embedded_SW/Embedded/Modules/General/Safety.c @@ -25,7 +25,10 @@ uint32_t SafetyControlId; bool DispenserOverPressure[MAX_SYSTEM_DISPENSERS] = {false,false,false,false,false,false,false,false}; uint32_t Safety_Main_State(uint32_t IfIndex, uint32_t BusyFlag); - +bool DrierDoorAlarmState = false; +bool AirFlowAlarmState = false; +bool AirFilterAlarmState = false; +bool WasteOverflowAlarmState = false; void Safety_Init(void) { SafetyControlId = AddControlCallback( Safety_Main_State, eOneSecond, TemplateDataReadCBFunction,0,0, 0 ); @@ -36,6 +39,10 @@ uint32_t Safety_Main_State(uint32_t IfIndex, uint32_t BusyFlag) int Disp_i; bool AllDispensersInSafety = true; bool AnyDispensersInSafety = false; + /*bool mDrierDoorAlarmState = false; + bool mAirFlowAlarmState = false; + bool mAirFilterAlarmState = false; + bool mWasteOverflowAlarmState = false;*/ for (Disp_i = 0;Disp_i < MAX_SYSTEM_DISPENSERS;Disp_i++) { if (isMotorConfigured(Disp_i + HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1)==true) @@ -51,6 +58,8 @@ uint32_t Safety_Main_State(uint32_t IfIndex, uint32_t BusyFlag) { //report and handle dryer door open AlarmHandlingSetAlarm(EVENT_TYPE__DRYER_DOOR_OPEN, true); + // mDrierDoorAlarmState = true; + // DrierDoorAlarmState = true; } else { @@ -59,6 +68,8 @@ uint32_t Safety_Main_State(uint32_t IfIndex, uint32_t BusyFlag) //report and handle air flow failure //if blower if off handling is different AlarmHandlingSetAlarm(EVENT_TYPE__NO_AIR_PRESSURE, true); + // mAirFlowAlarmState = true; + // AirFlowAlarmState = true; } else { @@ -66,6 +77,8 @@ uint32_t Safety_Main_State(uint32_t IfIndex, uint32_t BusyFlag) { //report and handle filter missing AlarmHandlingSetAlarm(EVENT_TYPE__AIR_FILTER_NOT_INSTALLED, true); + // mAirFilterAlarmState = true; + // AirFilterAlarmState = true; } else { @@ -73,6 +86,8 @@ uint32_t Safety_Main_State(uint32_t IfIndex, uint32_t BusyFlag) { //report and handle waste overflow AlarmHandlingSetAlarm(EVENT_TYPE__WASTE_CONTAINER_OVERFLOW, true); + // mWasteOverflowAlarmState = true; + // WasteOverflowAlarmState = true; } } } @@ -108,7 +123,31 @@ uint32_t Safety_Main_State(uint32_t IfIndex, uint32_t BusyFlag) } } } - +/* if ((mDrierDoorAlarmState != DrierDoorAlarmState)|| (mDrierDoorAlarmState == false)) + { + //alarm went off + AlarmHandlingSetAlarm(EVENT_TYPE__DRYER_DOOR_OPEN, false); + DrierDoorAlarmState = mDrierDoorAlarmState; + } + if ((mAirFlowAlarmState != AirFlowAlarmState)|| (mAirFlowAlarmState == false)) + { + //alarm went off + AlarmHandlingSetAlarm(EVENT_TYPE__NO_AIR_PRESSURE, false); + AirFlowAlarmState = mAirFlowAlarmState; + } + if ((mAirFilterAlarmState != AirFilterAlarmState)|| (mAirFilterAlarmState == false)) + { + //alarm went off + AlarmHandlingSetAlarm(EVENT_TYPE__AIR_FILTER_NOT_INSTALLED, false); + AirFilterAlarmState = mAirFilterAlarmState; + } + if ((mWasteOverflowAlarmState != WasteOverflowAlarmState)|| (mWasteOverflowAlarmState == false)) + { + //alarm went off + AlarmHandlingSetAlarm(EVENT_TYPE__WASTE_CONTAINER_OVERFLOW, false); + WasteOverflowAlarmState = mWasteOverflowAlarmState; + } +*/ return OK; } diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c index 5ebe10705..3401dbaaa 100644 --- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c +++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c @@ -197,7 +197,7 @@ JobDescriptionFileBrushStop *GetNextBrushStopFromJobFile(); void FreeBrushStopFileData(JobDescriptionFileBrushStop *BrushStop); */ - /************************************************************************************************************************************/ + /************************************************************************************************************************************ uint32_t IDS_MapDispenserUsedinFileJobshort(void *JobDetails) { JobTicket* JobTicket = JobDetails; @@ -206,6 +206,7 @@ void FreeBrushStopFileData(JobDescriptionFileBrushStop *BrushStop); int Dispenser_i, Brush_i,DispenserId; FRESULT Fresult = FR_OK; uint32_t status = OK; + bool lookForLubrication = false; for (Dispenser_i = 0;Dispenser_ienablelubrication == true) + { DispenserUsedInJob[LUBRICANT_DISPENSER] = true; + lookForLubrication = true; + } Fresult = OpenJobFile(); if (Fresult == FR_OK) @@ -238,12 +242,12 @@ void FreeBrushStopFileData(JobDescriptionFileBrushStop *BrushStop); if (BrushStop->dispensers[Dispenser_i]->nanolitterpersecond>0.0) { DispenserUsedInJob[DispenserId] = true; - /*if(DispenserId == LUBRICANT_DISPENSER) + if ((lookForLubrication == true)&&(DispenserId == LUBRICANT_DISPENSER)) { - lubricant_speed = JobTicket->segments[0]->brushstops[0]->dispensers[Dispenser_i]->nanolitterpersecond/ - JobTicket->segments[0]->brushstops[0]->dispensers[Dispenser_i]->nanoliterperpulse; - REPORT_MSG (lubricant_speed*100, "LUBRICANT_SPEED*100"); - }*/ + lookForLubrication = false; + lubricant_speed = BrushStop->dispensers[Dispenser_i]->nanolitterpersecond/BrushStop->dispensers[Dispenser_i]->nanoliterperpulse; + REPORT_MSG (lubricant_speed*100, "LUBRICANT_SPEED*100"); + } } }//for dispenser }//if dispensers @@ -270,6 +274,7 @@ void FreeBrushStopFileData(JobDescriptionFileBrushStop *BrushStop); return status; } + *************************************************************************************************************************************/ /************************************************************************************************************************************/ uint32_t IDS_MapDispenserUsedinFileJob(void *JobDetails) { @@ -282,7 +287,8 @@ void FreeBrushStopFileData(JobDescriptionFileBrushStop *BrushStop); uint32_t status = OK; FRESULT Fresult = FR_OK; FIL *FileHandle = 0; //the system supports a single active file - + bool lookForLubrication = false; + int brushCounter = 0; /* Parsing the job description file. The job description file simply contains an array of segments and their brush stops. @@ -312,7 +318,10 @@ c. Go to step 2.a x Segment.BrushStopsCount. if (EnableCleaning == true) DispenserUsedInJob[CLEANER_DISPENSER] = true; if (JobTicket->enablelubrication == true) + { DispenserUsedInJob[LUBRICANT_DISPENSER] = true; + lookForLubrication = true; + } if (JobTicket->uploadstrategy == JOB_UPLOAD_STRATEGY__JobDescriptionFile) { FileHandle = my_malloc(sizeof(FIL)); @@ -337,7 +346,7 @@ c. Go to step 2.a x Segment.BrushStopsCount. Segment = job_description_file_segment__unpack(NULL, SegmentSize, SegmentPtr); if ((Segment->has_brushstopscount)&&(Segment->brushstopscount)) { - REPORT_MSG (Segment->brushstopscount, "Segment->brushstopscount"); + //REPORT_MSG (Segment->brushstopscount, "Segment->brushstopscount"); for (Brush_i=0;Brush_ibrushstopscount;Brush_i++) { if (status == ERROR) @@ -354,7 +363,12 @@ c. Go to step 2.a x Segment.BrushStopsCount. { readBytes += ImmediateRead; BrushStop = job_description_file_brush_stop__unpack(NULL, BrushStopSize, BrushStopPtr); - REPORT_MSG (BrushStopSize, "BrushStop"); + //REPORT_MSG (BrushStopSize, "BrushStop"); + if ((brushCounter++ % 100)==0) + { + SendJobProgress(0.0,0,false, "Processing file"); + Control_WD(ENABLE,55); //activate heaters/dispenser watchdog, 0.5 seconds + } if (BrushStop->n_dispensers) { for (Dispenser_i = 0;Dispenser_i < BrushStop->n_dispensers;Dispenser_i++) @@ -365,6 +379,12 @@ c. Go to step 2.a x Segment.BrushStopsCount. { DispenserUsedInJob[DispenserId] = true; } + if ((lookForLubrication == true)&&(DispenserId == LUBRICANT_DISPENSER)) + { + lookForLubrication = false; + lubricant_speed = BrushStop->dispensers[Dispenser_i]->nanolitterpersecond/BrushStop->dispensers[Dispenser_i]->nanoliterperpulse; + REPORT_MSG (lubricant_speed*100, "LUBRICANT_SPEED*100"); + } }//for dispenser }//if dispensers else @@ -529,7 +549,7 @@ c. Go to step 2.a x Segment.BrushStopsCount. //IDS_MapDispenserUsedinJob(JobDetails); for (i = 0; i < MAX_SYSTEM_DISPENSERS; i++) { - IDS_StopHomeDispenser(i); + //IDS_StopHomeDispenser(i); if (DispenserUsedInJob[i] == true) //we actually should check for all dispensers { DispenserReady[i] = false; @@ -1060,7 +1080,7 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId) //TimerMotors_t HW_Motor_Id = DispenserIdToMotorId[deviceID]; //REPORT_MSG(deviceID,"Dispenser End called"); //MotorStop(HW_Motor_Id,Hard_Hiz); - IDS_HomeDispenser (deviceID, 800 , NULL); + //IDS_HomeDispenser (deviceID, 800 , NULL); return OK; } @@ -1100,6 +1120,7 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId) uint32_t IDS_StartLubrication(void) { IDS_Dispenser_Start_Motor_and_Open_Valve(LUBRICANT_DISPENSER,lubricant_speed,NULL); + REPORT_MSG (lubricant_speed, "IDS_StartLubrication"); Lubricant_2Way_Valve (START); return OK; } @@ -1108,6 +1129,7 @@ uint32_t IDS_StopLubrication(void) if(DispenserUsedInJob[LUBRICANT_DISPENSER]) { IDS_Dispenser_Close_Valve_And_Stop_Motor(LUBRICANT_DISPENSER,IDS_Valve_EndValveReady); + REPORT_MSG (lubricant_speed, "IDS_StopLubrication"); Lubricant_2Way_Valve (STOP); } return OK; diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c index d041b648e..34cb61e27 100644 --- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c +++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c @@ -9,6 +9,9 @@ #include "Drivers/USB_Communication/USBCDCD.h" #include "StateMachines/Initialization/PowerOffSequence.h" +#include "drivers/Flash_Memory/FATFS/ff.h" +#include "drivers/Flash_Memory/FATFS/Control_File_System.h" + //#include "graphics_adapter.h" void Stub_ProgressRequest(MessageContainer* requestContainer) @@ -20,27 +23,42 @@ void Stub_ProgressRequest(MessageContainer* requestContainer) //writeLine("Progress Request..."); ProgressResponse response = PROGRESS_RESPONSE__INIT; - response.has_progress = true; - PowerOffInit(); - int i = 0; - for (i = 0; i < request->amount; i++) - { - response.progress = i; - responseContainer = createContainer(MESSAGE_TYPE__ProgressResponse, requestContainer->token, false, &response, &progress_response__pack, &progress_response__get_packed_size); - uint8_t* container_buffer = malloc(message_container__get_packed_size(&responseContainer)); - size_t container_size = message_container__pack(&responseContainer, container_buffer); - free(responseContainer.data.data); - SendChars((char*)container_buffer, container_size); - //free(container_buffer); - - int co = 0; - for (co = 0; co < request->delay; co++) + if((request->amount == 0xCF) && (request->delay == 0xCF)) //Create File System on the Drive + { + FRESULT iFResult = Init_Flash_File_System(true); + if(iFResult != FR_OK) { - __delay_cycles(1000000); + LOG_ERROR (iFResult, "Error during init Flash File System"); + assert(iFResult); } } + else if((request->amount == 0xDF) && (request->delay == 0xDF)) //Power off + { + PowerOffInit(); + } + else + { + response.has_progress = true; + int i = 0; + for (i = 0; i < request->amount; i++) + { + response.progress = i; + responseContainer = createContainer(MESSAGE_TYPE__ProgressResponse, requestContainer->token, false, &response, &progress_response__pack, &progress_response__get_packed_size); + uint8_t* container_buffer = malloc(message_container__get_packed_size(&responseContainer)); + size_t container_size = message_container__pack(&responseContainer, container_buffer); + free(responseContainer.data.data); + SendChars((char*)container_buffer, container_size); + //free(container_buffer); + + int co = 0; + for (co = 0; co < request->delay; co++) + { + __delay_cycles(1000000); + } + } + } responseContainer = createContainer(MESSAGE_TYPE__ProgressResponse, requestContainer->token, true, &response, &progress_response__pack, &progress_response__get_packed_size); uint8_t* container_buffer = malloc(message_container__get_packed_size(&responseContainer)); size_t container_size = message_container__pack(&responseContainer, container_buffer); -- cgit v1.3.1 From fd7196c48de7ca02e9461b08022bb5538b0ec42e Mon Sep 17 00:00:00 2001 From: Shlomo Hecht Date: Mon, 29 Apr 2019 14:10:49 +0300 Subject: dispenser dtat writing disabled (potential disconnect cause). heaters bug. --- Software/Embedded_SW/Embedded/Main.c | 6 ++---- Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c | 2 +- Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c | 2 +- 3 files changed, 4 insertions(+), 6 deletions(-) (limited to 'Software/Embedded_SW/Embedded/Modules') diff --git a/Software/Embedded_SW/Embedded/Main.c b/Software/Embedded_SW/Embedded/Main.c index 64bac419e..379c45f76 100644 --- a/Software/Embedded_SW/Embedded/Main.c +++ b/Software/Embedded_SW/Embedded/Main.c @@ -262,8 +262,8 @@ int main(void) Heaters_Init(); MotorsInit(); //Shai WHS_HW_test(); // for WHS sensor test - //WHS_init(); - //Buttons_Init(); + WHS_init(); + Buttons_Init(); //IDS_ModuleInit(); Valve_Set(VALVE_MIXCHIP_WASTECH, Mixer_Waste); @@ -310,8 +310,6 @@ int main(void) IDLE_TASK_package_init(); -// HWControlId = AddControlCallback( MainHWInitCallBackFunction, 2* eOneSecond/*eHundredMillisecond*/, MainDummyFunction,0,0, 0 ); - Start_InitSequence(); PowerIdleInit(); BIOS_start(); diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c index b09e47b45..f2b629c51 100644 --- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c +++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c @@ -819,7 +819,7 @@ void DiagnosticsTask(UArg arg0, UArg arg1) DiagnosticTenMsecCollection(); break; case DispensersCollectionTrigger: - DispensersCollectionCall(); + //DispensersCollectionCall(); //suspended for ITMA break; default: break; diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c index 8fe0a9fd8..7a013f49f 100644 --- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c +++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c @@ -875,7 +875,7 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue) Control_Voltage_To_Blower(BlowerCfg.voltage); } } - if ((HeaterCmd[index].targettemperatue * AcHeatersLoweroperationLimit/1000)&&(readValue < (HeaterCmd[index].targettemperatue * AcHeatersUpperoperationLimit/1000)))//read value within 0.5 percent from target + if ((readValue > HeaterCmd[index].targettemperatue * AcHeatersLoweroperationLimit/1000)&&(readValue < (HeaterCmd[index].targettemperatue * AcHeatersUpperoperationLimit/1000)))//read value within 0.5 percent from target { ////////////////// //InitialHeating = false; -- cgit v1.3.1 From 0ab9e00c3593340713276a7132eb58410d9b2d3d Mon Sep 17 00:00:00 2001 From: Avi Levkovich Date: Mon, 29 Apr 2019 15:22:24 +0300 Subject: Add brackets to defines with calculation --- Software/Embedded_SW/Embedded/Drivers/Motors/Motor.h | 2 +- Software/Embedded_SW/Embedded/Drivers/SSI_Comm/SSI_Comm.h | 2 +- Software/Embedded_SW/Embedded/Modules/Heaters/Heaters.h | 2 +- Software/Embedded_SW/Embedded/Modules/Thread/Thread.h | 4 ++-- Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h | 2 +- 5 files changed, 6 insertions(+), 6 deletions(-) (limited to 'Software/Embedded_SW/Embedded/Modules') diff --git a/Software/Embedded_SW/Embedded/Drivers/Motors/Motor.h b/Software/Embedded_SW/Embedded/Drivers/Motors/Motor.h index 3b9eba3d8..894f60c09 100644 --- a/Software/Embedded_SW/Embedded/Drivers/Motors/Motor.h +++ b/Software/Embedded_SW/Embedded/Drivers/Motors/Motor.h @@ -20,7 +20,7 @@ #define TimerMotors_t HardwareMotorType -#define NUM_OF_MOTORS HARDWARE_MOTOR_TYPE__MOTO_RLOADING + 1 // TODO After the integration with mulbery change to: +#define NUM_OF_MOTORS (HARDWARE_MOTOR_TYPE__MOTO_RLOADING + 1) // TODO After the integration with mulbery change to: //#define NUM_OF_MOTORS HARDWARE_MOTOR_TYPE__MOTO_SPARE1_1 diff --git a/Software/Embedded_SW/Embedded/Drivers/SSI_Comm/SSI_Comm.h b/Software/Embedded_SW/Embedded/Drivers/SSI_Comm/SSI_Comm.h index 9028de45b..3a1c3ad5b 100644 --- a/Software/Embedded_SW/Embedded/Drivers/SSI_Comm/SSI_Comm.h +++ b/Software/Embedded_SW/Embedded/Drivers/SSI_Comm/SSI_Comm.h @@ -23,7 +23,7 @@ NUM_OF_ROTENC }RotEnc_t;*/ -#define NUM_OF_ROTENC HARDWARE_DANCER_TYPE__RightDancer+1 +#define NUM_OF_ROTENC (HARDWARE_DANCER_TYPE__RightDancer+1) void SSI1_Init(); diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters.h b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters.h index 3c9c59f3e..b25c3e5c7 100644 --- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters.h +++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters.h @@ -5,7 +5,7 @@ #include "PMR/Hardware/HardwarePidControlType.pb-c.h" #include "heaters_ex.h" /******************** DEFINITIONS ********************************************/ -#define MAX_AC_HEATERS HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary+1 +#define MAX_AC_HEATERS (HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary+1) #define MAX_TIMESLICES 200 extern uint32_t OutputProportionalSingleStep; //A/C Heaters step size from one decision point to another - in cpu clocks. 120000 = 1 millisecod diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread.h b/Software/Embedded_SW/Embedded/Modules/Thread/Thread.h index 3e2a6aa40..97f3811c7 100644 --- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread.h +++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread.h @@ -41,8 +41,8 @@ typedef struct }MotorControlConfig_t; -#define MAX_THREAD_FEED_MOTORS WINDER_MOTOR+1 -#define MAX_SYSTEM_DANCERS HARDWARE_DANCER_TYPE__RightDancer+1 +#define MAX_THREAD_FEED_MOTORS (WINDER_MOTOR+1) +#define MAX_SYSTEM_DANCERS (HARDWARE_DANCER_TYPE__RightDancer+1) extern TimerMotors_t ThreadMotorIdToMotorId[MAX_THREAD_MOTORS_NUM]; extern HardwareDancerType ThreadMotorIdToDancerId[MAX_THREAD_MOTORS_NUM]; diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h index d7ce917c0..91eedeb6b 100644 --- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h +++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h @@ -9,7 +9,7 @@ #define WINDER_DANCER HARDWARE_DANCER_TYPE__LeftDancer #define POOLER_DANCER HARDWARE_DANCER_TYPE__MiddleDancer #define FEEDER_DANCER HARDWARE_DANCER_TYPE__RightDancer -#define NUM_OF_DANCERS HARDWARE_DANCER_TYPE__RightDancer+1 +#define NUM_OF_DANCERS (HARDWARE_DANCER_TYPE__RightDancer+1) //} DANCER_ENUM; typedef enum threadMotorsEnum { -- cgit v1.3.1 From 594aa33b9a0689a8b75e5b0ea87a4b6fc01a3deb Mon Sep 17 00:00:00 2001 From: Shlomo Hecht Date: Mon, 29 Apr 2019 15:26:11 +0300 Subject: lubricant - divide the motor speed acording to microsteps --- .../Embedded_SW/Embedded/Modules/IDS/IDS_print.c | 33 ++++++++++++++++++++++ 1 file changed, 33 insertions(+) (limited to 'Software/Embedded_SW/Embedded/Modules') diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c index 3401dbaaa..4bcdcc06a 100644 --- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c +++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c @@ -246,6 +246,17 @@ void FreeBrushStopFileData(JobDescriptionFileBrushStop *BrushStop); { lookForLubrication = false; lubricant_speed = BrushStop->dispensers[Dispenser_i]->nanolitterpersecond/BrushStop->dispensers[Dispenser_i]->nanoliterperpulse; + if (BrushStop->dispensers[Dispenser_i]->dispenserstepdivision + != DISPENSER_STEP_DIVISION__Auto) + { + //MotorSetMicroStep(HW_Motor_Id, Dispensers[Dispenser_i]->dispenserstepdivision); + lubricant_speed /= + BrushStop->dispensers[Dispenser_i]->dispenserstepdivision; //the dye supply is calculated based on a 1/8 microstep + } + else + { + lubricant_speed/=8;//MotorsCfg[HW_Motor_Id].microstep; //the dye supply is calculated based on a 1/8 microstep + } REPORT_MSG (lubricant_speed*100, "LUBRICANT_SPEED*100"); } } @@ -383,6 +394,17 @@ c. Go to step 2.a x Segment.BrushStopsCount. { lookForLubrication = false; lubricant_speed = BrushStop->dispensers[Dispenser_i]->nanolitterpersecond/BrushStop->dispensers[Dispenser_i]->nanoliterperpulse; + if (BrushStop->dispensers[Dispenser_i]->dispenserstepdivision + != DISPENSER_STEP_DIVISION__Auto) + { + //MotorSetMicroStep(HW_Motor_Id, Dispensers[Dispenser_i]->dispenserstepdivision); + lubricant_speed /= + BrushStop->dispensers[Dispenser_i]->dispenserstepdivision; //the dye supply is calculated based on a 1/8 microstep + } + else + { + lubricant_speed/=8;//MotorsCfg[HW_Motor_Id].microstep; //the dye supply is calculated based on a 1/8 microstep + } REPORT_MSG (lubricant_speed*100, "LUBRICANT_SPEED*100"); } }//for dispenser @@ -497,6 +519,17 @@ c. Go to step 2.a x Segment.BrushStopsCount. { lubricant_speed = JobTicket->segments[0]->brushstops[0]->dispensers[Dispenser_i]->nanolitterpersecond/ JobTicket->segments[0]->brushstops[0]->dispensers[Dispenser_i]->nanoliterperpulse; + if (JobTicket->segments[0]->brushstops[0]->dispensers[Dispenser_i]->dispenserstepdivision + != DISPENSER_STEP_DIVISION__Auto) + { + //MotorSetMicroStep(HW_Motor_Id, Dispensers[Dispenser_i]->dispenserstepdivision); + lubricant_speed /= + JobTicket->segments[0]->brushstops[0]->dispensers[Dispenser_i]->dispenserstepdivision; //the dye supply is calculated based on a 1/8 microstep + } + else + { + lubricant_speed/=8;//MotorsCfg[HW_Motor_Id].microstep; //the dye supply is calculated based on a 1/8 microstep + } REPORT_MSG (lubricant_speed*100, "LUBRICANT_SPEED*100"); } -- cgit v1.3.1 From 3e5e7e29a922b4e33b286292a743e69421dfb41f Mon Sep 17 00:00:00 2001 From: Shlomo Hecht Date: Tue, 30 Apr 2019 11:52:07 +0300 Subject: new embedded parameters file --- .../Embedded/Modules/AlarmHandling/AlarmHandling.c | 4 +-- .../Modules/Diagnostics/DiagnosticActions.c | 6 ----- .../stubs/embeddedparametersbuild.cs | 30 ++++++++++++++++++++-- 3 files changed, 30 insertions(+), 10 deletions(-) (limited to 'Software/Embedded_SW/Embedded/Modules') diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c index 2256ebd34..2a7aef30a 100644 --- a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c +++ b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c @@ -865,14 +865,14 @@ uint32_t AlarmHandlingLoop(uint32_t tick) value = Get_MidTank_Int100_Sensor(AlarmItem[Alarm_i].DeviceId); if (AlarmItem[Alarm_i].AlarmDirection == OVER_VALUE) { - if (value*100 > AlarmItem[Alarm_i].AlarmValue) + if (value > AlarmItem[Alarm_i].AlarmValue) { Status = true; } } else { - if (value*100 < AlarmItem[Alarm_i].AlarmValue) + if (value < AlarmItem[Alarm_i].AlarmValue) { Status = true; } diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c index 6a1821f4b..2b24f9832 100644 --- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c +++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c @@ -244,12 +244,6 @@ uint32_t SetDigitalOutRequestRequestFunc(MessageContainer* requestContainer) /* case INTERFACE_IOS__GPO_LED4: DataUpdated = request->value; break;*/ -/* case INTERFACE_IOS__GPO_BLOWER_PWM: - if (request->value == true) - Control_Dryer_Fan(START,75); - else - Control_Dryer_Fan(STOP, 0); - break;*/ case INTERFACE_IOS__VALVE_WASTE_TANK: if (request->value == true) Valve_Set(VALVE_MIXCHIP_WASTECH,1); diff --git a/Software/Stubs Collection/stubs/embeddedparametersbuild.cs b/Software/Stubs Collection/stubs/embeddedparametersbuild.cs index 3ad7c1da8..b896e9968 100644 --- a/Software/Stubs Collection/stubs/embeddedparametersbuild.cs +++ b/Software/Stubs Collection/stubs/embeddedparametersbuild.cs @@ -50,8 +50,34 @@ configurationParameters.ACHeatersUpperOperationLimit = 1005; configurationParameters.DCHeatersLowerOperationLimit = 978; configurationParameters.DCHeatersUpperOperationLimit = 1005; -configurationParameters.MidTankPressureCorrection = 0.2; - +configurationParameters.MidTankPressureCorrection = 0.0; + +configurationParameters.DispenserPresegmentWFCF = 80; +configurationParameters.StartHeatingOnInitSequence = false; + +Double checkHardLimitAlarms = new Double(1); +configurationParameters.GeneralParameters.Add(checkHardLimitAlarms); +Double checkCurrentAlarms = new Double(1); +configurationParameters.GeneralParameters.Add(checkCurrentAlarms); +Double checkTamperAlarms = new Double(1); +configurationParameters.GeneralParameters.Add(checkTamperAlarms); + +configurationParameters.CurrentAlarmLowLimit = 0.80; +configurationParameters.CurrentAlarmHighLimit = 1.07; +configurationParameters.IDSSegmentRefillTimeout = 5000; +configurationParameters.IDSPreSegmentBuildupTime = 5000; +configurationParameters.IDSCleaningSpeed = 50; +configurationParameters.IDSCleaningStopBeforeSegmentTime = 3000; +configurationParameters.IDSCleaningStartSprayPreSegmentTime = 1000; +configurationParameters.IDSLeftCleaningMotorSpeed = 30; +configurationParameters.IDSRightCleaningMotorSpeed = 23; +configurationParameters.SwitchToIdleTimeinSeconds = 3600; +configurationParameters.IdleDrierTemperature = 80; +configurationParameters.IdleHeadTemperature = 80; +configurationParameters.IdleMixerTemperature = 0; +configurationParameters.PowerOffTemperatureLimit = 50; +configurationParameters.IDSPreSegmentWFCFTimeBeforeSegment = 1500; + File.WriteAllBytes("C:/temp/EmbParam.cfg",configurationParameters.ToBytes()); byte[] fileBytes = File.ReadAllBytes("C:/temp/EmbParam.cfg"); -- cgit v1.3.1 From 8b1f81f413f51facb57a320fef47f2a0e297dc40 Mon Sep 17 00:00:00 2001 From: Shlomo Hecht Date: Tue, 30 Apr 2019 14:49:51 +0300 Subject: Version 1.3.9.32 reduced diagnostics. new ITMA screens. heating improved. lubricant handled better --- .../Embedded_SW/Embedded/Common/SW_Info/SW_Info.c | 2 +- .../Embedded_SW/Embedded/Common/Utilities/Utils.c | 2 + Software/Embedded_SW/Embedded/Embedded.cfg | 10 +++-- Software/Embedded_SW/Embedded/Main.c | 14 +++---- .../Embedded/Modules/AlarmHandling/AlarmHandling.c | 18 ++++++++ .../Embedded/Modules/Diagnostics/Diagnostics.c | 28 +++++++++---- .../Embedded/Modules/Heaters/Heaters_print.c | 48 +++++++++++++++------- Software/Embedded_SW/Embedded/Modules/IDS/IDS.h | 3 ++ .../Embedded/Modules/IDS/IDS_dispenser.c | 11 ++++- .../Embedded_SW/Embedded/Modules/IDS/IDS_print.c | 20 ++++----- .../Embedded/StateMachines/Printing/JobSTM.c | 12 +++--- .../stubs/embeddedparametersbuild.cs | 9 ++-- 12 files changed, 122 insertions(+), 55 deletions(-) (limited to 'Software/Embedded_SW/Embedded/Modules') 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 c8ec2a487..092772989 100644 --- a/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c +++ b/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c @@ -20,7 +20,7 @@ typedef struct } TangoVersion_t; -TangoVersion_t _gTangoVersion = {1,3,9,3}; +TangoVersion_t _gTangoVersion = {1,3,9,32}; #define BUILD_DATE __DATE__ char Dat[50] = BUILD_DATE; char _gTangoName [MAX_STRING_LEN] = "Tango01 ";//d diff --git a/Software/Embedded_SW/Embedded/Common/Utilities/Utils.c b/Software/Embedded_SW/Embedded/Common/Utilities/Utils.c index 542ea659a..078aa5f53 100644 --- a/Software/Embedded_SW/Embedded/Common/Utilities/Utils.c +++ b/Software/Embedded_SW/Embedded/Common/Utilities/Utils.c @@ -11,6 +11,7 @@ #include "Common/Utilities/Utils.h" //#include #include "driverlib/hibernate.h" +#include //***************************************************************************** @@ -98,6 +99,7 @@ void InitWatchdog(uint32_t clock) // MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_WDOG0); ROM_WatchdogIntClear(WATCHDOG0_BASE); + ROM_WatchdogIntTypeSet(WATCHDOG0_BASE,0); //interrupt, not NMI ROM_IntEnable(INT_WATCHDOG); // diff --git a/Software/Embedded_SW/Embedded/Embedded.cfg b/Software/Embedded_SW/Embedded/Embedded.cfg index 1127c5a30..001fab666 100644 --- a/Software/Embedded_SW/Embedded/Embedded.cfg +++ b/Software/Embedded_SW/Embedded/Embedded.cfg @@ -136,12 +136,12 @@ Program.global.control = Task.create("&controlTask", ControlTaskParams); var AlarmHandlingTaskParams = new Task.Params(); AlarmHandlingTaskParams.instance.name = "AlarmHandling"; AlarmHandlingTaskParams.stackSize = 2048; -AlarmHandlingTaskParams.priority = 10; +AlarmHandlingTaskParams.priority = 9; Program.global.AlarmHandling = Task.create("&AlarmHandlingTask", AlarmHandlingTaskParams); var CommTxTaskParams = new Task.Params(); CommTxTaskParams.instance.name = "communicationTx"; -CommTxTaskParams.priority = 9; +CommTxTaskParams.priority = 10; CommTxTaskParams.stackSize = 4096; Program.global.communicationTx = Task.create("&communicationTxTask", CommTxTaskParams); @@ -176,7 +176,7 @@ Program.global.controlLow = Task.create("&controlLowTask", ControlLowTaskParams) var DiagnosticsTaskParams = new Task.Params(); DiagnosticsTaskParams.instance.name = "Diagnostics"; -DiagnosticsTaskParams.priority = 4; +DiagnosticsTaskParams.priority = 6; DiagnosticsTaskParams.stackSize = 8192; Program.global.Diagnostics = Task.create("&DiagnosticsTask", DiagnosticsTaskParams); @@ -219,7 +219,9 @@ Text.isLoaded = true; * reference unspecified external functions */ Error.raiseHook = "&errHook"; - + +BIOS.customCCOpts += " -Dxdc_FILE=__FILE__ "; + /* set user-defined code for E_generic errors */ Error.E_generic.code = 28; diff --git a/Software/Embedded_SW/Embedded/Main.c b/Software/Embedded_SW/Embedded/Main.c index 379c45f76..ad88a9ed2 100644 --- a/Software/Embedded_SW/Embedded/Main.c +++ b/Software/Embedded_SW/Embedded/Main.c @@ -74,7 +74,7 @@ #include "Modules/General/buttons.h" #include "Modules/Waste/Waste.h" #include -//#define WATCHDOG +#define WATCHDOG //***************************************************************************** @@ -114,7 +114,7 @@ Void errHook(Error_Block *eb) FRESULT Fresult = FR_OK; FIL *FileHandle = 0; //the system supports a single active file uint32_t Bytes = 0; - char ErrorPath[50] = "0://ErrorFile.txt"; + char ErrorPath[50] = "0://ErrFile.txt"; char File[50] = ""; char message[300]; int len; @@ -138,14 +138,14 @@ Void errHook(Error_Block *eb) Fresult = f_open(FileHandle,ErrorPath,FA_OPEN_ALWAYS | FA_WRITE | FA_READ); if (Fresult == FR_OK) { + f_lseek(FileHandle, FileHandle->fsize); strcpy(File,site->file); - len = usnprintf(message, 80, "\r\n%s %s %s",__DATE__, __TIME__,File); + len = usnprintf(message, 80, "\r\n%s %s",__DATE__, __TIME__); Fresult = f_write(FileHandle,message,len,&Bytes ); /* print user supplied error code */ - len = usnprintf(message, 300, "\r\nerror %d, eid %d file %s line %d mod %d", - eCode, eid, site->file, - site->line, - site->mod); + len = usnprintf(message, 300, "\r\nerror %d, eid %d mod %d file %s line %d", + eCode, eid,site->mod, + site->file,site->line); Fresult = f_write(FileHandle,message,len,&Bytes ); LOG_ERROR (eCode, "error # "); diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c index 2a7aef30a..3361bfdaa 100644 --- a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c +++ b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c @@ -175,6 +175,14 @@ const AlarmHandlingItemStruc HardCodedAlarmItem[MAX_SYSTEM_ALARMS]={ {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_7_OVERPRESSURE,"Dispenser 7 Over Pressure"}, {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_8_OVERPRESSURE,"Dispenser 8 Over Pressure"}, + {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,0,0,50/*500cc*/,false,DEBUG_LOG_CATEGORY__Warning,0xFF,2,EVENT_TYPE__MID_TANK_1_EMPTY,"MidTank 1 Empty alarm"}, + {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,1,1,50/*500cc*/,false,DEBUG_LOG_CATEGORY__Warning,0xFF,2,EVENT_TYPE__MID_TANK_2_EMPTY,"MidTank 2 Empty alarm"}, + {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,2,2,50/*500cc*/,false,DEBUG_LOG_CATEGORY__Warning,0xFF,2,EVENT_TYPE__MID_TANK_3_EMPTY,"MidTank 3 Empty alarm"}, + {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,3,3,50/*500cc*/,false,DEBUG_LOG_CATEGORY__Warning,0xFF,2,EVENT_TYPE__MID_TANK_4_EMPTY,"MidTank 4 Empty alarm"}, + {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,4,4,50/*500cc*/,false,DEBUG_LOG_CATEGORY__Warning,0xFF,2,EVENT_TYPE__MID_TANK_5_EMPTY,"MidTank 5 Empty alarm"}, + {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,7,7,50/*500cc*/,false,DEBUG_LOG_CATEGORY__Warning,0xFF,2,EVENT_TYPE__MID_TANK_8_EMPTY,"MidTank 8 Empty alarm"}, + + {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DRYER_MOTOR_OVERCURRENT,"Motor Drier Over Current"}, {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING, HARDWARE_MOTOR_TYPE__MOTO_RDRIVING, x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__FEEDER_MOTOR_OVERCURRENT,"Motor Feeder Over Current"}, {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_SCREW, HARDWARE_MOTOR_TYPE__MOTO_SCREW, x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__SCREW_MOTOR_OVERCURRENT,"Motor Screw Over Current"}, @@ -566,6 +574,7 @@ JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob) } for (Alarm_i = 0;Alarm_i= HeaterControl[index].sensormaxvalue) + if ((MinreadValue) >= HeaterControl[index].sensormaxvalue) { if (HeaterMaxTempFlag[index] == false) { @@ -808,7 +808,7 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue) //Heaters OFF until coming into the proportional band HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain,0); HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary,0); - //LOG_ERROR (0, "unconfigured"); + LOG_ERROR (0, "unconfigured"); return ERROR; } if (abs(readValue - HeaterPreviousRead[index])>2000) @@ -847,19 +847,22 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue) return OK; } // if (readValue < ((HeaterCmd[index].targettemperatue * (100-HeaterControl[index].outputproportionalband))/100)) - if (readValue < (/*HeaterCmd[index].targettemperatue * AcHeatersLoweroperationLimit/1000*/HeaterCmd[index].targettemperatue-1000)) + if (readValue < (/*HeaterCmd[index].targettemperatue * AcHeatersLoweroperationLimit/1000*/HeaterCmd[index].targettemperatue-800)) { if ((HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary] == false)&&(HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] == false)) { ActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary); ActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain); + HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain,100); + HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary,100); } return OK; } - if ((readValue > (HeaterCmd[index].targettemperatue-1000)/*(HeaterCmd[index].targettemperatue * AcHeatersLoweroperationLimit/1000)*/)&&(readValue < (HeaterCmd[index].targettemperatue * AcHeatersUpperoperationLimit/1000)))//read value within 0.5 percent from target +/* if ((readValue > (HeaterCmd[index].targettemperatue-300)/`*(HeaterCmd[index].targettemperatue * AcHeatersLoweroperationLimit/1000)*`/)&&(readValue < (HeaterCmd[index].targettemperatue * AcHeatersUpperoperationLimit/1000)))//read value within 0.5 percent from target { ////////////////// + Report("AC Turn Off secondary",__FILE__,__LINE__,readValue,RpWarning,(HeaterCmd[index].targettemperatue), 0); //InitialHeating = false; DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary); HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary, 0); @@ -875,11 +878,25 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue) Control_Voltage_To_Blower(BlowerCfg.voltage); } } - if ((readValue > HeaterCmd[index].targettemperatue * AcHeatersLoweroperationLimit/1000)&&(readValue < (HeaterCmd[index].targettemperatue * AcHeatersUpperoperationLimit/1000)))//read value within 0.5 percent from target + */ + if ((readValue > (HeaterCmd[index].targettemperatue * AcHeatersLoweroperationLimit/1000))&&(readValue < (HeaterCmd[index].targettemperatue * AcHeatersUpperoperationLimit/1000)))//read value within 0.5 percent from target { ////////////////// //InitialHeating = false; - Report("AC PID Activating",__FILE__,__LINE__,readValue,RpWarning,(HeaterCmd[index].targettemperatue-1000), 0); + Report("AC PID Activating",__FILE__,__LINE__,readValue,RpWarning,(HeaterCmd[index].targettemperatue), 0); +//////////////////////// + DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary); + HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary, 0); + HeatersControlStart(); + AlarmHandlingSetAlarm(HeaterUnderEventType[index], false); + if (BlowerCfg.enabled == true) + { + Turn_the_Blower_On();//Turn on with the Default_Voltage + if (BlowerCfg.voltage) + //Gradual_Increase_Blower(BlowerCfg.heatingvoltage,BlowerCfg.voltage); + Control_Voltage_To_Blower(BlowerCfg.voltage); + } + //////////////////////// HeaterReady[index] = true; Disable_Reading_Heaters_Current(HeaterId2CurrentId[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain]); @@ -974,13 +991,14 @@ uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue) if (HeaterCmd[index].targettemperatue == 0) { DeActivateHeater(index); - //LOG_ERROR (index, "unconfigured"); + HeaterRecalculateHeaterParams(index, 0); + LOG_ERROR (index, "unconfigured"); return ERROR; } if (abs(readValue - HeaterPreviousRead[index])>2000) { Report("DC Temperature Spike",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index); - if (readValue > HeaterCmd[index].targettemperatue) + //if (readValue > HeaterCmd[index].targettemperatue) { DeActivateHeater(index); HeaterRecalculateHeaterParams(index, 0); @@ -991,6 +1009,7 @@ uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue) { Report("DC Temperature disaster",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index); DeActivateHeater (index); + HeaterRecalculateHeaterParams(index, 0); return ERROR; } @@ -1017,6 +1036,7 @@ uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue) if ((readValue > (HeaterCmd[index].targettemperatue * DcHeatersLoweroperationLimit/1000))&&(readValue < (HeaterCmd[index].targettemperatue * DcHeatersUpperoperationLimit/1000)))//read value within 0.5 percent from target { + Report("DC PID Activating",__FILE__,index,readValue,RpWarning,(HeaterCmd[index].targettemperatue), 0); //DCInitialHeating[index] = false; HeatersControlStart(); HeaterReady[index] = true; diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h b/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h index 3d2bcf9ff..b47305d8c 100644 --- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h +++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h @@ -5,6 +5,9 @@ #include "drivers/motors/motor.h" #include "ids_ex.h" +#define LUBRICANT_DISPENSER 7 +#define CLEANER_DISPENSER 6 + extern int32_t CurrentDispenserSpeed[MAX_SYSTEM_DISPENSERS]; extern uint32_t DispenserIdToMotorId[MAX_SYSTEM_DISPENSERS]; extern float DispenserPressure[MAX_SYSTEM_DISPENSERS]; diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c index 13142ad5f..ed9a3adb7 100644 --- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c +++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c @@ -66,8 +66,15 @@ uint32_t IDS_Dispenser_Build_Pressure_Callback(uint32_t DispenserId, uint32_t Re { uint32_t status; DispenserPrepareTime[DispenserId]+=DispenserPrepareTimeLag; + double DispenserPressure = DispenserPreparePressure; - if ((GetDispenserPressure(DispenserId)>=DispenserPreparePressure)||(DispenserPrepareTime[DispenserId]>=DispenserPrepareTimeout)) + if (DispenserId == LUBRICANT_DISPENSER) + { + DispenserPressure = DispenserPreparePressure/5; + //lubricant lower pressure buildup + } + + if ((GetDispenserPressure(DispenserId)>=DispenserPressure)||(DispenserPrepareTime[DispenserId]>=DispenserPrepareTimeout)) { if (DispenserPrepareTime[DispenserId]>=DispenserPrepareTimeout) status = ERROR; @@ -249,6 +256,7 @@ void IDS_Dispenser_Content_Init (void) uint16_t seconds_counter = 0; uint32_t IDS_Dispenser_Store_Data (void) { + uint32_t timing = msec_millisecondCounter; FRESULT Status = FR_OK; IDSDispenserData.n_dispenserinfo = MAX_SYSTEM_DISPENSERS; IDSDispenserData.dispenserinfo = dispenserdata; @@ -263,6 +271,7 @@ uint32_t IDS_Dispenser_Store_Data (void) else return ERROR; + REPORT_MSG(msec_millisecondCounter - timing, "Updating dispensers file - time"); return Status; } void IDS_Dispenser_Content_Calculation (char DispenserId) diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c index 4bcdcc06a..30ad7d857 100644 --- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c +++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c @@ -40,8 +40,6 @@ typedef struct PID_Config_Params m_params; }DispenserControlConfig_t; HardwarePidControl *DispensersControl;// = (HardwarePidControl *)GENHWCFG_MAP_IN_FLASH + 0x4000; -#define LUBRICANT_DISPENSER 7 -#define CLEANER_DISPENSER 6 #define MAX_DYE_DISPENSERS 6 int32_t DispenserSamples[MAX_SYSTEM_DISPENSERS][MAX_CONTROL_SAMPLES] = {0}; int DispenserSamplePointer[MAX_SYSTEM_DISPENSERS] = {0}; @@ -321,6 +319,7 @@ b. Read brush stop message. c. Go to step 2.a x Segment.BrushStopsCount. 3. Go to step 1 until end of file. */ + GeneralHwReady = false; for (Dispenser_i = 0;Dispenser_in_dispensers) { for (Dispenser_i = 0;Dispenser_i < BrushStop->n_dispensers;Dispenser_i++) @@ -478,6 +478,7 @@ c. Go to step 2.a x Segment.BrushStopsCount. if (BrushStop != NULL) job_description_file_brush_stop__free_unpacked (BrushStop,NULL); Fresult = f_close(FileHandle); + GeneralHwReady = true; REPORT_MSG (n_segments, "Finished checking the file"); return status; @@ -1147,23 +1148,22 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId) } } - + IDS_StopLubrication(); return OK; } uint32_t IDS_StartLubrication(void) { IDS_Dispenser_Start_Motor_and_Open_Valve(LUBRICANT_DISPENSER,lubricant_speed,NULL); + CurrentDispenserSpeed[LUBRICANT_DISPENSER] = lubricant_speed; REPORT_MSG (lubricant_speed, "IDS_StartLubrication"); Lubricant_2Way_Valve (START); return OK; } uint32_t IDS_StopLubrication(void) { - if(DispenserUsedInJob[LUBRICANT_DISPENSER]) - { - IDS_Dispenser_Close_Valve_And_Stop_Motor(LUBRICANT_DISPENSER,IDS_Valve_EndValveReady); - REPORT_MSG (lubricant_speed, "IDS_StopLubrication"); - Lubricant_2Way_Valve (STOP); - } + IDS_Dispenser_Close_Valve_And_Stop_Motor(LUBRICANT_DISPENSER,IDS_Valve_EndValveReady); + CurrentDispenserSpeed[LUBRICANT_DISPENSER] = 0; + REPORT_MSG (lubricant_speed, "IDS_StopLubrication"); + Lubricant_2Way_Valve (STOP); return OK; } diff --git a/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c b/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c index b5034a11c..96b2b372e 100644 --- a/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c +++ b/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c @@ -713,6 +713,9 @@ void JobRequestFunc(MessageContainer* requestContainer) char logmsg[254]; char infomsg[254]; uint8_t JobStatusBuffer[400]; +ResumeCurrentJobResponse resumeresponse = RESUME_CURRENT_JOB_RESPONSE__INIT; +JobResponse JobResponseMsg = JOB_RESPONSE__INIT; +JobStatus jobStatus = JOB_STATUS__INIT; void SendJobProgress(double ProcessedLength, int SegmentId, bool done, char *Message) { @@ -734,9 +737,6 @@ void SendJobProgress(double ProcessedLength, int SegmentId, bool done, char *Mes if (JobToken[0] != 0) { - ResumeCurrentJobResponse resumeresponse = RESUME_CURRENT_JOB_RESPONSE__INIT; - JobResponse response = JOB_RESPONSE__INIT; - JobStatus jobStatus = JOB_STATUS__INIT; if (Message) { @@ -756,9 +756,9 @@ void SendJobProgress(double ProcessedLength, int SegmentId, bool done, char *Mes } else { - response.status = &jobStatus; - //responseContainer = createContainer(MESSAGE_TYPE__JobResponse, JobToken, done, &response, &job_response__pack, &job_response__get_packed_size); - responseContainer = createAllocatedContainer(MESSAGE_TYPE__JobResponse, JobToken, done, &response, &job_response__pack, &job_response__get_packed_size,&JobStatusBuffer); + JobResponseMsg.status = &jobStatus; + //responseContainer = createContainer(MESSAGE_TYPE__JobResponse, JobToken, done, &JobResponseMsg, &job_response__pack, &job_response__get_packed_size); + responseContainer = createAllocatedContainer(MESSAGE_TYPE__JobResponse, JobToken, done, &JobResponseMsg, &job_response__pack, &job_response__get_packed_size,&JobStatusBuffer); } container_buffer = my_malloc(message_container__get_packed_size(&responseContainer)); diff --git a/Software/Stubs Collection/stubs/embeddedparametersbuild.cs b/Software/Stubs Collection/stubs/embeddedparametersbuild.cs index b896e9968..90d799ed5 100644 --- a/Software/Stubs Collection/stubs/embeddedparametersbuild.cs +++ b/Software/Stubs Collection/stubs/embeddedparametersbuild.cs @@ -55,11 +55,14 @@ configurationParameters.MidTankPressureCorrection = 0.0; configurationParameters.DispenserPresegmentWFCF = 80; configurationParameters.StartHeatingOnInitSequence = false; -Double checkHardLimitAlarms = new Double(1); +Double checkHardLimitAlarms = new Double(); +checkHardLimitAlarms = 1.0; configurationParameters.GeneralParameters.Add(checkHardLimitAlarms); -Double checkCurrentAlarms = new Double(1); +Double checkCurrentAlarms = new Double(); +checkCurrentAlarms = 1.0; configurationParameters.GeneralParameters.Add(checkCurrentAlarms); -Double checkTamperAlarms = new Double(1); +Double checkTamperAlarms = new Double(); +checkTamperAlarms = 1.0; configurationParameters.GeneralParameters.Add(checkTamperAlarms); configurationParameters.CurrentAlarmLowLimit = 0.80; -- cgit v1.3.1 From 6764160829be092f9c31d8742a20d86d96d05477 Mon Sep 17 00:00:00 2001 From: Shlomo Hecht Date: Tue, 30 Apr 2019 15:23:14 +0300 Subject: mid tank should not stop a job --- Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c | 4 ++-- Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c | 2 +- Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c | 5 +++-- 3 files changed, 6 insertions(+), 5 deletions(-) (limited to 'Software/Embedded_SW/Embedded/Modules') diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c index 3361bfdaa..368c52436 100644 --- a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c +++ b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c @@ -584,7 +584,7 @@ JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob) break; } } - if (AlarmItem[Alarm_i].AlarmSource == ALARM_SOURCE_TYPE__FluidLevelAlarm) + /*if (AlarmItem[Alarm_i].AlarmSource == ALARM_SOURCE_TYPE__FluidLevelAlarm) { if (AlarmState[Alarm_i].Status == true) { @@ -592,7 +592,7 @@ JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob) AlarmId = Alarm_i; break; } - } + }*/ if (AlarmItem[Alarm_i].AlarmSource == ALARM_SOURCE_TYPE__MotorAlarm) { if (AlarmState[Alarm_i].Status == true) diff --git a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c index f0ce7397c..b12064915 100644 --- a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c +++ b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c @@ -118,7 +118,7 @@ void LoadConfigurationParameters(ConfigurationParameters *Params) EmbeddedParameters.has_breaksensorlimit = true; EmbeddedParameters.breaksensorlimit = 10; EmbeddedParameters.has_diagnosticcollectionlimit = true; - EmbeddedParameters.diagnosticcollectionlimit = 1; + EmbeddedParameters.diagnosticcollectionlimit = 2; EmbeddedParameters.has_overheatcountlimit = true; EmbeddedParameters.overheatcountlimit = 3; EmbeddedParameters.has_underheatcountlimit = true; diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c index be4328f4c..4402ec2f1 100644 --- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c +++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c @@ -846,9 +846,10 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue) HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary,0); return OK; } -// if (readValue < ((HeaterCmd[index].targettemperatue * (100-HeaterControl[index].outputproportionalband))/100)) - if (readValue < (/*HeaterCmd[index].targettemperatue * AcHeatersLoweroperationLimit/1000*/HeaterCmd[index].targettemperatue-800)) + if (readValue < ((HeaterCmd[index].targettemperatue * (100-HeaterControl[index].outputproportionalband))/100)) + //if (readValue < (/*HeaterCmd[index].targettemperatue * AcHeatersLoweroperationLimit/1000*/HeaterCmd[index].targettemperatue-800)) { + Report("AC Activating",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index); if ((HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary] == false)&&(HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] == false)) { ActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary); -- cgit v1.3.1 From be50a5b72cedd1afc0a14d36a468e8b04bf9a37f Mon Sep 17 00:00:00 2001 From: Avi Levkovich Date: Tue, 30 Apr 2019 16:22:08 +0300 Subject: Add the funtion Ink_Cart_Led to control the Ink led --- Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c | 2 ++ Software/Embedded_SW/Embedded/Modules/General/buttons.c | 11 +++++++++++ Software/Embedded_SW/Embedded/Modules/General/buttons.h | 1 + 3 files changed, 14 insertions(+) (limited to 'Software/Embedded_SW/Embedded/Modules') diff --git a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c index 193769265..916d33772 100644 --- a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c +++ b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c @@ -48,6 +48,7 @@ #include "Common/SWUpdate/FileSystem.h" #include "Communication/Connection.h" +#include "Modules/General/buttons.h" Task_Handle Millisecond_Task_Handle; /******************** Definitions ********************************************/ @@ -514,6 +515,7 @@ uint32_t MillisecLowLoop(uint32_t tick) { Speed_Data = Calculate_Speed_Sensor_Velocity(); Read_Buttons_Reg(); + Ink_Cart_Led(); for (Sensor_i = 0;Sensor_i < MAX_TEMPERATURE_SENSOR_ID;Sensor_i++) { MillisecUpdateTemperatures (Sensor_i,TemperatureSensorRead(Sensor_i)); diff --git a/Software/Embedded_SW/Embedded/Modules/General/buttons.c b/Software/Embedded_SW/Embedded/Modules/General/buttons.c index 74cb81aac..cfd44a6fa 100644 --- a/Software/Embedded_SW/Embedded/Modules/General/buttons.c +++ b/Software/Embedded_SW/Embedded/Modules/General/buttons.c @@ -603,6 +603,17 @@ uint32_t LoadStatMachine( button *pBtn) return OK; } +void Ink_Cart_Led()//temporary for ITMA +{ + if(Is_Cartridge_Present(CART_1) == true) + { + Pannel_Leds( CART_1, MODE_ON); + } + else + { + Pannel_Leds( CART_1, MODE_OFF); + } +} void test_avi() { diff --git a/Software/Embedded_SW/Embedded/Modules/General/buttons.h b/Software/Embedded_SW/Embedded/Modules/General/buttons.h index 2d14eb000..4d0df69e1 100644 --- a/Software/Embedded_SW/Embedded/Modules/General/buttons.h +++ b/Software/Embedded_SW/Embedded/Modules/General/buttons.h @@ -58,6 +58,7 @@ uint32_t Buttons_Init(void); uint32_t Button_load_Init(void); uint32_t Button_JOG_Init(void); bool SetPowerMachineState(PBmachineState state); +void Ink_Cart_Led(); -- cgit v1.3.1