EasyRC - Open-source RC Platform

Remote-controlled vehicles have fascinated me since I was a little kid. Nowadays, I’ve not only grown up, but also become a parent. And what better way is there to play with your kids and teach them new things than being able to do so with your own hobbies and interests? Therefore, I’ve decided to develop EasyRC: A simple, open-source platform for remote-controlled vehicles. It’s suitable for kids who want to play with an RC car, for teenagers who want to build their own RC car, and for anyone who wants to start with 3D printing, DIY electronics, and programming.

What’s the idea behind this platform? EasyRC is a fully open-source platform for a self-made RC car. It encompasses the design files for printing the 1:16-scale car and its remote control, includes the files for the circuit boards, and comes with a detailed manual that includes part lists, assembly instructions, background information, and much more. EasyRC is designed with ease of access in mind, meaning it is safe as a toy for kids (max. 10 km/h, suitable for indoor use, and sturdy enough to withstand quite a few crashes without damaging furniture). Despite the safety aspect, I also tried to keep the project costs low (around 100-150€ including filament, PCB manufacturing, electronic components and metal parts).

Some compromises were necessary during the development of this RC car, like sacrificing performance for safety and a small footprint. However, building it a bit smaller and slower than my previous projects also means it is significantly more durable. Taken together, EasyRC is a fully functional RC car, including an open differential and Ackermann steering, and it allows you to build your own RC car from scratch: Custom electronics, self-made 3D printed mechanics, and a printed chassis. With the detailed assembly instruction, it is great for beginners – but some fundamental experience with soldering and 3D printing is still helpful.

As all parts and codes for this project are available open-source on GitHub, you can build the car as described here, but also use it as a starting point for your own developments. You’d like to modify the chassis, upgrade it to a more powerful motor, or switch from a car to a truck, with some additional actuators? At some point, there will be limitations, like the tiny ESP32-C3 running out of pins, but when you dive into this topic, it’s part of the hobby to look for solutions on how to circumvent these issues.

This Instructable is designed as a summary and teaser for this project, because you can find a detailed 90+ page manual in its GitHub repository that describes the project’s concept, includes a full assembly guide, covers the programming, and lists all the parts needed to build EasyRC. Enjoy this project, let me know your feedback, and please share your builds with me!

EasyRC is designed to use as many standard components as possible so that a few tools are sufficient to complete the project. The two most expensive and largest tools needed for this project are a 3D printer (print bed with a width/length of 220 mm) and a soldering iron. Also, you’ll need the typical set of tools for wiring electronics: Wire strippers, crimping pliers, side cutters, and tweezers. Besides that, only a set of metric Allen keys is needed. The required consumables are solder, isolating tape, and some grease for the gears.

The EasyRC manual is available in German and English. It contains a detailed list of all commercial components (screws, nuts, bearings, electronic components). Along with the manual, the GitHub repository includes the bill of materials for all parts, the files for the printed parts (.stp files you can modify), and the Gerber files for the PCBs. The printed parts can mostly be printed from standard plastics such as PLA or PETG. A few flexible parts need to be printed from TPU. Those files are labeled accordingly. Particularly for the tires, it is helpful to use an as-soft-as-possible TPU, which improves the traction. I ended up with Shore 82A TPU, which is the softest filament that my Prusa i3 MK3S can handle.

Vehicle:

1. Size: 282x125x95 mm³ (LxWxH)
2. Scale: 1:16
3. Weight: approx. 1 kg (including batteries)
4. Microcontroller: ESP32-C3
5. Wireless communication: 2.4 GHz (ESP-NOW protocol)
6. Motor driver: Pololu DRV8876 (QFN)
7. Drive motor: JGA25-370 brushed DC motor with 1:10 gear reduction (12 V, 1.000 rpm)
8. Speed: max. 10 km/h
9. Steering servo: MG90S metal-gear micro servo
10. Power supply: 3x 18650 Li-Ion battery (11.1 V)
11. Power consumption: approx. 3-6 W during driving; 0.8 W in idle
12. Reverse-polarity protected battery connector
13. Overcurrent protection (self-resetting fuse)
14. Acoustic warnings: low battery (<10.2 V), connection loss (>1 s without connection), AFK (>1 min without user inputs)

Remote control:

1. Size: 80x40x41 mm³ (LxWxH)
2. Weight: approx. 125 g (including battery)
3. Microcontroller: ESP32-C3
4. Wireless communication: 2.4 GHz (ESP-NOW protocol)
5. Joystick: Alps 10k (Playstation 4 model)
6. Power supply: 1x 18650 Li-Ion battery (3.7 V)
7. Power consumption: approx. 0.5 W
8. Reverse-polarity protected battery connector
9. Self-calibrating joystick
10. Data rate: 20 Hz (user inputs are transmitted to the car every 50 ms)
11. Low battery indicator (<3.4 V)

