smarkleak_1_0_0

/*
  SmartLeak

  ESP8266 based leak sensor and relay control.

  Feature list:
  - Wifi network connectivity
  - MQTT publish-subscribe
  - 110V AC relay control

  created Sept 22, 2019
  by xxx

  Revision history
  1.0.0 - Initial release
  1.0.1 - Relay control
  1.0.2 - Variable hostname
  1.1.0 - OTA firmware update
*/

#include <ArduinoOTA.h>
#include <ESP8266WiFi.h>
#include <PubSubClient.h>

//
#define BUTTON_PIN        0   //GPIO 0
#define SENSOR_LEAK_PIN   3   //GPIO 3 (RX)
#define RELAY_PIN         12  //GPIO 12
#define LED_PIN           13  //GPIO 13

// Update these with values suitable for your network.
const char* ssid = "xxx";
const char* password = "xxx";
const char* mqtt_server = "xxx";
const char* charHostname = "xxx";

WiFiClient espClient;
PubSubClient client(espClient);

// Timer intervals
#define sysInterval 60000
#define leakInterval 30000
#define buttonInterval 500
#define buttonDelay 2000

//Timer variable definitions
long currentMillis;
long leakMillis = 0;
long sysMillis = 0;
long buttonMillis = 0;

// Global variables
long lastMsg = 0;
bool leakState = false;
String strTopic;
String strPayload;
char charPayload[10];
char charTopic[50];
float sysUptime = 0;
bool relayState = false;
bool relayPrevious = relayState;
bool buttonState = false;
String strHostname = String((char*)charHostname);

void setup_wifi() {
  delay(100);
  // We start by connecting to a WiFi network
  WiFi.mode(WIFI_STA);
  WiFi.hostname(charHostname);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED)
  {
    digitalWrite(LED_PIN, HIGH);
    delay(500);
    digitalWrite(LED_PIN, LOW);
  }
  randomSeed(micros());
}

void callback(char* topic, byte* payload, unsigned int length)
{
  payload[length] = '\0';
  strTopic = String((char*)topic);
  strPayload = String((char*)payload);

  if (strTopic == "openhab/" + strHostname + "/relay") {
    if (strPayload == "OFF") {
      relayState = false;
    }
    if (strPayload == "ON") {
      relayState = true;
    }
  }

  if (strTopic == "openhab/" + strHostname + "/restart") {
    ESP.restart();
  }
} //end callback

void reconnect() {
  // Loop until we're reconnected
  while (!client.connected())
  {
    // Create a random client ID
    String clientId = "ESP8266Client-";
    clientId += String(random(0xffff), HEX);

    if (client.connect(clientId.c_str()))
    {
      //once connected to MQTT broker, subscribe command if any
      client.subscribe("openhab/#");
    } else {
      // Wait 6 seconds before retrying
      delay(6000);
    }
  }
} //end reconnect()

void setup() {
  pinMode(LED_PIN, OUTPUT);
  pinMode(SENSOR_LEAK_PIN, INPUT);
  pinMode(BUTTON_PIN, INPUT);
  pinMode(RELAY_PIN, OUTPUT);

  setup_wifi();
  client.setServer(mqtt_server, 1883);
  client.setCallback(callback);

  ArduinoOTA.setHostname(charHostname);
  ArduinoOTA.begin();
}

void loop() {
  if (!client.connected()) {
    reconnect();
  }

  client.loop();

  ArduinoOTA.handle();

  currentMillis = millis();

  if (currentMillis - sysMillis > sysInterval) {
    sysMillis = currentMillis;

    strTopic = strHostname + "/relay/state";
    strTopic.toCharArray(charTopic, 50);
    if (relayState) {
      client.publish(charTopic, "ON");
    } else {
      client.publish(charTopic, "OFF");
    }

    sysUptime += 0.000694444;
    strTopic = strHostname + "/sysinfo/uptime";
    strTopic.toCharArray(charTopic, 50);
    strPayload = String(sysUptime, 1);
    strPayload.toCharArray(charPayload, 10);
    client.publish(charTopic, charPayload);

    int sysRssi = WiFi.RSSI();
    strTopic = strHostname + "/sysinfo/rssi";
    strTopic.toCharArray(charTopic, 50);
    strPayload = String(sysRssi);
    strPayload.toCharArray(charPayload, 10);
    client.publish(charTopic, charPayload);
  }

  if (currentMillis - leakMillis > leakInterval) {
    leakMillis = currentMillis;

    strTopic = strHostname + "/sensor/leak";
    strTopic.toCharArray(charTopic, 50);
    leakState = digitalRead(SENSOR_LEAK_PIN);
    if (leakState) {
      client.publish(charTopic, "ALERT");
    } else {
      client.publish(charTopic, "CLEAR");
    }
  }

  if (currentMillis - buttonMillis > buttonInterval) {
    buttonMillis = currentMillis;

    buttonState = !digitalRead(BUTTON_PIN);
    if (buttonState) {
      buttonMillis = currentMillis + buttonDelay;
      relayState = !relayPrevious;
    }

    if (relayState != relayPrevious) {
      strTopic = strHostname + "/relay/state";
      strTopic.toCharArray(charTopic, 50);

      if (relayState) {
        digitalWrite(RELAY_PIN, HIGH);
        client.publish(charTopic, "ON");
      } else {
        digitalWrite(RELAY_PIN, LOW);
        client.publish(charTopic, "OFF");
      }
      relayPrevious = relayState;
    }
  }
}