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 cc2eaa2093f98f8d33aecba9229199f637501891
parent eb00b138812f074c01a2a0a0a7d2b1fcef7dc10a
Author: Martin Kloeckner <mjkloeckner@gmail.com>
Date:   Sat, 28 Mar 2026 19:04:32 -0300

Cambiar prefijo `DS18B20_*` por `ds18b20_`

Diffstat:
Mfirmware/app/inc/ds18b20.h | 6+++---
Mfirmware/app/src/ds18b20.c | 252+++++++++++++++++++++++++++++++++++--------------------------------------------
Mfirmware/app/src/task_menu.c | 15++++++---------
Mfirmware/app/src/task_temp_sensor.c | 9+++++++--
4 files changed, 126 insertions(+), 156 deletions(-)
diff --git a/firmware/app/inc/ds18b20.h b/firmware/app/inc/ds18b20.h
@@ -82,10 +82,10 @@ typedef enum {
     ST_DS18B20_BUSY_WAITING_MSB,
     ST_DS18B20_BUSY_WAITING,
     ST_DS18B20_BUSY_WAITING_DMA
-} DS18B20_st_t;
+} ds18b20_st_t;
 
-void DS18B20_Init(void);
-void DS18B20_Update(void);
+void ds18b20_init(void);
+void ds18b20_update(void);
 
 #ifdef __cplusplus
 }
diff --git a/firmware/app/src/ds18b20.c b/firmware/app/src/ds18b20.c
@@ -12,41 +12,32 @@
 #include "stm32f1xx_ll_usart.h"
 #include "logger.h"
 
-#include "task_menu_attribute.h"
-#include "task_menu_interface.h"
-
 #define G_DS18B20_CONV_TIME_MS   100ul // ~188ms for 10 bit resolution
 #define G_TEMP_PERIOD_MS         1000ul
 #define G_DATA_BAUDRATE          96500
 
 // Private global variables
-const uint8_t g_buffer[8] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
-DS18B20_st_t g_DS18B20_state, g_DS18B20_prev_state;
-uint32_t g_DS18B20_tick;
-uint16_t g_DS18B20_temp;
-uint8_t Temp_LSB, Temp_MSB;
-
-static uint8_t g_DS18B20_TX_buffer[8];
-static uint8_t g_DS18B20_RX_buffer[8];
-bool b_DS18B20_DMA_TX_done, b_DS18B20_DMA_RX_done;
-static uint8_t l_DS18B20_DMA_error_count;
-
-const uint8_t g_DS18B20_Reset_data_tx = 0xF0;
-uint8_t g_DS18B20_Reset_data_rx = 0xF0;
+ds18b20_st_t g_ds18b20_state, g_ds18b20_prev_state;
+uint32_t g_ds18b20_tick;
+uint16_t g_ds18b20_temp;
+uint8_t temp_lsb, temp_msb;
+uint8_t g_ds18b20_tx_buffer[8], g_ds18b20_rx_buffer[8];
+uint8_t g_ds18b20_reset_data_tx, g_ds18b20_reset_data_rx;
+bool b_ds18b20_dma_tx_done, b_ds18b20_dma_rx_done;
 
 // Public global variables
-uint16_t g_DS18B20_update_count;
-uint16_t g_DS18B20_DMA_error_count;
+uint16_t g_ds18b20_update_count, g_ds18b20_dma_error_count;
 
 // Private functions declaration
-void DS18B20_Write(uint8_t data);
-void DS18B20_Write_DMA(uint8_t data);
-void DS18B20_SetResolution(uint8_t resolution);
-void DS18B20_Read_temp(void);
-void DS18B20_Reset_DMA(void);
-uint8_t DS18B20_Get_RX_byte(void);
-
-uint8_t DS18B20_Reset(void)
+void ds18b20_write(uint8_t data);
+void ds18b20_read_temp(void);
+void ds18b20_set_resolution(uint8_t resolution);
+
+void ds18b20_write_dma(uint8_t data);
+void ds18b20_reset_dma(void);
+uint8_t ds18b20_get_rx_byte(void);
+
+uint8_t ds18b20_reset(void)
 {
     uint8_t data = 0xF0;
 
@@ -68,18 +59,19 @@ uint8_t DS18B20_Reset(void)
     return 0;
 }
 
