Cube:Bit – Magical RGB Cubes


Magical RGB “neo-pixel” Cubes of awesome


Purchase Cube:Bit here

The Cube:Bit collection is a range of 3D “neo-pixel” compatible cubes that are easily built from individual 2D slices.

The current range consists of 3×3, 4×4 and 5×5 slices together with a base unit that allows power to be added easily (big cubes can use a lot of power), and also allows a Micro:Bit or Raspberry Pi Zero to be plugged in directly. Of course you can use the Cube:Bits without the base and with any microcontroller thats supports neopixels: Arduino, Raspberry Pi, even Crumble (although the Crumble only supports up to 32 pixels at present, so only the 3x3x3 Cube:Bit can be controller)

Assembling the cube is easy with threaded rods in each corner providing the structural strength as well as the electrical connections.

Programming it is equally simple as these just appear as a string of neopixels, so use your favourite neopixel driver for your controller.

For the BBC Micro:Bit we have developed a MakeCode package that allows you to use the Cube:Bits extremely simply as well as giving you full x,y,z control of each pixel.



Assembling a Cube:Bit

The basic construction method is:

  1. Place the 1st slice A-Side up
  2. Place second slice B-Side up, ensuring Vcc/5V and Gnd are in correct place
  3. Place third slice A-Side up
  4. Continue placing slices as required, alternating A-Side and B-Side
  5. Each Slice has a DOUT (Data Out) from the lower slice connected to its own DIN (Data In) connection. This means that there is a “free-hanging” female-female pillar which is alternately on the left and then on the right, with a matching gap in the vertical pillars on the opposite side
  6. You can stack these as high as you want – no need to limit yourself to a simple Cube – but watch the power requirements!


Step 1 – Check you have all the bits


3x3x3 – 3 slices, 5 female-female pillars, 5 male-female pillars, 10 screws

4x4x4 – 4 slices, 6 female-female pillars, 7 male-female pillars, 12 screws

5x5x5 – 5 slices, 7 female-female pillars, 9 male-female pillars, 14 screws


The construction method is the same for all Cube:Bit sizes. Just keep going upwards as you add more slices


Make sure you can tell which is Side A and which is Side B for each slice (These are more clearly labelled on release version):

  • Side A has the names for each LED as 0, 1 , 2, 3, etc.
  • Side B has the names as B0, B1, B2, etc.


Step 2 – Add Pillars to bottom slice


You will need 4 female-female pillars for underneath, and 3 male-female pillars and a screw for the top

Make sure you have the slice with the A-Side upwards, then fit a female-female pillar below the DIN connection (next to LED 0) using the screw


Fit the other 3 female-female pillars using the male-female pillars to hold them in place


Step 3 – Prepare the Second Slice


Make sure the slice is B-Side upwards, then take a female-female pillar and a screw and fit the pillar on top of the slice in the DOUT connection (next to B8, B15, or B24 depending on your cube size)



Step 4 – Fit the Prepared Second Slice


Use 2 male-female pillars and a screw.

IMPORTANT: Make sure you place Vcc/5V on this slice directly above Vcc/5V on the slice below.

Screw the pillar from the DOUT of the lower slice into DIN of this slice using the screw

Then use the male-female pillars to attach the remaining 2 pillars from below


Now repeat steps 3 and 4 as often as required – no repeats for a 3x3x3 cube

Remember to alternate A-Side and B-Side as you stack the slices


In fact you can keep going as high as you like to make a tall tower – this one is 5 x 5 x 15 slices high

TIP: If you are using the Makecode extension, then there is a hidden block called “set height of tower” that you should use before the “create cube:bit” block

Access this hidden block by switching to Javascript and then typing in cubebit.setHeight(<number of slices>). eg. for a six slice, 4×4 tower:

Step 5 – Fit the Top Slice


Back to A-Side upwards (assuming 3x3x3 or 5x5x5).

Use three screws to fit the top slice, ensuring that it is DOUT that is NOT connected and that Vcc of this slice is still above Vcc of previous slice


You now have the completed cube on legs as well as spare screws/pillars.

Final options at this point are:

  1. Leave as is and use croc clips (alligator clips) to connect to the legs for 5V, Ground and Signal
  2. Connect to the base using 4 of the spare screws. Make sure you connect 5V and Vcc
  3. Remove the bottom legs and change the first pillars to female-female held in with screws. This makes a tidy cube, then connect to it using soldered wires or tags, etc.


Powering Your Cube:Bit

These cubes have a lot of LEDs and LEDs require power. The 3x3x3 has 54 LEDs and the 5x5x5 has 250 LEDs. On full brightness with White colour this will be several amps.

You _can_ drive them with a low current as long as you set the brightness down low (40 or less) and you don’t set a lot of LEDs to white. This is perhaps suitable for the 3x3x3 cube.

I recommend however using the base and supplying power either via the USB connection or the DC jack connection. There are other connectors on the base as well. Make sure you have changed the jumper to select the power input you are using!

Example currents used (powered by 5V)

  • 3x3x3 all LEDs at Red, brightness 40 (out of 255) – Current 150mA
  • 3x3x3 all LEDs at White, brightness 40 – Current 340mA
  • 3x3x3 all LEDs at White, brightness 255 – Current 1.9A
  • 4x4x4 all LEDs at Red, brightness 40 – Current 350mA
  • 4x4x4 all LEDs at White, brightness 40 – Current 800mA
  • 4x4x4 all LEDs at White, brightness 255 – Current 4.5A
  • 5x5x5 all LEDs at Red, brightness 40 – Current 680mA
  • 5x5x5 all LEDs at White, brightness 40 – Current 1.6A
  • 5x5x5 all LEDs at White, brightness 255 – Current 8.75A

These numbers are important. For instance on the microbit you shouldn’t power the LEDs directly.

So use a 2.5A power supply for the 3x3x3 cube, 5A for 4x4x4 and 10A for the 5x5x5. Although if you set the brightness down low etc. then using lower current power supply is possible and we do most of our testing using a 4A supply. If the brightness is set to 40 (the default) then you can use a 3x3x3 cube with 0.5A power supply and a 4x4x4 with 1A.


  • Signal from controller (eg Micro:Bit) to DIN on the bottom slice
  • Ground from controller to GND on bottom slice
  • Ground from power supply to GND on bottom slice
  • Power from 5V DC power supply to Vcc/5V on bottom slice


Photo above shows using croc clips to connect to the legs. Yellow is signal from Micro:Bit Pin 0, Green is Gnd from Micro:Bit. Black is Gnd from power supply and Red is power from power supply



In the photo above we’re using a 5V DC power supply with a 2.1mm DC Jack connector (centre positive) that connects directly onto the base. The signal and ground from your controller of your choice then connect elsewhere on the base (eg. the croc clip connection or the GVS connector or the 4tronix Playground connector)


Using Cube:Bit with Raspberry Pi

Please follow this blog entry for installation, Cube:Bit python library and examples.


MakeCode for Micro:Bit Extension

There is a Makecode extension that makes it easy to use the Cube:Bit using x,y,z three-dimensional matrix address of the pixels.

The slice is physically laid out with the LEDs snaking from the DIN corner then back along the next row, and so on until it reaches the DOUT corner (ie. along x axis then along y axis). As alternate slices are mounted upside down and rotated, then the snaking goes along y-axis then along x-axis in these slices. So it is much easier to use the built-in mapping block.

To load the package (until it is formally released) go to Advanced (or click on cog icon) then select Extensions. In the search box add the URL

This provides the following blocks:

Your first block in the start of program should create a cube of the correct size. If you are using the Cube:Bit base then this will connect via Pin0, but you can change this when not using the base. This will create a string of neopixels of the correct length for your cube and set the brightness to the default of 40. If you want, you can change the brightness with the “set Cube:Bit brightness” block, anywhere from 0 to 255 (255 is the brightest)

You can then write a colour to any or all of the pixels in the cube. eg set (x,y,z) 2,3,0 to Blue when Button A is pressed

Note that this is using the map block to convert x,y,z co-ordinates to a Pixel ID

