Project Files of DC Tachogenerator Library for Proteus V1.0 (Arduino RPM Sensor)

DC TACHOGENERATOR LIBRARY FOR PROTEUS - V1.0 (a brushed tacho with a real output, its ripple 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/dc-tachogenerator-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
DC-Tachogenerator-TEP-v1.0/
|-- Proteus Library Files/
|   |-- ArduinoV4TEP.LIB                              201.9 KB   TEP Arduino boards V4.0 (UNO) -> LIBRARY
|   |-- TEPTACHO.LIB                                   16.2 KB   the library -> LIBRARY folder
|-- Proteus Model Files/
|   |-- TEPARDUINO.DLL                                883.5 KB   the Arduino board model -> MODELS folder
|   |-- TEPTACHO.DLL                                  297.0 KB   the model -> MODELS folder
|-- Proteus Simulation/
|   |-- DC-Tachogenerator-ArduinoUnoV4.pdsprj          21.5 KB   the demo project
|   |-- Tacho_Demo.hex                                 20.6 KB   the demo firmware
|   |-- TEPARDUINO.DLL                                883.5 KB   copy of the board model
|   |-- TEPTACHO.DLL                                  297.0 KB   copy of the model
|-- Arduino Code/
|   |-- Tacho_Demo/Tacho_Demo.ino                       3.7 KB   the demo sketch (source of the .hex)
|-- README.txt                                        ~16.9 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 a brushed DC tachogenerator: a small permanent-magnet DC
generator built for measuring speed, not for power. Its output voltage is
proportional to the speed of its shaft, and its sign tells the direction.
Our own model, not a voltage source with a picture:
  * The output: 7 V per 1000 RPM (property KV) behind the 60 ohm armature and
    brushes - a real source in the circuit, so a load makes it sag: 10 kohm
    takes 0.6 % at any speed, a heavy load much more.
  * The commutator: 11 segments put a small ripple on the output at 11 x the
    turns a second (1 % peak), and a hair of eccentricity adds a wobble once a
    turn - 288 mV peak to peak at 1500 RPM, 275 Hz.
  * The shaft belongs to the machine the tacho measures: its speed follows the
    set speed with the machine's inertia (a time constant of 0.4 s - 1.56 s
    to within 2 % from standstill to 1500 RPM). Set it with property RPM, the
    pop-up's speed chips (Stop, 500 - 3000 RPM, Reverse) or a click on the
    coupling on the sheet (+500 RPM).
  * What it names: the steady speed and its volts, the run-up time, the load's
    sag, the ripple, the direction, an overload (more than 10 mA - keep the
    load above 10 kohm), more than 5 V for an Arduino pin.
The symbol: the tacho seen from its shaft end - the dark mounting flange with
its four screw holes and its data, the coupling disc of the machine on the
shaft (six holes and a red marker; it turns at Run and blurs into rings at
speed, as a camera sees it), the terminal box with T+ (red stud) and T- (black
stud). The plate, the LED OUT (green while T+ is positive, red while it is
negative) and the strip under the plate (RPM, VOLTS, LOAD and OPEN PANEL) are
TEP additions; the real tacho has none of them.

