TT Gear Motor Library for Proteus V1.0 (Yellow DC Motor, Robot Car)

Hello friends, I hope you all are doing great. Today, I am going to share the new TT Gear Motor Library for Proteus V1.0. If you have ever built a robot car from a kit, you know this motor: the yellow plastic gearbox with a small silver motor at its back and a shaft sticking out of both sides for a fat 65 mm wheel. It is cheap, it is everywhere, and it is the first motor most students ever drive from an Arduino. Until now it only came along with our L9110S driver library; from today it is a library of its own, with a wheel that turns on your schematic and a pop-up window that shows what the motor gets and what it does.

The model is a real motor inside your circuit, not an animation. It sits between its + and - pins as an analog part, with the resistance of its winding, the back-EMF that grows with the speed, the friction of the gears, the inertia of the wheel and any load you put on it. So it works with any driver - an L9110S, an L293D, an L298N, a transistor or a relay - it slows down under load, and it stalls when the load is too much. The demo runs on our Arduino UNO V4.0 with our L9110S driver and a potentiometer as the speed and direction knob.

NOTICE: a motor in a simulator is only useful if it behaves like a motor. So we did not draw a spinning icon, we built the physics: the wheel speeds up, slows down under load, coasts, brakes and stalls like the real one, and it takes its current from your circuit. It took our team a lot of hard work. 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 TT Gear Motor Library for Proteus V1.0:

What is the TT Gear Motor?

The TT gear motor is a small brushed DC motor - the common "130" size - bolted to a plastic gearbox with a ratio of 1:48. The motor alone spins at thousands of RPM with almost no torque; the gearbox trades that speed for force, so the output shaft turns at a few hundred RPM, slow and strong enough to push a small car. The name comes from the shape of the gearbox, and the yellow colour is the one almost every seller uses. Its double shaft takes a wheel on one side and an encoder disc or a second wheel on the other.

Like every brushed DC motor it has just two wires. Put a voltage across them and it turns; swap the wires and it turns the other way; lower the average voltage with PWM and it turns slower. There is no position feedback and no speed control inside - the motor simply finds the speed where the voltage, its back-EMF and the load balance.

Why a Motor Needs a Driver

An Arduino pin gives about 20 mA; a TT motor wants 150 mA running free and more than a whole ampere when it starts or stalls. The pin cannot give that, and it cannot reverse the motor either. A motor driver does both: its H-bridge switches the motor supply across the two wires in either direction, and the Arduino only tells it which way and how fast. In our demo the driver is the L9110S from our L9110S Motor Driver Library for Proteus - a separate library that you install first, because this library ships only the motor.

What's New in TT Gear Motor Library for Proteus V1.0

• A part of its own: the TT motor no longer comes only with one driver; wire it to any driver you like.
• An analog motor model: the winding, the back-EMF, the gear friction, the inertia and a load, all seen at the wheel - it takes real current from your circuit in both directions.
• The data of the real motor: about 250 RPM and 0.15 A with no load at 6 V, 120 RPM at 3 V, a stall at about 1.5 A and 0.8 kg.cm.
• A wheel that turns on the schematic at the simulated speed, with a motion blur when it is fast and CW / CCW LEDs.
• Loads and stalls: a LOAD property, load buttons on the pop-up and a finger on the tyre when you click the wheel.
• A pop-up window with four pages - Motor, Graphs, Event log and Check - in the look of our serial monitor.
• Warnings: STALLED, OVER-VOLTAGE above 7.5 V and a reversal at speed with its current spike.
• A demo on our Arduino UNO V4.0 with our L9110S driver, a potentiometer and serial monitor commands.

The TT Gear Motor in Proteus

Search TT in Pick Devices; the device TTGEARMOTORTEP is in TEPTTGEAR.LIB (category Electromechanical, DC Motors) and its model is TEPTTGEAR.DLL. It is drawn the way you see the motor inside a robot car: the yellow gearbox in front, the silver motor can at its back with the red and black wires going to the + and - pins, and behind it the wheel - a black tyre on a yellow hub with six round holes.

While the simulation runs the wheel turns at the simulated speed, and the white shaft stub on the gearbox turns with it. The red dot on the hub shows the real rotation; when the wheel is fast it gets a motion blur, so it never seems to turn backwards on your screen the way a filmed wheel does. Two LEDs sit on the plate: CW (green) lights when + is above -, CCW (amber) the other way. Under the plate is the strip with the speed and its direction, for example "180 RPM CW", the average voltage across the motor, its current and the OPEN PANEL button. The plate, the LEDs and the strip are TEP additions; a real motor has none of them.

The Pins and the Properties

