jeans/openHASP
jeans/openHASP
1
0
Fork 0
mirror of https://github.com/HASwitchPlate/openHASP.git synced 2025-07-25 20:26:41 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fix mDNS on ESP8266

Browse Source
This commit is contained in:
fvanroie 2020-11-20 22:53:40 +01:00
parent ce20726ffb
commit 51423a9f83
2 changed files with 162 additions and 155 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

84
src/hasp_mdns.cpp
View File

@ -1,6 +1,8 @@
/* MIT License - Copyright (c) 2020 Francis Van Roie /* MIT License - Copyright (c) 2020 Francis Van Roie
For full license information read the LICENSE file in the project folder */ For full license information read the LICENSE file in the project folder */
#if HASP_USE_MDNS > 0
#include "ArduinoJson.h" #include "ArduinoJson.h"
#include "ArduinoLog.h" #include "ArduinoLog.h"
@ -21,44 +23,57 @@ uint8_t mdnsEnabled = true;
void mdnsSetup() void mdnsSetup()
{ {
// mdnsSetConfig(settings); // mdnsSetConfig(settings);
mdnsStart(); // mdnsStart(); // Wifis need to call this at connection time!
Log.trace(TAG_MDNS, F("Setup Complete"));
} }
void mdnsStart() void mdnsStart()
{ {
#if HASP_USE_MDNS > 0 if(!mdnsEnabled) {
if(mdnsEnabled) { Log.notice(TAG_MDNS, F("MDNS Responder is disabled"));
return;
}
Log.notice(TAG_MDNS, F("Starting MDNS Responder..."));
#if HASP_USE_MQTT > 0 #if HASP_USE_MQTT > 0
String hasp2Node = mqttGetNodename(); String hasp2Node = mqttGetNodename();
#else #else
String hasp2Node = "unknown"; String hasp2Node = "unknown";
#endif #endif
// Setup mDNS service discovery if enabled
/*if(debugTelnetEnabled) { // Setup mDNS service discovery if enabled
} char buffer[32];
return; snprintf_P(buffer, sizeof(buffer), PSTR("%u.%u.%u"), HASP_VERSION_MAJOR, HASP_VERSION_MINOR, HASP_VERSION_REVISION);
char buffer[128]; uint8_t attempt = 0;
snprintf_P(buffer, sizeof(buffer), PSTR("%u.%u.%u"), HASP_VERSION_MAJOR, HASP_VERSION_MINOR,
HASP_VERSION_REVISION); while(!MDNS.begin(hasp2Node.c_str())) {
MDNS.addServiceTxt(hasp2Node, "tcp", "app_version", buffer); */ if(attempt++ >= 3) {
if(MDNS.begin(hasp2Node.c_str())) {
MDNS.addService(F("http"), F("tcp"), 80);
MDNS.addService(F("telnet"), F("tcp"), 23);
MDNS.addServiceTxt(hasp2Node, F("tcp"), F("app_name"), F("HASP-lvgl"));
/*
addService("arduino", "tcp", port);
addServiceTxt("arduino", "tcp", "tcp_check", "no");
addServiceTxt("arduino", "tcp", "ssh_upload", "no");
addServiceTxt("arduino", "tcp", "board", ARDUINO_BOARD);
addServiceTxt("arduino", "tcp", "auth_upload", (auth) ? "yes" : "no");*/
Log.trace(TAG_MDNS, F("Responder started"));
} else {
Log.error(TAG_MDNS, F("Responder failed to start %s"), hasp2Node.c_str()); Log.error(TAG_MDNS, F("Responder failed to start %s"), hasp2Node.c_str());
}; return;
} }
#endif
// try another hostname
hasp2Node = mqttGetNodename();
hasp2Node += F("_");
hasp2Node += String(attempt);
Log.verbose(TAG_MDNS, F("Trying hostname %s"), hasp2Node.c_str());
};
MDNS.addService(F("http"), F("tcp"), 80);
MDNS.addServiceTxt(F("http"), F("tcp"), F("app_version"), buffer);
MDNS.addServiceTxt(F("http"), F("tcp"), F("app_name"), F("HASP-lvgl"));
// if(debugTelnetEnabled) {
MDNS.addService(F("telnet"), F("tcp"), 23);
// }
// MDNS.addService(F("arduino"), F("tcp"), port);
// MDNS.addServiceTxt(F("arduino"), F("tcp"), "tcp_check", "no");
// MDNS.addServiceTxt(F("arduino"), F("tcp"), "ssh_upload", "no");
// MDNS.addServiceTxt(F("arduino"), F("tcp"), "board", ARDUINO_BOARD);
// addServiceTxt("arduino", F("tcp"), "auth_upload", (auth) ? "yes" : "no");
Log.trace(TAG_MDNS, F("Responder started"));
} }
void mdnsLoop() void mdnsLoop()
@ -88,12 +103,9 @@ bool mdnsGetConfig(const JsonObject & settings)
return changed; return changed;
} }
/** Set MDNS Configuration. /**
* * Reads the settings from json and sets the application variables.
* Read the settings from json and sets the application variables.
*
* @note: data pixel should be formated to uint32_t RGBA. Imagemagick requirements. * @note: data pixel should be formated to uint32_t RGBA. Imagemagick requirements.
*
* @param[in] settings JsonObject with the config settings. * @param[in] settings JsonObject with the config settings.
**/ **/
bool mdnsSetConfig(const JsonObject & settings) bool mdnsSetConfig(const JsonObject & settings)
@ -104,4 +116,6 @@ bool mdnsSetConfig(const JsonObject & settings)
changed |= configSet(mdnsEnabled, settings[FPSTR(F_CONFIG_ENABLE)], F("mdnsEnabled")); changed |= configSet(mdnsEnabled, settings[FPSTR(F_CONFIG_ENABLE)], F("mdnsEnabled"));
return changed; return changed;
} }
#endif // HASP_USE_MDNS

