Programming Robobit Buggy in Makecode

Programming Robobit Buggy

The Microbit Makecode Package supports all version of the Robobit. Go to https://makecode.microbit.org/ or download the PC app from here 

Select Advanced or click on the gear icon, then select Extensions. Enter Robobit in the search box and search.

After it has loaded you will have an extra tool in 4tronix Orange with the Taxi icon, called Robobit

If you click on the Robobit tool, there are 3 subfolders for the Motors, the Sensors and the LedBar. There is also a single top-level block to allow you to select your model of Robobit – this should be used at the very start as shown below. In fact it can be the only thing in the start block

Now you are ready to start programming…

Programming the Motors

It’s a robot – you want it to move. So let’s see what we need to do.

The motors are individually controllable. So if you want, you can set different speeds for the left and right motors. But to start simply, let’s just drive forwards and backwards.

Forwards is represented by speeds from 0 to 1023. Backwards is speeds from -1023 to 0.

In both cases, 1023 is the fastest and 0 is dead stop. You will find that speeds below 200-300 may not be able to move the robot very much (it depends on battery levels, how “free” the motors are, etc)

The following code simple drives forwards at speed 600 (both motors at the same speed) for 1 second, stops for a second, then reverses and stops again. It repeats this forever

Yes, we have a moving robot!

NB. You may find, especially when the motors are new, that they go at different speeds and it doesn’t travel in straight lines. This is normal. The motors have a 10% speed tolerance, so can always be different speeds, but when they are new they can be especially stiff and even more different. Run the motors at full spoeed for a few minutes to free them up.

 

More Complex Motor Control

We can try and move in a square, or other shape. Great if you’re on a piece of paper and using the pen (Pen holders are designed for Sharpie felt tip pens – other pens are available)

Drive forwards for a bit, turn for a bit and do this 4 times. If you get the speed and times correct then a square can be formed. You will have to experiment with the speeds and times

The code above (click to enlarge) will do a four-sided figure and then stop. You will have to adjust the timings and/or speed of the spin to get it to accurately draw a square.

Of course, this software is tedious. It does the same thing 4 times. It would be better to use a loop function like this:

Here, we are using the “repeat nn times” block from the “Loops” toolbox

 

Now Let’s Flash some LEDs

It’s always fun to light LEDs and especially fun if you can control them individually with different brightness and colours.

The Robobit Mk3 and the Mk2 with LedBar have a row of 6 LEDs across the front as well as one in each front corner for a total of 8.

Scanner Feature

The Makecode package has a unique “Larsson Scanner” feature built-in which enables you to very easily scan the centre 6 LEDs back and forth at your choice speed and colour. Let’s do this to start with:

From the LedBar section of Robobit, select the “start scan…” block and insert it into the program after setting the required Robobit model. Here we are using a Mk2 Robobit with a LedBar attachment.

This code will immediately start the centre 6 LEDs scanning using various intensities of Red, with a delay of 100ms between changes, just like the Knight Rider KITT car!

Standard LED Programming

Normally when using the LEDs you will set on or more LEDs to a particular colour depending what you want the program to display. To do this, you need to understand how to work with individualy LEDs.

There are blocks you can use to set individual LEDs (or pixels), or all the LEDs at the same time. You can select colours using the names of colours (eg. Red, Yellow, Green, etc) or you can specify your own colour in terms of Red, Green and Blue components. All these blocks set the memory in the Microbit for the LEDs, but they do NOT update the LEDs with this memory information. To do that, you must use the most important block of all:

After doing this, all the changes you have made will be shown on the LEDs.

The other thing to remember is that the 8 LEDs are numbered from the left at 0 to the right at 7. So to flash the leftmost LED in Orange, we could do this:

This will set the LED at position 0 to orange, then wait for half a second, then set the LED to black (this is the same as OFF), then wait another half a second. Then this keeps repeating forever. Notice that each time we update the LED information, we than “show the LedBar changes”.

 

