ArduinoLibraries/MQTTDevice.cpp at main · Robert1991/ArduinoLibraries · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
#include "MQTTDevice.h"

// Device
MQTTDeviceClassificationFactory::MQTTDeviceClassificationFactory(String deviceUniqueId) {
  this->deviceUniqueId = deviceUniqueId;
}

MQTTDevice::MQTTDevice(MQTTDeviceClassificationFactory *deviceClassFactory, MQTTDeviceInfo deviceInfo) {
  MQTTDeviceClassification deviceClass = deviceClassFactory->create();
  assignDeviceInfos(deviceClass, deviceInfo);
}

void MQTTDevice::assignDeviceInfos(MQTTDeviceClassification deviceClass, MQTTDeviceInfo deviceInfo) {
  this->deviceEntityName = deviceInfo.deviceName + "_" + deviceClass.sensorType;
  this->sensorHomeAssistantPath =
      deviceInfo.autoDiscoveryPrefix + "/" + deviceClass.deviceType + "/" + deviceEntityName;
  this->stateTopic = sensorHomeAssistantPath + "/state";
  this->autoDiscoveryMQTTConfigureTopic = sensorHomeAssistantPath + "/config";
  this->deviceClassification = deviceClass;
  this->deviceInfo = deviceInfo;
}

int MQTTDevice::publishAutoDiscoveryInfo(DynamicJsonDocument autoConfigureJsonDocument) {
  return publishJsonDocument(autoDiscoveryMQTTConfigureTopic, autoConfigureJsonDocument, true);
}

int MQTTDevice::publishTo(String topic, String payload, bool retain) {
  return mqttClient->publishMessage(topic, payload, retain);
}

int MQTTDevice::publishState(String stateTopicPayload) { return publishTo(stateTopic, stateTopicPayload); }

int MQTTDevice::publishJsonDocument(String stateTopic, DynamicJsonDocument jsonDocument, bool retain) {
  String jsonMessage;
  serializeJson(jsonDocument, jsonMessage);
  logToSerial("Publishing to: ");
  logToSerial(stateTopic);
  logLineToSerial(" with payload: ");
  logLineToSerial(jsonMessage);
  mqttClient->publishMessage(stateTopic, jsonMessage, retain);
  return 1;
}

void MQTTDevice::subscribeTopic(String subscribeTopic) { return mqttClient->subscribeTopic(subscribeTopic); }

DynamicJsonDocument MQTTDevice::createDeviceInfoJsonObject() {
  DynamicJsonDocument autoConfigureJsonDocument = createJsonDocument(540);

  autoConfigureJsonDocument["name"] = deviceEntityName;
  if (deviceClassification.deviceClassIsAvailable) {
    autoConfigureJsonDocument["dev_cla"] = deviceClassification.deviceClass;
  }
  autoConfigureJsonDocument["stat_t"] = stateTopic;
  autoConfigureJsonDocument["uniq_id"] = deviceClassification.sensorUniqueId;
  autoConfigureJsonDocument["dev"]["ids"][0] = deviceInfo.uniqueId;
  autoConfigureJsonDocument["dev"]["name"] = deviceInfo.deviceFriendlyName;
  autoConfigureJsonDocument["dev"]["mdl"] = deviceInfo.deviceType;
  autoConfigureJsonDocument["dev"]["mf"] = deviceInfo.manufacturer;
  autoConfigureJsonDocument["dev"]["sw"] = deviceInfo.firmwareVersion;
  return autoConfigureJsonDocument;
}

DynamicJsonDocument MQTTDevice::createJsonDocument(int capacity) {
  const size_t document_size = JSON_ARRAY_SIZE(1) + JSON_OBJECT_SIZE(4) + JSON_OBJECT_SIZE(12) + capacity;
  DynamicJsonDocument json_document(document_size);
  return json_document;
}

void MQTTDevice::configureViaBroker() {
  DynamicJsonDocument autoConfigureJsonDocument = createDeviceInfoJsonObject();
  autoConfigureJsonDocument = extendAutoDiscoveryInfo(autoConfigureJsonDocument);
  if (publishAutoDiscoveryInfo(autoConfigureJsonDocument)) {
    logLineToSerial("Configure message successfully sent!");
    delay(100);
  }
}

DynamicJsonDocument MQTTDevice::extendAutoDiscoveryInfo(DynamicJsonDocument autoConfigureJsonDocument) {
  return autoConfigureJsonDocument;
}

// Sensor
MQTTSensor::MQTTSensor(MQTTDeviceClassificationFactory *deviceClassFactory, MQTTDeviceInfo deviceInfo)
    : MQTTDevice(deviceClassFactory, deviceInfo) {}

void MQTTSensor::initializePublisher(MessageQueueClient *mqttClient) {
  this->mqttClient = mqttClient;
  setupSensor();
}

void MQTTSensor::configureInTargetPlatform() { configureViaBroker(); }

void MQTTSensor::publishToTargetPlatform() { publishMeasurement(); }

void MQTTSensor::publishFloatValue(float floatValue) {
  char result[8];
  dtostrf(floatValue, 6, 2, result);
  mqttClient->publishMessage(stateTopic, result);
}

void MQTTSensor::publishBinaryMessage(bool on) {
  if (on) {
    String onPayload = "ON";
    mqttClient->publishMessage(stateTopic, onPayload);
  } else {
    String offPayload = "OFF";
    mqttClient->publishMessage(stateTopic, offPayload);
  }
}

void MQTTSensor::setupSensor() {}

bool MQTTSensor::areEqual(float value1, float value2, float maxDifference) {
  if (fabs(value1 - value2) > maxDifference) {
    return false;
  }
  return true;
}

// Actor
MQTTActor::MQTTActor(MQTTDeviceClassificationFactory *deviceClassFactory, MQTTDeviceInfo deviceInfo)
    : MQTTDevice(deviceClassFactory, deviceInfo) {}

void MQTTActor::configureInTargetPlatform() { configureViaBroker(); }

void MQTTActor::initializePublisher(MessageQueueClient *mqttClient) {
  this->mqttClient = mqttClient;
  setupActor();
}

void MQTTActor::publishToTargetPlatform() { reportStatus(); }

void MQTTActor::executeLoopMethod() {}

void MQTTActor::reportStatus() {
  if (actorStatusChanged) {
    reportStatusInformation();
    actorStatusChanged = false;
  }
}

void MQTTActor::reset() { actorStatusChanged = true; }