MG90S Servo Motor Library for Proteus V1.0 (Metal Gear, Arduino)

Hello friends, I hope you all are doing great. Today, I am going to share the new MG90S Servo Motor Library for Proteus V1.0. The MG90S is the servo people buy when the little SG90 is no longer enough. It has the same size, the same mounting ears and the same three wires, so it drops into the same place - but inside it has a metal gear train and a stronger motor. It is the usual choice for small robot arms, pan-tilt heads, RC planes and any joint that may get knocked.

This library brings the MG90S into Proteus as a part of its own. Its horn turns on your schematic at the real speed, it reads the pulses of the Arduino Servo library, it draws its current from the supply in your circuit, and its torque follows that supply: 1.8 kg.cm at 4.8 V, 2.2 kg.cm at 6 V. Load it beyond that and it stalls; load it a little less and it holds a few degrees short, exactly as a real analog servo does. The demo runs on our Arduino UNO V4.0 with Servo.h and a potentiometer as the knob.

NOTICE: two servos that look alike on paper behave differently on the bench, and the difference is in the gears, the motor and the current. We modelled each of them, so the MG90S in your simulation is not an SG90 painted black. 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 MG90S Servo Motor Library for Proteus V1.0:

What is the MG90S Servo Motor?

A hobby servo is a small motor that goes to an angle and stays there. Inside its case are a DC motor, a train of gears that slows it down and multiplies its torque, a potentiometer on the output shaft that measures the angle, and a small control board that compares the angle it measures with the angle it is asked for. If the two differ, the board drives the motor until they agree. One signal wire carries the request: a pulse every 20 ms whose width sets the angle.

The MG90S is a micro servo with metal gears. It weighs 13.4 g, a few grams more than the 9 g SG90, because of the metal in its gearbox. It runs from 4.8 to 6 V and turns about 180 degrees. Its three wires are brown for GND, red for the supply and orange for the signal. On the data sheet it gives 1.8 kg.cm and turns 60 degrees in 0.1 s at 4.8 V; at 6 V it gives 2.2 kg.cm and needs only 0.08 s.

MG90S or SG90?

