Wednesday, 24 August 2016

The Thirty Second Photo Studio

Do you need to photograph a small item? Couldn't be bothered setting up a studio soft-box?

Try this:

  1. Load about:blank on your web browser
  2. Crank the screen brightness to maximum
  3. Place one sheet of blank paper over your keyboard
  4. Position your item
  5. Lower the screen to light the item
  6. Snap, you're done.

Friday, 22 July 2016

Hot-Glue on Roses and Zip-Ties on Kittens

Here are A Few of My Favourite Things that I do when I am building a
multi-component installation.

When I need to turn a prototype into a working installation, two
important tools in my toolbox are hot-melt glue, and self-locking
cable ties (also known as "Zip Ties").

Pegboard and Ziptie module layouts

Together these techniques help to turn a jumble of wires and parts into
a robust installation that will function reliably and look professional.

Custom patch cables and headers

While pre-made "du Pont" jumper leads are convenient and inexpensive,
sometimes you want an exact length. Jumper leads typically come in
10cm, 20cm or 30cm lenths, but when you're making a permanent
installation, you want your links to be the exact length you need, to
reduce clutter. Here is a technique I learned in the days of the MIT
"Handy Board" (an early robotics experimenters' platform, popular in
the early 1990s):

First, obtain a supply of snap-off headers, female header pins, and
ribbon cable. Old parallel-ATA data cables are good, or you can buy a
roll of coloured ribbon cable. You can also cut your existing du Pont
cables to length and attach new ends.

Next hold your headers in a soldering clamp, and tin each pin.
Strip and tin your wires. Solder the wires to the pins by holding
them overlapped by 2mm and touching with the soldering iron.

Making a custom patch cable

Making a custom patch cable

Now you need to insulate the joins. Heat-shrink is good, but
fiddly. A quicker and more robust way is HOT GLUE. Heat up your glue
gun and apply a small amount of glue to completely cover all the
wires. Build the glue up onto the body of the header. Don't be
tempted to touch until it is cool.

Making a custom patch cable

Making a custom patch cable

Making a custom patch cable

Odd-sized headers

If you need a 14 pin header or any uncommon size that you don't have
as a one-piece header, reach into the supply of headers that you
do have.

You can either:

  • Remove one pin from a large header, and then cut the header at the
    missing pin to make smaller header, or
  • Hot-glue two or more smaller headers together to make a single
    large one

"SIL Gadgets"

"SIL" is an acronym for Single-In-Line, and refers to the arrangement of connection pins in single row, which is best for working with solderless breadboards and/or Arduino.

If you are working with breadboards, make up a number of cables that join a male header to various components such as switches, LEDs, speakers and batteries. When you want to test a module it's handy to have pre-wired inputs and outputs that you can re-use for temporary hook-ups.
I have a boxful of these that I've made for various devices, and some of them have been reused over and over for many years.

Examples of custom headers made with hot-glue

A library of "SIL gadgets" for breadboard experiments

Pegboard lash-up installations

When your installation consists of a number of modules connected by jumper cables, an excellent way to make the lash-up installable is to cut a piece of peg-board to size and fix each module in place with cable-ties.
Don't forget, the self-adhesive backing on most breadboards is there to be used, too.

I use this pegboard technique for home automation equipment points, and for larger robots.

Raspberry Pi and Arduino door lock

Motion sensing contoroller for LED string lights

Robot drive platform from dead vacuum bot

Minature K9 Robot Chassis

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.

Saturday, 19 March 2011

Flat Mate - protect your LiPo cells from over-discharge

This project monitors the voltage of a battery and displays a 5-element bar-graph indicating battery charge state. A MOSFET can be added if desired cut off supply at low voltage, to protect the battery from over-discharge.

It is particularly applicable for multi-cell Lithium-ion Polymer (LiPo) packs, which are easily ruined if over-discharged.

It is intended for use in high power applications such as portable lighting, robotics and power tools where a charged SLA or LiPo battery is discharged in the presence of a human operator. The first deployment was for a high-power bicycle headlamp. Design was inspired by the simple state-of-charge indicators present on some electric bicycles.

The advantage over existing inexpensive "off the shelf" protection circuits is that this circuit gives a visual indication of state-of-charge, presented as an easy-to-read bar-graph. Existing protection circuits (often designed for flashlights or model aircraft) either have no display (sudden surprise cutoff), digital voltage display (requires memorizing cutoff voltages) or audio-only alert (no visual display).

