Batch mixer on an Arduino Uno

// Batch mixer: a tank that follows a recipe, picked on a keypad, one step at a
// time.
//
//   13 12 11 10  keypad rows R1 to R4
//   9 8 7        keypad columns C1 to C3
//   6            relay 1, valve A (ingredient A in)
//   5            relay 2, valve B (ingredient B in)
//   4            relay 3, the mixer motor
//   3            relay 4, the drain valve
//   2            buzzer, + to the pin and - to GND
//   A0           the level sensor (a knob stands in for it: ends on 5 V and
//                GND, the middle to A0)
//   LCD          SDA -> A4    SCL -> A5    VCC -> 5 V    GND -> GND
//
// A batch plant does not have one program per product. It has one sequence
// and a table of recipes, and the recipe is just numbers the sequence reads:
//
//   READY    press 1, 2 or 3 to pick a recipe, then # to start.
//   FILL A  valve A open until the level reaches the recipe's target. This
//           step watches a sensor. If the level stops rising for
//           STALL_MS, something is wrong (a leak, a stuck valve), so it faults.
//   FILL B  valve B open for the recipe's time. This step only watches the
//           clock: the flow is known, so time measures the amount.
//   MIX     the mixer runs for the recipe's time.
//   DRAIN   the drain opens until the tank is below EMPTY_PCT.
//   DONE    a beep. Pick the next recipe.
//   FAULT   everything closed and an alarm. * clears it.
//
// * aborts a running batch at any step: valves shut, the mixer stops and the
// tank drains, because an empty tank is the safe one. Every output is set in
// one place, enter(), so no step can forget to close a valve.
//
// Press Run, press 1 then #, and turn the knob up slowly to fill the tank.

#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <Keypad.h>

const int VALVE_A_PIN = 6;
const int VALVE_B_PIN = 5;
const int MIXER_PIN = 4;
const int DRAIN_PIN = 3;
const int BUZZER_PIN = 2;
const int LEVEL_PIN = A0;

// The relay board switches on a low input.
const int ON = LOW;
const int OFF = HIGH;

// The recipes are data, not code. Times are scaled down to seconds so a
// batch fits in a minute on the bench.
struct Recipe {
  int levelA;                // percent of the tank to fill with A
  unsigned long fillBMs;     // how long valve B stays open
  unsigned long mixMs;       // how long the mixer runs
};
const Recipe RECIPES[] = {
  {40, 3000, 5000},
  {60, 2000, 8000},
  {25, 5000, 4000},
};
const int RECIPE_COUNT = 3;

const unsigned long STALL_MS = 5000;  // fill A must keep rising inside this
const int RISE_PCT = 2;               // a rise this big counts as progress
const int EMPTY_PCT = 5;              // below this the tank is empty
const unsigned long DONE_BEEP_MS = 1000;

const byte ROWS = 4;
const byte COLS = 3;
char keys[ROWS][COLS] = {
  {'1', '2', '3'},
  {'4', '5', '6'},
  {'7', '8', '9'},
  {'*', '0', '#'},
};
byte rowPins[ROWS] = {13, 12, 11, 10};
byte colPins[COLS] = {9, 8, 7};
Keypad keypad = Keypad(makeKeymap(keys), rowPins, colPins, ROWS, COLS);

enum State { READY, FILL_A, FILL_B, MIX, DRAIN, DONE, FAULT };
const char* const NAMES[] = {"READY", "FILL A", "FILL B", "MIX", "DRAIN", "DONE", "FAULT"};

LiquidCrystal_I2C lcd(0x27, 16, 2);

State state = READY;
unsigned long enteredAt = 0;
int recipe = 0;            // 1..3, 0 for none picked
bool aborted = false;
int bestLevel = 0;         // the highest level seen in FILL A
unsigned long risingAt = 0;
int shownLevel = -1;       // the level on the LCD, to redraw only on a change
unsigned long beepUntil = 0;

int levelPct() {
  return (long)analogRead(LEVEL_PIN) * 100 / 1023;
}

