Integration Guide

/*
 * ════════════════════════════════════════════════════════════════
 *  Arduino Uno/Mega + ESP8266 Module — Multi-Sensor Monitor
 *  Production-ready  •  Add unlimited sensors in 2 steps
 * ════════════════════════════════════════════════════════════════
 *
 *  WIRING (ESP8266 as serial WiFi via AT commands):
 *   Arduino D2  → ESP8266 TX
 *   Arduino D3  → ESP8266 RX  (use 3.3 V level-shifter)
 *   ESP8266 VCC → 3.3 V (NOT 5 V — will damage module)
 *   ESP8266 GND → GND
 *   ESP8266 CH_EN → 3.3 V
 *
 *  HOW TO ADD A NEW SENSOR:
 *   Step 1 — Write a float function that reads the sensor value
 *   Step 2 — Add one row to the SENSORS[] table below
 *
 *  LIBRARY: WiFiEsp by bportaluri (Arduino Library Manager)
 *  SERIAL MONITOR: 9600 baud
 * ════════════════════════════════════════════════════════════════
 */

#include <WiFiEsp.h>
#include <SoftwareSerial.h>

// ── STEP 0 — Credentials & server ────────────────────────────────
const char* WIFI_SSID     = "Your-SSID";
const char* WIFI_PASSWORD = "Your-Password";
const char* API_KEY       = "";

// Production server
const char* SERVER_HOST = "iot.getyourprojectdone.in";
const int   SERVER_PORT = 443;          // 443 = HTTPS/SSL
// Local LAMPP: SERVER_HOST = "192.168.x.x";  SERVER_PORT = 80;

// API path on the server
const char* API_PATH = "/api/insert_data.php";
// Local LAMPP:  const char* API_PATH = "/iot_platform/api/insert_data.php";

const unsigned long SEND_INTERVAL = 15000;  // 15 seconds (AT commands are slower)
// ─────────────────────────────────────────────────────────────────


// ════════════════════════════════════════════════════════════════
//  STEP 1 — Write one float function per sensor
// ════════════════════════════════════════════════════════════════

float readTemperature() {
  // TODO: e.g. return dht.readTemperature();
  return 27.5;
}

float readHumidity() {
  // TODO: e.g. return dht.readHumidity();
  return 58.0;
}

float readGas() {
  // TODO: e.g. return analogRead(A0) * (5.0 / 1023.0) * 100;
  return 380.0;
}

float readDistance() {
  // TODO: e.g. ultrasonic pulseIn measurement
  return 100.0;
}


// ════════════════════════════════════════════════════════════════
//  STEP 2 — Register sensors in this table
//  "device_name" must EXACTLY match name on your Devices page
// ════════════════════════════════════════════════════════════════

struct Sensor {
  const char* deviceName;
  const char* type;
  const char* unit;
  float (*readFn)();
};

Sensor SENSORS[] = {
// { "device_name",   "sensor_type",  "unit",  readFunction   }
  { "temp_sensor",   "temperature",  "C",     readTemperature },
  { "hum_sensor",    "humidity",     "%",     readHumidity    },
  { "gas_sensor",    "gas",          "ppm",   readGas         },
  { "ultra_sensor",  "distance",     "cm",    readDistance    },
};

// ─────────────────────────────────────────────────────────────────
// Internals
// ─────────────────────────────────────────────────────────────────

const int SENSOR_COUNT = sizeof(SENSORS) / sizeof(SENSORS[0]);

SoftwareSerial espSerial(2, 3);   // RX=D2, TX=D3
WiFiEspClient  client;

unsigned long lastSend = 0;
int cycleNum = 0;

void setup() {
  Serial.begin(9600);
  espSerial.begin(9600);
  delay(2000);

  Serial.println(F("\n══════════════════════════════════"));
  Serial.println(F("  Arduino Multi-Sensor Monitor"));
  Serial.print(F("  Sensors: ")); Serial.println(SENSOR_COUNT);
  Serial.println(F("══════════════════════════════════\n"));

  WiFiEsp.init(&espSerial);

  if (WiFiEsp.status() == WL_NO_SHIELD) {
    Serial.println(F("[ERROR] ESP8266 not detected — check wiring"));
    while (true);
  }

  connectWiFi();
  lastSend = millis() - SEND_INTERVAL;
}