A Click on the Wheel: a Finger on the Tyre

Click the wheel while the simulation runs and you put a finger on the tyre: 0.2 kg.cm of friction. The wheel slows down and the current rises, exactly what your sketch and your battery meet when a real car climbs a ramp or rubs against a wall. Click again to lift the finger. The pop-up's toolbar adds bigger loads - 0.1 to 0.6 kg.cm - and together with the finger they can stall the motor.

Download TT Gear Motor Library for Proteus

The download link of TT-Gear-Motor-Library-for-Proteus-v1.0.zip (without the source code) will be added here soon. The zip file will contain:

• README.txt: installation, the demo, the wiring, the properties, real hardware, troubleshooting and the limits.
• Proteus Library Files: TEPTTGEAR.LIB and ArduinoV4TEP.LIB from our Arduino Library for Proteus V4.0.
• Proteus Model Files: TEPTTGEAR.DLL and TEPARDUINO.DLL.
• Proteus Simulation: TT-Gear-Motor-L9110S-ArduinoUnoV4.pdsprj and TT_Motor_Demo.hex.
• Arduino Code: TT_Motor_Demo.ino (no library needed).

Important: the demo's driver is not in this zip. Download our L9110S Motor Driver Library for Proteus and install it first; this package carries only the TT motor and the Arduino UNO V4.0 the demo runs on.

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 TT Gear Motor Library for Proteus

1. Close Proteus and extract the whole zip file, for example to your Desktop.
2. Copy TEPTTGEAR.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 TEPTTGEAR.DLL and TEPARDUINO.DLL from Proteus Model Files into the MODELS folder.
4. For the demo, install our L9110S library the same way: TEPL9110S.LIB into LIBRARY and TEPL9110S.DLL into MODELS.
5. Delete TEPTTGEAR.IDX from the LIBRARY folder if it is there.
6. Start Proteus, press P and search for TT.

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

The Demo Circuit

Open TT-Gear-Motor-L9110S-ArduinoUnoV4.pdsprj. The sheet is A3 - the UNO, the driver and the motor side by side do not fit an A4 sheet legibly. ARD1 is an Arduino UNO V4.0 from our Arduino UNO Library for Proteus V4.0, running TT_Motor_Demo.hex with its serial monitor built in. DRV1 is the L9110S in its pop-up version, M1 is the TT motor on the driver's MOTOR A terminal and RV1 is a 10k potentiometer on A0. Motor B of the driver is not used.

In Proteus the four header pins of the driver climb to net labels - D5, D6, 5V and GND - and the same names sit on the UNO's pins, so the same name is the same wire. The motor is wired straight to the terminal, so you can follow both wires from the chip to the motor. The monitor needs no wires at all, because it is built into the UNO V4.0.

The Arduino Code

The demo needs no library: analogWrite() and digitalWrite() are all an L9110S needs. New to Arduino? Start with Arduino Tutorial for Beginners and Introduction to Arduino UNO; our older DC Motor Speed Control using Arduino tutorial shows the same idea with a transistor. The sketch keeps the truth table of the driver in one comment:

// L9110S: IA HIGH + IB LOW = forward, IA LOW + IB HIGH = reverse, both LOW = stop; PWM on the HIGH input sets the speed.

const int IA = 5, IB = 6, POT = A0;

One function turns a signed speed from -255 to 255 into the two inputs. A positive speed puts PWM on IA with IB at 0, a negative one puts PWM on IB with IA at 0, and zero sets both LOW, which brakes the motor:

void drive(int s) {
  s = constrain(s, -255, 255);
  if (s > 0) { analogWrite(IB, 0); analogWrite(IA, s); }
  else if (s < 0) { analogWrite(IA, 0); analogWrite(IB, -s); }
  else { digitalWrite(IA, LOW); digitalWrite(IB, LOW); }
  speedNow = s;
}

Note the order: the input that must be off is written first, so the driver never sees both inputs active at once. In setup() both pins become outputs and the motor starts stopped:

