Smart Agarbatti Packaging Dryer

#include <Arduino.h>
#include <Wire.h>
#include <Adafruit_SHT31.h>
#include <PID_v1.h>

// ESP32 control pins, matched to the wiring diagram.

// Hoisted type definitions
enum class PackageState { WAITING, CLAMPING, SEALING, COOLING, BEEPING, WAIT_FOR_CLEAR };


// Forward declarations
void setHeater(uint8_t duty);
void allPackagingOutputsOff();
void enterPackagingState(PackageState nextState, uint32_t now);
void readAndControlDryer(uint32_t now);
void runPackagingCycle(uint32_t now);

constexpr uint8_t HEATER_PIN = 25;
constexpr uint8_t INTAKE_FAN_PIN = 26;
constexpr uint8_t EXHAUST_FAN_PIN = 27;
constexpr uint8_t IR_SENSOR_PIN = 32;
constexpr uint8_t SOLENOID_PIN = 33;
constexpr uint8_t SEALER_PIN = 14;
constexpr uint8_t BUZZER_PIN = 13;
constexpr uint8_t SHT31_SDA_PIN = 21;
constexpr uint8_t SHT31_SCL_PIN = 22;

constexpr float TARGET_TEMP_C = 38.0F;
constexpr float MAX_SAFE_TEMP_C = 50.0F;
constexpr float HUMIDITY_LIMIT_PERCENT = 80.0F;
constexpr uint32_t SENSOR_INTERVAL_MS = 1000;
constexpr uint32_t PURGE_DURATION_MS = 30000;
constexpr uint32_t SOLENOID_SETTLE_MS = 100;
constexpr uint32_t SEAL_PULSE_MS = 1200;
constexpr uint32_t COOLING_HOLD_MS = 1500;
constexpr uint32_t BUZZER_MS = 300;
constexpr uint32_t POUCH_CLEAR_MS = 500;
constexpr uint8_t HEATER_PWM_CHANNEL = 0;
constexpr uint32_t HEATER_PWM_HZ = 5000;
constexpr uint8_t HEATER_PWM_BITS = 8;

Adafruit_SHT31 sht31;
double setpoint = TARGET_TEMP_C;
double inputTemp = 0.0;
double heaterOutput = 0.0;
PID heaterPID(&inputTemp, &heaterOutput, &setpoint, 10.0, 0.5, 1.0, DIRECT);


PackageState packageState = PackageState::WAITING;

bool sensorReady = false;
bool isPurging = false;
bool heaterSafetyLockout = false;
uint32_t lastSensorReadMs = 0;
uint32_t purgeStartedMs = 0;
uint32_t packageStateStartedMs = 0;

void setHeater(uint8_t duty) {
  ledcWrite(HEATER_PWM_CHANNEL, duty);
}

void allPackagingOutputsOff() {
  digitalWrite(SOLENOID_PIN, LOW);
  digitalWrite(SEALER_PIN, LOW);
  digitalWrite(BUZZER_PIN, LOW);
}

void enterPackagingState(PackageState nextState, uint32_t now) {
  packageState = nextState;
  packageStateStartedMs = now;
}

void readAndControlDryer(uint32_t now) {
  if (now - lastSensorReadMs < SENSOR_INTERVAL_MS) return;
  lastSensorReadMs = now;

  const float temperature = sht31.readTemperature();
  const float humidity = sht31.readHumidity();
  if (isnan(temperature) || isnan(humidity)) {
    Serial.println("SHT31 reading failed; heater switched off.");
    setHeater(0);
    digitalWrite(INTAKE_FAN_PIN, LOW);
    digitalWrite(EXHAUST_FAN_PIN, HIGH);
    return;
  }

  Serial.printf("Dryer: %.1f C, %.1f %%RH\n", temperature, humidity);
  inputTemp = temperature;

  if (temperature >= MAX_SAFE_TEMP_C) {
    if (!heaterSafetyLockout) Serial.println("Temperature safety cutoff active.");
    heaterSafetyLockout = true;
  } else if (heaterSafetyLockout && temperature < TARGET_TEMP_C) {
    heaterSafetyLockout = false;
    Serial.println("Temperature returned to the normal range.");
  }

  if (heaterSafetyLockout) {
    isPurging = false;
    setHeater(0);
    digitalWrite(INTAKE_FAN_PIN, LOW);
    digitalWrite(EXHAUST_FAN_PIN, HIGH);
    return;
  }

  if (!isPurging && humidity >= HUMIDITY_LIMIT_PERCENT) {
    isPurging = true;
    purgeStartedMs = now;
    Serial.println("High humidity: starting 30 second purge.");
  }

  if (isPurging) {
    setHeater(0);
    digitalWrite(INTAKE_FAN_PIN, LOW);
    digitalWrite(EXHAUST_FAN_PIN, HIGH);
    if (now - purgeStartedMs >= PURGE_DURATION_MS) {
      isPurging = false;
      digitalWrite(EXHAUST_FAN_PIN, LOW);
      Serial.println("Purge complete; resuming drying.");
    }
    return;
  }

  digitalWrite(INTAKE_FAN_PIN, HIGH);
  digitalWrite(EXHAUST_FAN_PIN, LOW);
  heaterPID.Compute();
  setHeater(static_cast<uint8_t>(heaterOutput));
}

