Build A Working Bench-top Prototype Of Iot-enabl

/*
  SMART MICRO-PUMP — WATER-ONLY BENCH RESEARCH PROTOTYPE (wiring verified)
  Not a medical device. Never connect to a person or use for IV delivery.
  Commands on Serial (newline terminated):
    SET_FLOW 2.0 | START | PAUSE | STOP | ACK_ALARM | RESUME
    CAL 140 | CAL_RESULT 10.0 | CAL_STOP | STATUS
*/
#include <Arduino.h>
#include <WiFi.h>
#include <WiFiClientSecure.h>
#include <PubSubClient.h>
#include <Preferences.h>
#include <esp_task_wdt.h>


struct CalibrationPoint { uint8_t pwm; float dropsPerSecond; float mlPerMin; };

enum PumpState { IDLE, CALIBRATING, RUNNING, PAUSED, COMPLETE, OCCLUSION_ALARM, FAULT };

enum FaultReason { NO_FAULT, STOP_PRESSED, OCCLUSION, NO_FLOW, PRESSURE_SENSOR_FAULT, IR_SENSOR_FAULT, NETWORK_TIMEOUT };


// Forward declarations
void IRAM_ATTR onDrop();
void writePumpPwm(uint8_t duty);
void pumpOff();
void alarmOutputs(bool active);
void latchFault(FaultReason why);
bool physicalStopPressed();
float readPressureKpa(bool &valid);
bool conditionsSafe();
void beginRun();
void pausePump();
void controlAndSafety();
void publishTelemetry();
void handleCommand(String command, bool remote);
void mqttCallback(char *topic, byte *payload, unsigned int length);
void serviceNetwork();

constexpr int AIN1_PIN = 25;
constexpr int AIN2_PIN = 26;
constexpr int PUMP_PWM_PIN = 27;
constexpr int DROP_PIN = 32;
constexpr int STOP_PIN = 33;
constexpr int PRESSURE_PIN = 34;
constexpr int ALARM_LED_PIN = 22;
constexpr int BUZZER_PIN = 23;

// ---- Experiment-specific constants: calibrate these with water before use ----
constexpr float KP = 28.0f;                 // PWM counts per (mL/min) error
constexpr float KI = 4.0f;                  // PWM counts per (mL/min*s) error
constexpr float KD = 2.0f;                  // PWM counts per (mL/min)/s error
constexpr uint8_t MIN_PWM = 55;             // experimentally find the pump's reliable start value
constexpr uint8_t MAX_PWM = 180;            // local hardware rate clamp; never exceed without revalidation
constexpr float LOCAL_MAX_FLOW_ML_MIN = 5.0f;
constexpr float DEFAULT_DROPS_PER_ML = 20.0f; // REPLACE using CAL_RESULT measurement
constexpr float DEFAULT_TARGET_FLOW_ML_MIN = 2.0f;
constexpr uint32_t SENSOR_TIMEOUT_MS = 12000;
constexpr float OCCLUSION_PRESSURE_KPA = 60.0f;
constexpr uint32_t CONTROL_PERIOD_MS = 250;
constexpr uint32_t DROP_DEBOUNCE_US = 2500;
constexpr uint32_t NETWORK_COMMAND_TIMEOUT_MS = 30000;
constexpr uint32_t STARTUP_NO_FLOW_GRACE_MS = 4000;
constexpr uint32_t WDT_TIMEOUT_S = 4;
constexpr uint32_t PWM_FREQ_HZ = 18000;
constexpr uint8_t PWM_BITS = 8;
constexpr uint8_t PUMP_PWM_CHANNEL = 1;

// Calibration table is a worksheet starter, not a pump model. Populate during water tests.

CalibrationPoint calibrationTable[] = {
  {60, 0.0f, 0.0f}, {100, 0.0f, 0.0f}, {140, 0.0f, 0.0f}, {180, 0.0f, 0.0f}
};
constexpr size_t CAL_POINTS = sizeof(calibrationTable) / sizeof(calibrationTable[0]);




volatile uint32_t totalDrops = 0;
volatile uint32_t windowDrops = 0;
volatile uint32_t lastDropUs = 0;
volatile uint32_t lastDropMs = 0;
PumpState state = IDLE;
FaultReason fault = NO_FAULT;
Preferences preferences;