-void DS18B20_Reset_DMA(void)
+void ds18b20_reset_dma(void)
 {
     __HAL_UART_DISABLE(&huart1);
     LL_USART_SetBaudRate(USART1, HAL_RCC_GetPCLK2Freq(), 9600);
     __HAL_UART_ENABLE(&huart1);
 
-    b_DS18B20_DMA_TX_done = b_DS18B20_DMA_RX_done = false;
-    HAL_UARTEx_ReceiveToIdle_DMA(&huart1, &g_DS18B20_Reset_data_rx, 1);
-    HAL_UART_Transmit_DMA(&huart1, &g_DS18B20_Reset_data_tx, 1);
+    b_ds18b20_dma_tx_done = b_ds18b20_dma_rx_done = false;
+    HAL_UARTEx_ReceiveToIdle_DMA(&huart1, &g_ds18b20_reset_data_rx, 1);
+    g_ds18b20_reset_data_tx = 0xF0;
+    HAL_UART_Transmit_DMA(&huart1, &g_ds18b20_reset_data_tx, 1);
 }
 
-void DS18B20_SetResolution(uint8_t resolution)
+void ds18b20_set_resolution(uint8_t resolution)
 {
     uint8_t config;
 
@@ -92,34 +84,34 @@ void DS18B20_SetResolution(uint8_t resolution)
         default: config = 0x7F;
     }
 
-    DS18B20_Reset();
-    DS18B20_Write(DS18B20_SKIP_ROM_CMD);
-    DS18B20_Write(DS18B20_WRITE_SCRATCHPAD_CMD);
+    ds18b20_reset();
+    ds18b20_write(DS18B20_SKIP_ROM_CMD);
+    ds18b20_write(DS18B20_WRITE_SCRATCHPAD_CMD);
 
-    DS18B20_Write(0x00); // Alarm TH byte
-    DS18B20_Write(0x00); // Alarm TL byte
-    DS18B20_Write(config);
+    ds18b20_write(0x00); // Alarm TH byte
+    ds18b20_write(0x00); // Alarm TL byte
+    ds18b20_write(config);
 
-    DS18B20_Reset();
-    DS18B20_Write(DS18B20_SKIP_ROM_CMD);
-    DS18B20_Write(DS18B20_WRITE_SCRATCHPAD_TO_EEPROM_CMD);
+    ds18b20_reset();
+    ds18b20_write(DS18B20_SKIP_ROM_CMD);
+    ds18b20_write(DS18B20_WRITE_SCRATCHPAD_TO_EEPROM_CMD);
 }
 
-void DS18B20_Init(void)
+void ds18b20_init(void)
 {
-    if (DS18B20_Reset() == 0)
+    if (ds18b20_reset() == 0)
     {
         LOGGER_INFO("Temperature sensor initialized successfully");
     }
-    DS18B20_SetResolution(9);
-    g_DS18B20_state = g_DS18B20_prev_state = ST_DS18B20_READY;
-    g_DS18B20_tick = G_TEMP_PERIOD_MS;
-    g_DS18B20_update_count = 0;
-    g_DS18B20_DMA_error_count = 0;
-    Temp_LSB = Temp_MSB = 0xFF;
+    ds18b20_set_resolution(9);
+    g_ds18b20_state = g_ds18b20_prev_state = ST_DS18B20_READY;
+    g_ds18b20_tick = G_TEMP_PERIOD_MS;
+    g_ds18b20_update_count = 0;
+    g_ds18b20_dma_error_count = 0;
+    temp_lsb = temp_msb = 0xFF;
 }
 
-void DS18B20_Write(uint8_t data)
+void ds18b20_write(uint8_t data)
 {
     uint8_t buffer[8];
 
@@ -135,42 +127,41 @@ void DS18B20_Write(uint8_t data)
         }
     }
 
-    // Blocking call and can wait max 100ms
     HAL_UART_Transmit(&huart1, buffer, 8, 100);
 }
 
