WiFiThermostat/src/WiFiThermostat/mqtt.ino

#include <string.h>
#include <ctype.h>
char *strlwr(char *str) {
  unsigned char *p = (unsigned char *)str;
  while (*p) {
    *p = tolower((unsigned char) * p);
    p++;
  }
  return str;
}

// MQTT callback
void mqttCallback(char* topic, byte* payload, unsigned int length) {
  //  Serial.print("MQTT payload arrived [");
  //  Serial.print(topic);
  //  Serial.print("] ");
  //  for (int i = 0; i < length; i++) {
  //    Serial.print((char)payload[i]);
  //  }
  //  Serial.println();

  char tmp_topic_pub[51];
  char tmp_payload_pub[51];

  if (strcmp(topic, mqtt_topic_in_cmd) == 0) { //if topic = mqtt_topic_in_cmd
    int len;
    if (length < 101) len = length; // if input is bigger than dest buffer, cut
    else len = 100;

    for (int i = 0; i < len; i++) {
      cmdPayload[i] = (char)payload[i];
    }

    cmdPayload[len] = '\0';
    //    Serial.print("cmdPayload:");
    //    Serial.println(cmdPayload);

    if (serialdebug) {
      Serial.print("received MQTT ");
      Serial.print(mqtt_topic_in_cmd);
      Serial.print(" - \"");
      Serial.print(cmdPayload);
      Serial.println("\"");
    }
    if (mqttdebug) {
      sprintf(tmp_topic_pub, "%s/%s", mqtt_topic_out, "mqtt_received");
      sprintf(tmp_payload_pub, "%s: %s", mqtt_topic_in_cmd, cmdPayload);
      mqttclient.publish(tmp_topic_pub, tmp_payload_pub);
    }

    if (strncmp(cmdPayload, "HEARTBEAT", 9) == 0) {
      Serial.println("resetting HEARTBEAT");
      mqttLastHeartbeat = millis();
      mqttConnected = true;
    }
    else {
      cmdInQueue = true; // payload is processed in "commands"
    }
  }//if topic = mqtt_topic_in_cmd

  if (strcmp(topic, mqtt_topic_in_setTemp) == 0) { //if topic = mqtt_topic_in_setTemp
    int len;
    if (length < 101) len = length; // if input is bigger than dest buffer, cut
    else len = 100;

    for (int i = 0; i < len; i++) {
      cmdPayload[i] = (char)payload[i];
    }
    //cmdPayload[len + 1] = '\0';
    cmdPayload[len] = '\0';
    //    Serial.print("cmdPayload:");
    //    Serial.println(cmdPayload);

    char tmpPayload[11];
    strlcpy(tmpPayload, cmdPayload, 10);

    float valueFloat;
    valueFloat = round(atof(tmpPayload) * 2.0) / 2.0;
    setTempTo(valueFloat);

    if (serialdebug) {
      Serial.print("received MQTT ");
      Serial.print(mqtt_topic_in_setTemp);
      Serial.print(" - \"");
      Serial.print(cmdPayload);
      Serial.println("\"");
    }
    if (mqttdebug) {
      sprintf(tmp_topic_pub, "%s/%s", mqtt_topic_out, "mqtt_received");
      sprintf(tmp_payload_pub, "%s: %s", mqtt_topic_in_setTemp, cmdPayload);
      mqttclient.publish(tmp_topic_pub, tmp_payload_pub);
    }

    cmdInQueue = false; // payload is processed in "commands"
  }//if topic = mqtt_topic_in_setTemp



  if (strcmp(topic, mqtt_topic_in_setMode) == 0) { //if topic = mqtt_topic_in_setMode
    int len;
    if (length < 101) len = length; // if input is bigger than dest buffer, cut
    else len = 100;

    for (int i = 0; i < len; i++) {
      cmdPayload[i] = (char)payload[i];
    }
    //cmdPayload[len + 1] = '\0';
    cmdPayload[len] = '\0';
    //    Serial.print("cmdPayload:");
    //    Serial.println(cmdPayload);

    char tmpPayload[21];
    strlcpy(tmpPayload, cmdPayload, 20);
    strlwr(tmpPayload);

    byte tmpHeatMode;

    char tmpModename0[15];
    char tmpModename1[15];
    strlcpy(tmpModename0, modename0, 14);
    strlcpy(tmpModename1, modename1, 14);
    strlwr(tmpModename0);
    strlwr(tmpModename1);

    if (strcmp(tmpPayload, tmpModename0) == 0) tmpHeatMode = 0;
    else if (strcmp(tmpPayload, tmpModename1) == 0) tmpHeatMode = 1;
    else if (strcmp(tmpPayload, "off") == 0) tmpHeatMode = 0;
    else if (strcmp(tmpPayload, "aus") == 0) tmpHeatMode = 0;
    else if (strcmp(tmpPayload, "on") == 0) tmpHeatMode = 1;
    else if (strcmp(tmpPayload, "ein") == 0) tmpHeatMode = 1;
    else if (atoi(tmpPayload) == 0) tmpHeatMode = 0;
    else if (atoi(tmpPayload) == 1) tmpHeatMode = 1;

    if (serialdebug) {
      Serial.print("set heatmode to: ");
      Serial.println(tmpHeatMode);
    }

    setHeatingmodeTo(tmpHeatMode);

    if (serialdebug) {
      Serial.print("received MQTT ");
      Serial.print(mqtt_topic_in_setMode);
      Serial.print(" - \"");
      Serial.print(cmdPayload);
      Serial.println("\"");
    }
    if (mqttdebug) {
      sprintf(tmp_topic_pub, "%s/%s", mqtt_topic_out, "mqtt_received");
      sprintf(tmp_payload_pub, "%s: %s", mqtt_topic_in_setMode, cmdPayload);
      mqttclient.publish(tmp_topic_pub, tmp_payload_pub);
    }

    cmdInQueue = false; // payload is processed in "commands"
  }//if topic = mqtt_topic_in_setMode


  if (strcmp(topic, mqtt_topic_in_setPreset) == 0) { //if topic = mqtt_topic_in_setPreset
    int len;
    if (length < 101) len = length; // if input is bigger than dest buffer, cut
    else len = 100;

    for (int i = 0; i < len; i++) {
      cmdPayload[i] = (char)payload[i];
    }
    //cmdPayload[len + 1] = '\0';
    cmdPayload[len] = '\0';
    //    Serial.print("cmdPayload:");
    //    Serial.println(cmdPayload);

    char tmpPayload[21];
    strlcpy(tmpPayload, cmdPayload, 20);
    strlwr(tmpPayload);

    byte tmpPreset;

    char tmpPresetName0[15];
    char tmpPresetName1[15];
    char tmpPresetName2[15];
    strlcpy(tmpPresetName0, psetname0, 14);
    strlcpy(tmpPresetName1, psetname1, 14);
    strlcpy(tmpPresetName2, psetname2, 14);
    strlwr(tmpPresetName0);
    strlwr(tmpPresetName1);
    strlwr(tmpPresetName2);

    if (strcmp(tmpPayload, tmpPresetName0) == 0) tmpPreset = 0;
    else if (strcmp(tmpPayload, tmpPresetName1) == 0) tmpPreset = 1;
    else if (strcmp(tmpPayload, tmpPresetName2) == 0) tmpPreset = 2;
    else if (strcmp(tmpPayload, "none") == 0) tmpPreset = 0;
    else if (strcmp(tmpPayload, "red1") == 0) tmpPreset = 1;
    else if (strcmp(tmpPayload, "red2") == 0) tmpPreset = 2;
    else if (atoi(tmpPayload) == 0) tmpPreset = 0;
    else if (atoi(tmpPayload) == 1) tmpPreset = 1;
    else if (atoi(tmpPayload) == 2) tmpPreset = 2;

    if (serialdebug) {
      Serial.print("set preset to: ");
      Serial.println(tmpPreset);
    }

    setPresetTo(tmpPreset);

    if (serialdebug) {
      Serial.print("received MQTT ");
      Serial.print(mqtt_topic_in_setPreset);
      Serial.print(" - \"");
      Serial.print(cmdPayload);
      Serial.println("\"");
    }
    if (mqttdebug) {
      sprintf(tmp_topic_pub, "%s/%s", mqtt_topic_out, "mqtt_received");
      sprintf(tmp_payload_pub, "%s: %s", mqtt_topic_in_setPreset, cmdPayload);
      mqttclient.publish(tmp_topic_pub, tmp_payload_pub);
    }

    cmdInQueue = false; // payload is processed in "commands"
  }//if topic = mqtt_topic_in_setPreset


  if (strcmp(topic, outTemp_topic_in) == 0) { //if topic = outTemp_topic_in
    int len;
    if (length < 6) len = length; // if input is bigger than dest buffer, cut
    else len = 5;
    for (int i = 0; i < len; i++) {
      outTemp_newValue[i] = (char)payload[i];
    }
    //outTemp_newValue[len + 1] = '\0';
    outTemp_newValue[len] = '\0';
    outTemp_parseNewValue = true;
  }//if topic = outTemp_topic_in

  if (strcmp(topic, outHum_topic_in) == 0) { //if topic = outHum_topic_in
    int len;
    if (length < 4) len = length; // if input is bigger than dest buffer, cut
    else len = 3;
    for (int i = 0; i < len; i++) {
      outHum_newValue[i] = (char)payload[i];
    }
    //outHum_newValue[len + 1] = '\0';
    outHum_newValue[len] = '\0';
    outHum_parseNewValue = true;
  }//if topic = outHum_topic_in

}//mqttCallback


