tdse-tf_3-02

Controlador PID para derretidor de miel con control local via botones y remoto via WiFi
Index Commits Files Refs Submodules README
commit 5af4fd0bb02e29063022e239cc18d8acb542146c
parent 16137903b3ca391610bc1a5f938708de4b9ac7da
Author: Martin Kloeckner <mjkloeckner@gmail.com>
Date:   Tue, 24 Mar 2026 23:15:09 -0300

Agregar nueva tarea `task_led`

Diffstat:
Mfirmware/Core/Inc/main.h | 10+++-------
Mfirmware/Core/Src/main.c | 6+++---
Mfirmware/Core/Src/stm32f1xx_it.c | 2+-
Afirmware/app/inc/task_led.h | 24++++++++++++++++++++++++
Afirmware/app/inc/task_led_attribute.h | 115+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Afirmware/app/inc/task_led_interface.h | 21+++++++++++++++++++++
Mfirmware/app/inc/task_system_attribute.h | 6+++---
Mfirmware/app/src/app.c | 36+++++++++++++++++++-----------------
Mfirmware/app/src/task_buttons.c | 16++++++++--------
Afirmware/app/src/task_led.c | 285+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Afirmware/app/src/task_led_interface.c | 24++++++++++++++++++++++++
Mfirmware/app/src/task_system.c | 65++++++++++++++++++++++++++++++++++++++---------------------------
Mfirmware/tdse-tf_3-02.ioc | 2+-
13 files changed, 545 insertions(+), 67 deletions(-)
diff --git a/firmware/Core/Inc/main.h b/firmware/Core/Inc/main.h
@@ -58,9 +58,9 @@ void Error_Handler(void);
 /* USER CODE END EFP */
 
 /* Private defines -----------------------------------------------------------*/
-#define B1_Pin GPIO_PIN_13
-#define B1_GPIO_Port GPIOC
-#define B1_EXTI_IRQn EXTI15_10_IRQn
+#define BTN_A_Pin GPIO_PIN_13
+#define BTN_A_GPIO_Port GPIOC
+#define BTN_A_EXTI_IRQn EXTI15_10_IRQn
 #define USART_TX_Pin GPIO_PIN_2
 #define USART_TX_GPIO_Port GPIOA
 #define USART_RX_Pin GPIO_PIN_3
@@ -94,10 +94,6 @@ void Error_Handler(void);
 
 /* USER CODE BEGIN Private defines */
 
-// BTN_D is board's built-in blue button
-#define BTN_A_Pin B1_Pin
-#define BTN_A_GPIO_Port B1_GPIO_Port
-
 /* USER CODE END Private defines */
 
 #ifdef __cplusplus
diff --git a/firmware/Core/Src/main.c b/firmware/Core/Src/main.c
@@ -245,11 +245,11 @@ static void MX_GPIO_Init(void)
   /*Configure GPIO pin Output Level */
   HAL_GPIO_WritePin(GPIOB, D5_Pin|D9_Pin|D8_Pin, GPIO_PIN_RESET);
 
-  /*Configure GPIO pin : B1_Pin */
-  GPIO_InitStruct.Pin = B1_Pin;
+  /*Configure GPIO pin : BTN_A_Pin */
+  GPIO_InitStruct.Pin = BTN_A_Pin;
   GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING;
   GPIO_InitStruct.Pull = GPIO_NOPULL;
-  HAL_GPIO_Init(B1_GPIO_Port, &GPIO_InitStruct);
+  HAL_GPIO_Init(BTN_A_GPIO_Port, &GPIO_InitStruct);
 
   /*Configure GPIO pins : USART_TX_Pin USART_RX_Pin */
   GPIO_InitStruct.Pin = USART_TX_Pin|USART_RX_Pin;
diff --git a/firmware/Core/Src/stm32f1xx_it.c b/firmware/Core/Src/stm32f1xx_it.c
@@ -252,7 +252,7 @@ void EXTI15_10_IRQHandler(void)
   /* USER CODE BEGIN EXTI15_10_IRQn 0 */
 
   /* USER CODE END EXTI15_10_IRQn 0 */
-  HAL_GPIO_EXTI_IRQHandler(B1_Pin);
+  HAL_GPIO_EXTI_IRQHandler(BTN_A_Pin);
   /* USER CODE BEGIN EXTI15_10_IRQn 1 */
 
   /* USER CODE END EXTI15_10_IRQn 1 */
