Coupled-Tank PID Level-Control Trainer with Logged Step Response

Coupled-Tank PID Level-Control Trainer is a benchtop process-control rig that reproduces the classic liquid-level problem every instrumentation and control engineer meets in industry: keep the level in a tank at its setpoint while the outflow keeps changing. Two clear acrylic tanks are coupled in series — a 12 V booster pump fills the upper tank, water gravity-feeds through a manually adjustable valve into the lower tank, and an ultrasonic sensor measures the lower-tank level. An ESP32 runs a discrete PID loop at 1 Hz, drives the pump through a MOSFET with PWM, and streams time-stamped level and duty readings over serial.

The hardware is only half the project. A companion Python toolchain logs every run to CSV, fits a first-order-plus-dead-time (FOPDT) model from open-loop step tests, and compares Ziegler-Nichols settings against a manually tuned loop using rise time, overshoot, settling time and integral absolute error. A small Flask dashboard shows the live loop so demonstrations do not need a serial terminal.

Commercial level-control trainers used in control labs cost ₹60,000–₹1,50,000, which is why most students only ever see this problem inside a simulator. This rig recreates the same learning — sensor calibration, process lag, valve-induced disturbances, integral windup, tuning trade-offs — with real sensor noise and real hydraulics, for under ₹4,000. It is a viva-defensible Instrumentation & Control project: every design decision, from sampling rate to anti-windup clamping, can be justified from logged data.

Loop tuning is the core skill of an instrumentation engineer, but students almost never practise it on real hardware: commercial coupled-tank trainers are too expensive for a college to give every batch repeated tuning time, and simulators hide the measurement noise, actuator non-linearity and dead time that make industrial loops hard. As a result, Ziegler-Nichols formulas are memorised without evidence, and the trade-off between overshoot and settling time is never actually observed.

There is a need for an affordable, open coupled-tank level-control rig with logged data that a four-member student team can build for under ₹4,000, calibrate against a steel-rule reference, and use to (a) identify a first-order-plus-dead-time model from step tests, (b) implement a discrete PID loop with anti-windup, and (c) compare tuning rules with quantitative closed-loop metrics — producing a repeatable lab trainer and a data-backed report instead of a guesswork demo.

Abstract

Level loops are the workhorse of process industries — boiler drum level, distillation column sumps, storage tanks and effluent plants all depend on them. Yet loop tuning is usually taught from slides or pure simulation, because commercial coupled-tank trainers are too expensive for a student budget. This project builds a low-cost coupled-tank trainer and uses it to run a proper tuning study: open-loop identification, PID design, closed-loop verification, all backed by logged data.

Introduction

In a series coupled-tank system the pump drives the upper tank, whose outflow is the inflow of the lower tank — so the process is second-order with interaction, exactly like scaled-down versions of plant level cascades. The controller must hold the lower-tank level at setpoint while the manual valve (the load) changes. This is the benchmark problem used in textbooks such as Åström and Hägglund's PID Controllers: Theory, Design, and Tuning, and it exercises every part of an instrumentation syllabus: transducers, signal conditioning, actuators, digital control and data recording.

Existing System

• Commercial trainers (two-tank and three-tank rigs) cost from ₹60,000 upward, beyond individual student budgets.
• Pure simulations (Simulink / Scilab Xcos models) hide real effects: ultrasonic echo noise, pump non-linearity at low duty, dead time from the pipe run, quantisation and drop-outs.
• College labs often let students observe a tuned loop but rarely let them tune one repeatedly and compare tuning rules on the same plant.
• Limitations of current practice: no ownership of the loop, no logged evidence, tuning learned as formulas rather than measured trade-offs.

Proposed System

• A ₹3,500–₹4,000 benchtop rig: two 1.5 L acrylic tanks, 12 V booster pump, MOSFET PWM drive, manual load valve, HC-SR04 ultrasonic level sensor in a stilling tube, ESP32 controller.
• Discrete PID firmware in C at 1 Hz sampling (tank time constants are in minutes, so 1 s is comfortably fast), with derivative-on-measurement and integral clamping.
• Logging protocol: every second the ESP32 prints timestamp, setpoint, filtered level and pump duty; a Python script captures sessions to CSV.
• Identification and tuning study: open-loop step tests at three pump duties → FOPDT model fit in Scilab → Ziegler-Nichols vs manual tuning → closed-loop metrics (overshoot, settling time, IAE) compared in plots and tables.
• A Flask dashboard for live display and a documented test matrix so the study is repeatable by next year's batch.

Feasibility Study

