Building a self-driving RC car is a fun DIY robotics project. You’ll use an Arduino microcontroller board as the “brain” of the car, and sensors and motors to make it move and avoid obstacles. In simple terms, the Arduino UNO board will read distance data from an ultrasonic sensor (like the HC-SR04) and drive the motors through a motor driver (L293D), so the car can steer itself around obstacles. For example, one project powered a car with an Arduino UNO R3 and an L293D motor shield, using an HC-SR04 ultrasonic sensor (on a rotating servo) to scan for paths instructables.com. The car drove forward until it detected an object, then used that sensor data to pick a new direction. In this tutorial we’ll cover parts, assembly, programming, testing, and troubleshooting for your DIY Arduino car. Follow these steps and you’ll have a working autonomous RC car!
Parts and Tools Needed
To build your self-driving car, you will need the main components below. These parts are commonly available in Arduino starter kits or individual modules. (We include affiliate links so you can easily find them on Amazon – for US readers, just click the product names below and use code ?tag=rcblogs-20 in the URL.)
- Arduino UNO R3 Board (and Starter Kit) – The UNO is a beginner-friendly Arduino board that controls everything. We recommend an all-in-one kit like the ELEGOO UNO R3 Starter Kit. This kit includes the UNO board plus lots of extras (breadboard, wires, LEDs, sensors, etc.) to get started. (An Arduino board is essentially a tiny computer that you program to read sensors and drive motors.)
- Motor Driver (L293D Shield or Breakout) – The L293D chip lets the Arduino power DC motors in both directions. It contains two H-bridge drivers, each supporting up to about 600 mA of current instructables.com. (That means you can run two small DC motors from one L293D module.) A convenient choice is the HiLetgo L293D Motor Driver Shield, which plugs right into the UNO and has screw terminals for motor wires. The L293D is what actually controls the speed and direction of the wheels as commanded by the Arduino instructables.com.
- Ultrasonic Distance Sensor (HC-SR04) – This sensor measures distance by sending 40 kHz sound pulses and timing their echo amazon.com. It can detect obstacles roughly from 3 cm out to about 4.5 m amazon.com. You’ll use at least one HC-SR04 to “see” in front of the car. (Some builders use 3 sensors for front/left/right coverage instructables.com, or one sensor on a servo for scanning instructables.com.) A good option is the ELEGOO HC-SR04 Ultrasonic Sensor Kit (comes with 5 sensors, in case you want extras).
- Robot Car Chassis Kit – This is the base, wheels, and motors of your car. You can use a 2WD or 4WD chassis kit. For beginners, a 4WD acrylic chassis gives stability and includes 4 geared DC motors and wheels. One popular kit is the Smart 4WD Robot Car Chassis, which includes a sturdy PCB platform, 4 TT motors, and wheels – ideal for Arduino or Raspberry Pi DIY robots amazon.com. (Another instructables project used a “Car Chassis Kit” with two gearmotors and wheels instructables.com.) Make sure your chassis kit comes with a battery holder. If not, you’ll need to supply a 9V battery pack or a pack of AA batteries (and an on-off switch).
- Power Supply – A battery pack (like 6×AA or a 9V battery) to power the motors and the Arduino. You may power the Arduino from a 9V battery via the barrel jack or Vin pin. Check that all grounds (motor driver, Arduino, sensor) share a common ground.
- Jumper Wires & Breadboard – For wiring everything together. Often the Arduino kit includes plenty of jumper wires. A small solderless breadboard can help organize connections from the Arduino to the sensor and motor driver.
- Optional Servo Motor – If you want the ultrasonic sensor to sweep left and right, add a hobby servo (e.g. SG90) to rotate the sensor for a wider “view” instructables.com. This is optional – a single fixed sensor will work, but a servo allows smarter scanning.
- Tools – Small screwdriver (for chassis assembly), soldering iron (if you attach wires permanently), hot glue or tape for mounting, and wire strippers.
Assembling the RC Car
Follow these steps to put together the hardware. Keep instructions simple and use common language. Numbered lists help make it clear:
- Build the Chassis Base: Attach the DC motors and wheels to the chassis frame. Most kits have screws or clips to mount motors. Attach the caster wheel (free-rolling third wheel) at the front or back if provided. Make sure the chassis and wheels move freely.
- Mount the Arduino and Motor Driver: Plug the L293D motor driver shield into the Arduino UNO, or wire an L293D breakout to the Arduino pins. Position the Arduino (with shield) on the chassis (you can screw or glue it down). If using a plain L293D chip, place it on the breadboard. The motors’ leads will later go to the L293D outputs.
- Connect the Motors: Each motor has two wires (polarity doesn’t matter initially). Connect motor A wires to one pair of L293D outputs, and motor B wires to the other pair. On a shield, these might be labeled M1/M2. For example, left motor to M1, right motor to M2. This lets you drive each wheel independently.
- Wire the Ultrasonic Sensor: Attach the HC-SR04 sensor module at the front of the car. If using a bracket or zip-ties, secure it so the sensor faces forward (or mount it on the servo if scanning). Connect the sensor’s VCC pin to the Arduino’s +5V, GND to ground, Trig pin to a digital output pin (e.g. 9), and Echo pin to another digital input (e.g. 10) on the Arduino. The image below shows the HC-SR04 hookup on a breadboard. The sensor module has 4 pins (VCC, Trig, Echo, GND) and wires from Trig/Echo go to your chosen Arduino pins instructables.com.
- Power Connections: Connect your battery pack positive lead to the Vin or 5V input (through a switch) and negative lead to the Arduino’s GND. Also connect the battery to the motor driver’s power input so the motors run off battery. Ensure all grounds are tied together: Arduino GND, motor driver GND, sensor GND.
- Finalize Wiring: Double-check everything with the wiring diagrams above. Make sure the motor driver’s enable pins are set (on a shield they’re often jumper-bridged for enabled), and that you’ve mounted any loose parts securely. The car is now ready for code!
Tip: Label your connections (e.g. write the pin numbers on a piece of tape) so you remember which Arduino pins control each motor and sensor. If using a servo, connect its signal pin to a PWM-capable Arduino pin (e.g. D5).
Arduino Code for Self-Driving
Now for the fun part: programming the Arduino to drive itself. The basic idea is: the Arduino will repeatedly measure distance from the ultrasonic sensor and decide how to move the motors.
Libraries
You can use the standard Arduino functions (no special library needed), or use a library like NewPing to handle the ultrasonic timing. Either way, define the Trig pin as OUTPUT and Echo pin as INPUT in setup().
Measuring Distance
To measure distance, send a 10µs pulse on Trig, then read the duration of the echo pulse on Echo. Convert this time to distance (Sound travels ~0.034 cm/µs, and you divide by 2 because the pulse goes forward and back instructables.com).
Motor Control Logic
In the loop(), implement obstacle avoidance with simple logic:
- Drive Forward: If the measured distance is greater than some safe threshold (say 20-30 cm), keep both motors running forward. You use digitalWrite() (or analogWrite() for speed control) on the L293D inputs to set motor directions. If both motors spin forward, the car moves ahead. For speed control, try analogWrite(pin, speed) on the enable pins as suggested in tutorials instructables.com.
- Obstacle Detected: If the distance reading is below the threshold (obstacle too close), stop the motors. Then decide a turn direction. One method is to spin the car in place (one wheel forward, one backward) to turn around until the sensor reads a clear path. Another is to rotate a servo-mounted sensor to look left and right and compare distances (as in [4]), then turn toward the larger reading.
- Turning: For simplicity, you might just turn right (for example) by running only the left motor forward (and right motor backward) until the front is clear. Or reverse a bit and then turn left. Experimentation is key. Always include a brief delay after turns so the sensor gets a stable reading.
- Loop: Repeat the measurement and motion. Keep the loop running at a reasonable pace (avoid long delay() calls so the car responds quickly).
Here’s a pseudocode sketch of the logic:
text
setup() {
pinMode(trigPin, OUTPUT);
pinMode(echoPin, INPUT);
// motor pins as outputs
}
loop() {
distance = measureDistance();
if (distance > SAFE_DISTANCE) {
// no obstacle: drive forward
digitalWrite(motorLeftForward, HIGH);
digitalWrite(motorRightForward, HIGH);
} else {
// obstacle: stop and avoid
digitalWrite(motorLeftForward, LOW);
digitalWrite(motorRightForward, LOW);
// choose turn direction
turnCar(); // e.g., right or left
}
delay(50); // short pause
}
Adjusting Speed
Use analogWrite() on the enable pins of the L293D to control speed as needed instructables.com. A value of 255 is full speed; lower values slow the motors.
Ultrasonic Code Tip
Remember that the HC-SR04 echo returns a HIGH pulse whose length is twice the time it took sound to bounce back. Many tutorials (e.g. [47]) explain how to convert this to distance. For instance, if Echo pulse is 3000µs, distance = (3000 * 0.034) / 2 ≈ 51 cm instructables.com.
Testing in Code
Print the distance to the Serial Monitor first to ensure your sensor is working before moving motors. Confirm that you read expected values when you put objects in front of the sensor.
By following these steps, your Arduino will measure distance and automatically avoid obstacles. Think of this as the “brain” logic: measure, decide, move.
Testing and Troubleshooting
After uploading your code, place the car on a flat open surface (no stairs!) and turn it on. Test it step by step: first, verify the ultrasonic readings by printing them on Serial. Next, try running the motors forward in code to ensure wheels spin as expected. Then enable the obstacle-avoidance logic.
Watch for Hazards
As [14] cautions, always supervise the car. It will drive on its own, so keep it away from stairs or edges instructables.com.
If Motors Don’t Run
Check power. Ensure the battery pack is fresh and correctly wired to the motor driver’s Vmotor input. Make sure the motor power jumper is in place (if using a shield). Confirm ground is common with the Arduino.
Sensor Issues
If the distance never changes, check the HC-SR04 wiring: VCC to 5V, GND to GND, Trig/Echo to the correct pins. An easy fix: swap the Trig and Echo pins in code if you wired them opposite. Also, objects that are very close (<3cm) or very thin (like a needle) may not register well.
Strange Behavior
If the car spins in circles or jerks, calibrate the speed values. Maybe one motor is stronger; you can PWM one slightly lower. Ensure the threshold distance in code matches your car’s size (a bigger car needs a larger safe distance).
Debugging Tip
Use LEDs or Serial prints in your code to indicate which branch it’s taking (e.g., “Turning left” vs “Turning right”). That way you know if the logic is working as intended.
If something isn’t working, start by isolating the problem. Test the sensor alone, then the motors alone, then together with simple code. The Arduino forum and DIY robotics communities are full of similar projects, so search for “Arduino HC-SR04 obstacle avoidance” for more tips. Generally, check one system at a time and fix that, then move on.
Recommended Products
To make it easy, here are 4 key products we recommend (with Amazon links). These are the parts we used in this tutorial. Clicking the product name will take you to Amazon (with our affiliate tag) so you can check the latest price and buy. We earn a small commission if you purchase, at no extra cost to you.
- ELEGOO UNO R3 Starter Kit – This kit includes an Arduino UNO R3 board plus 200+ components (breadboard, wires, LEDs, sensors, motors, etc.). It’s perfect for beginners. It comes with a tutorial booklet as well. Shop on Amazon for the ELEGOO kit.
- ELEGOO HC-SR04 Ultrasonic Sensors (5-pack) – A pack of 5 HC-SR04 distance sensors so you can use multiple sensors or have spares. These sensors are the same ones we use to detect obstacles. Check price on Amazon. Many reviewers praise their accuracy and low cost.
- HiLetgo L293D Motor Driver Shield – A plug-in shield that mounts on the Arduino, containing two L293D drivers. It simplifies wiring for DC motors and servos (has screw terminals and power jumpers). Buy on Amazon – look for the one labeled “L293D Motor Drive Shield”. It works exactly like the L293D chip but in a handy format.
- 4WD Smart Robot Car Chassis Kit – This is a robust acrylic chassis with 4 geared DC motors and wheels, plus a battery box. It’s larger and tougher for projects like this. Find it on Amazon (brand “XiaoR Geek” or “Smart 4WD”). It’s more stable than a tiny toy car chassis, and it’s easy to mount your electronics on it.
Each of these parts has lots of reviews. For example, the HC-SR04 sensors have thousands of 5-star ratings for reliability amazon.com, and the UNO kit is designed for STEM learning amazon.com. We tested these in our project and they worked great. Disclosure: We are Amazon affiliates; if you buy via these links, we get a small commission to help our blog (thanks!).
More Tips & Resources
This project is a great way to learn basic robotics and coding. Once your car works, you can expand it by adding more sensors (IR line trackers, for example), or improving the “AI” logic. For inspiration, check Arduino forums or the Arduino Project Hub for similar obstacle-avoiding robot projects. You might also find Reddit communities (like r/arduino) useful for sharing your build or asking questions.
Remember, practice makes perfect. If your car doesn’t work first try, double-check each part, and consult online guides. The important thing is to have fun building and experimenting. Soon you’ll have a clever little autonomous car that you built yourself!
Happy building, and happy driving!