Automated Roti Pressing and Cooking

#include <Arduino.h>
#include <Wire.h>
#include <Adafruit_MAX31855.h>
#include <Adafruit_MCP23X17.h>

// ESP32 wiring. PWM/DIR outputs pass through opto-isolated interfaces before the motor drivers.

enum class State : uint8_t { WARMING, IDLE, FEEDING, CLOSING, COOKING, OPENING, EJECTING, FAULT };


// Forward declarations
bool inputHealthy(uint8_t pin);
bool guardOk();
bool eStopOk();
bool pressIsOpen();
bool pressIsClosed();
bool doughPresent();
void driveMotor(int pwmPin, int dirPin, bool forward, bool enabled);
void stopAllMotors();
void setHeater(bool enabled);
void enterState(State next);
void enterFault();
void controlHeater(float temperatureC);
bool startPressed();

constexpr int THERMO_SCK = 18;
constexpr int THERMO_CS = 23;
constexpr int THERMO_SO = 19;
constexpr int HEATER_ENABLE_PIN = 25;
constexpr int PRESS_PWM_PIN = 26;
constexpr int PRESS_DIR_PIN = 27;
constexpr int FEED_PWM_PIN = 32;
constexpr int FEED_DIR_PIN = 33;
constexpr int EJECT_PWM_PIN = 13;
constexpr int EJECT_DIR_PIN = 14;
constexpr int I2C_SDA_PIN = 21;
constexpr int I2C_SCL_PIN = 22;

// MCP23017 pins are active LOW because the isolated field-input outputs pull down.
constexpr uint8_t START_INPUT = 0;
constexpr uint8_t GUARD_OK_INPUT = 1;
constexpr uint8_t DOUGH_PRESENT_INPUT = 2;
constexpr uint8_t ESTOP_OK_INPUT = 3;
constexpr uint8_t PRESS_OPEN_INPUT = 4;
constexpr uint8_t PRESS_CLOSED_INPUT = 5;

constexpr float SETPOINT_C = 225.0F;
constexpr float HEATER_HYSTERESIS_C = 5.0F;
constexpr float MAX_SAFE_TEMP_C = 280.0F;
constexpr unsigned long WARMUP_TIMEOUT_MS = 8UL * 60UL * 1000UL;
constexpr unsigned long FEED_TIME_MS = 1300UL;      // Fabricator tunes for exactly one 35-45 g ball.
constexpr unsigned long PRESS_TIMEOUT_MS = 7000UL;
constexpr unsigned long COOK_TIME_MS = 28000UL;     // Tune with flour hydration and target browning.
constexpr unsigned long EJECT_TIME_MS = 2200UL;
constexpr unsigned long START_DEBOUNCE_MS = 80UL;

Adafruit_MAX31855 thermocouple(THERMO_SCK, THERMO_CS, THERMO_SO);
Adafruit_MCP23X17 inputs;


State state = State::WARMING;
unsigned long stateStartedAt = 0;
unsigned long lastStartEdgeAt = 0;
bool heaterOn = false;

bool inputHealthy(uint8_t pin) {
  return inputs.digitalRead(pin) == LOW;
}

bool guardOk() { return inputHealthy(GUARD_OK_INPUT); }
bool eStopOk() { return inputHealthy(ESTOP_OK_INPUT); }
bool pressIsOpen() { return inputHealthy(PRESS_OPEN_INPUT); }
bool pressIsClosed() { return inputHealthy(PRESS_CLOSED_INPUT); }
bool doughPresent() { return inputHealthy(DOUGH_PRESENT_INPUT); }

void driveMotor(int pwmPin, int dirPin, bool forward, bool enabled) {
  digitalWrite(dirPin, forward ? HIGH : LOW);
  digitalWrite(pwmPin, enabled ? HIGH : LOW);
}

void stopAllMotors() {
  digitalWrite(PRESS_PWM_PIN, LOW);
  digitalWrite(FEED_PWM_PIN, LOW);
  digitalWrite(EJECT_PWM_PIN, LOW);
}

void setHeater(bool enabled) {
  heaterOn = enabled;
  digitalWrite(HEATER_ENABLE_PIN, enabled ? HIGH : LOW);
}

void enterState(State next) {
  stopAllMotors();
  state = next;
  stateStartedAt = millis();
}

