Project Files of Rotary Inverted Pendulum Lab Library for Proteus

ROTARY INVERTED PENDULUM LAB LIBRARY FOR PROTEUS - V1.0 (a rotary pendulum lab with a pop-up)
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/rotary-inverted-pendulum-lab-library-for-proteus.html
Report a bug or suggest a feature (our forum):
  https://www.theengineeringprojects.com/forum/category/rotary-pendulum-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
Rotary-Inverted-Pendulum-TEP-v1.0/
|-- Proteus Library Files/
|   |-- ArduinoV4TEP.LIB                              201.9 KB   TEP Arduino boards V4.0 (UNO) -> LIBRARY
|   |-- TEPROTPEND.LIB                                 22.8 KB   the library -> LIBRARY folder
|-- Proteus Model Files/
|   |-- TEPARDUINO.DLL                                883.5 KB   the Arduino board model -> MODELS folder
|   |-- TEPROTPEND.DLL                                345.0 KB   the model -> MODELS folder
|-- Proteus Simulation/
|   |-- Pendulum_Demo.hex                              22.7 KB   the demo firmware
|   |-- Pendulum-LQR-ArduinoUnoV4.pdsprj               18.9 KB   the demo project
|   |-- TEPARDUINO.DLL                                883.5 KB   copy of the board model
|   |-- TEPROTPEND.DLL                                345.0 KB   copy of the model
|-- Arduino Code/
|   |-- Pendulum_Demo/Pendulum_Demo.ino                 5.2 KB   the demo sketch (source of the .hex)
|-- README.txt                                        ~14.2 KB   this file
Total: 2.68 MB (unzipped). The C++ source code of the models is not included.

WHAT IS IT?
A rotary inverted pendulum control lab, drawn at true scale and seen from the front and a little
above - our own design, after the rotary
pendulums of university control courses:
  * A 100 x 80 x 100 mm black base holds a coreless DC motor (the values of the Allied Motion CL40,
    its 12 V winding: 4.6 ohm, 30 mN.m/A) and
    an H-bridge. On the motor's hub an 80 mm aluminium arm turns; at its tip a 1024-line encoder
    carries a 100 mm steel pendulum (22.3 g)
    that swings in the plane across the arm. A second 1024-line encoder sits on the motor. PWR, FWD
    and REV LEDs on the front.
  * The physics: the full nonlinear equations of the rotary (Furuta) pendulum - the arm with the
    motor's torque, back-EMF and friction, the
    pendulum as a uniform rod and its coupling to the arm - solved in steps of 0.1 ms. Upright, the
    pendulum is an unstable pole of 16.1 rad/s.
  * The H-bridge: PWM high drives the motor from 12V (DIR high forward, low reverse), PWM low brakes
    it; every edge is timed.
  * The encoders: A1 / B1 (the arm) and A2 / B2 (the pendulum, from where it started) in quadrature,
    A leading B while the angle grows.
  * Click it at Run for the pop-up: the arm from above and the pendulum along it, the energy, the
    arm, the pendulum and the motor since the
    start, the linear model about upright (its poles), the LQR gains for the Q / R properties (a 2
    ms loop) with the closed-loop poles, the
    swing-up (swings, the catch), every arm move (rise, overshoot, the wrong-way dip, settling) and
    the tap.
The body is drawn as on the real part and to true scale against our Arduino.
The TEP signature and the pop-up are TEP additions.