233
src/hasp_mqtt.cpp
View File

@ -116,14 +116,28 @@ const String mqttLightBrightSubscription = "hasp/" + String(haspGetNodename())
PubSubClient mqttClient(mqttNetworkClient); PubSubClient mqttClient(mqttNetworkClient);
static void mqttResult(bool result, const char * topic, const char * payload)
{
if(result) {
Log.notice(TAG_MQTT_PUB, F("%s => %s"), topic, payload);
} else {
Log.error(TAG_MQTT_PUB, F("Failed : %s => %s"), topic, payload);
}
}
static bool mqttPublish(const char * topic, const char * payload, size_t len)
{
if(mqttIsConnected()) {
return mqttClient.publish(topic, (uint8_t *)payload, len, false);
}
Log.error(TAG_MQTT, F("Not connected"));
return false;
}
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
// Send changed values OUT // Send changed values OUT
void mqtt_log_no_connection()
{
Log.error(TAG_MQTT, F("Not connected"));
}
bool IRAM_ATTR mqttIsConnected() bool IRAM_ATTR mqttIsConnected()
{ {
return mqttEnabled && mqttClient.connected(); return mqttEnabled && mqttClient.connected();
@ -138,52 +152,57 @@ void IRAM_ATTR mqtt_send_state(const __FlashStringHelper * subtopic, const char
// light = 0/1 // light = 0/1
// brightness = 100 // brightness = 100
if(mqttIsConnected()) { // if(mqttIsConnected()) {
char topic[64]; char tmp_topic[strlen(mqttNodeTopic) + 20];
snprintf_P(topic, sizeof(topic), PSTR("%sstate/%s"), mqttNodeTopic, subtopic); size_t len = snprintf_P(tmp_topic, sizeof(tmp_topic), PSTR("%sstate/%s"), mqttNodeTopic, subtopic);
mqttClient.publish(topic, payload); bool res = mqttPublish(tmp_topic, payload, len);
} else { mqttResult(res, tmp_topic, payload);
return mqtt_log_no_connection(); // } else {
} // return mqtt_log_no_connection();
// }
// Log after char buffers are cleared // Log after char buffers are cleared
Log.notice(TAG_MQTT_PUB, F("%sstate/%S = %s"), mqttNodeTopic, subtopic, payload); // Log.notice(TAG_MQTT_PUB, F("%sstate/%S = %s"), mqttNodeTopic, subtopic, payload);
} }
void mqtt_send_input(uint8_t id, const char * payload) void mqtt_send_input(uint8_t id, const char * payload)
{ {
// Log.verbose(TAG_MQTT,F("TST: %sstate/input%u = %s"), mqttNodeTopic, id, payload); // to be removed // Log.verbose(TAG_MQTT,F("TST: %sstate/input%u = %s"), mqttNodeTopic, id, payload); // to be removed
if(mqttIsConnected()) { // if(mqttIsConnected()) {
char topic[64]; char tmp_topic[strlen(mqttNodeTopic) + 20];
snprintf_P(topic, sizeof(topic), PSTR("%sstate/input%u"), mqttNodeTopic, id); size_t len = snprintf_P(tmp_topic, sizeof(tmp_topic), PSTR("%sstate/input%u"), mqttNodeTopic, id);
mqttClient.publish(topic, payload); bool res = mqttPublish(tmp_topic, payload, len);
} else { mqttResult(res, tmp_topic, payload);
return mqtt_log_no_connection(); // } else {
} // return mqtt_log_no_connection();
// }
// Log after char buffers are cleared // Log after char buffers are cleared
Log.notice(TAG_MQTT_PUB, F("%sstate/input%u = %s"), mqttNodeTopic, id, payload); // Log.notice(TAG_MQTT_PUB, F("%sstate/input%u = %s"), mqttNodeTopic, id, payload);
} }
void IRAM_ATTR mqtt_send_obj_attribute_str(uint8_t pageid, uint8_t btnid, const char * attribute, const char * data) void IRAM_ATTR mqtt_send_obj_attribute_str(uint8_t pageid, uint8_t btnid, const char * attribute, const char * data)
{ {
if(mqttIsConnected()) { // if(mqttIsConnected()) {
char payload[128]; char tmp_topic[strlen(mqttNodeTopic) + 12];
char topic[64]; char payload[25 + strlen(data) + strlen(attribute)];
snprintf_P(topic, sizeof(topic), PSTR("%sstate/json"), mqttNodeTopic); snprintf_P(tmp_topic, sizeof(tmp_topic), PSTR("%sstate/json"), mqttNodeTopic);
unsigned int len = unsigned int len =
snprintf_P(payload, sizeof(payload), PSTR("{\"p[%u].b[%u].%s\":\"%s\"}"), pageid, btnid, attribute, data); snprintf_P(payload, sizeof(payload), PSTR("{\"p[%u].b[%u].%s\":\"%s\"}"), pageid, btnid, attribute, data);
mqttClient.publish(topic, (uint8_t *)payload, len, false); bool res = mqttPublish(tmp_topic, payload, len); //, false);
} else { mqttResult(res, tmp_topic, payload);
return mqtt_log_no_connection();
} // } else {
// return mqtt_log_no_connection();
// }
// Log after char buffers are cleared // Log after char buffers are cleared
Log.notice(TAG_MQTT_PUB, F("%sstate/json = {\"p[%u].b[%u].%s\":\"%s\"}"), mqttNodeTopic, pageid, btnid, attribute, // Log.notice(TAG_MQTT_PUB, F("%sstate/json = {\"p[%u].b[%u].%s\":\"%s\"}"), mqttNodeTopic, pageid, btnid,
data); // attribute,
// data);
} }
void mqtt_send_statusupdate() void mqtt_send_statusupdate()
@ -228,70 +247,45 @@ void mqtt_send_statusupdate()
mqtt_send_state(F("statusupdate"), data); mqtt_send_state(F("statusupdate"), data);
debugLastMillis = millis(); debugLastMillis = millis();
/* if(updateEspAvailable) { /* if(updateEspAvailable) {
mqttStatusPayload += F("\"updateEspAvailable\":true,"); mqttStatusPayload += F("\"updateEspAvailable\":true,");
} else { } else {
mqttStatusPayload += F("\"updateEspAvailable\":false,"); mqttStatusPayload += F("\"updateEspAvailable\":false,");
} }
if(lcdConnected) { */
mqttStatusPayload += F("\"lcdConnected\":true,");
} else {
mqttStatusPayload += F("\"lcdConnected\":false,");
}
mqttStatusPayload += F("\"lcdVersion\":\"");
mqttStatusPayload += String(lcdVersion);
*/
// mqttClient.publish(mqttSensorTopic, mqttStatusPayload);
// mqttClient.publish(mqttStatusTopic, "ON", true); //, 1);
// debugPrintln(String(F("status update: ")) + String(mqttStatusPayload));
// debugPrintln(String(F("binary_sensor state: [")) + mqttStatusTopic + "] : [ON]");
} }
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
// Receive incoming messages // Receive incoming messages
static void mqtt_message_cb(char * topic, byte * payload, unsigned int length) static void mqtt_message_cb(char * topic, byte * payload, unsigned int length)
{ // Handle incoming commands from MQTT { // Handle incoming commands from MQTT
if(length >= MQTT_MAX_PACKET_SIZE) { if(length >= mqttClient.getBufferSize()) {
Log.error(TAG_MQTT_RCV, F("Payload too long (%d bytes)"), length); Log.error(TAG_MQTT_RCV, F("Payload too long (%d bytes)"), length);
return; return;
} else {
payload[length] = '\0';
} }
payload[length] = '\0';
// String strTopic((char *)0);
// strTopic.reserve(MQTT_MAX_PACKET_SIZE);
// Incoming Namespace (replace /device/ with /group/ for group commands) // Incoming Namespace (replace /device/ with /group/ for group commands)
// '[...]/device/command' -m '' = No command requested, respond with mqttStatusUpdate() // '[...]/device/command' -m '' = No command requested, respond with mqttStatusUpdate()
// '[...]/device/command' -m 'dim=50' = nextionSendCmd("dim=50") // '[...]/device/command' -m 'dim=50' = nextionSendCmd("dim=50")
// '[...]/device/command/json' -m '["dim=5", "page 1"]' = nextionSendCmd("dim=50"), nextionSendCmd("page 1")
// '[...]/device/command/page' -m '1' = nextionSendCmd("page 1")
// '[...]/device/command/statusupdate' -m '' = mqttStatusUpdate()
// '[...]/device/command/lcdupdate' -m 'http://192.168.0.10/local/HASwitchPlate.tft' =
// nextionStartOtaDownload("http://192.168.0.10/local/HASwitchPlate.tft")
// '[...]/device/command/lcdupdate' -m '' = nextionStartOtaDownload("lcdFirmwareUrl")
// '[...]/device/command/espupdate' -m 'http://192.168.0.10/local/HASwitchPlate.ino.d1_mini.bin' =
// espStartOta("http://192.168.0.10/local/HASwitchPlate.ino.d1_mini.bin")
// '[...]/device/command/espupdate' -m '' = espStartOta("espFirmwareUrl")
// '[...]/device/command/p[1].b[4].txt' -m '' = nextionGetAttr("p[1].b[4].txt")
// '[...]/device/command/p[1].b[4].txt' -m '"Lights On"' = nextionSetAttr("p[1].b[4].txt", "\"Lights On\"")
// char * topic = (char *)topic_p;
Log.notice(TAG_MQTT_RCV, F("%s = %s"), topic, (char *)payload); Log.notice(TAG_MQTT_RCV, F("%s = %s"), topic, (char *)payload);
// Node topic
if(topic == strstr(topic, mqttNodeTopic)) { // startsWith mqttNodeTopic if(topic == strstr(topic, mqttNodeTopic)) { // startsWith mqttNodeTopic
topic += strlen(mqttNodeTopic); // short topic
// Node topic
topic += strlen(mqttNodeTopic); // shorten topic
} else if(topic == strstr(topic, mqttGroupTopic)) { // startsWith mqttGroupTopic
// Group topic // Group topic
} else if(topic == strstr(topic, mqttGroupTopic)) { // startsWith mqttGroupTopic topic += strlen(mqttGroupTopic); // shorten topic
topic += strlen(mqttGroupTopic); // short topic
dispatchTopicPayload(topic, (char *)payload); dispatchTopicPayload(topic, (char *)payload);
return; return;
// Other topic
} else { } else {
// Other topic
Log.error(TAG_MQTT, F("Message received with invalid topic")); Log.error(TAG_MQTT, F("Message received with invalid topic"));
return; return;
} }
@ -300,11 +294,12 @@ static void mqtt_message_cb(char * topic, byte * payload, unsigned int length)
if(!strcmp_P(topic, PSTR("status"))) { // endsWith status if(!strcmp_P(topic, PSTR("status"))) { // endsWith status
if(!strcasecmp_P((char *)payload, PSTR("OFF"))) { if(!strcasecmp_P((char *)payload, PSTR("OFF"))) {
{ {
char topicBuffer[128]; char tmp_topic[strlen(mqttNodeTopic) + 8];
snprintf_P(topicBuffer, sizeof(topicBuffer), PSTR("%sstatus"), mqttNodeTopic); snprintf_P(tmp_topic, sizeof(tmp_topic), PSTR("%sstatus"), mqttNodeTopic);
mqttClient.publish(topicBuffer, "ON", true); // Literal String bool res = mqttPublish(tmp_topic, "ON", 3); //, true); // Literal String
mqttResult(res, tmp_topic, "ON");
} }
Log.notice(TAG_MQTT, F("binary_sensor state: [status] : ON")); // Log.notice(TAG_MQTT, F("binary_sensor state: [status] : ON"));
} else { } else {
// already ON // already ON
@ -312,37 +307,16 @@ static void mqtt_message_cb(char * topic, byte * payload, unsigned int length)
} else { } else {
dispatchTopicPayload(topic, (char *)payload); dispatchTopicPayload(topic, (char *)payload);
} }
/*
String strPayload = (char *)payload;
if(strTopic == mqttLightBrightCommandTopic) { // change the brightness from the light topic
int panelDim = map(strPayload.toInt(), 0, 255, 0, 100);
// nextionSetAttr("dim", String(panelDim));
// nextionSendCmd("dims=dim");
// mqttClient.publish(mqttLightBrightStateTopic, strPayload);
} else if(strTopic == mqttLightCommandTopic &&
strPayload == F("OFF")) { // set the panel dim OFF from the light topic, saving current dim level
first
// nextionSendCmd("dims=dim");
// nextionSetAttr("dim", "0");
mqttClient.publish(mqttLightStateTopic.c_str(), PSTR("OFF"));
} else if(strTopic == mqttLightCommandTopic &&
strPayload == F("ON")) { // set the panel dim ON from the light topic, restoring saved dim level
// nextionSendCmd("dim=dims");
mqttClient.publish(mqttLightStateTopic.c_str(), PSTR("ON"));
}
*/
} }
void mqttSubscribeTo(const char * format, const char * data) void mqttSubscribeTo(const char * format, const char * data)
{ {
char topic[64]; char tmp_topic[strlen(format) + 2 + strlen(data)];
snprintf_P(topic, sizeof(topic), format, data); snprintf_P(tmp_topic, sizeof(tmp_topic), format, data);
if(mqttClient.subscribe(topic)) { if(mqttClient.subscribe(tmp_topic)) {
Log.verbose(TAG_MQTT, F(" * Subscribed to %s"), topic); Log.verbose(TAG_MQTT, F(" * Subscribed to %s"), tmp_topic);
} else { } else {
Log.error(TAG_MQTT, F("Failed to subscribe to %s"), topic); Log.error(TAG_MQTT, F("Failed to subscribe to %s"), tmp_topic);
} }
} }
@ -361,45 +335,47 @@ void mqttReconnect()
Log.trace(TAG_MQTT, mqttClientId); Log.trace(TAG_MQTT, mqttClientId);
} }
mqttClient.setServer(mqttServer, 1883);
// Attempt to connect and set LWT and Clean Session // Attempt to connect and set LWT and Clean Session
snprintf_P(buffer, sizeof(buffer), PSTR("%sstatus"), mqttNodeTopic); snprintf_P(buffer, sizeof(buffer), PSTR("%sstatus"), mqttNodeTopic);
if(!mqttClient.connect(mqttClientId, mqttUser, mqttPassword, buffer, 0, false, "OFF", true)) { if(!mqttClient.connect(mqttClientId, mqttUser, mqttPassword, buffer, 0, false, "OFF", true)) {
// Retry until we give up and restart after connectTimeout seconds // Retry until we give up and restart after connectTimeout seconds
mqttReconnectCount++; mqttReconnectCount++;
snprintf_P(buffer, sizeof(buffer), PSTR("%%s"));
switch(mqttClient.state()) { switch(mqttClient.state()) {
case MQTT_CONNECTION_TIMEOUT: case MQTT_CONNECTION_TIMEOUT:
strcat_P(buffer, PSTR("Server didn't respond within the keepalive time")); snprintf_P(buffer, sizeof(buffer), PSTR("Server didn't respond within the keepalive time"));
break; break;
case MQTT_CONNECTION_LOST: case MQTT_CONNECTION_LOST:
strcat_P(buffer, PSTR("Network connection was broken")); snprintf_P(buffer, sizeof(buffer), PSTR("Network connection was broken"));
break; break;
case MQTT_CONNECT_FAILED: case MQTT_CONNECT_FAILED:
strcat_P(buffer, PSTR("Network connection failed")); snprintf_P(buffer, sizeof(buffer), PSTR("Network connection failed"));
break; break;
case MQTT_DISCONNECTED: case MQTT_DISCONNECTED:
strcat_P(buffer, PSTR("Client is disconnected cleanly")); snprintf_P(buffer, sizeof(buffer), PSTR("Client is disconnected cleanly"));
break; break;
case MQTT_CONNECTED: case MQTT_CONNECTED:
strcat_P(buffer, PSTR("(Client is connected")); snprintf_P(buffer, sizeof(buffer), PSTR("(Client is connected"));
break; break;
case MQTT_CONNECT_BAD_PROTOCOL: case MQTT_CONNECT_BAD_PROTOCOL:
strcat_P(buffer, PSTR("Server doesn't support the requested version of MQTT")); snprintf_P(buffer, sizeof(buffer), PSTR("Server doesn't support the requested version of MQTT"));
break; break;
case MQTT_CONNECT_BAD_CLIENT_ID: case MQTT_CONNECT_BAD_CLIENT_ID:
strcat_P(buffer, PSTR("Server rejected the client identifier")); snprintf_P(buffer, sizeof(buffer), PSTR("Server rejected the client identifier"));
break; break;
case MQTT_CONNECT_UNAVAILABLE: case MQTT_CONNECT_UNAVAILABLE:
strcat_P(buffer, PSTR("Server was unable to accept the connection")); snprintf_P(buffer, sizeof(buffer), PSTR("Server was unable to accept the connection"));
break; break;
case MQTT_CONNECT_BAD_CREDENTIALS: case MQTT_CONNECT_BAD_CREDENTIALS:
strcat_P(buffer, PSTR("Username or Password rejected")); snprintf_P(buffer, sizeof(buffer), PSTR("Username or Password rejected"));
break; break;
case MQTT_CONNECT_UNAUTHORIZED: case MQTT_CONNECT_UNAUTHORIZED:
strcat_P(buffer, PSTR("Client was not authorized to connect")); snprintf_P(buffer, sizeof(buffer), PSTR("Client was not authorized to connect"));
break; break;
default: default:
strcat_P(buffer, PSTR("Unknown failure")); snprintf_P(buffer, sizeof(buffer), PSTR("Unknown failure"));
} }
Log.warning(TAG_MQTT, buffer); Log.warning(TAG_MQTT, buffer);
@ -418,8 +394,7 @@ void mqttReconnect()
mqttStateJSONTopic = prefix + F("/state/json"); mqttStateJSONTopic = prefix + F("/state/json");
mqttCommandTopic = prefix + F("/page"); mqttCommandTopic = prefix + F("/page");
mqttGroupCommandTopic = "hasp/" + mqttGroupName + "/page"; mqttGroupCommandTopic = "hasp/" + mqttGroupName + "/page";
mqttCommandTopic = prefix + F("/command");
mqttGroupCommandTopic = "hasp/" + mqttGroupName + "/command";
mqttSensorTopic = prefix + F("/sensor"); mqttSensorTopic = prefix + F("/sensor");
mqttLightCommandTopic = prefix + F("/light/switch"); mqttLightCommandTopic = prefix + F("/light/switch");
mqttLightStateTopic = prefix + F("/light/state"); mqttLightStateTopic = prefix + F("/light/state");
@ -427,8 +402,11 @@ void mqttReconnect()
mqttLightBrightStateTopic = prefix + F("/brightness/state"); mqttLightBrightStateTopic = prefix + F("/brightness/state");
mqttMotionStateTopic = prefix + F("/motion/state"); mqttMotionStateTopic = prefix + F("/motion/state");
*/ */
// Set keepAlive, cleanSession, timeout // Set keepAlive, cleanSession, timeout
// mqttClient.setOptions(30, true, 5000); // mqttClient.setOptions(30, true, 5000);
mqttClient.setKeepAlive(30);
mqttClient.setSocketTimeout(5000);
// declare LWT // declare LWT
// mqttClient.setWill(mqttStatusTopic.c_str(), "OFF"); // mqttClient.setWill(mqttStatusTopic.c_str(), "OFF");
@ -465,13 +443,23 @@ void mqttReconnect()
mqtt_send_statusupdate(); mqtt_send_statusupdate();
} }
void mqttPreSetup()
{
// mqttClient.setCallback(mqtt_message_cb);
// mqttClient.setBufferSize(1024);
}
void mqttSetup() void mqttSetup()
{ {
mqttEnabled = strlen(mqttServer) > 0 && mqttPort > 0; mqttEnabled = strlen(mqttServer) > 0 && mqttPort > 0;
if(mqttEnabled) { if(mqttEnabled) {
mqttClient.setServer(mqttServer, 1883); mqttClient.setServer(mqttServer, 1883);
mqttClient.setCallback(mqtt_message_cb); mqttClient.setCallback(mqtt_message_cb);
Log.trace(TAG_MQTT, F("Setup Complete")); // if(!mqttClient.setBufferSize(1024)) {
// Log.error(TAG_MQTT, F("Buffer allocation failed"));
// } else {
Log.trace(TAG_MQTT, F("Setup Complete: %d bytes"), mqttClient.getBufferSize());
// }
} else { } else {
Log.warning(TAG_MQTT, F("Broker not configured")); Log.warning(TAG_MQTT, F("Broker not configured"));
} }
@ -495,13 +483,18 @@ String mqttGetNodename()
void mqttStop() void mqttStop()
{ {
if(mqttEnabled && mqttClient.connected()) { if(mqttEnabled && mqttClient.connected()) {
char topicBuffer[128]; char tmp_topic[strlen(mqttNodeTopic) + 8];
char tmp_payload[32];
Log.notice(TAG_MQTT, F("Disconnecting from broker..."));
snprintf_P(topicBuffer, sizeof(topicBuffer), PSTR("%sstatus"), mqttNodeTopic); size_t len;
mqttClient.publish(topicBuffer, "OFF"); snprintf_P(tmp_topic, sizeof(tmp_topic), PSTR("%sstatus"), mqttNodeTopic);
len = snprintf_P(tmp_payload, sizeof(tmp_topic), PSTR("OFF"), mqttNodeTopic);
mqttPublish(tmp_topic, tmp_payload, len);
snprintf_P(topicBuffer, sizeof(topicBuffer), PSTR("%ssensor"), mqttNodeTopic); snprintf_P(tmp_topic, sizeof(tmp_topic), PSTR("%ssensor"), mqttNodeTopic);
mqttClient.publish(topicBuffer, "{\"status\": \"unavailable\"}"); len = snprintf_P(tmp_payload, sizeof(tmp_topic), PSTR("{\"status\": \"unavailable\"}"), mqttNodeTopic);
mqttPublish(tmp_topic, tmp_payload, len);
mqttClient.disconnect(); mqttClient.disconnect();
Log.trace(TAG_MQTT, F("Disconnected from broker")); Log.trace(TAG_MQTT, F("Disconnected from broker"));