void enterFault() {
  setHeater(false);
  stopAllMotors();
  state = State::FAULT;
  stateStartedAt = millis();
}

void controlHeater(float temperatureC) {
  if (isnan(temperatureC) || temperatureC > MAX_SAFE_TEMP_C || !eStopOk()) {
    enterFault();
    return;
  }
  if (temperatureC <= SETPOINT_C - HEATER_HYSTERESIS_C) {
    setHeater(true);
  } else if (temperatureC >= SETPOINT_C + HEATER_HYSTERESIS_C) {
    setHeater(false);
  }
}

bool startPressed() {
  if (!inputHealthy(START_INPUT)) return false;
  const unsigned long now = millis();
  if (now - lastStartEdgeAt < START_DEBOUNCE_MS) return false;
  lastStartEdgeAt = now;
  return true;
}

void setup() {
  pinMode(HEATER_ENABLE_PIN, OUTPUT);
  pinMode(PRESS_PWM_PIN, OUTPUT);
  pinMode(PRESS_DIR_PIN, OUTPUT);
  pinMode(FEED_PWM_PIN, OUTPUT);
  pinMode(FEED_DIR_PIN, OUTPUT);
  pinMode(EJECT_PWM_PIN, OUTPUT);
  pinMode(EJECT_DIR_PIN, OUTPUT);
  setHeater(false);
  stopAllMotors();

  Serial.begin(115200);
  Wire.begin(I2C_SDA_PIN, I2C_SCL_PIN);
  if (!inputs.begin_I2C(0x20)) {
    enterFault();
    return;
  }
  for (uint8_t pin = START_INPUT; pin <= PRESS_CLOSED_INPUT; ++pin) {
    inputs.pinMode(pin, INPUT_PULLUP);
  }
  enterState(State::WARMING);
}

void loop() {
  const float temperatureC = thermocouple.readCelsius();
  controlHeater(temperatureC);
  if (state == State::FAULT) {
    setHeater(false);
    stopAllMotors();
    delay(25);
    return;
  }

  // A guard opening or E-stop feedback loss aborts motion immediately.
  if (!guardOk() || !eStopOk()) {
    enterFault();
    delay(25);
    return;
  }

  const unsigned long elapsed = millis() - stateStartedAt;
  switch (state) {
    case State::WARMING:
      if (elapsed > WARMUP_TIMEOUT_MS) enterFault();
      else if (temperatureC >= SETPOINT_C - HEATER_HYSTERESIS_C && pressIsOpen()) enterState(State::IDLE);
      break;

    case State::IDLE:
      if (!pressIsOpen()) {
        driveMotor(PRESS_PWM_PIN, PRESS_DIR_PIN, false, true); // retract to open
        if (elapsed > PRESS_TIMEOUT_MS) enterFault();
      } else if (startPressed() && doughPresent() && temperatureC >= SETPOINT_C - HEATER_HYSTERESIS_C) {
        enterState(State::FEEDING);
      }
      break;

    case State::FEEDING:
      driveMotor(FEED_PWM_PIN, FEED_DIR_PIN, true, true);
      if (elapsed >= FEED_TIME_MS) enterState(State::CLOSING);
      break;

    case State::CLOSING:
      if (pressIsClosed()) enterState(State::COOKING);
      else if (elapsed > PRESS_TIMEOUT_MS) enterFault();
      else driveMotor(PRESS_PWM_PIN, PRESS_DIR_PIN, true, true);
      break;

    case State::COOKING:
      // Plates remain mechanically closed at the calibrated 2 mm stop.
      if (!pressIsClosed()) enterFault();
      else if (elapsed >= COOK_TIME_MS) enterState(State::OPENING);
      break;

    case State::OPENING:
      if (pressIsOpen()) enterState(State::EJECTING);
      else if (elapsed > PRESS_TIMEOUT_MS) enterFault();
      else driveMotor(PRESS_PWM_PIN, PRESS_DIR_PIN, false, true);
      break;

    case State::EJECTING:
      driveMotor(EJECT_PWM_PIN, EJECT_DIR_PIN, true, true);
      if (elapsed >= EJECT_TIME_MS) enterState(State::IDLE);
      break;

    case State::FAULT:
      break;
  }
  delay(20);
}