Remote Weather Monitoring Station

#include <Arduino.h>
#include <DHT.h>
#include <OneWire.h>
#include <DallasTemperature.h>
#include <Adafruit_BMP280.h>
#include <LittleFS.h>
#include "esp_sleep.h"

// Field weather station: reads sensors, queues measurements locally, then posts by SIM900 GPRS.

// Forward declarations
void selectMuxChannel(uint8_t channel);
int averageAnalog(int pin, int samples);
float batteryVoltage();
int batteryPercent(float volts);
void clearModem();
bool waitFor(const char *text, uint32_t timeout);
bool at(const String &command, const char *expect, uint32_t timeout);
bool modemReady();
bool startGprs();
bool postMeasurement(const String &body);
bool beginQueue();
void queueMeasurement(const String &body);
bool firstQueued(String &line);
bool removeFirstQueued();
void sendQueue();

constexpr int STATION_ID = 22;
constexpr uint64_t SLEEP_US = 30ULL * 60ULL * 1000000ULL;
constexpr char APN[] = "izi.me";
constexpr char POST_URL[] = "http://37.151.253.210:2409/dashboard/index.php";
constexpr char QUEUE_FILE[] = "/post_queue.txt";

constexpr int SENSOR_POWER_PIN = 14;
constexpr int DHT_PIN = 4;
constexpr int ONE_WIRE_PIN = 27;
constexpr int BMP_SDA_PIN = 21;
constexpr int BMP_SCL_PIN = 22;
constexpr int PHOTO_PIN = 34;
constexpr int RAIN_PIN = 36;
constexpr int SOIL_MUX_PIN = 39;
constexpr int MUX_S0_PIN = 25;
constexpr int MUX_S1_PIN = 26;
constexpr int MUX_S2_PIN = 32;
constexpr int MUX_S3_PIN = 33;
constexpr int BATTERY_PIN = 35;
constexpr int SIM_RX_PIN = 16; // ESP32 RX receives SIM900 TX
constexpr int SIM_TX_PIN = 17; // ESP32 TX, through the resistor divider, drives SIM900 RX

constexpr float BATTERY_R_TOP_KOHM = 99.6f;
constexpr float BATTERY_R_BOTTOM_KOHM = 50.0f;
constexpr float ADC_REFERENCE = 3.3f;
constexpr float ADC_CORRECTION = 1.107f;
constexpr int SOIL_DRY = 4095;
constexpr int SOIL_WET = 600;
constexpr int RAIN_DRY = 4095;
constexpr int RAIN_WET = 0;

DHT dht(DHT_PIN, DHT21);
OneWire oneWire(ONE_WIRE_PIN);
DallasTemperature soilTemps(&oneWire);
Adafruit_BMP280 bmp;
HardwareSerial sim900(2);

DeviceAddress temperatureAddresses[7] = {
  {0x28,0x33,0x59,0x34,0x00,0x00,0x00,0x8A},
  {0x28,0x0D,0x23,0x34,0x00,0x00,0x00,0xA4},
  {0x28,0xBF,0x36,0x34,0x00,0x00,0x00,0x63},
  {0x28,0x8B,0x1F,0x36,0x00,0x00,0x00,0x5E},
  {0x28,0xA2,0x7A,0x38,0x00,0x00,0x00,0xA8},
  {0x28,0xE9,0x27,0x36,0x00,0x00,0x00,0x49},
  {0x28,0xF0,0x48,0x38,0x00,0x00,0x00,0xEF}
};

void selectMuxChannel(uint8_t channel) {
  digitalWrite(MUX_S0_PIN, channel & 1);
  digitalWrite(MUX_S1_PIN, (channel >> 1) & 1);
  digitalWrite(MUX_S2_PIN, (channel >> 2) & 1);
  digitalWrite(MUX_S3_PIN, (channel >> 3) & 1);
}

int averageAnalog(int pin, int samples = 8) {
  uint32_t total = 0;
  for (int i = 0; i < samples; ++i) { total += analogRead(pin); delay(5); }
  return total / samples;
}

float batteryVoltage() {
  float adc = averageAnalog(BATTERY_PIN, 20);
  return (adc / 4095.0f) * ADC_REFERENCE * ADC_CORRECTION *
         ((BATTERY_R_TOP_KOHM + BATTERY_R_BOTTOM_KOHM) / BATTERY_R_BOTTOM_KOHM);
}

int batteryPercent(float volts) {
  return constrain((int)((volts - 3.0f) * 100.0f / 1.2f), 0, 100);
}

void clearModem() { while (sim900.available()) sim900.read(); }

bool waitFor(const char *text, uint32_t timeout) {
  String reply;
  uint32_t started = millis();
  while (millis() - started < timeout) {
    while (sim900.available()) {
      char c = (char)sim900.read();
      Serial.write(c);
      reply += c;
      if (reply.indexOf(text) >= 0) return true;
      if (reply.indexOf("ERROR") >= 0) return false;
      if (reply.length() > 400) reply.remove(0, 200);
    }
    delay(1);
  }
  return false;
}

bool at(const String &command, const char *expect, uint32_t timeout) {
  clearModem();
  sim900.println(command);
  return waitFor(expect, timeout);
}

bool modemReady() {
  for (int i = 0; i < 3; ++i) if (at("AT", "OK", 2000)) return true;
  return false;
}

bool startGprs() {
  if (!at("AT+SAPBR=3,1,\"CONTYPE\",\"GPRS\"", "OK", 5000)) return false;
  if (!at(String("AT+SAPBR=3,1,\"APN\",\"") + APN + "\"", "OK", 5000)) return false;
  if (!at("AT+SAPBR=1,1", "OK", 60000)) {
    if (!at("AT+SAPBR=2,1", "+SAPBR: 1,1", 5000)) return false;
  }
  return true;
}

