Arduino RC Tamiya

Arduino RC Tamiya – Part 2

In the previous post the Tamiya RC car was built and we covered the electronic components. This gave us the knowledge required to look at replacing the factory components and control the RC car via code! Now let’s look at adding an Arduino for custom functionality.

Setting up the hardware

For this step I will be using an Arduino board to replace the receiver. This means the car will no longer have any radio transmission. Instead the servos and electronic speed controller will be controlled via code written to the Arduino board.

I’ve chosen to use the Arduino Uno WiFi Rev2 board because it has the required power and functionality. It also has the added bonus of WiFi which will be useful to enable Internet remote control of the car. Take a look at the above link for more information on the technical specification of the board.

I also bought an Arduino Proto Shield Rev3. With some soldering this will sit on top of the Arduino Uno board and allow custom ports and wiring. The servos can then be quickly plugged in or unplugged.

Arduino Uno WiFi Rev2

The first step is to act on the above and do the custom modification to the proto shield. This involves adding two 3 pin connectors to the board over the 5V, gnd and 8, 9 digital inputs. You can see the outcome of doing that in the following photos:

Both the three pin connectors shown allow for a servo and electronic speed controller to be directly connected, powered and controlled by the Arduino.

Writing Arduino code

We are ready to write and apply some custom code to the logic. I highly recommend that you try your code with the servos not connected to RC car parts to begin with. It is far too easy to accidentally upload some code that runs a servo at full speed and your fully built RC car flies off your desk and cables rip apart, drinks go flying and screens smash etc… I warned you!!

At this point we can open up the Arduino IDE to start writing some c++ code. There’s many tutorials out there on how to use this IDE to upload code to the board and it’s straightforward. A quick Google will get you on the right track.

The first step to setup the code is to declare which digital pins the two servos are connected to. I mentioned earlier that I’ve chosen to use pins 9 and 10. If you have good eyesight you might be able to see that on the board in the photos.

Fortunately there’s an Arduino Servo class ready for us to implement:

#include <Servo.h>

Servo steering;
Servo throttle;

