draft(legacy_alt): prepare support of alternative legacy protocol

AquaMQTT/.gitignore

@@ -1,4 +1,5 @@
 .pio
 include/config/CustomConfiguration.h
 include/config/CustomConfigurationProd.h
-.vscode
+.vscode
+.idea

AquaMQTT/include/Version.h

@@ -1,4 +1,4 @@
 namespace aquamqtt
 {
-constexpr char VERSION[] = "v1.8.1";
+constexpr char VERSION[] = "v1.8.2";
 }

AquaMQTT/include/config/Configuration.h

@@ -102,6 +102,15 @@ constexpr bool MQTT_PUBLISH_SERIAL_STATISTICS = false;
  */
 constexpr bool MQTT_PUBLISH_HEATPUMP_TIME_AND_DATE = false;
 
+/**
+ * Change this to use the alternative legacy protocol.
+ * There are heatpumps which use the legacy protocol identifiers ( id + length)
+ * but send different payloads Currently AquaMQTT does not support auto-detecting
+ * this special protocol type. In case you observe weird attributes and your heatpump
+ * is using the LEGACY protocol, you may set this flag to true.
+ */
+constexpr bool PROTOCOL_USE_LEGACY_ALTERNATIVE = false;
+
 /**
  * Change the time interval where all known attributes are re-published to the MQTT broker.
  */

AquaMQTT/lib/AtlanticSerialProtocol/include/message/Factory.h

@@ -11,6 +11,8 @@
 #include "legacy/HMIMessage.h"
 #include "legacy/MainEnergyMessage.h"
 #include "legacy/MainStatusMessage.h"
+#include "legacy_alternative/HMIMessage.h"
+#include "legacy_alternative/MainStatusMessage.h"
 #include "next/ErrorMessage.h"
 #include "next/HMIMessage.h"
 #include "next/MainEnergyMessage.h"
@@ -34,6 +36,10 @@ static std::unique_ptr<IHMIMessage>
     {
         message = std::make_unique<legacy::HMIMessage>(buffer, previousBuffer);
     }
