ESP32 Control Project

#include <Arduino.h>
#include <Wire.h>
#include <DHT.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include <Adafruit_NeoPixel.h>
#include <BLEDevice.h>
#include <BLEServer.h>
#include <BLEUtils.h>
#include <BLE2902.h>

// Required GPIO assignments
constexpr uint8_t DHT_PIN = 14;
constexpr uint8_t LDR_PIN = 15;
constexpr uint8_t WATER_PIN = 39;
constexpr uint8_t SMOKE_IN_PIN = 32;
constexpr uint8_t SMOKE_OUT_PIN = 33;
constexpr uint8_t BATTERY_PIN = 35;
constexpr uint8_t PUMP_RELAY_PIN = 25;
constexpr uint8_t BUZZER_PIN = 27;
constexpr uint8_t MATRIX_PIN = 4;
constexpr uint8_t OLED_SDA_PIN = 21;
constexpr uint8_t OLED_SCL_PIN = 22;

// Adjustable application thresholds. Change only these values when tuning the system.
constexpr float TEMPERATURE_LIMIT_C = 35.0f;
constexpr int LIGHT_DARK_THRESHOLD = 1800;
constexpr int WATER_DETECTED_THRESHOLD = 600;
constexpr int SMOKE_IN_ALERT_THRESHOLD = 1800;
constexpr int SMOKE_OUT_ALERT_THRESHOLD = 1800;

// Battery-divider calibration: this assumes the existing divider reduces battery voltage by 3:1.
// Example: 20 kOhm from BAT+ to OUT and 10 kOhm from OUT to GND.
constexpr float BATTERY_DIVIDER_RATIO = 3.0f;
constexpr float BATTERY_CALIBRATION = 1.000f;
constexpr float BATTERY_EMPTY_V = 6.00f;
constexpr float BATTERY_FULL_V = 8.40f;

constexpr bool RELAY_ACTIVE_LOW = true;
constexpr uint8_t DHT_TYPE = DHT11;
constexpr uint8_t BUZZER_CHANNEL = 0;
constexpr uint32_t SENSOR_INTERVAL_MS = 1000;
constexpr uint32_t DISPLAY_PAGE_INTERVAL_MS = 3000;
constexpr uint32_t BLE_UPDATE_INTERVAL_MS = 1000;
constexpr uint8_t MATRIX_BRIGHTNESS = 12; // Keeps the 8x8 matrix current low.

const char *DEVICE_NAME = "#BIOTECH PRANVAYU 0001";
const char *SERVICE_UUID = "7a8353f1-5e19-4e6b-80d8-4c6300020001";
const char *STATUS_UUID  = "7a8353f1-5e19-4e6b-80d8-4c6300020002";

DHT dht(DHT_PIN, DHT_TYPE);
Adafruit_SSD1306 display(128, 64, &Wire, -1);
Adafruit_NeoPixel matrix(64, MATRIX_PIN, NEO_GRB + NEO_KHZ800);
BLECharacteristic *statusCharacteristic = nullptr;

struct SystemState {
  float temperatureC = NAN;
  int lightRaw = 0;
  int waterRaw = 0;
  int smokeInRaw = 0;
  int smokeOutRaw = 0;
  float batteryV = 0.0f;
  int batteryPercent = 0;
  bool temperatureValid = false;
  bool waterDetected = false;
  bool dark = false;
  bool smokeInAlert = false;
  bool smokeOutAlert = false;
  bool pumpOn = false;
  bool buzzerOn = false;
  bool matrixOn = false;
  bool bleConnected = false;
};

SystemState state;
uint32_t lastSensorMs = 0;
uint32_t lastDisplayMs = 0;
uint32_t lastBleMs = 0;
uint8_t displayPage = 0;

class ServerCallbacks : public BLEServerCallbacks {
  void onConnect(BLEServer *) override { state.bleConnected = true; }
  void onDisconnect(BLEServer *server) override {
    state.bleConnected = false;
    delay(100);
    server->startAdvertising();
  }
};

void setRelay(bool on) {
  state.pumpOn = on;
  bool level = RELAY_ACTIVE_LOW ? !on : on;
  digitalWrite(PUMP_RELAY_PIN, level ? HIGH : LOW);
}

