moisture+relay+webserver

#include <WiFi.h>
#include <WiFiClient.h>
#include <WiFiAP.h>
#include <AsyncTCP.h>
#include <ESPAsyncWebServer.h>
#include <ArduinoMqttClient.h>
#include <ArduinoJson.h>
#include <Preferences.h>
#define NUM_SENSORS 6

void parseCommaSeparatedValues(String csv, int array[], int arraySize);

struct Config {
  String ssid = "ssid";
  String wifi_password = "password";
  String mqtt_server = "mqtt_address";
  String mqtt_username = "mqtt_username";
  String mqtt_password = "mqtt_pass";
  String clientID = "sensor";
  String mqtt_topic = "domoticz/in";
  int SensorPin[NUM_SENSORS] = { 0, 0, 0, 0, 0, 0 };
  int rawRange[2] = { 2830, 890 };  // Dry-wet
  int scaleRange[2] = { 200, 0 };   // Dry-wet
  int relayPin = 26;
  int WetLimit = 100;
  long relayOnTime = 10;
  unsigned long pollTime = 60;
  int Samples = 10;
  int NoOfSensor = 3;
  int sensorIdx[NUM_SENSORS] = { 0, 0, 0, 0, 0, 0 };
};

Config config;
Preferences preferences;
WiFiClient wifiClient;
MqttClient mqttClient(wifiClient);
AsyncWebServer server(80);
int lastPublishedValues[NUM_SENSORS] = { 0 };
unsigned long relayOffTime = 0;
bool relayOn = false;
int mapSensorValue(int rawValue) {
  return map(rawValue, config.rawRange[0], config.rawRange[1], config.scaleRange[0], config.scaleRange[1]);
}

void saveConfig() {
  preferences.begin("config", false);
  preferences.putString("ssid", config.ssid);
  preferences.putString("wifi_password", config.wifi_password);
  preferences.putString("mqtt_server", config.mqtt_server);
  preferences.putString("mqtt_username", config.mqtt_username);
  preferences.putString("mqtt_password", config.mqtt_password);
  preferences.putString("clientID", config.clientID);
  preferences.putString("mqtt_topic", config.mqtt_topic);
  preferences.putInt("relayPin", config.relayPin);
  preferences.putInt("WetLimit", config.WetLimit);
  preferences.putInt("relayOnTime", config.relayOnTime);
  preferences.putInt("pollTime", config.pollTime);
  preferences.putInt("Samples", config.Samples);
  preferences.putInt("NoOfSensor", config.NoOfSensor);
  String sensorPinsCSV = "";
  for (int i = 0; i < NUM_SENSORS; i++) {
    sensorPinsCSV += String(config.SensorPin[i]);
    if (i < NUM_SENSORS - 1) sensorPinsCSV += ",";
  }
  preferences.putString("SensorPin", sensorPinsCSV);
  String sensorIdxCSV = "";
  for (int i = 0; i < NUM_SENSORS; i++) {
    sensorIdxCSV += String(config.sensorIdx[i]);
    if (i < NUM_SENSORS - 1) sensorIdxCSV += ",";
  }
  preferences.putString("sensorIdx", sensorIdxCSV);
  preferences.putInt("rawRangeMin", config.rawRange[0]);
  preferences.putInt("rawRangeMax", config.rawRange[1]);
  preferences.putInt("scaleRangeMin", config.scaleRange[0]);
  preferences.putInt("scaleRangeMax", config.scaleRange[1]);
  preferences.end();
}