diff --git a/firmware/app/inc/task_led.h b/firmware/app/inc/task_led.h
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2026 Martin Javier Klöckner <mklockner@fi.uba.ar>
+ *
+ * See file `LICENSE` for full details
+ */
+
+#ifndef TASK_INC_TASK_LED_H_
+#define TASK_INC_TASK_LED_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern uint32_t g_task_led_cnt;
+extern volatile uint32_t g_task_led_tick_cnt;
+
+void task_led_init(void *parameters);
+void task_led_update(void *parameters);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* TASK_INC_TASK_LED_H_ */
diff --git a/firmware/app/inc/task_led_attribute.h b/firmware/app/inc/task_led_attribute.h
@@ -0,0 +1,115 @@
+/*
+ * Copyright (c) 2026 Martin Javier Klöckner <mklockner@fi.uba.ar>
+ *
+ * See file `LICENSE` for full details
+ */
+
+#ifndef TASK_INC_TASK_LED_ATTRIBUTE_H_
+#define TASK_INC_TASK_LED_ATTRIBUTE_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Led Statechart - State Transition Table */
+/* +-----------------------+-----------------------+-------------+-----------------------+-----------------------+
+ * | Current               | Event                 |             | Next                  |                       |
+ * | State                 | (Parameters)          | [Guard]     | State                 | Actions               |
+ * |=======================+=======================+=============+=======================+=======================|
+ * | INICIAL               |                       |             | ST_LED_XX_OFF         | led = LED_OFF         |
+ * |                       |                       |             |                       | op_led(led)           |
+ * |-----------------------+-----------------------+-------------+-----------------------+-----------------------|
+ * | ST_LED_XX_OFF         | EV_LED_XX_ON          |             | ST_LED_XX_ON          | led = LED_ON          |
+ * |                       |                       |             |                       | op_led(led)           |
+ * |                       |-----------------------+-------------+-----------------------+-----------------------|
+ * |                       | EV_LED_XX_BLINK       |             | ST_LED_XX_BLINK_ON    | tick = tick_max       |
+ * |                       |                       |             |                       | led = LED_ON          |
+ * |                       |                       |             |                       | op_led(led)           |
+ * |                       |-----------------------+-------------+-----------------------+-----------------------|
+ * |                       | EV_LED_XX_PULSE       |             | ST_LED_XX_PULSE       | tick = tick_max       |
+ * |                       |                       |             |                       | led = LED_ON          |
+ * |                       |                       |             |                       | op_led(led)           |
+ * |-----------------------+-----------------------+-------------+-----------------------+-----------------------|
+ * | ST_LED_XX_ON          | EV_LED_XX_OFF         |             | ST_LED_XX_OFF         |  led = LED_OFF        |
+ * |                       |                       |             |                       | op_led(led)           |
+ * |-----------------------+-----------------------+-------------+-----------------------+-----------------------|
+ * | ST_LED_XX_BLINK_ON    | EV_LED_XX_OFF         |             | ST_LED_XX_OFF         | led = LED_OFF         |
+ * |                       |                       |             |                       | op_led(led)           |
+ * |                       +-----------------------+-------------+-----------------------+-----------------------|
+ * |                       | EV_LED_XX_ON          |             | ST_LED_XX_ON          | led = LED_ON          |
+ * |                       |                       |             |                       | op_led(led)           |
+ * |                       +-----------------------+-------------+-----------------------+-----------------------|
+ * |                       |                       | [tick == 0] | ST_LED_XX_BLINK_OFF   | tick = tick_max       |
+ * |                       |                       |             |                       | led = LED_OFF         |
+ * |                       |                       |             |                       | op_led(led)           |
+ * |                       +-----------------------+-------------+-----------------------+-----------------------|
+ * |                       |                       | [tick >  0] | ST_LED_XX_BLINK_ON    | tick--                |
+ * |-----------------------+-----------------------+-------------+-----------------------+-----------------------|
+ * | ST_LED_XX_BLINK_OFF   | EV_LED_XX_OFF         |             | ST_LED_XX_OFF         | led = LED_OFF         |
+ * |                       |                       |             |                       | op_led(led)           |
+ * |                       +-----------------------+-------------+-----------------------+-----------------------|
+ * |                       | EV_LED_XX_ON          |             | ST_LED_XX_ON          | led = LED_ON          |
+ * |                       |                       |             |                       | op_led(led)           |
+ * |                       +-----------------------+-------------+-----------------------+-----------------------|
+ * |                       |                       | [tick >  0] | ST_LED_XX_BLINK_OFF   | tick--                |
+ * |                       +-----------------------+-------------+-----------------------+-----------------------|
+ * |                       |                       | [tick == 0] | ST_LED_XX_BLINK_ON    | tick = tick_max       |
+ * |                       |                       |             |                       | led = LED_ON          |
+ * |                       |                       |             |                       | op_led(led)           |
+ * |-----------------------+-----------------------+-------------+-----------------------+-----------------------|
+ * | ST_LED_XX_PULSE       |                       | [tick == 0] | ST_LED_XX_OFF         | tick = tick_max       |
+ * |                       |                       |             |                       | led = LED_OFF         |
+ * |                       |                       |             |                       | op_led(led)           |
+ * |-----------------------+-----------------------+-------------+-----------------------+-----------------------|
+ * |                       |                       | [tick >  0] | ST_LED_XX_PULSE       | tick--                |
+ * +-----------------------+-----------------------+-------------+-----------------------+-----------------------+ */
+
+/* Events to excite Task Led */
+typedef enum {
+    EV_LED_XX_OFF,
+    EV_LED_XX_ON,
+    EV_LED_XX_NOT_BLINK,
+    EV_LED_XX_BLINK,
+    EV_LED_XX_PULSE
+} task_led_ev_t;
+
+/* States of Task Led */
+typedef enum {
+    ST_LED_XX_OFF,
+    ST_LED_XX_ON,
+    ST_LED_XX_BLINK_ON,
+    ST_LED_XX_BLINK_OFF,
+    ST_LED_XX_PULSE
+} task_led_st_t;
+
+/* Identifier of Task Led */
+typedef enum {
+    ID_LED_A,
+} task_led_id_t;
+
+typedef struct
+{
+    task_led_id_t identifier;
+    GPIO_TypeDef *gpio_port;
+    uint16_t pin;
+    GPIO_PinState led_on;
+    GPIO_PinState led_off;
+    uint32_t tick_blink;
+    uint32_t tick_pulse;
+} task_led_cfg_t;
+
+typedef struct
+{
+    uint32_t tick;
+    task_led_st_t state;
+    task_led_ev_t event;
+    bool flag;
+} task_led_dta_t;
+
+extern task_led_dta_t task_led_dta_list[];
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* TASK_INC_TASK_LED_ATTRIBUTE_H_ */
diff --git a/firmware/app/inc/task_led_interface.h b/firmware/app/inc/task_led_interface.h
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2023 Juan Manuel Cruz <jcruz@fi.uba.ar> <jcruz@frba.utn.edu.ar>.
+ * Copyright (c) 2026 Martin Javier Klöckner <mklockner@fi.uba.ar>
+ *
+ * See file `LICENSE` for full details
+ */
+
+#ifndef TASK_INC_TASK_LED_INTERFACE_H_
+#define TASK_INC_TASK_LED_INTERFACE_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern void put_event_task_led(task_led_ev_t event, task_led_id_t identifier);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* TASK_INC_TASK_LED_INTERFACE_H_ */
diff --git a/firmware/app/inc/task_system_attribute.h b/firmware/app/inc/task_system_attribute.h
@@ -40,15 +40,15 @@ typedef enum task_system_ev {
 } task_system_ev_t;
 
 typedef enum task_system_st {
-    ST_SYS_LED_ON,
-    ST_SYS_LED_OFF
+    ST_SYS_IDLE,
+    ST_SYS_LED_BLINK
 } task_system_st_t;
 
 typedef struct {
     uint32_t         tick;
     task_system_st_t state;
     task_system_ev_t event;
-    bool             flag;
+    bool             event_flag;
 } task_system_dta_t;
 
 extern task_system_dta_t task_system_dta;
