12V Linear Actuator Library for Proteus V1.0 (50mm, 1000N, Arduino)

Hello friends, I hope you all are doing great. Today, I am going to share the new 12V Linear Actuator Library for Proteus V1.0. A linear actuator turns a motor's rotation into a straight push and pull, and the common 12 V "electric putter" does it with real force: TV lifts, hatch and window openers, solar trackers, standing desks, chicken coop doors and robot joints all use one. This library simulates the popular 50 mm, 1000 N type with the two things that make it so easy to use - built-in limit switches and a self-locking lead screw.

On the sheet, the actuator stands up and its rod lifts a platform with a load on it, so you can watch it push 1000 N, stop at the end of its stroke by itself and hold the load with the power off. The demo runs on our Arduino UNO V4.0 and drives the actuator from 12 V through our separate BTS7960 library, with a potentiometer for out and in.

NOTICE: a linear actuator in a simulator has to do three things right: draw the current a real one draws, stop at its ends the way a real one stops, and hold its load the way a real one holds it. Our team put a lot of effort into all three, and into a symbol that moves with the simulation. Your feedback is the fuel that keeps us going, so please tell us what you think in the comments below or in the Motor Driver board of our forum. And if our free libraries help you, you can buy us a coffee. So, let's get started with the 12V Linear Actuator Library for Proteus V1.0:

What is a 12V Linear Actuator?

Inside the aluminium tube of a linear actuator sits a lead screw. A small DC motor beside the tube turns it through a gearbox, and a nut on the screw pushes the inner rod out or pulls it in. Reverse the motor's polarity and the rod changes direction - there is no controller inside, just two wires. The actuator in this library has a 50 mm stroke and pushes 1000 N, about the weight of 100 kg, at roughly 9 mm/s; with no load it moves at 12 mm/s.

Limit Switches and Self-Locking

Two small switches inside the tube make a plain actuator safe to use from almost any controller. When the rod reaches the end of its stroke, a switch opens and cuts the motor. A diode across each switch lets the current flow the other way, so the actuator can always go back - only the direction that would go further is blocked. That is why you can simply apply 12 V and let it run out: it stops by itself at 50 mm, with no stall and no burnt motor.

The second trick is the screw itself. A lead screw slides, and its friction grows with the force it carries - in this model by 1.08 times the load. So the load can never turn the screw backwards: the actuator is self-locking, and a lid, a monitor or a platform stays exactly where the rod left it when the power goes off. The price is efficiency: less than half of the motor's effort reaches the load. It is the same principle as the worm gear in our JGY-370 Worm Gear Motor Library for Proteus.

What's New in 12V Linear Actuator Library for Proteus V1.0

• A 12 V actuator with real current: the winding, the back-EMF, the friction of the gears, the screw and the seals and the load, from any driver, PWM or DC, either way.
• Built-in limit switches: at 0 and 50 mm the motor stops by itself with 0 A, and only the other direction runs on.
• Self-locking: the screw's friction grows with the load, so the load can never push the rod back.
• A moving symbol: the actuator stands up and its rod lifts a platform with the load, its force written on it, over a 0 - 50 mm ruler.
• Loads: LOAD and START properties and load buttons from 250 to 1000 N on the pop-up.
• A pop-up window with four pages - Actuator, Graphs, Event log and Check - with FULLY OUT / FULLY IN and HOLDING states.
• A demo on our Arduino UNO V4.0 and our BTS7960 driver: the pot for out and in, and commands to move and stop.

The Linear Actuator in Proteus

Search actuator in Pick Devices; the device LINACT12VTEP is in TEPLINACT.LIB (category Electromechanical, Linear Actuators) and its model is TEPLINACT.DLL. It shows the actuator standing up, from the side, at a quarter of its real size: the rear clevis at the bottom, the black gearbox housing with its cable gland, the aluminium tube with the rod seal, the black motor beside the tube and the polished rod with its clevis. On the rod sits a platform with the load block, and a ruler on the left shows the position from 0 to 50 mm with a red pointer.

While the simulation runs, the rod, the platform and the load move with the simulated position. The strip under the plate gives the speed in mm/s with the direction, the position and the current, next to the OPEN PANEL button. The plate, the platform, the load, the ruler and the LEDs are TEP additions; the LEDs show OUT (green) and IN (amber).

Two properties set the scene: LOAD is the force pushing the rod in, in newtons (default 500 - about 50 kg on the platform), and START is the rod's position at the start in mm (default 0, fully in).

Download 12V Linear Actuator Library for Proteus

