Move task initialization from init method to constructor

This saves flash

include/Datastore.h

@@ -6,6 +6,7 @@
 
 class DatastoreClass {
 public:
+    DatastoreClass();
     void init(Scheduler& scheduler);
 
     // Sum of yield total of all enabled inverters, a inverter which is just disabled at night is also included
@@ -81,4 +82,4 @@ private:
     bool _isAtLeastOnePollEnabled = false;
 };
 
-extern DatastoreClass Datastore;
+extern DatastoreClass Datastore;

include/InverterSettings.h

@@ -8,6 +8,7 @@
 
 class InverterSettingsClass {
 public:
+    InverterSettingsClass();
     void init(Scheduler& scheduler);
 
 private:

include/MessageOutput.h

@@ -1,33 +1,34 @@
-// SPDX-License-Identifier: GPL-2.0-or-later
+// SPDX-License-Identifier: GPL-2.0-or-later
-#pragma once
+#pragma once
-
+
-#include <AsyncWebSocket.h>
+#include <AsyncWebSocket.h>
-#include <HardwareSerial.h>
+#include <HardwareSerial.h>
-#include <Stream.h>
+#include <Stream.h>
-#include <TaskSchedulerDeclarations.h>
+#include <TaskSchedulerDeclarations.h>
-#include <mutex>
+#include <mutex>
-
+
-#define BUFFER_SIZE 500
+#define BUFFER_SIZE 500
-
+
-class MessageOutputClass : public Print {
+class MessageOutputClass : public Print {
-public:
+public:
-    void init(Scheduler& scheduler);
+    MessageOutputClass();
-    size_t write(uint8_t c) override;
+    void init(Scheduler& scheduler);
-    size_t write(const uint8_t* buffer, size_t size) override;
+    size_t write(uint8_t c) override;
-    void register_ws_output(AsyncWebSocket* output);
+    size_t write(const uint8_t* buffer, size_t size) override;
-
+    void register_ws_output(AsyncWebSocket* output);
-private:
+
-    void loop();
+private:
-
+    void loop();
-    Task _loopTask;
+
-
+    Task _loopTask;
-    AsyncWebSocket* _ws = nullptr;
+
-    char _buffer[BUFFER_SIZE];
+    AsyncWebSocket* _ws = nullptr;
-    uint16_t _buff_pos = 0;
+    char _buffer[BUFFER_SIZE];
-    uint32_t _lastSend = 0;
+    uint16_t _buff_pos = 0;
-    bool _forceSend = false;
+    uint32_t _lastSend = 0;
-
+    bool _forceSend = false;
-    std::mutex _msgLock;
+
-};
+    std::mutex _msgLock;
-
+};
-extern MessageOutputClass MessageOutput;
+
+extern MessageOutputClass MessageOutput;

include/MqttHandleDtu.h

@@ -6,6 +6,7 @@
 
 class MqttHandleDtuClass {
 public:
+    MqttHandleDtuClass();
     void init(Scheduler& scheduler);
 
 private:
@@ -14,4 +15,4 @@ private:
     Task _loopTask;
 };
 
-extern MqttHandleDtuClass MqttHandleDtu;
+extern MqttHandleDtuClass MqttHandleDtu;

include/MqttHandleHass.h

@@ -51,6 +51,7 @@ const byteAssign_fieldDeviceClass_t deviceFieldAssignment[] = {
 
 class MqttHandleHassClass {
 public:
+    MqttHandleHassClass();
     void init(Scheduler& scheduler);
     void publishConfig();
     void forceUpdate();
@@ -79,4 +80,4 @@ private:
     bool _updateForced = false;
 };
 
-extern MqttHandleHassClass MqttHandleHass;
+extern MqttHandleHassClass MqttHandleHass;

include/MqttHandleInverter.h

@@ -8,6 +8,7 @@
 
 class MqttHandleInverterClass {
 public:
+    MqttHandleInverterClass();
     void init(Scheduler& scheduler);
 
     static String getTopic(std::shared_ptr<InverterAbstract> inv, const ChannelType_t type, const ChannelNum_t channel, const FieldId_t fieldId);
@@ -39,4 +40,4 @@ private:
     };
 };
 
-extern MqttHandleInverterClass MqttHandleInverter;
+extern MqttHandleInverterClass MqttHandleInverter;

include/MqttHandleInverterTotal.h

@@ -5,6 +5,7 @@
 
 class MqttHandleInverterTotalClass {
 public:
+    MqttHandleInverterTotalClass();
     void init(Scheduler& scheduler);
 
 private:
@@ -13,4 +14,4 @@ private:
     Task _loopTask;
 };
 
-extern MqttHandleInverterTotalClass MqttHandleInverterTotal;
+extern MqttHandleInverterTotalClass MqttHandleInverterTotal;

include/WebApi_dtu.h

@@ -6,6 +6,7 @@
 
 class WebApiDtuClass {
 public:
+    WebApiDtuClass();
     void init(AsyncWebServer& server, Scheduler& scheduler);
 
 private:

src/Datastore.cpp

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 /*
- * Copyright (C) 2023 Thomas Basler and others
+ * Copyright (C) 2023-2024 Thomas Basler and others
  */
 #include "Datastore.h"
 #include "Configuration.h"
@@ -8,12 +8,14 @@
 
 DatastoreClass Datastore;
 
+DatastoreClass::DatastoreClass()
+    : _loopTask(1 * TASK_SECOND, TASK_FOREVER, std::bind(&DatastoreClass::loop, this))
+{
+}
+
 void DatastoreClass::init(Scheduler& scheduler)
 {
     scheduler.addTask(_loopTask);
-    _loopTask.setCallback(std::bind(&DatastoreClass::loop, this));
-    _loopTask.setIterations(TASK_FOREVER);
-    _loopTask.setInterval(1 * TASK_SECOND);
     _loopTask.enable();
 }
 

src/Display_Graphic.cpp

@@ -35,6 +35,7 @@ static const char* const i18n_yield_total_kwh[] = { "total: %.1f kWh", "Ges.: %.
 static const char* const i18n_date_format[] = { "%m/%d/%Y %H:%M", "%d.%m.%Y %H:%M", "%d/%m/%Y %H:%M" };
 
 DisplayGraphicClass::DisplayGraphicClass()
+    : _loopTask(TASK_IMMEDIATE, TASK_FOREVER, std::bind(&DisplayGraphicClass::loop, this))
 {
 }
 
@@ -55,8 +56,6 @@ void DisplayGraphicClass::init(Scheduler& scheduler, const DisplayType_t type, c
         _diagram.init(scheduler, _display);
 
         scheduler.addTask(_loopTask);
-        _loopTask.setCallback(std::bind(&DisplayGraphicClass::loop, this));
-        _loopTask.setIterations(TASK_FOREVER);
         _loopTask.setInterval(_period);
         _loopTask.enable();
     }

src/Display_Graphic_Diagram.cpp

@@ -8,6 +8,8 @@
 #include <algorithm>
 
 DisplayGraphicDiagramClass::DisplayGraphicDiagramClass()
+    : _averageTask(1 * TASK_SECOND, TASK_FOREVER, std::bind(&DisplayGraphicDiagramClass::averageLoop, this))
+    , _dataPointTask(TASK_IMMEDIATE, TASK_FOREVER, std::bind(&DisplayGraphicDiagramClass::dataPointLoop, this))
 {
 }
 
@@ -16,14 +18,9 @@ void DisplayGraphicDiagramClass::init(Scheduler& scheduler, U8G2* display)
     _display = display;
 
     scheduler.addTask(_averageTask);
-    _averageTask.setCallback(std::bind(&DisplayGraphicDiagramClass::averageLoop, this));
-    _averageTask.setIterations(TASK_FOREVER);
-    _averageTask.setInterval(1 * TASK_SECOND);
     _averageTask.enable();
 
     scheduler.addTask(_dataPointTask);
-    _dataPointTask.setCallback(std::bind(&DisplayGraphicDiagramClass::dataPointLoop, this));
-    _dataPointTask.setIterations(TASK_FOREVER);
     updatePeriod();
     _dataPointTask.enable();
 }
@@ -58,7 +55,7 @@ uint32_t DisplayGraphicDiagramClass::getSecondsPerDot()
 void DisplayGraphicDiagramClass::updatePeriod()
 {
     //  Calculate seconds per datapoint
-    _dataPointTask.setInterval(Configuration.get().Display.Diagram.Duration * TASK_SECOND / MAX_DATAPOINTS );
+    _dataPointTask.setInterval(Configuration.get().Display.Diagram.Duration * TASK_SECOND / MAX_DATAPOINTS);
 }
 
 void DisplayGraphicDiagramClass::redraw(uint8_t screenSaverOffsetX, uint8_t xPos, uint8_t yPos, uint8_t width, uint8_t height, bool isFullscreen)
@@ -110,7 +107,9 @@ void DisplayGraphicDiagramClass::redraw(uint8_t screenSaverOffsetX, uint8_t xPos
 
     if (maxWatts > 0 && isFullscreen) {
         // draw y axis ticks
-        const uint16_t yAxisWattPerTick = maxWatts <= 100 ? 10 : maxWatts <= 1000 ? 100 : maxWatts < 5000 ? 500 : 1000;
+        const uint16_t yAxisWattPerTick = maxWatts <= 100 ? 10 : maxWatts <= 1000 ? 100
+            : maxWatts < 5000                                                     ? 500
+                                                                                  : 1000;
         const uint8_t yAxisTickSizePixel = height / (maxWatts / yAxisWattPerTick);
 
         for (int16_t tickYPos = graphPosY + height; tickYPos > graphPosY - arrow_size; tickYPos -= yAxisTickSizePixel) {

src/InverterSettings.cpp

@@ -25,6 +25,12 @@
 
 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))
+{
+}
+
 void InverterSettingsClass::init(Scheduler& scheduler)
 {
     const CONFIG_T& config = Configuration.get();
@@ -91,14 +97,9 @@ void InverterSettingsClass::init(Scheduler& scheduler)
     }
 
     scheduler.addTask(_hoyTask);
-    _hoyTask.setCallback(std::bind(&InverterSettingsClass::hoyLoop, this));
-    _hoyTask.setIterations(TASK_FOREVER);
     _hoyTask.enable();
 
     scheduler.addTask(_settingsTask);
-    _settingsTask.setCallback(std::bind(&InverterSettingsClass::settingsLoop, this));
-    _settingsTask.setIterations(TASK_FOREVER);
-    _settingsTask.setInterval(INVERTER_UPDATE_SETTINGS_INTERVAL);
     _settingsTask.enable();
 }
 
@@ -119,7 +120,7 @@ void InverterSettingsClass::settingsLoop()
         inv->setEnablePolling(inv_cfg.Poll_Enable && (SunPosition.isDayPeriod() || inv_cfg.Poll_Enable_Night));
         inv->setEnableCommands(inv_cfg.Command_Enable && (SunPosition.isDayPeriod() || inv_cfg.Command_Enable_Night));
     }
- }
+}
 
 void InverterSettingsClass::hoyLoop()
 {

src/Led_Single.cpp

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 /*
- * Copyright (C) 2023 Thomas Basler and others
+ * Copyright (C) 2023-2024 Thomas Basler and others
  */
 #include "Led_Single.h"
 #include "Configuration.h"
@@ -38,6 +38,8 @@ const uint8_t pwmTable[] = {
 #define LED_OFF 0
 
 LedSingleClass::LedSingleClass()
+    : _setTask(LEDSINGLE_UPDATE_INTERVAL * TASK_MILLISECOND, TASK_FOREVER, std::bind(&LedSingleClass::setLoop, this))
+    , _outputTask(TASK_IMMEDIATE, TASK_FOREVER, std::bind(&LedSingleClass::outputLoop, this))
 {
 }
 
@@ -62,14 +64,9 @@ void LedSingleClass::init(Scheduler& scheduler)
 
     if (ledActive) {
         scheduler.addTask(_outputTask);
-        _outputTask.setCallback(std::bind(&LedSingleClass::outputLoop, this));
-        _outputTask.setIterations(TASK_FOREVER);
         _outputTask.enable();
 
         scheduler.addTask(_setTask);
-        _setTask.setCallback(std::bind(&LedSingleClass::setLoop, this));
-        _setTask.setInterval(LEDSINGLE_UPDATE_INTERVAL * TASK_MILLISECOND);
-        _setTask.setIterations(TASK_FOREVER);
         _setTask.enable();
     }
 }

src/MessageOutput.cpp

@@ -1,63 +1,66 @@
-// SPDX-License-Identifier: GPL-2.0-or-later
+// SPDX-License-Identifier: GPL-2.0-or-later
-/*
+/*
- * Copyright (C) 2022-2023 Thomas Basler and others
+ * Copyright (C) 2022-2024 Thomas Basler and others
- */
+ */
-#include "MessageOutput.h"
+#include "MessageOutput.h"
-
+
-#include <Arduino.h>
+#include <Arduino.h>
-
+
-MessageOutputClass MessageOutput;
+MessageOutputClass MessageOutput;
-
+
-void MessageOutputClass::init(Scheduler& scheduler)
+MessageOutputClass::MessageOutputClass()
-{
+    : _loopTask(TASK_IMMEDIATE, TASK_FOREVER, std::bind(&MessageOutputClass::loop, this))
-    scheduler.addTask(_loopTask);
+{
-    _loopTask.setCallback(std::bind(&MessageOutputClass::loop, this));
+}
-    _loopTask.setIterations(TASK_FOREVER);
+
-    _loopTask.enable();
+void MessageOutputClass::init(Scheduler& scheduler)
-}
+{
-
+    scheduler.addTask(_loopTask);
-void MessageOutputClass::register_ws_output(AsyncWebSocket* output)
+    _loopTask.enable();
-{
+}
-    _ws = output;
+
-}
+void MessageOutputClass::register_ws_output(AsyncWebSocket* output)
-
+{
-size_t MessageOutputClass::write(uint8_t c)
+    _ws = output;
-{
+}
-    if (_buff_pos < BUFFER_SIZE) {
+
-        std::lock_guard<std::mutex> lock(_msgLock);
+size_t MessageOutputClass::write(uint8_t c)
-        _buffer[_buff_pos] = c;
+{
-        _buff_pos++;
+    if (_buff_pos < BUFFER_SIZE) {
-    } else {
+        std::lock_guard<std::mutex> lock(_msgLock);
-        _forceSend = true;
+        _buffer[_buff_pos] = c;
-    }
+        _buff_pos++;
-
+    } else {
-    return Serial.write(c);
+        _forceSend = true;
-}
+    }
-
+
-size_t MessageOutputClass::write(const uint8_t* buffer, size_t size)
+    return Serial.write(c);
-{
+}
-    std::lock_guard<std::mutex> lock(_msgLock);
+
-    if (_buff_pos + size < BUFFER_SIZE) {
+size_t MessageOutputClass::write(const uint8_t* buffer, size_t size)
-        memcpy(&_buffer[_buff_pos], buffer, size);
+{
-        _buff_pos += size;
+    std::lock_guard<std::mutex> lock(_msgLock);
-    }
+    if (_buff_pos + size < BUFFER_SIZE) {
-    _forceSend = true;
+        memcpy(&_buffer[_buff_pos], buffer, size);
-
+        _buff_pos += size;
-    return Serial.write(buffer, size);
+    }
-}
+    _forceSend = true;
-
+
-void MessageOutputClass::loop()
+    return Serial.write(buffer, size);
-{
+}
-    // Send data via websocket if either time is over or buffer is full
+
-    if (_forceSend || (millis() - _lastSend > 1000)) {
+void MessageOutputClass::loop()
-        std::lock_guard<std::mutex> lock(_msgLock);
+{
-        if (_ws && _buff_pos > 0) {
+    // Send data via websocket if either time is over or buffer is full
-            _ws->textAll(_buffer, _buff_pos);
+    if (_forceSend || (millis() - _lastSend > 1000)) {
-            _buff_pos = 0;
+        std::lock_guard<std::mutex> lock(_msgLock);
-        }
+        if (_ws && _buff_pos > 0) {
-        if (_forceSend) {
+            _ws->textAll(_buffer, _buff_pos);
-            _buff_pos = 0;
+            _buff_pos = 0;
-        }
+        }
-        _forceSend = false;
+        if (_forceSend) {
-    }
+            _buff_pos = 0;
-}
+        }
+        _forceSend = false;
+    }
+}

src/MqttHandleDtu.cpp

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 /*
- * Copyright (C) 2022-2023 Thomas Basler and others
+ * Copyright (C) 2022-2024 Thomas Basler and others
  */
 #include "MqttHandleDtu.h"
 #include "Configuration.h"
@@ -10,11 +10,14 @@
 
 MqttHandleDtuClass MqttHandleDtu;
 
+MqttHandleDtuClass::MqttHandleDtuClass()
+    : _loopTask(TASK_IMMEDIATE, TASK_FOREVER, std::bind(&MqttHandleDtuClass::loop, this))
+{
+}
+
 void MqttHandleDtuClass::init(Scheduler& scheduler)
 {
     scheduler.addTask(_loopTask);
-    _loopTask.setCallback(std::bind(&MqttHandleDtuClass::loop, this));
-    _loopTask.setIterations(TASK_FOREVER);
     _loopTask.setInterval(Configuration.get().Mqtt.PublishInterval * TASK_SECOND);
     _loopTask.enable();
 }
@@ -35,4 +38,4 @@ void MqttHandleDtuClass::loop()
         MqttSettings.publish("dtu/rssi", String(WiFi.RSSI()));
         MqttSettings.publish("dtu/bssid", WiFi.BSSIDstr());
     }