float targetFlowMlMin = DEFAULT_TARGET_FLOW_ML_MIN;
float dropsPerMl = DEFAULT_DROPS_PER_ML;
float measuredDropsSec = 0.0f, measuredFlowMlMin = 0.0f;
float pressureKpa = 0.0f;
float integral = 0.0f, priorError = 0.0f;
uint8_t pwmDuty = 0;
uint32_t lastControlMs = 0, runStartedMs = 0;
uint32_t calibrationStartDrops = 0, calibrationStartMs = 0;
uint8_t calibrationPwm = 0;
bool remoteSessionActive = false;
uint32_t lastRemoteCommandMs = 0;

// Leave these empty for standalone local bench tests. With real broker credentials,
// this module uses TLS on 8883 and publishes the documented topic layout.
const char *DEVICE_ID = "bench-pump-01";
const char *WIFI_SSID = "";
const char *WIFI_PASSWORD = "";
const char *MQTT_HOST = "";
const uint16_t MQTT_TLS_PORT = 8883;
WiFiClientSecure tlsClient;
PubSubClient mqtt(tlsClient);

const char *stateName(PumpState s) {
  switch (s) { case IDLE:return "IDLE"; case CALIBRATING:return "CALIBRATING"; case RUNNING:return "RUNNING"; case PAUSED:return "PAUSED"; case COMPLETE:return "COMPLETE"; case OCCLUSION_ALARM:return "OCCLUSION_ALARM"; default:return "FAULT"; }
}
const char *faultName(FaultReason f) {
  switch (f) { case NO_FAULT:return "NONE"; case STOP_PRESSED:return "PHYSICAL_STOP"; case OCCLUSION:return "OCCLUSION"; case NO_FLOW:return "NO_FLOW_OR_AIR"; case PRESSURE_SENSOR_FAULT:return "PRESSURE_SENSOR"; case IR_SENSOR_FAULT:return "IR_SENSOR"; default:return "NETWORK_TIMEOUT"; }
}

void IRAM_ATTR onDrop() {
  uint32_t now = micros();
  if ((uint32_t)(now - lastDropUs) >= DROP_DEBOUNCE_US) {
    totalDrops++; windowDrops++; lastDropUs = now; lastDropMs = millis();
  }
}

void writePumpPwm(uint8_t duty) {
  ledcWrite(PUMP_PWM_CHANNEL, duty);
}
void pumpOff() {
  writePumpPwm(0); pwmDuty = 0;
  digitalWrite(AIN1_PIN, LOW); digitalWrite(AIN2_PIN, LOW);
}
void alarmOutputs(bool active) {
  digitalWrite(ALARM_LED_PIN, active ? HIGH : LOW);
  digitalWrite(BUZZER_PIN, active ? HIGH : LOW);
}
void latchFault(FaultReason why) {
  pumpOff(); fault = why;
  state = (why == OCCLUSION) ? OCCLUSION_ALARM : FAULT;
  alarmOutputs(true);
  Serial.printf("ALARM,%s\n", faultName(why));
}
bool physicalStopPressed() { return digitalRead(STOP_PIN) == LOW; }

float readPressureKpa(bool &valid) {
  uint32_t sum = 0;
  for (int i = 0; i < 8; ++i) { sum += analogRead(PRESSURE_PIN); delayMicroseconds(150); }
  float adcV = (sum / 8.0f) * 3.3f / 4095.0f;
  // 20k top / 39k bottom divider: sensor voltage = ADC voltage * 59/39.
  float sensorV = adcV * (59.0f / 39.0f);
  valid = sensorV >= 0.20f && sensorV <= 4.95f;
  return constrain((sensorV - 0.5f) * 25.0f, 0.0f, 100.0f); // sensor's stated 0.5–4.5 V transfer
}

bool conditionsSafe() {
  bool pressureValid = false;
  float p = readPressureKpa(pressureValid);
  return !physicalStopPressed() && pressureValid && p < OCCLUSION_PRESSURE_KPA;
}
void beginRun() {
  if (!conditionsSafe()) { latchFault(physicalStopPressed() ? STOP_PRESSED : PRESSURE_SENSOR_FAULT); return; }
  integral = 0; priorError = 0; runStartedMs = millis();
  noInterrupts(); windowDrops = 0; interrupts();
  state = RUNNING; fault = NO_FAULT; alarmOutputs(false);
  pwmDuty = MIN_PWM; digitalWrite(AIN1_PIN, HIGH); digitalWrite(AIN2_PIN, LOW); writePumpPwm(pwmDuty);
}
void pausePump() { pumpOff(); if (state == RUNNING || state == CALIBRATING) state = PAUSED; }