Click the button below to download 12V-Linear-Actuator-Library-for-Proteus-v1.0.zip (about 1.2 MB, without the source code of the models):

• README.txt: installation, the demo, the wiring, real hardware, troubleshooting and the limits.
• Proteus Library Files: TEPLINACT.LIB and ArduinoV4TEP.LIB from our Arduino Library for Proteus V4.0.
• Proteus Model Files: TEPLINACT.DLL and TEPARDUINO.DLL.
• Proteus Simulation: 12V-Linear-Actuator-BTS7960-ArduinoUnoV4.pdsprj, LinearActuator_Demo.hex and copies of the two DLLs.
• Arduino Code: LinearActuator_Demo.ino (no library needed).

The driver is a separate library: this package holds only the actuator and the UNO. The demo drives it through our BTS7960 (IBT-2) motor driver, which has its own download - get it from our BTS7960 Motor Driver Library for Proteus and install it first, or the demo opens without its driver.

No Proteus yet? Read How to Download and Install Proteus 7 and 8. New to libraries? Follow How to Install a New Library in Proteus.

How to Install 12V Linear Actuator Library for Proteus

1. Close Proteus and extract the whole zip file, for example to your Desktop.
2. Copy TEPLINACT.LIB and ArduinoV4TEP.LIB from Proteus Library Files into the LIBRARY folder of Proteus (usually C:\Program Files (x86)\Labcenter Electronics\Proteus 8 Professional\LIBRARY).
3. Copy TEPLINACT.DLL and TEPARDUINO.DLL from Proteus Model Files into the MODELS folder. The two Arduino files are the ones of our Arduino Library V4.0; if you have it, they are the same.
4. Install our BTS7960 Motor Driver library the same way from its own zip: TEPBTS7960.LIB into LIBRARY and TEPBTS7960.DLL into MODELS.
5. Delete TEPLINACT.IDX from the LIBRARY folder if it is there.
6. Start Proteus, press P and search for actuator.

Tip: keep the Proteus Simulation folder together, because the project needs its .hex file and the DLLs beside it. The library is tested in Proteus 8.5; Proteus 7 is not supported.

The Demo Circuit

Open 12V-Linear-Actuator-BTS7960-ArduinoUnoV4.pdsprj. ARD1 is an Arduino UNO V4.0 from our Arduino UNO Library for Proteus V4.0, running LinearActuator_Demo.hex with its serial monitor built in. DRV1 is the BTS7960 (IBT-2) driver in its pop-up version. M1 is the actuator on the driver's M+ and M-, with 500 N on the platform. RV1 is a 10k potentiometer on A0: the middle stops the rod, right drives it out and left drives it in.

Why a BTS7960 and not a small driver? The actuator takes 3 A at its rated 1000 N and close to 10 A for a moment at every start and at a stall, which is far beyond an L298N or an L9110S. The driver's logic side runs on the UNO's 5V, its power side on a +12V power terminal.

The Arduino Code

The demo needs no library. New to Arduino? Start with Arduino Tutorial for Beginners and Introduction to Arduino UNO. The pins come first:

const int RPWM = 5, LPWM = 6, R_EN = 7, L_EN = 8, POT = A0;

In setup() all four become outputs and the actuator starts stopped:

  pinMode(RPWM, OUTPUT); pinMode(LPWM, OUTPUT); pinMode(R_EN, OUTPUT); pinMode(L_EN, OUTPUT);
  drive(0);

One function drives the BTS7960: PWM on RPWM drives the rod out, PWM on LPWM drives it in, and both LOW stop it. The pin that must be LOW is always written first, so the two halves of the bridge never push against each other:

void drive(int s) {                   // the pin that must be LOW first
  s = constrain(s, -255, 255);
  digitalWrite(R_EN, HIGH); digitalWrite(L_EN, HIGH);
  if (s > 0) { analogWrite(LPWM, 0); analogWrite(RPWM, s); }
  else if (s < 0) { analogWrite(RPWM, 0); analogWrite(LPWM, -s); }
  else { analogWrite(RPWM, 0); analogWrite(LPWM, 0); }
  speedNow = s;
}