void loop() {
  if (WiFiEsp.status() != WL_CONNECTED) {
    Serial.println(F("[WiFi] Reconnecting..."));
    connectWiFi();
    return;
  }

  if (millis() - lastSend >= SEND_INTERVAL) {
    lastSend = millis();
    cycleNum++;
    Serial.print(F("\n─── Cycle #")); Serial.print(cycleNum); Serial.println(F(" ───"));
    sendAllSensors();
  }
}

// ── Build JSON and POST ───────────────────────────────────────────
void sendAllSensors() {

  float values[SENSOR_COUNT];
  for (int i = 0; i < SENSOR_COUNT; i++) {
    values[i] = SENSORS[i].readFn();
    Serial.print(F("[Sensor] ")); Serial.print(SENSORS[i].deviceName);
    Serial.print(F(" = ")); Serial.print(values[i]); Serial.println(SENSORS[i].unit);
  }

  // Build JSON manually (no ArduinoJson on Uno — saves RAM)
  String json = F("{\"api_key\":\"");
  json += API_KEY;
  json += F("\",\"devices\":[");

  for (int i = 0; i < SENSOR_COUNT; i++) {
    if (i > 0) json += ',';
    json += F("{\"device_name\":\"");
    json += SENSORS[i].deviceName;
    json += F("\",\"sensors\":[{\"type\":\"");
    json += SENSORS[i].type;
    json += F("\",\"value\":\"");
    json += String(values[i], 2);
    json += F("\",\"unit\":\"");
    json += SENSORS[i].unit;
    json += F("\"}]}");
  }
  json += F("]}");

  Serial.print(F("[HTTP] Payload length: ")); Serial.println(json.length());
  sendPost(json);
}

// ── AT-command HTTP/HTTPS POST ────────────────────────────────────
void sendPost(const String& json) {
  bool useSSL = (SERVER_PORT == 443);

  // Build HTTP request string
  String request  = F("POST ");
  request += API_PATH;
  request += F(" HTTP/1.1\r\nHost: ");
  request += SERVER_HOST;
  request += F("\r\nContent-Type: application/json\r\nContent-Length: ");
  request += json.length();
  request += F("\r\nConnection: close\r\n\r\n");
  request += json;

  // Connect via SSL or TCP
  int ok;
  if (useSSL) {
    ok = client.connectSSL(SERVER_HOST, SERVER_PORT);
  } else {
    ok = client.connect(SERVER_HOST, SERVER_PORT);
  }

  if (!ok) {
    Serial.println(F("[HTTP] Connection failed"));
    return;
  }

  client.print(request);
  Serial.println(F("[HTTP] Request sent — reading response..."));

  // Read response (skip headers, grab body)
  String body = "";
  bool   inBody = false;
  unsigned long t = millis();

  while ((client.connected() || client.available()) && millis() - t < 8000) {
    while (client.available()) {
      String line = client.readStringUntil('\n');
      if (!inBody && line == "\r") { inBody = true; continue; }
      if (inBody) { body += line; }
    }
  }
  client.stop();

  body.trim();
  Serial.print(F("[Server] ")); Serial.println(body.isEmpty() ? F("(no body)") : body.c_str());
}

// ── WiFi ──────────────────────────────────────────────────────────
void connectWiFi() {
  Serial.print(F("[WiFi] Connecting to "));
  Serial.print(WIFI_SSID);

  int status = WL_IDLE_STATUS;
  int tries  = 0;
  while (status != WL_CONNECTED && tries < 10) {
    status = WiFiEsp.begin(WIFI_SSID, WIFI_PASSWORD);
    Serial.print('.');
    tries++;
  }

  if (WiFiEsp.status() == WL_CONNECTED) {
    Serial.println(F(" connected!"));
    Serial.print(F("[WiFi] IP: "));
    Serial.println(WiFiEsp.localIP());
  } else {
    Serial.println(F(" FAILED — check SSID/password or ESP8266 baud rate"));
  }
}

"""
════════════════════════════════════════════════════════════════
 Raspberry Pi Pico W — Multi-Sensor Monitor  (MicroPython)
 Production-ready  •  Add unlimited sensors in 2 steps
════════════════════════════════════════════════════════════════

 HOW TO ADD A NEW SENSOR:
  Step 1 — Write a function that returns a float value
  Step 2 — Add one dict to the SENSORS list below

 FIRMWARE: MicroPython for Pico W
   https://micropython.org/download/rp2-pico-w/

 NOTE: For a full Raspberry Pi (Linux/Raspbian), see the note
 at the bottom of this file — uses the standard `requests` lib.
════════════════════════════════════════════════════════════════
"""

