AguaGuard Monitor de Calidad

#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <RTClib.h>
#include <SoftwareSerial.h>
#include <EEPROM.h>
#include <math.h>

const uint8_t PH_PIN = A0;
const uint8_t TDS_PIN = A1;
const uint8_t TURBIDITY_PIN = A2;
const uint8_t NTC_PIN = A3;
const uint8_t MEASURE_BUTTON = 2;
const uint8_t SCREEN_BUTTON = 3;
const uint8_t CALIBRATE_BUTTON = 4;
const uint8_t DIP_0 = 5;
const uint8_t DIP_1 = 6;
const uint8_t PUMP_PIN = 7;
const uint8_t TDS_ENABLE_PIN = 8;  // LOW powers the PNP-switched TDS board.
const uint8_t BUZZER_PIN = 9;
const uint8_t ESP_RX_PIN = 10;
const uint8_t ESP_TX_PIN = 11;
const uint8_t AMBER_LED = 12;
const uint8_t BLUE_LED = 13;

const unsigned long PUMP_MS = 5000UL;
const unsigned long SETTLE_MS = 8000UL;
const unsigned long TDS_WARMUP_MS = 1000UL;
const unsigned long BLUE_PULSE_MS = 250UL;
const float TDS_FACTOR = 0.50F;

LiquidCrystal_I2C lcd(0x27, 16, 2);
RTC_DS3231 rtc;
SoftwareSerial espLink(ESP_RX_PIN, ESP_TX_PIN);

enum CycleState { WAITING, PUMPING, SETTLING, TDS_WARMUP, READING, REPORTING };
CycleState state = WAITING;
unsigned long stateStarted = 0;
unsigned long nextMeasurement = 0;
unsigned long blueUntil = 0;
uint8_t screen = 0;

struct Calibration {
  uint16_t magic;
  float v4;
  float v686;
};
Calibration cal;
const uint16_t CAL_MAGIC = 0xCA17;
uint8_t calibrationStage = 0;
unsigned long calPressedAt = 0;
bool calWasDown = false;
bool screenWasDown = false;

struct Reading {
  float ph;
  float tds;
  float turbidity;
  float tempC;
  DateTime timestamp;
};
Reading reading;

bool buttonPressed(uint8_t pin) { return digitalRead(pin) == LOW; }

int averageAdc(uint8_t pin) {
  long sum = 0;
  for (uint8_t i = 0; i < 30; ++i) sum += analogRead(pin);
  return (int)(sum / 30L);
}

float adcVoltage(int raw) { return raw * (5.0F / 1023.0F); }

float readTemperatureC() {
  float v = adcVoltage(averageAdc(NTC_PIN));
  if (v < 0.02F || v > 4.98F) return NAN;
  float rNtc = 10000.0F * v / (5.0F - v);
  float kelvin = 1.0F / (1.0F / 298.15F + log(rNtc / 10000.0F) / 3950.0F);
  return kelvin - 273.15F;
}

float readPh() {
  float v = adcVoltage(averageAdc(PH_PIN));
  if (fabs(cal.v686 - cal.v4) < 0.02F) return 7.0F;
  return 4.0F + (v - cal.v4) * 2.86F / (cal.v686 - cal.v4);
}

float readTds(float tempC) {
  float voltage = adcVoltage(averageAdc(TDS_PIN));
  float compensation = 1.0F + 0.02F * (tempC - 25.0F);
  float compensatedVoltage = voltage / compensation;
  return (133.42F * compensatedVoltage * compensatedVoltage * compensatedVoltage
        - 255.86F * compensatedVoltage * compensatedVoltage
        + 857.39F * compensatedVoltage) * TDS_FACTOR;
}

float readTurbidity() {
  float voltage = adcVoltage(averageAdc(TURBIDITY_PIN));
  // Raw voltage is retained as the low-cost sensor's calibration reference.
  return voltage;
}

unsigned long selectedInterval() {
  uint8_t choice = (buttonPressed(DIP_1) ? 2 : 0) | (buttonPressed(DIP_0) ? 1 : 0);
  if (choice == 0) return 10UL * 60UL * 1000UL;
  if (choice == 1) return 30UL * 60UL * 1000UL;
  if (choice == 2) return 60UL * 60UL * 1000UL;
  return 24UL * 60UL * 60UL * 1000UL;
}

void showLine(const __FlashStringHelper *a, const String &b) {
  lcd.setCursor(0, 0); lcd.print(a); lcd.print(F("                "));
  lcd.setCursor(0, 1); lcd.print(b); lcd.print(F("                "));
}

void showReading() {
  lcd.clear();
  if (screen == 0) {
    lcd.print(F("pH ")); lcd.print(reading.ph, 2); lcd.print(F(" TDS"));
    lcd.setCursor(0, 1); lcd.print(reading.tds, 0); lcd.print(F(" ppm"));
  } else if (screen == 1) {
    lcd.print(F("Temp ")); lcd.print(reading.tempC, 1); lcd.print(F(" C"));
    lcd.setCursor(0, 1); lcd.print(F("Turb ")); lcd.print(reading.turbidity, 2); lcd.print(F(" V"));
  } else {
    lcd.print(reading.timestamp.year()); lcd.print('-'); lcd.print(reading.timestamp.month()); lcd.print('-'); lcd.print(reading.timestamp.day());
    lcd.setCursor(0, 1); lcd.print(reading.timestamp.hour()); lcd.print(':'); if (reading.timestamp.minute() < 10) lcd.print('0'); lcd.print(reading.timestamp.minute());
  }
}