-}
+}

src/MqttHandleHass.cpp

@@ -11,11 +11,14 @@
 
 MqttHandleHassClass MqttHandleHass;
 
+MqttHandleHassClass::MqttHandleHassClass()
+    : _loopTask(TASK_IMMEDIATE, TASK_FOREVER, std::bind(&MqttHandleHassClass::loop, this))
+{
+}
+
 void MqttHandleHassClass::init(Scheduler& scheduler)
 {
     scheduler.addTask(_loopTask);
-    _loopTask.setCallback(std::bind(&MqttHandleHassClass::loop, this));
-    _loopTask.setIterations(TASK_FOREVER);
     _loopTask.enable();
 }
 
@@ -53,7 +56,7 @@ void MqttHandleHassClass::publishConfig()
 
     const CONFIG_T& config = Configuration.get();
 
-     // publish DTU sensors
+    // publish DTU sensors
     publishDtuSensor("IP", "", "diagnostic", "mdi:network-outline", "", "");
     publishDtuSensor("WiFi Signal", "signal_strength", "diagnostic", "", "dBm", "rssi");
     publishDtuSensor("Uptime", "duration", "diagnostic", "", "s", "");

src/MqttHandleInverter.cpp

@@ -18,6 +18,11 @@
 
 MqttHandleInverterClass MqttHandleInverter;
 