import network
import urequests
import ujson
import utime

# ── STEP 0 — Credentials & server ────────────────────────────────
WIFI_SSID     = "Your-SSID"
WIFI_PASSWORD = "Your-Password"
API_KEY       = ""   # from dashboard → API Key pill

# Production server (HTTPS)
SERVER = "https://iot.getyourprojectdone.in"

# Local LAMPP testing — comment out SERVER above, use this:
# SERVER = "http://192.168.x.x/iot_platform"

SEND_INTERVAL = 10   # seconds between sends
# ─────────────────────────────────────────────────────────────────


# ════════════════════════════════════════════════════════════════
#  STEP 1 — Write one function per sensor.
#  Each function must return a float.
#  Replace the simulated values with real sensor reads.
#  See the SENSOR SNIPPETS section at the bottom for DHT11,
#  DS18B20, BMP280, HC-SR04, MQ-2, LDR, and more.
# ════════════════════════════════════════════════════════════════

def read_temperature():
    # TODO: e.g. from machine import ADC (onboard sensor)
    # or use DHT11/DHT22 library
    return 27.5   # simulated

def read_humidity():
    # TODO: e.g. dht_sensor.humidity()
    return 62.0   # simulated

def read_gas():
    # TODO: e.g. ADC(26).read_u16() / 65535 * 100
    return 350.0  # simulated

def read_distance():
    # TODO: HC-SR04 pulse measurement
    return 115.0  # simulated


# ════════════════════════════════════════════════════════════════
#  STEP 2 — Register sensors in this list.
#  Add or remove dicts freely — nothing else needs to change.
#
#  Keys:
#    "device"  — must EXACTLY match name on your Devices page
#    "type"    — temperature | humidity | gas | distance |
#                pressure | light | ph | co2 | motion | custom
#    "unit"    — C | F | % | ppm | cm | hPa | lux | V | etc.
#    "fn"      — the function you wrote in Step 1
# ════════════════════════════════════════════════════════════════

SENSORS = [
    # { "device": "device_name", "type": "sensor_type", "unit": "unit", "fn": read_function },
    { "device": "temp_sensor",  "type": "temperature", "unit": "C",   "fn": read_temperature },
    { "device": "hum_sensor",   "type": "humidity",    "unit": "%",   "fn": read_humidity    },
    { "device": "gas_sensor",   "type": "gas",         "unit": "ppm", "fn": read_gas         },
    { "device": "ultra_sensor", "type": "distance",    "unit": "cm",  "fn": read_distance    },

    # Add more dicts here:
    # { "device": "pressure_sensor", "type": "pressure", "unit": "hPa", "fn": read_pressure },
]

# ─────────────────────────────────────────────────────────────────
# Internals — no changes needed below this line
# ─────────────────────────────────────────────────────────────────

def connect_wifi():
    wlan = network.WLAN(network.STA_IF)
    wlan.active(True)
    if wlan.isconnected():
        return wlan

    print(f"[WiFi] Connecting to {WIFI_SSID}", end="")
    wlan.connect(WIFI_SSID, WIFI_PASSWORD)

    for _ in range(30):
        if wlan.isconnected():
            break
        utime.sleep(1)
        print(".", end="")

    if wlan.isconnected():
        print(f" connected!\n[WiFi] IP: {wlan.ifconfig()[0]}")
    else:
        print("\n[WiFi] FAILED — check SSID/password")

    return wlan


def send_all_sensors():
    # Read all values
    readings = []
    for s in SENSORS:
        try:
            val = s["fn"]()
            readings.append((s, round(float(val), 2)))
            print(f"[Sensor] {s['device']:<18} = {val} {s['unit']}")
        except Exception as e:
            print(f"[Sensor] {s['device']} ERROR: {e}")

    if not readings:
        print("[Send] No valid readings — skipping")
        return

    # Build payload
    payload = {
        "api_key": API_KEY,
        "devices": [
            {
                "device_name": s["device"],
                "sensors": [
                    {
                        "type":  s["type"],
                        "value": str(val),
                        "unit":  s["unit"]
                    }
                ]
            }
            for s, val in readings
        ]
    }

    url  = SERVER + "/api/insert_data.php"
    body = ujson.dumps(payload)

    print(f"[HTTP] POST → {url}")

    try:
        resp = urequests.post(
            url,
            data=body,
            headers={"Content-Type": "application/json"}
        )
        result = resp.text
        resp.close()
        print(f"[Server] {result}")

    except OSError as e:
        print(f"[HTTP] ERROR: {e}")
        print("       Check SERVER and network connection")