void runPackagingCycle(uint32_t now) {
  const bool pouchPresent = digitalRead(IR_SENSOR_PIN) == LOW;

  switch (packageState) {
    case PackageState::WAITING:
      if (pouchPresent) {
        Serial.println("Pouch detected: clamping.");
        digitalWrite(SOLENOID_PIN, HIGH);
        enterPackagingState(PackageState::CLAMPING, now);
      }
      break;

    case PackageState::CLAMPING:
      if (now - packageStateStartedMs >= SOLENOID_SETTLE_MS) {
        Serial.println("Sealing pouch.");
        digitalWrite(SEALER_PIN, HIGH);
        enterPackagingState(PackageState::SEALING, now);
      }
      break;

    case PackageState::SEALING:
      if (now - packageStateStartedMs >= SEAL_PULSE_MS) {
        digitalWrite(SEALER_PIN, LOW);
        enterPackagingState(PackageState::COOLING, now);
      }
      break;

    case PackageState::COOLING:
      if (now - packageStateStartedMs >= COOLING_HOLD_MS) {
        digitalWrite(SOLENOID_PIN, LOW);
        digitalWrite(BUZZER_PIN, HIGH);
        enterPackagingState(PackageState::BEEPING, now);
      }
      break;

    case PackageState::BEEPING:
      if (now - packageStateStartedMs >= BUZZER_MS) {
        digitalWrite(BUZZER_PIN, LOW);
        Serial.println("Sealed pouch ready.");
        enterPackagingState(PackageState::WAIT_FOR_CLEAR, now);
      }
      break;

    case PackageState::WAIT_FOR_CLEAR:
      if (!pouchPresent && now - packageStateStartedMs >= POUCH_CLEAR_MS) {
        enterPackagingState(PackageState::WAITING, now);
      }
      break;
  }
}

void setup() {
  Serial.begin(115200);
  pinMode(INTAKE_FAN_PIN, OUTPUT);
  pinMode(EXHAUST_FAN_PIN, OUTPUT);
  pinMode(SOLENOID_PIN, OUTPUT);
  pinMode(SEALER_PIN, OUTPUT);
  pinMode(BUZZER_PIN, OUTPUT);
  pinMode(IR_SENSOR_PIN, INPUT_PULLUP);

  digitalWrite(INTAKE_FAN_PIN, LOW);
  digitalWrite(EXHAUST_FAN_PIN, LOW);
  allPackagingOutputsOff();

  ledcSetup(HEATER_PWM_CHANNEL, HEATER_PWM_HZ, HEATER_PWM_BITS);
  ledcAttachPin(HEATER_PIN, HEATER_PWM_CHANNEL);
  setHeater(0);

  Wire.begin(SHT31_SDA_PIN, SHT31_SCL_PIN);
  sensorReady = sht31.begin(0x44);
  if (!sensorReady) {
    Serial.println("SHT31 not found; heater remains off until fixed.");
  }

  heaterPID.SetOutputLimits(0, 255);
  heaterPID.SetSampleTime(SENSOR_INTERVAL_MS);
  heaterPID.SetMode(AUTOMATIC);
  Serial.println("Smart agarbatti dryer and sealer started.");
}

void loop() {
  const uint32_t now = millis();
  if (sensorReady) readAndControlDryer(now);
  else setHeater(0);
  runPackagingCycle(now);
}