diff --git a/firmware/app/src/app.c b/firmware/app/src/app.c
@@ -16,12 +16,14 @@
 #include "task_temp_sensor.h"
 #include "task_buttons.h"
 #include "task_menu.h"
+#include "task_led.h"
 
 #define G_APP_CNT_INI       0ul
 #define G_APP_TICK_CNT_INI  0ul
 #define G_APP_WCET_INI      0ul
 
 #define TASK_X_WCET_INI     0ul
+#define TASK_X_TICK_INI     0ul
 #define TASK_X_DELAY_MIN    0ul
 
 typedef struct {
@@ -30,27 +32,27 @@ typedef struct {
     void *parameters;
 } task_cfg_t;
 
-typedef struct {
-    uint32_t WCET; // Task worst-case execution time (microseconds)
-} task_dta_t;
-
 const task_cfg_t task_cfg_list[] = {
-    {task_buttons_init,     task_buttons_update,     NULL},
-    {task_temp_sensor_init, task_temp_sensor_update, NULL},
-    {task_system_init,      task_system_update,      NULL},
-    {task_actuator_init,    task_actuator_update,    NULL},
-    {task_menu_init,        task_menu_update,        NULL}
+    {task_system_init,  task_system_update,  NULL},
+    {task_buttons_init, task_buttons_update, NULL},
+    {task_led_init,     task_led_update,     NULL},
+    // {task_temp_sensor_init, task_temp_sensor_update, NULL, g_task_buttons_tick_cnt},
+    // {task_actuator_init,    task_actuator_update,    NULL, g_task_buttons_tick_cnt},
+    // {task_menu_init,        task_menu_update,        NULL, g_task_buttons_tick_cnt}
 };
 
 #define TASK_QTY (sizeof(task_cfg_list)/sizeof(task_cfg_t))
 
+typedef struct {
+    uint32_t WCET; // Task worst-case execution time (microseconds)
+} task_dta_t;
+
+task_dta_t task_dta_list[TASK_QTY];
+
 uint32_t g_app_runtime_us;
 uint32_t g_app_WCET_us; // Worst case execution time historically
-
 volatile uint32_t g_app_tick_cnt;
 
-task_dta_t task_dta_list[TASK_QTY] = {0};
-
 void app_init(void)
 {
     LOGGER_INFO("Initializing `app`...");
@@ -100,7 +102,6 @@ void app_update(void)
             (*task_cfg_list[index].task_update)(task_cfg_list[index].parameters);
 
             cycle_counter_time_us = cycle_counter_get_time_us();
-
             g_app_runtime_us += cycle_counter_time_us;
 
             if (g_app_WCET_us < g_app_runtime_us) {
@@ -133,9 +134,10 @@ void HAL_SYSTICK_Callback(void)
 {
     g_app_tick_cnt++;
 
-    g_task_buttons_tick_cnt++;
-    g_task_temp_sensor_tick_cnt++;
     g_task_system_tick_cnt++;
-    g_task_actuator_tick_cnt++;
-    g_task_menu_tick_cnt++;
+    g_task_buttons_tick_cnt++;
+    g_task_led_tick_cnt++;
+    // g_task_temp_sensor_tick_cnt++;
+    // g_task_actuator_tick_cnt++;
+    // g_task_menu_tick_cnt++;
 }
diff --git a/firmware/app/src/task_buttons.c b/firmware/app/src/task_buttons.c
@@ -18,17 +18,17 @@
 #include "task_menu_attribute.h"
 #include "task_menu_interface.h"
 
-#define G_TASK_SEN_TICK_CNT_INI   0ul
+#define G_TASK_BTN_TICK_CNT_INI   0ul
 
 #define DEL_BTN_XX_MIN          0ul
 #define DEL_BTN_XX_MED          25ul
 #define DEL_BTN_XX_MAX          50ul
 
 const task_buttons_cfg_t task_buttons_cfg_list[] = {
-    {ID_BTN_A, BTN_A_GPIO_Port, BTN_A_Pin, BTN_A_PRESSED, DEL_BTN_XX_MAX, EV_MEN_ENT_ACTIVE, EV_MEN_ENT_IDLE},
-    {ID_BTN_B, BTN_B_GPIO_Port, BTN_B_Pin, BTN_A_PRESSED, DEL_BTN_XX_MAX, EV_MEN_ENT_ACTIVE, EV_MEN_ENT_IDLE},
-    {ID_BTN_C, BTN_C_GPIO_Port, BTN_C_Pin, BTN_A_PRESSED, DEL_BTN_XX_MAX, EV_MEN_NEX_ACTIVE, EV_MEN_NEX_IDLE},
-    {ID_BTN_D, BTN_D_GPIO_Port, BTN_D_Pin, BTN_A_PRESSED, DEL_BTN_XX_MAX, EV_MEN_ESC_ACTIVE, EV_MEN_ESC_IDLE},
+    {ID_BTN_A, BTN_A_GPIO_Port, BTN_A_Pin, BTN_A_PRESSED, DEL_BTN_XX_MAX, EV_SYS_BTN_A_IDLE, EV_SYS_BTN_A_ACTIVE},
+    {ID_BTN_B, BTN_B_GPIO_Port, BTN_B_Pin, BTN_A_PRESSED, DEL_BTN_XX_MAX, EV_SYS_BTN_B_IDLE, EV_SYS_BTN_B_ACTIVE},
+    {ID_BTN_C, BTN_C_GPIO_Port, BTN_C_Pin, BTN_A_PRESSED, DEL_BTN_XX_MAX, EV_SYS_BTN_C_IDLE, EV_SYS_BTN_C_ACTIVE},
+    {ID_BTN_D, BTN_D_GPIO_Port, BTN_D_Pin, BTN_A_PRESSED, DEL_BTN_XX_MAX, EV_SYS_BTN_D_IDLE, EV_SYS_BTN_D_ACTIVE},
 };
 
 #define BUTTONS_CFG_QTY (sizeof(task_buttons_cfg_list)/sizeof(task_buttons_cfg_t))
@@ -71,7 +71,7 @@ void task_buttons_update(void *parameters)
     bool b_time_update_required = false;
 
     __asm("CPSID i");
-    if (G_TASK_SEN_TICK_CNT_INI < g_task_buttons_tick_cnt)
+    if (G_TASK_BTN_TICK_CNT_INI < g_task_buttons_tick_cnt)
     {
         g_task_buttons_tick_cnt--;
         b_time_update_required = true;
@@ -83,7 +83,7 @@ void task_buttons_update(void *parameters)
         task_buttons_statechart();
 
         __asm("CPSID i");
-        if (G_TASK_SEN_TICK_CNT_INI < g_task_buttons_tick_cnt)
+        if (G_TASK_BTN_TICK_CNT_INI < g_task_buttons_tick_cnt)
         {
             g_task_buttons_tick_cnt--;
             b_time_update_required = true;
@@ -146,7 +146,7 @@ void task_buttons_statechart(void)
                 {
                     if (0 == p_task_buttons_dta->tick) {
                         p_task_buttons_dta->state = ST_BTN_XX_DOWN;
-                        put_event_task_menu(p_task_buttons_cfg->signal_down);
+                        put_event_task_system(p_task_buttons_cfg->signal_down);
                     }
                     else
                     {
diff --git a/firmware/app/src/task_led.c b/firmware/app/src/task_led.c
@@ -0,0 +1,285 @@
+/*
+ * Copyright (c) 2023 Juan Manuel Cruz <jcruz@fi.uba.ar> <jcruz@frba.utn.edu.ar>.
+ * Copyright (c) 2026 Martin Javier Klöckner <mklockner@fi.uba.ar>
+ *
+ * See file `LICENSE` for full details
+ */
+
+/* Project includes */
+#include "main.h"
+
+/* Demo includes */
+#include "logger.h"
+#include "dwt.h"
+
+/* Application & Tasks includes */
+#include "board.h"
+#include "app.h"
+#include "task_led_attribute.h"
+#include "task_led_interface.h"
+
+#define G_TASK_LED_CNT_INIT     0ul
+#define G_TASK_LED_TICK_CNT_INI 0ul
+
+#define DEL_LED_XX_PUL      250ul
+#define DEL_LED_XX_BLI      500ul
+#define DEL_LED_XX_MIN      0ul
+
+#define LED_ON  GPIO_PIN_SET
+#define LED_OFF GPIO_PIN_RESET
+
+const task_led_cfg_t task_led_cfg_list[] = {
+    {ID_LED_A, LD2_GPIO_Port, LD2_Pin, LED_ON, LED_OFF, DEL_LED_XX_BLI, DEL_LED_XX_PUL},
+    // {ID_LED_B, LED_A_GPIO_Port, LED_A_Pin, LED_ON, LED_OFF, DEL_LED_XX_BLI, DEL_LED_XX_PUL},
+};
+
+#define LED_CFG_QTY (sizeof(task_led_cfg_list)/sizeof(task_led_cfg_t))
+
+task_led_dta_t task_led_dta_list[] = {
+    {DEL_LED_XX_MIN, ST_LED_XX_OFF, EV_LED_XX_NOT_BLINK, false},
+    // {DEL_LED_XX_MIN, ST_LED_XX_OFF, EV_LED_XX_NOT_BLINK, false}
+};
+
+#define LED_DTA_QTY (sizeof(task_led_dta_list)/sizeof(task_led_dta_t))
+
+// Private functions declaration
+void task_led_statechart(void);
+
+// External data declaration
+uint32_t g_task_led_cnt;
+volatile uint32_t g_task_led_tick_cnt;
+
+// External functions definition
+void task_led_init(void *parameters)
+{
+    uint32_t index;
+    const task_led_cfg_t *p_task_led_cfg;
+    task_led_dta_t *p_task_led_dta;
+
+    LOGGER_INFO("Initializing `task_led`...");
+
+    g_task_led_cnt = G_TASK_LED_CNT_INIT;
+    for (index = 0; LED_DTA_QTY > index; index++)
+    {
+        /* Update Task led Configuration & Data Pointer */
+        p_task_led_cfg = &task_led_cfg_list[index];
+        p_task_led_dta = &task_led_dta_list[index];
+
+        p_task_led_dta->state = ST_LED_XX_OFF;
+        p_task_led_dta->event = EV_LED_XX_OFF;
+        p_task_led_dta->flag = false;
+
+        /*
+        LOGGER_INFO(" ");
+        LOGGER_INFO("   %s = %lu   %s = %lu   %s = %lu   %s = %s",
+                GET_NAME(index), index,
+                GET_NAME(state), (uint32_t)state,
+                GET_NAME(event), (uint32_t)event,
+                GET_NAME(b_event), (b_event ? "true" : "false"));
+        */
+        HAL_GPIO_WritePin(p_task_led_cfg->gpio_port,
+                p_task_led_cfg->pin,
+                p_task_led_cfg->led_off);
+    }
+}
+
+void task_led_update(void *parameters)
+{
+    bool b_time_update_required = false;
+
+    __asm("CPSID i");
+    if (G_TASK_LED_TICK_CNT_INI < g_task_led_tick_cnt)
+    {
+        g_task_led_tick_cnt--;
+        b_time_update_required = true;
+    }
+    __asm("CPSIE i");
+
+    while (b_time_update_required)
+    {
+        g_task_led_cnt++;
+
+        task_led_statechart();
+
+        __asm("CPSID i");
+        if (G_TASK_LED_TICK_CNT_INI < g_task_led_tick_cnt)
+        {
+            g_task_led_tick_cnt--;
+            b_time_update_required = true;
+        }
+        else
+        {
+            b_time_update_required = false;
+        }
+        __asm("CPSIE i");
+    }
+}
+
+void task_led_statechart(void)
+{
+    uint32_t index;
+    const task_led_cfg_t *p_task_led_cfg;
+    task_led_dta_t *p_task_led_dta;
+
+    for (index = 0; LED_DTA_QTY > index; index++)
+    {
+        p_task_led_cfg = &task_led_cfg_list[index];
+        p_task_led_dta = &task_led_dta_list[index];
+
+        switch (p_task_led_dta->state)
+        {
+            case ST_LED_XX_OFF:
+                if (true == p_task_led_dta->flag)
+                {
+                    p_task_led_dta->flag = false;
+                    switch(p_task_led_dta->event)
+                    {
+                        case EV_LED_XX_ON:
+                            p_task_led_dta->state = ST_LED_XX_ON;
+                            HAL_GPIO_WritePin(
+                                    p_task_led_cfg->gpio_port,
+                                    p_task_led_cfg->pin,
+                                    p_task_led_cfg->led_on);
+                        break;
+
+                        case EV_LED_XX_BLINK:
+                            p_task_led_dta->tick  = DEL_LED_XX_BLI;
+                            p_task_led_dta->state = ST_LED_XX_BLINK_ON;
+                            HAL_GPIO_WritePin(
+                                    p_task_led_cfg->gpio_port,
+                                    p_task_led_cfg->pin,
+                                    p_task_led_cfg->led_on);
+                        break;
+
+                        case EV_LED_XX_PULSE:
+                            p_task_led_dta->tick  = DEL_LED_XX_PUL;
+                            p_task_led_dta->state = ST_LED_XX_PULSE;
+                            HAL_GPIO_WritePin(
+                                    p_task_led_cfg->gpio_port,
+                                    p_task_led_cfg->pin,
+                                    p_task_led_cfg->led_on);
+                        default:
+                        break;
+                    }
+                }
+            break;
+
+            case ST_LED_XX_ON:
+                if ((true == p_task_led_dta->flag)
+                        && (EV_LED_XX_OFF == p_task_led_dta->event))
+                {
+                    p_task_led_dta->flag = false;
+                    p_task_led_dta->state = ST_LED_XX_OFF;
+                    HAL_GPIO_WritePin(
+                            p_task_led_cfg->gpio_port,
+                            p_task_led_cfg->pin,
+                            p_task_led_cfg->led_off);
+                }
+
+            break;
+
+            case ST_LED_XX_BLINK_ON:
+                if (true == p_task_led_dta->flag)
+                {
+                    p_task_led_dta->flag = false;
+                    switch(p_task_led_dta->event)
+                    {
+                        case EV_LED_XX_OFF:
+                            p_task_led_dta->state = ST_LED_XX_OFF;
+                            HAL_GPIO_WritePin(
+                                    p_task_led_cfg->gpio_port,
+                                    p_task_led_cfg->pin,
+                                    p_task_led_cfg->led_off);
+                        break;
+                        case EV_LED_XX_ON:
+                            p_task_led_dta->state = ST_LED_XX_ON;
+                            HAL_GPIO_WritePin(
+                                    p_task_led_cfg->gpio_port,
+                                    p_task_led_cfg->pin,
+                                    p_task_led_cfg->led_on);
+                        default:
+                        break;
+                    }
+                }
+
+                if (DEL_LED_XX_MIN == p_task_led_dta->tick)
+                {
+                    p_task_led_dta->state = ST_LED_XX_BLINK_OFF;
+                    p_task_led_dta->tick = DEL_LED_XX_BLI;
+                    HAL_GPIO_WritePin(
+                            p_task_led_cfg->gpio_port,
+                            p_task_led_cfg->pin,
+                            p_task_led_cfg->led_off);
+                }
+
+                if (DEL_LED_XX_MIN < p_task_led_dta->tick)
+                {
+                    p_task_led_dta->tick--;
+                }
+            break;
+
+            case ST_LED_XX_BLINK_OFF:
+                if (true == p_task_led_dta->flag)
+                {
+                    p_task_led_dta->flag = false;
+                    switch(p_task_led_dta->event)
+                    {
+                        case EV_LED_XX_OFF:
+                            p_task_led_dta->state = ST_LED_XX_OFF;
+                            HAL_GPIO_WritePin(
+                                    p_task_led_cfg->gpio_port,
+                                    p_task_led_cfg->pin,
+                                    p_task_led_cfg->led_off);
+                        break;
+                        case EV_LED_XX_ON:
+                            p_task_led_dta->state = ST_LED_XX_ON;
+                            HAL_GPIO_WritePin(
+                                    p_task_led_cfg->gpio_port,
+                                    p_task_led_cfg->pin,
+                                    p_task_led_cfg->led_on);
+                        default:
+                        break;
+                    }
+                }
+
+                if (DEL_LED_XX_MIN == p_task_led_dta->tick)
+                {
+                    p_task_led_dta->state = ST_LED_XX_BLINK_ON;
+                    p_task_led_dta->tick = DEL_LED_XX_BLI;
+                    HAL_GPIO_WritePin(
+                            p_task_led_cfg->gpio_port,
+                            p_task_led_cfg->pin,
+                            p_task_led_cfg->led_on);
+                }
+
+                if (DEL_LED_XX_MIN < p_task_led_dta->tick)
+                {
+                    p_task_led_dta->tick--;
+                }
+            break;
+
+            case ST_LED_XX_PULSE:
+                if (DEL_LED_XX_MIN == p_task_led_dta->tick)
+                {
+                    p_task_led_dta->state = ST_LED_XX_OFF;
+                    HAL_GPIO_WritePin(
+                            p_task_led_cfg->gpio_port,
+                            p_task_led_cfg->pin,
+                            p_task_led_cfg->led_off);
+                }
+
+                if (DEL_LED_XX_MIN < p_task_led_dta->tick)
+                {
+                    p_task_led_dta->tick--;
+                }
+            break;
+
+            default:
+                p_task_led_dta->tick  = DEL_LED_XX_MIN;
+                p_task_led_dta->state = ST_LED_XX_OFF;
+                p_task_led_dta->event = EV_LED_XX_OFF;
+                p_task_led_dta->flag = false;
+            break;
+        }
+    }
+}
diff --git a/firmware/app/src/task_led_interface.c b/firmware/app/src/task_led_interface.c
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2023 Juan Manuel Cruz <jcruz@fi.uba.ar> <jcruz@frba.utn.edu.ar>.
+ * Copyright (c) 2026 Martin Javier Klöckner <mklockner@fi.uba.ar>
+ *
+ * See file `LICENSE` for full details
+ */
+
+#include "main.h"
+
+#include "logger.h"
+#include "dwt.h"
+
+#include "board.h"
+#include "app.h"
+#include "task_led_attribute.h"
+
+void put_event_task_led(task_led_ev_t event, task_led_id_t identifier)
+{
+    task_led_dta_t *p_task_led_dta;
+
+    p_task_led_dta = &task_led_dta_list[identifier];
+    p_task_led_dta->event = event;
+    p_task_led_dta->flag = true;
+}
diff --git a/firmware/app/src/task_system.c b/firmware/app/src/task_system.c
@@ -14,28 +14,30 @@
 #include "app.h"
 #include "task_system_attribute.h"
 #include "task_system_interface.h"
-#include "task_actuator_attribute.h"
-#include "task_actuator_interface.h"
+#include "task_led_attribute.h"
+#include "task_led_interface.h"
 
 #define G_TASK_SYS_CNT_INI       0ul
 #define G_TASK_SYS_TICK_CNT_INI  0ul
 
-#define G_LED_PERIOD_MS 1000ul
-#define G_LED_T_ON_MS   500ul
+#define DEL_SYS_MIN             0ul
+#define DEL_SYS_MED             50ul
+#define DEL_SYS_MAX             500ul
 
 task_system_dta_t task_system_dta = {
-    G_LED_PERIOD_MS, ST_SYS_LED_ON, EV_SYS_IDLE, false
+    DEL_SYS_MIN, ST_SYS_IDLE, EV_SYS_IDLE, false
 };
 
 #define SYSTEM_DTA_QTY (sizeof(task_system_dta)/sizeof(task_system_dta_t))
 
-void task_system_statechart(void);
-
 uint32_t g_task_system_cnt;
 
 // this is updated every ms by the HAL_SysTick
 volatile uint32_t g_task_system_tick_cnt;
 
+
+void task_system_statechart(void);
+
 void task_system_init(void *parameters)
 {
     task_system_dta_t *p_task_system_dta;
@@ -49,7 +51,7 @@ void task_system_init(void *parameters)
 
     p_task_system_dta = &task_system_dta;
 
-    state = ST_SYS_LED_ON;
+    state = ST_SYS_IDLE;
     p_task_system_dta->state = state;
 
     LOGGER_INFO("Done initializing `task_system`");
@@ -93,38 +95,47 @@ void task_system_statechart(void)
 
     if (true == any_event_task_system())
     {
-        p_task_system_dta->flag = true;
+        p_task_system_dta->event_flag = true;
         p_task_system_dta->event = get_event_task_system();
     }
 
     switch (p_task_system_dta->state)
     {
-        case ST_SYS_LED_ON:
-
-            if (G_LED_T_ON_MS < g_task_system_cnt)
+        case ST_SYS_IDLE:
+            if (true == p_task_system_dta->event_flag)
             {
-                put_event_task_actuator(EV_LED_OFF, ID_LED_A);
-                p_task_system_dta->state = ST_SYS_LED_OFF;
+                p_task_system_dta->event_flag = false;
+                switch (p_task_system_dta->event)
+                {
+                    case EV_SYS_BTN_B_ACTIVE:
+                        p_task_system_dta->state = ST_SYS_LED_BLINK;
+                        put_event_task_led(EV_LED_XX_BLINK, ID_LED_A);
+                        break;
+                    default: break;
+                }
             }
-
             break;
 
-        case ST_SYS_LED_OFF:
-
-            if (G_LED_PERIOD_MS < g_task_system_cnt)
+        case ST_SYS_LED_BLINK:
+            if (true == p_task_system_dta->event_flag)
             {
-                g_task_system_cnt = G_TASK_SYS_CNT_INI;
-                put_event_task_actuator(EV_LED_ON, ID_LED_A);
-                p_task_system_dta->state = ST_SYS_LED_ON;
+                p_task_system_dta->event_flag = false;
+                switch (p_task_system_dta->event)
+                {
+                    case EV_SYS_BTN_B_ACTIVE:
+                        p_task_system_dta->state = ST_SYS_IDLE;
+                        put_event_task_led(EV_LED_XX_OFF, ID_LED_A);
+                        break;
+                    default: break;
+                }
             }
-
             break;
 
-        default:
-
-            p_task_system_dta->tick  = 0;
-            p_task_system_dta->state = ST_SYS_LED_ON;
-
+        default: 
+            if (true == p_task_system_dta->event_flag)
+            {
+                p_task_system_dta->event_flag = false;
+            }
             break;
     }
 }
diff --git a/firmware/tdse-tf_3-02.ioc b/firmware/tdse-tf_3-02.ioc
@@ -161,7 +161,7 @@ PB9.GPIO_PuPd=GPIO_PULLUP
 PB9.Locked=true
 PB9.Signal=GPIO_Output
 PC13-TAMPER-RTC.GPIOParameters=GPIO_PuPd,GPIO_Label
-PC13-TAMPER-RTC.GPIO_Label=B1 [Blue PushButton]
+PC13-TAMPER-RTC.GPIO_Label=BTN_A
 PC13-TAMPER-RTC.GPIO_PuPd=GPIO_NOPULL
 PC13-TAMPER-RTC.Locked=true
 PC13-TAMPER-RTC.Signal=GPXTI13