Using Sensors

Depending on your Robobit model and options fitted you may have an Ultrasonic Distance sensor and/or line following sensors. For the Robobit Mk3, these are both included as standard. For the Mk2, they can be purchased as options.

The Robobit Makecode extension includes blocks for using these easily.

Line Following Sensors

There are 2 of these mounted underneath the buggy, close to the front caster. They both use the same hardware sensor (TCRT5000) but the integrated ones on the Mk3 use 4tronix electronics specifically designed for this application whereas the Mk2 uses generic modules which have a trimmer on. Turn this until the LED turns off when it goes over a black line. You will find that the integrated units perform better.

The key thing to remember is that the Robobit buggy and the motors have a lot of interia when moving and cannot stop very quickly, so you must design your line follower program to move slowly (there are clever things that can be done, but we won’t look at that now). The Mk2 will have to go slower than the Mk3 because of the difference in sensitivity of the sensors.

To create a track to follow, you can use black electrical tape, or a permanent black marker. The surface needs to be reflective and the tape or marker pen needs to be not reflective. I prefer to print the tracks using track tiles from RobotSquare as these work excellently.

The simplest algorithm will be to check each sensor. If it is over a line, then turn the buggy that way, otheriwse carry straight on. Keep checking in a loop like this:

Note that we are using speeds of less than 400. For a Mk1 or Mk2 you will probably have to go even slower.

This is a very basic algorithm and will have problems with junctions on the track etc. it also won’t do very well in a speed trial.

 

Ultrasonic Distance Sensor

These little sensors work like bats, by sending out an ultrasound ping and waiting for the echo to come back. The time for the echo to come back, together with the speed of sound, gives us an idea of the distance. Do not expect ultimate accuracy from these sensors.

You can choose to get the distance back in different units: centimetres, inches or microseconds. These examples all use centimetres (cm).

Obstacle Avoider

This simple program drives forwards until it detects an obstacle, then spins and reverse to avoid it before setting off again.

The first block checks if the robot is within 20cm of an object. If it is then it reverses at speed 500 for half a second, before turning left for 400ms. If it is not less than 20cm from an object it just drives straight on at speed 600.

 

Follow Me Program

This fun little program drives forwards until it gets close to an object and then stops. Then if the object (eg. your leg) gets further away, it will start moving again to follow you. However, if your leg gets closer then it will back away trying to keep the same distance from you:

In this one, we have created a variable called Distance so that we can check it against 2 values without reading the sensor again. Here we reverse the robot if it less than 20cm away and go forwards if it is more than 30cm away. Between 20cm and 30cm the robot will stay still.

Robobit Buggy Mk3

Assembling and Using Robobit Mk3

Robobit Mk3 buggy is a fully integrated and updated version of the Mk2 with all options (except Talon grabber) ready integrated into the unit

Purchase Robobit Mk3 here

Features

  • Compact design DIY robot that is easy and quick to build
  • No soldering required. Screwdriver and spanner widget included and are the only tools required
  • Presented in an attractive gift box
  • Integrated ultrasonic distance sensor
  • Integrated line follower sensors
  • Integrated pen holder (designed for Sharpies, but other pens will fit)
  • Integrated RGB smart LEDs (aka neopixels) with semi-automatic Larsson scanner function
  • Fully supported by the Microsoft Makecode extension – search extensions for “Robobit”
  • Powered by 4 x AA batteries (not included)

Assembly

Step 1 – Check you Have the Correct Parts

IMG_2444a

  • Main PCBA with prefitted ultrasonic sensor
  • Battery Holder PCBA (NB. Ring fits to rear of robot – no matter what it says on it!)
  • 2 x bags with motor mountings
  • Bag with 6 x 6mm M2.5 screws and 2 x 25mm pillars
  • 2 x motors with pre-fitted cables and plugs
  • 2 x Wheels