bool postMeasurement(const String &body) {
  if (!modemReady() || !startGprs()) return false;
  at("AT+HTTPTERM", "OK", 2000);
  bool ok = at("AT+HTTPINIT", "OK", 5000) &&
            at("AT+HTTPPARA=\"CID\",1", "OK", 5000) &&
            at(String("AT+HTTPPARA=\"URL\",\"") + POST_URL + "\"", "OK", 10000) &&
            at("AT+HTTPPARA=\"CONTENT\",\"application/x-www-form-urlencoded\"", "OK", 5000);
  if (ok) {
    clearModem();
    sim900.print("AT+HTTPDATA="); sim900.print(body.length()); sim900.println(",10000");
    ok = waitFor("DOWNLOAD", 5000);
    if (ok) { sim900.print(body); ok = waitFor("OK", 10000); }
    if (ok) { clearModem(); sim900.println("AT+HTTPACTION=1"); ok = waitFor("+HTTPACTION: 1,200", 60000); }
  }
  at("AT+HTTPTERM", "OK", 5000);
  at("AT+SAPBR=0,1", "OK", 10000);
  return ok;
}

bool beginQueue() {
  if (!LittleFS.begin(true)) return false;
  if (!LittleFS.exists(QUEUE_FILE)) { File f = LittleFS.open(QUEUE_FILE, FILE_WRITE); if (!f) return false; f.close(); }
  return true;
}

void queueMeasurement(const String &body) {
  File f = LittleFS.open(QUEUE_FILE, FILE_APPEND);
  if (f) { f.println(body); f.close(); }
}

bool firstQueued(String &line) {
  File f = LittleFS.open(QUEUE_FILE, FILE_READ);
  if (!f || !f.available()) { if (f) f.close(); return false; }
  line = f.readStringUntil('\n'); f.close(); line.trim(); return line.length() > 0;
}

bool removeFirstQueued() {
  File input = LittleFS.open(QUEUE_FILE, FILE_READ);
  File output = LittleFS.open("/queue_tmp.txt", FILE_WRITE);
  if (!input || !output) return false;
  input.readStringUntil('\n');
  while (input.available()) output.println(input.readStringUntil('\n'));
  input.close(); output.close();
  LittleFS.remove(QUEUE_FILE);
  return LittleFS.rename("/queue_tmp.txt", QUEUE_FILE);
}

void sendQueue() {
  String body;
  while (firstQueued(body)) {
    if (!postMeasurement(body)) break;
    if (!removeFirstQueued()) break;
  }
}

void setup() {
  Serial.begin(115200);
  pinMode(SENSOR_POWER_PIN, OUTPUT);
  digitalWrite(SENSOR_POWER_PIN, HIGH);
  pinMode(MUX_S0_PIN, OUTPUT); pinMode(MUX_S1_PIN, OUTPUT);
  pinMode(MUX_S2_PIN, OUTPUT); pinMode(MUX_S3_PIN, OUTPUT);
  analogReadResolution(12);
  analogSetAttenuation(ADC_11db);
  delay(1500); // sensors need time to receive stable 3.3 V

  dht.begin();
  soilTemps.begin();
  Wire.begin(BMP_SDA_PIN, BMP_SCL_PIN);
  bool bmpFound = bmp.begin(0x76, &Wire);

  float airHumidity = dht.readHumidity();
  float airTemp = dht.readTemperature();
  float pressureMmHg = NAN;
  if (bmpFound) { bmp.setSampling(Adafruit_BMP280::MODE_FORCED); bmp.takeForcedMeasurement(); pressureMmHg = bmp.readPressure() / 100.0f * 0.750062f; }

  float soilTemperature[7];
  soilTemps.requestTemperatures();
  delay(750);
  for (int i = 0; i < 7; ++i) soilTemperature[i] = soilTemps.getTempC(temperatureAddresses[i]);

  int soilHumidity[7];
  for (int i = 0; i < 7; ++i) {
    selectMuxChannel(i); delay(100);
    soilHumidity[i] = constrain(map(averageAnalog(SOIL_MUX_PIN, 5), SOIL_DRY, SOIL_WET, 0, 100), 0, 100);
  }
  int light = constrain(map(averageAnalog(PHOTO_PIN), 4095, 0, 0, 100), 0, 100);
  int rain = constrain(map(averageAnalog(RAIN_PIN), RAIN_DRY, RAIN_WET, 0, 100), 0, 100);
  float volts = batteryVoltage();

  String body = "station_id=" + String(STATION_ID);
  body += "&temperature_air=" + String(airTemp, 1);
  body += "&humidity_air=" + String(airHumidity, 1);
  body += "&pressure=" + String(pressureMmHg, 1);
  body += "&illumination=" + String(light);
  const int depth[] = {0,15,30,45,60,75,90};
  for (int i = 0; i < 7; ++i) {
    body += "&humidity_soil_" + String(depth[i]) + "=" + String(soilHumidity[i]);
    body += "&temperature_soil_" + String(depth[i]) + "=" + String(soilTemperature[i], 1);
  }
  body += "&precipitation=" + String(rain);
  body += "&battery=" + String(batteryPercent(volts));
  body += "&version_firmware=1.0.0";

  Serial.println(body);
  sim900.begin(9600, SERIAL_8N1, SIM_RX_PIN, SIM_TX_PIN);
  if (beginQueue()) { queueMeasurement(body); sendQueue(); }

  digitalWrite(SENSOR_POWER_PIN, LOW);
  esp_sleep_enable_timer_wakeup(SLEEP_US);
  delay(100);
  esp_deep_sleep_start();
}

void loop() {}