void setBuzzer(bool on) {
  state.buzzerOn = on;
  if (on) {
    ledcWriteTone(BUZZER_PIN, 2400);
  } else {
    ledcWriteTone(BUZZER_PIN, 0);
  }
}

void setMatrix(bool on) {
  state.matrixOn = on;
  matrix.clear();
  if (on) {
    for (uint16_t i = 0; i < matrix.numPixels(); ++i) {
      matrix.setPixelColor(i, matrix.Color(0, 35, 0));
    }
  }
  matrix.show();
}

float readBatteryVoltage() {
  uint32_t millivolts = analogReadMilliVolts(BATTERY_PIN);
  return (millivolts / 1000.0f) * BATTERY_DIVIDER_RATIO * BATTERY_CALIBRATION;
}

int batteryPercent(float voltage) {
  float percent = (voltage - BATTERY_EMPTY_V) * 100.0f / (BATTERY_FULL_V - BATTERY_EMPTY_V);
  return constrain((int)lroundf(percent), 0, 100);
}

void readSensorsAndControl() {
  float reading = dht.readTemperature();
  if (!isnan(reading)) {
    state.temperatureC = reading;
    state.temperatureValid = true;
  } else {
    state.temperatureValid = false;
  }

  state.lightRaw = analogRead(LDR_PIN);
  state.waterRaw = analogRead(WATER_PIN);
  state.smokeInRaw = analogRead(SMOKE_IN_PIN);
  state.smokeOutRaw = analogRead(SMOKE_OUT_PIN);
  state.batteryV = readBatteryVoltage();
  state.batteryPercent = batteryPercent(state.batteryV);

  state.dark = state.lightRaw < LIGHT_DARK_THRESHOLD;
  state.waterDetected = state.waterRaw >= WATER_DETECTED_THRESHOLD;
  state.smokeInAlert = state.smokeInRaw >= SMOKE_IN_ALERT_THRESHOLD;
  state.smokeOutAlert = state.smokeOutRaw >= SMOKE_OUT_ALERT_THRESHOLD;

  bool overTemperature = state.temperatureValid && state.temperatureC >= TEMPERATURE_LIMIT_C;
  bool critical = state.waterDetected || state.smokeInAlert || state.smokeOutAlert || overTemperature;
  setRelay(overTemperature || state.smokeInAlert || state.smokeOutAlert);
  setBuzzer(critical);
  setMatrix(state.dark);
}

void printHeader(const char *title) {
  display.setTextSize(1);
  display.setTextColor(SSD1306_WHITE);
  display.setCursor(0, 0);
  display.print("BIOTECH PRANVAYU");
  display.setCursor(0, 10);
  display.print(title);
}

void drawDisplay() {
  display.clearDisplay();
  if (displayPage == 0) {
    printHeader("ENVIRONMENT");
    display.setCursor(0, 23);
    if (state.temperatureValid) {
      display.printf("Temp: %.1f C", state.temperatureC);
    } else {
      display.print("Temp: SENSOR ERROR");
    }
    display.setCursor(0, 35);
    display.printf("Light: %d %s", state.lightRaw, state.dark ? "DARK" : "BRIGHT");
    display.setCursor(0, 47);
    display.printf("Water: %s", state.waterDetected ? "DETECTED" : "NORMAL");
  } else if (displayPage == 1) {
    printHeader("SMOKE / BATTERY");
    display.setCursor(0, 23);
    display.printf("Smoke IN : %d", state.smokeInRaw);
    display.setCursor(0, 35);
    display.printf("Smoke OUT: %d", state.smokeOutRaw);
    display.setCursor(0, 47);
    display.printf("Battery: %.2fV %d%%", state.batteryV, state.batteryPercent);
  } else {
    printHeader("SYSTEM STATUS");
    display.setCursor(0, 23);
    display.printf("Air pump: %s", state.pumpOn ? "ON" : "OFF");
    display.setCursor(0, 35);
    display.printf("Buzzer: %s", state.buzzerOn ? "ALERT" : "OFF");
    display.setCursor(0, 47);
    display.printf("Matrix:%s BLE:%s", state.matrixOn ? "ON" : "OFF", state.bleConnected ? "ON" : "WAIT");
  }
  display.display();
}

