How to Build a Remote-Controlled Car with a Single Motor System

Building a remote-controlled car from scratch is one of the most rewarding projects a hobbyist can take on. It teaches you about power delivery, steering geometry, wireless communication, and mechanical tradeoffs — all in one compact package. Most guides, however, assume you'll use two motors: one for the rear wheels and one for steering. That doubles your motor driver cost, your wiring complexity, and your tuning headaches.

In this guide, we'll do it differently. We'll build a fully functional RC car using a single drive motor for propulsion and a micro servo motor for steering. Along the way, you'll see why the micro servo has quietly become the hero component of small-scale robotics — and why it's the perfect match for a one-motor drivetrain.

Why a Single-Motor System Makes Sense

Before we touch a screwdriver, let's talk about the philosophy behind this build. A single-motor system means one motor handles forward and reverse motion, while a micro servo handles directional control through a mechanical steering linkage. This architecture has real advantages:

• Lower cost. One DC motor plus one micro servo is cheaper than two gear motors with encoders.
• Simpler wiring. Fewer motor driver channels, fewer power rails to manage.
• Lighter chassis. Weight savings matter enormously in small-scale RC builds.
• Easier troubleshooting. When something goes wrong, you have exactly two actuators to inspect.

The tradeoff is that you can't do tank-style steering (where each wheel drives independently). Instead, you'll use Ackermann-style or simple pivot steering, which is exactly how full-size cars work. That's a feature, not a bug — it forces you to think about real steering geometry.

The Star of the Show: The Micro Servo Motor

Here's where the micro servo earns its spotlight. A typical micro servo — think the SG90 or MG90S — weighs around 9 to 13 grams, delivers roughly 1.5 to 2.2 kg·cm of torque, and runs on 4.8 to 6 volts. It contains its own control circuit, a potentiometer for position feedback, and a small DC motor with a gear train, all packed into a plastic or metal case roughly the size of a postage stamp.

What makes it perfect for this build?

1. Built-in position control. You send a PWM signal, and the servo moves to a specific angle. No encoder, no PID loop, no closed-loop code on your microcontroller. The servo handles all of that internally.
2. Plug-and-play wiring. Three wires: power, ground, signal. That's it.
3. Precise, repeatable steering angles. A micro servo typically sweeps 180 degrees, giving you fine-grained control over steering lock.
4. Low current draw. At idle, a micro servo sips milliamps. Under load, it peaks around 500–700 mA — easily handled by a small battery pack.
5. Compact form factor. It fits inside a chassis barely larger than your palm.

If you've ever watched a micro servo snap to a commanded angle with a satisfying little whir, you already understand why it's the go-to actuator for steering in small robotics.

Gathering the Parts

Here's your bill of materials for a compact single-motor RC car:

Electronics

• 1× micro servo motor (SG90 or MG90S recommended; the metal-gear MG90S survives crashes better)
• 1× DC gear motor (6V, 200–300 RPM is a good starting point)
• 1× motor driver module (L298N or TB6612FNG)
• 1× microcontroller board (Arduino Nano or ESP32 if you want Wi-Fi control)
• 1× RC receiver and transmitter pair (or a Bluetooth/Wi-Fi module for phone control)
• 1× battery pack (4× AA NiMH, or a 2S LiPo with a buck converter)
• Jumper wires, a small breadboard or perfboard

Mechanical

• 1× chassis plate (acrylic, plywood, or 3D-printed)
• 2× rear wheels with a matching axle or coupler for the gear motor
• 2× front wheels mounted on steering knuckles
• 1× steering linkage set (tie rod, servo horn, ball links — or fabricate from stiff wire)
• Screws, standoffs, zip ties, and double-sided foam tape

Tools

• Soldering iron, wire strippers, screwdriver set
• Hot glue gun or small bolts for mounting
• Optional: 3D printer for custom brackets

Designing the Chassis and Steering Geometry

The chassis is straightforward: a flat plate roughly 15–20 cm long and 10 cm wide gives you room for the battery, electronics, and motor while staying nimble. Mount the gear motor at the rear, centered, with its output shaft driving both rear wheels through an axle or a pair of couplers.

The front end is where the micro servo lives, and it deserves careful thought.

Mounting the Micro Servo

