Add dtu scheduler stats (idle/cycle/active)

ranma · Sep 29, 2024 · f14a49e · f14a49e
1 parent e9cb3fd
commit f14a49e
Show file tree

Hide file tree

Showing 19 changed files with 48 additions and 1 deletion.
diff --git a/include/MessageOutput.h b/include/MessageOutput.h
@@ -22,6 +22,7 @@ class MessageOutputClass : public Print {
     void loop();
 
     Task _loopTask;
+    StatusRequest _condition;
 
     using message_t = std::vector<uint8_t>;
 

diff --git a/include/NetworkSettings.h b/include/NetworkSettings.h
@@ -65,6 +65,7 @@ class NetworkSettingsClass {
     void NetworkEvent(const WiFiEvent_t event, WiFiEventInfo_t info);
 
     Task _loopTask;
+    StatusRequest _condition;
 
     static constexpr byte DNS_PORT = 53;
 

diff --git a/platformio.ini b/platformio.ini
@@ -27,6 +27,9 @@ build_flags =
     -DPIOENV=\"$PIOENV\"
     -D_TASK_STD_FUNCTION=1
     -D_TASK_THREAD_SAFE=1
+    -D_TASK_TIMECRITICAL=1
+    -D_TASK_TIMEOUT=1
+    -D_TASK_STATUS_REQUEST=1
     -DCONFIG_ASYNC_TCP_EVENT_QUEUE_SIZE=128
     -DCONFIG_ASYNC_TCP_QUEUE_SIZE=128
     -DEMC_TASK_STACK_SIZE=6400

diff --git a/src/Battery.cpp b/src/Battery.cpp
@@ -27,6 +27,7 @@ void BatteryClass::init(Scheduler& scheduler)
     scheduler.addTask(_loopTask);
     _loopTask.setCallback(std::bind(&BatteryClass::loop, this));
     _loopTask.setIterations(TASK_FOREVER);
+    _loopTask.setInterval(1 * TASK_SECOND);
     _loopTask.enable();
 
     this->updateSettings();

diff --git a/src/Huawei_can.cpp b/src/Huawei_can.cpp
@@ -206,6 +206,7 @@ void HuaweiCanClass::init(Scheduler& scheduler, uint8_t huawei_miso, uint8_t hua
     scheduler.addTask(_loopTask);
     _loopTask.setCallback(std::bind(&HuaweiCanClass::loop, this));
     _loopTask.setIterations(TASK_FOREVER);
+    _loopTask.setInterval(10 * TASK_MILLISECOND);
     _loopTask.enable();
 
     this->updateSettings(huawei_miso, huawei_mosi, huawei_clk, huawei_irq, huawei_cs, huawei_power);

diff --git a/src/InverterSettings.cpp b/src/InverterSettings.cpp
@@ -14,7 +14,7 @@ InverterSettingsClass InverterSettings;
 
 InverterSettingsClass::InverterSettingsClass()
     : _settingsTask(INVERTER_UPDATE_SETTINGS_INTERVAL, TASK_FOREVER, std::bind(&InverterSettingsClass::settingsLoop, this))
-    , _hoyTask(TASK_IMMEDIATE, TASK_FOREVER, std::bind(&InverterSettingsClass::hoyLoop, this))
+    , _hoyTask(10 * TASK_MILLISECOND, TASK_FOREVER, std::bind(&InverterSettingsClass::hoyLoop, this))
 {
 }
 

diff --git a/src/MessageOutput.cpp b/src/MessageOutput.cpp
@@ -47,6 +47,7 @@ size_t MessageOutputClass::write(uint8_t c)
     auto iter = res.first;
     auto& message = iter->second;
 
+    _condition.signal();
     message.push_back(c);
 
     if (c == '\n') {
@@ -71,6 +72,7 @@ size_t MessageOutputClass::write(const uint8_t *buffer, size_t size)
     for (size_t idx = 0; idx < size; ++idx) {
         uint8_t c = buffer[idx];
 
+        _condition.signal();
         message.push_back(c);
 
         if (c == '\n') {
@@ -88,6 +90,8 @@ size_t MessageOutputClass::write(const uint8_t *buffer, size_t size)
 
 void MessageOutputClass::loop()
 {
+    _condition.setWaiting(1);
+    _loopTask.waitFor(&_condition);
     std::lock_guard<std::mutex> lock(_msgLock);
 
     // clean up (possibly filled) buffers of deleted tasks

diff --git a/src/MqttHandleBatteryHass.cpp b/src/MqttHandleBatteryHass.cpp
@@ -16,11 +16,13 @@ void MqttHandleBatteryHassClass::init(Scheduler& scheduler)
     scheduler.addTask(_loopTask);
     _loopTask.setCallback(std::bind(&MqttHandleBatteryHassClass::loop, this));
     _loopTask.setIterations(TASK_FOREVER);
+    _loopTask.setInterval(Configuration.get().Mqtt.PublishInterval * TASK_SECOND);
     _loopTask.enable();
 }
 
 void MqttHandleBatteryHassClass::loop()
 {
+    _loopTask.setInterval(Configuration.get().Mqtt.PublishInterval * TASK_SECOND);
     CONFIG_T& config = Configuration.get();
 
     if (!config.Battery.Enabled) { return; }

diff --git a/src/MqttHandleDtu.cpp b/src/MqttHandleDtu.cpp
@@ -8,6 +8,7 @@
 #include "NetworkSettings.h"
 #include <Hoymiles.h>
 #include <CpuTemperature.h>
+#include <Scheduler.h>
 
 MqttHandleDtuClass MqttHandleDtu;
 
@@ -48,4 +49,16 @@ void MqttHandleDtuClass::loop()
     if (!std::isnan(temperature)) {
         MqttSettings.publish("dtu/temperature", String(temperature));
     }
+
+    float cpuTotal = scheduler.getCpuLoadTotal();
+    if (cpuTotal > 0) {
+      float cpuIdle = scheduler.getCpuLoadIdle() / cpuTotal;
+      float cpuCycle = scheduler.getCpuLoadCycle() / cpuTotal;
+      float cpuActive = 1.0 - cpuIdle - cpuCycle;
+      scheduler.cpuLoadReset();
+
+      MqttSettings.publish("dtu/scheduler/idle", String(cpuIdle));
+      MqttSettings.publish("dtu/scheduler/cycle", String(cpuCycle));
+      MqttSettings.publish("dtu/scheduler/active", String(cpuActive));
+    }
 }
diff --git a/src/MqttHandleHass.cpp b/src/MqttHandleHass.cpp
@@ -20,11 +20,13 @@ MqttHandleHassClass::MqttHandleHassClass()
 void MqttHandleHassClass::init(Scheduler& scheduler)
 {
     scheduler.addTask(_loopTask);
+    _loopTask.setInterval(Configuration.get().Mqtt.PublishInterval * TASK_SECOND);
     _loopTask.enable();
 }
 
 void MqttHandleHassClass::loop()
 {
+    _loopTask.setInterval(Configuration.get().Mqtt.PublishInterval * TASK_SECOND);
     if (_updateForced) {
         publishConfig();
         _updateForced = false;

diff --git a/src/MqttHandleHuawei.cpp b/src/MqttHandleHuawei.cpp
@@ -3,6 +3,7 @@
  * Copyright (C) 2022 Thomas Basler and others
  */
 #include "MqttHandleHuawei.h"
+#include "Configuration.h"
 #include "MessageOutput.h"
 #include "MqttSettings.h"
 #include "Huawei_can.h"
@@ -16,6 +17,7 @@ void MqttHandleHuaweiClass::init(Scheduler& scheduler)
     scheduler.addTask(_loopTask);
     _loopTask.setCallback(std::bind(&MqttHandleHuaweiClass::loop, this));
     _loopTask.setIterations(TASK_FOREVER);
+    _loopTask.setInterval(Configuration.get().Mqtt.PublishInterval * TASK_SECOND);
     _loopTask.enable();
 
     subscribeTopics();
@@ -56,6 +58,7 @@ void MqttHandleHuaweiClass::unsubscribeTopics()
 
 void MqttHandleHuaweiClass::loop()
 {
+    _loopTask.setInterval(Configuration.get().Mqtt.PublishInterval * TASK_SECOND);
     const CONFIG_T& config = Configuration.get();
 
     std::unique_lock<std::mutex> mqttLock(_mqttMutex);

diff --git a/src/MqttHandlePowerLimiter.cpp b/src/MqttHandlePowerLimiter.cpp
@@ -16,6 +16,7 @@ void MqttHandlePowerLimiterClass::init(Scheduler& scheduler)
     scheduler.addTask(_loopTask);
     _loopTask.setCallback(std::bind(&MqttHandlePowerLimiterClass::loop, this));
     _loopTask.setIterations(TASK_FOREVER);
+    _loopTask.setInterval(Configuration.get().Mqtt.PublishInterval * TASK_SECOND);
     _loopTask.enable();
 
     using std::placeholders::_1;
@@ -63,6 +64,7 @@ void MqttHandlePowerLimiterClass::unsubscribeTopics()
 
 void MqttHandlePowerLimiterClass::loop()
 {
+    _loopTask.setInterval(Configuration.get().Mqtt.PublishInterval * TASK_SECOND);
     std::unique_lock<std::mutex> mqttLock(_mqttMutex);
 
     const CONFIG_T& config = Configuration.get();

diff --git a/src/MqttHandlePowerLimiterHass.cpp b/src/MqttHandlePowerLimiterHass.cpp
@@ -18,11 +18,13 @@ void MqttHandlePowerLimiterHassClass::init(Scheduler& scheduler)
     scheduler.addTask(_loopTask);
     _loopTask.setCallback(std::bind(&MqttHandlePowerLimiterHassClass::loop, this));
     _loopTask.setIterations(TASK_FOREVER);
+    _loopTask.setInterval(Configuration.get().Mqtt.PublishInterval * TASK_SECOND);
     _loopTask.enable();
 }
 
 void MqttHandlePowerLimiterHassClass::loop()
 {
+    _loopTask.setInterval(Configuration.get().Mqtt.PublishInterval * TASK_SECOND);
     if (!Configuration.get().PowerLimiter.Enabled) {
         return;
     }

diff --git a/src/MqttHandleVedirect.cpp b/src/MqttHandleVedirect.cpp
@@ -19,6 +19,7 @@ void MqttHandleVedirectClass::init(Scheduler& scheduler)
     scheduler.addTask(_loopTask);
     _loopTask.setCallback([this] { loop(); });
     _loopTask.setIterations(TASK_FOREVER);
+    _loopTask.setInterval(Configuration.get().Mqtt.PublishInterval * TASK_SECOND);
     _loopTask.enable();
 
     // initially force a full publish
@@ -35,6 +36,7 @@ void MqttHandleVedirectClass::forceUpdate()
 
 void MqttHandleVedirectClass::loop()
 {
+    _loopTask.setInterval(Configuration.get().Mqtt.PublishInterval * TASK_SECOND);
     CONFIG_T& config = Configuration.get();
 
     if (!MqttSettings.getConnected() || !config.Vedirect.Enabled) {

diff --git a/src/MqttHandleVedirectHass.cpp b/src/MqttHandleVedirectHass.cpp
@@ -19,11 +19,13 @@ void MqttHandleVedirectHassClass::init(Scheduler& scheduler)
     scheduler.addTask(_loopTask);
     _loopTask.setCallback([this] { loop(); });
     _loopTask.setIterations(TASK_FOREVER);
+    _loopTask.setInterval(Configuration.get().Mqtt.PublishInterval * TASK_SECOND);
     _loopTask.enable();
 }
 
 void MqttHandleVedirectHassClass::loop()
 {
+    _loopTask.setInterval(Configuration.get().Mqtt.PublishInterval * TASK_SECOND);
     if (!Configuration.get().Vedirect.Enabled) {
         return;
     }

diff --git a/src/NetworkSettings.cpp b/src/NetworkSettings.cpp
@@ -132,6 +132,7 @@ bool NetworkSettingsClass::onEvent(NetworkEventCb cbEvent, const network_event e
 
 void NetworkSettingsClass::raiseEvent(const network_event event)
 {
+    _condition.signal();
     for (auto& entry : _cbEventList) {
         if (entry.cb) {
             if (entry.event == event || entry.event == network_event::NETWORK_EVENT_MAX) {
@@ -275,6 +276,10 @@ void NetworkSettingsClass::loop()
     }
 
     handleMDNS();
+
+    _condition.setWaiting(1);
+    _loopTask.waitFor(&_condition);
+    _loopTask.setTimeout(1 * TASK_MILLISECOND);
 }
 
 void NetworkSettingsClass::applyConfig()

diff --git a/src/PowerLimiter.cpp b/src/PowerLimiter.cpp
@@ -26,6 +26,7 @@ void PowerLimiterClass::init(Scheduler& scheduler)
     scheduler.addTask(_loopTask);
     _loopTask.setCallback(std::bind(&PowerLimiterClass::loop, this));
     _loopTask.setIterations(TASK_FOREVER);
+    _loopTask.setInterval(1 * TASK_SECOND);
     _loopTask.enable();
 }
 

diff --git a/src/PowerMeter.cpp b/src/PowerMeter.cpp
@@ -15,6 +15,7 @@ void PowerMeterClass::init(Scheduler& scheduler)
     scheduler.addTask(_loopTask);
     _loopTask.setCallback(std::bind(&PowerMeterClass::loop, this));
     _loopTask.setIterations(TASK_FOREVER);
+    _loopTask.setInterval(100 * TASK_MILLISECOND);
     _loopTask.enable();
 
     updateSettings();

diff --git a/src/VictronMppt.cpp b/src/VictronMppt.cpp
@@ -12,6 +12,7 @@ void VictronMpptClass::init(Scheduler& scheduler)
     scheduler.addTask(_loopTask);
     _loopTask.setCallback([this] { loop(); });
     _loopTask.setIterations(TASK_FOREVER);
+    _loopTask.setInterval(10 * TASK_MILLISECOND);
     _loopTask.enable();
 
     this->updateSettings();