void mqttPrepareSubscribeTopics() {
  //char tmp_topic_out[50];
  sprintf(mqtt_topic_in_cmd, "%s/%s", mqtt_topic_in, "cmd");
  sprintf(mqtt_topic_in_setTemp, "%s/%s", mqtt_topic_in_cmd, "setTemp");
  sprintf(mqtt_topic_in_setMode, "%s/%s", mqtt_topic_in_cmd, "setMode");
  sprintf(mqtt_topic_in_setPreset, "%s/%s", mqtt_topic_in_cmd, "setPreset");
}

boolean mqttReconnect() {
  mqttclient.disconnect();
  delay(10);
  // Create MQTT client ID from device name
  String mqttClientId = "ESP8266Client-";
  //mqttClientId += String(random(0xffff), HEX);   //or random
  mqttClientId += String(deviceName);

  if (serialdebug) Serial.print("connecting to MQTT broker with ");

  boolean connRes;
  mqttReconnectAttempts++;

  if (strlen(mqtt_user) > 0 && strlen(mqtt_willTopic) == 0) {
    // user and password, no Last Will
    if (serialdebug) Serial.println("user and password, no Last Will");
    connRes = mqttclient.connect(mqttClientId.c_str(), mqtt_user, mqtt_pass);
  }
  else if (strlen(mqtt_user) > 0 && strlen(mqtt_willTopic) > 0) {
    // user, password and Last Will
    if (serialdebug) Serial.println("user, password and Last Will");
    connRes = mqttclient.connect(mqttClientId.c_str(), mqtt_user, mqtt_pass, mqtt_willTopic, mqtt_willQos, mqtt_willRetain, mqtt_willMsg);
  }
  else if (strlen(mqtt_user) == 0 && strlen(mqtt_willTopic) > 0) {
    // Last Will but no user and password
    if (serialdebug) Serial.println("Last Will, no user and password");
    connRes = mqttclient.connect(mqttClientId.c_str(), mqtt_willTopic, mqtt_willQos, mqtt_willRetain, mqtt_willMsg);
  }
  else {
    // no user, password and no Last Will
    if (serialdebug) Serial.println("no user, password and no Last Will");
    connRes = mqttclient.connect(mqttClientId.c_str());
  }
  
  if (serialdebug) {
    Serial.print("... attempt: ");
    Serial.print(mqttReconnectAttempts);
    Serial.println();
  }

  if (connRes) { // if connection was successful
    if (serialdebug) {
      Serial.print("MQTT connected. Reconnects: ");
      Serial.println(mqttReconnects);
    }

    mqttConnected = true;
    mqttReconnects++;
    mqttOnConnect();

    if (serialdebug) Serial.println("Subscribed to:");
    if (strlen(mqtt_topic_in_cmd) > 0) {
      char mqtt_topic_in_subscribe[52];
      sprintf(mqtt_topic_in_subscribe, "%s/%s", mqtt_topic_in_cmd, "#");
      if (mqttclient.subscribe(mqtt_topic_in_subscribe)) {
        if (serialdebug) Serial.println(mqtt_topic_in_subscribe);
        mqttInTopicSubscribed = true;
      }
    }
    if (strlen(outTemp_topic_in) > 0) {
      if (mqttclient.subscribe(outTemp_topic_in)) {
        if (serialdebug) Serial.println(outTemp_topic_in);
      }
    }
    if (strlen(outHum_topic_in) > 0) {
      if (mqttclient.subscribe(outHum_topic_in)) {
        if (serialdebug) Serial.println(outHum_topic_in);
      }
    }
    mqttReconnectAttempts = 0;
    return mqttclient.connected();
  }
  else {
    int mqttConnRes = mqttclient.state();
    if (serialdebug) {
      Serial.print("MQTT connect FAILED, rc=");
      Serial.print(mqttConnRes);
      Serial.print(" (");
      switch(mqttConnRes) {
        case -4:
          Serial.print(F("MQTT_CONNECTION_TIMEOUT"));
          break;
        case -3:
          Serial.print(F("MQTT_CONNECTION_LOST"));
          break;
        case -2:
          Serial.print(F("MQTT_CONNECT_FAILED"));
          break;
        case -1:
          Serial.print(F("MQTT_DISCONNECTED"));
          break;
        case 0:
          Serial.print(F("MQTT_CONNECTED"));
          break;
        case 1:
          Serial.print(F("MQTT_CONNECT_BAD_PROTOCOL"));
          break;
        case 2:
          Serial.print(F("MQTT_CONNECT_BAD_CLIENT_ID"));
          break;
        case 3:
          Serial.print(F("MQTT_CONNECT_UNAVAILABLE"));
          break;
        case 4:
          Serial.print(F("MQTT_CONNECT_BAD_CREDENTIALS"));
          break;
        case 5:
          Serial.print(F("MQTT_CONNECT_UNAUTHORIZED"));
          break;
      }
      Serial.println(")");
      
    }

    if (mqttReconnectAttempts >= 3 && (mqttConnRes == 4 || mqttConnRes == 5)) {
      // MQTT credentials are invalid/rejected from the server - stop trying to reconnect until reboot
      mqtt_tempDisabled_credentialError = true;
      if(serialdebug) {
        Serial.println(F("MQTT disabled until reboot due to credential error"));
      }
    }
    mqttConnected = false;
    mqttOnDisconnect();
  }
} //mqttReconnect