+    if (version == PROTOCOL_LEGACY_ALTERNATIVE)
+    {
+        message = std::make_unique<legacyalt::HMIMessage>(buffer, previousBuffer);
+    }
     else if (version == PROTOCOL_ODYSSEE)
     {
         message = std::make_unique<odyssee::HMIMessage>(buffer, previousBuffer);
@@ -58,6 +64,10 @@ static std::unique_ptr<IMainMessage>
     {
         message = std::make_unique<odyssee::MainStatusMessage>(buffer, previousBuffer);
     }
+    else if (version == PROTOCOL_LEGACY_ALTERNATIVE)
+    {
+        message = std::make_unique<legacyalt::MainStatusMessage>(buffer, previousBuffer);
+    }
     else
     {
         message = std::make_unique<legacy::MainStatusMessage>(buffer, previousBuffer);
@@ -79,6 +89,7 @@ static std::unique_ptr<IEnergyMessage> createEnergyMessageFromBuffer(
     {
         message = std::make_unique<odyssee::MainEnergyMessage>(buffer, previousBuffer);
     }
+    // LEGACY + LEGACY ALTERNATIVE
     else
     {
         message = std::make_unique<legacy::MainEnergyMessage>(buffer, previousBuffer);
@@ -97,6 +108,7 @@ static std::unique_ptr<IErrorMessage> createErrorMessageFromBuffer(const Protoco
     {
         message = std::make_unique<odyssee::ErrorMessage>(buffer);
     }
+    // LEGACY + LEGACY ALTERNATIVE
     else
     {
         message = std::make_unique<legacy::ErrorMessage>(buffer);

AquaMQTT/lib/AtlanticSerialProtocol/include/message/MessageConstants.h

@@ -1,8 +1,8 @@
 #ifndef AQUAMQTT_MESSAGECONSTANTS_H
 #define AQUAMQTT_MESSAGECONSTANTS_H
 
-#include <cstdio>
 #include <cstdint>
+#include <cstdio>
 
 #include "mqtt/MQTTDefinitions.h"
 
@@ -21,10 +21,11 @@ enum class FrameBufferChannel
 
 enum ProtocolVersion
 {
-    PROTOCOL_UNKNOWN = -1,
-    PROTOCOL_LEGACY  = 0,
-    PROTOCOL_NEXT    = 1,
-    PROTOCOL_ODYSSEE = 2
+    PROTOCOL_UNKNOWN            = -1,
+    PROTOCOL_LEGACY             = 0,
+    PROTOCOL_NEXT               = 1,
+    PROTOCOL_ODYSSEE            = 2,
+    PROTOCOL_LEGACY_ALTERNATIVE = 3,
 };
 
 enum ProtocolChecksum
@@ -58,7 +59,7 @@ constexpr uint8_t EXTRA_MESSAGE_IDENTIFIER     = 217;
 constexpr uint8_t EXTRA_MESSAGE_LENGTH_ODYSSEE = 31;
 
 // this will work as long as they will always differ in length
-static ProtocolVersion getVersionByIdentifier(uint8_t identifier, uint8_t length)
+static ProtocolVersion getVersionByIdentifier(uint8_t identifier, uint8_t length, bool useAlternative)
 {
     if (identifier == HMI_MESSAGE_IDENTIFIER)
     {
@@ -69,6 +70,10 @@ static ProtocolVersion getVersionByIdentifier(uint8_t identifier, uint8_t length
             case HMI_MESSAGE_LENGTH_ODYSSEE:
                 return PROTOCOL_ODYSSEE;
             case HMI_MESSAGE_LENGTH_LEGACY:
+                if (useAlternative)
+                {
+                    return PROTOCOL_LEGACY_ALTERNATIVE;
+                }
                 return PROTOCOL_LEGACY;
             default:
                 break;
@@ -83,6 +88,10 @@ static ProtocolVersion getVersionByIdentifier(uint8_t identifier, uint8_t length
             case MAIN_MESSAGE_LENGTH_ODYSSEE:
                 return PROTOCOL_ODYSSEE;
             case MAIN_MESSAGE_LENGTH_LEGACY:
+                if (useAlternative)
+                {
+                    return PROTOCOL_LEGACY_ALTERNATIVE;
+                }
                 return PROTOCOL_LEGACY;
             default:
                 break;
@@ -97,6 +106,10 @@ static ProtocolVersion getVersionByIdentifier(uint8_t identifier, uint8_t length
             case ENERGY_MESSAGE_LENGTH_ODYSSEE:
                 return PROTOCOL_ODYSSEE;
             case ENERGY_MESSAGE_LENGTH_LEGACY:
+                if (useAlternative)
+                {
+                    return PROTOCOL_LEGACY_ALTERNATIVE;
+                }
                 return PROTOCOL_LEGACY;
             default:
                 break;
@@ -111,6 +124,10 @@ static ProtocolVersion getVersionByIdentifier(uint8_t identifier, uint8_t length
             case ERROR_MESSAGE_LENGTH_ODYSSEE:
                 return PROTOCOL_ODYSSEE;
             case ERROR_MESSAGE_LENGTH_LEGACY:
+                if (useAlternative)
+                {
+                    return PROTOCOL_LEGACY_ALTERNATIVE;
+                }
                 return PROTOCOL_LEGACY;
             default:
                 break;
@@ -140,6 +157,7 @@ static uint8_t lengthByFrameIdAndProtocol(const uint8_t frameId, const ProtocolV
             case PROTOCOL_ODYSSEE:
                 return HMI_MESSAGE_LENGTH_ODYSSEE;
             case PROTOCOL_LEGACY:
+            case PROTOCOL_LEGACY_ALTERNATIVE:
             default:
                 return HMI_MESSAGE_LENGTH_LEGACY;
         }
@@ -153,6 +171,7 @@ static uint8_t lengthByFrameIdAndProtocol(const uint8_t frameId, const ProtocolV
             case PROTOCOL_ODYSSEE:
                 return MAIN_MESSAGE_LENGTH_ODYSSEE;
             case PROTOCOL_LEGACY:
+            case PROTOCOL_LEGACY_ALTERNATIVE:
             default:
                 return MAIN_MESSAGE_LENGTH_LEGACY;
         }
@@ -166,6 +185,7 @@ static uint8_t lengthByFrameIdAndProtocol(const uint8_t frameId, const ProtocolV
             case PROTOCOL_ODYSSEE:
                 return ENERGY_MESSAGE_LENGTH_ODYSSEE;
             case PROTOCOL_LEGACY:
+            case PROTOCOL_LEGACY_ALTERNATIVE:
             default:
                 return ENERGY_MESSAGE_LENGTH_LEGACY;
         }
@@ -179,6 +199,7 @@ static uint8_t lengthByFrameIdAndProtocol(const uint8_t frameId, const ProtocolV
             case PROTOCOL_ODYSSEE:
                 return ERROR_MESSAGE_LENGTH_ODYSSEE;
             case PROTOCOL_LEGACY:
+            case PROTOCOL_LEGACY_ALTERNATIVE:
             default:
                 return ERROR_MESSAGE_LENGTH_LEGACY;
         }
@@ -196,6 +217,8 @@ static const char* protocolVersionStr(ProtocolVersion version)
     {
         case PROTOCOL_LEGACY:
             return reinterpret_cast<const char*>(mqtt::ENUM_AQUAMQTT_PROTOCOL_LEGACY);
+        case PROTOCOL_LEGACY_ALTERNATIVE:
+            return reinterpret_cast<const char*>(mqtt::ENUM_AQUAMQTT_PROTOCOL_LEGACY_ALT);
         case PROTOCOL_NEXT:
             return reinterpret_cast<const char*>(mqtt::ENUM_AQUAMQTT_PROTOCOL_NEXT);
         case PROTOCOL_ODYSSEE:
@@ -248,10 +271,10 @@ static const char* operationModeStr(HMIOperationMode mode)
 
 enum HMIOperationType : int
 {
-    OT_UNKNOWN = -1,
+    OT_UNKNOWN        = -1,
     OT_OFF_PEAK_HOURS = 0,
-    OT_ALWAYS_ON = 1,
-    OT_TIMER = 2,
+    OT_ALWAYS_ON      = 1,
+    OT_TIMER          = 2,
 
 };
 

AquaMQTT/lib/AtlanticSerialProtocol/include/message/legacy_alternative/HMIMessage.h

@@ -0,0 +1,59 @@
+#ifndef AQUAMQTT_LEGACYALTHMIMESSAGE_H
+#define AQUAMQTT_LEGACYALTHMIMESSAGE_H
+
+#include <cstring>
+#include <set>
+
+#include "message/IHMIMessage.h"
+
+namespace aquamqtt::message::legacyalt
+{
+class HMIMessage : public IHMIMessage
+{
+public:
+    explicit HMIMessage(uint8_t* data, const uint8_t* previous = nullptr);
+
+    ~HMIMessage() override = default;
+
+    uint8_t getLength() override;
+
+    void setDateMonthAndYear(uint8_t month, uint16_t year) const override;
+
+    uint8_t  getAttr(HMI_ATTR_U8 attr) override;
+    uint16_t getAttr(HMI_ATTR_U16 attr) override;
+    bool     getAttr(HMI_ATTR_BOOL attr) override;
+    float    getAttr(HMI_ATTR_FLOAT attr) override;
+    void     getAttr(HMI_ATTR_STR attr, char* buffer) override;
+
+    void setAttr(HMI_ATTR_U8 attr, uint8_t value) override;
+    void setAttr(HMI_ATTR_U16 attr, uint16_t value) override;
+    void setAttr(HMI_ATTR_BOOL attr, bool value) override;
+    void setAttr(HMI_ATTR_FLOAT attr, float value) override;
+
+    bool hasAttr(HMI_ATTR_U8 attr) const override;
+    bool hasAttr(HMI_ATTR_U16 attr) const override;
+    bool hasAttr(HMI_ATTR_BOOL attr) const override;
+    bool hasAttr(HMI_ATTR_FLOAT attr) const override;
+    bool hasAttr(HMI_ATTR_STR attr) const override;
+
+    bool hasChanged(HMI_ATTR_U8 attr) const override;
+    bool hasChanged(HMI_ATTR_U16 attr) const override;
+    bool hasChanged(HMI_ATTR_BOOL attr) const override;
+    bool hasChanged(HMI_ATTR_FLOAT attr) const override;
+    bool hasChanged(HMI_ATTR_STR attr) const override;
+
+private:
+    void compareWith(const uint8_t* data);
+
+    bool                     mCreatedWithoutPrevious;
+    std::set<HMI_ATTR_U8>    mHasChangedU8;
+    std::set<HMI_ATTR_U16>   mHasChangedU16;
+    std::set<HMI_ATTR_BOOL>  mHasChangedBool;
+    std::set<HMI_ATTR_FLOAT> mHasChangedFloat;
+    std::set<HMI_ATTR_STR>   mHasChangedStr;
+
+    uint8_t* mData;
+};
+}  // namespace aquamqtt::message::legacy
+
+#endif  // AQUAMQTT_LEGACYALTHMIMESSAGE_H

AquaMQTT/lib/AtlanticSerialProtocol/include/message/legacy_alternative/MainStatusMessage.h

@@ -0,0 +1,55 @@
+#ifndef AQUAMQTT_LEGACYALTMAINSTATUSMESSAGE_H
+#define AQUAMQTT_LEGACYALTMAINSTATUSMESSAGE_H
+
+#include <cstring>
+#include <memory>
+#include <set>
+
+#include "message/IMainMessage.h"
+
+namespace aquamqtt::message::legacyalt
+{
+class MainStatusMessage : public IMainMessage
+{
+public:
+    explicit MainStatusMessage(uint8_t* data, const uint8_t* previous = nullptr);
+
+    ~MainStatusMessage() override = default;
+
+    uint8_t getLength() override;
+
+    float    getAttr(MAIN_ATTR_FLOAT attr) override;
+    bool     getAttr(MAIN_ATTR_BOOL attr) override;
+    uint8_t  getAttr(MAIN_ATTR_U8 attr) override;
+    uint16_t getAttr(MAIN_ATTR_U16 attr) override;
+
+    void setAttr(MAIN_ATTR_FLOAT attr, float value) override;
+    void setAttr(MAIN_ATTR_BOOL attr, bool value) override;
+    void setAttr(MAIN_ATTR_U8 attr, uint8_t value) override;
+    void setAttr(MAIN_ATTR_U16 attr, uint16_t value) override;
+
+    bool hasAttr(MAIN_ATTR_FLOAT attr) const override;
+    bool hasAttr(MAIN_ATTR_BOOL attr) const override;
+    bool hasAttr(MAIN_ATTR_U8 attr) const override;
+    bool hasAttr(MAIN_ATTR_U16 attr) const override;
+
+    bool hasChanged(MAIN_ATTR_FLOAT attr) const override;
+    bool hasChanged(MAIN_ATTR_BOOL attr) const override;
+    bool hasChanged(MAIN_ATTR_U8 attr) const override;
+    bool hasChanged(MAIN_ATTR_U16 attr) const override;
+
+private:
+    void compareWith(const uint8_t* data);
+
+    bool     mCreatedWithoutPrevious;
+    uint8_t* mData;
+
+    std::set<MAIN_ATTR_FLOAT> mHasChangedFloat;
+    std::set<MAIN_ATTR_BOOL>  mHasChangedBool;
+    std::set<MAIN_ATTR_U8>    mHasChangedU8;
+    std::set<MAIN_ATTR_U16>   mHasChangedU16;
+};
+
+}  // namespace aquamqtt::message::legacy
+
+#endif  // AQUAMQTT_LEGACYALTMAINSTATUSMESSAGE_H

AquaMQTT/lib/AtlanticSerialProtocol/include/mqtt/MQTTDefinitions.h

@@ -20,9 +20,10 @@ constexpr char ENUM_UNKNOWN[] = { "UNKNOWN" };
 constexpr char ENUM_AQUAMQTT_MODE_LISTENER[] = { "LISTENER" };
 constexpr char ENUM_AQUAMQTT_MODE_MITM[]     = { "MITM" };
 
-constexpr char ENUM_AQUAMQTT_PROTOCOL_LEGACY[]  = { "LEGACY" };
-constexpr char ENUM_AQUAMQTT_PROTOCOL_NEXT[]    = { "NEXT" };
-constexpr char ENUM_AQUAMQTT_PROTOCOL_ODYSSEE[] = { "ODYSSEE" };
+constexpr char ENUM_AQUAMQTT_PROTOCOL_LEGACY[]     = { "LEGACY" };
+constexpr char ENUM_AQUAMQTT_PROTOCOL_LEGACY_ALT[] = { "LEGACY_ALT" };
+constexpr char ENUM_AQUAMQTT_PROTOCOL_NEXT[]       = { "NEXT" };
+constexpr char ENUM_AQUAMQTT_PROTOCOL_ODYSSEE[]    = { "ODYSSEE" };
 
 constexpr char ENUM_BRAND_ATLANTIC[] = { "Atlantic" };
 constexpr char ENUM_BRAND_THERMOR[]  = { "Thermor" };