Building a remote-controlled car is a classic DIY project, but adding a speedometer takes it from a simple toy to a functional data-gathering machine. The key to this build lies in the micro servo motor—a tiny but powerful component that can measure rotational speed with surprising accuracy. In this guide, I’ll walk you through the entire process, from selecting the right micro servo to integrating it with an Arduino-based speedometer display. This isn’t just about assembling parts; it’s about understanding how a micro servo motor can double as a speed sensor, giving your RC car a professional-grade feature.

Why a Micro Servo Motor for Speed Sensing?

Most RC car speedometers rely on Hall effect sensors or optical encoders, but these require additional magnets or reflective tape. A micro servo motor, however, offers a clever alternative: its internal potentiometer and gear train can be repurposed to measure rotational velocity. Here’s why it’s ideal:

• Built-in feedback: Micro servos have a potentiometer that reports the shaft’s angular position. By reading this signal, you can calculate RPM.
• Compact size: At roughly 23mm x 12mm x 29mm, it fits easily into tight spaces on a chassis.
• Low power consumption: It draws only 5V at 200mA under load, perfect for battery-powered projects.
• High resolution: Most micro servos provide 180-degree rotation with 1-2 microsecond pulse width modulation (PWM) resolution, translating to fine-grained speed data.

The catch? You can’t use a standard servo motor directly—you need to disable its position-holding mode and allow it to spin freely. This requires a simple modification: removing the mechanical stop and bypassing the control circuit. Don’t worry; I’ll show you how.

Tools and Components You’ll Need

Before diving in, gather these materials. I’ve listed them in three categories: essentials, optional upgrades, and tools.

Essentials

• Micro servo motor: A Tower Pro SG90 or MG90S works best. The metal-geared MG90S handles higher RPMs.
• Arduino Uno or Nano: For reading servo signals and driving the display.
• RC car chassis: A 1:10 scale buggy or truck with a brushed DC motor. Avoid brushless motors for simplicity.
• Motor driver: L298N or L293D to control the car’s main motor.
• RF receiver/transmitter: A 2.4GHz module like the FlySky FS-i6 for remote control.
• Speedometer display: A 16x2 I2C LCD or a 0.96-inch OLED.
• Power source: A 7.4V LiPo battery for the car, plus a 5V regulator for the Arduino.
• Jumper wires, breadboard, and soldering iron.

Optional Upgrades

• GPS module: For adding real-world speed calibration (e.g., NEO-6M).
• SD card module: To log speed data over time.
• RGB LED: To indicate speed thresholds (e.g., red for high speed).

Tools

• Screwdrivers (Phillips and flathead)
• Wire strippers
• Multimeter
• Hot glue gun
• Small file or Dremel (for servo modification)

Step 1: Modifying the Micro Servo Motor for Continuous Rotation

This is the heart of the project. A standard micro servo expects a PWM signal to move to a specific angle. For speed sensing, we need it to spin freely without stopping at a set position.

Disable the Mechanical Stop

1. Remove the servo horn: Unscrew the screw holding the horn and pull it off.
2. Open the servo case: Use a small screwdriver to pry open the plastic casing. Be careful not to damage the gears.
3. Locate the mechanical stop: This is a small plastic tab on the output shaft gear. File it down completely using a Dremel or a fine file. The gear should now rotate 360 degrees without hitting a barrier.
4. Reassemble the case: Ensure the gears are aligned and the shaft spins freely.

Bypass the Control Circuit

The servo’s internal potentiometer (pot) tells the controller where the shaft is. For continuous rotation, we need to trick it into thinking it’s always at the center position.

1. Desolder the potentiometer: It’s usually a three-pin component on the PCB. Remove it carefully.
2. Replace with fixed resistors: Solder two 2.5kΩ resistors in series between the pot’s power and ground pins. The center tap (wiper) should connect to the junction of the resistors. This creates a voltage divider that mimics the pot at 90 degrees.
3. Test with Arduino: Upload a simple servo sweep sketch. The motor should spin continuously when the PWM signal is between 1000µs and 2000µs. If it stops at certain angles, adjust the resistor values slightly.

Pro tip: If you’re not comfortable with soldering, buy a pre-modified continuous rotation servo. The “FS90R” is a drop-in replacement, but it lacks the potentiometer feedback we’ll use for speed measurement. Stick with the modified SG90.

Step 2: Mounting the Micro Servo to the Car’s Drivetrain

The servo will act as a tachometer. It needs to be mechanically coupled to a rotating part of the drivetrain, such as the main motor shaft or a wheel axle.

Option A: Direct Motor Shaft Coupling

1. Attach a small rubber wheel to the servo horn (e.g., a 10mm diameter silicone tire from a toy car).
2. Press the rubber wheel against the motor shaft using a spring-loaded arm or a 3D-printed bracket. The friction should be firm but not too tight—otherwise, it’ll slow the motor.
3. Secure the servo to the chassis with double-sided tape or screws. Ensure the wheel maintains contact during vibration.

Option B: Gear-Driven Coupling

