Project Files of 12V Peristaltic Pump Library for Proteus V1.0 (Dosing, Arduino)

12V PERISTALTIC PUMP LIBRARY FOR PROTEUS - V1.0 (the dosing pump whose rotor turns and fills a beaker on the sheet)
Designed by The Engineering Projects
www.TheEngineeringProjects.com

IMPORTANT LINKS
Article (read it first - pictures, step by step, every feature explained):
  https://www.theengineeringprojects.com/2026/11/12v-peristaltic-pump-library-for-proteus-v1-0.html
Report a bug or suggest a feature (our forum):
  https://www.theengineeringprojects.com/forum/category/motor-driver-proteus-library
The demo runs on our Arduino UNO V4.0 (included) - working LEDs, RESET and a
built-in serial monitor - its own article:
  https://www.theengineeringprojects.com/2026/10/arduino-uno-library-for-proteus-v40.html
The demo's driver is our L9110S Motor Driver - a SEPARATE library, not in this
package: download and install it first - its own article:
  https://www.theengineeringprojects.com/2026/10/l9110s-motor-driver-library-for-proteus-v1-0.html
Support us (the libraries are free):
  https://www.theengineeringprojects.com/donate

FILE STRUCTURE
12V-Peristaltic-Pump-TEP-v1.0/
|-- Proteus Library Files/
|   |-- ArduinoV4TEP.LIB                              201.9 KB   TEP Arduino boards V4.0 (UNO) -> LIBRARY
|   |-- TEPPERIPUMP.LIB                                26.7 KB   the library -> LIBRARY folder
|-- Proteus Model Files/
|   |-- TEPARDUINO.DLL                                883.5 KB   the Arduino board model -> MODELS folder
|   |-- TEPPERIPUMP.DLL                               306.0 KB   the model -> MODELS folder
|-- Proteus Simulation/
|   |-- 12V-Peristaltic-Pump-L9110S-ArduinoUnoV4.pdsprj   26.0 KB   the demo project
|   |-- PeristalticPump_Demo.hex                       23.4 KB   the demo firmware
|   |-- TEPARDUINO.DLL                                883.5 KB   copy of the board model
|   |-- TEPPERIPUMP.DLL                               306.0 KB   copy of the model
|-- Arduino Code/
|   |-- PeristalticPump_Demo/PeristalticPump_Demo.ino    5.0 KB   the demo sketch (source of the .hex)
|-- README.txt                                        ~18.4 KB   this file
Total: 2.62 MB (unzipped). The C++ source code of the models is not included.