ONE DEVICE (search "ROTPEND" in Pick Devices):
  ROTPENDTEP  "Rotary Inverted Pendulum V1.0" in TEPROTPEND.LIB (Control Labs > Motion), prefix U,
  model TEPROTPEND.DLL (mixed: digital +
              SPICE). Pins 12V (the motor's supply), PWM, DIR (the H-bridge), A1, B1 (the arm's
              encoder), A2, B2 (the pendulum's encoder), 5V
              (the encoders), GND - on the base's left edge.

THE POP-UP
Click the part at Run. Tabs:
    Lab        the arm from above and the pendulum along it (the LQR's catch zone, the energy), the
    arm, the pendulum and the motor since the
               start, and eight live values: the arm, the pendulum, the motor, the bridge, the
               model, the LQR gains, the swing-up and the
               last move (or the tap).
    Graphs     the live values over the last 2, 6 or 15 s. Live / Freeze.
    Event log  every change and warning; filters All / Changes / Warnings, Pause, Clear
    Check      what the part is doing and what to look at, 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 7 Nov 2026 (the demo project as shipped: an A4 sheet, an Arduino UNO V4.0).
What the runs showed (the model's own numbers and the sketch's monitor):
  * The project loads and starts cleanly; the demo runs 12.4 simulated seconds in about two minutes
    on our PC; the bridge's PWM is 31.4 kHz.
  * Swing-up: a push of the arm at 0.5 s; the pendulum is caught upright at 1.045 s after 2 swings
    (0.48 s of swing-up), the arm at +3.7 deg.
  * The LQR (Q 20 10 0.5 0.1, R 1, a 2 ms loop): K 4.166 V/rad, 30.64 V/rad, 1.519 V.s/rad, 2.360
    V.s/rad. Open-loop poles about upright
    16.1, 0, -0.84 and -16.9 rad/s; closed-loop poles -7.5, -8.9, -11.4 and -41.3 rad/s.
  * Arm moves while balanced: 0 to +45.3 deg - the dip the wrong way 9.7 %, rise 380 ms, overshoot
    0.8 %, settled (5 %) in 0.64 s, the
    pendulum out to 6.2 deg; +44.9 to -0.4 deg - dip 10.8 %, rise 378 ms, overshoot 0.4 %, 0.65 s,
    the pendulum out to 6.4 deg.
  * Holding over a second: the pendulum within 0.26 deg, the arm within 0.55 deg, the motor 0.31 V
    RMS.
  * The tap at 9 s (+2 rad/s): the pendulum out to 5.6 deg, the arm 14.9 deg; back within 1 deg in
    0.31 s.
  * The balance off at 11.5 s: the pendulum falls at 12.02 s. The pop-up: Lab, Graphs, Event log,
    Check - all four pages followed the run.

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" (TEPROTPEND.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
   (use the folder that already holds Proteus's own .LIB files).
3. Copy TEPROTPEND.DLL and TEPARDUINO.DLL from "Proteus Model Files" to the MODELS folder
(...\Proteus 8 Professional\MODELS).
4. Delete TEPROTPEND.IDX from the LIBRARY folder if it is there (Proteus makes a new index).
5. Start Proteus. In Pick Devices (P) search "ROTPEND".

RUN THE DEMO
"Proteus Simulation\Pendulum-LQR-ArduinoUnoV4.pdsprj" (an A4 sheet) - keep the .hex file and the
DLLs beside the project.
  ARD1:   Arduino UNO V4.0 running Pendulum_Demo.hex, its serial monitor built in (window "TEP
  Arduino UNO - ARD1").
  U1:     the pendulum lab (TAP = 9 s): PWM - D9 (Timer1 at 31.4 kHz), DIR - D8, A1 - D2, B1 - D4,
  A2 - D3, B2 - D5, 5V - VCC, 12V - a
          +12V terminal, GND. A1 and A2 are on the UNO's two external interrupts; each A edge is one
          count (2048 counts per turn).
  1. At 0.5 s a push of the arm starts the pendulum swinging; the energy swing-up brings it to the
  top, where the LQR catches it.
  2. Balanced, the arm goes to 45 degrees at 4 s and back at 6.5 s (it dips the wrong way first);
  the lab taps the pendulum at 9 s.
  3. At 11.5 s the balance goes off and the pendulum falls.
Closed the monitor? Click the UNO's USB port.

WIRING (the same in Proteus and on a real board)
  PWM: a fast PWM pin (D9 with Timer1's prescaler at 1: 31.4 kHz); DIR: any pin; A1, A2: the two
  interrupt pins (D2, D3); B1, B2: any pins;
  5V and GND; 12V: a supply that can give 2.6 A (the motor's stall current).
REAL HARDWARE:
 * A real rotary pendulum's encoder cable winds up: keep the arm within a turn or two either way.
 * Start with the pendulum hanging still: its encoder counts from where it is at power-up.
 * The swing-up throws the pendulum hard: keep hands and cables out of its circle.
 * A real arm has some backlash and the pendulum's bearing some friction: expect the arm to wander a
   degree or two while balancing.

THE DEMO SKETCH ON THE SERIAL MONITOR (Pendulum_Demo V1.0, 9600 baud)
There are no commands. The sketch swings the pendulum up, balances it, moves the arm, rides out the
tap, lets go, and prints every 0.5 s.
EXPECTED MONITOR OUTPUT
  Rotary Inverted Pendulum - The Engineering Projects
  t=5.00 s: arm 45.5, pend -0.2, 0.02 V
  t=8.00 s: arm 0.5, pend -0.2, -0.06 V

PROPERTIES (double-click the part > Edit Properties)
  Encoder lines (LINES)                lines per turn of both encoders (x4 = counts per turn)
  The pendulum at the start (START)    degrees from hanging (its encoder reads 0 there)
  LQR weights Q (Q)                    arm, pendulum, arm speed, pendulum speed: the pop-up's LQR
  uses them
  LQR weight R (R)                     on the voltage
  A tap (TAP)                          a tap on the pendulum (+2 rad/s) at this time in seconds; 0 =
  none
Every run starts again from the properties.

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 TEPROTPEND.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
* NO 12 V: the bridge is driven but 12V is missing - the motor cannot turn.
* NO ENCODER SUPPLY: 5V is low - the encoders' outputs float.
* The pendulum never gets to the top: the swing-up's push is too weak, or its sign is wrong (push
  the arm against the pendulum's swing).
* It falls as soon as it is caught: a sign in the LQR - the pendulum leaning one way must turn the
  arm the same way.
* The part is not simulated: TEPROTPEND.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.

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/rotary-pendulum-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 model (TEPROTPEND.DLL), the symbols and artwork, the other parts of ours in the demo 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 models use 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 .hex file 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\Pendulum_Demo\Pendulum_Demo.ino, select Arduino Uno and use Sketch > Export Compiled
Binary. Replace the simulation's .hex with the exported HEX. The sketch needs 8,252 bytes of flash
and 483 bytes of RAM.

MODEL SCOPE AND LIMITS
Modelled: the motor's resistance, back-EMF and friction (its 0.59 mH is far faster than anything
here), the arm and the pendulum with the
full coupling, the pendulum's bearing friction, the H-bridge's duty and direction, both encoders'
edges, the supply's current.
Not modelled: the encoder cable's pull, gear backlash (the arm is direct drive), the arm's flex, the
motor's heating.

VERSION
TEP Rotary Inverted Pendulum library V1.0 (Nov 2026). Device ROTPENDTEP (TEPROTPEND.LIB /
TEPROTPEND.DLL). Demo sketch Pendulum_Demo V1.0. Demo board: ARDUINO UNO V4.0 (TEP Arduino Library
V4.0) with its built-in serial monitor.