// An LCD over I2C is slow, so only the number is redrawn, and only when it
// changes: the loop has to keep reading the keypad.
void showLevel(int level) {
  if (level == shownLevel) return;
  shownLevel = level;
  lcd.setCursor(6, 1);
  lcd.print(level);
  lcd.print("%  ");
}

void show() {
  lcd.setCursor(0, 0);
  lcd.print("R");
  if (recipe) lcd.print(recipe);
  else lcd.print("-");
  lcd.print(" ");
  lcd.print(NAMES[state]);
  lcd.print("          ");
  lcd.setCursor(0, 1);
  lcd.print("Level ");
  shownLevel = -1;
  showLevel(levelPct());
}

void beep(unsigned long ms) {
  beepUntil = millis() + ms;
  digitalWrite(BUZZER_PIN, HIGH);
}

void enter(State next) {
  state = next;
  enteredAt = millis();
  digitalWrite(VALVE_A_PIN, next == FILL_A ? ON : OFF);
  digitalWrite(VALVE_B_PIN, next == FILL_B ? ON : OFF);
  digitalWrite(MIXER_PIN, next == MIX ? ON : OFF);
  digitalWrite(DRAIN_PIN, next == DRAIN ? ON : OFF);
  Serial.print("state ");
  Serial.println(NAMES[next]);
  show();
}

void setup() {
  pinMode(VALVE_A_PIN, OUTPUT);
  pinMode(VALVE_B_PIN, OUTPUT);
  pinMode(MIXER_PIN, OUTPUT);
  pinMode(DRAIN_PIN, OUTPUT);
  pinMode(BUZZER_PIN, OUTPUT);
  digitalWrite(VALVE_A_PIN, OFF);
  digitalWrite(VALVE_B_PIN, OFF);
  digitalWrite(MIXER_PIN, OFF);
  digitalWrite(DRAIN_PIN, OFF);
  Serial.begin(9600);
  Serial.println("Batch mixer");
  lcd.init();
  lcd.backlight();
  enter(READY);
}

void handleKey(char key) {
  bool running = state == FILL_A || state == FILL_B || state == MIX;
  if (key == '*') {
    if (running) {
      Serial.println("abort");
      aborted = true;
      enter(DRAIN);
    } else if (state == FAULT) {
      enter(READY);
    }
    return;
  }
  if (state != READY && state != DONE) return;
  if (key >= '1' && key <= '0' + RECIPE_COUNT) {
    recipe = key - '0';
    Serial.print("recipe ");
    Serial.println(recipe);
    enter(READY);
  } else if (key == '#' && recipe) {
    Serial.print("start recipe ");
    Serial.println(recipe);
    aborted = false;
    bestLevel = levelPct();
    risingAt = millis();
    enter(FILL_A);
  }
}

void loop() {
  char key = keypad.getKey();
  if (key) handleKey(key);
  unsigned long now = millis();

  int level = levelPct();
  const Recipe& r = RECIPES[recipe > 0 ? recipe - 1 : 0];

  switch (state) {
    case FILL_A:
      // Level control: the sensor says when to stop.
      if (level >= r.levelA) {
        enter(FILL_B);
      } else {
        // The watchdog: a fill that stops rising is a fault, not a wait.
        if (level >= bestLevel + RISE_PCT) {
          bestLevel = level;
          risingAt = now;
        }
        if (now - risingAt >= STALL_MS) {
          Serial.println("fault: level not rising");
          beep(DONE_BEEP_MS);
          enter(FAULT);
        }
      }
      break;
    case FILL_B:
      // Time control: the clock says when to stop.
      if (now - enteredAt >= r.fillBMs) enter(MIX);
      break;
    case MIX:
      if (now - enteredAt >= r.mixMs) enter(DRAIN);
      break;
    case DRAIN:
      if (level < EMPTY_PCT) {
        if (aborted) {
          Serial.println("aborted, tank empty");
          enter(READY);
        } else {
          Serial.print("batch done, recipe ");
          Serial.println(recipe);
          beep(DONE_BEEP_MS);
          enter(DONE);
        }
      }
      break;
    default:
      break;
  }

  if (beepUntil && now >= beepUntil) {
    beepUntil = 0;
    digitalWrite(BUZZER_PIN, LOW);
  }
  showLevel(level);
  delay(5);
}