Talon Grabber Assembly & Use

Talon Grabber for Bit:Bot and Robobit Buggy



Purchase Talon here


Assembling Talon for Bit:Bot

Step 1 – Ensure you have all the parts


Your kit should contain:

  • 3 x PCBs: Talon Base, Talon A, Talon B
  • 10 x Screws: M2.5, 6mm
  • 2 x Screws: self-tapping 6mm (there are also longer ones in the servo bag – ignore these)
  • 1 x Screw to attach servo arm to the servo (this is in the servo bag)
  • 1 x Metal gear servo (with various servo arms and screws
  • 1 x M3, 12mm, male-female pillar
  • 1 x M3, 6mm screw
  • 1 x M3 nylock nut
  • 1 x Pimoroni spanner widget to help tighten nylock nut
  • 4 x M2.5, 12mm pillars to attach to Bit:Bot


Step 2: Attach the Pillar for Floating Jaw


You will require the Talon Base PCB, M3 screw and M3 pillar

Fit the screw through the side of the board shown above and screw tightly into the female end of the pillar. Ensure this is firmly attached


Step 3: Fit the Servo to the Talon Base


You will need the servo and 2 of the M2.5, 6mm screws


Ensure the servo is positioned on the opposite side of the PCB to the pillar, and the shaft of the servo is in line with the pillar.

Pass the screws through the holes in the PCB and tighten into the flanges of the servo


Turn the PCB over and take the servo wire


Wrap it around the servo twice then plug the end into the 3-pin connector. Brown wire to the pin labelled GND, Red to VCC and Orange to P15


Step 4: Fit the Floating Jaw


You will require Talon B and the M3 nylock nut.

Fit the Talon B board onto the pillar so the the Talon logo is facing towards the talon Base PCB

Then screw on the nylock nut all the way, then undo it about quarter of a turn until the Talon B jaw can move freely without wobbling up and down



Step 5: Fit the Servo Arm to the Driven Jaw


You will need Talon A, the straight servo arm (from the servo bag) and the 2 small self-tapping screws (not the longer ones in the servo bag)

DO NOT pass the large shaft on the servo arm through the PCB. This shaft needs to be facing away from the PCB.


The screws then pass through the PCB into the Servo Arm and should be tightened.


Do NOT fit this arm to the Talon assembly yet. We need to get the servo working from the Bit:Bot first


Step 6: Fit the Talon Assembly to the Bit:Bot


You will need the 4 M2.5, 12mm pillars and 4 of the M2.5 6mm screws

Screw from the bottom of the Bit:Bot into each pillar, and tighten well. The pillars should be point upwards


Then using 4 more of the M2.5, 6mm screws, attach the Talon assembly to the top of the pillars.


Note that the servo should be at the top and the floating jaw at the bottom



Step 7: Fit the Driven Jaw (Talon A)


You will need the small screw in the servo bag to attach the drive jaw to the servo.

But first: Set the servo to position 5 degrees. If using the Makecode Bit:Bot package, then use the open talon block:



Once the servo is in the correct position, then fit the Talon A jaw, making sure it is closed and is interlocking with the floating jaw (Talon B)


Screw the little screw into the servo shaft to hold it in place


All done! Now you can open and close the jaws by setting the claw/talon to different values between 0 (fully closed) and 90 (fully open)

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 https://github.com/4tronix/cubebit

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


Click on any photo to enlarge

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

Make sure you are adept at soldering. There are plenty of good soldering videos on the web and other resources to get you going.

Solder this kit by fitting the lowest height 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 terminals 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 forms a smooth joint all round.
  5. Cut all the pins neatly underneath using side-cutters, 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 the notch 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: https://github.com/4tronix/BitCommander



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
music.play(music.ENTERTAINER, 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



  • MusicBox.py 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
  • NoteSynch.py  this micropython works in a similar way to MusicBox.py, 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 www.arduino.cc 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 and XL

CrumbleBot 2 and CrumbleBot XL – 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


Assembling CrumbleBot Mk2 and XL

Click any photo to enlarge

Step 1 – Check you have the correct Parts


You should have the following items in the box:

  • CrumbleBot Mk2 or XL main circuit board
  • 2 x Wheels
  • Battery Holder PCB
  • 10 x small 7mm pillars to mount Crumble (not required for version 2.1 or XL as pillars are pre-fitted)
  • 2 x larger 12mm pillars to mount battery holder
  • Caster ball and housing (Mk2 only – prefitted on XL)
  • 2 x M2, 6mm screws to attach caster (Mk2 only)
  • 2 x M2 nuts for caster (Mk2 Only)
  • 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 (Mk2 only)





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.

Caster is pre-fitted on CrumbleBot XL


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


NB. V2.1 and XL 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.

CrumbleBot XL has an extra position on the left side. This to enable the ultrasonic sensor and connect it to I/O pin A


Step 8 Optional – Add the Ultrasonic Distance Sensor


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

For Mk2, to connect the sensor to the Crumble, you must use one of the 12cm jumper wires to connect to a GPIO pin. On XL use the yello jumper in its most forward position

All our examples use GPIO A so wire it as shown in the photo above. (Mk2 only, 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 or XL is Finished and ready for Coding!




Coding Your CrumbleBot

 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 and the XL adds another position for I/O pin A. 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 (www.multiwingspan.co.uk)



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: https://github.com/4tronix/Robobit 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.