Solar IoT Paddi Water Monitor

#include <Arduino.h>
#include <Wire.h>
#include <RTClib.h>
#include <Preferences.h>
#include <math.h>

// Commission these three values for the SIM and central dashboard before field deployment.
static const char APN[] = "YOUR_APN";
static const char HTTPS_URL[] = "https://your-cloud.example/api/v1/water-level";
static const char DEVICE_ID[] = "paddy-node-001";

constexpr int BATTERY_ADC_PIN = 1;
constexpr int NTC_ADC_PIN = 2;
constexpr int CHARGE_STATUS_PIN = 3;
constexpr int ULTRASONIC_TRIG_PIN = 4;
constexpr int ULTRASONIC_ECHO_PIN = 5;
constexpr int SENSOR_SWITCH_PIN = 6;
constexpr int MODEM_BOOST_EN_PIN = 14;
constexpr int MODEM_SWITCH_EN_PIN = 15;
// ESP32-S3 routes UART signals through its GPIO matrix; these avoid the board's USB/console pins.
constexpr int MODEM_RX_PIN = 18;
constexpr int MODEM_TX_PIN = 17;
constexpr int MODEM_PWRKEY_PIN = 21;
constexpr int I2C_SDA_PIN = 8;
constexpr int I2C_SCL_PIN = 9;

constexpr uint64_t SAMPLE_INTERVAL_US = 30ULL * 60ULL * 1000000ULL;
constexpr uint8_t UPLOAD_EVERY_SAMPLES = 6;  // 3 hours; change to 12 for 6 hours.
constexpr uint8_t QUEUE_SLOTS = 24;          // Holds 12 hours of 30-minute records.
constexpr float SENSOR_ZERO_HEIGHT_CM = 55.0f;
// The sensor face is fixed 55 cm above the soil-zero reference. A distance of 25 cm is +30 cm water.

HardwareSerial modem(1);
RTC_DS3231 rtc;
Preferences prefs;

struct Reading {
  float waterLevelCm;
  float batteryV;
  float temperatureC;
  int rssi;
  bool charging;
  DateTime timestamp;
};

static void setLoadPower(bool on) {
  digitalWrite(MODEM_BOOST_EN_PIN, on ? HIGH : LOW);
  digitalWrite(MODEM_SWITCH_EN_PIN, on ? HIGH : LOW);
  digitalWrite(SENSOR_SWITCH_PIN, on ? HIGH : LOW);
  if (on) delay(250);
}

static float readBatteryV() {
  // Divider is 100k/100k, so ADC pin voltage is half battery voltage.
  uint32_t raw = analogReadMilliVolts(BATTERY_ADC_PIN);
  return (raw * 2.0f) / 1000.0f;
}

static float readNtcC() {
  // 10k B3950 NTC, 10k fixed resistor to 3.3 V. Return NAN if wiring is open/shorted.
  uint32_t mv = analogReadMilliVolts(NTC_ADC_PIN);
  if (mv < 20 || mv > 3280) return NAN;
  const float v = mv / 1000.0f;
  const float resistance = 10000.0f * v / (3.3f - v);
  const float kelvin = 1.0f / ((1.0f / 298.15f) + logf(resistance / 10000.0f) / 3950.0f);
  return kelvin - 273.15f;
}

static float readDistanceCm() {
  digitalWrite(ULTRASONIC_TRIG_PIN, LOW);
  delay(5);
  digitalWrite(ULTRASONIC_TRIG_PIN, HIGH);
  delayMicroseconds(12);
  digitalWrite(ULTRASONIC_TRIG_PIN, LOW);
  const uint32_t pulse = pulseIn(ULTRASONIC_ECHO_PIN, HIGH, 45000UL);
  if (pulse == 0) return NAN;
  return pulse / 58.0f;
}

static float filteredWaterLevelCm() {
  float sum = 0.0f;
  uint8_t valid = 0;
  for (uint8_t i = 0; i < 5; ++i) {
    const float distance = readDistanceCm();
    if (!isnan(distance) && distance >= 25.0f && distance <= 100.0f) {
      sum += distance;
      ++valid;
    }
    delay(80);
  }
  if (valid < 3) return NAN;
  const float distance = sum / valid;
  return SENSOR_ZERO_HEIGHT_CM - distance;
}

static bool atCommand(const String &command, const char *expected, uint32_t timeoutMs, String *reply = nullptr) {
  while (modem.available()) modem.read();
  modem.println(command);
  String response;
  const uint32_t started = millis();
  while (millis() - started < timeoutMs) {
    while (modem.available()) response += static_cast<char>(modem.read());
    if (response.indexOf(expected) >= 0) {
      if (reply != nullptr) *reply = response;
      return true;
    }
    delay(10);
  }
  if (reply != nullptr) *reply = response;
  return false;
}

static int modemRssi() {
  String reply;
  if (!atCommand("AT+CSQ", "OK", 2500, &reply)) return -1;
  const int colon = reply.indexOf(':');
  const int comma = reply.indexOf(',', colon + 1);
  if (colon < 0 || comma < 0) return -1;
  const int csq = reply.substring(colon + 1, comma).toInt();
  if (csq == 99) return -1;
  return -113 + (2 * csq); // 3GPP CSQ to dBm approximation.
}

static bool modemStart() {
  setLoadPower(true);
  modem.begin(115200, SERIAL_8N1, MODEM_RX_PIN, MODEM_TX_PIN);
  pinMode(MODEM_PWRKEY_PIN, OUTPUT);
  digitalWrite(MODEM_PWRKEY_PIN, LOW);
  delay(1200);
  digitalWrite(MODEM_PWRKEY_PIN, HIGH);
  for (uint8_t tries = 0; tries < 12; ++tries) {
    if (atCommand("AT", "OK", 1500)) return true;
    delay(1000);
  }
  return false;
}

