Revert ESP-MQTT (#508)

* Revert ESP-MQTT * Revert ESP-MQTT * Update sdkconfig.defaults
2024-11-02 17:07:00 +01:00
parent 81a91c4157
commit 7454208230
115 changed files with 9965 additions and 962 deletions
--- a/src/networkDevices/EthernetDevice.cpp
+++ b/src/networkDevices/EthernetDevice.cpp
@@ -1,10 +1,14 @@
 #include "EthernetDevice.h"
 #include "../PreferencesKeys.h"
 #include "../Logger.h"
+#ifndef NUKI_HUB_UPDATER
+#include "../MqttTopics.h"
+#include "espMqttClient.h"
+#endif
 #include "../RestartReason.h"

-RTC_NOINIT_ATTR bool criticalEthFailure;
-extern char WiFi_fallbackDetect[14];
+extern bool ethCriticalFailure;
+extern bool wifiFallback;

 EthernetDevice::EthernetDevice(const String& hostname, Preferences* preferences, const IPConfiguration* ipConfiguration, const std::string& deviceName, uint8_t phy_addr, int power, int mdc, int mdio, eth_phy_type_t ethtype, eth_clock_mode_t clock_mode)
    : NetworkDevice(hostname, ipConfiguration),
@@ -49,6 +53,51 @@ EthernetDevice::EthernetDevice(const String &hostname,
    init();
 }

+void EthernetDevice::init()
+{
+#ifndef NUKI_HUB_UPDATER
+    size_t caLength = _preferences->getString(preference_mqtt_ca, _ca, TLS_CA_MAX_SIZE);
+    size_t crtLength = _preferences->getString(preference_mqtt_crt, _cert, TLS_CERT_MAX_SIZE);
+    size_t keyLength = _preferences->getString(preference_mqtt_key, _key, TLS_KEY_MAX_SIZE);
+
+    _useEncryption = caLength > 1;  // length is 1 when empty
+
+    if(_useEncryption)
+    {
+        Log->println(F("MQTT over TLS."));
+        _mqttClientSecure = new espMqttClientSecure(espMqttClientTypes::UseInternalTask::NO);
+        _mqttClientSecure->setCACert(_ca);
+        if(crtLength > 1 && keyLength > 1) // length is 1 when empty
+        {
+            Log->println(F("MQTT with client certificate."));
+            _mqttClientSecure->setCertificate(_cert);
+            _mqttClientSecure->setPrivateKey(_key);
+        }
+    } else
+    {
+        Log->println(F("MQTT without TLS."));
+        _mqttClient = new espMqttClient(espMqttClientTypes::UseInternalTask::NO);
+    }
+
+    if(_preferences->getBool(preference_mqtt_log_enabled, false) || _preferences->getBool(preference_webserial_enabled, false))
+    {
+        MqttLoggerMode mode;
+
+        if(_preferences->getBool(preference_mqtt_log_enabled, false) && _preferences->getBool(preference_webserial_enabled, false)) mode = MqttLoggerMode::MqttAndSerialAndWeb;
+        else if (_preferences->getBool(preference_webserial_enabled, false)) mode = MqttLoggerMode::SerialAndWeb;
+        else mode = MqttLoggerMode::MqttAndSerial;
+
+        _path = new char[200];
+        memset(_path, 0, sizeof(_path));
+
+        String pathStr = _preferences->getString(preference_mqtt_lock_path);
+        pathStr.concat(mqtt_topic_log);
+        strcpy(_path, pathStr.c_str());
+        Log = new MqttLogger(*getMqttClient(), _path, mode);
+    }
+#endif
+}
+
 const String EthernetDevice::deviceName() const
 {
    return _deviceName.c_str();
@@ -57,12 +106,12 @@ const String EthernetDevice::deviceName() const
 void EthernetDevice::initialize()
 {
    delay(250);
-    if(criticalEthFailure)
+    if(ethCriticalFailure)
    {
-        criticalEthFailure = false;
+        ethCriticalFailure = false;
        Log->println(F("Failed to initialize ethernet hardware"));
        Log->println("Network device has a critical failure, enable fallback to Wi-Fi and reboot.");
-        strcpy(WiFi_fallbackDetect, "wifi_fallback");
+        wifiFallback = true;
        delay(200);
        restartEsp(RestartReason::NetworkDeviceCriticalFailure);
        return;
@@ -73,18 +122,18 @@ void EthernetDevice::initialize()
    if(_useSpi)
    {
        Log->println(F("Use SPI"));
-        criticalEthFailure = true;
+        ethCriticalFailure = true;
        SPI.begin(_spi_sck, _spi_miso, _spi_mosi);
        _hardwareInitialized = ETH.begin(_type, _phy_addr, _cs, _irq, _rst, SPI);
-        criticalEthFailure = false;
+        ethCriticalFailure = false;
    }
 #ifdef CONFIG_IDF_TARGET_ESP32
    else
    {
        Log->println(F("Use RMII"));
-        criticalEthFailure = true;
+        ethCriticalFailure = true;
        _hardwareInitialized = ETH.begin(_type, _phy_addr, _mdc, _mdio, _power, _clock_mode);
-        criticalEthFailure = false;
+        ethCriticalFailure = false;
        if(!_ipConfiguration->dhcpEnabled())
        {
            _checkIpTs = espMillis() + 2000;
@@ -95,7 +144,7 @@ void EthernetDevice::initialize()
    if(_hardwareInitialized)
    {
        Log->println(F("Ethernet hardware Initialized"));
-        memset(WiFi_fallbackDetect, 0, sizeof(WiFi_fallbackDetect));
+        wifiFallback = false;

        if(_useSpi && !_ipConfiguration->dhcpEnabled())
        {
@@ -111,7 +160,7 @@ void EthernetDevice::initialize()
    {
        Log->println(F("Failed to initialize ethernet hardware"));
        Log->println("Network device has a critical failure, enable fallback to Wi-Fi and reboot.");
-        strcpy(WiFi_fallbackDetect, "wifi_fallback");
+        wifiFallback = true;
        delay(200);
        restartEsp(RestartReason::NetworkDeviceCriticalFailure);
        return;
@@ -120,18 +169,19 @@ void EthernetDevice::initialize()

 void EthernetDevice::update()
 {
-    if(_checkIpTs != -1)
+    NetworkDevice::update();
+  
+    if(_checkIpTs != -1 && _checkIpTs < espMillis())
    {
        if(_ipConfiguration->ipAddress() != ETH.localIP())
        {
            Log->println(F("ETH Set static IP"));
            ETH.config(_ipConfiguration->ipAddress(), _ipConfiguration->defaultGateway(), _ipConfiguration->subnet(), _ipConfiguration->dnsServer());
-            _checkIpTs = espMillis() + 2000;
-        }
-        else
-        {
-            _checkIpTs = -1;
+            _checkIpTs = espMillis() + 5000;
+            return;
        }
+        
+        _checkIpTs = -1;
    }
 }

--- a/src/networkDevices/EthernetDevice.h
+++ b/src/networkDevices/EthernetDevice.h
@@ -11,6 +11,9 @@
 #include <NetworkClientSecure.h>
 #include <Preferences.h>
 #include "NetworkDevice.h"
+#ifndef NUKI_HUB_UPDATER
+#include "espMqttClient.h"
+#endif

 class EthernetDevice : public NetworkDevice
 {
@@ -45,8 +48,8 @@ public:
    virtual void initialize();
    virtual void reconfigure();
    virtual void update();
-    virtual void scan(bool passive = false, bool async = true);

+    virtual void scan(bool passive = false, bool async = true);
    virtual bool isConnected();
    virtual bool isApOpen();

@@ -58,10 +61,12 @@ public:
 private:
    Preferences* _preferences;

+    void init();
    void onDisconnected();
    void onNetworkEvent(arduino_event_id_t event, arduino_event_info_t info);

    bool _connected = false;
+    char* _path;
    bool _hardwareInitialized = false;

    const std::string _deviceName;
@@ -85,4 +90,10 @@ private:
    eth_phy_type_t _type;
    eth_clock_mode_t _clock_mode;
    bool _useSpi = false;
+
+    #ifndef NUKI_HUB_UPDATER
+    char _ca[TLS_CA_MAX_SIZE] = {0};
+    char _cert[TLS_CERT_MAX_SIZE] = {0};
+    char _key[TLS_KEY_MAX_SIZE] = {0};
+    #endif
 };
--- a/src/networkDevices/NetworkDevice.cpp
+++ b/src/networkDevices/NetworkDevice.cpp
@@ -1,6 +1,179 @@
 #include <Arduino.h>
 #include "NetworkDevice.h"
+#include "../Logger.h"

+void NetworkDevice::printError()
+{
+    Log->print(F("Free Heap: "));
+    Log->println(ESP.getFreeHeap());
+}
+
+#ifndef NUKI_HUB_UPDATER
 void NetworkDevice::update()
 {
-}
+    if (_mqttEnabled)
+    {
+        getMqttClient()->loop();
+    }
+}
+
+void NetworkDevice::mqttSetClientId(const char *clientId)
+{
+    if (_useEncryption)
+    {
+        _mqttClientSecure->setClientId(clientId);
+    }
+    else
+    {
+        _mqttClient->setClientId(clientId);
+    }
+}
+
+void NetworkDevice::mqttSetCleanSession(bool cleanSession)
+{
+    if (_useEncryption)
+    {
+        _mqttClientSecure->setCleanSession(cleanSession);
+    }
+    else
+    {
+        _mqttClient->setCleanSession(cleanSession);
+    }
+}
+
+void NetworkDevice::mqttSetKeepAlive(uint16_t keepAlive)
+{
+    if (_useEncryption)
+    {
+        _mqttClientSecure->setKeepAlive(keepAlive);
+    }
+    else
+    {
+        _mqttClient->setKeepAlive(keepAlive);
+    }
+}
+
+uint16_t NetworkDevice::mqttPublish(const char *topic, uint8_t qos, bool retain, const char *payload)
+{
+    return getMqttClient()->publish(topic, qos, retain, payload);
+}
+
+uint16_t NetworkDevice::mqttPublish(const char *topic, uint8_t qos, bool retain, const uint8_t *payload, size_t length)
+{
+    return getMqttClient()->publish(topic, qos, retain, payload, length);
+}
+
+bool NetworkDevice::mqttConnected() const
+{
+    return getMqttClient()->connected();
+}
+
+void NetworkDevice::mqttSetServer(const char *host, uint16_t port)
+{
+    if (_useEncryption)
+    {
+        _mqttClientSecure->setServer(host, port);
+    }
+    else
+    {
+        _mqttClient->setServer(host, port);
+    }
+}
+
+bool NetworkDevice::mqttConnect()
+{
+    return getMqttClient()->connect();
+}
+
+bool NetworkDevice::mqttDisconnect(bool force)
+{
+    return getMqttClient()->disconnect(force);
+}
+
+void NetworkDevice::setWill(const char *topic, uint8_t qos, bool retain, const char *payload)
+{
+    if (_useEncryption)
+    {
+        _mqttClientSecure->setWill(topic, qos, retain, payload);
+    }
+    else
+    {
+        _mqttClient->setWill(topic, qos, retain, payload);
+    }
+}
+
+void NetworkDevice::mqttSetCredentials(const char *username, const char *password)
+{
+    if (_useEncryption)
+    {
+        _mqttClientSecure->setCredentials(username, password);
+    }
+    else
+    {
+        _mqttClient->setCredentials(username, password);
+    }
+}
+
+void NetworkDevice::mqttOnMessage(espMqttClientTypes::OnMessageCallback callback)
+{
+    if (_useEncryption)
+    {
+        _mqttClientSecure->onMessage(callback);
+    }
+    else
+    {
+        _mqttClient->onMessage(callback);
+    }
+}
+
+void NetworkDevice::mqttOnConnect(espMqttClientTypes::OnConnectCallback callback)
+{
+    if(_useEncryption)
+    {
+        _mqttClientSecure->onConnect(callback);
+    }
+    else
+    {
+        _mqttClient->onConnect(callback);
+    }
+}
+
+void NetworkDevice::mqttOnDisconnect(espMqttClientTypes::OnDisconnectCallback callback)
+{
+    if (_useEncryption)
+    {
+        _mqttClientSecure->onDisconnect(callback);
+    }
+    else
+    {
+        _mqttClient->onDisconnect(callback);
+    }
+}
+
+uint16_t NetworkDevice::mqttSubscribe(const char *topic, uint8_t qos)
+{
+    return getMqttClient()->subscribe(topic, qos);
+}
+
+void NetworkDevice::disableMqtt()
+{
+    getMqttClient()->disconnect();
+    _mqttEnabled = false;
+}
+
+MqttClient *NetworkDevice::getMqttClient() const
+{
+    if (_useEncryption)
+    {
+        return _mqttClientSecure;
+    }
+    else
+    {
+        return _mqttClient;
+    }
+}
+#else
+void NetworkDevice::update()
+{
+}
+#endif
--- a/src/networkDevices/NetworkDevice.h
+++ b/src/networkDevices/NetworkDevice.h
@@ -1,4 +1,9 @@
 #pragma once
+
+#ifndef NUKI_HUB_UPDATER
+#include "espMqttClient.h"
+#include "MqttClientSetup.h"
+#endif
 #include "IPConfiguration.h"
 #include "../EspMillis.h"

@@ -14,16 +19,48 @@ public:

    virtual void initialize() = 0;
    virtual void reconfigure() = 0;
+    virtual void printError();
+
    virtual void update();
    virtual void scan(bool passive = false, bool async = true) = 0;
-
    virtual bool isConnected() = 0;
    virtual bool isApOpen() = 0;
    virtual int8_t signalStrength() = 0;

    virtual String localIP() = 0;
    virtual String BSSIDstr() = 0;
-protected:    
+
+    #ifndef NUKI_HUB_UPDATER
+    virtual void mqttSetClientId(const char* clientId);
+    virtual void mqttSetCleanSession(bool cleanSession);
+    virtual void mqttSetKeepAlive(uint16_t keepAlive);
+    virtual uint16_t mqttPublish(const char* topic, uint8_t qos, bool retain, const char* payload);
+    virtual uint16_t mqttPublish(const char* topic, uint8_t qos, bool retain, const uint8_t* payload, size_t length);
+    virtual bool mqttConnected() const;
+    virtual void mqttSetServer(const char* host, uint16_t port);
+    virtual bool mqttConnect();
+    virtual bool mqttDisconnect(bool force);
+    virtual void setWill(const char* topic, uint8_t qos, bool retain, const char* payload);
+    virtual void mqttSetCredentials(const char* username, const char* password);
+    virtual void mqttOnMessage(espMqttClientTypes::OnMessageCallback callback);
+    virtual void mqttOnConnect(espMqttClientTypes::OnConnectCallback callback);
+    virtual void mqttOnDisconnect(espMqttClientTypes::OnDisconnectCallback callback);
+    virtual void disableMqtt();
+
+    virtual uint16_t mqttSubscribe(const char* topic, uint8_t qos);
+    #endif
+
+protected:
+    #ifndef NUKI_HUB_UPDATER
+    espMqttClient *_mqttClient = nullptr;
+    espMqttClientSecure *_mqttClientSecure = nullptr;
+
+    bool _useEncryption = false;
+    bool _mqttEnabled = true;
+    
+    MqttClient *getMqttClient() const;
+    #endif
+    
    const String _hostname;
    const IPConfiguration* _ipConfiguration = nullptr;
 };
--- a/src/networkDevices/WifiDevice.cpp
+++ b/src/networkDevices/WifiDevice.cpp
@@ -3,14 +3,59 @@
 #include "WifiDevice.h"
 #include "../PreferencesKeys.h"
 #include "../Logger.h"
+#ifndef NUKI_HUB_UPDATER
+#include "../MqttTopics.h"
+#include "espMqttClient.h"
+#endif
 #include "../RestartReason.h"

 WifiDevice::WifiDevice(const String& hostname, Preferences* preferences, const IPConfiguration* ipConfiguration)
    : NetworkDevice(hostname, ipConfiguration),
      _preferences(preferences)
 {
+    #ifndef NUKI_HUB_UPDATER
+    size_t caLength = preferences->getString(preference_mqtt_ca, _ca, TLS_CA_MAX_SIZE);
+    size_t crtLength = preferences->getString(preference_mqtt_crt, _cert, TLS_CERT_MAX_SIZE);
+    size_t keyLength = preferences->getString(preference_mqtt_key, _key, TLS_KEY_MAX_SIZE);
+
+    _useEncryption = caLength > 1;  // length is 1 when empty
+
+    if(_useEncryption)
+    {
+        Log->println(F("MQTT over TLS."));
+        _mqttClientSecure = new espMqttClientSecure(espMqttClientTypes::UseInternalTask::NO);
+        _mqttClientSecure->setCACert(_ca);
+        if(crtLength > 1 && keyLength > 1) // length is 1 when empty
+        {
+            Log->println(F("MQTT with client certificate."));
+            _mqttClientSecure->setCertificate(_cert);
+            _mqttClientSecure->setPrivateKey(_key);
+        }
+    } 
+    else
+    {
+        Log->println(F("MQTT without TLS."));
+        _mqttClient = new espMqttClient(espMqttClientTypes::UseInternalTask::NO);
+    }
+
+    if(preferences->getBool(preference_mqtt_log_enabled, false) || preferences->getBool(preference_webserial_enabled, false))
+    {
+        MqttLoggerMode mode;
+
+        if(preferences->getBool(preference_mqtt_log_enabled, false) && preferences->getBool(preference_webserial_enabled, false)) mode = MqttLoggerMode::MqttAndSerialAndWeb;
+        else if (preferences->getBool(preference_webserial_enabled, false)) mode = MqttLoggerMode::SerialAndWeb;
+        else mode = MqttLoggerMode::MqttAndSerial;
+        _path = new char[200];
+        memset(_path, 0, sizeof(_path));
+        String pathStr = preferences->getString(preference_mqtt_lock_path);
+        pathStr.concat(mqtt_topic_log);
+        strcpy(_path, pathStr.c_str());
+        Log = new MqttLogger(*getMqttClient(), _path, mode);
+    }
+    #endif
 }

+
 const String WifiDevice::deviceName() const
 {
    return "Built-in Wi-Fi";
@@ -373,7 +418,7 @@ void WifiDevice::onDisconnected()
        }

        _connecting = false;
-        //END QUICK RECONECT
+        //END QUICK RECONNECT

        if(!isConnected())
        {
--- a/src/networkDevices/WifiDevice.h
+++ b/src/networkDevices/WifiDevice.h
@@ -29,6 +29,7 @@ private:
    void onDisconnected();
    void onConnected();
    bool connect();
+    char* _path;

    Preferences* _preferences = nullptr;

@@ -44,4 +45,10 @@ private:
    uint8_t _connectedChannel = 0;
    uint8_t* _connectedBSSID;
    int64_t _disconnectTs = 0;
+    
+    #ifndef NUKI_HUB_UPDATER
+    char _ca[TLS_CA_MAX_SIZE] = {0};
+    char _cert[TLS_CERT_MAX_SIZE] = {0};
+    char _key[TLS_KEY_MAX_SIZE] = {0};
+    #endif
 };