stm32f103rb_hal_ds18b20

Index Commits Files Refs README
commit 0253f4dfd9fe9f7d336abc35a20843fea6dbccfd
parent ea3046037a1cd4f03c74f7f1ded0d61c55a3a7ac
Author: Martin Kloeckner <mjkloeckner@gmail.com>
Date:   Mon, 16 Mar 2026 02:55:11 -0300

implement fsm for ds18b20 sensor

Diffstat:
Mapp/inc/task_sensor_attribute.h | 4++--
Mapp/src/app.c | 2+-
Mapp/src/ds18b20.c | 25+++++++++----------------
Mapp/src/task_sensor.c | 110++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-------
Mapp/src/task_system.c | 4++--
5 files changed, 115 insertions(+), 30 deletions(-)
diff --git a/app/inc/task_sensor_attribute.h b/app/inc/task_sensor_attribute.h
@@ -34,7 +34,8 @@ typedef enum {
 /* States of Task Sensor */
 typedef enum {
     ST_SEN_READY,
-    ST_SEN_BUSY
+    ST_SEN_BUSY_WAITING_CONV,
+    ST_SEN_BUSY_WAITING_DMA,
 } task_sensor_st_t;
 
 /* Identifier of Task Sensor */
@@ -44,7 +45,6 @@ typedef enum {
 
 typedef struct {
     task_sensor_id_t identifier;
-    UART_HandleTypeDef huart;
 } task_sensor_cfg_t;
 
 typedef struct {
diff --git a/app/src/app.c b/app/src/app.c
@@ -46,7 +46,7 @@ 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];
+task_dta_t task_dta_list[TASK_QTY] = {0};
 
 void app_init(void)
 {
diff --git a/app/src/ds18b20.c b/app/src/ds18b20.c
@@ -16,10 +16,7 @@
 
 uint8_t b_DS18B20_Received_data;
 uint8_t g_DS18B20_Received_data_buffer[8];
-float g_DS18B20_temp;
-
-uint8_t Temp_LSB, Temp_MSB;
-uint16_t temp;
+// float g_DS18B20_temp;
 // extern UART_HandleTypeDef huart1;
 
 void UART1_SetBaud(uint32_t baud)
@@ -123,8 +120,10 @@ uint8_t DS18B20_Read(void)
     HAL_UART_Transmit_DMA(&huart1, buffer, 8);
     HAL_UART_Receive_DMA(&huart1, g_DS18B20_Received_data_buffer, 8);
 
-    while (b_DS18B20_Received_data == false)
-        ;
+    // while(b_DS18B20_Received_data == false)
+    //     ;
+
+    // b_DS18B20_Received_data = false;
 
     for (uint8_t i = 0; i < 8; ++i)
     {
@@ -134,15 +133,9 @@ uint8_t DS18B20_Read(void)
         }
     }
 
-    b_DS18B20_Received_data = false;
     return received_value;
 }
 
-void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
-{
-    b_DS18B20_Received_data = true;
-}
-
 void DS18B20_Read_temp(void)
 {
     DS18B20_Reset();
@@ -153,9 +146,9 @@ void DS18B20_Read_temp(void)
     DS18B20_Write(0xCC); // send 'Skip ROM' command
     DS18B20_Write(0xBE); // send 'read scratchpad' command
 
-    Temp_LSB = DS18B20_Read();
-    Temp_MSB = DS18B20_Read();
+    // uint8_t Temp_LSB = DS18B20_Read();
+    // uint8_t Temp_MSB = DS18B20_Read();
 
-    temp = (Temp_MSB << 8) | Temp_LSB;
-    g_DS18B20_temp = (float) temp / 16.0;
+    // uint16_t temp = (Temp_MSB << 8) | Temp_LSB;
+    // g_DS18B20_temp = (float) temp / 16.0;
 }
diff --git a/app/src/task_sensor.c b/app/src/task_sensor.c
@@ -18,23 +18,43 @@
 #include "ds18b20.h"
 
 #define G_TASK_SEN_TICK_CNT_INI   0ul
-#define G_TASK_SEN_TEMP_PERIOD_MS 2000ul
+#define G_TASK_SEN_TEMP_PERIOD_MS 500ul
+#define G_DS18B20_CONV_TIME_MS    200ul
+#define G_DS18B20_DMA_TIMEOUT_MS  5000ul
 
 const task_sensor_cfg_t task_sensor_cfg_list[] = {
-    {ID_DS18B20, 0, EV_DS18B20_CONV_DONE}
+    {ID_DS18B20}
 };
 
 #define SENSOR_CFG_QTY (sizeof(task_sensor_cfg_list)/sizeof(task_sensor_cfg_t))
 
 task_sensor_dta_t task_sensor_dta_list[] = {
-    {G_TASK_SEN_TICK_CNT_INI, ST_SEN_READY}
+    {G_TASK_SEN_TEMP_PERIOD_MS, ST_SEN_READY, EV_DS18B20_CONV_DONE}
 };
 
 #define SENSOR_DTA_QTY (sizeof(task_sensor_dta_list)/sizeof(task_sensor_dta_t))
 
 void task_sensor_statechart(void);
 
+volatile extern bool b_DS18B20_Received_data;
+extern uint8_t g_DS18B20_Received_data_buffer[8];
+
+volatile float g_DS18B20_temp;
 uint32_t g_task_sensor_tick;
+uint8_t Temp_LSB, Temp_MSB;
+uint16_t temp;
+static bool b_DS18B20_Received_data_LSB;
+static const uint8_t buffer[8] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
+
+void HAL_UART_TxHalfCpltCallback(UART_HandleTypeDef *huart)
+{
+    // HAL_UART_Receive_DMA(&huart1, g_DS18B20_Received_data_buffer, 8);
+}
+
+void HAL_UART_RxHalfCpltCallback(UART_HandleTypeDef *huart)
+{
+    b_DS18B20_Received_data = true;
+}
 
 // this variable is incremented by 1 on every ms by HAL_SysTick
 volatile uint32_t g_task_sensor_tick_cnt;
@@ -100,7 +120,7 @@ void task_sensor_statechart(void)
 {
     uint32_t index;
     const task_sensor_cfg_t *p_task_sensor_cfg;
-    task_sensor_dta_t *p_task_sensor_dta;
+    task_sensor_dta_t       *p_task_sensor_dta;
 
     for (index = 0; SENSOR_DTA_QTY > index; index++)
     {
@@ -115,9 +135,14 @@ void task_sensor_statechart(void)
                     case ST_SEN_READY:
                         if (0 == g_task_sensor_tick)
                         {
-                            DS18B20_Read_temp();
-                            p_task_sensor_dta->event = EV_DS18B20_CONV_DONE;
-                            p_task_sensor_dta->state = ST_SEN_BUSY;
+                            // Send start temp conversion command
+                            // this needs 96ms to 750ms depending on resolution
+                            DS18B20_Reset();
+                            DS18B20_Write(0xCC); // send 'Skip ROM' command
+                            DS18B20_Write(0x44); // send 'Convert T' command
+
+                            p_task_sensor_dta->state = ST_SEN_BUSY_WAITING_CONV;
+                            g_task_sensor_tick = G_DS18B20_CONV_TIME_MS;
                         }
                         else
                         {
@@ -125,12 +150,79 @@ void task_sensor_statechart(void)
                         }
                     break;
 
-                    case ST_SEN_BUSY:
-                        if (EV_DS18B20_CONV_DONE == p_task_sensor_dta->event)
+                    case ST_SEN_BUSY_WAITING_CONV:
+                        if (0 == g_task_sensor_tick)
+                        {
+                            DS18B20_Reset();
+                            DS18B20_Write(0xCC); // send 'Skip ROM' command
+                            DS18B20_Write(0xBE); // send 'read scratchpad' command
+
+                            if (HAL_OK == HAL_UART_Transmit_DMA(&huart1, buffer, 8))
+                            {
+                                if (HAL_OK == HAL_UART_Receive_DMA(&huart1, g_DS18B20_Received_data_buffer, 8))
+                                {
+                                    b_DS18B20_Received_data_LSB = true;
+                                    p_task_sensor_dta->state = ST_SEN_BUSY_WAITING_DMA;
+                                    g_task_sensor_tick = G_DS18B20_DMA_TIMEOUT_MS;
+                                }
+                            }
+                        }
+                        else
                         {
+                            g_task_sensor_tick--;
+                        }
+
+                    break;
+
+                    case ST_SEN_BUSY_WAITING_DMA:
+
+                        if (0 == g_task_sensor_tick)
+                        {
+                            // DMA Timeout, reset conversion
                             p_task_sensor_dta->state = ST_SEN_READY;
                             g_task_sensor_tick = G_TASK_SEN_TEMP_PERIOD_MS;
+                            break;
                         }
+                        else
+                        {
+                            g_task_sensor_tick--;
+                        }
+
+                        if (true == b_DS18B20_Received_data)
+                        {
+                            b_DS18B20_Received_data = false;
+
+                            uint8_t received_value = 0;
+                            for (uint8_t i = 0; i < 8; ++i)
+                            {
+                                if (g_DS18B20_Received_data_buffer[i] == 0xFF)
+                                {
+                                    received_value |= (1 << i);
+                                }
+                            }
+
+                            if (true == b_DS18B20_Received_data_LSB)
+                            {
+                                if (HAL_OK == HAL_UART_Transmit_DMA(&huart1, buffer, 8))
+                                {
+                                    if (HAL_OK == HAL_UART_Receive_DMA(&huart1, g_DS18B20_Received_data_buffer, 8))
+                                    {
+                                        b_DS18B20_Received_data_LSB = false;
+                                        Temp_LSB = received_value;
+                                        g_task_sensor_tick = G_DS18B20_DMA_TIMEOUT_MS;
+                                    }
+                                }
+                            }
+                            else
+                            {
+                                Temp_MSB = received_value;
+                                temp = ((Temp_MSB << 8) | Temp_LSB);
+                                g_DS18B20_temp = (float) temp / 16.0;
+                                p_task_sensor_dta->state = ST_SEN_READY;
+                                g_task_sensor_tick = G_TASK_SEN_TEMP_PERIOD_MS;
+                            }
+                        }
+
                     break;
 
                     default: break;
diff --git a/app/src/task_system.c b/app/src/task_system.c
@@ -20,8 +20,8 @@
 #define G_TASK_SYS_CNT_INI       0ul
 #define G_TASK_SYS_TICK_CNT_INI  0ul
 
-#define G_LED_PERIOD_MS 2000ul
-#define G_LED_T_ON_MS   1500ul
+#define G_LED_PERIOD_MS 1000ul
+#define G_LED_T_ON_MS   500ul
 
 task_system_dta_t task_system_dta = {
     G_LED_PERIOD_MS, ST_SYS_LED_ON