Доработка проекта STM, испраление путаницы

STM32_CO2_NODE/Core/Src/freertos.cpp

@@ -11,6 +11,7 @@
 #include "queues.hpp"
 #include "co2_task.hpp"
 #include "sd_task.hpp"
+#include "can_task.hpp"
 /* USER CODE END Includes */
 
 /* Private variables ---------------------------------------------------------*/
@@ -97,11 +98,10 @@ void StartSDTask(void *argument)
 /* CAN Task */
 void StartCANTask(void *argument)
 {
-  (void)argument;
+    (void)argument;
 
-  for (;;)
+    for(;;)
-  {
+    {
-    /* example placeholder */
+        CANTask_RunOnce();
-    osDelay(10);
+    }
-  }
 }

STM32_CO2_NODE/Drivers/MHZ19C/mhz19c.cpp

@@ -3,10 +3,11 @@
 MHZ19C::MHZ19C(UART_HandleTypeDef* huart)
     : uart(huart)
 {
-    buildRequest();
+    BuildReadFrame();
 }
 
-void MHZ19C::buildRequest() {
+void MHZ19C::BuildReadFrame()
+{
     txFrame[0] = 0xFF;
     txFrame[1] = 0x01;
     txFrame[2] = 0x86;
@@ -15,29 +16,76 @@ void MHZ19C::buildRequest() {
     txFrame[5] = 0x00;
     txFrame[6] = 0x00;
     txFrame[7] = 0x00;
-    txFrame[8] = checksum(txFrame);
+    txFrame[8] = Checksum(txFrame);
 }
 
-uint8_t MHZ19C::checksum(uint8_t* data) {
+uint8_t MHZ19C::Checksum(uint8_t* data)
+{
     uint8_t sum = 0;
-    for(int i=1;i<8;i++) sum += data[i];
+
+    for(int i = 1; i < 8; i++)
+    {
+        sum += data[i];
+    }
+
     return 0xFF - sum + 1;
 }
 
-void MHZ19C::requestCO2() {
+bool MHZ19C::ReadCO2(uint16_t& ppm)
-    HAL_UART_Transmit_DMA(uart, txFrame, 9);
+{
-    HAL_UART_Receive_DMA(uart, rxFrame, 9);
+    if(HAL_UART_Transmit(
-}
+            uart,
+            txFrame,
+            9,
+            100)
+       != HAL_OK)
+    {
+        return false;
+    }
 
-bool MHZ19C::readCO2(uint16_t &ppm) {
+    if(HAL_UART_Receive(
-    if(rxFrame[0] != 0xFF) return false;
+            uart,
+            rxFrame,
+            9,
+            100)
+       != HAL_OK)
+    {
+        return false;
+    }
+
+    if(rxFrame[0] != 0xFF)
+    {
+        return false;
+    }
+
+    ppm =
+        (rxFrame[2] << 8) |
+        rxFrame[3];
 
-    ppm = (rxFrame[2] << 8) | rxFrame[3];
     return true;
 }
 
-void MHZ19C::calibrateZero() {
+void MHZ19C::CalibrateZero()
-    uint8_t cmd[9] = {0xFF,0x01,0x87,0,0,0,0,0,0};
+{
-    cmd[8] = checksum(cmd);
+    uint8_t cmd[9] =
-    HAL_UART_Transmit(uart, cmd, 9, 100);
+    {
+        0xFF,
+        0x01,
+        0x87,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+    };
+
+    cmd[8] = Checksum(cmd);
+
+    HAL_UART_Transmit(
+        uart,
+        cmd,
+        9,
+        100
+    );
 }

STM32_CO2_NODE/Drivers/MHZ19C/mhz19c.hpp

@@ -1,22 +1,27 @@
 #pragma once
+
 #include "stm32f1xx_hal.h"
+
 #include <cstdint>
 
-class MHZ19C {
+class MHZ19C
+{
 public:
-    MHZ19C(UART_HandleTypeDef* huart);
 
-    void init();
+    explicit MHZ19C(UART_HandleTypeDef* huart);
-    void calibrateZero();
+
-    void requestCO2();
+    bool ReadCO2(uint16_t& ppm);
-    bool readCO2(uint16_t &ppm);
+
+    void CalibrateZero();
 
 private:
+
     UART_HandleTypeDef* uart;
 
     uint8_t txFrame[9];
     uint8_t rxFrame[9];
 
-    void buildRequest();
+    void BuildReadFrame();
-    uint8_t checksum(uint8_t* data);
+
+    uint8_t Checksum(uint8_t* data);
 };

STM32_CO2_NODE/FATFS/App/Tasks/can_task.cpp

@@ -0,0 +1,30 @@
+#include "co2_data.hpp"
+#include "queues.hpp"
+#include "can_task.hpp"
+
+#include "co2_can_protocol.hpp"
+
+extern "C"
+{
+#include "can.h"
+}
+
+extern CAN_HandleTypeDef hcan;
+
+static CANProtocol canProtocol(&hcan);
+
+void CANTask_RunOnce()
+{
+    CO2Data data;
+
+    if(xQueueReceive(
+           g_canQueue,
+           &data,
+           pdMS_TO_TICKS(100))
+       == pdTRUE)
+    {
+        canProtocol.sendCO2(
+            data.ppm
+        );
+    }
+}

STM32_CO2_NODE/FATFS/App/Tasks/can_task.hpp

@@ -0,0 +1,3 @@
+#pragma once
+
+void CANTask_RunOnce();

STM32_CO2_NODE/FATFS/App/Tasks/co2_task.cpp

@@ -1,26 +1,35 @@
 #include "co2_task.hpp"
+
 #include "mhz19c.hpp"
-#include "queues.hpp"
 #include "co2_data.hpp"
+#include "queues.hpp"
 
-extern MHZ19C sensor;
+extern "C"
+{
+#include "usart.h"
+#include "main.h"
+}
 
-void CO2Task_Run() {
+extern UART_HandleTypeDef huart1;
-    uint16_t ppm;
 
-    while (1) {
+static MHZ19C sensor(&huart1);
-        sensor.requestCO2();
-        HAL_Delay(100);
 
-        if (sensor.readCO2(ppm)) {
+void CO2Task_RunOnce()
-            CO2Data data;
+{
-            data.ppm = ppm;
+    CO2Data data;
-            data.timestamp = HAL_GetTick();
 
+    if(sensor.ReadCO2(data.ppm))
+    {
+        data.timestamp = HAL_GetTick();
+
+        if(g_sdQueue != nullptr)
+        {
             xQueueSend(g_sdQueue, &data, 0);
-            xQueueSend(g_canQueue, &data, 0);
         }
 
-        osDelay(1000);
+        if(g_canQueue != nullptr)
+        {
+            xQueueSend(g_canQueue, &data, 0);
+        }
     }
 }

STM32_CO2_NODE/FATFS/App/Tasks/sd_task.cpp

@@ -1,17 +1,32 @@
 #include "sd_task.hpp"
+
 #include "sdcard.hpp"
 #include "queues.hpp"
+#include "co2_data.hpp"
+
+#include <cstdio>
 
 extern SDCardLogger sd;
 
-void SDTask_Run() {
+void SDTask_RunOnce()
+{
     CO2Data data;
 
-    while (1) {
+    if(xQueueReceive(
-        if (xQueueReceive(g_sdQueue, &data, portMAX_DELAY)) {
+            g_sdQueue,
-            char line[64];
+            &data,
-            sprintf(line, "CO2:%d t:%lu", data.ppm, data.timestamp);
+            pdMS_TO_TICKS(100))
-            sd.write(line);
+       == pdTRUE)
-        }
+    {
+        char line[64];
+
+        sprintf(
+            line,
+            "CO2:%u t:%lu\r\n",
+            data.ppm,
+            data.timestamp
+        );
+
+        sd.write(line);
     }
 }

STM32_CO2_NODE/FATFS/App/Tasks/sd_task.hpp

@@ -1,13 +1,3 @@
 #pragma once
-#include "fatfs.h"
-#include <string>
 
-class SDCardLogger {
+void SDTask_RunOnce();
-public:
-    bool init();
-    bool write(const std::string &line);
-
-private:
-    FIL file;
-    FATFS fs;
-};