def main():
    print("\n══════════════════════════════════")
    print("  Pico W Multi-Sensor Monitor")
    print(f"  Sensors  : {len(SENSORS)}")
    print(f"  Interval : {SEND_INTERVAL}s")
    print("══════════════════════════════════\n")

    wlan = connect_wifi()
    cycle = 0

    while True:
        if not wlan.isconnected():
            print("[WiFi] Connection lost — reconnecting...")
            wlan = connect_wifi()

        cycle += 1
        print(f"\n─── Cycle #{cycle} ───────────────────────")
        send_all_sensors()
        utime.sleep(SEND_INTERVAL)


main()


# ════════════════════════════════════════════════════════════════
#  SENSOR SNIPPETS — copy what you need into Step 1
# ════════════════════════════════════════════════════════════════
#
#  ── Onboard temperature (Pico W only) ──────────────────────────
#  from machine import ADC
#  _adc = ADC(4)
#  def read_temperature():
#      v = _adc.read_u16() * 3.3 / 65535
#      return round(27 - (v - 0.706) / 0.001721, 1)
#
#  ── DHT11 / DHT22 ───────────────────────────────────────────────
#  import dht
#  from machine import Pin
#  _dht = dht.DHT11(Pin(15))   # or DHT22
#  def read_temperature():
#      _dht.measure(); return _dht.temperature()
#  def read_humidity():
#      _dht.measure(); return _dht.humidity()
#
#  ── HC-SR04 Ultrasonic ──────────────────────────────────────────
#  from machine import Pin, time_pulse_us
#  _trig = Pin(14, Pin.OUT)
#  _echo = Pin(15, Pin.IN)
#  def read_distance():
#      _trig.low(); utime.sleep_us(2)
#      _trig.high(); utime.sleep_us(10); _trig.low()
#      dur = time_pulse_us(_echo, 1, 30000)
#      return round(dur / 58.0, 1) if dur > 0 else 0
#
#  ── MQ-2 Gas sensor (ADC) ───────────────────────────────────────
#  from machine import ADC
#  _adc = ADC(26)              # GP26 = ADC0
#  def read_gas():
#      return round(_adc.read_u16() / 65535 * 100, 1)
#
#  ── LDR Light sensor ────────────────────────────────────────────
#  from machine import ADC
#  _ldr = ADC(27)              # GP27 = ADC1
#  def read_light():
#      return round(_ldr.read_u16() / 65535 * 100, 1)
#
# ════════════════════════════════════════════════════════════════
#  FOR FULL RASPBERRY PI (Raspbian / Linux)
#  Replace the entire file with this simpler version:
#
#  pip3 install requests
#
#  import requests, time
#
#  SERVER = "https://iot.getyourprojectdone.in"
#  API_KEY = ""
#
#  SENSORS = [
#      { "device": "temp_sensor",  "type": "temperature", "unit": "C",  "fn": lambda: 28.5 },
#      { "device": "hum_sensor",   "type": "humidity",    "unit": "%",  "fn": lambda: 60.0 },
#  ]
#
#  while True:
#      payload = {
#          "api_key": API_KEY,
#          "devices": [
#              {"device_name": s["device"],
#               "sensors": [{"type": s["type"], "value": str(s["fn"]()), "unit": s["unit"]}]}
#              for s in SENSORS
#          ]
#      }
#      r = requests.post(SERVER + "/api/insert_data.php", json=payload)
#      print(r.json())
#      time.sleep(10)
# ════════════════════════════════════════════════════════════════