The commands out and in take a percentage and turn it into a signed PWM value:

  if (!strncmp(s, "out", 3) || !strncmp(s, "in", 2)) {
    const bool out = s[0] == 'o';
    int pct = constrain(atoi(s + (out ? 3 : 2)), 0, 100);

stop drives zero, and that is all it needs to do: the lead screw holds the load by itself, and the sketch says so:

  if (!strcmp(s, "stop")) { mode = FIXED; drive(0); report(F("stop")); return; }

  if (speedNow == 0) Serial.println(F(" -> stop: the lead screw holds the load"));

Notice also what the sketch does not contain: any code for the ends. The actuator's own limit switches stop it at 0 and 50 mm, so the Arduino can keep driving and nothing breaks. The pot is read in the loop - its 0 - 1023 becomes -255 to 255, with a dead zone round the middle - and knob gives it the control back:

      int s = map(raw, 0, 1023, -255, 255);
      if (abs(s) < 20) s = 0;                       // a dead zone round the middle

  if (!strcmp(s, "knob")) { mode = KNOB; lastKnob = 9999; Serial.println(F("Following the pot on A0")); return; }

The open-loop basics of motor control are in our older DC Motor Speed Control using Arduino tutorial. The HEX file is in the package; to change the sketch, open it in the Arduino IDE and export the compiled binary, as in How to get the HEX file from Arduino. It needs 5,188 bytes of flash (16 % of the UNO) and 254 bytes of RAM.

Running the Demo

Press Run. The UNO's serial monitor and the pop-ups of the actuator and the BTS7960 open over the schematic; move them aside. RV1 starts at 75 %, so the rod goes out at about half speed with its 500 N: 4.0 mm/s at 5.95 V and 1.87 A. This is the whole session of our test run, with the commands typed in the monitor:

12V Linear Actuator demo - The Engineering Projects
BTS7960: RPWM D5, LPWM D6, R_EN D7, L_EN D8. Turn the pot on A0: the middle stops, right = out, left = in.
Commands: out 80 | in 50 | stop | knob | help
Pot 768 -> out 49 % (PWM 127/255)
stop
stop -> stop: the lead screw holds the load
out 100
out -> out 100 % (PWM 255/255)
in 100
in -> in 100 % (PWM 255/255)
stop
stop -> stop: the lead screw holds the load

The Pop-Up Window

At Run the actuator opens TEP 12V Linear Actuator, a window in the look of our TEP Serial Monitor Advance for Proteus. Its four tabs are Actuator, Graphs, Event log and Check, with Settings and Help behind the gear and question mark icons. If you close it, OPEN PANEL on the strip brings it back.

The banner gives the state in one line - here "EXTENDING 500 N" with the speed and the drive. The gauge runs from 15 mm/s in (left) to 15 mm/s out (right), with the band from 9 mm/s at 1000 N to 12 mm/s with no load marked. The live values are the speed, the direction, the average voltage, the current, the drive, the power, the load and the position. The toolbar puts None, 250, 500, 750 or 1000 N on the platform.

Self-Locking: Stop Halfway

Type stop halfway. The drive goes off, the current drops to zero and the rod stays exactly where it is. The banner turns teal: "HOLDING 500 N AT 21.5 MM WITH NO DRIVE - THE SCREW LOCKS", and the Event log adds "holding 500 N at 21.5 mm with no drive - the lead screw locks (self-locking)".

Now click 1000 N while it is off. Twice the load, and the rod still does not move - 1000 N is exactly the self-locking force of this actuator. In our host tests, the same screw without its load-dependent friction lets the load push the rod all the way in.

The Check page puts it in rows with a verdict each: the drive (none), the current against the common drivers, the speed, the load, the self-locking - "the lead screw holds 1000 N at 21.5 mm with no drive - the load cannot push it back" - and the position.

Pushing 1000 N to the End

Type out 100 with the 1000 N still on: "steady 8.9 mm/s out, 1000 N, at 11.92 V average, 2.998 A" - the rated point of the actuator, close to the 9 mm/s and 3 A of its data. The BTS7960 hardly loses any voltage at 3 A.

It keeps going until the rod reaches 50 mm. There the limit switch opens, the motor stops with 0 A and the rod stays at 50.1 mm - it coasts a tenth of a millimetre. The driver still puts 12 V on the wires; the actuator simply refuses that direction.

The pop-up turns blue: "FULLY OUT (50.1 MM) - THE LIMIT SWITCH CUT THE MOTOR, 0 A", and the Event log says "fully out (50.0 mm): the limit switch opened - the motor stops, 0 A". Compare this with the winch of our JGY-370 library, which stalls at the top because a plain motor has no switch to stop it.

Then in 100: the open switch lets this direction through and the rod comes back at 11.9 mm/s with 0.84 A - faster and with much less current than going out, because the load now helps. But the motor still has to drive the screw: a self-locking screw cannot be pushed in by the load alone.

Graphs and Event Log

The Graphs page draws the speed, the current and the rod's position over the last 1, 3 or 6 seconds. At the end of the run - in 100, then stop - the speed and the current drop to zero and the position line simply goes flat at 21.8 mm with 1000 N on it.

The Event log is the actuator's diary, newest first: every steady speed with the direction and the load, every stop with its position, the holds, the load changes and the end of the stroke. Filters show only the drive and speed or only the warnings.

How the Model Works

The actuator is solved by Proteus's analog engine: the rod's speed is an internal node computed together with the driver from the winding resistance, the back-EMF, the friction, the equivalent mass of the motor and the gears and the load, in analog steps of 2 ms or less. The screw's friction grows with the force on the rod. At each end, the switch for the direction that would go further opens the motor's circuit; the other direction stays closed, as the diode in a real actuator does.

The demo runs at about 0.2 x real time on a desktop PC: 27 seconds of simulation took about 2 minutes. We checked the model on a PC with 16 automatic tests: 12.00 mm/s and 0.75 A at 12 V with no load, 90 % of the speed in 18 ms, 9.00 mm/s and 3.00 A at 1000 N, 5.5 mm/s at 6 V, both ends with 0 A and the way back still open, 1000 N held for 2 seconds with the motor shorted and with it open (0.006 mm of creep), retracting under 1000 N at 11.9 mm/s and 0.84 A, and 4500 N stalling at 9.75 A.

Why the Actuator Says STEADY

Our BTS7960 model does not switch the motor on and off a thousand times a second; in each analog step it hands the motor the average of its PWM over whole PWM periods. The speed is exactly what the PWM gives, and the simulation runs much faster. So the actuator's Drive tile reads STEADY, while the UNO's 980 Hz PWM is on the BTS7960's own pop-up.

Troubleshooting

• The rod never moves and the pop-up says NO DRIVE: the driver's R_EN / L_EN, its B+ supply, or the wires on the wrong outputs.
• It does not move in one direction, 0 A: it is at that end and the limit switch is open - drive it the other way.
• No driver in the project: install our BTS7960 library (TEPBTS7960.LIB / TEPBTS7960.DLL) - it is not in this package.
• Slow, about half speed: the driver's B+ is on 5 V or 6 V, not 12 V.
• It goes in when it should go out: swap the actuator's wires, or RPWM and LPWM.
• STALLED: less load, or more drive.
• Nothing moves on the sheet, no UNO or no monitor: TEPLINACT.DLL or TEPARDUINO.DLL is missing from MODELS and the project folder; a closed monitor opens again with a click on the UNO's USB port.

Things to Know Before Using a Real Linear Actuator

• The current: about 0.75 A with no load, 3 A at 1000 N and near 10 A for a moment at a start or a stall. A BTS7960, two relays or a MOSFET bridge suits it; an L298N only for light loads.
• Stopping in between: the limit switches only stop it at the ends. To stop at a position you need a timer or an actuator with a feedback potentiometer or Hall sensor - or a linear servo like the one of our L12 Linear Servo Library for Proteus.
• Duty cycle: real actuators are rated for about 10 - 25 % on-time; let them rest between long runs.
• Mounting: both clevises on pins, so the rod only pushes and pulls; side loads bend it.
• Safety: self-locking holds a load at rest, it is not a brake for a load that is already falling - never stand under a lifted load.
• Know your actuator: 12 V actuators come with strokes from 25 to 1000 mm and forces from about 100 to 6000 N; this one is the 50 mm, 1000 N, 12 mm/s type.

Limitations of the Simulation

• Not modelled: the winding inductance, the backlash of the gears and the screw, side loads, the switches' hysteresis and bounce, heating and the duty cycle limit, and the differences between real actuators.
• The actuator is the 12 V, 50 mm, 1000 N type; other strokes and forces are not selectable.
• The plate, the platform, the load, the ruler, the LEDs and the strip are TEP additions.
• The model is our own, written from the typical data of 12 V 50 mm 1000 N linear actuators; this library is not made or endorsed by Arduino or Labcenter.
• Licences: the demo needs no Arduino library; the HEX file contains the Arduino AVR core 1.8.6 with LGPL-licensed code, and the sketch is included. The potentiometer is Proteus's own POT-HG. The BTS7960 driver is our separate library.
• Tested in Proteus 8.5 in October 2026 with the demo as shipped: the pot, holding 500 and 1000 N, pushing 1000 N to the end, the limit switch, retracting and the pop-ups. Proteus 7 is not supported.

So, that was all about the 12V Linear Actuator Library for Proteus V1.0. I hope it helps you plan your lift, opener or tracker - its driver, its supply and its stops - before the first rod moves on the bench. If you have any questions, ask in the comments and I will help you out. Till the next tutorial, take care and have fun!