Project Files of L12 Linear Servo Library for Proteus V1.0 (Linear Actuator, Arduino)

L12 LINEAR SERVO LIBRARY FOR PROTEUS - V1.0 (an L12-R micro linear servo with a moving rod and a pop-up panel)
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/10/l12-linear-servo-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, no Virtual Terminal to wire - its own article:
  https://www.theengineeringprojects.com/2026/10/arduino-uno-library-for-proteus-v40.html
Support us (the libraries are free):
  https://www.theengineeringprojects.com/donate

FILE STRUCTURE
L12-Linear-Servo-TEP-v1.0/
|-- Proteus Library Files/
|   |-- ArduinoV4TEP.LIB                              201.9 KB   TEP Arduino boards V4.0 (UNO) -> LIBRARY
|   |-- TEPL12.LIB                                     18.2 KB   the library -> LIBRARY folder
|-- Proteus Model Files/
|   |-- TEPARDUINO.DLL                                883.5 KB   the Arduino board model -> MODELS folder
|   |-- TEPL12.DLL                                    293.0 KB   the model -> MODELS folder
|-- Proteus Simulation/
|   |-- L12_Linear_Servo_Demo.hex                      25.6 KB   the demo firmware
|   |-- L12-Linear-Servo-ArduinoUnoV4.pdsprj           21.9 KB   the demo project
|   |-- TEPARDUINO.DLL                                883.5 KB   copy of the board model
|   |-- TEPL12.DLL                                    293.0 KB   copy of the model
|-- Arduino Code/
|   |-- L12_Linear_Servo_Demo/L12_Linear_Servo_Demo.ino    4.6 KB   the demo sketch (source of the .hex)
|-- README.txt                                        ~19.0 KB   this file
Total: 2.58 MB (unzipped). The C++ source code of the models is not included.