/*
 * ════════════════════════════════════════════════════════════════
 *  sensor_library.h — Sensor Accessory Code
 *  Copy-paste any section you need into esp8266_monitor.ino
 *  or ardiuno_monitor.ino as your Step 1 read functions.
 * ════════════════════════════════════════════════════════════════
 *
 *  USAGE:
 *   1. Install the required library for your sensor
 *   2. Copy the ENTIRE section (includes + pin define + function)
 *      into your .ino file above the SENSORS[] table
 *   3. Use the read function in the SENSORS[] table
 *
 *  AVAILABLE SENSORS:
 *   • DHT11 / DHT22    — Temperature + Humidity
 *   • BMP280           — Temperature + Pressure
 *   • DS18B20          — Temperature (waterproof)
 *   • HC-SR04          — Ultrasonic Distance
 *   • MQ-2 / MQ-135   — Gas / Air Quality (analog)
 *   • LDR              — Light level (analog)
 *   • Soil Moisture    — Analog moisture sensor
 *   • ACS712           — Current sensor (analog)
 *   • PIR              — Motion detection (digital)
 *   • Water Level      — Analog water level
 * ════════════════════════════════════════════════════════════════
 */

#pragma once

// ════════════════════════════════════════════════════════════════
//  DHT11 / DHT22 — Temperature & Humidity
//  Library: "DHT sensor library" by Adafruit  (Library Manager)
//  Also install: "Adafruit Unified Sensor"
// ════════════════════════════════════════════════════════════════
/*
#include <DHT.h>

#define DHT_PIN   D5        // change to your data pin
#define DHT_TYPE  DHT11     // DHT11 or DHT22

DHT dht(DHT_PIN, DHT_TYPE);

void initDHT() { dht.begin(); }

float readDHT_Temp() {
  float t = dht.readTemperature();
  return isnan(t) ? -1 : t;
}

float readDHT_Humidity() {
  float h = dht.readHumidity();
  return isnan(h) ? -1 : h;
}

// Add to SENSORS[]:
// { "temp_sensor",     "temperature", "C",  readDHT_Temp     },
// { "humidity_sensor", "humidity",    "%",  readDHT_Humidity },

// Add to setup():
//   initDHT();
*/


// ════════════════════════════════════════════════════════════════
//  BMP280 — Temperature & Barometric Pressure
//  Library: "Adafruit BMP280 Library"  (Library Manager)
//  Wiring: SDA → D2 (GPIO4), SCL → D1 (GPIO5)  [I2C]
// ════════════════════════════════════════════════════════════════
/*
#include <Wire.h>
#include <Adafruit_BMP280.h>

Adafruit_BMP280 bmp;

void initBMP() {
  if (!bmp.begin(0x76)) {  // try 0x77 if 0x76 fails
    Serial.println("[BMP280] Not found — check wiring");
  }
}

float readBMP_Temp()     { return bmp.readTemperature(); }   // °C
float readBMP_Pressure() { return bmp.readPressure() / 100.0; }  // hPa

// Add to SENSORS[]:
// { "temp_sensor",     "temperature", "C",   readBMP_Temp     },
// { "pressure_sensor", "pressure",    "hPa", readBMP_Pressure },

// Add to setup():
//   Wire.begin(); initBMP();
*/


// ════════════════════════════════════════════════════════════════
//  DS18B20 — Waterproof Temperature Sensor (1-Wire)
//  Library: "DallasTemperature" + "OneWire"  (Library Manager)
//  Wiring: Data → any digital pin, 4.7 kΩ pullup to 3.3 V
// ════════════════════════════════════════════════════════════════
/*
#include <OneWire.h>
#include <DallasTemperature.h>

#define DS18B20_PIN  D4

OneWire           oneWire(DS18B20_PIN);
DallasTemperature ds18b20(&oneWire);

void initDS18B20() { ds18b20.begin(); }

float readDS18B20() {
  ds18b20.requestTemperatures();
  float t = ds18b20.getTempCByIndex(0);
  return (t == DEVICE_DISCONNECTED_C) ? -1 : t;
}

// Add to SENSORS[]:
// { "temp_sensor", "temperature", "C", readDS18B20 },

// Add to setup():
//   initDS18B20();
*/


// ════════════════════════════════════════════════════════════════
//  HC-SR04 — Ultrasonic Distance Sensor
//  No library needed — uses pulseIn()
//  Wiring: VCC → 5V, TRIG → D6, ECHO → D7 (use voltage divider!)
// ════════════════════════════════════════════════════════════════
/*
#define ULTRASONIC_TRIG  D6   // GPIO12
#define ULTRASONIC_ECHO  D7   // GPIO13

void initUltrasonic() {
  pinMode(ULTRASONIC_TRIG, OUTPUT);
  pinMode(ULTRASONIC_ECHO, INPUT);
}

float readUltrasonic() {
  // Send pulse
  digitalWrite(ULTRASONIC_TRIG, LOW);
  delayMicroseconds(2);
  digitalWrite(ULTRASONIC_TRIG, HIGH);
  delayMicroseconds(10);
  digitalWrite(ULTRASONIC_TRIG, LOW);

  // Measure echo (timeout = 30 ms → max ~500 cm)
  long duration = pulseIn(ULTRASONIC_ECHO, HIGH, 30000);
  if (duration == 0) return -1;  // out of range
  return duration / 58.0;        // convert to cm
}

// Add to SENSORS[]:
// { "distance_sensor", "distance", "cm", readUltrasonic },

// Add to setup():
//   initUltrasonic();
*/