void setup() {
  pinMode(IA, OUTPUT); pinMode(IB, OUTPUT);
  drive(0);
  Serial.begin(9600);

The pot is a speed and direction knob in one. Its reading from 0 to 1023 is mapped onto -255 to 255, and a small dead zone round the middle makes sure the motor really stops there instead of humming at a few percent:

    int raw = analogRead(POT);
    if (abs(raw - lastKnob) >= 8) {
      lastKnob = raw;
      int s = map(raw, 0, 1023, -255, 255);
      if (abs(s) < 20) s = 0;                       // a dead zone round the middle
      drive(s);

The commands f and r take a percentage and turn it into a PWM value:

  if ((s[0] == 'f' || s[0] == 'r') && (s[1] == ' ' || (s[1] >= '0' && s[1] <= '9'))) {
    int pct = constrain(atoi(s + 1), 0, 100);
    mode = FIXED;
    drive((s[0] == 'f' ? 1 : -1) * (int)(pct * 255L / 100));

The ramp runs the motor from 0 to 100 % and back, first forward and then in reverse, in 50 steps of 40 ms each way - without delay(), so the monitor keeps working while it runs:

  } else if (mode == RAMP && millis() - rampAt >= 40) {   // 50 steps of 40 ms = 2 s each way
    rampAt = millis();
    int phase = rampStep / 50, k = rampStep % 50;
    int pct = phase % 2 == 0 ? k * 2 : 100 - k * 2;
    drive((phase < 2 ? 1 : -1) * (int)(pct * 255L / 100));

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,646 bytes of flash (17 % of the UNO) and 258 bytes of RAM.

Running the Demo

Press Run. The UNO's serial monitor, the motor's pop-up and the L9110S's pop-up open over the schematic; move them aside. RV1 starts at 75 %, a little right of the middle, so the motor runs forward at about half speed:

TT Gear Motor demo - The Engineering Projects
L9110S: A-IA on D5, A-IB on D6. Turn the pot on A0: the middle stops, right = forward, left = reverse.
Commands: f 50 | r 30 | stop | ramp | knob | help
Pot 768 -> forward 49 % (PWM 127/255)

The wheel spins up and settles at 84 RPM CW with 2.33 V on average across the motor and about 0.15 A. The green CW LED on the motor and the motor-A LED on the driver are lit. Click the arrows of RV1 and the speed follows; go left of the middle and the wheel stops, then turns the other way.

Type a command in the monitor and press Send. The pot is ignored until you type knob:

r 60
reverse -> reverse 60 % (PWM 153/255)
f 100
forward -> forward 100 % (PWM 255/255)

With r 60 the motor reverses and settles at about 100 RPM CCW with about -2.7 V across it; the amber CCW LED takes over. With f 100 it runs at full drive: 189 RPM CW at 4.69 V and 0.15 A, which is 0.64 m/s at the rim of the 65 mm wheel. The motor gets a little less than the UNO's 5 V because the L9110S drops some of it, as the real chip does.

The ramp is the best way to see the motor as a system. Watch the wheel: it starts late, because the gears' friction must be beaten before anything moves, then the speed follows the voltage almost in a straight line:

ramp
Ramp: forward 0 -> 100 -> 0 %, reverse the same
ramp forward -> stop (IA LOW, IB LOW)
ramp forward -> forward 100 % (PWM 255/255)
ramp reverse -> stop (IA LOW, IB LOW)
knob
Following the pot on A0
Pot 771 -> forward 50 % (PWM 129/255)

The Pop-Up Window

At Run the motor opens TEP TT Gear Motor, a window in the look of our TEP Serial Monitor Advance for Proteus. It has four tabs - Motor, Graphs, Event log and Check - plus Settings and Help behind the gear and question mark icons, and the palette icon that switches the theme. If you close it, the OPEN PANEL button on the strip brings it back.

Motor

The banner says what the motor is doing in big letters: RUNNING CW or CCW, STOPPED, COASTING or BRAKING, STALLED or OVER-VOLTAGE. The gauge runs from 300 RPM CCW on the left to 300 RPM CW on the right, with the 250 - 300 RPM band of a free TT motor in orange. The live values are the speed, the direction, the average voltage, the current, the drive, the power, the load and the speed at the rim of the wheel in metres per second. At the bottom, The drive across + / - draws the last 5 ms of the voltage the motor sees, with its average.

The drive tile and the waveform deserve a word. When a driver really switches, the motor sees the PWM and the pop-up shows its frequency, its duty and the square wave. Our L9110S model is faster than that: it averages its PWM over each analog step of the simulation, which keeps the speed exact and the simulation quick. So the motor sees a steady average voltage and reports STEADY. The PWM itself is shown where it belongs, on the driver's own pop-up:

Graphs

Graphs draws the speed, the current and the average voltage over the last 1, 3 or 6 seconds, as 50 ms averages. During the ramp the three curves cross zero together: as the voltage falls, the speed follows it down, stops, and comes back in the other direction. The current tells the story of the load - it stays small while the motor runs free and would jump at a stall or a sudden reversal. Freeze holds the page for a closer look.

A Stall

Type f 100, pick 0.6 kg.cm on the toolbar and click the wheel for the finger. Together that is 0.8 kg.cm, the stall torque of a TT motor, and the wheel stops. The banner turns red: "STALLED - 0.87 A at 2 RPM: the load is too much". Notice the voltage: only 3.17 V is left across the motor, because the L9110S cannot hold its output up at that current. A real stalled TT motor at 6 V would try to draw about 1.5 A - more than an L9110S channel is made for.

Check

The Check page puts every condition in a row with a verdict: green for fine, amber for check, red for wrong. The current row compares the motor with the common drivers - an L9110S gives 0.8 A, an L293D 0.6 A and an L298N 2 A continuously - so you see at once whether your driver is big enough. Under the rows are the wiring of the L9110S and the tips: swap the wires to swap the direction, click the wheel for a finger on the tyre.

Event Log

The Event log keeps the story of the run, newest first: every change of the drive, every steady speed with its voltage and current - for example "steady 189 RPM CW (0.64 m/s) at 4.69 V average, 0.15 A" - every direction change, the loads and the warnings. Filter it by drive and speed or by warnings, pause it or clear it.

How the Model Works

The motor is an analog part, solved by Proteus together with the driver. Inside it there is an extra node that holds the speed. At every analog step - 2 ms or less - the model works out the current from the voltage across its pins, the winding resistance and the back-EMF of the present speed, then the torque from that current, and then the new speed from the torque, the friction, the inertia and the load. The angle of the wheel is the speed added up over time. Because the current is part of the circuit, a weak supply sags, a driver drops its voltage and a reversal really sends a spike through the driver.

We checked the model on a PC with 20 automatic tests: at 6 V it runs at 248 RPM and draws 0.155 A, reaching 90 % of its speed in 0.108 s; at 3 V it runs at 113 RPM; 0.4 kg.cm slows it to 140 RPM and 1.0 kg.cm stalls it at 1.64 A; a reversal at full speed at 5 V gives a 2.57 A peak and its warning; and 9 V raises the over-voltage warning. Real TT motors differ by 10 - 20 % from one to the next, so the two wheels of a real car never turn at exactly the same speed; the model is the typical motor.

Troubleshooting

• The wheel never turns and the pop-up says NO DRIVE: check the driver's inputs (both LOW = stop), its VCC, and that the motor wires sit on the driver's outputs.
• It turns the wrong way: swap the motor's two wires, or swap IA and IB in the sketch.
• It turns slowly and the current is high: a load, or the driver's voltage drop - the Check page compares the current with the common drivers.
• STALLED: less load, or more drive.
• No wheel, no driver or no monitor: TEPTTGEAR.DLL is missing from MODELS, our L9110S library (TEPL9110S.LIB / .DLL) is not installed, or TEPARDUINO.DLL is missing; a closed monitor opens again with a click on the UNO's USB port.
• The pop-up does not appear: click OPEN PANEL on the strip, or turn "Open the panel at Run" back on in its Settings.

Things to Know Before Using a Real TT Motor

• Power: a TT motor starts and stalls at up to about 1.5 A at 6 V. Feed the driver's VCC from a battery - 4 x AA, or two 18650 cells through a regulator - with GND common to the Arduino, never from the Arduino's 5V pin.
• The driver: an L9110S is fine for a light car; for a heavier robot use a driver with more current, like the one in our TB6612FNG Motor Driver Library for Proteus.
• Reversing: stop or brake before you reverse at speed; the current spikes to about twice the stall current.
• No two are the same: real TT motors differ by 10 - 20 %, so a car that should drive straight needs a little trim in the sketch, or encoders.
• Noise: a 100 nF ceramic capacitor across the motor's terminals keeps the brushes' noise away from the Arduino.

Limitations of the Simulation

• Not modelled: the winding inductance (the current follows the voltage within each step), the brushes' noise, heating, gear backlash and the differences between real motors.
• With the TEP L9110S the motor sees the PWM as its average, so the motor reports STEADY; the driver's pop-up shows the PWM.
• The plate, the LEDs, the strip and the finger are TEP additions.
• The model is our own, written from the typical data of the TT gear motor; this library is not made or endorsed by Arduino or Labcenter.
• Licences: the demo HEX contains the Arduino AVR core 1.8.6 (LGPL); the sketch is included and the README gives the source link. The potentiometer is Proteus's own POT-HG.
• Tested in Proteus 8.5 in October 2026 with the demo as shipped: the knob, f, r, stop, ramp, the loads, the finger, the stall and all four pages of the pop-up. Proteus 7 is not supported.

So, that was all about the TT Gear Motor Library for Proteus V1.0. I hope it helps you try your robot car's code - the speeds, the turns and the current it costs - before the first wheel touches the floor. If you have any questions, ask in the comments and I will help you out. Till the next tutorial, take care and have fun!