An Atmel ATTiny45 microcontroller is used to sample the battery voltage and control the LED bargraph. Power for the microcontroller is derived from a 78L05 regulator connected to the main battery. Battery voltage is monitored using an analog input via a voltage divider and compared to the microcontroller's 1.1v internal voltage reference.

The bargraph will show 4 LEDs when at "full charge" and 1 LED when at minimum usable voltage. When voltage is critical a 5th "alert" LED will illuminate (and output supply can be terminated).

The circuit can be used purely as a voltage indicator by leaving off the optional MOSFET switch components. If a MOSFET is fitted this can be used to disconnect the main load when the battery is depleted.

Hardware Details

Flat Mate Schematic

The bargraph consists of 5 3mm LEDs (green, yellow and red) arranged GYYYR. The first four (GYYY) form the bargraph and the 5th (red) is the critical alert. The first three are connected to dedicated output pins, the final two share a single pin in a totem-pole arrangement. The fourth LED shares state with the output FET (if fitted), when this LED is lit, power is good and the FET is enabled. When this output pin is cleared, the fifth LED (the complementary red CRITICAL alert) is illuminated and the FET is disabled.

As the monitor circuit is indended for use in high-drain situations (0.5--10A), the approx 20mA consumed by the monitoring circuit is considered negligible. In particular the voltage divider is not isolated from supply between samples, so presents a constant drain of around 850uA. Current through the bargraph elements is limited by a 1kΩ resistor to around 3mA per element, so the bargraph consumes up to 12mA when at FULL level.

Software Details

Software is configurable for the type and number of cells. The initial application of a 3-cell (11.4v nominal) Lithium-ion Polymer (LiPo) battery will be used to describe the code.

Four voltage thresholds are configured (in millivolts), depending on battery type. For a 3S LiPo these are:

    BMV_FULL = 12.000v
    BMV_GOOD = 11.000v
    BMV_LOW  = 10.000v
    BMV_CRIT =  9.000v

The code converts these thresholds to analog sample values at compile time, defining corresponding VL_FULL..CRIT constants.

These thresholds give the following LED readouts:

    if >= FULL output GYYY_
    if >= GOOD output _YYY_
    if >= LOW  output __YY_
    if >= CRIT output ___Y_
    if  < CRIT output ____R


  • Configure analog pin as input
  • Configure LED pins as outputs
  • Strobe the LEDs for 1s to see that they all work
  • Configure timer 1 to give 4Hz interrupts
  • Configure ADC for internal 1v1 reference, selecting single-ended channel 2
  • Set ADC clock prescaler to give 125kHz, take and discard one sample

Main loop

  • do nothing, go straight to sleep mode until timer interrupt.

Timer interrupt handler

  • Read battery voltage
    • initiate conversion
    • busy-wait until conversion complete
    • read completed value
  • Update sample value
    • add sample value to accumulator
    • if 4 samples are accumulated, calculate the average and reset accumulator
  • Update the display whenver accumulator is reset
    • Clear all LEDs
    • Light the CRITICAL LED (and kill power) if level is <=VL_CRIT
    • Set the bargraph appropriately if level is >VL_CRIT (see above)

Since samples are accumulated at 4Hz, and each 4 samples are averaged, the outputs will be changed only once per second. Averaging is used to avoid falsely detecting a CRITICAL state when transient spikes such as motor start occur.


The circuit was prototyped on a solderless breadboard, with battery simulated using a 24v supply and an adjustable-output regulator (LM317T).

A selection of LEDs with one leg replaced by a current-limiting resistor have been made to simplify use of LEDs in breadboard prototypes.

For in-circuit programming I use the tuxgraphics AVRUSB500v2, as this programmer features a 5-pin SIL programming header, which is very convenient for breadboards.


Once the design was proven, a version was constructed on through-hole prototyping board with components arranged to take advantage of pin-bridging where possible. This turned out to be difficult since the chosen double-sided prototype board featured a solder mask that was VERY resistant to bridging (this would normally be a laudable feature). A plain copper single-sided protoboard would have actually been a better choice.

Flat Mate

The prototype has been deployed for use as a bicycle headlamp battery pack.

Subsequent revisions will use ATTiny25 in SMD package, and SMD components.

Flat Mate PCB

Full code and design files are available on GitHub

Update: Here is the etched and drilled PCB for the surface mount version (with through-hole headers and MOSFET), alongside a SOIC to DIL breakout board constructed to allow programming the ATTiny25:

Flat Mate PCB and breakout

Thanks to Warranty Voider for the breakout board design.

Update 2: Here is the assembled SMD prototype:

SMD Assembly

SMD Assembled