You should also have 2 tools: a double ended screwdriver (pull out of handle and turn round ot get alternate end), and a Pimoroni “spanner widget” for the motor mount nuts

 

Step 2 – Fit the motor brackets to the Motors

IMG_2445a

Mount the brackets the opposite way to each other so you have left hand and right hand assmblies as shown.

Use the Pimoroni spanner widget to held the nuts while you tighten the screws.

NB. Very important to ensure the edges of the nuts are flat with the top of the motors or the motors will be at a strange angle when fitted.

 

Step 3 – Fit Motors to Mainboard

IMG_2446a

Use th two 10mm screws in each motor mount bag to fit the motors to the top of the main PCBA as shown above

Ensure the axles are at the rear and facing outwards.

IMG_2447a

Tighten the screws fully

 

Step 4 – Fit the Front Caster

IMG_2448a

Remove the ball if it is supplied already in the housing

Use two of the 6mm screws to fit the housing the the bottom of the main board as shown above

 

Step 5 – Fit the Battery Mounting Pillars

IMG_2449a

Use two of the 6mm screws to fit the 25mm pillars as shown above

Tighten up fully

 

Step 6 – Attach the Battery Holder

IMG_2450a

Use the remaining two 6mm screws to attach the battery holder firmly

Ensure the pen holder ring of the battery holder is directly above the pen holder hole in the main board

 

Step 7 – Finish

Push on the wheels and pop in the caster ball

Fit batteries.

Add your Micro:Bit and start programming!

Visit Programming Robobit Buggy

 

Talon Grabber Assembly & Use

Talon Grabber for Bit:Bot and Robobit Buggy

IMG_2245a

 

Purchase Talon here

 

Assembling Talon for Bit:Bot

Step 1 – Ensure you have all the parts

IMG_2225a

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

Step2

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

Step3a

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

Step3b

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

Step3c

Turn the PCB over and take the servo wire

Step3d

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

Step4a

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

Step4b

 

Step 5: Fit the Servo Arm to the Driven Jaw

Step5a

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.

Step5b

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

Step5c

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

Step6a

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

Step6b

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

Step6c

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

Step6d

 

Step 7: Fit the Driven Jaw (Talon A)

Step7a

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 set claw block:

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

Step7b

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

Cube:Bit

Magical RGB “neo-pixel” Cubes of awesome

IMG_2188a

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.

Cubebit_Package01

 

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

IMG_2198a

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

IMG_2199a

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

IMG_2200a

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

IMG_2201a

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

 

Step 3 – Prepare the Second Slice

IMG_2202a

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)

IMG_2203a

 

Step 4 – Fit the Prepared Second Slice

IMG_2204a

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

IMG_2205a

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

IMG_2279a

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

IMG_2206a

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

IMG_2207a

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.

Connections:

  • 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

IMG_2208a

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

 

IMG_2209a

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

 

Bit:Commander Games Consoler & Controller

Bit:Commander for BBC micro:bit

IMG_1812a

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

 

Overview

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

 

Resources:

Music:Box with Blinkie Plugins

Music:Box with Blinkie Plugins

IMG_1701a

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

Specification:

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

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.

Phew!

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
np.show()

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

 

Examples

  • 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

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

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

IMG_1053a

[Click on any image to enlarge]

Purchase >HERE<

Overview

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

 

Configuration

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

GPIO Pin

Physical Pin

0

04

7

1

17

11

2

18

12

8

27

13

12

22

15

16

23

16

5

24

18

11

25

22

13

SCL

5

14

MISO

21

15

MOSI

19

19

SCLK

23

20

SDA

3

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

IMG_0904a

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

Overview

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

IMG_0898a

 

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

IMG_1474a

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

 

step01

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

IMG_1475a

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

IMG_1476a

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.

IMG_1477a

Screw the 20mm pillars on tightly as shown above.

IMG_1478a

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

IMG_1479a

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

STP51

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

STP52

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

STP53

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

STP54

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

STP55

