huawei grid charger: TWAI: asynchronously poll for messages

instead of using a large receive queue and a large stack to handle it
all, we now use a mechanism similar to the MCP2515 ISR, which alerts the
hardware interface of inbound messages once they are available. this is
done by creating another task which blocks on twai_read_alerts() and
tests if new messages arrived. if so, the upstream task is notified and
can process these messages in time.

Author: schlimmchen

include/gridcharger/huawei/TWAI.h

@@ -1,6 +1,9 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 #pragma once
 
+#include <atomic>
+#include <FreeRTOS.h>
+#include <freertos/task.h>
 #include <gridcharger/huawei/HardwareInterface.h>
 
 namespace GridCharger::Huawei {
@@ -14,6 +17,13 @@ class TWAI : public HardwareInterface {
     bool getMessage(HardwareInterface::can_message_t& msg) final;
 
     bool sendMessage(uint32_t canId, std::array<uint8_t, 8> const& data) final;
+
+private:
+    TaskHandle_t _pollingTaskHandle = nullptr;
+    std::atomic<bool> _pollingTaskDone = false;
+    std::atomic<bool> _stopPolling = false;
+
+    static void pollAlerts(void* context);
 };
 
 } // namespace GridCharger::Huawei

src/WebApi_sysstatus.cpp

@@ -54,9 +54,9 @@ void WebApiSysstatusClass::onSystemStatus(AsyncWebServerRequest* request)
     root["flashsize"] = ESP.getFlashChipSize();
 
     JsonArray taskDetails = root["task_details"].to<JsonArray>();
-    static std::array<char const*, 12> constexpr task_names = {
+    static std::array<char const*, 13> constexpr task_names = {
         "IDLE0", "IDLE1", "wifi", "tiT", "loopTask", "async_tcp", "mqttclient",
-        "HuaweiHwIfc", "PM:SDM", "PM:HTTP+JSON", "PM:SML", "PM:HTTP+SML"
+        "HuaweiHwIfc", "HuaweiTwai", "PM:SDM", "PM:HTTP+JSON", "PM:SML", "PM:HTTP+SML"
     };
     for (char const* task_name : task_names) {
         TaskHandle_t const handle = xTaskGetHandle(task_name);

src/gridcharger/huawei/HardwareInterface.cpp

@@ -28,9 +28,9 @@ void HardwareInterface::staticLoopHelper(void* context)
 
 bool HardwareInterface::startLoop()
 {
-    uint32_t constexpr stackSize = 4096;
+    uint32_t constexpr stackSize = 2048;
     return pdPASS == xTaskCreate(HardwareInterface::staticLoopHelper,
-            "HuaweiHwIfc", stackSize, this, 1/*prio*/, &_taskHandle);
+            "HuaweiHwIfc", stackSize, this, 10/*prio*/, &_taskHandle);
 }
 
 void HardwareInterface::stopLoop()

src/gridcharger/huawei/TWAI.cpp

@@ -12,6 +12,15 @@ namespace GridCharger::Huawei {
 
 TWAI::~TWAI()
 {
+    if (_pollingTaskHandle != nullptr) {
+        _pollingTaskDone = false;
+        _stopPolling = true;
+
+        while (!_pollingTaskDone) { delay(10); }
+
+        _pollingTaskHandle = nullptr;
+    }
+
     stopLoop();
 
     if (twai_stop() != ESP_OK) {
@@ -41,7 +50,6 @@ bool TWAI::init()
     auto tx = static_cast<gpio_num_t>(pin.huawei_tx);
     auto rx = static_cast<gpio_num_t>(pin.huawei_rx);
     twai_general_config_t g_config = TWAI_GENERAL_CONFIG_DEFAULT(tx, rx, TWAI_MODE_NORMAL);
-    g_config.rx_queue_len = 16;
 
     // interrupts at level 1 are in high demand, at least on ESP32-S3 boards,
     // but only a limited amount can be allocated. failing to allocate an
@@ -65,30 +73,55 @@ bool TWAI::init()
         return false;
     }
 
+    if (!startLoop()) {
+        MessageOutput.printf("[Huawei::TWAI] failed to start loop task\r\n");
+        return false;
+    }
+
+    // enable alert on message received
+    uint32_t alertsToEnable = TWAI_ALERT_RX_DATA;
+    if (twai_reconfigure_alerts(alertsToEnable, NULL) != ESP_OK) {
+        MessageOutput.print("[Huawei::TWAI] Failed to configure alerts\r\n");
+        return false;
+    }
+
+    uint32_t constexpr stackSize = 1536;
+    return pdPASS == xTaskCreate(TWAI::pollAlerts,
+            "HuaweiTwai", stackSize, this, 20/*prio*/, &_pollingTaskHandle);
+
     MessageOutput.print("[Huawei::TWAI] driver ready\r\n");
 
-    return startLoop();
+    return true;
 }
 
-bool TWAI::getMessage(HardwareInterface::can_message_t& msg)
+void TWAI::pollAlerts(void* context)
 {
-    twai_status_info_t status;
+    auto& instance = *static_cast<TWAI*>(context);
+    uint32_t alerts;
 
-    while (true) {
-        if (twai_get_status_info(&status) != ESP_OK) {
-            MessageOutput.print("[Huawei::TWAI] Failed to get status info\r\n");
-            return false;
+    while (!instance._stopPolling) {
+        if (twai_read_alerts(&alerts, pdMS_TO_TICKS(500)) != ESP_OK) { continue; }
+
+        if (alerts & TWAI_ALERT_RX_DATA) {
+            // wake up hardware interface task to actually receive the message
+            xTaskNotifyGive(instance.getTaskHandle());
         }
+    }
+
+    instance._pollingTaskDone = true;
 
-        if (status.msgs_to_rx == 0) { return false; }
+    vTaskDelete(nullptr);
+}
 
+bool TWAI::getMessage(HardwareInterface::can_message_t& msg)
+{
+    while (true) {
         twai_message_t rxMessage;
 
-        // wait for message to be received, function is blocking (for 100ms)
-        if (twai_receive(&rxMessage, pdMS_TO_TICKS(100)) != ESP_OK) {
-            MessageOutput.print("[Huawei::TWAI] Failed to receive message\r\n");
-            return false;
-        }
+        // it's okay if we cannot receive a message now, as the hardware
+        // interface task wakes up for reasons other than a message being
+        // received, but always checks if a message is available.
+        if (twai_receive(&rxMessage, pdMS_TO_TICKS(1)) != ESP_OK) { return false; }
 
         if (rxMessage.extd != 1) { continue; } // we only process extended format messages
 

webapp/src/locales/de.json

@@ -313,6 +313,7 @@
         "Task_asynctcp": "Async TCP",
         "Task_mqttclient": "MQTT Client",
         "Task_huaweihwifc": "Netzladegerät Hardwareschnittstelle",
+        "Task_huaweitwai": "Netzladegerät TWAI",
         "Task_pmsdm": "Stromzähler (SDM)",
         "Task_pmhttpjson": "Stromzähler (HTTP+JSON)",
         "Task_pmsml": "Stromzähler (Serial SML)",

webapp/src/locales/en.json

@@ -314,6 +314,7 @@
         "Task_asynctcp": "Async TCP",
         "Task_mqttclient": "MQTT Client",
         "Task_huaweihwifc": "Grid Charger Hardware Interface",
+        "Task_huaweitwai": "Grid Charger TWAI",
         "Task_pmsdm": "PowerMeter (SDM)",
         "Task_pmhttpjson": "PowerMeter (HTTP+JSON)",
         "Task_pmsml": "PowerMeter (Serial SML)",