+MqttHandleInverterClass::MqttHandleInverterClass()
+    : _loopTask(TASK_IMMEDIATE, TASK_FOREVER, std::bind(&MqttHandleInverterClass::loop, this))
+{
+}
+
 void MqttHandleInverterClass::init(Scheduler& scheduler)
 {
     using std::placeholders::_1;
@@ -36,8 +41,6 @@ void MqttHandleInverterClass::init(Scheduler& scheduler)
     MqttSettings.subscribe(String(topic + "+/cmd/" + TOPIC_SUB_RESTART), 0, std::bind(&MqttHandleInverterClass::onMqttMessage, this, _1, _2, _3, _4, _5, _6));
 
     scheduler.addTask(_loopTask);
-    _loopTask.setCallback(std::bind(&MqttHandleInverterClass::loop, this));
-    _loopTask.setIterations(TASK_FOREVER);
     _loopTask.setInterval(Configuration.get().Mqtt.PublishInterval * TASK_SECOND);
     _loopTask.enable();
 }

src/MqttHandleInverterTotal.cpp

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 /*
- * Copyright (C) 2023 Thomas Basler and others
+ * Copyright (C) 2023-2024 Thomas Basler and others
  */
 #include "MqttHandleInverterTotal.h"
 #include "Configuration.h"