// ════════════════════════════════════════════════════════════════
//  MQ-2 / MQ-135 — Gas / Air Quality Sensor (Analog)
//  No library needed — uses analogRead()
//  Wiring: AO → A0 (ESP8266 only has one ADC pin)
//  Note: ESP8266 ADC is 0-1V (use voltage divider if needed)
// ════════════════════════════════════════════════════════════════
/*
#define GAS_PIN  A0

float readGas() {
  int raw = analogRead(GAS_PIN);          // 0–1023
  return raw * (100.0 / 1023.0);          // 0–100% scale
  // For actual ppm, use sensor datasheet calibration curve
}

// Add to SENSORS[]:
// { "gas_sensor", "gas", "%", readGas },
*/


// ════════════════════════════════════════════════════════════════
//  LDR — Light Dependent Resistor (Analog)
//  Wiring: LDR + 10 kΩ resistor voltage divider → A0
// ════════════════════════════════════════════════════════════════
/*
#define LDR_PIN  A0

float readLDR() {
  int raw = analogRead(LDR_PIN);          // 0 = dark, 1023 = bright
  return raw * (100.0 / 1023.0);          // 0–100 lux scale (approximate)
}

// Add to SENSORS[]:
// { "light_sensor", "light", "lux", readLDR },
*/


// ════════════════════════════════════════════════════════════════
//  Soil Moisture Sensor (Analog)
//  Wiring: AO → A0
//  Output: 0% = dry, 100% = wet (inverted — raw 1023=dry, 0=wet)
// ════════════════════════════════════════════════════════════════
/*
#define SOIL_PIN  A0

float readSoilMoisture() {
  int raw = analogRead(SOIL_PIN);
  return (1023 - raw) * (100.0 / 1023.0);  // invert so 100% = wet
}

// Add to SENSORS[]:
// { "soil_sensor", "moisture", "%", readSoilMoisture },
*/


// ════════════════════════════════════════════════════════════════
//  ACS712 — Current Sensor (5A / 20A / 30A variants) (Analog)
//  Wiring: OUT → A0
// ════════════════════════════════════════════════════════════════
/*
#define ACS712_PIN       A0
#define ACS712_SENSITIVITY  0.185   // V/A for 5A module (use 0.100 for 20A, 0.066 for 30A)
#define ACS712_VREF         2.5     // V  (midpoint at VCC/2)

float readCurrent() {
  int   raw     = analogRead(ACS712_PIN);
  float voltage = raw * (3.3 / 1023.0);          // ADC voltage
  float current = (voltage - ACS712_VREF) / ACS712_SENSITIVITY;
  return abs(current);
}

// Add to SENSORS[]:
// { "current_sensor", "current", "A", readCurrent },
*/


// ════════════════════════════════════════════════════════════════
//  PIR — Motion Detection Sensor (Digital)
//  Wiring: OUT → D5 (any digital pin)
//  Returns 1.0 = motion detected, 0.0 = no motion
// ════════════════════════════════════════════════════════════════
/*
#define PIR_PIN  D5

void initPIR() { pinMode(PIR_PIN, INPUT); }

float readPIR() {
  return digitalRead(PIR_PIN) ? 1.0 : 0.0;
}

// Add to SENSORS[]:
// { "pir_sensor", "motion", "", readPIR },

// Add to setup():
//   initPIR();
*/


// ════════════════════════════════════════════════════════════════
//  Water Level Sensor (Analog)
//  Wiring: S (signal) → A0
// ════════════════════════════════════════════════════════════════
/*
#define WATER_PIN  A0

float readWaterLevel() {
  int raw = analogRead(WATER_PIN);
  return raw * (100.0 / 1023.0);   // 0–100%
}

// Add to SENSORS[]:
// { "water_sensor", "water_level", "%", readWaterLevel },
*/