Sunday, 11 October 2015

Simple Arduino Robots for Kids - Part 1

Simple Arduino Robots for Kids - Part 1

I want to share this series of articles on fun things to do with a simple tricycle-layout robot with two drive wheels.

I start by building a basic remote control car, then use this to engage kids' interest in adding autonomous behaviours and more components.

Simple Arduino Robot

Ask your kids what they they want to add next, they might surprise you.

The robot is based around the "Differential Drive" layout, where there are two independently driven wheels, and steering is achieved by varying wheel speed.

You see this pattern in a lot of places, for example:

  • Star Wars' R2D2
  • Roomba and imitators
  • Most small e-bay robot chassis (see below)
  • Tanks and other tracked vehicles (including WALL-E)
  • Segways and other self-balancing vehicles

The advantages of this arrangement are simplicity (only two motors, no steering linkage) and nimbleness (can turn on the spot). The disadvantage is that if the wheels aren't turning at the same speed, the vehicle will not run straight. The disadvantage can be overcome using closed loop feedback of some kind.

Simplest possible case - two motors, no feedback

You can get a long way with two well matched motors and no feedback (and if your motors aren't matched, you can maybe get away with correcting for the mismatch in software).

We will use this arrangement as a starting platform to be embellished in future articles. For now, we will build a working robot with the least number of parts.

Assemble your chassis

The chassis kit from ebay comes with decks, spacers, screws, wheels and motors. Kids can assemble it with minimal help.

Basic Chassis kit from eBay Chassis rear view Chassis Underside

You will need to solder some short wires (about 8cm) to the motors.

Begin fitting the electronics

All the electronic parts can be found at or other hobby electronics supplier.

You need an Arduino board, a Battery pack, some breadboards, a dual-channel motor controller, and a Bluetooth module. You'll also need some breadboard jumper wires. There are links to parts sources above.

Electronic Parts

Fit the motor controller

Start by connecting the motor wires to the motor controller, using a small screwdriver.

Connecting the motor drive Motor driver connected

Fit six female-to-male jumper wires to the motor controller, and secure it in place with a cable-tie. You can put it in any position that is easy to secure.

Jumper wires for motor driver

Fit the battery

Secure the battery box over the front wheel using a cable tie. Feed the wire up to the top deck through one of the holes.

Fit the battery

Connect the Arduino

Here I use a small 5x5 breadboard as a power distribution bus, but you can dispense with this, and use spare rows on a single breadboard if you prefer.

I'm using an Arduino Nano compatible, but there is room for a full-sized board such as Arduino Uno if that's what you have.

Connect the motor driver

Connect your battery to the VIN pin on the Arduino. This will use the Arduino's on board regulator to reduce the battery voltage to the 5v needed by the microcontroller.

To reiterate the power connections

  • Battery connects to ground and VIN
  • Motor controller connects to ground and VIN
  • Bluetooth connects to ground and 5v
  • Anything else should connect to ground and 5v

Program the Bitlash firmware

Install the bitlash library from Open the "bitlashdemo" example by following the Arduino IDE menus to File -> Examples -> bitlash -> bitlashdemo. Select your board and port and program the sketch.

Connect the arduino serial monitor and you should see "Bitlash Here" plus more information and a command prompt. The bitlash demo defaults to 57600 bits per second as the serial port speed. If you have trouble with bluetooth later on, try changing the bitlashdemo script to use 9600 bps.

Connect the Bluetooth Module

You won't have much fun tethered by a cable, so we are going to use a Bluetooth radio to replace the USB cable.

The Bluetooth module has 4 pins, Power, Ground, Transmit and Receive. Connect power and ground to the 5v pin on the Arduino (NOT the unregulated battery nor VIN). The TX pin on the Bluetooth goes to RX on the Arduino, and vice-versa.

If you hook up a USB cable to your Arduino, you should temporarily unplug the Bluetooth module first, so that the Bluetooth and the USB bridge do not "fight" over the TX and RX pins.

Simple Arduino Robot

Pair the bluetooth module

Start out using your PC to talk to the bluetooth module. You can use a PC, Mac, Linux or Android. Unfortunately iPhone and iPad don't have general purpose bluetooth serial connectivity; later in this series we will look at other ways to use an iPhone to control the robot.

Use your operating system's bluetooth settings to pair the device. Then use the Arduino serial monitor, or any serial terminal program to connect to it. Pair your bluetooth module

To use the terminal app on Mac or Linux, you can do

$ screen /dev/tty.HC-06.Dev-B

On windows, try Hyperterminal.

Program some simple commands in Bitlash

The motor controller will drive each motor in forward or reverse, using two pins, A and B. The motor controller lables its pins IA1 IB1 (inputs A and B for motor 1) and IA2 IB2 (inputs A and B for motor 2).


At this point, it may turn out we hooked up one of the motors backwards. If the motor runs in the wrong direction, loosen the terminal block screws and reverse the wires.

Arduino Pins 2 and 3 are the A and B outputs for the left wheel

Arduino pins 4 and 5 are the A and B outputs for the right wheel.

Later in this series we will use Pulse-width-modulation and the analogWrite function to control speed of the wheels. For now, we have stopped and full speed.

We define six basic bitlash commands to control the motors

  • lfwd - left motor forwards rotation
  • lrev - left motor reverse rotation
  • lstp - left motor stopped
  • rfwd - right motor forwards rotation
  • rrev - right motor reverse rotation
  • rstp - right motor stopped

Paste these commands into bitlash, put the robot up on a block (or disconnect the wheels) and try them out. Make sure you run 'iosetup' first. You may need to stop and rewire the motors if the wheels turn in the wrong direction.

function iosetup { d2=d3=0; pinmode(d2,1); pinmode(d3,1); d4=d5=0; pinmode(d4,1); pinmode(d5,1); }

function lfwd {d2=1;d3=0}
function lrev {d2=0;d3=1}
function lstp {d2=d3=0}

function rfwd {d4=1;d5=0}
function rrev {d4=0;d5=1}
function rstp {d4=d5=0}

Once you are satisfied that the motors are working, we can move on to some higher-level behaviours:

function fwd {lfwd;rfwd}
function rev {lrev;rrev}
function stp {lstp;rstp}
function ltr {lrev;rfwd}
function rtr {rrev;lfwd}

function navsetup {a=40; b=120}
function l90 {ltr; delay(b); stp}
function r90 {rtr;delay(b);stp}
function l15 {ltr; delay(a); stp}
function r15 {rtr;delay(a);stp}

function startup {iosetup; navsetup}

Since we are going to do without motor feedback for now, we will achieve controlled turns by guessing how long to run the motors. I arrived at 40ms for a 15 degree turn, and 120ms for a 90 degree turn. Adjust the values of variables a and b until you get good results.

Try to drive your robot around using the bitlash commands. I got quite good at this after a bit of practice.

Control the robot with an Android phone

You can replace "fast typing and crashing a lot" with an Android phone. Download the BlueTooth Serial Controller app, which lets you define buttons to send each of the commands above.

Set up Android app to control

Use the app settings (spanner icon) to name and configure the buttons as shown. Each button should send the command, plus a new line.

To connect to your robot, tap the magnifying glass icon and look for your bluetooth device. When you have connected the light on the bluetooth module will stop flashing and become solid red.

Have fun!

Now you have a robot that you can drive around.

What next?

In future articles we will look at some variations and improvements

  • Using a hobby radio control transmitter and receiver instead of bluetooth
  • Using and internet connection and an iPhone
  • Implementing closed-loop feedback for more precise steering
  • Adding sonar and infrared collision sensors
  • Adding First Person View video camera
  • Scaling up to bigger platforms
  • Becoming autonomous, and more

Saturday, 10 October 2015

Make a 5 volt battery supply for any Arduino

Make a 5 volt battery supply for any Arduino

Make a 5v battery from a 9v battery snap.

Powering your Arduino from a 9v battery and the built-in linear regulator is inefficient; 9v batteries have very low energy capacity, and
using a simple linear regulator (perhaps 60% efficient) wastes much of it. 9v batteries are also quite expensive compared to other battery types.

A switching regulator can be over 95% efficient. 14500 Lithium cells, which are the same size as AA cells, but deliver 3.7v each, are much more cost effective in the long term than disposable alkaline cells.

This project shows you how to make a regulated 5v supply that is about the same size as a 9v battery, and which you can connect direct to the 5v pin (NOT the power socket, nor the VIN pin) of your Arduino or other circuit.

Gather the parts

Tiny voltage regulator module

The core of the circuit is this regulator module which will take up to 23v in and output from 1 to 17 volts depending on adjustment (as long as the input is higher than the desired output). It costs less than a single 9v battery.

You also need a battery snap, some heat-shrink tubing, and a battery of some kind. I recommend a 2xAA holder holding two 14500 lithium cells, which are rechargeable 3.7v Lithium Ion cells and cost less than $5 a pair.

Assemble the parts

Begin by selecting some heat-shrink tubing of the appropriate size, and punching two holes for the battery connectors.

Preparing to punch holes

Punching holes

Prepare to assemble a 5v regulator

Then cut and solder the battery snap wires to the regulator.

Wiring the regulator

Connect the regulator and adjust the trimming potentiometer with a small screwdriver until the output reads 5 volts. Disconnect battery.

Adjusting the output voltage

Fit the heatshrink over the battery snap, then feed the battery snap wire and the regulator module into the heat shrink.

Fitting the regulator into the tubing

Use a heat source to shrink the tubing. You don't have to be obsessive, just shrink until snug.

Shrinking the tubing

Use your assembled battery

Make a 5v battery from a 9v battery snap.

A handy tip for when working with 9v battery snaps, when you need to switch on and off, just connect ONE pin, and rotate the snap until the snap makes contact with the outside of the other pin to turn on. You can rotate the snap to bring the pins apart to switch off.

Using a 9v battery snap as a switch

Remember, you have your own high-efficiency low-dropout regulator, so you do not need to use any regulator built into your Arduino, you can connect direct to the ground and 5 lines.

Power an Arduino from 5v

Monday, 5 October 2015

iPhone + Blynk = Keyless house entry

Blynk App to open door

Somehow I missed hearing about Blynk when it was a thing on Kickstarter in early 2015.

Fast forward 6 months and it's in the field and while it's still early days, Blynk looks like a load of fun.

I've been working on a keyless entry system for my house, because I've always wanted to be able to just push a button and come in, like modern cars. A friend gave me some leftover parts when he moved house, including a solenoid striker plate. I replaced my front door recently during a renovation, and decided to install the lock hardware at that time.

As someone who remembers how difficult and expensive electronics was in the 80s, the age of Smart Objects is exciting. You can basically plug together a selection of off-the-shelf modules without having to pick up a soldering iron. Now Blynk brings the same convenience to the software side.

While I learned to code in Assembler, and I learned electronics at the transistor level, I don't miss either.

Blynk is an app for iPhone and Android which connects Things to the Internet. It uses a cloud service to make your device accessible, or you can run your own server. The intended devices are ethernet or wifi connected microcontrollers such as the Arduino. In my case I'm using a board based on Arduino nano, tethered to a Raspberry Pi over USB. I find the combination of a Pi for brains and an Arduino for 5 volt-io-and-replaceable-if-you-smoke-it brawn is the sweet spot in robotics and automation projects.

The hardware

Home Automation Hub

PIR sensor and LED light strip

Solenoid door striker

Raspberry Pi single-board PC: This computer is my home automation hub, it connects to cameras sensors and actuators around my house.

Arduino Nano: while the Pi has its own IO pins, they're unbuffered 3v and a little too easy to blow up. I prefer to use microcontrollers of various kinds as a "hind brain" for my Pi projects.

Relay board: an inexpensive module that holds several 5 volt relays, which are controlled by outputs pin of the Arduino.

Solenoid door strikeplate when the 12v solenoid is energized via one of the relays, the door opens with a light push

Passive Infra-Red (PIR) Sensors two sensors will detect movement near the door, for automatic lighting.

LED light strips: Another relay energizes constant-current LED driver circuits that power two 8-watt LED strips.

Arduino Pin assignments

  • D2 (output) Relay A, the door solenoid
  • D3 (output) Relay B, the LED lighting array
  • D4 (input) PIR Sensor A, internal movement sensor
  • D5 (input) PIR Sensor B, external movement sensor
  • D6 (input) Reed Switch, for open door detection

Prototyping the software - Arduino plus Bitlash

Blynk keyless entry breadboard prototype

I've been using Bitlash for quick prototypes, it's an interpreted language resembling C that runs on the Arduino platform. The following bitlash functions allowed me to test and tune a working model of the system on a breadboard.

function startup {iosetup; run getpir; run lights; run lockdog };
function iosetup {pinmode(2,1); pinmode(3,1); pinmode(13,1); d2=d3=p=d=0 };

function getpir {p=d4|d5; d13=p; snooze(100) };
function lights {if (p) {d3=1; snooze(30000)} else {d3=0; snooze(250)} };
function lockdog {d2=d; if (d) d=d-1;d2=d;snooze(1000) };

function unlock {d=10 };
function lock {d=0 };

The system polls the PIR sensors every 100ms, and if the sensors detect movement the LED lights are turned on for 30 seconds, then off again. (By which time you have opened the door and turned on the house lights). If the 'unlock' command is given, the solenoid is activated for 10 seconds. (It turns out 5 is plenty).

Installed version - Arduino plus Blynk

Blynk App to open door Automated front door

The installed version of the application uses a timer to inspect the sensors 4 times per second. When a motion event is detected, the lights are activated. Every sensor is pushed to Blynk, and there are "Virtual Pins" configured for Blynk to activate the relays.

Blynk uses Virtual pins for pushing events to the cloud and also for sending actions to the Thing.

In this case the sensors, light and lock status are pushed on pins V0,V1 and V2, while the lights and lock can be actuated by writing to pins V3 and V4.

Virtual pin v5 is the "whoops, did I leave the front door open" sensor, for those moments when you get to the end of the street and think "I don't remember if I locked the door!".

Code is at github.