String makeStatusJson() {
  String payload = "{";
  payload += "\"project\":\"BIOTECH PRANVAYU\",";
  payload += "\"temperature_c\":" + String(state.temperatureValid ? state.temperatureC : -127.0f, 1) + ",";
  payload += "\"light_raw\":" + String(state.lightRaw) + ",";
  payload += "\"light_status\":\"" + String(state.dark ? "DARK" : "BRIGHT") + "\",";
  payload += "\"water_status\":\"" + String(state.waterDetected ? "WATER DETECTED" : "NORMAL") + "\",";
  payload += "\"smoke_input\":" + String(state.smokeInRaw) + ",";
  payload += "\"smoke_output\":" + String(state.smokeOutRaw) + ",";
  payload += "\"battery_percent\":" + String(state.batteryPercent) + ",";
  payload += "\"battery_voltage\":" + String(state.batteryV, 2) + ",";
  payload += "\"air_pump\":\"" + String(state.pumpOn ? "ON" : "OFF") + "\",";
  payload += "\"buzzer\":\"" + String(state.buzzerOn ? "ON" : "OFF") + "\",";
  payload += "\"matrix\":\"" + String(state.matrixOn ? "ON" : "OFF") + "\",";
  payload += "\"ble_connected\":" + String(state.bleConnected ? "true" : "false");
  payload += "}";
  return payload;
}

void updateBle() {
  if (statusCharacteristic == nullptr) return;
  String payload = makeStatusJson();
  statusCharacteristic->setValue(payload.c_str());
  if (state.bleConnected) statusCharacteristic->notify();
}

void setupBle() {
  BLEDevice::init(DEVICE_NAME);
  BLEServer *server = BLEDevice::createServer();
  server->setCallbacks(new ServerCallbacks());
  BLEService *service = server->createService(SERVICE_UUID);
  statusCharacteristic = service->createCharacteristic(
      STATUS_UUID, BLECharacteristic::PROPERTY_READ | BLECharacteristic::PROPERTY_NOTIFY);
  statusCharacteristic->addDescriptor(new BLE2902());
  statusCharacteristic->setValue("Starting");
  service->start();
  BLEAdvertising *advertising = BLEDevice::getAdvertising();
  advertising->addServiceUUID(SERVICE_UUID);
  advertising->setScanResponse(true);
  BLEDevice::startAdvertising();
}

void setup() {
  pinMode(PUMP_RELAY_PIN, OUTPUT);
  pinMode(BUZZER_PIN, OUTPUT);
  setRelay(false);
  ledcAttach(BUZZER_PIN, 2000, 8);
  setBuzzer(false);

  analogReadResolution(12);
  analogSetPinAttenuation(LDR_PIN, ADC_11db);
  analogSetPinAttenuation(WATER_PIN, ADC_11db);
  analogSetPinAttenuation(SMOKE_IN_PIN, ADC_11db);
  analogSetPinAttenuation(SMOKE_OUT_PIN, ADC_11db);
  analogSetPinAttenuation(BATTERY_PIN, ADC_11db);

  dht.begin();
  matrix.begin();
  matrix.setBrightness(MATRIX_BRIGHTNESS);
  setMatrix(false);

  Wire.begin(OLED_SDA_PIN, OLED_SCL_PIN);
  if (display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
    display.clearDisplay();
    display.setTextColor(SSD1306_WHITE);
    display.setCursor(0, 0);
    display.println("BIOTECH PRANVAYU");
    display.println("Starting safely...");
    display.display();
  }
  setupBle();
}

void loop() {
  uint32_t now = millis();
  if (now - lastSensorMs >= SENSOR_INTERVAL_MS) {
    lastSensorMs = now;
    readSensorsAndControl();
  }
  if (now - lastDisplayMs >= DISPLAY_PAGE_INTERVAL_MS) {
    lastDisplayMs = now;
    displayPage = (displayPage + 1) % 3;
    drawDisplay();
  }
  if (now - lastBleMs >= BLE_UPDATE_INTERVAL_MS) {
    lastBleMs = now;
    updateBle();
  }
  delay(1);
}