ONE DEVICE (search "TACHO" in Pick Devices):
  DCTACHOTEP   "DC Tachogenerator V1.0"   (category Electromechanical >
               DC Motors), model TEPTACHO.DLL
  The pop-up panel "TEP DC Tachogenerator" opens at Run (and with OPEN PANEL on
  the strip) - the look of the TEP Serial Monitor. Tabs Tacho, Graphs, Event
  log and Check; gear and ? icons for Settings and Help; the palette icon
  switches the theme:
    Tacho      the state in big letters (1500 RPM - 10.44 V AT THE TERMINALS /
               RUNNING UP / RUNNING DOWN / BACKWARDS / STOPPED / OVERLOADED),
               a speed dial - the shaft in blue, the set speed in orange -, the
               live values (speed, set speed, terminals, EMF, load current, the
               volts lost in the armature, ripple, ripple frequency) and the
               terminal voltage over the last 20 ms, zoomed in on the ripple.
               The toolbar: the shaft's speed (Stop, 500, 1000, 1500, 2000,
               3000) and Reverse.
    Graphs     the speed and the set speed, and the output (averaged over 50
               ms) over the last 2, 6 or 15 s. Live / Freeze.
    Event log  every set speed, every steady speed with its run-up time ("STEADY
               at +1500 RPM after 1.56 s - 10.41 V at the terminals"), the
               direction, stopping, overload; filters All / Speeds / Warnings,
               Pause, Clear
    Check      Good for: a reading that is zero, negative, too low, jumpy or
               too high for the Arduino's pin - the output, the direction, the
               load, an Arduino's input, the ripple and the speed, 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 29 Oct 2026 (the demo project as shipped: an
A4 sheet, an Arduino UNO V4.0 with its built-in monitor, the tacho TG1, RV1 at
23 % as the divider into A0; the pop-up open).
What the runs showed:
  * The project loads and starts cleanly. The machine runs up to 1500 RPM
    (property RPM) in 1.56 s: 10.43 V at the terminals (EMF 10.49 V, 1.04 mA
    into RV1's 10 kohm, 0.063 V lost in the armature), ripple 288 mV peak to
    peak at 275 Hz. The sketch: "A0 2.400 V -> tacho 10.43 V -> 1490 RPM" -
    0.7 % low: the armature's sag and the divider's tolerance.
  * cal 1500: "calibrated: RV1 ratio = 0.2287"; from then on "A0 2.401 V ->
    tacho 10.50 V -> 1500 RPM".
  * 3000 RPM (the pop-up): steady after 1.29 s, 20.88 V (EMF 21.00 V, 2.09 mA,
    0.125 V lost), ripple 577 mV at 550 Hz; the sketch: "A0 4.807 V -> tacho
    21.02 V -> 3003 RPM". raw: 20 single samples swing between 970 and 990 -
    the ripple the averaging removes.
  * Reverse: -3000 RPM after 1.84 s, -20.87 V, the LED OUT red, the pop-up
    BACKWARDS; A0 reads 0 V - an Arduino pin cannot see a negative input.
  * 500 RPM: 3.48 V; Stop: 0 V, STOPPED; 1500 RPM again: 10.43 V, 1500 RPM.
  * The pop-up: Tacho, Graphs (2 / 6 / 15 s), Event log, Check - all four pages
    followed the run.
  Plus automatic checks on a PC, 0 failed: 14 on the tacho (1500 RPM into 10
  kohm: 10.425 V, a 1.56 s run-up, 0.290 V of ripple, 6.954 V per 1000 RPM at
  the terminals, 0.063 V of sag; -1000 RPM reverses the sign; Stop gives 0 V;
  500 ohm at 3000 RPM is an overload; KV 2.5 gives 5.0 V at 2000 RPM); 2 on
  the pop-up pages rendered; the demo project read back from disk (45 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" (TEPTACHO.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 TEPTACHO.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 TEPTACHO.IDX from the LIBRARY folder if it is there (Proteus makes a
   new index).
5. Start Proteus. In Pick Devices (P) search "TACHO".

RUN THE DEMO
"Proteus Simulation\DC-Tachogenerator-ArduinoUnoV4.pdsprj" (an A4 sheet) -
keep the .hex file and the two DLLs beside the project.
  ARD1: Arduino UNO V4.0 running Tacho_Demo.hex, its serial monitor built in
        (window "TEP Arduino UNO - ARD1").
  TG1:  the DC tachogenerator - T+ on the net label TACHO, T- on ground.
  RV1:  a 10k potentiometer (POT-HG) as the divider: its top on TACHO, its
        bottom on ground, its wiper (at 23 %) on A0 - 21 V at 3000 RPM gives
        4.8 V there.
  1. Press Run. The monitor and the tacho's pop-up open (move them aside -
     they open over the schematic). The machine runs up to 1500 RPM and the
     sketch prints the speed as it rises.
  2. Type cal 1500 in the monitor: the sketch calibrates RV1's ratio.
  3. On the pop-up's toolbar pick a speed (or click the coupling on the sheet):
     the run-up shows on the Graphs page and in the monitor.
  4. Type raw: twenty single samples show the commutator ripple.
  5. Reverse: the output goes negative - the Check page explains.
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)
  Tachogenerator  Arduino UNO
   T+             the divider's top (RV1, or two resistors)
   T-             GND
  Divider         its middle (RV1's wiper) to A0, its bottom to GND
Choose the divider so the top speed gives under 5 V at A0: 7 V/1000 RPM x 3000
RPM = 21 V needs about 0.23 (for example 33 kohm over 10 kohm, or RV1 at 23 %).
Keep the divider's total at 10 kohm or more: the tacho is a sensor.
In the sketch: average many samples (the demo takes 256, about 30 ms), then
  rpm = volts at A0 / ratio x 1000 / KV
REAL HARDWARE:
 * Reversed, the tacho's output is negative and so is A0: a real Arduino pin
   must never see a negative voltage. Add a clamp (a Schottky diode from A0 to
   GND and a series resistor) or an offset if the shaft can turn backwards.
 * Industrial tachos give 7 - 60 V per 1000 RPM: check the data plate (KV) and
   size the divider for the top speed.
 * The ripple grows with worn brushes; an RC filter (for example 10 kohm and 1
   uF) in front of A0 helps as much as averaging.

THE DEMO SKETCH ON THE SERIAL MONITOR (Tacho_Demo V1.0, 9600 baud)
  cal 1500      the shaft turns at 1500 RPM now: work out RV1's ratio
  ratio 0.23    set RV1's ratio by hand
  raw           20 single samples, about 0.2 ms apart: the commutator ripple
  avg 256       samples averaged per reading (1 - 1000)
  help          the list
The speed is set on the tacho's pop-up, not by the sketch: the sketch only
measures, as on a real machine.
EXPECTED MONITOR OUTPUT
  DC tachogenerator demo - The Engineering Projects
  Tacho 7 V/1000 RPM -> RV1 (x0.23) -> A0. Set the shaft's speed on the tacho's pop-up.
  Commands: cal 1500 | ratio 0.23 | raw | avg 256 | help
  A0 2.400 V -> tacho 10.43 V -> 1490 RPM

PROPERTIES (double-click the part > Edit Properties)
  RPM   the shaft's speed at the start in RPM (default 1500; minus = backwards,
        up to 6000) - the machine runs up to it at Run
  KV    the tacho's volts per 1000 RPM (default 7)