void loadConfig() {
  preferences.begin("config", true);
  config.ssid = preferences.getString("ssid", config.ssid);
  config.wifi_password = preferences.getString("wifi_password", config.wifi_password);
  config.mqtt_server = preferences.getString("mqtt_server", config.mqtt_server);
  config.mqtt_username = preferences.getString("mqtt_username", config.mqtt_username);
  config.mqtt_password = preferences.getString("mqtt_password", config.mqtt_password);
  config.clientID = preferences.getString("clientID", config.clientID);
  config.mqtt_topic = preferences.getString("mqtt_topic", config.mqtt_topic);
  config.relayPin = preferences.getInt("relayPin", config.relayPin);
  config.WetLimit = preferences.getInt("WetLimit", config.WetLimit);
  config.relayOnTime = preferences.getInt("relayOnTime", config.relayOnTime);
  config.pollTime = preferences.getInt("pollTime", config.pollTime);
  config.Samples = preferences.getInt("Samples", config.Samples);
  config.NoOfSensor = preferences.getInt("NoOfSensor", config.NoOfSensor);
  String sensorPinsCSV = preferences.getString("SensorPin", "");
  if (!sensorPinsCSV.isEmpty()) {
    parseCommaSeparatedValues(sensorPinsCSV, config.SensorPin, NUM_SENSORS);
  }
  String sensorIdxCSV = preferences.getString("sensorIdx", "");
  if (!sensorIdxCSV.isEmpty()) {
    parseCommaSeparatedValues(sensorIdxCSV, config.sensorIdx, NUM_SENSORS);
  }
  config.rawRange[0] = preferences.getInt("rawRangeMin", config.rawRange[0]);
  config.rawRange[1] = preferences.getInt("rawRangeMax", config.rawRange[1]);
  config.scaleRange[0] = preferences.getInt("scaleRangeMin", config.scaleRange[0]);
  config.scaleRange[1] = preferences.getInt("scaleRangeMax", config.scaleRange[1]);
  preferences.end();
}

void connectToWiFi() {
  Serial.print("Connecting to WiFi: ");
  Serial.println(config.ssid);
  WiFi.begin(config.ssid.c_str(), config.wifi_password.c_str());
  unsigned long startTime = millis();
  while (WiFi.status() != WL_CONNECTED && millis() - startTime < 30000) {
    delay(500);
    Serial.print(".");
  }
  if (WiFi.status() == WL_CONNECTED) {
    Serial.println("WiFi connected");
    Serial.print("IP address: ");
    Serial.println(WiFi.localIP());
  } else {
    Serial.println("Failed to connect to WiFi. Creating an ad-hoc network...");
    WiFi.mode(WIFI_AP);
    IPAddress local_IP(192, 168, 1, 1);
    IPAddress gateway(192, 168, 1, 1);
    IPAddress subnet(255, 255, 255, 0);
    if (!WiFi.softAPConfig(local_IP, gateway, subnet)) {
      Serial.println("AP Config Failed");
      return;
    }
    bool apSuccess = WiFi.softAP("Plants");
    if (apSuccess) {
      Serial.print("Ad-hoc network SSID: 'Plants' with IP: ");
      Serial.println(WiFi.softAPIP());
    } else {
      Serial.println("Failed to create ad-hoc network. Please check the configuration and device capabilities.");
    }
  }
}

void connectToMQTT() {
  mqttClient.setId(config.clientID.c_str());
  mqttClient.setUsernamePassword(config.mqtt_username.c_str(), config.mqtt_password.c_str());
  int attempts = 0;
  while (!mqttClient.connect(config.mqtt_server.c_str(), 1883) && attempts < 3) {
    Serial.print(".");
    delay(5000);
    attempts++;
  }
  if (attempts < 3) {
    Serial.println("\nConnected to MQTT");
  } else {
    Serial.println("\nFailed to connect to MQTT, proceeding without MQTT functionality.");
  }
}

void publishSensorValues(int sensorIdx, int value) {
  int domoticzIdx = -1;
  for (int i = 0; i < NUM_SENSORS; i++) {
    if (config.sensorIdx[i] == sensorIdx) {
      domoticzIdx = sensorIdx;
      lastPublishedValues[i] = value;
      break;
    }
  }
  if (domoticzIdx != -1) {
    DynamicJsonDocument doc(1024);
    doc["idx"] = domoticzIdx;
    doc["nvalue"] = value;
    doc["svalue"] = String(value);
    String payload;
    serializeJson(doc, payload);
    if (!config.mqtt_topic.isEmpty()) {
      // Publish to the configured MQTT topic
      mqttClient.beginMessage(config.mqtt_topic);
      mqttClient.print(payload);
      mqttClient.endMessage();
    } else {
      // If MQTT topic is empty, use Home Assistant discovery format
      String stateTopic = "homeassistant/" + config.clientID + "/sensor" + String(sensorIdx) + "/state";
      DynamicJsonDocument haDoc(1024);
      haDoc["moisture"] = value;
      String haPayload;
      serializeJson(haDoc, haPayload);
      mqttClient.beginMessage(stateTopic);
      mqttClient.print(haPayload);
      mqttClient.endMessage();
    }
  } else {
    Serial.println("MQTT topic is empty, cannot publish sensor values to Domoticz.");
  }
}

