diff --git a/.github/workflows/clang-format-check.yml b/.github/workflows/clang-format-check.yml index 3b4f9733..459e1d47 100644 --- a/.github/workflows/clang-format-check.yml +++ b/.github/workflows/clang-format-check.yml @@ -26,7 +26,7 @@ jobs: - name: Run clang-format style check. uses: jidicula/clang-format-action@v4.10.2 with: - clang-format-version: '15' + clang-format-version: '16' check-path: 'Core' # In the following line all files exceptions should be defined exclude-regex: '(freertos|main.c|main.h|stm32h7xx|syscalls.c|sysmem.c|FreeRTOSConfig.h)' \ No newline at end of file diff --git a/Core/Inc/leds/debug_leds_handler.h b/Core/Inc/leds/debug_leds_handler.h index ced92b49..1c54111f 100644 --- a/Core/Inc/leds/debug_leds_handler.h +++ b/Core/Inc/leds/debug_leds_handler.h @@ -1,8 +1,8 @@ /* * leds.h * - * Created on: May 13, 2021 - * Author: Felipe Telles + * Created on: May 21, 2023 + * Author: Samuel Dantas */ #ifndef INC_DEBUGLEDS_H_ @@ -19,7 +19,7 @@ typedef enum { ON, OFF, TOGGLE, BLINK, FASTBLINK } ControlDebugLED_e; typedef struct { - uint16_t lednumber; + uint16_t led_number; ControlDebugLED_e control; uint8_t amount; } debug_led_message_t; diff --git a/Core/Inc/leds/rgb_led_handler.h b/Core/Inc/leds/rgb_led_handler.h index 7ec0398a..e44175b1 100644 --- a/Core/Inc/leds/rgb_led_handler.h +++ b/Core/Inc/leds/rgb_led_handler.h @@ -1,7 +1,7 @@ /* * leds.h * - * Created on: May 13, 2021 + * Created on: May 21, 2023 * Author: Felipe Telles */ @@ -13,30 +13,53 @@ #include "stdint.h" #include "util/global_definitions.h" -#define RGB_BLINK_DELAY 200 +#define RGB_TIMEOUT 200 +#define RGB_BLINK_200_DELAY 200 +#define RGB_BLINK_1000_DELAY 1000 +#define ONE_COLOR_PATTERN_POS 0 +#define ONE_COLOR_PATTERN_SIZE 1 +#define SOFT_ERROR_COLORS_PATTERN_SIZE 2 +#define HARD_ERROR_COLORS_PATTERN_SIZE 3 #define RGB_BLACK \ - (rgb_t) { 0, 0, 0 } + (rgb_t) { \ + 0, 0, 0 \ + } #define RGB_RED \ - (rgb_t) { 1, 0, 0 } + (rgb_t) { \ + 1, 0, 0 \ + } #define RGB_GREEN \ - (rgb_t) { 0, 1, 0 } + (rgb_t) { \ + 0, 1, 0 \ + } #define RGB_BLUE \ - (rgb_t) { 0, 0, 1 } + (rgb_t) { \ + 0, 0, 1 \ + } #define RGB_YELLOW \ - (rgb_t) { 1, 1, 0 } + (rgb_t) { \ + 1, 1, 0 \ + } #define RGB_PURBLE \ - (rgb_t) { 1, 0, 1 } + (rgb_t) { \ + 1, 0, 1 \ + } #define RGB_CYAN \ - (rgb_t) { 0, 1, 1 } + (rgb_t) { \ + 0, 1, 1 \ + } #define RGB_WHITE \ - (rgb_t) { 1, 1, 1 } + (rgb_t) { \ + 1, 1, 1 \ + } -typedef enum { FIXED, BLINK200, NO_CHANGE } control_rgb_led_e; +typedef enum { FIXED, BLINK200 } control_rgb_led_e; typedef struct { - cores_t color; + colors_t pattern[3]; control_rgb_led_e control; + uint8_t size_of_pattern; } rgb_led_message_t; typedef struct { @@ -45,6 +68,7 @@ typedef struct { GPIO_PinState blue; } rgb_t; -osStatus_t set_rgb_led(cores_t color, control_rgb_led_e control); +osStatus_t set_rgb_led(const colors_t* pattern, uint8_t size_of_pattern, + control_rgb_led_e control); #endif /* INC_RGB_LED_H_ */ diff --git a/Core/Inc/util/CMSIS_extra/global_variables_handler.h b/Core/Inc/util/CMSIS_extra/global_variables_handler.h index f799375f..19ec28a3 100644 --- a/Core/Inc/util/CMSIS_extra/global_variables_handler.h +++ b/Core/Inc/util/CMSIS_extra/global_variables_handler.h @@ -162,4 +162,4 @@ void set_global_var(global_vars_e type, void* message); type##_var; \ }) -#endif /* INC_CMSIS_EXTRA_GLOBAL_VARIABLES_HANDLER_H_ */ +#endif /* INC_CMSIS_EXTRA_GLOBAL_VARIABLES_HANDLER_H_ */ \ No newline at end of file diff --git a/Core/Inc/util/global_definitions.h b/Core/Inc/util/global_definitions.h index f8539b1c..b5d7df42 100644 --- a/Core/Inc/util/global_definitions.h +++ b/Core/Inc/util/global_definitions.h @@ -18,7 +18,7 @@ typedef enum { FRONT_RIGHT = 0, FRONT_LEFT, REAR_RIGHT, REAR_LEFT } speed_pin_e; // cores do LED da ECU -typedef enum { PRETO = 0, VERMELHO, VERDE, AZUL, AMARELO, ROXO, CIANO, BRANCO } cores_t; +typedef enum { BLACK = 0, RED, GREEN, BLUE, YELLOW, PURPLE, CYAN, WHITE } colors_t; typedef enum modos_desempenho { ERRO = 0, @@ -28,7 +28,7 @@ typedef enum modos_desempenho { AUTOX } race_mode_t; -typedef struct // struct de modo +typedef struct // struct de modo { int tor_max; // torque maximo (de 0 a 4000) int vel_max; // velocidade maxima (de 0 a 9000) @@ -43,7 +43,7 @@ typedef struct // struct de modo int torq_gain; // ganho de torque, aconselhavel q seja proporcional ao torque maximo ( // de 0 a 40) race_mode_t mode; // 1 enduro, 2 aceleracao, 3 skidpad, 4 autox - cores_t cor; + colors_t rgb_colors[1]; } modos; #define R_MOTOR 0 diff --git a/Core/Src/driver_settings/RTD.c b/Core/Src/driver_settings/RTD.c index 3ca35e0e..8daa9857 100644 --- a/Core/Src/driver_settings/RTD.c +++ b/Core/Src/driver_settings/RTD.c @@ -23,19 +23,20 @@ static void set_RTD(); void RTD(void* argument) { UNUSED(argument); - // seta o led rgb no primeira execucao do codigo - set_rgb_led(get_global_var_value(SELECTED_MODE).cor, BLINK200); + // set the rgb led on the first execution of the code + set_rgb_led(get_global_var_value(SELECTED_MODE).rgb_colors, ONE_COLOR_PATTERN_SIZE, + BLINK200); for (;;) { - // espera receber flag q o botao de RTD foi pressionado + // waits to receive flag that the RTD button was pressed osThreadFlagsWait(RTD_BTN_PRESSED_THREAD_FLAG, osFlagsWaitAny, osWaitForever); if (!is_RTD_active()) { if (can_RTD_be_enabled()) { set_RTD(); } else { - // envia uma mensagem de alerta caso n seja possivel acionar RTD + // sends an alert message if it is not possible to trigger RTD set_debugleds(DEBUGLED1, BLINK, 2); } } @@ -43,11 +44,10 @@ void RTD(void* argument) { } void exit_RTD() { - // seta modo_selecionado como erro + // set the mode_selected as error set_global_var_value(SELECTED_MODE, erro); set_global_var_value(RACE_MODE, ERRO); - set_rgb_led(get_global_var_value(SELECTED_MODE).cor, BLINK200); - // limpa flag de RTD + // clear RTD flag osEventFlagsClear(e_ECU_control_flagsHandle, RTD_FLAG); osThreadFlagsSet(t_odometer_saveHandle, ODOMETER_SAVE_THREAD_FLAG); } @@ -81,7 +81,7 @@ void exit_RTD() { * TODO: Allow RTD activation from the status check of the AIRs. */ static bool can_RTD_be_enabled() { - // obtem todas as flags e filtra apenas flags de erros severos, ignorando as outras + // get all flags and filter only severe error flags, ignoring others uint32_t error_flags = osEventFlagsGet(e_ECU_control_flagsHandle); error_flags &= ALL_SEVERE_ERROR_FLAG; BRAKE_STATUS_t is_brake_active = get_global_var_value(BRAKE_STATUS); @@ -100,7 +100,8 @@ static bool can_RTD_be_enabled() { static void set_RTD() { osEventFlagsSet(e_ECU_control_flagsHandle, RTD_FLAG); - set_rgb_led(get_global_var_value(SELECTED_MODE).cor, FIXED); + set_rgb_led(get_global_var_value(SELECTED_MODE).rgb_colors, FIXED, + ONE_COLOR_PATTERN_SIZE); activate_RTDS(); } diff --git a/Core/Src/driver_settings/modo.c b/Core/Src/driver_settings/modo.c index 0ea1046f..0f5201cc 100644 --- a/Core/Src/driver_settings/modo.c +++ b/Core/Src/driver_settings/modo.c @@ -37,8 +37,8 @@ void seleciona_modo(void* argument) { case AUTOX: set_global_var_value(SELECTED_MODE, autox); break; default: set_global_var_value(SELECTED_MODE, erro); break; } - - set_rgb_led(get_global_var_value(SELECTED_MODE).cor, BLINK200); + set_rgb_led(get_global_var_value(SELECTED_MODE).rgb_colors, + ONE_COLOR_PATTERN_SIZE, BLINK200); osEventFlagsClear(e_ECU_control_flagsHandle, DYNAMIC_CONTROL_FLAG); } // todo: dataloggar modos diff --git a/Core/Src/leds/debug_leds_handler.c b/Core/Src/leds/debug_leds_handler.c index fbd62b8e..71ce20f4 100644 --- a/Core/Src/leds/debug_leds_handler.c +++ b/Core/Src/leds/debug_leds_handler.c @@ -1,13 +1,15 @@ /* * leds.c * - * Created on: May 12, 2021 - * Author: Felipe Telles + * Created on: May 21, 2023 + * Author: Samuel Dantas */ #include "leds/debug_leds_handler.h" #include "cmsis_os.h" +#include "util/CMSIS_extra/cmsis_extra.h" +#include "util/CMSIS_extra/global_variables_handler.h" #include "util/global_definitions.h" #include "util/global_variables.h" #include "util/util.h" @@ -16,7 +18,7 @@ extern osMessageQueueId_t q_debug_leds_messageHandle; osStatus_t set_debugleds(uint16_t lednumber, ControlDebugLED_e control, uint8_t amount) { debug_led_message_t message = {lednumber, control, amount}; - return osMessageQueuePut(q_debug_leds_messageHandle, &message, 0, 0U); + return osMessageQueuePutOverwrite(q_debug_leds_messageHandle, &message, 0); } void debug_leds(void* argument) { @@ -27,36 +29,36 @@ void debug_leds(void* argument) { for (;;) { ECU_ENABLE_BREAKPOINT_DEBUG(); - // espera ate alguma mensagem chegar + // wait until some message arrives osMessageQueueGet(q_debug_leds_messageHandle, &message, NULL, osWaitForever); switch (message.control) { case ON: - // acende o led escolhido - HAL_GPIO_WritePin(GPIOE, message.lednumber, GPIO_PIN_RESET); + // lights up the chosen led + HAL_GPIO_WritePin(GPIOE, message.led_number, GPIO_PIN_RESET); break; case OFF: - // apaga o led escolhido - HAL_GPIO_WritePin(GPIOE, message.lednumber, GPIO_PIN_SET); + // turn off the chosen led + HAL_GPIO_WritePin(GPIOE, message.led_number, GPIO_PIN_SET); break; case TOGGLE: - // toggle o led escolhido - HAL_GPIO_TogglePin(GPIOE, message.lednumber); + // toggle the chosen led + HAL_GPIO_TogglePin(GPIOE, message.led_number); break; case BLINK: - // pisca o led escolhido, pelo valor de vezes escolhido - // delays garante que eh possivel contar quantas vezes piscou + // blink the chosen led, by the chosen value of times + // delays ensures that it is possible to count how many times it blinked for (uint8_t i = 0; i < message.amount; i++) { - HAL_GPIO_WritePin(GPIOE, message.lednumber, GPIO_PIN_RESET); + HAL_GPIO_WritePin(GPIOE, message.led_number, GPIO_PIN_RESET); osDelay(300); - HAL_GPIO_WritePin(GPIOE, message.lednumber, GPIO_PIN_SET); + HAL_GPIO_WritePin(GPIOE, message.led_number, GPIO_PIN_SET); osDelay(300); } osDelay(500); break; case FASTBLINK: - HAL_GPIO_WritePin(GPIOE, message.lednumber, GPIO_PIN_RESET); + HAL_GPIO_WritePin(GPIOE, message.led_number, GPIO_PIN_RESET); osDelay(message.amount); - HAL_GPIO_WritePin(GPIOE, message.lednumber, GPIO_PIN_SET); + HAL_GPIO_WritePin(GPIOE, message.led_number, GPIO_PIN_SET); osDelay(message.amount / 2); break; } diff --git a/Core/Src/leds/rgb_led_handler.c b/Core/Src/leds/rgb_led_handler.c index 79b2df67..0123388d 100644 --- a/Core/Src/leds/rgb_led_handler.c +++ b/Core/Src/leds/rgb_led_handler.c @@ -1,18 +1,6 @@ /* - * leds.c - * Cores: - * Preto: - - * Vermelho: Erro - * Verde: Enduro - * Azul: Autox - * Amarelo: Erro leve (APPS ou BSE Plausability) - * Roxo: Aceleracao - * Ciano: Skidpad - * Branco: Aviso (REGEN ou Controle dinamicos) - * - * - * Created on: May 12, 2021 - * Author: Felipe Telles + * Created on: May 21, 2023 + * Author: Samuel Dantas */ #include "leds/rgb_led_handler.h" @@ -21,14 +9,22 @@ #include "util/global_variables.h" #include "util/util.h" -void write_rgb_color(rgb_t rgb_gpio); -void write_debug_color(rgb_t rgb_gpio); -rgb_t get_rgb_color(cores_t color); -void blink_rgb(uint32_t delay); +static void write_rgb_color(rgb_t rgb_gpio); +// static void write_debug_color(rgb_t rgb_gpio); +static void write_pattern(rgb_led_message_t message, int delay); +static uint32_t are_messages_available(osMessageQueueId_t q_id); +static void blink_rgb(uint32_t delay); +rgb_t get_rgb_color(colors_t color); -osStatus_t set_rgb_led(cores_t color, control_rgb_led_e control) { - rgb_led_message_t message = {color, control}; - return osMessageQueuePut(q_rgb_led_messageHandle, &message, 0, 0U); +osStatus_t set_rgb_led(const colors_t* pattern, uint8_t size_of_pattern, + control_rgb_led_e control) { + rgb_led_message_t message; + message.control = control; + message.size_of_pattern = size_of_pattern; + message.pattern[0] = pattern[0]; + message.pattern[1] = size_of_pattern > 1 ? pattern[1] : 0; + message.pattern[2] = size_of_pattern > 2 ? pattern[2] : 0; + return osMessageQueuePutOverwrite(q_rgb_led_messageHandle, &message, 0); } void rgb_led(void* argument) { @@ -39,32 +35,30 @@ void rgb_led(void* argument) { for (;;) { ECU_ENABLE_BREAKPOINT_DEBUG(); - // espera RTD ser setado ou timeout estourar - switch ( - osMessageQueueGet(q_rgb_led_messageHandle, &message, NULL, RGB_BLINK_DELAY)) { + // wait until the RTD is set or to timeout overflow - // caso timeout estore vai piscar o led, indicando que ta fora do RTD - case osErrorTimeout: - write_rgb_color(get_rgb_color(message.color)); - blink_rgb(RGB_BLINK_DELAY); - break; + switch (osMessageQueueGet(q_rgb_led_messageHandle, &message, NULL, RGB_TIMEOUT)) { + + // if the timeout overflows the led will blink to show the car its not in RTD + case osErrorTimeout: write_pattern(message, RGB_BLINK_200_DELAY); break; default: - switch (message.control) { - case FIXED: - for (;;) { - write_rgb_color(get_rgb_color(message.color)); - osMessageQueueGet(q_rgb_led_messageHandle, &message, NULL, - osWaitForever); - if (message.control == BLINK200) { - break; - } + if (message.control == FIXED) { + if (message.size_of_pattern > 1) { + while (!are_messages_available(q_rgb_led_messageHandle)) { + write_pattern(message, RGB_BLINK_1000_DELAY); } break; - default: - write_rgb_color(get_rgb_color(message.color)); - blink_rgb(RGB_BLINK_DELAY); - break; + } + write_rgb_color( + get_rgb_color(message.pattern[ONE_COLOR_PATTERN_POS])); + while (!are_messages_available(q_rgb_led_messageHandle)) { + osDelay(RGB_BLINK_200_DELAY); + } + } + + else if (message.control == BLINK200) { + write_pattern(message, RGB_BLINK_200_DELAY); } break; } @@ -73,32 +67,43 @@ void rgb_led(void* argument) { void blink_rgb(uint32_t delay) { osDelay(delay); - write_rgb_color(get_rgb_color(PRETO)); + write_rgb_color(get_rgb_color(BLACK)); +} + +void write_pattern(rgb_led_message_t message, int delay) { + for (int i = 0; i < message.size_of_pattern; ++i) { + write_rgb_color(get_rgb_color(message.pattern[i])); + blink_rgb(delay); + } +} + +uint32_t are_messages_available(osMessageQueueId_t q_id) { + return osMessageQueueGetCount(q_id); } void write_rgb_color(rgb_t rgb_gpio) { HAL_GPIO_WritePin(C_LED_RED_GPIO_Port, C_LED_RED_Pin, rgb_gpio.red); HAL_GPIO_WritePin(C_LED_GREEN_GPIO_Port, C_LED_GREEN_Pin, rgb_gpio.green); HAL_GPIO_WritePin(C_LED_BLUE_GPIO_Port, C_LED_BLUE_Pin, rgb_gpio.blue); - // write_debug_color(rgb_gpio); //apenas para debug + // write_debug_color(rgb_gpio); //only for debug } - +/* void write_debug_color(rgb_t rgb_gpio) { HAL_GPIO_WritePin(C_LED_DEBUG1_GPIO_Port, C_LED_DEBUG1_Pin, !rgb_gpio.red); HAL_GPIO_WritePin(C_LED_DEBUG2_GPIO_Port, C_LED_DEBUG2_Pin, !rgb_gpio.green); HAL_GPIO_WritePin(C_LED_DEBUG3_GPIO_Port, C_LED_DEBUG3_Pin, !rgb_gpio.blue); -} +}*/ -rgb_t get_rgb_color(cores_t color) { +rgb_t get_rgb_color(colors_t color) { switch (color) { - case PRETO: return RGB_BLACK; - case VERMELHO: return RGB_RED; - case VERDE: return RGB_GREEN; - case AZUL: return RGB_BLUE; - case AMARELO: return RGB_YELLOW; - case ROXO: return RGB_PURBLE; - case CIANO: return RGB_CYAN; - case BRANCO: + case BLACK: return RGB_BLACK; + case RED: return RGB_RED; + case GREEN: return RGB_GREEN; + case BLUE: return RGB_BLUE; + case YELLOW: return RGB_YELLOW; + case PURPLE: return RGB_PURBLE; + case CYAN: return RGB_CYAN; + case WHITE: default: return RGB_WHITE; } } diff --git a/Core/Src/util/CMSIS_extra/global_variables_handler.c b/Core/Src/util/CMSIS_extra/global_variables_handler.c index a1b4c4ca..529c0d95 100644 --- a/Core/Src/util/CMSIS_extra/global_variables_handler.c +++ b/Core/Src/util/CMSIS_extra/global_variables_handler.c @@ -17,7 +17,6 @@ typedef struct { // create local storage of queue infos static global_variable_message_queue_data_t queues_info[_global_vars_quan]; - /* * This macro creates a Message Queue of size 1, based on the name provided by * var_name parameter. The Message Queue Id is then stored in the array @@ -70,4 +69,4 @@ void get_global_var(global_vars_e type, void* message) { void set_global_var(global_vars_e type, void* message) { osMessageQueuePutOverwrite(queues_info[type].id, message, 0); -} +} \ No newline at end of file diff --git a/Core/Src/util/initializers.c b/Core/Src/util/initializers.c index abed8299..841dbb92 100644 --- a/Core/Src/util/initializers.c +++ b/Core/Src/util/initializers.c @@ -34,7 +34,7 @@ void init_ADC_DMA(ADC_HandleTypeDef* hadc) { } extern uint8_t error_count; -cores_t led_conf; +colors_t led_conf; uint8_t error_count = 0; // conta erros, quantas vezes o programa caiu no error handler uint16_t debug_milis = 0, debug_milis_ant = 0; @@ -65,7 +65,7 @@ void init_modes() { enduro.bat_safe = 1; enduro.torq_gain = 10; // ERA 15 enduro.mode = ENDURO; - enduro.cor = VERDE; + enduro.rgb_colors[0] = GREEN; aceleracao.tor_max = 1500; aceleracao.vel_max = vel_max_rpm; @@ -75,7 +75,7 @@ void init_modes() { aceleracao.bat_safe = 0; aceleracao.torq_gain = 15; aceleracao.mode = ACELERACAO; - aceleracao.cor = ROXO; + aceleracao.rgb_colors[0] = PURPLE; skidpad.tor_max = 2000; skidpad.vel_max = vel_max_rpm; @@ -85,7 +85,7 @@ void init_modes() { skidpad.bat_safe = 0; skidpad.torq_gain = 20; skidpad.mode = SKIDPAD; - skidpad.cor = CIANO; + skidpad.rgb_colors[0] = CYAN; autox.tor_max = 2500; autox.vel_max = vel_max_rpm; @@ -95,7 +95,7 @@ void init_modes() { autox.bat_safe = 0; autox.torq_gain = 25; autox.mode = AUTOX; - autox.cor = AZUL; + autox.rgb_colors[0] = BLUE; erro.tor_max = 0; erro.vel_max = 0; @@ -105,7 +105,7 @@ void init_modes() { erro.bat_safe = 0; erro.torq_gain = 0; erro.mode = ERRO; - erro.cor = VERMELHO; + erro.rgb_colors[0] = RED; set_global_var_value(SELECTED_MODE, enduro); // inicializa no modo enduro } diff --git a/Core/Src/util/main_task.c b/Core/Src/util/main_task.c index 2eafbfac..ca399e82 100644 --- a/Core/Src/util/main_task.c +++ b/Core/Src/util/main_task.c @@ -13,27 +13,87 @@ #include "leds/rgb_led_handler.h" #include "sensors/APPS.h" #include "util/CMSIS_extra/global_variables_handler.h" +#include "util/global_definitions.h" #include "util/global_instances.h" #include "util/global_variables.h" #include "util/util.h" +void led_color_response(uint32_t flag) { + + switch (flag) { + // Soft error + case BSE_ERROR_FLAG: { + colors_t pattern[SOFT_ERROR_COLORS_PATTERN_SIZE] = {YELLOW, PURPLE}; + set_rgb_led(pattern, SOFT_ERROR_COLORS_PATTERN_SIZE, BLINK200); + break; + } + case APPS_ERROR_FLAG: { + colors_t pattern[SOFT_ERROR_COLORS_PATTERN_SIZE] = {YELLOW, BLUE}; + set_rgb_led(pattern, SOFT_ERROR_COLORS_PATTERN_SIZE, BLINK200); + break; + } + // Hard error + case INVERTER_CAN_TRANSMIT_ERROR_FLAG: { + colors_t pattern[HARD_ERROR_COLORS_PATTERN_SIZE] = {RED, BLUE, YELLOW}; + set_rgb_led(pattern, HARD_ERROR_COLORS_PATTERN_SIZE, FIXED); + break; + } + case SU_F_ERROR_FLAG: { + colors_t pattern[HARD_ERROR_COLORS_PATTERN_SIZE] = {RED, WHITE, BLACK}; + set_rgb_led(pattern, HARD_ERROR_COLORS_PATTERN_SIZE, FIXED); + break; + } + case INVERTER_BUS_OFF_ERROR_FLAG: { + colors_t pattern[HARD_ERROR_COLORS_PATTERN_SIZE] = {RED, BLUE, GREEN}; + set_rgb_led(pattern, HARD_ERROR_COLORS_PATTERN_SIZE, FIXED); + break; + } + case LEFT_INVERTER_COMM_ERROR_FLAG: { + colors_t pattern[HARD_ERROR_COLORS_PATTERN_SIZE] = {RED, BLUE, PURPLE}; + set_rgb_led(pattern, HARD_ERROR_COLORS_PATTERN_SIZE, FIXED); + break; + } + case RIGHT_INVERTER_COMM_ERROR_FLAG: { + colors_t pattern[HARD_ERROR_COLORS_PATTERN_SIZE] = {RED, BLUE, CYAN}; + set_rgb_led(pattern, HARD_ERROR_COLORS_PATTERN_SIZE, FIXED); + break; + } + } +} +int test_aux = 500; +uint32_t oldValue; + +uint32_t test(int test_aux, uint32_t* oldValue) { + uint32_t error_vec[3] = {BSE_ERROR_FLAG, INVERTER_CAN_TRANSMIT_ERROR_FLAG, + RIGHT_INVERTER_COMM_ERROR_FLAG}; + if (test_aux % 500 == 0 && test_aux < 1501) { + *oldValue = error_vec[(test_aux / 500) - 1]; + return error_vec[(test_aux / 500) - 1]; + } else { + return *oldValue; + } +} + void main_task(void* argument) { + UNUSED(argument); for (;;) { - ECU_ENABLE_BREAKPOINT_DEBUG(); + // ECU_ENABLE_BREAKPOINT_DEBUG(); - wait_for_rtd(); + // wait_for_rtd(); // Wait for any error osThreadFlagsWait(ALL_ERRORS_FLAG, osFlagsWaitAny | osFlagsNoClear, osWaitForever); // Get the most significant thread flag - uint32_t most_significant_error_flag = get_most_significant_thread_flag(); + uint32_t most_significant_error_flag = + test(test_aux, &oldValue); // get_most_significant_thread_flag(); // Get the event flag - uint32_t event_flags = osEventFlagsGet(e_ECU_control_flagsHandle); - + uint32_t event_flags = + test(test_aux, &oldValue); // osEventFlagsGet(e_ECU_control_flagsHandle); + test_aux++; bool isErrorPresent; switch (most_significant_error_flag) { @@ -46,6 +106,7 @@ void main_task(void* argument) { isErrorPresent = event_flags & INVERTER_BUS_OFF_ERROR_FLAG; if (isErrorPresent) { exit_RTD(); + led_color_response(most_significant_error_flag); } else { // Starts a timer. If the error happens again before the timer expires // the car leaves RTD mode. @@ -64,6 +125,7 @@ void main_task(void* argument) { isErrorPresent = event_flags & most_significant_error_flag; if (isErrorPresent) { exit_RTD(); + led_color_response(most_significant_error_flag); } else { // Clear the thread flag osThreadFlagsClear(most_significant_error_flag); @@ -76,12 +138,13 @@ void main_task(void* argument) { // If the event flag contains the error flag ECU led is set to yellow isErrorPresent = event_flags & most_significant_error_flag; if (isErrorPresent) { - set_rgb_led(AMARELO, NO_CHANGE); + led_color_response(most_significant_error_flag); osDelay(20); } else { // Clear the thread flag and set ECU led to normal osThreadFlagsClear(most_significant_error_flag); - set_rgb_led(get_global_var_value(SELECTED_MODE).cor, NO_CHANGE); + set_rgb_led(get_global_var_value(SELECTED_MODE).rgb_colors, BLINK200, + ONE_COLOR_PATTERN_SIZE); } break;