-void DS18B20_Write_DMA(uint8_t data)
+void ds18b20_write_dma(uint8_t data)
 {
     for (uint8_t i = 0; i < 8; ++i)
     {
         if (data & (1 << i))
         {
-            g_DS18B20_TX_buffer[i] = 0xFF;
+            g_ds18b20_tx_buffer[i] = 0xFF;
         }
         else
         {
-            g_DS18B20_TX_buffer[i] = 0x00;
+            g_ds18b20_tx_buffer[i] = 0x00;
         }
     }
 
-    b_DS18B20_DMA_TX_done = false;
-    HAL_UART_Transmit_DMA(&huart1, g_DS18B20_TX_buffer, 8);
+    b_ds18b20_dma_tx_done = false;
+    HAL_UART_Transmit_DMA(&huart1, g_ds18b20_tx_buffer, 8);
 }
 
-void DS18B20_Read_DMA(void)
+void ds18b20_read_dma(void)
 {
-    memset(g_DS18B20_RX_buffer, 0, sizeof(g_DS18B20_RX_buffer));
-    b_DS18B20_DMA_RX_done = false;
-    HAL_UARTEx_ReceiveToIdle_DMA(&huart1, g_DS18B20_RX_buffer, 8);
+    memset(g_ds18b20_rx_buffer, 0, sizeof(g_ds18b20_rx_buffer));
+    b_ds18b20_dma_rx_done = false;
+    HAL_UARTEx_ReceiveToIdle_DMA(&huart1, g_ds18b20_rx_buffer, 8);
 }
 