void mqttClientInit() {
  if (mqtt_enable) {
    mqttclient.setServer(mqtt_server, mqtt_port);
    mqttclient.setCallback(mqttCallback);
    mqttLastReconnectAttempt = 0;
    mqttReconnectAttempts = 0;
    mqtt_tempDisabled_credentialError = false;
  }
}

int lastWifiStatus;

void mqttHandleConnection() {
  int currWifiStatus = WiFi.status();
  if ( currWifiStatus != lastWifiStatus ) {
    lastWifiStatus = currWifiStatus;
    Serial.print("WiFi status changed to: ");
    Serial.println(currWifiStatus);
  }

  if ( mqtt_enable && !mqtt_tempDisabled_credentialError && currWifiStatus == WL_CONNECTED ) {
    // MQTT reconnect if not connected (nonblocking)
    boolean doReconnect = false;
    if (!mqttclient.connected()) doReconnect = true;

    if (mqttInTopicSubscribed && mqtt_heartbeat_maxage_reconnect > 0) { //  if mqtt_topic_in is subscribed
      if ( (millis() - mqttLastHeartbeat) > mqtt_heartbeat_maxage_reconnect ) { // also reconnect if no HEARTBEAT was received for some time
        doReconnect = true;
        mqttConnected = false;
        mqttLastHeartbeat = millis();
        Serial.println("MQTT HEARTBEAT overdue. Force-Reconnecting MQTT...");
      }
    }

    if (doReconnect) {
      unsigned int mqttReconnectAttemptDelay;
      if (mqttReconnectAttempts < 3) mqttReconnectAttemptDelay = 15000; // if this is the 1-3rd attempt, try again in 15s
      else if (mqttReconnectAttempts < 10) mqttReconnectAttemptDelay = 60000; // if more than 3 attempts failed, try again every min
      else mqttReconnectAttemptDelay = 300000; // if more than 10 attempts failed, try again every 5 min

      if ( mqtt_heartbeat_maxage_reboot > 0 && (millis() - mqttLastHeartbeat) > mqtt_heartbeat_maxage_reboot) {
        // if no heartbeat was received for set time, reboot the ESP
        delay(100);
        ESP.restart();
      }

      if ((millis() - mqttLastReconnectAttempt) > mqttReconnectAttemptDelay) {
        mqttLastReconnectAttempt = millis();
        mqttReconnect();
      }
      mqttclient.loop();
    }
    else {
      mqttclient.loop();
    }
  }
}