@@ -10,11 +10,14 @@
 
 MqttHandleInverterTotalClass MqttHandleInverterTotal;
 
+MqttHandleInverterTotalClass::MqttHandleInverterTotalClass()
+    : _loopTask(TASK_IMMEDIATE, TASK_FOREVER, std::bind(&MqttHandleInverterTotalClass::loop, this))
+{
+}
+
 void MqttHandleInverterTotalClass::init(Scheduler& scheduler)
 {
     scheduler.addTask(_loopTask);
-    _loopTask.setCallback(std::bind(&MqttHandleInverterTotalClass::loop, this));
-    _loopTask.setIterations(TASK_FOREVER);
     _loopTask.setInterval(Configuration.get().Mqtt.PublishInterval * TASK_SECOND);
     _loopTask.enable();
 }

src/NetworkSettings.cpp

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 /*
- * Copyright (C) 2022-2023 Thomas Basler and others
+ * Copyright (C) 2022-2024 Thomas Basler and others
  */
 #include "NetworkSettings.h"
 #include "Configuration.h"
@@ -12,7 +12,8 @@
 #include <ETH.h>
 
 NetworkSettingsClass::NetworkSettingsClass()
-    : _apIp(192, 168, 4, 1)
+    : _loopTask(TASK_IMMEDIATE, TASK_FOREVER, std::bind(&NetworkSettingsClass::loop, this))
+    , _apIp(192, 168, 4, 1)
     , _apNetmask(255, 255, 255, 0)
 {
     _dnsServer.reset(new DNSServer());
@@ -29,8 +30,6 @@ void NetworkSettingsClass::init(Scheduler& scheduler)
     setupMode();
 
     scheduler.addTask(_loopTask);
-    _loopTask.setCallback(std::bind(&NetworkSettingsClass::loop, this));
-    _loopTask.setIterations(TASK_FOREVER);
     _loopTask.enable();
 }
 