void startCycle() {
  state = PUMPING;
  stateStarted = millis();
  digitalWrite(AMBER_LED, HIGH);
  digitalWrite(PUMP_PIN, HIGH);
  digitalWrite(TDS_ENABLE_PIN, HIGH);
  showLine(F("Tomando muestra"), F("Bomba encendida"));
}

void saveCalibrationVoltage(float voltage) {
  if (calibrationStage == 0) {
    cal.v4 = voltage;
    calibrationStage = 1;
    showLine(F("pH4 guardado"), F("Ponga buffer 6.86"));
  } else {
    cal.v686 = voltage;
    cal.magic = CAL_MAGIC;
    EEPROM.put(0, cal);
    calibrationStage = 0;
    showLine(F("Calibracion"), F("pH 4 y 6.86 lista"));
  }
}

void handleCalibrationButton() {
  bool down = buttonPressed(CALIBRATE_BUTTON);
  if (down && !calWasDown) calPressedAt = millis();
  if (!down && calWasDown && millis() - calPressedAt >= 1500UL) {
    saveCalibrationVoltage(adcVoltage(averageAdc(PH_PIN)));
  }
  calWasDown = down;
}

void reportReading() {
  char line[128];
  snprintf(line, sizeof(line), "%04d-%02d-%02dT%02d:%02d:%02dZ,river_tijuana,ph,%.2f,ph,raw,uno\n",
           reading.timestamp.year(), reading.timestamp.month(), reading.timestamp.day(), reading.timestamp.hour(), reading.timestamp.minute(), reading.timestamp.second(), reading.ph);
  espLink.print(line);
  snprintf(line, sizeof(line), "%04d-%02d-%02dT%02d:%02d:%02dZ,river_tijuana,solidos_disueltos_totales,%.1f,ppm,raw,uno\n",
           reading.timestamp.year(), reading.timestamp.month(), reading.timestamp.day(), reading.timestamp.hour(), reading.timestamp.minute(), reading.timestamp.second(), reading.tds);
  espLink.print(line);
  Serial.print(line);
  blueUntil = millis() + BLUE_PULSE_MS;
  digitalWrite(BLUE_LED, HIGH);
  if (reading.ph < 6.5F || reading.ph > 8.5F || reading.tds > 1000.0F) tone(BUZZER_PIN, 2200, 350);
}

void setup() {
  pinMode(PUMP_PIN, OUTPUT); pinMode(TDS_ENABLE_PIN, OUTPUT);
  pinMode(BUZZER_PIN, OUTPUT); pinMode(AMBER_LED, OUTPUT); pinMode(BLUE_LED, OUTPUT);
  pinMode(MEASURE_BUTTON, INPUT_PULLUP); pinMode(SCREEN_BUTTON, INPUT_PULLUP); pinMode(CALIBRATE_BUTTON, INPUT_PULLUP);
  pinMode(DIP_0, INPUT_PULLUP); pinMode(DIP_1, INPUT_PULLUP);
  digitalWrite(PUMP_PIN, LOW); digitalWrite(TDS_ENABLE_PIN, HIGH);
  Serial.begin(9600); espLink.begin(9600);
  Wire.begin(); lcd.init(); lcd.backlight();
  if (!rtc.begin()) { showLine(F("RTC no encontrado"), F("Revise A4 y A5")); }
  if (rtc.lostPower()) rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
  EEPROM.get(0, cal);
  if (cal.magic != CAL_MAGIC) { cal.magic = CAL_MAGIC; cal.v4 = 3.00F; cal.v686 = 2.50F; }
  showLine(F("Estacion de agua"), F("Lista para medir"));
  nextMeasurement = millis() + selectedInterval();
}

void loop() {
  unsigned long now = millis();
  handleCalibrationButton();
  bool screenDown = buttonPressed(SCREEN_BUTTON);
  if (screenDown && !screenWasDown && state == WAITING) { screen = (screen + 1) % 3; showReading(); }
  screenWasDown = screenDown;
  if (blueUntil && now >= blueUntil) { digitalWrite(BLUE_LED, LOW); blueUntil = 0; }

  if (state == WAITING) {
    if (buttonPressed(MEASURE_BUTTON) || now >= nextMeasurement) startCycle();
  } else if (state == PUMPING && now - stateStarted >= PUMP_MS) {
    digitalWrite(PUMP_PIN, LOW); state = SETTLING; stateStarted = now; showLine(F("Muestra quieta"), F("Esperando burbujas"));
  } else if (state == SETTLING && now - stateStarted >= SETTLE_MS) {
    digitalWrite(TDS_ENABLE_PIN, LOW); state = TDS_WARMUP; stateStarted = now; showLine(F("Midiendo TDS"), F("Sensor encendido"));
  } else if (state == TDS_WARMUP && now - stateStarted >= TDS_WARMUP_MS) {
    reading.tempC = readTemperatureC();
    reading.tds = readTds(reading.tempC);
    digitalWrite(TDS_ENABLE_PIN, HIGH);
    state = READING;
  } else if (state == READING) {
    reading.ph = readPh(); reading.turbidity = readTurbidity(); reading.timestamp = rtc.now();
    state = REPORTING;
  } else if (state == REPORTING) {
    reportReading(); showReading(); digitalWrite(AMBER_LED, LOW);
    nextMeasurement = now + selectedInterval(); state = WAITING;
  }
  delay(1);
}