WHAT IS IT?
A simulation model of the 12 V peristaltic (dosing) pump - the small pump with
a round clear head of aquarium dosers, nutrient dosing in hydroponics, lab
liquid handling, drink machines and chemistry projects. A DC gear motor turns
a rotor with three rollers; the rollers squeeze a soft silicone tube against
the curved track of the head and push the liquid along. Our own model:
  * An analog (SPICE) model between its + and - pins: the gear motor (14 ohm,
    the back-EMF through the gearbox), the friction of the squeezed tube, the
    inertia and the lift's pressure. Any driver works: an L9110S, an L298N, a
    MOSFET, a relay, PWM or DC, either way round.
  * The data of the common 12 V head with a 2 x 4 mm tube (0 - 100 mL/min):
    at 12 V 106 RPM at the head, 85 mL/min and 253 mA; at 6 V 34 RPM and
    27 mL/min; it starts at about 3.1 V (the tube has to be squeezed); stalled
    at 12 V: 0.86 A.
  * A positive-displacement pump: every turn of the head moves 0.8 mL, forward
    or backward, whatever the lift - a 3 m lift gives 84.4 mL/min, 30 cm
    85.0 (property HEAD and the pop-up's lift buttons).
  * The tubes (a 2 mm bore): the inlet from the bottle (40 cm) and the outlet
    (the lift + 30 cm) hold 3.14 mL for a 30 cm lift. It is self-priming: the
    first drop after the tubes fill (about 2.2 s at 12 V). When it stops the
    rollers seal the tube, so the tubes stay full and the next start delivers
    at once. Turning backward empties the outlet first (a suck-back: the tip
    stops dripping), then runs the water back into the bottle.
  * The scene on the schematic: the rotor and its rollers turn at the head's
    speed, the water climbs the inlet and runs round the head, drops fall
    from the outlet, the beaker fills with the water delivered (a 100 mL
    beaker, emptied when full) and the bottle empties.
  * What it tells: the flow (forward or back), the head's speed, the average
    voltage, the current, PWM (frequency and duty), the tubes' fill, every
    run's volume ("a run: 4.98 mL delivered"), the suck-backs, the priming time
    and the warnings - NOT TURNING (too little voltage to squeeze the tube),
    STALLED, OVER-VOLTAGE (more than 13.5 V average).
The symbol shows the pump from the front: the black housing with its two
mounting ears, the round clear cover, the amber silicone tube round the lower
half of the track, the grey rotor with three white rollers, the red + and
black - leads into the housing; the clear inlet runs down into a bottle of
water and the outlet over to a beaker. The plate, the bottle, the beaker, the
FWD (green) and REV (amber) LEDs and the strip under the plate (ML/MIN, RPM,
MA, OPEN PANEL) are TEP additions; the real pump has none of them.

ONE DEVICE (search "peristaltic" in Pick Devices):
  PERIPUMPTEP   "12V Peristaltic Pump V1.0"   (category Electromechanical >
                Pumps), model TEPPERIPUMP.DLL
  The pop-up panel "TEP 12V Peristaltic Pump" opens at Run (and with OPEN
  PANEL on the strip) - the look of the TEP Serial Monitor. Tabs Pump, Graphs,
  Event log and Check; gear and ? icons for Settings and Help; the palette
  icon switches the theme:
    Pump       the state in big letters (PUMPING 80.1 ML/MIN, PRIMING - THE
               TUBES 0.96 OF 3.14 ML, SUCKING BACK, PUMPING BACK INTO THE
               BOTTLE, STOPPED - THE ROLLERS HOLD THE TUBES FULL, NOT
               TURNING, STALLED, OVER-VOLTAGE); the flow gauge (-100 .. +100
               mL/min, forward to the right, the 12 V flow marked); the live
               values (flow, the head's speed, current, the average voltage,
               the drive: PWM Hz and duty, or STEADY; the water delivered,
               the tubes, the last run); the drive across + / - over the last
               5 ms with its average. The toolbar: the lift (10, 30, 100,
               300 cm), Empty the tubes, Fill the tubes.
    Graphs     the flow (forward and back), the current and the water
               delivered over the last 1, 3 or 6 s - every dose is a step.
               Live / Freeze.
    Event log  the drive (PWM / steady), every steady flow ("steady 80.1 mL/min
               forward, 100 RPM, 11.49 V average, 252 mA"), the first drop
               after a priming, every run's volume, every suck-back, the
               tubes emptied back, every 100 mL, the warnings; filters All /
               Drive + speed / Warnings, Pause, Clear
    Check      Good for: a pump that does not turn, doses too little or too
               much, drips, or resets the Arduino - the drive, the PWM, the
               current, the speed, the flow, the tubes, the priming, the last
               run, the suck-back, the water delivered
    Settings   theme, text size, open at Run, window size
    Help       report a bug, suggest a feature, article, updates, donate,
               forum; Copy diagnostics for a bug report

TEST STATUS
V1.0: verified in Proteus 8.5 on 29 Oct 2026 (the demo project as shipped: an
A3 sheet, an Arduino UNO V4.0 with its built-in monitor, our L9110S driver -
its pop-up version, from its own library - on a +12V supply, the pump on
MOTOR A, RV1 on A0; all pop-ups open). What the runs showed:
  * The project loads and starts cleanly. RV1 at 90 %: "Pot 922: forward 89 %
    (PWM 226/255 = 10.64 V average)"; the pump gets 10.15 V: 84 RPM, 247 mA,
    67.2 mL/min; the tubes fill and the first drop falls; the FWD LED lit, the
    rotor turning.
  * "s 100": "steady 80.1 mL/min forward, 100 RPM, 11.49 V average, 252 mA"
    (the L9110S leaves 11.49 of the 12 V).
  * "dose 5" (3,731 ms forward + 150 ms back): "a run: 4.98 mL delivered in
    3.73 s", then "back: 0.19 mL drawn back from the outlet (a suck-back: its
    tip will not drip)". The next "dose 5" adds 150 ms for the suck-back's
    refill (3,881 ms): 4.98 mL again.
  * "rev 50": "steady 23.0 mL/min BACK, 29 RPM, -5.56 V average, -234 mA", the
    REV LED lit, the outlet emptying.
  * The Empty button, then "prime" (2,600 ms at full speed): "first drop at
    the outlet after 2358 ms: the tubes hold 3.14 mL (self-priming)"; then
    "dose 5": 4.98 mL.
  Plus automatic checks on a PC, 0 failed: 23 on the pump (12 V: 106.2 RPM,
  253 mA, 85.0 mL/min; the first drop after 2,224 ms, the tubes 3.14 mL; the
  tubes still full after a stop and water at once on a restart; a 5 mL dose
  by time: 5.00 mL; a 150 ms suck-back: 0.21 mL; a long reverse: 3.14 mL back
  into the bottle; 6 V: 34.3 RPM, 27.4 mL/min; 2.5 V does not turn, 3.6 V
  does; a 3 m lift: 84.4 mL/min; PWM 980 Hz found with its duty; an averaging
  driver gives no false PWM; a beaker of 100 mL; 14.5 V: over-voltage); 5 on
  the pop-up pages rendered; the demo project read back from disk (69 checks:
  devices, pins, wires, labels, no wire through a part, no crossing).

INSTALLATION (about 2 minutes)
1. Close Proteus. Extract the WHOLE ZIP to a normal folder (e.g. Desktop).
2. Copy everything in "Proteus Library Files" (TEPPERIPUMP.LIB and our Arduino
   library V4.0, ArduinoV4TEP.LIB) to the LIBRARY folder of Proteus, for
   example:
     C:\Program Files (x86)\Labcenter Electronics\Proteus 8 Professional\LIBRARY
   (on some PCs: C:\ProgramData\Labcenter Electronics\Proteus 8 Professional\
   LIBRARY - use the folder that already holds Proteus's own .LIB files).
3. Copy TEPPERIPUMP.DLL and TEPARDUINO.DLL from "Proteus Model Files" to the
   MODELS folder (...\Proteus 8 Professional\MODELS). The demo's driver is NOT
   in this package: install our L9110S Motor Driver library the same way (its
   own ZIP - see IMPORTANT LINKS): TEPL9110S.LIB and TEPL9110S.DLL.
4. Delete TEPPERIPUMP.IDX from the LIBRARY folder if it is there.
5. Start Proteus. In Pick Devices (P) search "peristaltic".

RUN THE DEMO
"Proteus Simulation\12V-Peristaltic-Pump-L9110S-ArduinoUnoV4.pdsprj" - keep
the .hex file and the DLLs beside the project (with the L9110S library
installed).
  ARD1: Arduino UNO V4.0 running PeristalticPump_Demo.hex, its serial monitor
        built in (window "TEP Arduino UNO - ARD1").
  DRV1: the L9110S driver (pop-up version, our L9110S library): A-IA on D5,
        A-IB on D6, VCC on a +12V supply, GND - by net labels; motor B unused.
  M1:   the pump on MOTOR A (A-OA to + red, A-OB to - black), a 30 cm lift,
        the tubes empty at the start.
  RV1:  a 10k potentiometer on A0: the forward speed - left = off, right =
        full.
  1. Press Run. The monitor and the two pop-ups open (move them aside). The
     rotor turns, the water climbs the inlet and, after about 2.5 s, drips
     into the beaker (RV1 at 90 %).
  2. Click RV1's arrows: the speed and the flow follow (it stops turning at
     about 3.1 V).
  3. Type in the monitor and press Send: s 80, rev 50, prime, dose 5, stop,
     knob, help.
  4. On the pump's pop-up: the lift buttons, Empty the tubes, Fill the tubes.
  5. The pump's pop-up: Pump, Graphs, Event log, Check.

WIRING (the same in Proteus and on a real board)
  L9110S          Arduino UNO
   A-IA           D5 (PWM: forward)
   A-IB           D6 (PWM: backward)
   VCC            a 12 V supply (not the Arduino's 5V)
   GND            GND (common with the Arduino)
  Pump            L9110S MOTOR A: + (red) to A-OA, - (black) to A-OB
In the sketch (no library needed):
  forward:  digitalWrite(IB, LOW); analogWrite(IA, speed);    // 0 - 255
  backward: digitalWrite(IA, LOW); analogWrite(IB, speed);
  stop:     digitalWrite(IA, LOW); digitalWrite(IB, LOW);
REAL HARDWARE:
 * Never run it from an Arduino pin: 0.25 A running and up to 0.86 A for a
   moment at a start at 12 V. Use an H-bridge (L9110S, L298N, TB6612FNG) to
   run it both ways, or a logic-level MOSFET with a diode for one way.
 * Feed the driver from a 12 V supply with GND common with the Arduino.
 * Prime it once (run until the liquid comes out), then dose by time - and
   measure the flow first: run it for 30 s into a measuring cylinder.
 * A short reverse after each dose (a suck-back) stops the tip from dripping;
   the next dose first refills it, so add that time.
 * The tube wears: re-measure the flow from time to time, and release the
   tube (or the head's clamp) when the pump is stored for long.

THE DEMO SKETCH ON THE SERIAL MONITOR (PeristalticPump_Demo V1.0, 9600 baud)
  s 80      forward at 80 %               rev 50    backward at 50 % (the water goes back into the bottle)
  prime     fill the empty tubes          dose 5    pump 5 mL by time, then a short suck-back (no drip)
  stop      both inputs LOW               knob      follow the pot again            help      the list
EXPECTED MONITOR OUTPUT
  12V Peristaltic Pump demo - The Engineering Projects
  L9110S on 12 V: A-IA on D5 (forward), A-IB on D6 (backward). The pot on A0 sets the forward speed.
  Commands: s 80 | rev 50 | prime | dose 5 | stop | knob | help
  Pot 922: forward 89 % (PWM 226/255 = 10.64 V average)
  forward 100 % (PWM 255/255 = 12.00 V average)
  stop: IA LOW, IB LOW (the rollers hold the tubes full)
  dose 5.0 mL: 3731 ms forward + 150 ms back
  dose done
  dose 5.0 mL: 3881 ms forward (with the suck-back's refill) + 150 ms back
  backward 50 % (PWM 127/255 = 5.98 V average)
  prime: 2600 ms at full speed - the tubes fill

PROPERTIES (double-click the part > Edit Properties)
  HEAD     the lift from the bottle to the outlet, in cm (default 30; it
           hardly changes the flow, it sets the outlet tube's length)
  PRIMED   1 = the tubes full at the start, 0 = empty (default)
Every run starts again from the properties.

TROUBLESHOOTING
* The rotor never turns and the pop-up says NO DRIVE: the driver's inputs
  (both LOW = stop), its VCC (12 V), or the leads on the wrong outputs.
* NOT TURNING: less than about 3.1 V across it - the tube needs that much
  force; more speed (PWM) or a higher supply.
* It turns but nothing comes out: the tubes are still filling (about 2.5 s
  from empty at full speed) - or it turns backward.
* A dose is too small or too big: measure FLOW_ML_S in the sketch for your
  pump, tube and driver; prime before the first dose.
* The part is not simulated: TEPPERIPUMP.DLL is missing from MODELS and from
  the project folder. No driver: install our L9110S library (TEPL9110S.LIB /
  .DLL). No UNO / no monitor window: TEPARDUINO.DLL, or click the UNO's USB
  port.
* The pop-up does not appear: click OPEN PANEL on the strip, or turn "Open the
  panel at Run" on its Settings page back on.

BUG REPORTS AND FEATURE REQUESTS
Please post them in our forum with a screenshot, the Serial Monitor text, the
simulation log and the pop-up's Copy diagnostics text:
  https://www.theengineeringprojects.com/forum/category/motor-driver-proteus-library

SUPPORT US
This library is free. If it saves you time, please support our work:
  https://www.theengineeringprojects.com/donate

LICENCES AND THIRD-PARTY NOTES
* The pump model (TEPPERIPUMP.DLL), the symbol and artwork and the Arduino
  Library V4.0 (ArduinoV4TEP.LIB / TEPARDUINO.DLL) are made by The Engineering
  Projects. The model is an independent implementation written from the
  typical data of 12 V peristaltic pumps with a 2 x 4 mm tube. The models use
  only standard Windows libraries; no Visual C++ redistributable is needed.
  The C++ source code is not included.
  The demo's driver, our L9110S Motor Driver library (TEPL9110S.LIB /
  TEPL9110S.DLL), is a separate download.
* The potentiometer is Proteus's own POT-HG.
* The demo's .hex is built from the demo sketch and the Arduino AVR core 1.8.6,
  which includes LGPL-licensed code; its source code is available at
  https://github.com/arduino/ArduinoCore-avr/tree/1.8.6
* Proteus is a product of Labcenter Electronics and is not included. Arduino is
  a trademark of Arduino SA. This library is not made or endorsed by Arduino or
  Labcenter.

REBUILDING THE FIRMWARE (OPTIONAL)
The HEX file is supplied; Arduino IDE is not needed to run the demo. To edit
the sketch, open Arduino Code\PeristalticPump_Demo\PeristalticPump_Demo.ino,
select Arduino Uno and use Sketch > Export Compiled Binary. The sketch needs
8,496 bytes of flash (26 % of the UNO) and 277 bytes of RAM.

MODEL SCOPE AND LIMITS
Modelled: the gear motor (the winding resistance, the back-EMF through the
gearbox), the friction of the squeezed tube and the gears, the inertia, the
lift's pressure on the displacement, the current both ways, any voltage
either way, 0.8 mL a turn either way, the tubes filling, staying full and
emptying backward, the water delivered and run back.
How it runs: the speed is an internal analog node solved together with the
driver (backward Euler, analog steps of 0.1 ms or less, so a PWM driver's
pulses are resolved); the water is stepped at every accepted point.
Not modelled: the winding inductance, the pulsing of the flow at each roller,
the tube's wear and its springing back, air bubbles, viscous liquids, a
bottle running empty, the differences between real pumps and tubes.

VERSION
TEP 12V Peristaltic Pump library V1.0 (Oct 2026). Device PERIPUMPTEP
(TEPPERIPUMP.LIB / TEPPERIPUMP.DLL). Demo sketch PeristalticPump_Demo V1.0.
Demo driver: L9110SADVTEP (TEP L9110S Motor Driver library V1.0, a separate
library). Demo board: ARDUINO UNO V4.0 (TEP Arduino Library V4.0) with its
built-in serial monitor.