src/SunPosition.cpp

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 /*
- * Copyright (C) 2023 Thomas Basler and others
+ * Copyright (C) 2023-2024 Thomas Basler and others
  */
 #include "SunPosition.h"
 #include "Configuration.h"
@@ -10,15 +10,13 @@
 SunPositionClass SunPosition;
 
 SunPositionClass::SunPositionClass()
+    : _loopTask(5 * TASK_SECOND, TASK_FOREVER, std::bind(&SunPositionClass::loop, this))
 {
 }
 
 void SunPositionClass::init(Scheduler& scheduler)
 {
     scheduler.addTask(_loopTask);
-    _loopTask.setCallback(std::bind(&SunPositionClass::loop, this));
-    _loopTask.setIterations(TASK_FOREVER);
-    _loopTask.setInterval(5 * TASK_SECOND);
     _loopTask.enable();
 }
 

src/WebApi_dtu.cpp

@@ -9,6 +9,11 @@
 #include <AsyncJson.h>
 #include <Hoymiles.h>
 
+WebApiDtuClass::WebApiDtuClass()
+    : _applyDataTask(TASK_IMMEDIATE, TASK_ONCE, std::bind(&WebApiDtuClass::applyDataTaskCb, this))
+{
+}
+
 void WebApiDtuClass::init(AsyncWebServer& server, Scheduler& scheduler)
 {
     using std::placeholders::_1;
@@ -19,8 +24,6 @@ void WebApiDtuClass::init(AsyncWebServer& server, Scheduler& scheduler)
     _server->on("/api/dtu/config", HTTP_POST, std::bind(&WebApiDtuClass::onDtuAdminPost, this, _1));
 
     scheduler.addTask(_applyDataTask);
-    _applyDataTask.setCallback(std::bind(&WebApiDtuClass::applyDataTaskCb, this));
-    _applyDataTask.setIterations(TASK_ONCE);
 }
 
 void WebApiDtuClass::applyDataTaskCb()