1. 3D print a small gear that fits the servo horn and meshes with a gear on the car’s transmission.
2. Align the gears so they engage without binding. Use a spacer to keep the servo at the correct height.
3. Lubricate with light machine oil to reduce friction.

I recommend Option A for simplicity. The rubber wheel introduces minimal drag, and you can adjust the contact pressure easily.

Step 3: Wiring the Electronics

Now, let’s connect everything. The wiring diagram is straightforward, but pay attention to power distribution to avoid noise.

Circuit Connections

• Arduino to Motor Driver:
  • Pin 9 → L298N Enable A (PWM for motor speed)
  • Pin 8 → L298N Input 1
  • Pin 7 → L298N Input 2
• Arduino to Servo:
  • Pin 10 → Servo signal wire (yellow)
  • 5V → Servo power (red)
  • GND → Servo ground (brown)
• Arduino to LCD (I2C):
  • A4 (SDA) → LCD SDA
  • A5 (SCL) → LCD SCL
  • 5V and GND as usual
• RF Receiver:
  • Connect to Arduino’s serial pins (RX/TX) per your module’s datasheet.
• Power:
  • LiPo battery → L298N power input (12V terminal)
  • L298N 5V output → Arduino 5V pin (if using a 7.4V battery, ensure the regulator can handle it; otherwise, use a separate 5V regulator)

Warning: Never power the servo directly from the Arduino’s 5V pin if it draws more than 500mA. The SG90 draws about 200mA under load, so it’s safe, but the MG90S can spike to 700mA during stalls. Use a separate 5V regulator for the servo if you’re using the metal-geared version.

Step 4: Programming the Speedometer Logic

The code has three main tasks: reading the servo’s potentiometer signal, calculating RPM, and displaying the speed. I’ll explain each part.

Reading the Servo’s Analog Signal

The modified servo’s potentiometer outputs a voltage between 0V and 5V as it spins. Connect the pot’s wiper to Arduino’s analog pin A0. The voltage changes linearly with rotation, giving us a position value from 0 to 1023.

cpp int potValue = analogRead(A0); // 0-1023

Calculating RPM

To convert position to RPM, we need to detect how fast the voltage changes. Here’s the trick: measure the time it takes for the pot to complete one full rotation (i.e., go from 0 to 1023 and back to 0). Since the pot is linear, a full rotation corresponds to a change of 1023 units.

1. Track the previous position and compare it to the current one.
2. Detect zero-crossings: When the value jumps from high to low (e.g., 1000 to 10), a full rotation has occurred.
3. Measure the time between zero-crossings using millis().

cpp unsigned long lastTime = 0; int lastPos = 0; float rpm = 0;