void setup()  {

Our first movement

Simple, now we have two Servo variables that we can write to and control the physical Servos. The next tricky bit is figuring out the ranges of your Servo, most Servos range from 0 to 180. In the acceleration configuration there’s a neutral range around 90-100 with forward and reverse above and below those ranges respectively. The higher or lower the value from the neutral the faster your speed. In the steering servo configuration 90 is straight, 0 -> 89 is left and 91 -> 180 right. The higher this value the tighter the turn.

The below is a very simple script to demo forward movement and stopping. The car will first steer straight and then move forwards at a slow speed for two seconds before stopping for five seconds. This gives us a few seconds to grab the car before we realise our speed controller works in a different range and accelerates into the nearest wall at full speed… (you’re testing without the Servos attached to the car though, right?!).

#include <Servo.h>

Servo steering;
Servo throttle;

void setup() {
    // Before we move the car, reset the steering

void loop() {
    // Accelerate forwards at a slow speed for two seconds

    // Enter the neutral range for 5 seconds

If the above was a success we can try getting our car to turn around in circles by itself. The following code will repeat an automated three point turn:

#include <Servo.h>

Servo steering;
Servo throttle;

int accelerationSpeed = 89; // Slowest accelerate speed 90
int reverseSpeed = 104;     // Slowest reverse speed 102
int neutral = 91;
int brake = 180;

int noTurn = 90;
int leftTurn = 0;
int rightTurn = 180;

bool debug = true;

void setup() {
    if (debug) {

void Logger(String message) {
    if (debug) {

void MoveBackward() {
    Logger("Move: reverse");

void MoveForward() {
    Logger("Move: accelerate");

void Brake() {
    Logger("Move: brake");

void Stop() {
    Logger("Move: stop");

void SteerLeft() {
    Logger("Steer: left");

void SteerStraight() {
    Logger("Steer: staight");

void SteerRight() {
    Logger("Steer: right");

void loop() {



You should now have an RC car that does something similar to the one I made in this video:

That’s all for part two. Have a play around with the code and see what you can make the car do. There’s a couple of projects out there that have incorporated sensors at this point. They would stop the cars movement before it drove into anything. That could be quite useful functionality if you’re looking for more small additions.

I’ve created a GitHub repository for the above code samples and I’ll be adding more along the way. Check it out:

Stay tuned for part 3 coming in the near future. The next step will be using the WiFi on the Arduino board to allow remote control over the Internet.

Arduino RC Tamiya Car

Run for Heroes 5K

With the current COVID-19 lockdown situation it can be all but too easy to accidentally stay in your home for a few days without doing any of your permitted daily exercises. I’m guilty myself of submitting to the mindset of “Oh I’ll just go running tomorrow…” and then never actually making it out the door.

Thankfully there’s a great incentive right now to get people up and moving, the Run for Heroes challenge and it’s very simple too! All you have to do is run 5K, donate £5 and then nominate 5 of your friends to complete the challenge too. This results in people staying fit and also much needed funds for our NHS Worker heroes who have been going above and beyond for all of us.

I did my 5K yesterday and now it’s your turn to step up to the challenge because I nominate you! Go and enjoy the nice weather and get some lovely fresh air. Even for non runners it’s a great time to give running a try, you don’t have to bit fit and you don’t have to run fast, it’s just about doing your best and enjoying it, even if that’s walking most of the distance!

Run for Heroes Instagram:

Remote Control Arduino Tamiya

Arduino RC Tamiya – Part 1

This is my first blogged side project and it’s quite an exciting / fun one. I hope this set of posts inspires you to get involved and give it a go yourself.

What is this project?
This project is about taking a standard remote control Tamiya and replacing the electronics (in particular the receiver) with an Arduino. This then allows the introduction of custom C / C++ code so we can do anything we want with the RC car! One particular interest I have is to make the RC car remote driveable, via Wifi for example so that friends can drive around my location. Once that works there’s a future step to add a mounted phone to the car with an app that would allow friends to have a telepresence.

Why would you do this?
There’s two reasons for this, the first being that we’re currently stuck in-doors due to Coronavirus (COVID-19) and there’s nothing to do so I need something to keep my creative and constantly logic solving mind at peace. The second is that when I was 11 years old I received and built my first Tamiya, a TL01 and have missed crashing it into things. What better way to get back into that then let a robot drive into things at full speed… Okay I’ll try to avoid that but robotics and programming can create some interesting scenarios.

What’s the plan?
As of writing I’ve already dived head first into this project so firstly I need to update on my progress so far, here goes:

The first step is to get some sort of remote control car that uses electronic components that are easy to get at and modify. As I have experience with Tamiya I know exactly how these cars work and the parts included, due to the lockdown I also knew I’d enjoy the building bit so I went with the Tamiya Grasshopper. This is very much a hobbyist level entry RC car but for this projects that’s perfect, I didn’t want to spend too much and ideally I don’t actually want or need it to be fast.

I already have the radio equipment and car electronics from previously so I didn’t need to invest in more of that but this is the build list so far:

  • Tamiya Grasshopper
  • 1x Futaba T2ER controller (this has lasted 19 years at time of writing)
  • 2x NI-CD 7.2V batteries at 1800MAH and 3000MAH
  • Lots of random electronic speed controllers
    • Xtra Ripmac QUAKE
    • LRP Runner plus reverse digital
    • Tamiya TBLE-02S
  • Lots of random servos
    • Futaba
    • Hitec
  • Futaba FP-R122JE receiver with 40Mhz green crystal

The Grasshopper arrived and I spent an afternoon reminiscing how pleasurable and often extremely frustrating it is building kit RC cars. If you’ve never done this step then I highly recommend it, starting out with plastic moulds and finishing off with quite a powerful little car is very satisfying!

So that’s the first stage complete, I have a built and working remote control car that I can begin to adapt.

The car currently functions as normal with all the default parts an RC car has. To go through those quickly we have the receiver, this talks to the remote control and receives the transmission of data from the throttle and direction sticks. It sends this data to either the servo that controls the speed or the servo that controls the steering. Servos are small mechanical servomotors that contain a motor and gears, they perform movements such as rotating to push and pull steering rods. Most RC cars will have two by default, one works to steer and the second would control the speed via a manual speed controller, these have now mostly been replaced with electronic speed controllers so you’re more likely to only need a steering servo. The electronic speed controller does what it says on the tin, the receiver sends the speed related data to it and it tells the motor how fast to rotate, when to stop and when to put that car into reverse. Lastly connected to this is the battery that powers all of these components.

That’s all for step 1, we now have everything needed on the RC car side setup and working so we can begin to hack away with the electronics. In step two I will go into detail on replacing the receiver with an Arduino and how we can wire the servos into the Arduino so that we can program them to control what they do.

Part 2 is now available:

Hello World

As with all new blogs that feature a level of tech talk, Hello World!

I’ve decided to have another go at writing a personal blog, I’ve written a few over the years included topics not limited to: Arsenal, getting started in Web Design and running 500 miles for charity. However they’ve never stuck around due to a mix of server migrations / breakages and a loss of interest in the topic. I’ve decided this time to make it a bit broader and implement a more reliable back-end setup to ensure it sticks around!

So what will this blog be about then if you’re not picking a particular subject? Good question, it’s going to be a mix of all my interests; a bit of work, coding, sport, random side projects, etc. Hopefully it will end up quite diverse but also somewhat interesting to people.

Enough rambling, let’s go down to some serious blogging.

See you in the next post!