Project Files of JGB37-520 Encoder Gear Motor Library for Proteus V1.0 (12V, Hall)

JGB37-520 ENCODER GEAR MOTOR LIBRARY FOR PROTEUS - V1.0 (the JGB37-520 12 V metal gear motor with its Hall encoder)
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/jgb37-520-encoder-gear-motor-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
JGB37-520-Encoder-Gear-Motor-TEP-v1.0/
|-- Proteus Library Files/
|   |-- ArduinoV4TEP.LIB                              201.9 KB   TEP Arduino boards V4.0 (UNO) -> LIBRARY
|   |-- TEPJGB37.LIB                                   17.1 KB   the library -> LIBRARY folder
|-- Proteus Model Files/
|   |-- TEPARDUINO.DLL                                883.5 KB   the Arduino board model -> MODELS folder
|   |-- TEPJGB37.DLL                                  283.0 KB   the model -> MODELS folder
|-- Proteus Simulation/
|   |-- JGB37_Encoder_Demo.hex                         27.8 KB   the demo firmware
|   |-- JGB37-520-Encoder-Motor-L9110S-ArduinoUnoV4.pdsprj   25.0 KB   the demo project
|   |-- TEPARDUINO.DLL                                883.5 KB   copy of the board model
|   |-- TEPJGB37.DLL                                  283.0 KB   copy of the model
|-- Arduino Code/
|   |-- JGB37_Encoder_Demo/JGB37_Encoder_Demo.ino       6.3 KB   the demo sketch (source of the .hex)
|-- README.txt                                        ~18.8 KB   this file
Total: 2.57 MB (unzipped). The C++ source code of the models is not included.