-uint8_t DS18B20_Get_RX_byte(void)
+uint8_t ds18b20_get_rx_byte(void)
 {
     // Process received byte
     uint8_t received_value = 0;
     for (uint8_t i = 0; i < 8; ++i)
     {
-        if (g_DS18B20_RX_buffer[i] == 0xFF)
+        if (g_ds18b20_rx_buffer[i] == 0xFF)
         {
             received_value |= (1 << i);
         }
@@ -178,108 +169,97 @@ uint8_t DS18B20_Get_RX_byte(void)
     return received_value;
 }
 
-void DS18B20_Update(void)
+void ds18b20_update(void)
 {
-    switch (g_DS18B20_state)
+    switch (g_ds18b20_state)
     {
         case ST_DS18B20_READY:
-            if (0 == g_DS18B20_tick)
+            if (0 == g_ds18b20_tick)
             {
-                l_DS18B20_DMA_error_count = 0;
-                g_DS18B20_prev_state = g_DS18B20_state;
-                g_DS18B20_state = ST_DS18B20_BUSY_SENDING_RESET;
-                DS18B20_Reset_DMA();
+                g_ds18b20_prev_state = g_ds18b20_state;
+                g_ds18b20_state = ST_DS18B20_BUSY_SENDING_RESET;
+                ds18b20_reset_dma();
             }
             else
             {
-                g_DS18B20_tick--;
+                g_ds18b20_tick--;
             }
             break;
         case ST_DS18B20_BUSY_SENDING_RESET:
             // TODO: Check received value (presence byte)
-            if (true == b_DS18B20_DMA_TX_done)
+            if (true == b_ds18b20_dma_tx_done)
             {
                 __HAL_UART_DISABLE(&huart1);
                 LL_USART_SetBaudRate(USART1, HAL_RCC_GetPCLK2Freq(), G_DATA_BAUDRATE);
                 __HAL_UART_ENABLE(&huart1);
-                g_DS18B20_state = ST_DS18B20_BUSY_SENDING_SKIP_ROM;
-                DS18B20_Write_DMA(DS18B20_SKIP_ROM_CMD);
+                g_ds18b20_state = ST_DS18B20_BUSY_SENDING_SKIP_ROM;
+                ds18b20_write_dma(DS18B20_SKIP_ROM_CMD);
             }
             break;
         case ST_DS18B20_BUSY_SENDING_SKIP_ROM:
-            if (true == b_DS18B20_DMA_TX_done)
+            if (true == b_ds18b20_dma_tx_done)
             {
-                switch (g_DS18B20_prev_state)
+                switch (g_ds18b20_prev_state)
                 {
                     case ST_DS18B20_READY:
-                        g_DS18B20_prev_state = g_DS18B20_state;
-                        g_DS18B20_state = ST_DS18B20_BUSY_SENDING_CONV_T;
-                        DS18B20_Write_DMA(DS18B20_CONVERT_T_CMD);
+                        g_ds18b20_prev_state = g_ds18b20_state;
+                        g_ds18b20_state = ST_DS18B20_BUSY_SENDING_CONV_T;
+                        ds18b20_write_dma(DS18B20_CONVERT_T_CMD);
                     break;
                     case ST_DS18B20_BUSY_WAITING_CONV:
-                        g_DS18B20_prev_state = g_DS18B20_state;
-                        g_DS18B20_state = ST_DS18B20_BUSY_SENDING_READ_SCRATCHPAD;
-                        DS18B20_Write_DMA(DS18B20_READ_SCRATCHPAD_CMD);
+                        g_ds18b20_prev_state = g_ds18b20_state;
+                        g_ds18b20_state = ST_DS18B20_BUSY_SENDING_READ_SCRATCHPAD;
+                        ds18b20_write_dma(DS18B20_READ_SCRATCHPAD_CMD);
                     break;
                     default: 
-                        g_DS18B20_state = ST_DS18B20_READY;
+                        g_ds18b20_state = ST_DS18B20_READY;
                     break;
                 }
             }
             break;
         case ST_DS18B20_BUSY_SENDING_CONV_T:
-            if (true == b_DS18B20_DMA_TX_done)
+            if (true == b_ds18b20_dma_tx_done)
             {
-                g_DS18B20_state = ST_DS18B20_BUSY_WAITING_CONV;
-                g_DS18B20_tick = G_DS18B20_CONV_TIME_MS;
+                g_ds18b20_state = ST_DS18B20_BUSY_WAITING_CONV;
+                g_ds18b20_tick = G_DS18B20_CONV_TIME_MS;
             }
             break;
         case ST_DS18B20_BUSY_WAITING_CONV:
-            if (0 == g_DS18B20_tick)
+            if (0 == g_ds18b20_tick)
             {
                 // Start reading sensor data
-                g_DS18B20_prev_state = g_DS18B20_state;
-                g_DS18B20_state = ST_DS18B20_BUSY_SENDING_RESET;
-                DS18B20_Reset_DMA();
+                g_ds18b20_prev_state = g_ds18b20_state;
+                g_ds18b20_state = ST_DS18B20_BUSY_SENDING_RESET;
+                ds18b20_reset_dma();
             }
             else
             {
-                g_DS18B20_tick--;
+                g_ds18b20_tick--;
             }
             break;
 
         case ST_DS18B20_BUSY_SENDING_READ_SCRATCHPAD:
-            if (true == b_DS18B20_DMA_TX_done)
+            if (true == b_ds18b20_dma_tx_done)
             {
                 // Read sensor LSB of data
-                DS18B20_Read_DMA();
-                DS18B20_Write_DMA(0xFF);
-                g_DS18B20_state = ST_DS18B20_BUSY_WAITING_LSB;
+                ds18b20_read_dma();
+                ds18b20_write_dma(0xFF);
+                g_ds18b20_state = ST_DS18B20_BUSY_WAITING_LSB;
             }
             break;
 
         case ST_DS18B20_BUSY_WAITING_LSB:
-            if (true == b_DS18B20_DMA_RX_done)
+            if (true == b_ds18b20_dma_rx_done)
             {
-                Temp_LSB = DS18B20_Get_RX_byte();
-                g_DS18B20_state = ST_DS18B20_BUSY_WAITING_MSB;
-                DS18B20_Read_DMA();
-                DS18B20_Write_DMA(0xFF);
+                temp_lsb = ds18b20_get_rx_byte();
+                g_ds18b20_state = ST_DS18B20_BUSY_WAITING_MSB;
+                ds18b20_read_dma();
+                ds18b20_write_dma(0xFF);
             }
-            else if (0 == g_DS18B20_tick)
+            else if (0 == g_ds18b20_tick)
             {
                 // Try again readying scratchpad
-                g_DS18B20_DMA_error_count++;
-                l_DS18B20_DMA_error_count++;
-                task_menu_interface_put_event(EV_MEN_DISPLAY_UPDATE);
-
-                /*
-                HAL_UART_Abort(&huart1);
-                __HAL_DMA_ENABLE_IT(huart1.hdmarx, DMA_IT_TC);
-                __HAL_DMA_ENABLE_IT(huart1.hdmarx, DMA_IT_TE);
-                __HAL_DMA_ENABLE_IT(huart1.hdmatx, DMA_IT_TC);
-                __HAL_DMA_ENABLE_IT(huart1.hdmatx, DMA_IT_TE);
-                */
+                g_ds18b20_dma_error_count++;
 
                 HAL_UART_AbortReceive(&huart1);
                 __HAL_UART_CLEAR_OREFLAG(&huart1);
@@ -288,40 +268,28 @@ void DS18B20_Update(void)
                 __HAL_UART_CLEAR_PEFLAG(&huart1);
                 __HAL_UART_CLEAR_IDLEFLAG(&huart1);
 
-
-                g_DS18B20_prev_state = g_DS18B20_state;
-                g_DS18B20_state = ST_DS18B20_BUSY_WAITING_DMA;
+                g_ds18b20_prev_state = g_ds18b20_state;
+                g_ds18b20_state = ST_DS18B20_BUSY_WAITING_DMA;
             }
             else
             {
-                g_DS18B20_tick--;
+                g_ds18b20_tick--;
             }
             break;
 
         case ST_DS18B20_BUSY_WAITING_MSB:
-            if (true == b_DS18B20_DMA_RX_done)
+            if (true == b_ds18b20_dma_rx_done)
             {
-                Temp_MSB = DS18B20_Get_RX_byte();
-                g_DS18B20_temp = ((Temp_MSB << 8) | Temp_LSB) / 16;
-                g_DS18B20_state = ST_DS18B20_READY;
-                g_DS18B20_tick = G_TEMP_PERIOD_MS;
-                g_DS18B20_update_count++;
-                task_menu_interface_put_event(EV_MEN_DISPLAY_UPDATE);
+                temp_msb = ds18b20_get_rx_byte();
+                g_ds18b20_temp = ((temp_msb << 8) | temp_lsb) / 16;
+                g_ds18b20_state = ST_DS18B20_READY;
+                g_ds18b20_tick = G_TEMP_PERIOD_MS;
+                g_ds18b20_update_count++;
             }
-            else if (0 == g_DS18B20_tick)
+            else if (0 == g_ds18b20_tick)
             {
                 // Try again readying scratchpad
-                g_DS18B20_DMA_error_count++;
-                l_DS18B20_DMA_error_count++;
-                task_menu_interface_put_event(EV_MEN_DISPLAY_UPDATE);
-
-                /*
-                HAL_UART_Abort(&huart1);
-                __HAL_DMA_ENABLE_IT(huart1.hdmarx, DMA_IT_TC);
-                __HAL_DMA_ENABLE_IT(huart1.hdmarx, DMA_IT_TE);
-                __HAL_DMA_ENABLE_IT(huart1.hdmatx, DMA_IT_TC);
-                __HAL_DMA_ENABLE_IT(huart1.hdmatx, DMA_IT_TE);
-                */
+                g_ds18b20_dma_error_count++;
 
                 HAL_UART_AbortReceive(&huart1);
                 __HAL_UART_CLEAR_OREFLAG(&huart1);
@@ -330,12 +298,12 @@ void DS18B20_Update(void)
                 __HAL_UART_CLEAR_PEFLAG(&huart1);
                 __HAL_UART_CLEAR_IDLEFLAG(&huart1);
 
-                g_DS18B20_prev_state = g_DS18B20_state;
-                g_DS18B20_state = ST_DS18B20_BUSY_WAITING_DMA;
+                g_ds18b20_prev_state = g_ds18b20_state;
+                g_ds18b20_state = ST_DS18B20_BUSY_WAITING_DMA;
             }
             else
             {
-                g_DS18B20_tick--;
+                g_ds18b20_tick--;
             }
             break;
 
@@ -343,12 +311,12 @@ void DS18B20_Update(void)
             if ((huart1.hdmarx->State == HAL_DMA_STATE_READY) &&
                     (huart1.RxState == HAL_UART_STATE_READY))
             {
-                switch (g_DS18B20_prev_state)
+                switch (g_ds18b20_prev_state)
                 {
                     case ST_DS18B20_BUSY_WAITING_LSB:
                     case ST_DS18B20_BUSY_WAITING_MSB:
-                        g_DS18B20_state = ST_DS18B20_READY;
-                        g_DS18B20_tick = G_TEMP_PERIOD_MS;
+                        g_ds18b20_state = ST_DS18B20_READY;
+                        g_ds18b20_tick = G_TEMP_PERIOD_MS;
                         break;
                     default: break;
                 }
@@ -363,7 +331,7 @@ void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)
 {
     if (huart->Instance == USART1)
     {
-        b_DS18B20_DMA_TX_done = true;
+        b_ds18b20_dma_tx_done = true;
     }
 }
 
@@ -371,7 +339,7 @@ void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
 {
     if (huart->Instance == USART1)
     {
-        b_DS18B20_DMA_RX_done = true;
+        b_ds18b20_dma_rx_done = true;
     }
 }
 
@@ -379,7 +347,7 @@ void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef *huart, uint16_t size)
 {
     if (huart->Instance == USART1)
     {
-        b_DS18B20_DMA_RX_done = true;
+        b_ds18b20_dma_rx_done = true;
     }
 }
 
diff --git a/firmware/app/src/task_menu.c b/firmware/app/src/task_menu.c
@@ -37,9 +37,9 @@ task_menu_st_t g_menu_prev_state;
 volatile uint32_t g_task_menu_tick_cnt;
 
 // External variables
-extern uint16_t g_DS18B20_temp;
-extern uint16_t g_DS18B20_update_count;
-extern uint16_t g_DS18B20_DMA_error_count;
+extern uint16_t g_ds18b20_temp;
+extern uint16_t g_ds18b20_update_count;
+extern uint16_t g_ds18b20_dma_error_count;
 
 // Public functions
 void task_menu_init(void *parameters)
@@ -58,10 +58,8 @@ void task_menu_init(void *parameters)
 
     display_i2c_init();
     display_i2c_set_cursor_pos(0, 0);
-    display_i2c_write_string("Idle");
-    display_i2c_set_cursor_pos(0, 1);
-    display_i2c_write_string("Hello!");
-    g_display_update = false;
+    display_i2c_write_string("Inicializando...");
+    g_display_update = true;
 
     LOGGER_INFO("Done initializing `task_menu`");
 }
@@ -154,8 +152,7 @@ void task_menu_statechart(void)
                 g_display_update = false;
                 display_i2c_async_clear();
                 memset(menu_row_str, '\0', sizeof(menu_row_str));
-
-                snprintf(menu_row_str, 20, "Idle");
+                snprintf(menu_row_str, 20, "Idle%10d%cC", g_ds18b20_temp, 0xDF);
                 display_i2c_async_write_string(menu_row_str);
             }
 