void connectToNetwork() {
  connectToWiFi();
  connectToMQTT();
}

void parseAndSetSensorPins(String sensorPins) {
  int pinsArray[NUM_SENSORS];
  parseCommaSeparatedValues(sensorPins, pinsArray, NUM_SENSORS);
  for (int i = 0; i < NUM_SENSORS; i++) {
    config.SensorPin[i] = pinsArray[i];
  }
}

void parseAndSetSensorIdxs(String sensorIdxs) {
  int idxsArray[NUM_SENSORS];
  parseCommaSeparatedValues(sensorIdxs, idxsArray, NUM_SENSORS);
  for (int i = 0; i < NUM_SENSORS; i++) {
    config.sensorIdx[i] = idxsArray[i];
  }
}

void parseCommaSeparatedValues(String csv, int array[], int arraySize) {
  int idx = 0;
  int lastIdx = 0;
  for (int i = 0; i <= csv.length(); i++) {
    // Check for end of string or comma
    if (i == csv.length() || csv[i] == ',') {
      if (idx < arraySize) {
        array[idx++] = csv.substring(lastIdx, i).toInt();
      }
      lastIdx = i + 1;  // Move past the comma
    }
  }
}

void publishMQTTDiscoveryConfig() {
  for (int i = 0; i < NUM_SENSORS; i++) {
    DynamicJsonDocument configDoc(1024);
    String configTopic = "homeassistant/sensor/" + config.clientID + "_sensor" + String(i) + "/config";
    configDoc["name"] = "Plant_Sensor " + String(i);
    configDoc["device_class"] = "moisture";
    configDoc["unit_of_measurement"] = "%";
    configDoc["state_topic"] = "homeassistant/" + config.clientID + "/sensor" + String(i) + "/state";
    configDoc["value_template"] = "{{ value_json.moisture }}";
    String configPayload;
    serializeJson(configDoc, configPayload);
    mqttClient.beginMessage(configTopic);
    mqttClient.print(configPayload);
    mqttClient.endMessage();
  }
}

void pollAndPublishSensors() {
  int sensorsAtOrAboveThreshold = 0;
  for (int i = 0; i < NUM_SENSORS; i++) {
    int sum = 0;
    for (int j = 0; j < config.Samples; j++) {
      sum += analogRead(config.SensorPin[i]);
    }
    int average = sum / config.Samples;
    Serial.printf("Immediate Poll - Sensor %d Raw Moisture: %d\n", i, average);
    int processedValue = mapSensorValue(average);
    publishSensorValues(config.sensorIdx[i], processedValue);
    if (processedValue >= config.WetLimit) {
      sensorsAtOrAboveThreshold++;
    }
  }
  if (sensorsAtOrAboveThreshold >= config.NoOfSensor && !relayOn) {
    triggerRelayForInterval();
    Serial.println("Manual polling triggered irrigation.");
  }
}