Position the servo centrally between the front wheels, with its output shaft pointing upward. Secure it with screws through its mounting tabs or with a snug 3D-printed bracket. The servo horn attaches to a linkage that connects to both steering knuckles.

Building the Steering Linkage

A simple and reliable approach is a tie-rod setup: the servo horn rotates, pushing and pulling a stiff wire or threaded rod that connects to arms on each front knuckle. Keep the linkage parallel to the axle to minimize bump steer. If you want proper Ackermann geometry, angle the knuckle arms slightly inward so the inner wheel turns sharper than the outer wheel — but for a first build, parallel linkage is perfectly acceptable.

Setting the Steering Center

Before you finalize anything, power up the servo and command it to its neutral position (typically 90 degrees, or a 1500 µs pulse). Mount the horn and linkage so the wheels point straight ahead at that pulse width. This single step saves you hours of trim adjustment later.

Wiring It All Together

The wiring diagram in your head should look like this:

• Battery → motor driver VM and servo power (through a shared 5–6V rail)
• Microcontroller → motor driver logic pins (direction and PWM)
• Microcontroller → servo signal pin
• Receiver/module → microcontroller (UART, SPI, or PWM input)
• All grounds tied together — this is non-negotiable

A common mistake is powering the micro servo from the microcontroller's onboard 5V regulator. Under load, the servo's current spikes can brown out the board and cause resets. Give the servo its own feed from the battery rail, and tie the grounds together.

The Control Signal

The micro servo expects a PWM signal at 50 Hz, with pulse widths from about 1000 µs (full left) to 2000 µs (full right), and 1500 µs as center. On an Arduino, the Servo library handles this with a single write() call. On an ESP32, you can use the LEDC peripheral or the newer ESP32Servo library.

Writing the Control Code

The firmware has three jobs: read the RC input, translate it into throttle and steering commands, and drive the two actuators.

Reading the Input

If you're using a standard RC receiver, it outputs PWM pulses on each channel. Use pulseIn() on the Arduino to read them. If you're using Bluetooth or Wi-Fi, parse your command packets instead — the logic downstream is identical.

Driving the Motor

Map the throttle channel to a PWM duty cycle on the motor driver. Add a deadband around center so the car doesn't creep when the stick is neutral. Invert the direction pin when the throttle goes negative.

Steering with the Micro Servo

Map the steering channel to an angle between your mechanically safe limits — say 55 to 125 degrees rather than the full 0 to 180 — so you never stall the servo against its end stops. Stalling a micro servo is the fastest way to burn it out; its tiny gear train and motor simply aren't built for continuous stall torque.

Smoothing the Response

Raw RC inputs are jittery. Apply a simple exponential filter to both channels, or slew-rate-limit the servo angle so it glides rather than snaps. Your steering will feel dramatically more controlled, and your servo gears will thank you.

Testing and Tuning

Start with the wheels off the ground. Verify that:

1. Steering moves left and right smoothly across the full range without binding.
2. The motor spins forward and reverse and stops cleanly at neutral.
3. Nothing browns out when you slam the throttle and steering simultaneously.

Then put it on the floor and tune. Adjust the steering trim so the car tracks straight at neutral. Reduce the steering endpoint if the linkage binds at full lock. If the car understeers, you can increase steering throw slightly — but watch the servo's current draw.

Protecting Your Micro Servo

A few field-tested habits: add a small capacitor across the servo's power leads to absorb current spikes, avoid mounting the servo where it takes the first impact in a crash, and consider a servo saver (a spring-loaded horn) if you plan to drive aggressively. The MG90S's metal gears tolerate abuse far better than the SG90's nylon ones.

Taking It Further

Once the base build works, the single-motor architecture leaves you room to grow. Swap the Arduino for an ESP32 and stream live telemetry. Add a second micro servo for a panning camera. Upgrade to a higher-torque micro servo if you widen the track. The beauty of this design is its modularity — the micro servo handles steering so reliably that you can pour your attention into everything else.

There's a particular satisfaction in watching a car you built yourself carve a turn, knowing that a nine-gram servo the size of your thumb is doing the steering. Build it, drive it, break it, fix it — and you'll understand exactly why the micro servo has become the quiet workhorse of small-scale robotics.