WHAT IS IT?
A simulation model of the L12-R micro linear servo - the 30 mm stroke, 100:1
gearing, 6 V version: a small DC motor, a gearbox and a lead screw push a rod
in and out, and a built-in controller places the rod where RC servo pulses
tell it. Our own model, not a symbol on top of Proteus's motor:
  * It reads the pulses on SIG like the real servo: a servo pulse is 300 -
    3000 us; 1000 us puts the rod fully in (0 mm), 2000 us fully out (30 mm)
    (properties PULSE_MIN / PULSE_MAX). With the Arduino Servo library use
    attach(pin, 1000, 2000) and writeMicroseconds().
  * Inside: the position loop (a dead band of 0.08 mm), the DC motor (13.3
    ohm, back-EMF), the gearbox and the lead screw, end stops at -0.3 and 30.3
    mm. The rod moves at the real speed: 19 mm/s with no load at 5 V - 30 mm in
    about 1.7 s -, 23 mm/s at 6 V.
  * The force follows the supply: about 38 N at 5 V and 46 N at 6 V (the data
    sheet's 23 N at 12 mm/s peak power point at 6 V). Under a load it slows
    down: about 4 mm/s against 30 N at 5 V.
  * The current comes from V+ in the circuit: about 8 mA at rest, up to about
    0.38 A when it stalls at 5 V (0.45 A at 6 V).
  * A lead screw does not back-drive: with no pulses (detach()) the rod stays
    where it is, even under a load.
  * The load: property LOAD (N), the load buttons on the pop-up (10 - 40 N),
    or a click on the rod: a 60 N brake - more than an L12 can push: it
    stalls. A load it can carry holds the rod a little short - the loop's
    droop - and the pop-up says so.
  * The mistakes it names: no power or a low V+, SIG stuck HIGH, fast PWM
    (analogWrite) instead of servo pulses, a pulse beyond the range (the rod
    pushes into its end stop), a stall.
The symbol looks like the real actuator from the side: the black gearbox body
with the motor at the back and the rear mounting hole, the steel rod and the
black rod end with its hole, the black / red / white RC cable to its plug (GND,
V+, SIG). The rod moves on the schematic to the simulated position over a
printed 0 - 30 mm ruler; an orange tick on the ruler shows the position the
pulses ask for. The plate, the ruler, the PWR and SIG LEDs and the strip under
the plate (POSITION, PULSE, CURRENT and OPEN PANEL) are TEP additions; the real
actuator has none of them.

ONE DEVICE (search "L12" or "linear" in Pick Devices):
  L12SERVOTEP   "L12 Linear Servo V1.0"   (category Electromechanical > Linear
               Actuators), model TEPL12.DLL
  The pop-up panel "TEP L12 Linear Servo" opens at Run (and with OPEN PANEL on
  the strip) - the look of the TEP Serial Monitor. Tabs Servo, Graphs, Event
  log and Check; gear and ? icons for Settings and Help; the palette icon
  switches the theme:
    Servo      the state in big letters (HOLDING / MOVING / HOLDING AGAINST
               A LOAD / NO PULSES / STALLED / NO POWER), the actuator from the
               side - the rod over a 0 - 30 mm ruler, the orange target -, the
               live values (target, position, pulse, rate, speed, current,
               supply, load), the signal: one frame and the last pulse against
               the 0 / 15 / 30 mm marks. The toolbar: the load on the rod (None,
               10, 20, 30, 40 N) and the 60 N brake.
    Graphs     the position (the rod and the target), the supply current and
               the pulse width over the last 1, 3 or 6 s. Live / Freeze.
    Event log  power, every new target and every move with its time and speed
               ("reached 5.1 mm from 22.5 in 1036 ms"), a move stopped short
               by the load, the signal, the load, the warnings; filters All /
               Moves / Warnings, Pause, Clear
    Check      Good for: a rod that does not move, stops short, sits at an end,
               crawls or resets the Arduino - the supply, the signal, the pulse
               rate, the pulse widths seen against the servo's range, the
               range, the load against the force at this supply, the position
               and the current, each with a verdict (green = fine, amber =
               check, red = wrong)
    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 30 Oct 2026 (the demo project as shipped: an
A4 sheet, an Arduino UNO V4.0 with its built-in monitor, the L12 on D9, RV1 on
A0 at 75 %; the pop-up open).
What the runs showed (the rod's position as the model computed it):
  * The project loads and starts cleanly: "attach(9, 1000, 2000): 0 - 30 mm",
    "Pot 768 -> 22.5 mm -> pulse 1750 us"; "reached 22.4 mm from 1.5 in 1196 ms
    (17.5 mm/s)", 22.4 mm held at 8 mA.
  * mm 5: 1167 us - "reached 5.1 mm from 22.5 in 1036 ms (16.8 mm/s)"; knob:
    "reached 22.4 mm from 5.1 in 1033 ms (16.8 mm/s)".
  * The load (the pop-up's chips) at 5 V: 40 N and mm 5 - the rod did not
    move: "STALLED at 22.43 mm - the load (40 N) is above its force (38 N at 5.0
    V), 382 mA" (the pop-up: 383 mA). 30 N: the rod crawled down at about 4
    mm/s, about 300 mA, and "stopped at 5.8 mm, 0.8 mm short of 5.0 (the
    load)"; the pop-up: "HOLDING 5.7 MM AGAINST 30 N - 0.69 MM SHORT (THE LOOP'S
    DROOP)", 184 mA.
  * sweep: 0 -> 30 -> 0 mm at 10 mm/s, the rod on the target; "Sweep done -
    following the pot".
  * knob again: 22.4 mm; the Check page all green - "50.0 Hz - right for an RC
    servo input (50 Hz)", "the L12 pushes 38 N at 5.0 V (38 at 5 V, 46 at 6
    V)", "8 mA now, 545 mA peak".
  * The pop-up: Servo, Graphs (1 / 3 / 6 s), Event log, Check - all four pages
    followed the run.
  Plus automatic checks on a PC, 0 failed: 23 on the servo (0 - 30 mm in 5 mm
  steps within 0.1 mm; 30 mm in 1.671 s at 5 V, 1.360 s at 6 V; top speed 19.0
  mm/s; no overshoot; 8 mA at rest; 30 N reaches 29.30 mm (0.70 mm of droop);
  40 N stalls at 5 V and gets through at 6 V; the 60 N brake stalls it at 384
  mA; no pulses = no drive; detach() holds the rod even under 20 N; 2300 us =
  the end stop; analogWrite pulses ignored; SIG stuck HIGH found; 2.5 V =
  dead); 6 on the pop-up pages rendered; the demo project read back from disk
  (51 checks: devices, pins, wires, labels, no wire through a part, no wire
  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" (TEPL12.LIB, and our Arduino
   library V4.0, ArduinoV4TEP.LIB, with the ARDUINO UNO V4.0 used by the demo)
   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 TEPL12.DLL and TEPARDUINO.DLL from "Proteus Model Files" to the
   MODELS folder (...\Proteus 8 Professional\MODELS).
   ArduinoV4TEP.LIB and TEPARDUINO.DLL are the files of our Arduino Library
   V4.0 - if you have it, they are the same.
4. Delete TEPL12.IDX from the LIBRARY folder if it is there (Proteus makes a
   new index).
5. Start Proteus. In Pick Devices (P) search "L12".

RUN THE DEMO
"Proteus Simulation\L12-Linear-Servo-ArduinoUnoV4.pdsprj" (an A4 sheet) - keep
the .hex file and the two DLLs beside the project.
  ARD1: Arduino UNO V4.0 running L12_Linear_Servo_Demo.hex (the Arduino Servo
        library), its serial monitor built in (window "TEP Arduino UNO - ARD1").
  SERVO1: the L12 - SIG on D9 (by the SIG net label), V+ on the +5V power
        terminal (Proteus' 5 V rail), GND.
  RV1: a 10k potentiometer (POT-HG) on A0: turn it and the rod follows.
  1. Press Run. The monitor and the servo's pop-up open (move them aside -
     they open over the schematic). The rod goes to the pot's position (RV1 at
     75 %: 22.5 mm = 1750 us).
  2. Type mm 5 in the monitor and press Enter or Send; then knob.
  3. On the pop-up pick 40 N and type mm 5: STALLED - more than the 38 N an L12
     pushes at 5 V. Pick 30 N: it crawls, and holds a little short. Click the
     rod for the 60 N brake (again to release).
  4. Try sweep, us 2200 (beyond the range), detach - see THE DEMO SKETCH; and
     the pop-up's Graphs, Event log and Check.