void setupWebServer() {
  server.on("/", HTTP_GET, [](AsyncWebServerRequest *request) {
    String html = "<html><body><h1>Plant Monitoring System</h1>"
                  "<h2>Sensor Readings</h2><ul>";
    for (int i = 0; i < NUM_SENSORS; i++) {
      html += "<li>Sensor " + String(i) + ": " + String(lastPublishedValues[i]) + "</li>";
    }
    html += "</ul>"
            "<form action='/submit' method='POST'>"
            "SSID: <input type='text' name='ssid' value='"
            + config.ssid + "'><br>"
                            "WiFi Password: <input type='password' name='wifiPassword' value='"
            + config.wifi_password + "'><br>"
                                     "Sensor Pins (comma-separated): <input type='text' name='sensorPins' value='";
    for (int i = 0; i < 6; i++) {
      html += String(config.SensorPin[i]);
      if (i < 5) html += ",";
    }
    html += "'><br>"
            "Sensor IDXs (comma-separated): <input type='text' name='sensorIdxs' value='";
    for (int i = 0; i < 6; i++) {
      html += String(config.sensorIdx[i]);
      if (i < 5) html += ",";
    }
    html += "'><br>"
            "MQTT Server: <input type='text' name='mqttServer' value='"
            + config.mqtt_server + "'><br>"
                                   "MQTT Topic: (Leave empty for HA Discovery) <input type='text' name='mqttTopic' value='"
            + config.mqtt_topic + "'><br>"
                                  "MQTT Username: <input type='text' name='mqttUsername' value='"
            + config.mqtt_username + "'><br>"
                                     "MQTT Password: <input type='password' name='mqttPassword' value='"
            + config.mqtt_password + "'><br>"
                                     "Client ID: <input type='text' name='clientID' value='"
            + config.clientID + "'><br>"
                                "Raw Value Range (dry-wet)(comma-separated): <input type='text' name='rawRange' value='"
            + String(config.rawRange[0]) + "," + String(config.rawRange[1]) + "'><br>"
                                                                              "Scale Range (dry-wet)(comma-separated): <input type='text' name='scaleRange' value='"
            + String(config.scaleRange[0]) + "," + String(config.scaleRange[1]) + "'><br>"
                                                                                  "Relay Pin: <input type='text' name='relayPin' value='"
            + String(config.relayPin) + "'><br>"
                                        "Moisture Threshold: <input type='text' name='WetLimit' value='"
            + String(config.WetLimit) + "'><br>"
                                        "Relay On Time: <input type='text' name='relayOnTime' value='"
            + String(config.relayOnTime) + "'><br>"
                                           "Number of sensors required to trigger irrigation: <input type='text' name='NoOfSensor' value='"
            + String(config.NoOfSensor) + "'><br>"
                                          "Poll Interval (minutes): <input type='text' name='pollTime' value='"
            + String(config.pollTime) + "'><br>"
                                        "Number of Samples: <input type='text' name='numSamples' value='"
            + String(config.Samples) + "'><br>"
                                       "<input type='submit' value='Update'>"
                                       "</form>"
                                       "<form action='/pollSensors' method='POST'>"
                                       "<input type='submit' value='Poll Sensors Now'>"
                                       "</form>"
                                       "<form action='/triggerRelay' method='POST'>"
                                       "<input type='submit' value='Trigger Relay'>"
                                       "</form></body></html>";
    request->send(200, "text/html", html);
  });
  server.on("/pollSensors", HTTP_POST, [](AsyncWebServerRequest *request) {
    pollAndPublishSensors();
    request->send(200, "text/html", "<p>Sensors polled successfully. Redirecting...</p><script>setTimeout(function(){window.location.href='/'}, 3000);</script>");
  });
  server.on("/triggerRelay", HTTP_POST, [](AsyncWebServerRequest *request) {
    triggerRelayForInterval();
    request->send(200, "text/html", "<p>Relay triggered. Redirecting...</p><script>setTimeout(function(){window.location.href='/'}, 3000);</script>");
  });
  server.on("/submit", HTTP_POST, [](AsyncWebServerRequest *request) {
    String tempSensorPins, tempSensorIdxs;
    if (request->hasParam("ssid", true)) {
      config.ssid = request->getParam("ssid", true)->value();
    }
    if (request->hasParam("wifiPassword", true)) {
      config.wifi_password = request->getParam("wifiPassword", true)->value();
    }
    if (request->hasParam("mqttServer", true)) {
      config.mqtt_server = request->getParam("mqttServer", true)->value();
    }
    if (request->hasParam("sensorIdxs", true)) {
      tempSensorIdxs = request->getParam("sensorIdxs", true)->value();
      parseAndSetSensorIdxs(tempSensorIdxs);  // Use improved parsing function
    }
    if (request->hasParam("mqttTopic", true)) {
      config.mqtt_topic = request->getParam("mqttTopic", true)->value();
    }
    if (request->hasParam("mqttUsername", true)) {
      config.mqtt_username = request->getParam("mqttUsername", true)->value();
    }
    if (request->hasParam("mqttPassword", true)) {
      config.mqtt_password = request->getParam("mqttPassword", true)->value();
    }
    if (request->hasParam("clientID", true)) {
      config.clientID = request->getParam("clientID", true)->value();
    }
    if (request->hasParam("relayPin", true)) {
      config.relayPin = request->getParam("relayPin", true)->value().toInt();
    }
    if (request->hasParam("WetLimit", true)) {
      config.WetLimit = request->getParam("WetLimit", true)->value().toInt();
    }
    if (request->hasParam("rawRange", true)) {
      String rawRange = request->getParam("rawRange", true)->value();
      int rangeArray[2];
      parseCommaSeparatedValues(rawRange, rangeArray, 2);
      config.rawRange[0] = rangeArray[0];
      config.rawRange[1] = rangeArray[1];
    }
    if (request->hasParam("scaleRange", true)) {
      String scaleRange = request->getParam("scaleRange", true)->value();
      int rangeArray[2];
      parseCommaSeparatedValues(scaleRange, rangeArray, 2);
      config.scaleRange[0] = rangeArray[0];
      config.scaleRange[1] = rangeArray[1];
    }
    if (request->hasParam("relayOnTime", true)) {
      config.relayOnTime = request->getParam("relayOnTime", true)->value().toInt();
    }
    if (request->hasParam("NoOfSensor", true)) {
      config.NoOfSensor = request->getParam("NoOfSensor", true)->value().toInt();
    }
    if (request->hasParam("pollTime", true)) {
      config.pollTime = request->getParam("pollTime", true)->value().toInt();
    }
    if (request->hasParam("numSamples", true)) {
      config.Samples = request->getParam("numSamples", true)->value().toInt();
    }
    if (request->hasParam("sensorPins", true)) {
      String sensorPins = request->getParam("sensorPins", true)->value();
      parseAndSetSensorPins(sensorPins);
    }
    saveConfig();
    request->send(200, "text/html", "<p>Settings updated. The device will restart now.</p><script>setTimeout(function(){window.location.href='/'}, 3000);</script>");
    delay(100);
    ESP.restart();
  });
}

