3D Printed RC Tank
I’ve been working on a new remote controlled tank in my spare time. My goal with this project is to make a cheap, printable RC tank kit. This post goes back and forth between talking about the tank, and a basic tutorial on how the components and code work together.
Currently it’s a working prototype. The tank uses an Arduino Nano clone (ATmega328) as the primary board. An L298n H-Bridge is used to control the left and right motors independently, allowing it to quickly turn or revese. It uses the HC-06 Bluetooth module to receive commands. The power comes from two 18650 batteries that are connected in series.
Hardware:
I purchased the majority of the hardware from Aliexpress, because it’s so cheap. The links below are to the stores that I used, but you can find the same parts on many websites other than Aliexpress.
- Arduino Nano V3 Clone ( AtMega328p ) – Link
- L298n H-Bridge Motor Controller – Link
- HC-06 Bluetooth Module – Link
- 2x DC Motor + 64:1 Gearbox – Link
- 2x 18650 Battery – I took mine from an old laptop, wired them in series for 7V+
- 1x 500mA Polyfuse – Optional, put between power source and VIN
I salvaged some steel weights from an old set of window blinds, and super-glued them to the base to add some weight.
Frame:
The frame of the tank was printed as a solid piece. There are four mounting spots for wheels. The two at the front are designed so that small bearings will slot into them, so that the front wheels spin freely. The other two of the mounts are designed to hold the gearbox motors. I made a T-shape in the center of the frame so that I can mount a breadboard on top of the frame. The frame design leaves much to be desired, it’s much too thin and flexible.
The front and rear wheels have teeth that are spaced out, so that they catch on the inside of the cable-chain tracks. The teeth are tapered slightly to keep the tracks aligned, and there is a guard on the front wheels to ensure that they stay on. The battery holder has holes in the sides and bottom so that wires can pass through. Screws hold the wheels in place.
Schematic:
The Arduino and L298N are powered using two 18650 batteries. These are fairly common rechargeable batteries, with an output around 3.7V. I wired my batteries in series. My schematic says 7.2V, that’s a typo, it’s really 7.4V+. I use the VIN pin on the Arduino Nano to power the chip.
The 5V output on the Arduino powers the HC-06 module. Make sure that you’re using an HC-06 module with a breakout board like mine, so that it is 5V tolerant. This is because the raw HC-06 chip is NOT 5V tolerant.
Pins 2 and 3 are connected to the HC-06, and pins 4 through 7 are connected to the L298N. On the L298N, pins ENA and ENB are used for PWM control of the outputs, so that you can achieve finer speed control. I don’t utilize these, so they are set high.
Code:
There are only two main components to control other than the Arduino itself, they are the HC-06 and the L298n. The HC-06 is going to receive data from an external source, and then pass it to the Arduino. Then the Arduino will make a decision, and send signals to the L298N to turn on the motors.
There is a link at the bottom to download the full code, or read through and copy/paste the example blocks.
Startup:
The program imports the SoftwareSerial library, and establishes pins for motor control. A char named btData is used to handle incoming Bluetooth data. Then pins 2 and 3 are declared as RX and TX using SoftwareSerial.
//SoftwareSerial library is included so that we can utilize pins 2 and 3 for the HC-06
#include <SoftwareSerial.h> //Pins 4, 5, 6, 7 used for motors.
const int motorRF = 4; //RF = Right motor, Forward direction
const int motorRR = 5; //RR = Right motor, Reverse direction
const int motorLF = 6; //LF = Left motor, Forward direction
const int motorLR = 7; //LR = Left motor, Reverse direction
char btData; //char used for bluetooth data - receives commands like "1", "2", "a", etc.
SoftwareSerial HC06(2,3); //RX, TX - Pins 2 and 3 used for HC-06 Module
Setup:
Serial communication is set up, and a string saying “Hello” is sent as a self-check. Then digital pins 4, 5, 6 and 7 are declared as outputs, in order to send signals to the L298n.
void setup() {
HC06.begin(9600); //Begin serial at 9600 baud as "HC06"
HC06.println("Hello."); //Sends "Hello." through serial, to acknowledge startup
pinMode(motorRF, OUTPUT); //Sets pins 4 through 7 to OUTPUTs, to control the L298N
pinMode(motorRR, OUTPUT);
pinMode(motorLF, OUTPUT);
pinMode(motorLR, OUTPUT);
}
Loop:
The loop works by cycling until data is available at the HC-06 module. When data is received, it enters the loop and then makes decisions. In this case, I use the numbers 1 through 4 to control the state of the L298N. When a ‘1’ is received, the Arduino sets pins 4 and 6 to HIGH, so that the L298N enables the outputs in a manner that turns both motors forwards. I use a delay function, so that it keeps the motor on for a second.
void loop() {
//Loops until data is sent to HC06
if (HC06.available()){ //When data is available in the HC06, do this
HC06.println("Reading."); //Prints "Reading." through serial, to acknowledge incoming data
btData = HC06.read(); //Reads "HC06" and stores the value into the char "btData"
if (btData=='1'){ //If the HC-06 receives a 1, do this
HC06.println("Forward."); //Sends "Forward." through serial, to acknowledge that a 1 was received
digitalWrite(motorRF, HIGH); //Activates the motors so that the tank moves forwards
digitalWrite(motorLF, HIGH);
delay(1000); //Delays for approximately one second
}
if (btData=='2'){ //If the HC-06 receives a 2, do this
HC06.println("Reverse."); //Sends "Reverse." through serial, to acknowledge that a 1 was received
digitalWrite(motorRR, HIGH); //Activates the motors so that the tank moves backwards
digitalWrite(motorLR, HIGH);
delay(1000); //Delays for approximately one second
}
if (btData=='3'){ //If the HC-06 receives a 3, do this
HC06.println("Left."); //Sends "Left." through serial, to acknowledge that a 1 was received
digitalWrite(motorRF, HIGH); //Activates the motors so that the tank rotates left
digitalWrite(motorLR, HIGH);
delay(1000); //Delays for approximately one second
}
if (btData=='4'){ //If the HC-06 receives a 4, do this
HC06.println("Right."); //Sends "Right." through serial, to acknowledge that a 1 was received
digitalWrite(motorLF, HIGH); //Activates the motors so that the tank rotates right
digitalWrite(motorRR, HIGH);
delay(1000); //Delays for approximately one second
}
digitalWrite(motorLF, LOW); //Turns all of the motors off, by setting everything to LOW
digitalWrite(motorLR, LOW);
digitalWrite(motorRF, LOW);
digitalWrite(motorRR, LOW);
}
}
Download the full code here.
Connecting to the HC-06
I use the mobile app Bluetooth Electronics to connect to and send commands to my HC-06 module. I like using my phone since I can follow the car around. You can also use PuTTy, or another program to send serial commands to the HC-06 from a laptop or desktop.
The HC-06 becomes available for pairing when it is powered on. Pair your device with it, using the default password of “1234“. Once your device is paired with the HC-06, you’ll be able to connect to it using your program of choice.
To connect to it using Bluetooth Electronics, make sure that you’ve paired your device with the HC-06 and then open Bluetooth Electronics. Click “connect” at the top, and select your HC-06 from the list. Assuming you wired it correctly and it’s paired, you will now be able to send commands to it through the app. The app makes it incredibly simple to create a customized GUI for sending commands to the tank.
Future Design Ideas
I plan on making a lot of changes to this tank. I’m going to redesign the majority of the frame and the connection points on the wheels so that they are stronger. I want to increase the number of batteries to 3, so that it’s capable of higher speeds. The battery holder design is a little bit too short, requiring tape to stay closed, so I’ll fix that in the next revision.
I am working on a standalone program so that the project can be controlled in an easier manner. Instead of having it drive for predetermined lengths of time according to command-line strings, I plan on having a GUI with realtime feedback. There are a lot of options for making a program like this. I have been experimenting with python to some success, but I might resort to using one of the many application builders that are available. For right now, the Bluetooth Electronics app meets all of my requirements so I’ll continue down that path until I need more complicated functionality.
A great upgrade for the system would be to use an ESP8266. It would provide greater control options, and it would lower the cost and footprint. The extreme simplicity of the Arduino and HC-06 combination make it very easy to use and adapt, so I am going to continue using it for this project. Plus, I have a bunch of Nanos and HC modules sitting in a drawer collecting dust; it’s about time I turned them into something. My next RC vehicle project will hopefully utilize wifi.
More on this project is coming.
Thanks for reading!