The electronics are the core of a remote-controlled vehicle. A pair of a transmitter and a receiver is needed that can read analog input devices (like joysticks) in real time and send this data to the receiver, as fast and as reliably as possible. The receiver then has to convert this data into actuator outputs to let the car move. Besides this basic functionality, the electronics should be as small as possible to fit into small models and as affordable as possible. There are commercial products available, but EasyRC shall be an open platform, without the constraints of proprietary hardware and software.

Therefore, EasyRC employs the ESP32 microcontroller, which includes most of the required functions for this application: the ESP32 has built-in WiFi for wireless data transmission, analog-to-digital converters to read sensors and user inputs, and freely adjustable PWM outputs that allow direct control of RC servos. All of these functions are available in tiny form factors, such as the Xiao ESP32-C3, which is used in both the remote control and the car. This developer board is installed in custom-designed circuit boards that fit all required external components. Assembling the boards can be done straightforwardly by hand, since only THT components are used (no SMD components, which can be frustrating for hand soldering).

The ESP32-C3 in the car is used to its limits: it controls the steering servo, the electric motor for propulsion, the turn signals, the tail lights, and the piezo buzzer, and it measures the voltage of the car’s batteries. Controlling the steering servo, the main motor, and the piezo buzzer requires different PWM frequencies. This is a particular strength of the ESP32 microcontrollers, since they can handle different PWM channels and allocate them to various GPIOs. Nonetheless, I encountered a limitation. I could only operate two different PWM frequencies at once, meaning the car could drive and steer but not operate the piezo buzzer at the same time. Still, the piezo buzzer can be used as the car’s “horn” when the car is standing still.

The remote control reads the joystick and sends this information to the car every 50 ms, which corresponds to a data rate of 20 Hz. This rate could be set even higher, but given the car’s limited maximum speed, I considered this data rate sufficient. Higher rates would unnecessarily increase the microcontroller’s power draw. The microcontroller uses the ESP-NOW protocol, which operates on the 2.4 GHz WiFi frequency, but does not require it to be part of an existing network. Instead, two ESP32s can directly communicate with each other. Here, I’ve programmed the receiver to check the transmitter’s MAC address. This feature enables pairing the transmitter and receiver: the car can only be controlled by the remote control if the correct MAC address is set in its code. Hence, it is possible to use multiple EasyRC simultaneously by assigning each pair its own unique set of MAC addresses.

More details about the electronics are provided in the EasyRC manual in chapter 3. Information on how to change WiFi channels or MAC addresses is available in chapter 9.

The car and the remote control can both be printed with standard FDM printers. My prototypes are printed in PETG, which is very easy to print and sufficiently durable for parts exposed to mechanical loads. The remote control only required six printed parts and is built around its circuit board and battery holder. The car requires a lot more parts, but everything can be printed on a standard-sized printer. The longest prints are the two parts that make up the car’s body. I designed the car with easy maintenance in mind: no glue is needed, and all parts are assembled with screws and nuts.

The remote control follows a minimalist design: a single joystick provides throttle and steering inputs, allowing the car to be controlled with one hand. I opted for a joystick module as it is used in game console controllers because its quality is better than that of thumbstick modules available on their own breakout boards. Therefore, the car can be controlled very precisely, although some practice is needed, as RC cars are typically controlled with separate joysticks for throttle and steering. Here, however, I opted for the smallest possible size, which also helps keep the overall cost low.

The car follows the same principle, at a 1:16 scale. At this size, it is slightly smaller than A4 paper, which means the amount of filament needed for printing is much smaller than for larger 1:10 or 1:8 models. Due to the small size, I decided to skip implementing shock absorbers: EasyRC is designed for indoor use, where shock absorbers are not necessary. This decision means there is plenty of space available to fit the steering and differential, both of which follow real-car principles. The steering employs Ackermann geometry, meaning the steering angle of the inner wheel is greater than that of the outer wheel, which improves traction in tight turns. The open differential of the driven rear axis also helps with traction as it allows the inner wheel to rotate more slowly than the outer wheel while both are actively driven by the motor. More information on this topic is provided in chapter 4 in the manual.