Every run starts again from the properties. The demo's UNO (ARDUINO UNO V4.0):
PROGRAM Tacho_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 TEPTACHO.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 reading is 0 (STOPPED): the shaft stands still - pick a speed on the
  pop-up or click the coupling; or T+ / T- are not connected.
* The reading is 0 but the pop-up shows a speed: the shaft turns backwards and
  A0 cannot read a negative voltage (BACKWARDS on the pop-up) - or the
  divider's middle is not on A0.
* The reading is a little low: the armature's sag under the load and the
  divider's tolerance - calibrate (cal 1500) at a known speed.
* The reading jumps: too few samples averaged (avg 256), or a heavy load.
* OVERLOADED: the load draws more than 10 mA - the divider is too small.
* The part is not simulated / the disc never turns: TEPTACHO.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 tacho model (TEPTACHO.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 small brushed
  DC tachogenerators. 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 .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 any
  tachogenerator maker, 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\Tacho_Demo\Tacho_Demo.ino, select Arduino Uno and use
Sketch > Export Compiled Binary. Replace the simulation's .hex with the exported
HEX. The sketch needs 7,474 bytes of flash (23 % of the UNO) and 276 bytes of
RAM.

MODEL SCOPE AND LIMITS
Modelled: the EMF (KV x RPM, its sign the direction), the 60 ohm armature and
brushes in the circuit, the commutator ripple (11 segments) and a once-a-turn
wobble, the machine's speed lag (0.4 s), an overload, a speed above the rated
6000 RPM.
How it runs: the terminals are the EMF behind 60 ohm, stamped as a Norton
source at every analog point; the analog step is cut to 1/20 of a ripple
period, and to 2 ms while the speed changes.
Not modelled: the tacho's own drag on the machine, brush wear, temperature
(a real tacho loses about 0.05 % per degree), the armature's inductance, AC
tachogenerators.

VERSION
TEP DC Tachogenerator library V1.0 (Oct 2026). Device DCTACHOTEP (TEPTACHO.LIB /
TEPTACHO.DLL). Demo sketch Tacho_Demo V1.0. Demo board: ARDUINO UNO V4.0 (TEP
Arduino Library V4.0) with its built-in serial monitor.