void loop() { int currentPos = analogRead(A0); if (abs(currentPos - lastPos) > 500) { // Detects wrap-around unsigned long currentTime = millis(); unsigned long deltaTime = currentTime - lastTime; if (deltaTime > 0) { rpm = 60000.0 / deltaTime; // 60,000 ms per minute } lastTime = currentTime; } lastPos = currentPos; }

This method works well at moderate RPMs (up to about 3000 RPM). For higher speeds, increase the sampling rate by using interrupts on a timer.

Converting RPM to Speed

Speed = RPM × wheel circumference × gear ratio. Assuming the servo is coupled to the motor shaft directly:

• Measure your car’s wheel diameter (e.g., 65mm).
• Circumference = π × diameter = 3.14 × 0.065m = 0.204m.
• If the motor has a 10:1 gearbox, the wheel RPM is motor RPM / 10.
• Speed (m/s) = (RPM / 10) × 0.204 / 60.

For display, convert to mph or km/h: multiply m/s by 2.237 for mph, or 3.6 for km/h.

Displaying on LCD

Use the LiquidCrystal_I2C library to show speed in real time.

cpp

include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd(0x27, 16, 2);

lcd.setCursor(0, 0); lcd.print("Speed: "); lcd.print(speedKmh, 1); lcd.print(" km/h");

Full Code Structure

Here’s a simplified version. Note: This assumes you’ve installed the necessary libraries.

cpp

include <Servo.h>

include <LiquidCrystal_I2C.h>

Servo carMotor; // Not for speed sensing, but for driving the car LiquidCrystal_I2C lcd(0x27, 16, 2);

const int servoPotPin = A0; const int motorEnablePin = 9; const int motorIn1 = 8; const int motorIn2 = 7;

unsigned long lastCrossTime = 0; int lastPotValue = 0; float rpm = 0; float speedKmh = 0;

void setup() { Serial.begin(9600); lcd.init(); lcd.backlight(); pinMode(motorEnablePin, OUTPUT); pinMode(motorIn1, OUTPUT); pinMode(motorIn2, OUTPUT); }

void loop() { // Read servo pot int potValue = analogRead(servoPotPin);

// Detect full rotation if (abs(potValue - lastPotValue) > 500) { unsigned long currentTime = millis(); unsigned long delta = currentTime - lastCrossTime; if (delta > 0) { rpm = 60000.0 / delta; // Convert to km/h (example: wheel diam 65mm, gear ratio 10:1) speedKmh = (rpm / 10.0) * 0.204 * 3.6; } lastCrossTime = currentTime; } lastPotValue = potValue;

// Display speed lcd.setCursor(0, 0); lcd.print("Speed: "); lcd.print(speedKmh, 1); lcd.print(" km/h");

// Drive control (simplified - add RF logic here) analogWrite(motorEnablePin, 200); // 0-255 digitalWrite(motorIn1, HIGH); digitalWrite(motorIn2, LOW);

delay(50); // Adjust for smoother readings }

Note: The delay(50) limits the refresh rate. For higher accuracy, use a non-blocking timer with millis().

Step 5: Calibrating the Speedometer

No sensor is perfect. Calibration ensures your speedometer reads accurately.

Static Calibration

1. Lift the car’s wheels off the ground so they spin freely.
2. Run the motor at a known PWM value (e.g., 150 out of 255).
3. Measure the actual wheel RPM using a handheld tachometer or a strobe light.
4. Compare to the Arduino’s RPM reading. Adjust the gear ratio or circumference in the code until they match.

Dynamic Calibration (Optional)

1. Use a GPS module to record real speed over a straight path.
2. Drive at a constant speed (e.g., 10 km/h on GPS).
3. Tweak the conversion factor until the LCD matches the GPS.

I found that my modified SG90 had about 5% error at low speeds due to friction. Adding a tiny drop of oil to the servo’s bearings reduced this to 2%.

Step 6: Assembling the Remote Control Integration

The speedometer is useless if you can’t drive the car remotely. Integrate your RF receiver with the Arduino.

Wiring the RF Receiver

• Connect the receiver’s channel outputs to Arduino digital pins (e.g., CH1 to pin 2, CH2 to pin 3).
• Use the PulseIn() function to read the PWM signal from each channel.

cpp int ch1 = pulseIn(2, HIGH, 25000); // 1000-2000µs

Mapping to Motor Control

Map the receiver’s PWM to the motor driver:

cpp int motorSpeed = map(ch1, 1000, 2000, 0, 255); analogWrite(motorEnablePin, motorSpeed);

For steering, add a second servo (standard, not modified) connected to the front wheels.

Troubleshooting Common Issues

Even experienced builders hit snags. Here are fixes for the most common problems.

Servo Spins Erratically

• Cause: The potentiometer replacement resistors are mismatched.
• Fix: Measure the voltage at the pot’s wiper pin. It should be 2.5V when the servo is idle. Adjust resistors until it’s exactly half of the supply voltage.

Speed Reading Jumps Wildly

• Cause: Vibration causing the rubber wheel to slip.
• Fix: Increase contact pressure or switch to a gear-driven coupling. Also, add a low-pass filter in code: rpm = 0.9 * rpm + 0.1 * newRpm;

LCD Shows “0 km/h” Constantly

• Cause: The zero-crossing detection threshold is too high.
• Fix: Lower the threshold from 500 to 300. The pot’s analog range might not cover 0-1023 if the servo doesn’t rotate fully.

Car Moves Slowly Even at Full Throttle

• Cause: The modified servo adds drag to the drivetrain.
• Fix: Ensure the rubber wheel is not pressing too hard. A 3D-printed bracket with adjustable tension helps.

Expanding the Project

Once your basic speedometer works, consider these enhancements.

Data Logging

Add an SD card module to record speed every second. This is great for analyzing acceleration or battery performance over time.

cpp File dataFile = SD.open("speedlog.txt", FILE_WRITE); dataFile.println(speedKmh); dataFile.close();

Wireless Telemetry

Use a Bluetooth module (HC-05) to stream speed data to your phone. An app like “Serial Bluetooth Terminal” can display it in real time.

Visual Feedback

Program an RGB LED to change color based on speed: - Green: 0-10 km/h - Yellow: 10-20 km/h - Red: 20+ km/h

This makes the car look like a futuristic racer.

Multiple Sensors

Mount a second micro servo on the rear wheel to measure wheel slip. Compare front and rear RPMs to detect loss of traction.

Final Thoughts on the Micro Servo Motor’s Role

The micro servo motor is the unsung hero of this build. Its dual nature—as both a position actuator and a rotational sensor—makes it incredibly versatile. By modifying it for continuous rotation, you’ve unlocked a cheap, accurate speed sensor that costs less than $5. Compare that to a commercial Hall effect sensor kit, which runs $20-$30 and requires extra magnets.

The trade-off is mechanical complexity: you need to physically couple the servo to the drivetrain, and friction can introduce errors. But with careful mounting and calibration, you can achieve accuracy within 1-2% of a GPS-based system. Plus, the learning experience is invaluable. You’ve transformed a simple hobby servo into a core component of a data-driven machine.

Now, take your RC car for a spin. Watch the speedometer climb as you push the throttle. That micro servo, spinning away inside, is silently counting every rotation, turning mechanical motion into numbers on a screen. It’s a small piece of engineering magic—and you built it yourself.