Note also that the show Cube:Bit changes block is required to actually set the LEDs to the new values that you have set.

TIP: Setting LEDs is always a two part process. Make all the changes you want then show the changes on the Cube:Bit. Just making the changes has no effect on the pixels as it only changes internal memory. This is the FIRST thing you should check if your program is not creating the effect you require


There is a block that allows you to write to a whole plane of pixels at one time. Decide which axis the plane lies on and which plane within that axis:


Additionally you can specify exactly which RGB values to use, instead of simply picking one of the predefined colours:

Make a Rainbow

An easy and fun way to start is to create a rainbow effect using the built-in blocks

The Start block creates the cube then sets the LEDs to a rainbow scheme (the show cube:bit changes block makes the LEDs match the settings you have selected

Then the Forever block moves the colours all the pixels by one position. Taking the colour of the last pixel and putting it back into the first pixel. This is called rotation. It does this every 20ms so you get an ever-changing colour effect

Example Software

While testing Cube:Bit we have developed a few interesting animations and games for CubeBit

You can download them all from this zip file

Extract the files into a folder on your PC (and remember where you put them)

Then click on Projects, then Import File, then browse to find the file you require.

All examples have a variable called “side” which is set at beginning of the Start block to be 3, 4 or 5 depending which size Cube:Bit you have. Changing the value of side will allow the rest of the program to work correctly and of course affects the way the x, y, z mapping is calculated. You will need to change this line so that it sets the correct size for your Cube:Bit.

  • PlaneBounce – this simply lights up a plane and moves it left and right. Coloured Green going right and Red going left
  • raindrop – sets a blue/white colour to be rain on the top of the Cube, then drops each pixel to the bottom one at a time and randomly. If you tilt the cube, different planes become the top (at the start of each cycle)
  • PurpleRain – as raindrop, but in purple and with a lightning flash at the start and rain recovery animation at the end
  • RainSplash – as raindrop, but makes a little splash as each raindrop lands (not great!)
  • Revolver – rotates planes in random axis and colours. This works best with larger cubes
  • RGBTest – cycles through Red, Green, Blue and White, lighting every pixel on the Cube. A good test of power supply – check the White is actually White and not a yellow/orange colour
  • Scan – lights up all LEDs in x, y, z order from 0, 0, 0 to size of the Cube
  • TimesCube – builds a small 2x2x2 cube in one corner and grows it to fill the Cube:Bit, then shrinks into a different corner. And repeat
  • TicTacToe amd BitCommander – provides a 2 player game of 3D Noughts and Crosses. Install the BitCommander software on the microbit in your Bit:Commander and the TicTacToe software in your Cube:Bit. Use the buttons and dial on the Bit:Commander to move your person around and press on the Joystick to select the pixel you want. The cursor then changes from Red to Green and it is Player 2’s turn. When a line of 3 is made in any direction, the winning line is flashed on and off. Press the Red button on Bit:Commander to start again


Basic Building Blocks

Basic Building Blocks


Basic Building Blocks is a range of soldering kits to make Raspberry Pi add-on boards (aka HATs). The 40-pin GPIO connector is already soldered on all boards (including when you purchase “board only” instead of the complete kit). So you typically only have to add a few components and headers by hand.

Because the boards are very basic, you are not forced down one way of operating. Also, all the boards are sold as bare boards (with GPIO header already fitted) or as a complete kit

In addition by using an extended female header and appropriate mounting pillars, you can stack these boards together allowing multiple functions simultaneously. Many of the boards have the ability to use different pins for each function by changing jumpers or solder jumpers around.

Purchase Basic Building Blocks here

Download the sample software here


DC Motor


This can be purchase as a Quad motor or a Dual motor kit. The Quad motor kit comes with two L293D motor drivers, whereas the dual comes with just one.

Solder this kit using the lowest hight components first: Diode, then capacitors, then IC sockets, then 2-pin screw terminals

  1. Ensure the diode is the correct way round. White band to the left as shown in the photo above
  2. Capacitors can go either way round
  3. IC sockets should be placed with the notch to the left to match the position of the silk screen on the board (nearest the words IC1 and IC2 as appropriate). If you only have one L293D (ie. the Dual version) then you can choose which position to use
  4. The 2 screw termionals for each pair of motors should be clipped together before connecting to the board. Slide the right hand one down the side of the left one and ensure that it forams a smooth joint all round.
  5. Cut all the pins neatly underneath, not forgetting the screw terminals which could foul on the HDMI header of the Pi if left long
  6. Insert the L293D driver chips with thenotch on the chip matching the notch on the socket

Now you’re ready to go. Plug it carefully onto your Pi and use whatever language you want to control it.

The default pins are:

  • Motor 1: 04, 18
  • Motor 2: 17, 27
  • Motor 3: 19, 20
  • Motor 4: 21, 26

These are set by default in the pin selection area. To change them you will need to cut the small track on each solder jumper above the holes labelled 1A, 1B, 2A, 2B etc. Then wire in your choice of pins from the long row of holes above to the 4 holes on each side

Programming motors is easy using GPIO.ZERO




Bit:Commander Games Consoler & Controller

Bit:Commander for BBC micro:bit


The Bit:Commander is a great device for powering and experimenting with the BBC micro:bit.

Purchase Bit:Commander here


NEW: Try out the Makecode/PXT package for Bit:Commander

In Makecode, go to Advanced and select Add Package. Then insert this URL into the searchbox:



As well as a battery pack (3 x AA batteries required), the Bit:Commander includes

  • Edge Connector for easy connection of the BBC micro:bit
  • Robust on/off switch
  • Blue power indicator
  • 6 multi-colour RGB LEDs (aka neopixels)
  • 4 square 12mm push buttons with coloured caps (Red. Yellow, Green, Blue)
  • Analog dial input with centre click detent for easy centreing
  • Analog Joystick with X and Y movement and a push switch
  • Powered miniature speaker


Suggested uses:

  • Acting as a remote control for another micro:bit device, such as a Bit:Bot
  • Acting as a self-contained portable (no wires) games console
  • Experimenting with various Digital and Analog inputs available as well as the speaker and neopixel outputs
  • Everything is pre-fitted. No wires, soldering or jumpoers to fiddle with


Pin Connections:

  • Speaker: Pin 0 (*)
  • Dial: Pin 0 (*)
  • Joystick X: Pin 1
  • Joystick Y: Pin 2
  • Joystick button: Pin 8
  • Neopixels: Pin 13
  • Red Button: Pin 12
  • Yellow Button: Pin 16
  • Green Button: Pin 14
  • Blue Button: Pin 15

(*) Pin 0 is used both for Speaker output (using the Music or Tone output methods) as well as the Dial analog input. This causes some compromises – most notable of which is that the Dial analog input cannot reach its normal maximum value of 1023 and stops at around 850 instead. As long as the software understands this, then it shouldn’t be a problem.

NB. The Bit:Commander is only powered if batteries are fitted and it is switched on. Powering the micro:bit does not power the Bit:Commander. However, when the Bit:Commander is powered up, then it will also power the micro:bit



Music:Box with Blinkie Plugins

Music:Box with Blinkie Plugins


The music box is a small board that makes your BBC micro:bit totally mobile with blinky LED plugins and on-board powered speaker

Purchase here


  • 3xAAA battery holder
  • Robust on/off switch
  • Blue indicator LED
  • Mini speaker with powered driver
  • Fittings for BBC micro:bit (version from v1.0 onwards have edge connector instead of pillars and screws. No functional change to the operation however)
  • Connector for neopixel plugins


Making Music

The powered speaker is connected to Pin 0 of the Micro:Bit. This is the default pin for the music modules in micropython and PXT

So in PXT you could simply create this block to run once at the start


In micropython, you can do the same thing with the following code:

from microbit import *
import music

You can make your own music or use one of the built-in tunes. You can also play the tune in the background, so you can be doing other things while the music is playing. To play forever in the background:

with PXT


with micropython

from microbit import *
import music, wait=False, loop=True)

More micropython help can be found here


Flashing the Neopixels