Finally, add the second motor and screw tightly together

 

Step 3. Prepare the Robo:Bit for Fitting

STP56

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

STP57

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

 

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

STP58

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

STP59

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

STP60

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

STP61

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

step03

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

step04

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.

step06

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

step07

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

step09

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

step10

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

IMG_1492a

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

IMG_1493a

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

step11

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

step12

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

step22

  • 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

step24

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

step26

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

step28

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

bb01

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.

 

Features

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)

 

Assembling

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)

Step1

Step2

Step3

Step4

Step5

 

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.

Step6

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

 

Step7

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

 

Step 3 – Fit the Wheels

Step8

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

 

Step 4 – Attach your BBC micro:bit

Step9

 

Know Your Bit:Bot

Above

bb17a

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

 

Below

bb15a

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

Motors

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.

LEDs

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.

Sensors

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)

Buzzer

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

Motors

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:

pin0.write_digital(1)
pin8.write_digital(0)

Move left motor Reverse:

pin0.write_digital(0)
pin8.write_digital(1)

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%

pin1.write_analog(770)
pin12.write_digital(0)

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%

pin1.write_analog(253)
pin12.write_digital(1)

 

Neopixels

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)
np.show( )

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 np.show( )

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( )
    else:
        forward(speed)

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()

 

Buzzer

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:
    pin14.write_digital(1)
    sleep(400)
    pin14.write_digital(0)
    sleep(400)

Ultrasonic Distance Sensor

This optional HC-SR04 ultrasonic distance sensor addon can be used most easily in Microsoft PXT. In MicroPython we are hampered by the lack of a microsecond resolution timer. (but see the demo “Ultrasonic Obstacle Avoider” below)

Example Micropython Programs

 

 

Playground for Crumble, Micro:Bit & Raspberry Pi

Playground for Crumble, BBC Micro:Bit and Raspberry Pi

IMG_0999b PlayMicro03aPlayCrum_03

(Click on any image to enlarge)

 Purchase Here

Playground Overview

The Playground system allows you to connect external electronics (inputs, outputs, sensors, etc.) to your controller. Currently supports Crumble (from Redfern Electronics), Raspberry Pi and the BBC micro:bit.

The connections from the controller are converted to 3-pin 3.5mm jack connections and the connecting cables are 20cm jack cables – although longer cables can be used if required.

The separate electronic parts, Gizmos, can be used with any Playground. The exception being the Motor Gizmo, which can only be used with Crumble, as the micro:bit does not have integral motor drivers.

All of the Gizmos can be used within your programs using the built-in drivers for the relevant part.

Because each connection includes the necessary power and ground, you don’t need to wire these in separately – this transforms what can be a complicated and messy wiring setup into something tidy and more easily understood

Please check out these videos for Playground for Crumble and Playground for MicroBit

 

Installing Raspberry Pi Software

We have created a python library module that allows you to use the Playground for Raspberry Pi easily and quickly. You can install this from your Raspberry Pi connected to the internet as follows.

  • Download the latest version of the software using wget like this from a command line (eg. LXTerminal):
    wget http://4tronix.co.uk/pg.sh -O pg.sh
    bash pg.sh
  • This will create a new folder on your Pi in the /home/pi folder called playground (all lower case) with the playground.py library module and example files

 

Gizmos

IMG_0337a

Initially, we have 11 Gizmos for sale. These have been colour-coded in a similar way to our Crumbs:

  • Blue:  Digital inputs, such as a Button or Touch sensor
  • Yellow:  Analog inputs, such as a Light sensor or Dial
  • Black: Digital outputs, such as LEDs or Buzzer
  • Red:  Analog outputs such as the Servo or Motor
  • White:  Smart Pixels (aka “neopixels” or “sparkles”), individually addressable, chainable, RGB pixels (Flame, Blaze and Fire Stick)

 

Button Gizmo

Button_02