void controlAndSafety() {
  if (physicalStopPressed()) { if (state != FAULT || fault != STOP_PRESSED) latchFault(STOP_PRESSED); return; }
  bool pressureValid = false;
  pressureKpa = readPressureKpa(pressureValid);
  if (!pressureValid) { if (state == RUNNING || state == CALIBRATING) latchFault(PRESSURE_SENSOR_FAULT); return; }
  if (pressureKpa >= OCCLUSION_PRESSURE_KPA && (state == RUNNING || state == CALIBRATING)) { latchFault(OCCLUSION); return; }
  if (state != RUNNING) return;
  uint32_t now = millis();
  if (remoteSessionActive && (!mqtt.connected() || now - lastRemoteCommandMs > NETWORK_COMMAND_TIMEOUT_MS)) { latchFault(NETWORK_TIMEOUT); return; }
  if (pwmDuty >= MIN_PWM && now - runStartedMs > STARTUP_NO_FLOW_GRACE_MS && now - lastDropMs > SENSOR_TIMEOUT_MS) { latchFault(NO_FLOW); return; }
  if (now - lastControlMs < CONTROL_PERIOD_MS) return;
  float dt = (now - lastControlMs) / 1000.0f; lastControlMs = now;
  noInterrupts(); uint32_t drops = windowDrops; windowDrops = 0; interrupts();
  measuredDropsSec = drops / dt;
  measuredFlowMlMin = measuredDropsSec * 60.0f / dropsPerMl;
  float error = targetFlowMlMin - measuredFlowMlMin;
  float candidateIntegral = constrain(integral + error * dt, -20.0f, 20.0f);
  float derivative = (error - priorError) / dt;
  float output = KP * error + KI * candidateIntegral + KD * derivative;
  float requested = pwmDuty + output;
  uint8_t constrained = (uint8_t)constrain(requested, (float)MIN_PWM, (float)MAX_PWM);
  // Only retain the integral when saturation is not forcing the output farther outward.
  if ((requested == constrained) || (requested > MAX_PWM && error < 0) || (requested < MIN_PWM && error > 0)) integral = candidateIntegral;
  priorError = error; pwmDuty = constrained; writePumpPwm(pwmDuty);
}