On paper the two servos are close: the same body, the same pulses, the same 1.8 kg.cm at 4.8 V. The difference is in what they survive. The SG90's plastic gears strip when a horn is forced or a robot arm hits something; the MG90S's metal gears do not. The metal train costs a little efficiency and adds a little inertia, so in our model the MG90S has a stronger motor (6.9 ohm instead of the SG90's 7.4 ohm) to keep the same speed, and draws about 0.7 A when it stalls instead of 0.65 A. If you start with our SG90 Servo Motor Library for Proteus, the MG90S is the next step; for real torque there is our MG996R Servo Motor Library for Proteus.

How a Servo Reads Its Pulses

The servo measures the width of each pulse, not its frequency. A short pulse means one end of the range, a long pulse the other end. Data sheets often say 1 to 2 ms, but most micro servos use a wider span, and the Arduino Servo library uses 544 us for 0 degrees and 2400 us for 180 degrees. Our model uses the same numbers by default, so write(90) puts the horn at 90 degrees; the properties PULSE_MIN and PULSE_MAX change them for other libraries.

Two details make an analog servo behave the way it does. After each pulse its board drives the motor for about 22 ms only, so a servo that gets no more pulses is no longer driven and holds by the friction of its gears. And its loop has a small dead band: within about 0.45 degrees of the target - the data sheet's 5 us - it does nothing. Both are in the model.

What's New in MG90S Servo Motor Library for Proteus V1.0

• A part of its own: the MG90S with its black body, its METAL GEAR label and the brass bushing round the shaft.
• A horn that turns: the white horn on the schematic turns to the simulated angle; an orange marker on the 0 - 180 degree scale shows the angle the pulses ask for.
• Real timing: the pulse decoder, the position loop with its dead band, the motor and the metal gearbox - 60 degrees in about 0.13 s at 4.8 V with the start and the slow-down.
• Torque from the supply: 1.8 kg.cm at 4.8 V, about 1.9 kg.cm at 5 V and 2.2 kg.cm at 6 V.
• Real current: drawn from V+ in your circuit, so a probe or an ammeter shows the peaks.
• Loads, stalls and droop: a LOAD property, load buttons on the pop-up and a brake when you click the horn; the pop-up tells a stall from a horn held short under a load it can carry.
• A pop-up window with four pages - Servo, Graphs, Event log and Check - in the look of our serial monitor.
• A full release: the zip with the library, our Arduino UNO V4.0 and an A4 demo, tested in Proteus.

The MG90S in Proteus

Search MG90S in Pick Devices; the device MG90SSERVOTEP is in TEPMG90S.LIB (category Electromechanical, Servo Motors) and its model is TEPMG90S.DLL. It is drawn as the real servo seen from the top: the black body with its two mounting ears and its labels, the round boss of the output shaft with the brass bushing that gives a metal gear servo away, and the white single-arm horn. The brown, red and orange cable runs to the plug at the top right, where the pins GND, V+ and SIG come out.

Around the servo is a light TEP plate with a 0 - 180 degree scale. The horn points at the angle the model has computed, and the small orange triangle on the scale points at the angle the pulses ask for - while the horn is on its way you see both. PWR (red) lights when V+ is high enough and SIG (amber) while pulses arrive. Under the plate the strip shows the angle, the last pulse width and the current, with the OPEN PANEL button. The plate, the scale, the LEDs and the strip are TEP additions; a real servo has none of them.

The Pins and the Properties

Download MG90S Servo Motor Library for Proteus

Click the button below to download MG90S-Servo-Motor-Library-for-Proteus-v1.0.zip (about 1.2 MB, without the source code of the models):

MG90S Servo Motor Library for Proteus V1.0

• README.txt: installation, the demo, the wiring, the properties, real hardware, troubleshooting and the limits.
• Proteus Library Files: TEPMG90S.LIB and ArduinoV4TEP.LIB from our Arduino Library for Proteus V4.0.
• Proteus Model Files: TEPMG90S.DLL and TEPARDUINO.DLL.
• Proteus Simulation: MG90S-Servo-Motor-ArduinoUnoV4.pdsprj, MG90S_Servo_Demo.hex and copies of the two DLLs.
• Arduino Code: MG90S_Servo_Demo.ino (the Servo library comes with the Arduino IDE).

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 MG90S Servo Motor Library for Proteus

1. Close Proteus and extract the whole zip file, for example to your Desktop.
2. Copy TEPMG90S.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 TEPMG90S.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. Delete TEPMG90S.IDX from the LIBRARY folder if it is there.
5. Start Proteus, press P and search for MG90S.

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 MG90S-Servo-Motor-ArduinoUnoV4.pdsprj. The A4 sheet holds three parts. ARD1 is an Arduino UNO V4.0 from our Arduino UNO Library for Proteus V4.0, running MG90S_Servo_Demo.hex with its serial monitor built in. SERVO1 is the MG90S. RV1 is a 10k potentiometer on A0 that works as the knob.

In Proteus the SIG pin of the servo and D9 of the UNO meet through a net label called SIG, V+ is on the +5V power terminal and GND on a ground terminal. The serial monitor needs no wires at all: it is built into the UNO V4.0.

The Arduino Code

The demo uses the Servo library that comes with the Arduino IDE. New to Arduino? Start with Arduino Tutorial for Beginners and Introduction to Arduino UNO. The sketch begins with the library, the two pins and one Servo object:

#include <Servo.h>

const int SERVO_PIN = 9;
const int POT_PIN = A0;

Servo servo;

attach() starts the pulses on D9. From then on the library sends a pulse every 20 ms by itself, in the background, whatever the sketch does:

void setup() {
  Serial.begin(9600);
  servo.attach(SERVO_PIN);
  Serial.println(F("MG90S Servo Motor demo - The Engineering Projects"));
  Serial.println(F("Turn the pot on A0, or type an angle."));
  help();
}

The knob is the Arduino's Knob example: read the pot, map 0 - 1023 to 0 - 180 degrees and write the angle. The sketch only writes when the angle has changed by two degrees, so the monitor stays readable:

  if (mode == KNOB) {
    int raw = analogRead(POT_PIN);
    int angle = map(raw, 0, 1023, 0, 180);
    if (lastAngle < 0 || abs(angle - lastAngle) >= 2) {
      servo.write(angle);
      lastAngle = angle;

For each angle it prints the pulse width the library sends. write() maps 0 - 180 degrees onto 544 - 2400 us, and the sketch does the same sum for the monitor:

void report(int angle) {
  Serial.print(F("Angle "));
  Serial.print(angle);
  Serial.print(F(" deg -> pulse "));
  Serial.print(map(angle, 0, 180, 544, 2400));
  Serial.println(F(" us"));
}

writeMicroseconds() is clamped to the limits given to attach(), 544 - 2400 us by default. To try a pulse outside them, the sketch attaches again with wider limits:

bool wide = false;
void ensureAttached(bool wideLimits = false) {
  if (servo.attached() && wide == wideLimits) return;
  if (servo.attached()) servo.detach();
  if (wideLimits) servo.attach(SERVO_PIN, 400, 2900);
  else servo.attach(SERVO_PIN);

  if (!strncmp(s, "us", 2)) {
    int w = atoi(s + 2);
    if (w < 400 || w > 2900) { Serial.println(F("Pulse width: 400 - 2900 us")); return; }
    ensureAttached(w < 544 || w > 2400); mode = FIXED;
    servo.writeMicroseconds(w);

The sweep is the Arduino's Sweep example: one degree every 15 ms, from 0 to 180 and back, without delay() so the monitor keeps working:

  } else if (mode == SWEEP && millis() - sweepAt >= 15) {
    sweepAt = millis();
    servo.write(sweepAngle);

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 6,648 bytes of flash (20 % of the UNO) and 306 bytes of RAM.

Running the Demo

Press Run. The UNO's serial monitor and the servo's pop-up open over the schematic; move them aside. RV1 starts at 75 %, so the first reading asks for 135 degrees:

MG90S Servo Motor demo - The Engineering Projects
Turn the pot on A0, or type an angle.
Commands: 0-180 = angle, us 1500 = pulse width, sweep, knob, detach, help
Pot 768 -> Angle 135 deg -> pulse 1936 us

The horn swings from its start at 90 degrees: the Event log says "reached 134.7 deg from 92.7 in 112 ms (377 deg/s)". Then it settles at 135.0 degrees and holds, and the strip says 6 mA: a servo at rest only feeds its control board.

Now type 30 in the monitor and press Enter or Send. The pot is ignored until you type knob. The sketch sends 853 us and the log reads "reached 30.2 deg from 134.9 in 214 ms (489 deg/s)". After knob it goes back: "reached 134.7 deg from 30.1 in 215 ms (488 deg/s)". 105 degrees in about 0.21 s is the data sheet's 0.1 s per 60 degrees at full speed, plus the start and the slow-down at the end that every position loop has.

Type sweep and the sketch runs the Sweep example, printing a line every 30 degrees. When it is done it goes back to the pot by itself:

Angle 120 deg -> pulse 1781 us
Angle 150 deg -> pulse 2090 us
Angle 180 deg -> pulse 2400 us
Angle 150 deg -> pulse 2090 us
Angle 120 deg -> pulse 1781 us
Angle 90 deg -> pulse 1472 us
Angle 60 deg -> pulse 1162 us
Angle 30 deg -> pulse 853 us
Angle 0 deg -> pulse 544 us
Sweep done - following the pot
Pot 768 -> Angle 135 deg -> pulse 1936 us
knob
Following the pot on A0
Pot 768 -> Angle 135 deg -> pulse 1936 us

The Pop-Up Window

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

Servo

The banner says what the servo is doing: HOLDING, MOVING, HOLDING AGAINST A LOAD, NO PULSES, STALLED or NO POWER. The dial shows the horn in white and the target in orange. The live values are the target, the angle, the pulse width, the pulse rate, the speed, the current, the supply and the load. At the bottom, the signal on SIG: one 20 ms frame and the last pulse against the 0, 90 and 180 degree marks. The toolbar puts a load on the horn - None, 0.5, 1.0, 1.5 or 2.0 kg.cm - or the 2.5 kg.cm brake.

Graphs

Graphs draws the angle of the horn and the target, the supply current and the pulse width over the last 1, 3 or 6 seconds. The current graph tells the story of a move. At the start the motor stands still, so nothing limits its current but its resistance: a peak of about 440 mA in the graph's 5 ms samples. As the motor speeds up its back-EMF grows and the current falls to about 20 mA, and when the horn arrives it drops back to the 6 mA of the control board.

During the sweep the target moves one degree at a time and the horn follows it so closely that the blue line covers the orange one. Every step costs a tiny start, so the current is a row of small spikes, and the average stays at about 14 mA.

Torque, the Supply and the Load

This is where the MG90S earns its place, and where the model is most useful. The torque of a servo is not one number: it grows with the supply voltage. The data sheet gives two points, 1.8 kg.cm at 4.8 V and 2.2 kg.cm at 6 V, and on the 5 V of an Arduino the MG90S gives about 1.9 kg.cm. The pop-up's load chips let you test that edge.

2.0 kg.cm: a Stall

Pick 2.0 kg.cm on the toolbar and type 30. The target jumps to 30 degrees, the motor pushes with all it has - and the horn stays where it was. The banner turns red: STALLED AT 134.2 DEG - LOAD 2.0 KG.CM (IT GIVES 1.9 AT 5.0 V), and the current reads 730 mA. The Event log puts it in one sentence: "STALLED at 134.8 deg - the load (2.0 kg.cm) is above its torque (1.9 kg.cm at 5.0 V), 729 mA".

On the schematic the orange target marker sits at 30 degrees while the horn has not moved, and a red dot on the hub marks the stall. The strip shows the 730 mA. Feed the same servo from 6 V and the same load would not stop it: our automatic tests check exactly that, a 2.0 kg.cm load that stalls the MG90S at 4.8 V and lets it through at 6 V.

1.5 kg.cm: the Droop

Now pick 1.5 kg.cm. That is less than the servo can give, so the horn moves - more slowly - and stops at 34.0 degrees. It does not reach 30. The banner turns amber: HOLDING 33.5 DEG AGAINST 1.5 KG.CM - 3.6 DEG SHORT (THE LOOP'S DROOP), and the servo draws 377 mA to hold it there.

This is how every analog servo behaves, and it surprises many people. The control board drives the motor in proportion to the error: the further the horn is from the target, the harder it pushes. Under a load the horn settles where the push just balances the load, and that point is a few degrees short. Heavier load, bigger droop. A robot arm that sags a little when it lifts something is not broken - it is a proportional loop at work. It is also a hint: a servo that holds a load all the time runs warm, because it draws hundreds of milliamps just to stand still.

Event Log

The Event log keeps the story, newest first: the power, the first pulses, every new target with its pulse width, every finished move with its time and speed, every load change, the stall warning in red and the move that stopped short: "stopped at 34.0 deg, 4.0 deg short of 30.0 (the load)". Filter it by moves or warnings, pause it or clear it.

The Check Page

The Check page answers the forum questions in one look, each row with a verdict - green for fine, amber to check, red for wrong: the supply, the signal, the pulse rate, the pulse widths seen against the servo's range, the load against the torque at this supply, the position and the current. At the end of our run all are green. The load row reads "the MG90S gives 1.9 kg.cm at 5.0 V (1.8 at 4.8 V, 2.2 at 6 V)" and the current row "6 mA now, 766 mA peak - the peaks are the start of each move; fine on 5 V for one MG90S". Under the rows are the Arduino code to start from and the advice to match PULSE_MIN and PULSE_MAX with your library.

How the Model Works

Proteus runs the digital part of a circuit, the Arduino and its pulses, before each analog step. The servo keeps every edge on SIG with its exact time, so it knows the width of each pulse to the microsecond. It then integrates its motor and its horn over the step in 50 us slices: the pulse sets the target, the loop compares it with the angle, the board drives the motor for about 22 ms after each pulse, the motor fights its back-EMF, the friction of the metal gears and the load, and the gearbox turns the horn.

The current is part of the circuit, drawn from V+, so an ammeter in series with the red wire reads what the pop-up shows. We checked the model on a PC with 28 automatic tests: 60 degrees take 0.129 s at 4.8 V with the settling and 0.107 s at 6 V, the top speed is 584 degrees per second, the 2.5 kg.cm brake stalls it at 702 mA, 1.5 kg.cm still gets it there within its droop, and the Sweep example is followed within 1.7 degrees. Six more tests render the pop-up pages, and the demo project is read back from disk with 51 checks.

Need more servos than an Arduino has timers for? Our PCA9685 Servo Driver Library for Proteus drives sixteen of them over I2C.

Troubleshooting

• The horn never moves and the pop-up says NO POWER: V+ is not connected or below 3 V; an MG90S wants 4.8 - 6 V.
• WAITING FOR PULSES: SIG is on another pin than the one in attach(), or the sketch never calls attach().
• "SIG stays HIGH" or "pulses under 300 us": digitalWrite() or analogWrite() on the SIG pin - use the Servo library.
• The horn stops a few degrees short: a load it can carry - the droop; the banner says HOLDING AGAINST A LOAD.
• STALLED: the load is above the torque at this supply (1.9 kg.cm at 5 V), or the brake - the orange ring on the hub.
• No horn, no UNO or no monitor: TEPMG90S.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 MG90S

• Power: one MG90S draws up to about 0.7 A when it starts or stalls. More than one servo, or any load, wants its own 5 - 6 V supply for the red wire, with GND common to the Arduino; an Arduino on USB power can reset otherwise.
• 6 V is worth it: it gives about a quarter more torque and speed than 4.8 V - but keep it at or under 6 V.
• Metal gears, warm motor: the gears survive a stall that strips an SG90, but the motor still heats up; do not leave it stalled.
• Each servo has its own range: find its limits and use attach(pin, min, max); a servo pushing against its end stop runs hot.
• The Servo library uses Timer1: on an UNO, analogWrite() on D9 and D10 stops working while a servo is attached.

Limitations of the Simulation

• The model is the standard 180 degree analog MG90S at 50 Hz; digital and continuous rotation servos are other parts.
• Not modelled: the variation of the range and the dead band from one servo to the next, gear play, heating, and damage from a wrong supply (the model only warns).
• The plate, the scale, the LEDs, the strip and the brake are TEP additions.
• The model is our own, written from the typical data of the MG90S; this library is not made or endorsed by TowerPro, Arduino or Labcenter.
• Licences: the demo HEX contains the Arduino Servo library 1.2.2 (LGPL 2.1) and the Arduino AVR core 1.8.6 (LGPL); the sketch is included and the README gives the source links. The potentiometer is Proteus's own POT-HG.
• Tested in Proteus 8.5 in October 2026 with the demo as shipped: the knob, 30, the 2.0 and 1.5 kg.cm loads, the sweep and all four pages of the pop-up. Proteus 7 is not supported.

So, that was all about the MG90S Servo Motor Library for Proteus V1.0. I hope it helps you find out in Proteus how much your servo can really lift, how far it droops and how much current it costs - before the first metal gear servo goes into your robot. If you have any questions, ask in the comments and I will help you out. Till the next tutorial, take care and have fun!