This provides a simple digital input to Playground. It is Active (High) when pressed and inactive (Low) when not pressed. There is a white indicator LED to show whether it is active or not.

Worksheet Links: Crumble  BBC micro:bit   Raspberry Pi

 

Touch Sensor Gizmo

Touch_02

This provides a digital input to PlayGround. Simply touch the pad on the sensor for it to become active (High) and release for it become inactive (Low). There is a white indicator LED to show whether it is active or not. In fact the sensor will detect your finger without actually touching, so you can do experiments to see how many sheets of paper you can cover it with before it stops working

Worksheet Links: Crumble  BBC micro:bit  Raspberry Pi

 

Dial Gizmo

Dial_02

The Dial Gizmo provides an analog input to your Playground. On the Crumble it will read from 0 to 256, while on the micro:bit it will go from 0 to 1023. The actual top end number will vary due to various losses in the system

Worksheet Links: Crumble  BBC micro:bit    Raspberry Pi

 

Light Sensor Gizmo

Light_02

The Light Sensor Gizmo is an anlog input Gizmo that reacts to the brightness of light to the sensor in the centre. It is tuned to be sensitive to daylight. The values vary from 0 (dark) to 256 (bright) on the Crumble, while on the micro:bit it will go from 0 to 1023. The actual top end number will vary due to various losses in the system

Worksheet Links: Crumble  BBC micro:bit  Raspberry Pi

 

Traffic Light Gizmo

Traffic_02

The Traffic Light Gizmo is a digital output Gizmo for your Playground. Each of the large 10mm LEDs will turn on when the appropriate input is set to High. There are three inputs, one for each of Red, Amber and Yellow

Worksheet Links: Crumble  BBC micro:bit  Raspberry Pi

 

Buzzer Gizmo

Buzzer_02

The Buzzer Gizmo is a digital output Gizmo for your Playground. When the input is set to High, the buzzer will sound and a white indicator LED will light

Worksheet Links: Crumble  BBC micro:bit  Raspberry Pi

 

Flame Gizmo

Flame_01

The Flame Gizmo provides a single, fully controllable, RGB pixel. This allows you to change the colour to any one of 16 million different colours. These are chainable, with both an input and an output connector. On the Crumble, these “smart pixels” are referred to as “Sparkles”, while on the micro:bit they are known as “neopixels”

Worksheet Links: Crumble  BBC micro:bit  Raspberry Pi

 

Blaze Gizmo

Blaze_02

The Blaze Gizmo gives you a ring of 8 , independently controllable, RGB pixels. This allows you to change the colour of any or all of them to any one of 16 million different colours. On the Crumble, these “smart pixels” are referred to as “Sparkles”, while on the micro:bit they are known as “neopixels”. These can be added onto the end of a chain of Flame Gizmos if required, or used on their own

Worksheet Links: Crumble  BBC micro:bit  Raspberry Pi

 

Servo Gizmo

Servo_02

As the name suggests, this Gizmo allows you to very easily connect a miniature 9g servo to your Playground. Plug it in, then program it for a 180 degree range of movement

Worksheet Links: Crumble  BBC micro:bit  Raspberry Pi

 

Motor Gizmo

(Not compatible with micro:bit Playground)

Motor_01

The Motor Gizmo is driven directly from the Crumble motor driver outputs – it cannot work with the micro:bit. Use the Crumble motor control blocks to set the speed and direction of up to 2 Motor Gizmos. You can build yourself a robot very easily with 2 of these

Worksheet Links: Crumble  (BBC micro:bit and Raspberry Pi not available – a prototype motor Gizmo for Pi is shown at top of page – this has a built in motor driver.)

 

Prototyping Gizmo

Proto_01

This simple Gizmo allows you to build your own Gizmo for those inputs or outputs that are not yet available as a ready-made Gizmo. For instance, you could make a temperature sensor, or have a controllable relay. The board has 4 holes for the Signal, 6 for each of Power and Ground, and 48 for you to use for your creation.