• Technical: all parts are hobby-grade and documented; the control mathematics is second-year material; risks (echo scatter, siphoning) are handled with a stilling tube and a break-slot between tanks.
• Economic: the BOM is ₹3,500–₹4,000 including the pump, PSU and acrylic; no licence costs — Arduino IDE, Python and Scilab are free.
• Operational: the rig runs on a single 12 V 2 A adapter with water only — safe for a hostel-table demo; a 15-minute calibration sheet makes it usable by non-builders.

In scope

• Series coupled two-tank system, one control loop (lower-tank level), one manipulated variable (pump PWM duty).
• Ultrasonic level sensing with stilling tube; software median filtering.
• Discrete PID firmware (1 Hz), serial logging, CSV analysis, FOPDT identification, Ziegler-Nichols vs manual tuning comparison, Flask live dashboard.
• Setpoint-tracking and load-disturbance validation tests.

Out of scope

• Industrial 4–20 mA transmitters and intrinsic-safety design (a current-loop output stage is listed in future scope).
• Cascade (level–flow) and multi-loop MIMO control; PLC/SCADA integration.
• Temperature, density or conductivity control; heated or pressurised vessels.
• Long-term reliability study (weeks of continuous operation).

The project follows an iterative build-and-test methodology — each phase ends with a measured result that the next phase consumes, which suits a control rig where nothing can be tuned before the plant exists and is calibrated.

Testing approach: calibration is checked by re-running the 10-point scale twice (repeatability ≤ 2 mm); the FOPDT model must predict an independent step test within ±10 %; every closed-loop configuration is run three times and reported as mean ± spread; safety checks (leak test, MOSFET temperature after 30 min) are logged in the test matrix.

The system is a classic single-loop feedback architecture with a digital controller and a serial data path.

1. Process — two series tanks; the pump is the manipulated variable, the manual valve is the load, the lower-tank level is the controlled variable.
2. Controller (ESP32, C) — a timer-driven 1 Hz task reads the HC-SR04 echo (median of 5 pings for noise rejection), computes the PID term with derivative-on-measurement, clamps the integral when the PWM output saturates, and outputs a 0–100 % duty at ~1 kHz PWM through a logic-level MOSFET.
3. Data path — each cycle the ESP32 emits one CSV line (millis, setpoint, level_cm, duty) over USB serial; a Python logger captures sessions to disk for the analysis toolchain.
4. Analysis tier (PC, Python/Scilab) — offline scripts clean the logs, fit the FOPDT model, compute tuning rules and closed-loop metrics, and render the comparison plots used in the report.
5. Dashboard tier (Flask) — reads the live serial stream and renders level vs setpoint in the browser for demos.

flowchart LR
  SP["Setpoint: lower-tank level (cm)"] -->|"error e(k)"| PID["PID task on ESP32<br/>Kp, Ki, Kd + anti-windup"]
  PID -->|"PWM duty 0-100 %"| DRV["Logic-level MOSFET driver"]
  DRV --> PMP["12 V booster pump"]
  PMP --> T1["Upper acrylic tank"]
  T1 -->|"gravity outflow"| VL["Manual load valve (disturbance)"]
  VL --> T2["Lower acrylic tank"]
  T2 --> US["HC-SR04 in stilling tube"]
  US -->|"echo time"| FILT["Median-of-5 filter"]
  FILT --> PID
  FILT -->|"CSV at 1 Hz"| LOG["Python serial logger"]
  LOG --> ANA["Scilab FOPDT fit + Matplotlib metrics"]
  LOG --> DASH["Flask live dashboard"]

The sampling choice is deliberate: identified tank time constants are 2–6 minutes, so a 1 Hz loop is about 100× faster than the process, keeping the discrete PID essentially equivalent to its continuous form while leaving USB bandwidth free for logging. All actuator authority sits on the pump side, so the valve stays purely as a disturbance generator — this keeps the loop single-input single-output and the study clean.

• 4–20 mA current-loop output stage (XTR-style transmitter) so the rig can drive or mimic industrial transmitters and be read by a real SCADA client.
• Relay (Åström-Hägglund) auto-tuning as a firmware mode, comparing its settings against the manual study.
• Cascade level–flow control by adding a flow sensor and a second valve, moving from SISO to the cascade structure used on boiler drums.
• MQTT and SCADA-lite — publish readings to a broker and add historical trends and alarms.
• Second pump as an independent disturbance generator for cleaner load-step experiments.
• A printed lab-manual sheet so junior batches can run the tuning exercise in one 3-hour session.