WHAT IS IT?
A simulation model of the JGB37-520 metal gear motor with a magnetic (Hall)
encoder - the 37 mm gear motor of robot cars, rovers, conveyors and PID
projects: 12 V, 1:90 gearbox, about 110 RPM, a 6 mm D-shaft set off the
gearbox's centre, the encoder disc and its two Hall sensors on the motor's
rear shaft (6 wires). Our own model, not Proteus's DC motor:
  * The motor between M+ and M- is analog: the winding (5 ohm), the
    back-EMF, the gearbox's friction and losses, the inertia and a load
    torque, all seen at the output shaft - about 110 RPM / 0.15 A with no load
    at 12 V, 85 RPM at about 0.65 A (its rated point), 51 RPM at 6 V, a stall
    at about 2.4 A and 12 kg.cm. Any driver works: an L9110S, an L298N, a
    TB6612, a BTS7960, a transistor, PWM or DC.
  * The encoder is digital: 11 pulses per motor turn x 90 = 990 pulses per
    output turn on C1 and on C2, 90 deg apart - 3960 counts per turn when both
    edges of both channels are counted (x4). C1 leads C2 while it turns CW
    (M+ positive). Every edge comes at the moment the shaft reaches it (the
    model works out each edge's time from the speed), so Arduino interrupts,
    the Encoder library and PID loops see what they would see on the bench.
    The encoder needs its supply: with VCC low or open, C1 and C2 float.
  * The dial turns on the schematic to the simulated shaft angle; the C1 and
    C2 LEDs show the two channels.
  * The load: property LOAD (kg.cm), the pop-up's load buttons, or a click on
    the dial: a hand on the wheel (5 kg.cm) - the speed drops, the current
    rises; enough load and it stalls.
  * What it tells: the speed and direction, the average voltage, the current,
    PWM (frequency and duty) when the driver really switches, the encoder's
    count and pulse rate, and the warnings - STALLED, OVER-VOLTAGE (more than
    14 V), a reversal at speed, no encoder supply.
The symbol shows the motor from its shaft end at 1.5 x its size: the 37 mm
round silver gearbox face with its M3 mounting holes, the output shaft 6 mm
off the centre with a white dial on it, and the encoder's six wires to the
pins - M+ red, M- white (the motor), VCC blue, GND black (the encoder supply),
C1 yellow, C2 green (the encoder outputs; other makers use other colours). The
plate, the dial, the C1 / C2 LEDs and the strip under the plate (RPM, ANGLE,
COUNT, OPEN PANEL) are TEP additions; the real motor has none of them.

ONE DEVICE (search "JGB37" or "encoder" in Pick Devices):
  JGB37MOTORTEP   "JGB37-520 Encoder Gear Motor V1.0"   (category
                  Electromechanical > DC Motors), model TEPJGB37.DLL
  The pop-up panel "TEP JGB37-520 Encoder Gear Motor" opens at Run (and with
  OPEN PANEL on the strip) - the look of the TEP Serial Monitor. Tabs Motor,
  Graphs, Event log and Check; gear and ? icons for Settings and Help:
    Motor      the state in big letters (RUNNING CW / CCW, STOPPED, STALLED,
               OVER-VOLTAGE); the speed gauge (-150 .. +150 RPM, CW to the
               right, the 85 - 110 RPM band from rated to no load marked); the
               live values (speed, direction, the average voltage, the
               current, the drive: PWM Hz and duty, or STEADY; the power, the
               load, the encoder count in counts and turns); C1 and C2 over
               the last 5 ms (the quadrature, C1 leading = CW) with the drive
               under them. The toolbar: the load on the shaft (None, 2, 4, 6,
               10 kg.cm) and the hand.
    Graphs     the speed, the current and the average voltage over the last
               1, 3 or 6 s. Live / Freeze.
    Event log  the drive, every steady speed ("steady 56 RPM CW (919 Hz on
               C1) at 10.20 V average, 0.90 A"), every direction change,
               stops, the load, the encoder's supply, the warnings; filters
               All / Drive + speed / Warnings, Pause, Clear
    Check      Good for: a motor that does not turn, turns slowly or the wrong
               way, stalls, or an encoder that does not count - the drive, the
               PWM, the current against the common drivers, the speed with the
               encoder rate, the load, the encoder (supply, count, edges), the
               peaks
    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 - on +12V, the JGB37-520 on MOTOR A with C1 / C2 on D2 /
D3, RV1 on A0; all pop-ups open). What the runs showed:
  * The project loads and starts cleanly. RV1 at 40 %: "Pot 410 -> target 1586
    counts = 144.2 deg"; the sketch's encoder loop turned the shaft there and
    held it: 144.3 deg (count 1587).
  * "a 270": 269.9 deg (count 2969) - the dial at 270 deg.
  * "rpm 80" (the sketch measures the speed from the encoder, a PI loop):
    80.8 RPM CW at 9.0 V, 0.15 A; the Motor page shows C1 leading C2.
    "rpm -100": 100.5 RPM CCW at 11.1 V, C2 leading.
  * "pwm 100" (open loop, full drive from the L9110S at 12 V): 106.8 RPM at
    11.69 V, 0.15 A.
  * 4 kg.cm on the shaft at full drive: 55.6 RPM at 10.20 V, 0.90 A.
  * 10 kg.cm + the hand (15 kg.cm) at full drive: "STALLED - 1.71 A at 0.2
    RPM" (the L9110S's switches drop 3.4 V at 1.71 A: 8.58 V across the
    motor).
  * "knob" at full speed: the loop reverses the motor at once (a reversal
    warning with a peak above 3 A - the warning a real driver deserves),
    winds about 10 turns back and stops on the pot's angle again: "At 1584
    counts = 144.0 deg - holding".
  * The L9110S's own pop-up: VCC 12.00 V, the run's peak current in red and
    "See the warnings" - above its 0.8 A continuous / 1.5 A peak ratings (see
    REAL HARDWARE).
  * The simulation runs at about 0.25 x real time on a desktop PC (the whole
    demo run: 38 s of simulation in under 3 minutes, up to 7,000 encoder
    edges a second at 107 RPM).
  Plus automatic checks on a PC, 0 failed: 26 on the motor and the encoder
  (12 V: 110 RPM, 0.15 A, 90 % of the speed in 0.23 s; 6 V: 51 RPM; PWM 980 Hz
  found with its duty, the speed following 25 / 50 / 75 % (22 / 51 / 80
  RPM); an averaging driver gives no false PWM; a reversal at 12 V: 4.6 A peak
  and its warning; braked to a stop; 14 kg.cm stalls at 2.39 A, 3 kg.cm turns
  at 82 RPM / 0.71 A; 16 V: over-voltage; 3960 counts per turn, C1 leading CW
  / C2 leading CCW, the edges evenly spaced); 3 on the pop-up pages rendered;
  the demo project read back from disk (90 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" (TEPJGB37.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 TEPJGB37.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 TEPJGB37.IDX from the LIBRARY folder if it is there.
5. Start Proteus. In Pick Devices (P) search "JGB37".

RUN THE DEMO
"Proteus Simulation\JGB37-520-Encoder-Motor-L9110S-ArduinoUnoV4.pdsprj" - keep
the .hex file and the DLLs beside the project.
  ARD1: Arduino UNO V4.0 running JGB37_Encoder_Demo.hex, its serial monitor
        built in (window "TEP Arduino UNO - ARD1").
  DRV1: the L9110S driver (pop-up version): A-IA on D5, A-IB on D6, VCC on a
        +12V power terminal (Proteus's 12 V rail), GND - by net labels; motor
        B unused.
  M1:   the JGB37-520 on MOTOR A (A-OA to M+, A-OB to M-); its encoder: VCC
        on 5V, GND, C1 on D2, C2 on D3 (by labels).
  RV1:  a 10k potentiometer on A0: the target angle (0 - 360 deg).
  1. Press Run. The monitor and the two pop-ups open (move them aside). The
     shaft turns to the pot's angle and holds it.
  2. Click RV1's arrows: the dial follows.
  3. Type in the monitor and press Enter (or Send): a 90, s 3960, rpm 80,
     rpm -100, pwm 50, stop, zero, knob.
  4. Click the dial: a hand on the wheel - in "rpm" mode the loop pushes
     harder to keep the speed. Add a load on the pop-up (10 kg.cm + the hand
     at full drive: it stalls).
  5. The motor's pop-up: Motor (the C1 / C2 chart), Graphs, Event log, Check.

WIRING (the same in Proteus and on a real board)
  L9110S          Arduino UNO / supply
   A-IA           D5 (PWM)
   A-IB           D6 (PWM)
   VCC            12 V supply (the L9110S takes 2.5 - 12 V; its inputs stay
                  5 V logic)
   GND            GND (common with the Arduino)
  JGB37-520       L9110S MOTOR A: M+ (red) to A-OA, M- (white) to A-OB
  encoder         VCC (blue) 5V, GND (black) GND, C1 (yellow) D2, C2 (green) D3
                  (D2 and D3 are the UNO's interrupt pins)
In the sketch (no library needed):
  attachInterrupt(digitalPinToInterrupt(2), encISR, CHANGE);   // C1
  attachInterrupt(digitalPinToInterrupt(3), encISR, CHANGE);   // C2
  // encISR: read C1 and C2, add -1 / 0 / +1 from the old and the new state
  // (the demo sketch's STEP table): 3960 counts per output turn
  forward:  analogWrite(IB, 0);  analogWrite(IA, speed);      // 0 - 255
  reverse:  analogWrite(IA, 0);  analogWrite(IB, speed);
REAL HARDWARE:
 * The L9110S suits the JGB37-520's rated load (about 0.65 A) and the demo.
   A JGB37-520 stalls at about 2.4 A at 12 V and a reversal at full speed
   peaks near 4.6 A - far above an L9110S's 0.8 A (1.5 A peak). For a robot
   that pushes, climbs or stalls use a BTS7960 (or an L298N for loads up to
   about 2 A). Our libraries have them.
 * Feed the driver from a 12 V supply or a 3S Li-ion pack (11.1 - 12.6 V),
   GND common with the Arduino.
 * The encoder's VCC is 3.3 - 5 V; many boards need no pull-ups, some do (10k
   to VCC on C1 / C2).
 * Swap M+ / M- and both the direction and the count's sign change - swap C1 /
   C2 in the sketch (or the wires) if the count runs the wrong way.
 * JGB37-520s come with many gearboxes and 6 V / 12 V / 24 V windings - this
   one is the 12 V 1:90 (11 PPR encoder, 3960 counts per turn).

THE DEMO SKETCH ON THE SERIAL MONITOR (JGB37_Encoder_Demo V1.0, 9600 baud)
  a 90      go to 90 deg (and stay - the pot is ignored until "knob")
  s 3960    3960 counts from here (one turn; - = the other way)
  rpm 80    hold 80 RPM (- = CCW, up to 105) with the encoder as the speed
            sensor (a PI loop with anti-windup)
  pwm 50    open loop: 50 % forward (- = reverse)
  stop      both inputs LOW (the motor brakes)      zero   the count = 0 here
  knob      follow the pot again                     help   the list
EXPECTED MONITOR OUTPUT
  JGB37-520 Encoder Gear Motor demo - The Engineering Projects
  L9110S A-IA D5, A-IB D6; encoder C1 D2, C2 D3 (x4: 3960 counts per turn). The shaft follows the pot on A0.
  Commands: a 90 | s 3960 | rpm 80 | pwm 50 | stop | zero | knob | help
  Pot 410 -> target 1586 counts = 144.2 deg
  At 1587 counts = 144.3 deg - holding   (a count or two either side: the loop's deadband is 2 counts)

PROPERTIES (double-click the part > Edit Properties)
  LOAD     a constant load on the shaft in kg.cm (default 0; it stalls at
           about 12 kg.cm at 12 V - about 8 kg.cm through an L9110S)
Every run starts again from the properties.

TROUBLESHOOTING
* The shaft never turns and the pop-up says NO DRIVE: the driver's inputs
  (both LOW = stop), its VCC, or the motor wires on the wrong outputs.
* The count stays 0 while it turns: the encoder's VCC / GND, or C1 / C2 on pins
  the sketch does not read (D2 / D3 for the UNO's interrupts). The Check page
  shows "no supply" when VCC is not HIGH.
* The count runs backwards: swap C1 and C2 (or M+ and M-).
* It oscillates around the target: lower the P gain or raise the D gain in the
  sketch (3.0 and 24.0 in the demo).
* Slow (about half speed): the driver's VCC is 5 V, not 12 V.
* STALLED: less load, or more drive.
* The part is not simulated / the dial never turns: TEPJGB37.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 motor model (TEPJGB37.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
  the 12 V 1:90 JGB37-520 gear motor with a Hall encoder. 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\JGB37_Encoder_Demo\JGB37_Encoder_Demo.ino, select
Arduino Uno and use Sketch > Export Compiled Binary. The sketch needs 10,110
bytes of flash (31 % of the UNO) and 323 bytes of RAM.

MODEL SCOPE AND LIMITS
Modelled: the winding resistance, the back-EMF, the gearbox's friction (Coulomb
and viscous) and losses, the inertia, a load torque, the current both ways
(driving and braking), any voltage either way; the encoder's 3960 quadrature
counts per turn at the shaft's real angle, its supply.
How it runs: the speed is an internal analog node solved together with the
driver (backward Euler, analog steps of 2 ms or less); the angle is the speed
integrated; a digital callback sets C1 / C2 at each count edge, timed from the
last analog point and the speed.
Not modelled: the winding inductance, the gear backlash (the encoder sits on
the motor shaft: it counts the backlash on a real one), the encoder's duty and
phase errors, heating, the differences between real motors.

VERSION
TEP JGB37-520 Encoder Gear Motor library V1.0 (Oct 2026). Device JGB37MOTORTEP
(TEPJGB37.LIB / TEPJGB37.DLL). Demo sketch JGB37_Encoder_Demo V1.0. Demo
driver: L9110SADVTEP (TEP L9110S Motor Driver library V1.0). Demo board:
ARDUINO UNO V4.0 (TEP Arduino Library V4.0) with its built-in serial monitor.