At the front of the Music Box there are 2 rows of 4 pins, with symbols next to them indicating “facing forward” and “facing backwards”. The outer 2 pins of each 4 are power and ground and the inner two pins are Data in and data out.

The row of pins nearest the edge of the board (facing outward) are the first neopixels in the chain. The data out from these, goes to the data in of the 4 pins facing into the board. This means you can put one plugin facing outwards and one facing inwards. The plugin facing inwards would start at LED10 (assuming a standard 10 neopixel plugin is in the first position).

If you only have an inward facing plugin, you must link the data in and data out of the outward facing pins. This is why there is a little back jumper included. If you only have a plugin facing outward, then you don’t need the little jumper, but you can keep it safe by plugging it into the inward facing pins.


On the Music:Box the neopixels are connected to the MicroBit pin 1, so remember to select Pin 1 in the following code examples

Plug your selected plugin (Santa or Christmas tree for now) into the 4 pins nearest the edge of the board. the LED marked 0 at the bottom is the first LED in the chain of neopixels.

Now you can use the standard neopixel modules in your selected MicroBit language.

For PXT you can do this to set all the pixels to Red:

NB: The neopixels are on Pin 1 and they use GRB format (as shown in the example above)

Don’t forget to include the ‘show’ block after you have changed the pixel colours. It doesn’t actually update the pixels themselves until you do. You will also find that the LEDs will light up even if the Music:Box is not switched on. However, the colours won’t be correct and it will generally be quite dim. Always switch on the Music:Box when testing LEDs.

For micropython, you can do something like this:

from microbit import *
import neopixel
np = neopixel.NeoPixel(pin1, 10)
np[0] = (50,60,100) # set R,G,B values of pixel 0

Again, you must run the show method after setting pixel values and ensure that the Music;Box is turned on. More micropython help can be found here



  • This micropython program randomly flashes the neopixels and plays your choice of tune when A button is pressed. Stops when B button is pressed. You can hear glitches in the music when the neopixels are being update
  •  this micropython works in a similar way to, but it plays each note individually and then updates the neopixels. This synchronises the music with the light show and also removes the glitches in the music

4duino – Arduino Uno Compatible Products

4duino – Arduino Uno Compatible Products


Purchase 4duino here

4tronix have created a range of Arduino compatible boards with our own brand of magic.

All members of this new range are fully compatible with Arduino Uno software, and the 2 larger Uno form factor boards are fully hardware compatible as well

In addition, the 4duino range features:

  • 16MHz ATMega328P-AU processors
  • 14 Digital I/O pins (5 of which can be PWM – Pulse Width Modulated)
  • 8 Analog input pins (6 of which can be Digital I/O as well)
  • Built-in 5V regulators (check individual specifications for current ratings)
  • Reset buttons
  • Full USB interface (using CH340 interface chip)
  • Micro-USB connector

The 4duino Uno full-size products also have:

  • DC Jack for powering via up to 11V
  • Coloured coded pins (Pro) or available holes for 3-pin sensors (GVS – Ground, Volts, Signal) for all 22 I/O pins


You can download the schematics for these boards from the following links

Programming 4duino Boards

As these boards are fully compatible with the standard Arduino Uno, you should follow the instructions and reference examples at to download programming software, libraries, example files and lots of tutorials.

The additional motor drivers on the Pro versions of these boards you will need the pin information and a brief example:

  • Motor A Pins: D5 and D9
  • Motor B Pins: D6 and D10

The motor driver is a standard dual H-Bridge (DRV8833 chip):

  • Setting one pin High and the other Low will drive the motor one direction
  • Swapping High and Low will drive the motor in the opposite direction
  • Setting both to Low, or both to High will stop the motor
  • (setting both High will brake the motor quickly, setting both Low will allow the motor to coast to a stop)
  • The following code, drives one motor forwards, then backwards, then stops:

