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 ebcaec6086118627e36090fb482b5c0546d7ed7f
parent 44defb82561a08db184f8849d382d87557ef57a9
Author: Martin Kloeckner <mjkloeckner@gmail.com>
Date:   Sun, 22 Mar 2026 19:01:35 -0300

Usar UART con DMA para enviar comandos al sensor DS18B20

Diffstat:
Mfirmware/app/inc/ds18b20.h | 5+++++
Mfirmware/app/src/ds18b20.c | 98++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-----
2 files changed, 97 insertions(+), 6 deletions(-)
diff --git a/firmware/app/inc/ds18b20.h b/firmware/app/inc/ds18b20.h
@@ -51,10 +51,15 @@ extern "C" {
 
 typedef enum {
     ST_DS18B20_READY,
+    ST_DS18B20_BUSY_SENDING_RESET,
+    ST_DS18B20_BUSY_SENDING_SKIP_ROM,
+    ST_DS18B20_BUSY_SENDING_CONV_T,
+    ST_DS18B20_BUSY_SENDING_READ_SCRATCHPAD,
     ST_DS18B20_BUSY_WAITING_CONV,
     ST_DS18B20_BUSY_WAITING_DMA
 } DS18B20_st_t;
 
+
 void DS18B20_Init(void);
 void DS18B20_Update(void);
 
diff --git a/firmware/app/src/ds18b20.c b/firmware/app/src/ds18b20.c
@@ -24,7 +24,7 @@ volatile bool b_DS18B20_Received_data;
 static uint8_t g_DS18B20_Received_data_buffer[8];
 const uint8_t g_buffer[8] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
 static bool b_DS18B20_Received_data_LSB;
-DS18B20_st_t g_DS18B20_state;
+DS18B20_st_t g_DS18B20_state, g_DS18B20_prev_state;
 uint32_t g_DS18B20_tick;
 uint16_t g_DS18B20_temp;
 
@@ -95,7 +95,7 @@ void DS18B20_Init(void)
         LOGGER_INFO("Temperature sensor initialized successfully");
     }
     DS18B20_SetResolution(9);
-    g_DS18B20_state = ST_DS18B20_READY;
+    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;
@@ -124,6 +124,28 @@ void DS18B20_Write(uint8_t data)
     HAL_UART_Transmit(&huart1, buffer, 8, 100);
 }
 
+uint8_t g_DS18B20_TX_buffer[8];
+bool b_DS18B20_DMA_done = false;
+
+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;
+        }
+        else
+        {
+            g_DS18B20_TX_buffer[i] = 0x00;
+        }
+    }
+
+    b_DS18B20_DMA_done = false;
+    HAL_UART_Transmit_DMA(&huart1, g_DS18B20_TX_buffer, 8);
+}
+
+
 void DS18B20_Start_conv(void)
 {
     // Send start temp conversion command
@@ -142,21 +164,56 @@ void DS18B20_Update(void)
         case ST_DS18B20_READY:
             if (0 == g_DS18B20_tick)
             {
-                DS18B20_Start_conv();
-                g_DS18B20_state = ST_DS18B20_BUSY_WAITING_CONV;
-                g_DS18B20_tick = G_DS18B20_CONV_TIME_MS;
+                // DS18B20_Start_conv();
+                g_DS18B20_prev_state = g_DS18B20_state;
+                g_DS18B20_state = ST_DS18B20_BUSY_SENDING_SKIP_ROM;
                 l_DS18B20_DMA_error_count = 0;
+                DS18B20_Reset(); // Blocking ~500us
+                DS18B20_Write_DMA(0xCC); // Send 'Skip ROM' command
             }
             else
             {
                 g_DS18B20_tick--;
             }
             break;
+        case ST_DS18B20_BUSY_SENDING_SKIP_ROM:
+            if (true == b_DS18B20_DMA_done)
+            {
+                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(0x44); // Send 'Convert T' command
+                        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(0xBE); // Send 'read scratchpad' command
+                        break;
+                    default: 
+                        g_DS18B20_state = ST_DS18B20_READY;
+                        break;
+                }
+            }
+            break;
+        case ST_DS18B20_BUSY_SENDING_CONV_T:
+            if (true == b_DS18B20_DMA_done)
+            {
+                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)
             {
                 DS18B20_Reset();
-                DS18B20_Write(0xCC); // Send 'Skip ROM' command
+                DS18B20_Write_DMA(0xCC); // Send 'Skip ROM' command
+
+                g_DS18B20_prev_state = g_DS18B20_state;
+                g_DS18B20_state = ST_DS18B20_BUSY_SENDING_SKIP_ROM;
+
+                /*
                 DS18B20_Write(0xBE); // Send 'read scratchpad' command
 
                 HAL_UART_Transmit_DMA(&huart1, g_buffer, 8);
@@ -165,6 +222,7 @@ void DS18B20_Update(void)
                 b_DS18B20_Received_data_LSB = true;
                 g_DS18B20_state = ST_DS18B20_BUSY_WAITING_DMA;
                 g_DS18B20_tick = G_DS18B20_DMA_TIMEOUT_MS;
+                */
             }
             else
             {
@@ -173,6 +231,18 @@ void DS18B20_Update(void)
 
             break;
 
+        case ST_DS18B20_BUSY_SENDING_READ_SCRATCHPAD:
+            if (true == b_DS18B20_DMA_done)
+            {
+                HAL_UART_Transmit_DMA(&huart1, g_buffer, 8);
+                HAL_UART_Receive_DMA(&huart1, g_DS18B20_Received_data_buffer, 8);
+
+                b_DS18B20_Received_data_LSB = true;
+                g_DS18B20_state = ST_DS18B20_BUSY_WAITING_DMA;
+                g_DS18B20_tick = G_DS18B20_DMA_TIMEOUT_MS;
+            }
+            break;
+
         case ST_DS18B20_BUSY_WAITING_DMA:
             // Process received byte if any
             if (true == b_DS18B20_Received_data)
@@ -257,6 +327,22 @@ void DS18B20_Update(void)
     }
 }
 
+void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)
+{
+    if (huart->Instance == USART1)
+    {
+        switch (g_DS18B20_state)
+        {
+            case ST_DS18B20_BUSY_SENDING_SKIP_ROM:
+            case ST_DS18B20_BUSY_SENDING_CONV_T:
+            case ST_DS18B20_BUSY_SENDING_READ_SCRATCHPAD:
+                b_DS18B20_DMA_done = true;
+                break;
+            default: break;
+        }
+    }
+}
+
 void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
 {
     if (huart->Instance == USART1)