static void modemStop() {
  atCommand("AT+HTTPTERM", "OK", 1500);
  modem.end();
  setLoadPower(false);
}

static bool postJsonTls(const String &json) {
  // SIM7600 HTTPS AT sequence. The deployed SIM profile must permit packet data and TLS.
  if (!atCommand("AT+CGDCONT=1,\"IP\",\"" + String(APN) + "\"", "OK", 3000)) return false;
  if (!atCommand("AT+CGATT=1", "OK", 30000)) return false;
  if (!atCommand("AT+HTTPINIT", "OK", 4000)) return false;
  if (!atCommand("AT+HTTPPARA=\"CID\",1", "OK", 3000)) return false;
  if (!atCommand("AT+HTTPSSL=1", "OK", 3000)) return false;
  if (!atCommand("AT+HTTPPARA=\"URL\",\"" + String(HTTPS_URL) + "\"", "OK", 5000)) return false;
  if (!atCommand("AT+HTTPPARA=\"CONTENT\",\"application/json\"", "OK", 3000)) return false;
  if (!atCommand("AT+HTTPDATA=" + String(json.length()) + ",10000", "DOWNLOAD", 5000)) return false;
  modem.print(json);
  delay(200);
  return atCommand("AT+HTTPACTION=1", "+HTTPACTION: 1,2", 45000);
}

static String toJson(const Reading &r) {
  char stamp[25];
  snprintf(stamp, sizeof(stamp), "%04d-%02d-%02dT%02d:%02d:%02dZ", r.timestamp.year(), r.timestamp.month(), r.timestamp.day(), r.timestamp.hour(), r.timestamp.minute(), r.timestamp.second());
  String json = "{\"device_id\":\"" + String(DEVICE_ID) + "\",\"timestamp\":\"" + String(stamp) + "\",\"water_level_cm\":";
  json += isnan(r.waterLevelCm) ? "null" : String(r.waterLevelCm, 1);
  json += ",\"battery_v\":" + String(r.batteryV, 3);
  json += ",\"temp_c\":" + (isnan(r.temperatureC) ? String("null") : String(r.temperatureC, 1));
  json += ",\"rssi\":" + String(r.rssi);
  json += ",\"charging\":" + String(r.charging ? "true" : "false") + "}";
  return json;
}

static void queueRecord(const String &json) {
  const uint8_t head = prefs.getUChar("head", 0);
  prefs.putString(("q" + String(head)).c_str(), json);
  prefs.putUChar("head", (head + 1) % QUEUE_SLOTS);
  uint8_t count = prefs.getUChar("count", 0);
  if (count < QUEUE_SLOTS) ++count;
  prefs.putUChar("count", count);
}

static void publishQueued() {
  uint8_t count = prefs.getUChar("count", 0);
  uint8_t head = prefs.getUChar("head", 0);
  uint8_t tail = (head + QUEUE_SLOTS - count) % QUEUE_SLOTS;
  while (count > 0) {
    const String key = "q" + String(tail);
    const String json = prefs.getString(key.c_str(), "");
    if (json.length() == 0 || !postJsonTls(json)) break;
    prefs.remove(key.c_str());
    tail = (tail + 1) % QUEUE_SLOTS;
    --count;
    prefs.putUChar("count", count);
  }
}

void setup() {
  pinMode(SENSOR_SWITCH_PIN, OUTPUT);
  pinMode(MODEM_BOOST_EN_PIN, OUTPUT);
  pinMode(MODEM_SWITCH_EN_PIN, OUTPUT);
  pinMode(ULTRASONIC_TRIG_PIN, OUTPUT);
  pinMode(ULTRASONIC_ECHO_PIN, INPUT);
  pinMode(CHARGE_STATUS_PIN, INPUT_PULLUP);
  setLoadPower(false);

  analogReadResolution(12);
  Wire.begin(I2C_SDA_PIN, I2C_SCL_PIN);
  rtc.begin();
  prefs.begin("paddy", false);

  // Power only the sensor path for the five-sample measurement burst.
  digitalWrite(MODEM_BOOST_EN_PIN, HIGH);
  digitalWrite(SENSOR_SWITCH_PIN, HIGH);
  delay(250);
  Reading reading;
  reading.waterLevelCm = filteredWaterLevelCm();
  reading.batteryV = readBatteryV();
  reading.temperatureC = readNtcC();
  reading.charging = digitalRead(CHARGE_STATUS_PIN) == LOW;
  reading.timestamp = rtc.now();
  digitalWrite(SENSOR_SWITCH_PIN, LOW);
  digitalWrite(MODEM_BOOST_EN_PIN, LOW);
  reading.rssi = -1;

  uint8_t sampleCount = prefs.getUChar("samples", 0) + 1;
  bool shouldUpload = sampleCount >= UPLOAD_EVERY_SAMPLES;
  if (shouldUpload) sampleCount = 0;
  prefs.putUChar("samples", sampleCount);

  if (shouldUpload && modemStart()) {
    reading.rssi = modemRssi();
    queueRecord(toJson(reading));
    publishQueued();
    modemStop();
  } else {
    queueRecord(toJson(reading));
  }

  prefs.end();
  esp_sleep_enable_timer_wakeup(SAMPLE_INTERVAL_US);
  delay(50);
  esp_deep_sleep_start();
}

void loop() {
  // setup() always enters deep sleep; loop is intentionally never reached.
}