void publishTelemetry() {
  if (!mqtt.connected()) return;
  char topic[80], payload[220];
  snprintf(topic, sizeof(topic), "smartpump/%s/telemetry", DEVICE_ID);
  snprintf(payload, sizeof(payload), "{\"state\":\"%s\",\"fault\":\"%s\",\"target_ml_min\":%.3f,\"flow_ml_min\":%.3f,\"drops_s\":%.3f,\"pressure_kpa\":%.2f,\"pwm\":%u}", stateName(state), faultName(fault), targetFlowMlMin, measuredFlowMlMin, measuredDropsSec, pressureKpa, pwmDuty);
  mqtt.publish(topic, payload, false);
}
void handleCommand(String command, bool remote) {
  command.trim(); command.toUpperCase();
  if (remote) { remoteSessionActive = true; lastRemoteCommandMs = millis(); }
  if (command.startsWith("SET_FLOW ")) {
    float requested = command.substring(9).toFloat();
    if (requested > 0.0f && requested <= LOCAL_MAX_FLOW_ML_MIN) targetFlowMlMin = requested;
    else Serial.println("REJECTED: flow exceeds local clamp or is invalid");
  } else if (command == "START") {
    if (state == IDLE || state == PAUSED) beginRun();
    else Serial.println("REJECTED: acknowledge faults, then explicitly RESUME");
  } else if (command == "PAUSE") pausePump();
  else if (command == "STOP") latchFault(STOP_PRESSED);
  else if (command == "ACK_ALARM") {
    if ((state == FAULT || state == OCCLUSION_ALARM) && conditionsSafe()) { fault = NO_FAULT; state = PAUSED; alarmOutputs(false); Serial.println("ACKNOWLEDGED: now use RESUME"); }
    else Serial.println("REJECTED: release STOP and remove pressure/sensor fault first");
  } else if (command == "RESUME") {
    if (state == PAUSED && fault == NO_FAULT && conditionsSafe()) beginRun();
    else Serial.println("REJECTED: safety conditions are not verified");
  } else if (command.startsWith("CAL ")) {
    if (state == IDLE || state == PAUSED) { calibrationPwm = constrain(command.substring(4).toInt(), MIN_PWM, MAX_PWM); calibrationStartDrops = totalDrops; calibrationStartMs = millis(); state = CALIBRATING; fault = NO_FAULT; alarmOutputs(false); digitalWrite(AIN1_PIN,HIGH); digitalWrite(AIN2_PIN,LOW); pwmDuty = calibrationPwm; writePumpPwm(pwmDuty); Serial.println("CAL running: collect water, then send CAL_RESULT <measured_mL>"); }
  } else if (command.startsWith("CAL_RESULT ")) {
    if (state == CALIBRATING) { float volume = command.substring(11).toFloat(); uint32_t d = totalDrops - calibrationStartDrops; float sec = (millis()-calibrationStartMs)/1000.0f; pumpOff(); state = PAUSED; if (volume > 0.0f && sec > 0.0f) { dropsPerMl = d / volume; preferences.putFloat("dropsMl", dropsPerMl); Serial.printf("CAL,%u,%.3f drops/s,%.3f mL/min,%.3f drops/mL SAVED\n", calibrationPwm, d/sec, volume*60.0f/sec, dropsPerMl); } }
  } else if (command == "CAL_STOP") pausePump();
  else if (command == "STATUS") { /* printed by periodic report */ }
  else Serial.println("Unknown command");
}
void mqttCallback(char *topic, byte *payload, unsigned int length) {
  String command; for (unsigned int i=0; i<length; ++i) command += (char)payload[i];
  handleCommand(command, true);
}
void serviceNetwork() {
  // Empty credentials deliberately leave the prototype in local bench mode.
  if (strlen(WIFI_SSID) == 0 || strlen(MQTT_HOST) == 0) return;
  if (WiFi.status() != WL_CONNECTED) return;
  if (!mqtt.connected()) {
    mqtt.setServer(MQTT_HOST, MQTT_TLS_PORT); mqtt.setCallback(mqttCallback);
    char clientId[48]; snprintf(clientId, sizeof(clientId), "%s-%08lx", DEVICE_ID, (unsigned long)ESP.getEfuseMac());
    if (mqtt.connect(clientId)) { char topic[80]; snprintf(topic,sizeof(topic),"smartpump/%s/command",DEVICE_ID); mqtt.subscribe(topic); }
  }
  mqtt.loop();
}
void setup() {
  Serial.begin(115200);
  pinMode(AIN1_PIN, OUTPUT); pinMode(AIN2_PIN, OUTPUT); pinMode(ALARM_LED_PIN, OUTPUT); pinMode(BUZZER_PIN, OUTPUT);
  pinMode(STOP_PIN, INPUT); pinMode(DROP_PIN, INPUT); // External 10 kΩ pull-ups are required.
  analogReadResolution(12); analogSetPinAttenuation(PRESSURE_PIN, ADC_11db);
  ledcSetup(PUMP_PWM_CHANNEL, PWM_FREQ_HZ, PWM_BITS); ledcAttachPin(PUMP_PWM_PIN, PUMP_PWM_CHANNEL);
  pumpOff(); alarmOutputs(false);
  attachInterrupt(digitalPinToInterrupt(DROP_PIN), onDrop, FALLING);
  preferences.begin("smartpump", false); dropsPerMl = preferences.getFloat("dropsMl", DEFAULT_DROPS_PER_ML);
#if ESP_ARDUINO_VERSION_MAJOR >= 3
  esp_task_wdt_config_t cfg = { .timeout_ms = WDT_TIMEOUT_S * 1000, .idle_core_mask = 0, .trigger_panic = true };
  esp_task_wdt_init(&cfg);
#else
  esp_task_wdt_init(WDT_TIMEOUT_S, true);
#endif
  esp_task_wdt_add(NULL);
  if (strlen(WIFI_SSID) > 0) WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
  lastControlMs = millis(); lastDropMs = millis();
  Serial.println("Water-only smart pump ready. Pump defaults OFF. Send STATUS or SET_FLOW then START.");
}
void loop() {
  esp_task_wdt_reset();
  if (Serial.available()) handleCommand(Serial.readStringUntil('\n'), false);
  serviceNetwork(); controlAndSafety();
  static uint32_t lastReport = 0, lastPublish = 0;
  if (millis() - lastReport >= 1000) {
    lastReport = millis();
    float error = targetFlowMlMin - measuredFlowMlMin;
    Serial.printf("state=%s fault=%s wifi=%s target=%.3f flow=%.3f drops/s=%.3f pressure=%.2f pwm=%u error=%.3f\n", stateName(state), faultName(fault), WiFi.status()==WL_CONNECTED?"connected":"local/offline", targetFlowMlMin, measuredFlowMlMin, measuredDropsSec, pressureKpa, pwmDuty, error);
  }
  if (millis() - lastPublish >= 1000) { lastPublish = millis(); publishTelemetry(); }
}