diff --git a/firmware/app/src/task_temp_sensor.c b/firmware/app/src/task_temp_sensor.c
@@ -10,6 +10,7 @@
 #include <string.h>
 
 #include "main.h"
+#include "app.h"
 
 #include "task_temp_sensor_attribute.h"
 #include "task_temp_sensor.h"
@@ -26,10 +27,13 @@ volatile uint32_t g_task_temp_sensor_tick_cnt;
 
 void task_temp_sensor_init(void *parameters)
 {
+    shared_data_type *p_shared_data = (shared_data_type *)parameters;
+    p_shared_data->temp_sensor = 0;
+
     LOGGER_INFO("Initializing `task_temp_sensor`...");
 
     g_task_temp_sensor_tick = G_TASK_SEN_TICK_CNT_INI;
-    DS18B20_Init();
+    ds18b20_init();
 
     LOGGER_INFO("Done initializing `task_temp_sensor`");
 }
@@ -37,6 +41,7 @@ void task_temp_sensor_init(void *parameters)
 void task_temp_sensor_update(void *parameters)
 {
     bool b_time_update_required = false;
+    shared_data_type *p_shared_data = (shared_data_type *)parameters;
 
     __asm("CPSID i");
     if (G_TASK_SEN_TICK_CNT_INI < g_task_temp_sensor_tick_cnt)
@@ -60,6 +65,6 @@ void task_temp_sensor_update(void *parameters)
         }
         __asm("CPSIE i");
 
-        DS18B20_Update();
+        ds18b20_update();
     }
 }