Closed a window? The monitor: click the UNO's USB port; the pop-up: OPEN PANEL.

WIRING (the same in Proteus and on a real board)
  L12-R wire       Arduino UNO
   black (GND)    GND
   red (V+)       5 - 6 V (the 6 V version; 0.45 A stall)
   white (SIG)    D9 (any digital pin: the Servo library makes the pulses
                  with Timer1)
  Potentiometer   the ends to 5V and GND, the wiper to A0
In the sketch (Arduino Servo library, installed with the Arduino IDE):
  #include <Servo.h>
  Servo rod;
  rod.attach(9, 1000, 2000);       // D9: 50 Hz pulses, 1000 - 2000 us = 0 - 30 mm
  rod.writeMicroseconds(1500);     // 15 mm
REAL HARDWARE:
 * Use attach(pin, 1000, 2000): plain attach(pin) sends 544 - 2400 us, and
   write(0) / write(180) push the rod into its end stops.
 * One L12 on the Arduino's 5V is fine (0.38 A stall at 5 V); more of them, or
   the 12 V version, want their own supply, GND common.
 * The rod takes side loads badly: guide the load, push along the rod.
 * analogWrite() is not a servo signal (980 Hz PWM): use the Servo library.

THE DEMO SKETCH ON THE SERIAL MONITOR (L12_Linear_Servo_Demo V1.0, 9600 baud)
  mm 12.5       go to 12.5 mm and stay (the pot is ignored until knob)
  us 1500       writeMicroseconds(1500), 800 - 2200 us - try 2200: beyond the
                servo's range, the rod pushes against its end stop (the Servo
                library clamps writeMicroseconds() to the attach() limits, so
                the sketch re-attaches with attach(9, 800, 2200) for a pulse
                outside them)
  sweep         0 -> 30 -> 0 mm at 10 mm/s, then back to the pot
  knob          follow the pot on A0 again
  detach        stop the pulses - the rod is no longer driven (the screw holds)
  help          the list
EXPECTED MONITOR OUTPUT
  L12 Linear Servo demo - The Engineering Projects
  attach(9, 1000, 2000): 0 - 30 mm
  Turn the pot on A0, or type mm 15.
  Commands: mm 12.5 = position, us 1500 = pulse width, sweep, knob, detach, help
  Pot 768 -> 22.5 mm -> pulse 1750 us

PROPERTIES (double-click the part > Edit Properties)
  PULSE_MIN   the pulse for the rod fully in (0 mm) in us (default 1000)
  PULSE_MAX   the pulse for the rod fully out (30 mm) in us (default 2000)
  START       the rod's position at the start in mm (default 0)
  LOAD        a constant load on the rod in N (default 0; the L12 pushes 38 N at
              5 V, 46 N at 6 V)
Every run starts again from the properties. The demo's UNO (ARDUINO UNO V4.0):
PROGRAM L12_Linear_Servo_Demo.hex, MONITOR YES (the built-in monitor), BAUD
9600, AUTOOPEN YES, BOOTLOADER YES.

LINKS.INI (OPTIONAL)
The Help page cards of the pop-up open web pages. To point them somewhere else
without a new DLL, put a text file named links.ini next to TEPL12.DLL with
lines KEY=URL, for example:
  ARTICLE=https://www.theengineeringprojects.com/...