void mqttPublishStatus() {
  char outMsg[60];
  if (mqtt_enable && mqttclient.state() == 0) {
    sprintf(outMsg, "MQTT connected, reconnects: %d, uptime: %s, free_heap: %d", mqttReconnects - 1, uptimeStr, ESP.getFreeHeap());
    mqttclient.publish(mqtt_topic_out, outMsg, mqtt_outRetain);
  }
}

void mqttSendLog(char* payload) {
  if (mqtt_enable && mqttclient.state() == 0) {
    char buf[101];
    strlcpy(buf, payload, 101);
    Serial.println(buf);
    mqttclient.publish(mqtt_topic_out, buf, mqtt_outRetain);
    yield();
  }
}

void mqttOnConnect() {
  mqttPublishConnectMsg();
  mqttPublishStatus();
  displayShowMQTTConnected();
}

void mqttOnDisconnect() {
  displayShowMQTTConnectionError();
}

void mqttPublishConnectMsg() {
  if (strlen(mqtt_willTopic) > 4) {
    if (mqtt_enable && mqttclient.state() == 0) {
      mqttclient.publish(mqtt_willTopic, mqtt_connMsg, mqtt_willRetain);
    }
  }
}

void mqttPublishHeartbeat() {
  if (mqtt_enable && mqttclient.state() == 0) {
    mqttclient.publish(mqtt_topic_in_cmd, "HEARTBEAT"); // publishes to IN-topic. MQTT will force-reconnect if it does not get a HEARTBEAT for 2 min
  }
}