void triggerRelayForInterval() {
  digitalWrite(config.relayPin, HIGH);
  relayOn = true;
  relayOffTime = millis() + config.relayOnTime * 1000;  // Use the configured relay on time
  Serial.println("Relay triggered!");
}

void setup() {
  Serial.begin(9600);
  loadConfig();
  connectToNetwork();
  pinMode(config.relayPin, OUTPUT);
  digitalWrite(config.relayPin, LOW);
  setupWebServer();
  server.begin();
  if (config.mqtt_topic.isEmpty()) {
    publishMQTTDiscoveryConfig();
  }
}

void loop() {
  static unsigned long lastSensorPollTime = 0;
  unsigned long pollIntervalMillis = static_cast<unsigned long>(config.pollTime) * 60000UL;
  if (!mqttClient.connected()) {
    connectToMQTT();
  }
  mqttClient.poll();
  if (relayOn && millis() >= relayOffTime) {
    digitalWrite(config.relayPin, LOW);
    relayOn = false;
  }
  if (millis() - lastSensorPollTime > pollIntervalMillis) {
    lastSensorPollTime = millis();
    int sensorsAtOrAboveThreshold = 0;
    for (int i = 0; i < NUM_SENSORS; i++) {
      int sum = 0;
      for (int j = 0; j < config.Samples; j++) {
        sum += analogRead(config.SensorPin[i]);
      }
      int average = sum / config.Samples;
      Serial.printf("Sensor %d Raw Moisture: %d\n", i, average);
      int processedValue = mapSensorValue(average);
      if (processedValue != lastPublishedValues[i]) {
        lastPublishedValues[i] = processedValue;
        Serial.printf("Sensor %d Mapped Moisture: %d\n", i, processedValue);
        publishSensorValues(config.sensorIdx[i], processedValue);
      }
      if (processedValue >= config.WetLimit) {
        sensorsAtOrAboveThreshold++;
      }
    }
    if (sensorsAtOrAboveThreshold >= config.NoOfSensor && !relayOn) {
      triggerRelayForInterval();
    }
  }
}