RASPBERRY PI | RC RACE CAR (PART 1)

In this project, you will take an off-the-shelf RC car and transform it into a WiFi controlled vehicle that can be driven from a computer. Using a Raspberry Pi, and optionally an Arduino, you will build a system that allows you to steer, accelerate, and view a live camera feed from the car all in real time.

The Raspberry Pi will act as the car’s onboard computer, receiving control commands from your PC and sending them as PWM signals to the car’s motor and steering system. A small camera mounted on a servo motor will transmit a driver’s eye video feed, giving you the experience of driving from inside the car. The control interface on your PC will let you drive the car around a track using a steering wheel, game controller, or keyboard.
​
By the end of the project, you will have a working tele-operated vehicle capable of:

• Variable speed acceleration and steering via PWM control
• Live video streaming from an onboard camera
• Remote driving through a local Wi-Fi network
• ​Camera panning using a servo motor

The system you’ll create mirrors technologies used in many modern applications:

• Autonomous and semi-autonomous vehicles use similar control and feedback systems for navigation.
• Teleoperated robots are used in hazardous or remote environments where humans cannot easily go.
• IoT devices rely on real-time data exchange, just like the link between your PC and the Raspberry Pi.

Through this build you will explore how embedded computing, wireless communication, and mechanical systems integrate to form complete cyber physical systems. You’ll also begin to understand key engineering challenges such as latency, power management, and reliability all essential in robotics and remote control applications.
This project bridges disciplines:

• Computer Science | programming, networking, and data transmission
• Electronics | circuits, power, and signal control
• Engineering | design, testing, and iterative problem solving

SAMPLE VIDEO
'The Raspberry Pi-powered RC car in action — controlled from a PC using a steering wheel interface, with a live video feed streamed from the onboard camera'

SECTION 1 | MATERIAL NEEDED

1. Hardware Requirements

• RC Car (1/10 or 1/12 scale recommended)
• A standard hobby-grade RC car with a removable receiver and a motor controlled by an Electronic Speed Controller (ESC). The ESC and steering servo should both use 3-wire connections (signal, power, ground).
  
• Raspberry Pi (Model 4B or 5)Acts as the onboard computer, handling video capture, Wi-Fi communication, and coordination of the control system.
  
• Arduino (Uno or Nano) Generates precise PWM signals for the ESC and steering servo. The Raspberry Pi sends control commands to it via USB serial.
  
• Camera Module (Raspberry Pi Camera v3 recommended) Provides live video feed for remote driving. The wide-angle version gives a better field of view around the track. 
• Servo Motor for Camera Pan Allows the driver to rotate the camera using the control interface, simulating head movement or a change in viewpoint.

Power and Connectivity

• ESC and Motor Power Source – typically a 2S or 3S LiPo battery supplied with the RC car.
• 5 V Power Supply for Raspberry Pi and Arduino – use a UBEC or separate USB power bank to ensure stable voltage.
• Common Ground Connection between Pi, Arduino, ESC, and servo is essential for signal accuracy.
• ​Wi-Fi Router (5 GHz preferred) – creates a dedicated local network for low-latency communication.

Optional:

• USB game controller or steering wheel for the PC
• ​Mounting hardware (Velcro, cable ties, small brackets)
• Cut-off switch or E-stop button for testing
• 3D Printed car Body

2. Software RequirementsOn the Raspberry Pi

• Raspberry Pi OS (Bookworm or later) – Lite version recommended for performance
• Python 3 – for communication and control scripting
  
• Libraries:

1. pigpio (for PWM if controlling directly from Pi)
2. pyserial (for communication with Arduino)
3. webrtc-streamer or gstreamer (for low-latency video)
4. flask or socket (for command reception and web interface)

On the Arduino

• Arduino IDE – for uploading the PWM control program
• Simple serial listener code to receive commands (e.g., “M1700S1600”) and output PWM to ESC and servo pins

On the PC

• Python with PyGame or Tkinter – for creating the control interface
  
• Controller drivers (if using a steering wheel or gamepad)
• Access to the Raspberry Pi’s IP address to view the camera stream and send control commands

3. Network Setup

• Use a local Wi-Fi network (not the school’s main network) to avoid congestion.
• The router should have DHCP enabled or use static IPs for both the Raspberry Pi and PC.
• If possible, connect the PC to the router via Ethernet cable for lower latency.
• The Raspberry Pi and PC must be on the same subnet (e.g., 192.168.0.x).

OVERVIEW

• Raspberry Pi 4B (4 GB)or Pi 5Main processor 
• Pi Camera v3 (Wide) |Mounted front 
• Arduino Nano (ATmega328) | Servo/motor interface 
• MG995 servo | For camera pan 
• 5V USB | Stable Pi power 
• RC car (1/10 scale) | With Mod-friendly base 
• USB Wi-Fi adapter optional | For 5 GHz link 
• 5 GHz router |Dedicated control network 

SECTION 2| THE PRINCIPLES

This project brings together three key systems control, communication, and feedback to allow a human driver to control a real RC car over a Wi-Fi network. Understanding how data flows between each component is essential before starting the build.
1. The Overall System FlowAt a high level, your setup will operate like this:
PC (control interface) → Wi-Fi network → Raspberry Pi (onboard computer) → Arduino (signal converter) → ESC and steering servo (mechanical output)
Meanwhile, a camera mounted on the Raspberry Pi streams a live video feed back to the PC, creating a feedback loop that lets you drive visually in real time. This two-way data flow that controls commands going out, and video feedback coming back is what makes the project both challenging and rewarding.

2. The Control Path

• The driver uses a keyboard, joystick, or steering wheel connected to a Windows PC.
• ​The control interface converts these inputs into digital values representing speed and steering angle.
• These values are sent from the PC to the Raspberry Pi over the local Wi-Fi network using a UDP or WebSocket connection.
• The Raspberry Pi receives these commands and sends them to the Arduino (or directly to its own GPIO pins) using a simple serial connection.
  
• The Arduino generates PWM signals that control:

1. The ESC, which drives the car’s motor at variable speed.
2. ​The steering servo, which adjusts the front wheels.

Each of these signals is continuously updated to respond to the driver’s inputs in near real time.

3. The Feedback Path (Video Streaming)

• A camera mounted on the car captures live video from the car’s perspective.
• ​The Raspberry Pi processes the camera feed using tools such as webrtc-streamer or gstreamer to compress and transmit it efficiently.
• The video stream is sent back to the driver’s PC over the same Wi-Fi network.
• The PC displays the video feed alongside the control interface, allowing the driver to steer as if sitting in the car.

Minimising delay (known as latency) between capturing and displaying the video is critical it directly affects how controllable the car feels.

4. The Communication NetworkAll communication happens within a local network, created by a 5 GHz router dedicated to the project.
This ensures:

• Low interference from other school Wi-Fi traffic
• ​A consistent IP address range for easy connection
• Minimal latency due to short transmission distance

Unlike an internet connection, this local network does not require cloud access — everything operates inside your own closed system.
5. The Feedback LoopThe car constantly receives inputs and provides feedback:

• Inputs: Speed and steering commands from the PC
• ​Outputs: Physical motion of the car and live video feedback

This continuous cycle of control and response forms a feedback loop, which is the foundation of teleoperation and autonomous systems alike.