Keys: WEBSITE, FORUM, BUG_REPORT, FEATURE_REQUEST, ARTICLE, USER_GUIDE,
UPDATE_CHECK, DONATE. Only http:// and https:// links are used; lines starting
with # are comments.

TROUBLESHOOTING
* The rod sits at an end and the current is high: a pulse beyond 1000 - 2000 us
  (plain attach(pin) sends 544 - 2400 us) - use attach(pin, 1000, 2000).
* The rod never moves and the pop-up says NO POWER: V+ is not connected or
  below 3 V (the L12 wants 5 - 6 V).
* WAITING FOR PULSES / no pulses: SIG is on another pin than the sketch's
  attach(), or the sketch never called attach() / write().
* "SIG stays HIGH" or "pulses under 300 us": digitalWrite() or analogWrite() on
  the SIG pin - use the Servo library.
* The rod crawls: a load (LOAD, the pop-up's load buttons) - under 30 N it
  moves at about 4 mm/s at 5 V - and it stops a little short: HOLDING AGAINST
  A LOAD.
* STALLED: the load is above the force at this supply (38 N at 5 V), or the
  brake - the orange ring round the rod end.
* The part is not simulated / the rod never moves: TEPL12.DLL is missing from
  MODELS and from the project folder. No UNO / no monitor window:
  TEPARDUINO.DLL is missing, 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

WEBSITE
  https://www.theengineeringprojects.com/

LICENCES AND THIRD-PARTY NOTES
* The servo model (TEPL12.DLL), the symbol and artwork and the Arduino Library
  V4.0 (ArduinoV4TEP.LIB / TEPARDUINO.DLL, with its built-in TEP Serial Monitor
  Advance) are made by The Engineering Projects. The model is an independent
  implementation written from the typical data of the L12-R micro linear
  servo. The model uses only standard Windows libraries; no Visual C++
  redistributable is needed.
  The C++ source code is not included.
* Arduino UNO V4.0 (ArduinoV4TEP.LIB / TEPARDUINO.DLL, our Arduino Library
  V4.0 - its microcontroller is Proteus's own AVR model): The Engineering
  Projects, https://www.theengineeringprojects.com/2026/10/arduino-uno-library-for-proteus-v40.html
* The potentiometer is Proteus's own POT-HG.
* The demo sketch uses the Arduino Servo library 1.2.2 (LGPL 2.1, Arduino:
  https://github.com/arduino-libraries/Servo), installed with the Arduino IDE.
  The .hex file is built from the demo sketch, the Servo library and the
  Arduino AVR core 1.8.6, which include LGPL-licensed code; their source code
  is available at https://github.com/arduino-libraries/Servo/tree/1.2.2 and
  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. L12 is an Actuonix product.
  This library is not made or endorsed by Actuonix, 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\L12_Linear_Servo_Demo\L12_Linear_Servo_Demo.ino (the
Servo library comes with the Arduino IDE), select Arduino Uno and use Sketch >
Export Compiled Binary. Replace the simulation's .hex with the exported HEX.
The sketch needs 9,302 bytes of flash (29 % of the UNO) and 326 bytes of RAM.

MODEL SCOPE AND LIMITS
Modelled: the L12-R's pulse decoding (300 - 3000 us, the period between
pulses), the drive while pulses come (about 22 ms after each pulse), the
position loop with its dead band, the motor (resistance, back-EMF), the gearbox
and the lead screw (no back-driving), friction, end stops, the current from V+,
the force and the speed from the supply (5 - 6 V; 3 V and less: nothing moves),
a load force against the motion, the droop under a load, stalls.
How it runs: Proteus runs the digital side (the Arduino's pulses) before each
analog step; the servo keeps every SIG edge with its time and integrates its
motor and rod over each step from that history, in 50 us steps, with analog
steps of 1 ms or less.
Not modelled: the other strokes (10, 50, 100 mm), gearings (50:1, 210:1) and
the 12 V version; a load that pulls the rod (it is taken as a force against
the motion); side loads, wear and heating. The L12-P (potentiometer feedback)
and L12-I (limit switches) are other parts.

VERSION
TEP L12 Linear Servo library V1.0 (Oct 2026). Device L12SERVOTEP (TEPL12.LIB /
TEPL12.DLL). Demo sketch L12_Linear_Servo_Demo V1.0 (Arduino Servo library
1.2.2). Demo board: ARDUINO UNO V4.0 (TEP Arduino Library V4.0) with its
built-in serial monitor.