src/WebApi_ws_console.cpp

@@ -10,6 +10,7 @@
 
 WebApiWsConsoleClass::WebApiWsConsoleClass()
     : _ws("/console")
+    , _wsCleanupTask(1 * TASK_SECOND, TASK_FOREVER, std::bind(&WebApiWsConsoleClass::wsCleanupTaskCb, this))
 {
 }
 
@@ -20,9 +21,6 @@ void WebApiWsConsoleClass::init(AsyncWebServer& server, Scheduler& scheduler)
     MessageOutput.register_ws_output(&_ws);
 
     scheduler.addTask(_wsCleanupTask);
-    _wsCleanupTask.setCallback(std::bind(&WebApiWsConsoleClass::wsCleanupTaskCb, this));
-    _wsCleanupTask.setIterations(TASK_FOREVER);
-    _wsCleanupTask.setInterval(1 * TASK_SECOND);
     _wsCleanupTask.enable();
 }
 

src/WebApi_ws_live.cpp

@@ -13,6 +13,8 @@
 
 WebApiWsLiveClass::WebApiWsLiveClass()
     : _ws("/livedata")
+    , _wsCleanupTask(1 * TASK_SECOND, TASK_FOREVER, std::bind(&WebApiWsLiveClass::wsCleanupTaskCb, this))
+    , _sendDataTask(1 * TASK_SECOND, TASK_FOREVER, std::bind(&WebApiWsLiveClass::sendDataTaskCb, this))
 {
 }
 
@@ -32,15 +34,9 @@ void WebApiWsLiveClass::init(AsyncWebServer& server, Scheduler& scheduler)
     _ws.onEvent(std::bind(&WebApiWsLiveClass::onWebsocketEvent, this, _1, _2, _3, _4, _5, _6));
 
     scheduler.addTask(_wsCleanupTask);
-    _wsCleanupTask.setCallback(std::bind(&WebApiWsLiveClass::wsCleanupTaskCb, this));
-    _wsCleanupTask.setIterations(TASK_FOREVER);
-    _wsCleanupTask.setInterval(1 * TASK_SECOND);
     _wsCleanupTask.enable();
 
     scheduler.addTask(_sendDataTask);
-    _sendDataTask.setCallback(std::bind(&WebApiWsLiveClass::sendDataTaskCb, this));
-    _sendDataTask.setIterations(TASK_FOREVER);
-    _sendDataTask.setInterval(1 * TASK_SECOND);
     _sendDataTask.enable();
 }