The car is equipped with a full set of lighting. The headlights are always on, but the microcontoller controls the turn signals and the tail lights. Therefore, the car blinks left and right, depending on the requested steering angle, and the tail lights are dimmed while driving forward but at full intensity when braking and during a standstill. Also, there is the option to add more lights: Each light channel (headlights, left indicator, right indicator, and tail lights) can power up to four LEDs, but only two are installed per channel. Hence, if you want to change the chassis and add more light, no changes to the PCB are needed.

The car’s actuators are an MG90S micro-servo for the steering and a brushed DC motor with an integrated gearbox for driving. Here, I recommend the MG (“metal gear”) servo over the SG version with plastic gears as it lasts much longer. I initially operated the car with an SG90 servo, but it wears out within hours, whereas the MG90S lasts much longer. These servos don’t have much torque, but for this small scale and for indoor use, they are very well suited. The drive motor is a JGA25-370 motor, a small brushed DC motor with a 25 mm diameter and an integrated 1:10 gearbox. While it is possible to print a gearbox, I opted for this version to save space (printed gears must be comparably large to be sufficiently mechanically stable) and to improve the longevity of the drivetrain. The motor gear is pushed onto the D-shaped motor shaft, which works well for the low-power drivetrain. However, this gear may need replacement every now and then if the tight fit between the gear and the motor shaft wears out.

In the meantime, I’ve also designed a trailer for the car that can be connected by adding a trailer hitch to the car’s body. While that doesn’t match the design of this 90s/2000s sports car body kit, it is surprisingly funny and challenging to master reversing with a trailer only using a single joystick remote control! Let me know if you’re interested in these parts. If you’d like to get them, I can upload them to the GitHub repository, as well!

The car and the remote control both use the ESP32-C3, which can be programmed using different software. I opted for the Arduino IDE because it is well-developed and well-documented, and it allows beginners to progress quickly. As it is designed for programming Arduino microcontrollers, additional packages need to be installed to allow it to upload code to an ESP32 as well. The required procedure is described in detail in chapter 5 of the manual.

Programming microcontrollers for a project, or, more specifically, adjusting code of someone else to adapt it to your requirements, can be particularly frustrating. Understanding someone else’s code can sometimes take longer than rewriting it from scratch, which is why I tried to minimize the need to alter anything in EasyRC’s code. Hence, the main parts of the code are universally applicable, and only a few variables need to be adjusted to account for required modifications, such as steering calibration and fine-tuning of the drive characteristics. These lines, possible values for these variables, and their effect are described in detail in the manual.

The code design follows straightforward logic to allow this type of simple adjustment: the remote control sends these variables to the car, so the car’s code can be considered fixed. The remote control has a directly accessible USB-C port, allowing steering trimming on the fly while the remote control is connected to a computer. The car’s code only needs to be adjusted if its MAC address needs to be changed, when you want to operate more than one EasyRC car at the same time.

The code must run fast on the microcontroller, and data transmission must also be fast to prevent lag between user inputs and the car’s actuator movement. The fast ESP32 microcontroller and the fast ESP-NOW data transmission protocol meet these requirements. ESP-NOW has limited bandwidth, but it is perfect for sending small data packets as fast as possible, as it can even be configured to skip waiting for a confirmation signal from the receiver after sending data. Also, its transmission range is more than enough for this indoor RC car and can even be used outdoors as long as the transmitter and receiver remain in line of sight. Further, the data transmission is set to a single direction: the remote control does not receive any information from the car but only sends control inputs to the car. ESP-NOW allows configuring ESP32s as transceivers that can both send and receive data, but I omitted this option to keep the code and communication as simple and straightforward as possible.

EasyRC is designed for people who enjoy building their own projects but don’t want to spend a fortune in the process and are fine with the compromises needed in a DIY project compared with commercial products. With these considerations in mind, this project addresses only a niche, but I hope that whoever reads this Instructable up to this point belongs to this niche – and that you enjoy building this project! Also, keep in mind that completing this project equips you with a great toy for kids to play with, and later on they can learn to fix, rebuild, and modify it.

The car’s design, as well as its electronics and code, are open source, allowing everyone to reuse and modify them as needed. Whether it’s about another body kit, the above-mentioned trailer for the car, or even the upgrade to a truck, or a complete redesign of the PCB to let it control external high-performance motor drivers: EasyRC is not intended to be a final product but a starting point for whatever you can think of.

If you want to share your own design and modifications, I’ll be more than happy to hear about them! Also, if you encounter any issues with this project, please leave a comment or send me a message, and I’ll do my best to help you resolve any issues and update the manual accordingly. Hence, please let me know when you’re building or modifying this project, and don’t forget to upload your builds using Instructables’ “I made it” feature!