// the setup routine runs once when you press reset:
void setup() {
// initialize the digital pins we will use as an output.
pinMode(D5, OUTPUT);
pinMode(D9, OUTPUT);

// the loop routine runs over and over again forever:
void loop() {
// Forwards, then wait 500ms
digitalWrite(D5, HIGH);
digitalWrite(D9, LOW);
// Reverse, then wait 500ms
digitalWrite(D5, LOW);
digitalWrite(D9, HIGH);
// Stop, then wait 500ms
digitalWrite(D5, LOW);
digitalWrite(D9, LOW);

Powering the Boards

The 4Duino range can be powered by putting between 7 and 10V into the DC Jack connector (not available on the Mini or Mini Pro). It can also be powered with 5V on the USB connector – eg. connecting directly to a PC. Finally it can be powered by putting 5V onto the 5V signal.

Powering the Motors

The motors use a separate power supply from the Arduino processor. This is because the 5V regulators cannot deliver as much current as you may need to use, but this depends on the motors used.

4Duino Pro: You can select using jumper J3 whether the motor power is taken from the DC Jack input or the separate 2-pin screw terminal. The full voltage on the selected input is used to drive the motor. Note that the Ground signal is common to the Arduino chip, the DC Jack input and the 2-pin terminal.

4Duino Mini Pro: The power for the motors is taken from the end pin labelled ‘+’. For low power motors this “could be” connected directly to the 5V pin on the board, but probably best to connect to the Vin pin.

Download the CH340 Drivers for your OS

4duino Uno


This is software and hardware compatible with an Arduino Uno. You can use all the same addon Shields and get the same performance. In addition, we have made the extra 2 Analog pins available via the holes on the board into which you can solder headers if required.

These extra analog pins can be used within the Arduino IDE as A6 and A7. Note that they are analog ONLY – there is no ability to do a digital read or write on them and there is no ability to set pullup resistors.

Currently, the 4duino Uno is a depopulated 4duino Uno Pro board – so you can upgrade it to the full Pro specification with some surface mount soldering! Adding the GVS headers is much easier and a great upgrade though.

The USB interface is via the CH340 chip which has drivers available for all operating systems here.

On board 5V regulator: 1A


4duino Uno Pro


This is the fully populated version of the board that includes an integrated 2-channel H-bridge motor driver (the DRV8833).

The 4duino Uno Pro is fully hardware and software compatible with an Arduino Uno. You can use all the same addon Shields and get the same performance. In addition we have added colour-coded GVS headers for all the I/O pins including the additional 2 analog pins, A6 and A7. Note that these additional analog pins are analog ONLY – there is no ability to do a digital read or write on them and there is no ability to set pullup resistors.

The great news is that the Pro version also includes a 2-channel full H-bridge motor driver so you can control motors without requiring any addition shields or messy wiring. In fact, with the GVS headers installed, together with the motor drivers, the 4duino Uno Pro is like combing an Uno, sensor shield and motor shield into a single board!

On board 5V regulator: 1A

Motor control Pins:

  • Motor 0:  D5, D9
  • Motor 1:  D6, D10


4duino Mini


The 4duino Mini is an extremely small version of the Arduino Uno with all the same I/O pins, USB interface, reset button and voltage regulator.

All 22 I/O pins are brought out to the board edge where you can connect directly to them or solder in the provided headers.

The extra 2 analog pins can be used within the Arduino IDE as A6 and A7. Note that they are analog ONLY – there is no ability to do a digital read or write on them and there is no ability to set pullup resistors.

It is intended that headers, if fitted, are fitted so that the underside of the board is visible during use. This side of the board has no components and so has more room for labelling of all the pins.

Certain pins have symbols around them:

  • Circle: this is a digital pin that is capable of PWM
  • Octagon:  These are the Ground connections
  • Square:  One of these is 5V and is either a 5V input to the board, or a 5V output if you are using the onboard 5V regulator. The other square is the VIN for the voltage regulator. This can be from 6V to 9V. So if you are using this board with 4xAA batteries you would have a 6V nominal voltage which you apply to the VIN and GND inputs. You can then use the 5V pin to power the rest of your ciruit (up to 150mA)

On board 5V voltage regulator:  150mA

  • Dimensions: 33.75 x 18.5 x 1mm
  • Weight: 2g


4duino Mini Pro


The 4duino Mini Pro is a slightly longer version of the 4duino Mini. The extra length is used to house the dual H-Bridge motor driver and associated components, as well as the motor power input and motor power outputs. The remainder of the board is identical to the 4duino Mini

All 22 I/O pins are brought out to the board edge where you can connect directly to them or solder in the provided headers.

The extra 2 analog pins can be used within the Arduino IDE as A6 and A7. Note that they are analog ONLY – there is no ability to do a digital read or write on them and there is no ability to set pullup resistors.

It is intended that headers, if fitted, are fitted so that the underside of the board is visible during use. This side of the board has no components and so has more room for labelling of all the pins.

Certain pins have symbols around them:

  • Circle: this is a digital pin that is capable of PWM
  • Octagon:  These are the Ground connections
  • Square:  One of these is 5V and is either a 5V input to the board, or a 5V output if you are using the onboard 5V regulator. The other square is the VIN for the voltage regulator. This can be from 6V to 9V. So if you are using this board with 4xAA batteries you would have a 6V nominal voltage which you apply to the VIN and GND inputs. You can then use the 5V pin to power the rest of your ciruit (up to 150mA)

On board 5V voltage regulator:  500mA (peak)

  • Dimensions: 43.75 x 18.5 x 1mm
  • Weight: 2.6g

Motor control Pins:

  • Motor 2:  D5, D9 (labelled on PCB as M2, but is M0 to be consistent with 4duino Uno Pro)
  • Motor 1:  D6, D10
  • The + and – pins on the opposite side from the Motor pins are what is used to power the motors. You need to wire these to your board power input or raw 5V or whatever if you need to power the motors.


CrumbleBot Mk2

CrumbleBot2 – Assembling and Coding


Purchase CrumbleBot Mk2 here


CrumbleBot Mk1

If you are looking for information on the previous versions, please check the older blog entry here


Updated Features

  • 8 Addressable RGB LEDs (‘Sparkles’)
  • Easy to use buzzer
  • 2 push button switches
  • Jumpers with handles, instead of crocodile/alligator clips
  • “Wire-free”, low-profile battery holder (no USB connectors or wires to get broken)
  • Modified motor mounting positions to reduce dust ingress into the gearbox
  • Improved, smooth-running, front caster
  • Powered front accessory connector
  • Additional mounting holes near rear to allow fitting of a “second deck”


Assembling CrumbleBot Mk2

Click any photo to enlarge

Step 1 – Check you have the correct Parts


You should have the following items in the box:

  • CrumbleBot Mk2 main circuit board
  • 2 x Black Wheels
  • Battery Holder PCB
  • 10 x small 7mm pillars to mount Crumble (not required for version 2.1 as pillars are pre-fitted)
  • 2 x larger 12mm pillars to mount battery holder
  • Caster ball and housing
  • 2 x M2, 6mm screws to attach caster
  • 2 x M2 nuts for caster
  • 10 x 4mm M3 screws (v2.0 has 20 x 5mm) to attach Crumble
  • 4 x 8mm countersink head screws to fit battery holder
  • 4 x Yellow (colour may vary) jumpers with “handle” to select function of each connection
  • 4 x coloured 12cm jumper leads for when the little yellow jumpers can’t reach


Step 2 – Fit the Caster





Use the 2 small M2, 6mm screws to pass through the caster underneath the CrumbleBot and fit the nuts on the top of the CrumbleBot mainboard


Step 3 – Fit the Crumble mounting Pillars (v2.0 Only)


NB. V2.1 Has these pillars ready-fitted – skip this step

V2.0: Use 10 of the small 5mm screws to fit the 10 small pillars on the top of the CrumbleBot.


Step 4 – Fit the Crumble


Use the 10 M3, 4mm (for v2.0 use the remaining 10 small 5mm) screws to attach the Crumble to the 10 pillars fitted in Step 3.


Step 5 – Fit the Battery Holder Pillars


Use the 8mm screws to fit the 2 longer 11mm pillars into the holes marked “GND” and “PWR”


Step 6 – Fit the Battery Holder


User the remaining 2 longer 8mm screws to fit the battery holder to the 11mm pillars.

NB. Ensure  the switch and LED are at the rear of the robot


Step 7 – Add the batteries and Jumpers


A good starting point for the jumpers is in the middle two positions on the left side, and the outer two positions on the right side.  This allows use of the line sensors, sparkles and buzzer without changing anything.


Step 8 Optional – Add the Ultrasonic Distance Sensor


Using the four 6mm screws, screw the two 20mm pillars into the front accessory connectors. Then screw the sensor module onto the top of the the two pillars as shown above.

To connect the sensor to the Crumble, you must use one of the 12cm jumper wires to connect to a GPIO pin. All our examples use GPIO A so wire it as shown in the photo above. Remember to remove the Yellow jumper attached to GPIO A. Now you can use the distance block in the Crumble software, setting both T (Trigger) and E (Echo) to the same pin. A in this case.


Your CrumbleBot Mk2 is Finished and ready for Coding!




Coding Your CrumbleBot Mk2

 1. Understanding the Jumpers

The Crumble has 4 general purpose IO (GPIO) connections, labelled A, B, C, D. These are all interchangeable for everything except driving Sparkles, which can only be done using GPIO D.

CrumbleBot Mk2 brings each GPIO connection to 2 positions on a jumper block. The other side of each position is connected to one of the functions of the CrumbleBot. Thus, you can use the little Yellow jumpers to connect from a GPIO to one of the functions on the CrumbleBot2. For instance the top row on the left-side connector block is connected to to GPIO A (on the right of the connector block) and to the left side Light sensor (on the left of the connector block). Fitting a Yellow jumper across the top row will therefore connect the light sensor to GPIO A. If instead you connect the yellow jumper to the next row down, you would be connecting GPIO A to the line sensor. (As an aside, it is possible to connect each GPIO to 2 different signals at the same time – this won’t damage anything but will give unexpected results).

So the default settings for the yellow jumpers will connect the GPIO as follows:

  • A to the left Line sensor
  • B to the Buzzer
  • C to the right Line sensor
  • D to the 8 on-board sparkles


2. Driving the Motors

The Crumble has its own motor drivers which are connected directly to the motors on the CrumbleBot. You do not need to make any special connections to make these work. Each Motor is driven independently and you can select the speed (0 to 100) and direction (Forward or Reverse) in your code.

To drive the CrumbleBot2 forward, you would set each motor to the same speed Forward:

And to drive the CrumbleBot in reverse, you could set each motor to the same speed Reverse:

If both motors are going the same speed, but opposite directions, then the CrumbleBot2 will turn on the spot:

If the motors are turning different speeds, then the CrumbleBot2 will drive in an arc


3. Flashing the LEDs

The LEDs on the CrumbleBot2 are called “Sparkles” in Crumble-speak. You can easily code them to flash different colours using the colour-picker, or by setting different Red-Green-Blue (RGB) values.

First of all, make sure that GPIO D is connected via a jumper to  “LEDs” – this is the default setting of the yellow jumpers.

This bit of code continuously makes all the LEDs flash Green on and off:

Of course, you can set each Sparkle to different colours and brightnesses – they do not have to be all the same. The following code implements a “Larson Scanner” famous from the KITT car in the Knight Rider show. It’s a bit complicated, but bear with it.


4. Following a Line

The CrumbleBot2 has built-in, digital, line following sensors. Make sure that the jumpers are set to connect GPIO A to the left line sensor and GPIO C to the right line sensor. This is the default setting. The following code drives forward until one of the sensors detects a line, then it turns toward the line until the line is not detected any more. This is a very inefficient “way to do it” (algorithm). Can you find a better algorithm for following lines?

You should make the black line out of something that doesn’t reflect light, with the background being a good reflector. Black electrical tape is good and so is printing black lines on a laser printer – here is a good resource for printing line-following tracks.


5. Making a Buzz

The CrumbleBot2 contains a little buzzer (small, round and black, underneath the battery holder). This buzzes loudly (quieter if the sticker is left on the top!) when the input is set to Hi.

The default jumper settings have the buzzer connected to GPIO B, so the following code makes an annoying beep every second:


6. Acting on Switches

There are 2 switches on CrumbleBot2 SW1 (A) on the left side and SW2 (B) on the right side. You will need to move the jumpers from their default positions to use them. The following code modifies the buzzer code in 5. “Making a Buzz” so that it waits for SW1 (A) to go HI (pressed) then starts the buzzer until SW2 (B) is pressed. You will have to use a 12cm jumper wire to connect GPIO A to the SW1 (A) – not forgetting to remove the yellow jumper. So this should have:

  • 12cm Jumper wire from GPIO A to SW1 (A)
  • Yellow Jumper from GPIO B to BUZZ
  • Yellow Jumper from GPIO D to SW1 (B)


7. Following the Light

CrumbleBot2 has 2 light sensitive transistors which produce an analog value from 0 (very dark) to 255 (very bright).

We can use a similar program to the line follower. What we want to do is turn the robot to the side that has the most light. Because the light sensors can vary a lot, we must be careful that we don’t turn the robot every time there is a very slight difference in light levels, otherwise it would spend all its time turning and never move forward much. So we create a guard band in the software and make sure the light levels are sufficiently different before we decide to turn the robot. This is why we compare the X and Y variables and make sure there is a difference of at least 10, before turning.

Connect the yellow jumpers for GPIO A and GPIO C to Light


8. Use the Distance Sensor to Follow You around

Using the optional ultrasonic distance sensor, we can make the CrumbleBot2 follow us and stay the same distance away. The following code measures the distance to an object (eg. your feet). If it is too far away then the CrumbleBot2 moves Forward. If it is too close, then it moves in Reverse. This is a simple way to make a robot “friend”

Bit:2:Pi Control Raspberry Pi Addon Boards with your Micro:Bit

Bit:2:Pi Control Raspberry Pi Addon Boards with your Micro:Bit


[Click on any image to enlarge]

Purchase >HERE<


Bit:2:Pi (Pronounced Bit – to – Pie) is a connector and power management system that allows you to plug in a Micro:Bit at one end and a Raspberry Pi addon board (26-pin or 40-pin, HAT, pHAT or other) at the other end.

In between there are some breakout and connection headers that enable you to customise how the two boards are connected.

The power on the board is managed so that:

  1. Any or all power sources can be connected safely at the same time
  2. The Micro:Bit is never used to power the Raspberry Pi HAT (this is true for Bit:2:Pi v1.0 or later)
  3. Power for the HAT is provided either by the micro-USB connector at the HAT end, or by an attached battery holder
  4. The On/Off power switch controls the power to the HAT as well as to the Micro:Bit
  5. The “5V” signal on the HAT connector is actually from the battery or the micro-USB. If using the battery, this is likely to be around 4.5 to 4.8V using alkaline batteries, or 3.6 to 4.0V using rechargeable batteries. Not all HATs will work at these voltages.

To control the Raspberry Pi addon board (shortened to “HAT” from now on), you must write some code for the BBC Micro:Bit:

  • Many HATs are simply setting GPIO pins High or Low and for these you can use any available language easily. Simply set the Micro:Bit pin corresponding to the HAT GPIO pin (as determined by the various jumpers)
  • Some HATs use neopixels (eg. PlayHAT or Unicorn HAT). These require the neopixels to be driven by GPIO18 (physical Pin 12). By default, this is Pin 2 on the Micro:Bit
  • Some HATs require I2C commands (eg. Picon Zero). You can use the standard I2C commands within Micro:Bit to send and receive the necessary data. The default configuration connects the I2C pins
  • Some HATs require SPI connections (eg. various Analog boards using the MCP3008 or similar). Again the SPI pins are connected by default



The male header block closest to the Micro:Bit (labelled MBit/RPi in v1.0) is where most of the configuration is done.

The MBit side of the header is labelled with the Micro:Bit pin numbers and the RPi side of the jumper is numbered with the GPIO names (Broadcom names)

The Bit:2:Pi is supplied with 13 little black jumpers that connect across from the MBit side to the RPi side. This gives the default settings as follow:

Micro:Bit Pin


Physical Pin








































If you need to connect something differently, then simply remove the appropriate black jumper(s) and use a short Female-Female dupont wire to connect theMicro:Bit pin(s) to the appropriate Raspberry Pi pins.


Example Boards

[this section requires tested boards with example code – contributions welcome]

Some tested working boards are:


External Contributors

Several people have written some software for the Micro:Bit to work with Raspberry Pi addon boards using the Bit:2:Pi adaptor. Many thanks go out to these contributors!


Michael Rimicans (Twitter @heeedt)


Neil Avery (Twitter @veryalien)


Les Pounder (Twitter @biglesp)


 Mark Atkinson (



Robo:Bit Mk2 Robotics Controller and Buggy for Micro:Bit

Robo:Bit Mk2 Robotics Controller and Buggy for Micro:Bit


Looking for Robobit Mk3 ? Then Visit this Page

Robo:Bit Mk2 is a general purpose robotics controller for the BBC Micro:Bit, that also converts easily into a self-contained little buggy.

Purchase Robo:Bit here

Purchase the Robo:Bit Buggy here


The Robo:Bit controller has the following features

  • Ready assembled (NB. headers for the underside are not fitted unless the complete buggy is purchased, but they are included in case you want to add these)
  • Edge connector for easy attachment of your BBC Micro:Bit
  • Dual motor driver with full control of each motor for both direction and speed (uses DRV8833)
  • 3.3V Regulator to power the BBC Micro:Bit
  • Power On/Off switch with LED indicator
  • Mounting holes for either 3-cell or 4-cell AA battery holder
  • Front interface for ultrasonic distance sensor (simply push-fit an HC-SR04, or solder for added security) [NB. You can also plug the McRoboFace into here directly and it will work as required!]
  • 7 of the Micro:Bit pins are broken out to a header with GVS connections (Ground, Volts, Signal) for ease of connecting external devices and sensors
  • I2C signals broken out in case you want to add more complex peripherals

Warning: The line follower sensors share the same pins as the buttons. Depending what language you are using, when the Micro:Bit is started or reset it will check the 2 buttons and start pairing if they are both pressed. With the Robobit, this translates to both line follower sensors getting reflections. You can stop it happening by lifting it off the surface before switching on, or of course disconnecting one or both of the sensors

Software & Programming

Robo:Bit uses the same connections for the motors as Bit:Bot, so most of the software will continue to work.

{{OLD INFO:  In particular, the BitBot package for Microsoft PXT works fine (but you cannot use the sonar or neopixel blocks from this package as they use the wrong pins for RoboBit). To use this package, load up microsoft PXT for Micro:Bit from here, then go to Advanced or Tools and select Add package. Then search for “BitBot”.}}

Please use the currently Beta Robobit package. for Microsoft Makecode (aka PXT). Select Advanced, then “Add Package”. Into the search bar, put this URL: and the Package will show as an Orange Taxi icon on the left.

The Pins are used as follows:

  • Left Motor: Pin 0 (PWM) and Pin 8 (Direction)
  • Right Motor: Pin 1 (PWM) and Pin 12 (Direction)
  • Ultrasonic detector: Pin 13 (alternatively neopixel output pin)
  • Left line sensor: Pin 11 (bottom 3×2 header)
  • Right Line sensor: Pin 5 (bottom 3×2 header)

For each motor there is a 2-pin screw terminal and a 2-pin male header. If fitted, there is also a 2-pin JST header underneath the board (used in the buggy). All three connectors for each motor are connected together.

Some sample PXT programs. Click on them to download the compressed HEX files. You can install them into your Makecode environment by selecting Projects and “Import File” and browsing to the HEX file on your PC


Motor Test

Simply moves forward and backwards to check the motors are connected OK


Sonar test with the Ultrasonic

Simply displays the distance measurement on the MicroBit


FollowMe Sonar Test

The Robot will move to within 15-20cms of an obstacle and then move forwards or backwards to stay within this range


Control your Robobit Buggy from another Microbit

The same code can be loaded into each microbit. The one on the buggy will receive the commands from the second one – in your hand. To load this code, copy the compressed HEX file from here onto your PC, and uncompress it. Then, from Makecode, select Project and browse to find where you put the HEX file. Install this onto both the controller and the buggy. Here is the complete code visually:

Assembling the Robo:Bit Buggy

STOP: Before continuing, please check which version of RoboBit you have as the assembly instructions differ. The version number is written on the underside of the PCB as v1.0 or v1.1 or v2.0

Note that this buggy can be purchased in modular form. You can use your own motors and wheels if you already have them – the little yellow motors are pretty ubiquitous, so many schools and hobbyists will already have them. This guide to assembly assumes you have purchased the complete kit, including the ready-soldered wires on the motors – if not you would have to connect the wires to the motors and use the screw terminals on the top of the board.

Click on the image below for a quick assembly GIF



Step 1. Check you have all the Parts

NB. These are different for each Version. Check the PCB version (written on the underside of the PCB) before continuing


Version 2.0

  • Robo:Bit v2.0
  • Battery Holder with no wires, mounted on a PCB
  • Yellow gear motors x 2 with JST connectors
  • 1 caster (plastic ball plus plastic housing)
  • 25mm brass female-female pillars x 2
  • 11mm brass female-female pillars x 2
  • 20mm brass female-female pillar (M2.5) x 2
  • 30mm brass female-female pillar (M3) with holes x 2
  • 6mm M3 screws x 2
  • 30mm M2.5 screws x 4
  • 6mm M2.5 screws (pan head) x 6
  • 8mm M2.5 screws (CSK) x 2



Version 1.1

  • Robo:Bit v1.1
  • Battery Holder
  • Yellow gear motors x 2
  • 1 caster (plastic ball plus plastic housing)
  • 10mm black nylon male-female pillars x 2
  • 15mm black nylon female-female pillars x 2
  • 20mm brass female-female pillar (M2.5) x 2
  • 30mm brass female-female pillar (M3) with fitted attachments x 2
  • 11mm brass female-female pillars x 2
  • 25mm M3 screws x 4
  • 6mm M2.5 screws (pan head) x 6
  • 8mm M2.5 screws (CSK) x 2
  • 4-cell AA battery holder


Version 1.0

  • Robo:Bit v1.0
  • Battery Holder
  • Yellow gear motors x 2
  • 1 caster (metal ball plus plastic housing)
  • 10mm black nylon male-female pillars x 2
  • 15mm black nylon female-female pillars x 2
  • 25mm black nylon female-female pillar (M3)
  • 25mm brass female-female pillar (M3) with fitted attachments
  • 11mm brass female-female pillars x 2
  • 25mm M3 screws x 4
  • 6mm M2.5 screws (pan head) x 8 (or x10 – see step 6)
  • 8mm M2.5 screws (CSK) x 6 (or x4 – see step 6)
  • M2.5 nuts x 4
  • 4-cell AA battery holder


For v1.0 assembly, go to Step 2A

For v1.1 assembly, go to Step 2B

Step 2 (v2) Make the Motor Assembly v2


You will need the two 30mm brass pillars with holes, two 20mm brass pillars and 4 long (30mm) M2.5 screws


Push two of the screws through the holes in one of the motors and through the holes in the 30mm pillar as shown. Take care that the axle of the motor is on the outside and the pillar is on the inside. Also ensure that the motor wires do not get trapped under the pillar.


Screw the 20mm pillars on tightly as shown above.


Then fit the remaining 2 long screws through the second motor, ensuring the orientation is correct as shown above


Finally, screw the second motor firmly to the 20mm pillars. You have now completed the motor mount assembly. Now skip to Step 3

Step 2B (v1.1). Make the Motor Assembly v1.1


You will need the 2 brass bracket assemblies, 20mm female-female pillars (x2) and 30mm M2.5 screws (x4)


Push the 30mm screws through the motors as shown, with the screw threads protruding through the side with wires


Slide the bracket assemblies onto the ends of the 30mm screws as shown above. Ensure that:
1. The vertical 30mm pillar is away from where the wires exit the front of the motor
2. The wires go over the vertical pillars, not under them
3. The short spacers stick out on one side – this is the side that fits against the motor – do not try to fit them the other way around


Screw the two 20mm female-female brass pillars onto one motor as shown above


Finally, add the second motor and screw tightly together


Step 3. Prepare the Robo:Bit for Fitting


You will need the Robo:Bot circuit board, 6mm M2.5 screws (x2) and 11mm pillars (x2)


Fit the pillars in the positions shown above and screw tightly together


Step 4: Fit the Robo:Bit to the Motor Assembly


You will need the motor assembly from Step2, the Robo:Bit assembly from Step3 and M3 6mm screws (x2)


Pass the M3 6mm screws through the Robo:Bit board and into the top of the pillars in the brass bracket assemblies as shown above


Plug the two cables in making sure the left motor is plugged into the left socket and the right motor is plugged into the right socket


The photo above shows the gap between the motors and the Robo:Bit board

Now skip to Step 5



Step 2A. Make the Motor Assembly v1.0


Place the motors into position as shown above, with the axles facing outwards

Use 2 of the 25mm screws to fit the M3 black nylon 25mm female-female spacer to the bottom holes in the motor

Use the other 2 of the 25mm screws to fit the brass bracket assembly to the top holes, making sure that the connector parts point upwards as shown above


Step 3A. Prepare the Robo:Bit for Fitting


Fit 4 of the 8mm M2.5 CSK screws and the 4 nuts to the Robo:Bit as shown above. Pass each screw from the top of the board into a nut on the bottom. Tighten securely.


Using 2 of the 6mm M2.5 pan head screws, fit the 11mm brass pillars in place for the 4-cell battery holder – the outermost two holes – as shown above. Tighten securely


Step 4A: Fit the Robo:Bit to the Motor Assembly


Use 2 of the 6mm M2.5 pan-head screws to attach the Robo:Bit to the upwards-facing connectors on the brass bracket assembly as shown above. Tighten securely.

Push the JST plugs from the motors into the sockets underneath the Robo:Bit controller. The wires are short enough to stay tidy.


Step 5. Fit the Front Caster


For v1.0 and v1.1, Screw each 10mm black nylon male-female pillar into a 15mm making it into a 25mm female-female pillar.

For v2, use the 25mm brass female-female pillars

Use a 6mm M2.5 pan-head screw to fit each pillar to the front holes on the Robo:Bit


Then use two more 6mm M2.5 pan-head screws to fit the caster housing to the pillars (you will have to remove the metal ball while you do this)


Move to Step 6A for v1.0 and v1.1

Step 6 (v2): Fit the Battery Holder


You will need the battery holder assembly and the two 8mm countersunk screws


Screw the battery holder assembly tightly to the upright pillars, ensuring that the labelling is at the rear of the Robo:Bit as shown above. There is no need for wires as the battery power passes directly through the upright pillars.


Step 6A (v1.0 and v1.1): Fit the Battery Holder


Screw the wires into the power terminal. Red to 5V and Black to GND. Wrap the wires tidily out of the way under the battery holder


Use the remaining 2 of the 8mm M2.5 CSK (or 6mm pan head) screws to screw the battery holder to the brass mounting pillars. With some battery holders, the wide countersunk screws don’t fit, so swap them with the 2 smaller pan-head screws used to hold the mounting pillars for the front caster


Step 7. Finish off and Go!

step17v1.0 or v1.1 Ultrasonic

Push on the wheels. Be careful to hold the motor as the wheels can be quite stiff to fit, especially the first time

Push in or bolt on the Ultrasonic Sensor (if you have one)

IMG_1498av2 Ultrasonic

Push the BBC Micro:Bit into the edge connector (LED display and buttons upwards)

Program -> Switch On -> Go!


Fitting the Line Sensors

Step 8. Check you Have the Parts


  • 30mm black nylon M3 pillars
  • 6mm M3 screws x 4
  • Line follower sensors x 2
  • 10cm GVS cables x 2


Step 9. Fit the pillars to the Robo:Bit


Use 2 of the 6mm M3 screws to fit a 30mm black nylon pillar to each front corner of the Robo:Bit board


Step 10. Fit the Sensors


Push one of the GVS leads onto each line follower sensor. Make sure you use the colour coding: Brown for Ground (G), Red for volts (V+) and Orange for Signal (S)

Then use the remaining 2 of the 6mm M3 screws to to fit the line sensors to the bottom of each pillar. Use the hole near the centre of the sensor, not the one at the front. The wires should be at the back, as shown above


Step 11. Plug the GVS leads into the Connector


Pass the wires around the motor supports and then into the 3×2 male header underneath the Robo:Bit board. Make sure brown goes to Ground (GND), Red to power (3V) and Orange to Signal (SIG)

Also make sure you connect the left one to the left set of pins, and the right one to the right set of pins. It is VERY confusing when writing programs with these reversed (trust me, I know this)


Step 12. Trim the Sensors

Each sensor has a little preset potentiometer (pot) which can be turned to define the position at which it detects a line.

Turn the pot until the red LED on the sensor _just_ turns off. It is then at its most sensitive.

When using 3V, these sensors are not as sensitive. With a little ingenuity (and a different cable) you can connect the power line to VCC (the bottom 3 pins on the 8×3 header on the top of the board). This will make the sensors more sensitive.



Bit:Bot Robot for BBC Micro:Bit

Bit:Bot – The Integrated Robot for BBC Micro:Bit


Purchase BitBot here


A great way to engage young and old kids alike with the BBC micro:bit and all the languages available. Both block-based and text-based languages can support the Bit:Bot

You can also use the Radio or Bluetooth functionality of the Micro:Bit to send and receive commands and date. See a Bluetooth tutorial here

Warning: On versions before v1.2, the line follower sensors share the same pins as the buttons. Depending what language you are using, when the Micro:Bit is started or reset it will check the 2 buttons and start pairing if they are both pressed. With the Bit:Bot, this translates to both line follower sensors getting reflections. You can stop it happening by lifting it off the surface before switching on. On v1.2 the line sensors are disabled for 2 seconds after power on so that the MicroBit doesn’t detect the pairing situation. In addition there is a small switch that allows you to disable the line follower sensors completely, allowing the use of the MicroBit buttons.



The Bit:Bot gives you all these features:

  • 2 micro-metal gear motors. Both fully controllable in software, for both speed (0 to 100%) and direction (forward or reverse)
  • Wheels with rubber tyres for maximum grip
  • 12 mini neopixels in 2 sets of 6 along the arms either side. Select any colour for any pixel, produce stunning lighting effects as your Bit:Bot moves around
  • 2 digital line following sensors. Code your own line-following robots and race them to see whose code produces the fastest lap time!
  • 2 analog light sensors (front left and front right) so your Bit:Bot can be programmed to follow a light source such as a torch, or you could code it to go and hide in the darkest place it can find
  • Buzzer, so you can make beeping sounds whenever you want
  • Powered from integrated 3xAA battery holder with on/off switch and blue indicator LED
  • Easily plug your BBC micro:bit in and out using the edge connector
  • Extension port for additional neopixels (such as McRoboFace)
  • Expansion connections at the front for additional sensors (eg. ultrasonic distance sensor, Talon grabber)



Step 0 – Check you have all the correct parts:

  • 1 caster assembly (either metal ball or plastic ball)
  • 2 x 6mm M2 pan head screws (now already fitted)
  • 2 x M2 nuts (now already fitted)
  • 2 x 12mm brass pillars
  • 4 x 8mm M2.5 countersunk screws
  1. Use the M2 6mm (panhead) screws and nuts to attach the front caster housing, then push the caster ball into the housing
  2. Use the M2.5 6mm panhead and 8mm countersunk screws to fit the battery pack onto the 2 metal pillars: ENSURE the on/off switch is at the rear of the Bit:Bot
  3. Push the wheels on with the smooth side outwards. The axle should come flush with the outside of the wheel and not protrude (or the inside can catch on the motor housing)
  4. Push your BBC micro:bit into the edge connector with the LEDs and switches on the top

Click on any image to enlarge

Step 1 – Fit the Front Caster (already fitted to current models)







Step 2 – Fit the Battery Holder

At this point you should have 4 screws left. Either 4 x 8mm countersink, or 2 x 6mm panhead and 2 x 8mm countersink.

If you have the 6mm panhead screws, use these to fit the 12mm brass pillars to the Bit:Bot main PCB.

Always use 8mm countersink screws to fit the battery holder to the brass pillars.


Use either 6mm panhead or 8mm countersink to fit the 12mm brass pillars to the main board (above)



Use the 8mm countersink screws to fit the battery holder to the brass pillars.


Step 3 – Fit the Wheels


Push the wheels on, so that the axle is flush with the outside of the wheel


Step 4 – Attach your BBC micro:bit



Know Your Bit:Bot



This shows the neopixels (6 on each arm), the 2 light sensors, on/off switch and indicator LED

The buzzer is below the on/off switch and the edge-connector is below the front of the battery holder




Now you can see the 2 line sensors and the port for neopixel extensions and general purpose expansion connector. Connection labelling is on the underside


Programming in Microsoft Makecode

For Makecode block programming, you can use the official BitBot extension. Go to the Advanced tab (or press the cog icon) and select Extensions. Then search for BitBot and select the official package. This will give you a BitBot tab in the toolbar with 4 sub-categories for the Motors, Sensors, LEDs and advanced (…more).

For text-based programming there is micro-python, and I prefer to use this offline using the Mu editor.  It provides a very neat and easy way of interfacing to the micro:bit without all the fuss of dragging and dropping. NOTE: At the time of writing (December 2016), there are problems with Mu when using PWM with neopixels and other things, so it best to use the online micropython editor for now.

The following examples use both of these languages to show code fragments.

Note on examples: We want to show people how the various features can be used. We don’t want to do the coding for you – that is the learning experience you should be taking away from using it. In the following examples, we will give you the tools to use all the features of Bit:Bot but it is up to you to combine them together in your code to make it do something useful. We do give a complete example of line-following – but it is a very basic algorithm and will get confused at T-junctions  and crossings; and it doesn’t use the neopixels.

Download Python examples at the bottom of this page.

Some great tutorials/examples by Mark Atkinson here


Under the Motors tab there are 5 blocks available as shown:

The first one “drive at speed 600” simply turns both motors at the speed selected between 1023 and -1023. 1023 is full speed forwards and -1023 is full speed backwards. Setting the speed to 0 will stop both motors.

The second one will do the same, but then stop both motors after the time selected.

The next two “spin <left> at speed 600” will spin the BitBot on the spot by turning one wheel at the selected speed forwards and the other at the selected speed backwards.

The final block allows you to control the individual motors. Either the left motor or the right motor (or both). This is so that you can make a long sweeping turn instead of spinning on the spot, by making one motor go slower than the other.


A great feature of the Bit:Bot is the set of neopixel LEDs, 6 down each arm.

The Makeblock extension supports these easily

The LEDs category has the basic blocks as shown above, but there are additional advanced blocks in the “…more” category

Normally, the process to update LEDs is a 2-stage process:
1. Make the changes to the LED colours (eg. “set all LEDs to Red”)
2. Send all the changes to the LEDs (“show LED changes”)

However, we have made it so that the default is “automatic updates”, so any changes made to the LED values will automatically result in the LEDs changing. This is a slower way to do things, but much easier to understand. If you want the normal, manual, update method then this can be selected from the “…more” category.

You can get a simple rainbow pattern on all the LEDs with just the “set led rainbow” block

And by using the forever block you can get the LEDs to animate using “rotate LEDs” and a pause to slow them down.


The Sensors category provides access to both the integrated features (buzzer, line follower sensors, light sensors) and the optional addons (ultrasonic distance sensor, Talon grabber)


The “turn buzzer on/off” block enables you to make a simple beep

The program above will make a very annoying beep, beep, beep sound forever…

Ultrasonic Distance Sensor (sonar)

The “read sonar as cm/inches/microseconds” block enables you to read the distance from the front of the Bit:Bot to the nearest obstacle. Don’t expect this to be stunningly accurate, but it is good enough for obstacle avoiding etc. Here is a very simple obstacle avoiding program

In this program it reads the distance in centimetres. If it is nearer than 20cm then it reverses and turns, otherwise it carries straight on.

Line Following Sensors

The idea of these sensors is that you create a black, non-reflective, line on an otherwise reflective surface. You can then program the Bit:Bot to follow the line.

The best way to get a good line is to print a track on a laser printer. We use these printable tiles which are excellent

This is a very simple and very inefficient line follower program. But it works. If the left line sensor detects a line then spin left, if the right line sensor detects a line then spin right. Otherwise carry straight on. You can add some LEDs to the program to make it more interesting. Here we have a Red LED on the end of each stalk if it is turning that way, or 2 Green LEDs if it is going straight


Programming in Python

For text-based programming there is micro-python, and I prefer to use this offline using the Mu editor.  It provides a very neat and easy way of interfacing to the micro:bit without all the fuss of dragging and dropping.

Note on examples: We want to show people how the various features can be used. We don’t want to do the coding for you – that is the learning experience you should be taking away from using it. In the following examples, we will give you the tools to use all the features of Bit:Bot but it is up to you to combine them together in your code to make it do something useful. We do give a complete example of line-following – but it is a very basic algorithm and will get confused at T-junctions  and crossings; and it doesn’t use the neopixels.

Download Python examples at the bottom of this page.

Some great tutorials/examples by Mark Atkinson here


Each motor has two pins connected to it. One determines the speed and the other the direction:

Left motor: Speed Pin 0, Direction, Pin 8

Right motor: Speed Pin 1, Direction Pin 12

The simplest way to make the motors move is to set the Speed pin to HIGH and the Direction pin to LOW (to move full speed forwards)

Move left motor Forwards:


Move left motor Reverse:


If we want to change the speed of a motor, so that it is not going at full speed all the time, we need to use PWM (Pulse Width Modulation). This is means of changing the amount of power given to the motor by switching it on and off very fast. The percentage value of PWM determines the amount of each cycle that the output is ON. So a percentage of 100% is the same as being on all the time and thus the same as the examples above. A percentage of 50% would mean that the motor is only energised half the time, so it will go much slower. Note that the actual speed of the motor is not the same as the percentage of PWM – the motor won’t turn at all if the PWM value is too low and you will also get some stuttering at certain values. Nevertheless, being able to change the speed makes for a much better robot. For example, you can make a line follower that smoothly follows the line, rather than the normal shaking left and right.

To change the PWM value of a pin, we must use the analog_write commands. These can be set to a value between 0 (always off) to 1023 (always on), so 50% would be 511. Here are the commands to change the speed of the Right motor to approx 75% (value is 770)

Move right motor forwards at 75%


Doing this for the motors moving in reverse is a little confusing. Remember we need to change the direction pin to 1 for reverse. Then we need to set the amount of time in each cycle that the speed pin is LOW. This is the opposite of moving forwards, where we set the time for it to be High. Se we simply take the number (770 in this case) away from 1023, giving 253:

Move right motor Reverse at 75%




In fact, the name “neopixel” is a termed coined by Adafruit, but like “hoover” was a name of a brand of vacuum cleaner and is now a general term for all similar products, whoever makes it. The generic term is “smart RGB pixel” and is usually referenced with the name of the chip WS2812B. However, there are many different chips, all performing in a compatible way. The ones on the Bit:Bot are actually SK6812-3535

These smart RGB pixels are able to display any of 16 million colours by selecting a value of 0 to 255 for each of the Red, Green and Blue LEDs on each chip. The whole thing is controlled by a single pin on the BBC micro:bit (pin 13 for Bit:Bot). It is simple to use the included neopixel libraries to control each pixel individually.

The pixels are labelled on the Bit:Bot. From 0 to 5 on the left arm and from 6 to 11 on the right arm. If you connect any more neopixels into the extension port, then the new ones will start at 12.

Set neopixel 2 to purple (red and blue)

import neopixel
np = neopixel.NeoPixel(pin13, 12)
np[2] = (40, 0, 40) )

The first line imports the neopixel library. We only need to do this once, at the very top of your Python programThe second line creates an Python list with an element for each pixel. As shown, it specifies 12 pixels connected to pin 13. If you added more neopixels then you would increase the number from 12 by the number of pixels you added. eg. if you added a McRoboFace, then the total would be 12 + 17 = 29 so you would change the line to: np = neopixel.NeoPixel(pin13, 29)
The third line sets the pixel we have selected (number 2 in this case) to the colour which is set by three values in the brackets, each value can be from 0 to 255 and covers Red, Green and Blue. In our example we have set Red and Blue to 40.
The fourth line tells the neopixel library to copy all the data to the neopixels, from the Python list that we have been working with. It is only at this point that the LEDs change. In general, you would make all the changes you want and only at the end would you use a )

Line Follower Sensors

NB. Version 1.0.0 of mu editor (v1.0.0) incorporates an updated version of micropython that allows these pins to ONLY be used as buttons. So instead of using pin11.read_digital() you need to say button_B.is_pressed() for instance. The examples will be changed to reflect this

These are digital inputs and connected to Pin 11 (left) and Pin 5 (right). These are the same pins as used by the buttons, so pressing a button will have the same effect as detecting a black line. This may have unexpected side-effects – as switching the micro:bit on when both buttons are pressed can cause it to enter Bluetooth pairing mode (depending what software is installed).

So you can use the normal Button inputs to read the sensors if you want, or you can use digital_read commands (as shown below). If the left sensor detects a line, it means the Bit:Bot is too far to the right, so it should move left. The opposite is the case if the right sensor detects a line. Here is some simple code for line following in Python (the actual motor commands are in separate functions for clarity)

while True:
    lline = pin11.read_digital()
    rline = pin5.read_digital()
    if (lline == 1):
        spinLeft( )
    elif (rline == 1):
        spinRight( )

Light Sensors

These are analog sensors and will give a value of 0 to 1023, where 0 is fully dark and 1023 is maximum brightness. As there are only 3 analog pins available on the micro:bit (without affecting the LED displays) and we are using 2 of them to control the motors, we only have one left (Pin 2) to read the analog values from 2 line sensors. How can we do this? Well, the Bit:Bot has an analog switch that uses a digital output signal (pin 16) to determine whether the analog input we are reading is for the left sensor or the right sensor.

Therefore, to read the light sensors we need to set the selection output pin first, then read the analog data.

In Python, we can do it like this to read the values into 2 variables called leftVal and rightVal:

Pin16.write_digital(0) # select left sensor
leftVal = Pin2.read_analog()
Pin16.write_digital(1) # select right sensor
rightVal = Pin2.read_analog()



The buzzer is a very simply device that outputs a 2.4kHz sound when it is set to ON. It is NOT controlled by the tone signal that can be output by the micro:bit on Pin 0 so you don’t need to install any libraries to operate it.

It is connected to Pin14. Setting this to ON (1) will activate the buzzer and setting to OFF (0) will deactivate it.

In Python, a very simple and annoying beep, beep, beep sound can be made as follows:

while True:

Ultrasonic Distance Sensor

This optional HC-SR04 ultrasonic distance sensor addon can be used most easily in Microsoft PXT. In MicroPython we can use the utime module to measure time at microsecond level. Below we have a function called sonar() which returns the number of cm to the nearest object. Then we have a while loop that prints the distance every second:

from microbit import *
from utime import ticks_us, sleep_us

def sonar( ):
    SONAR.write_digital(1) # Send 10us Ping pulse
    SONAR.set_pull(SONAR, NO_PULL)
while SONAR.read_digital() == 0: # ensure Ping pulse has cleared

    start = ticks_us() # define starting time
    while SONAR.read_digital() == 1: # wait for Echo pulse to return
    end = ticks_us() # define ending time
    echo = end-start
    distance = int(0.01715 * echo) # Calculate cm distance
    return distance

while True:

Example Micropython Programs