micro:bit MicroPython in 60 minutes

even if you’ve never programmed in Python before!

Romilly Cocking
This book is for sale at http://leanpub.com/microbitmicropython

This version was published on 2017-03-16

This is a Leanpub book. Leanpub empowers authors and publishers with the
Lean Publishing process. Lean Publishing is the act of publishing an in-progress
ebook using lightweight tools and many iterations to get reader feedback, pivot
until you have the right book and build traction once you do.

This work is licensed under a Creative Commons Attribution-ShareAlike 4.0

International License
Thanks to Ben Nuttall of the Raspberry Pi Foundation for creating the opportunity,
and to @sooseeg and @scipiguy for their encouragement and support.
Contents

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
What you will do . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
What you will need . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
You don’t have to finish everything in 60 minutes . . . . . . . . . . . . . . . 2
Let’s get started with mu! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2

Plugging in your micro:bit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

Using mu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

Hello World! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
Typing in a program . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

Images . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
Displaying a happy face . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
Changing the display to a sad face . . . . . . . . . . . . . . . . . . . . . . . . 10
Looping - repeating code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
Making your own images . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
Animation - images that change . . . . . . . . . . . . . . . . . . . . . . . . . 13

Buttons . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

Moving and shaking . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

print() and the REPL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
Repl stands for Read, Evaluate, Print Loop . . . . . . . . . . . . . . . . . . 17
Time to get coding! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
Time for some fun . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

What’s next . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
More stuff the micro:bit can do . . . . . . . . . . . . . . . . . . . . . . . . . 21
Help, please . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
Where to find out more . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

Licence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
Introduction
What you will do

In this 60 minute workshop you will use the mu editor on a Raspberry Pi to write
MicroPython programs and run them on the micro:bit.
MicroPython is a small but very fast version of Python 3 that has been specially
designed to work on microcontrollers such as those found on the micro:bit.
The experiments will show you some of the things the micro:bit can do. You can
use them as a base to build your own projects.
At the end of this workbook you will find some links to help you explore once the
workshop is over.

What you will need

You’ll need a BBC micro:bit and its USB connector. You don’t need a battery, as the
micro:bit will be powered via USB.

If you have a Raspberry Pi

This workbook assumes that you have a working Raspberry Pi with screen, key-
board and mouse, that you will connect via USB to a BBC micro:bit.
 Introduction 2

If you have a Raspberry Pi you will need to install the mu editor before you can
start editing.
Open a terminal window and run the following commands:

1 sudo apt-get update

2 sudo apt-get upgrade
3 sudo apt-get install mu

If you don’t have a Raspberry Pi

If you don’t have a Raspberry Pi, don’t despair. You can use a desktop or laptop
computer with the micro:bit, and you can use the mu editor with Microsoft
Windows, Mac OS or Linux. You’ll find instructions for downloading and installing
mu here

You don’t have to finish everything in 60 minutes

You’ll have plenty of fun things to do over the next 60 minutes, but don’t feel you
have to do all of the experiments right now. The workbook covers most of the
features of the micro:bit, and you’ll find plenty to do after the workshop is over.

Let’s get started with mu!

1. If you haven’t installed the mu editor on your Raspberry Pi, open a terminal
window, type sudo apt-get install mu and wait for the installation to finish.
2. On the Pi, open Mu from the main menu under Programming.
3. A new window should open up that looks like this:
Introduction 3

mu screenshot
Plugging in your micro:bit
The micro:bit has a micro USB port that you can use to connect it to your Raspberry
Pi. This will provide a power and data connection.

1. Connect your Raspberry Pi to the micro:bit using a USB A-to-micro-B cable,

as shown below:

usb setup
2. You’ll know that the micro:bit has connected to your Raspberry Pi, because a
dialogue box should pop up like the one below:
Plugging in your micro:bit 5

screen2
3. This dialogue box might pop up a few times while you’re playing with the
micro:bit. You can simply click on Cancel when it does.

Using mu
The mu software has been designed with young learners in mind. It has a very easy
to use interface, and most of the menu items should be self-explanatory.

screen3
Plugging in your micro:bit 6

1. The New button will open a new file. In mu this is done in a new tab. Have a go
opening a few new files, and then closing them again.
2. The Load button is for opening existing code that you have written.
3. The Save button saves any work you have in the visible tab.
4. The Flash button will push your code onto the micro:bit. You’ll learn more
about this later on.
5. The Repl button opens an interactive shell. This is covered in the next
section.
6. The Zoom buttons will alter the size of the text in the window.
7. The Theme button switches between light and dark themes. You can choose
your preference.
8. The Help button will open the Epiphany web browser and take you to the help
pages.
9. The Quit button will close mu.
Hello World!
Typing in a program
In the mu editor, click the + (new) icon. You should see a new tab open in the editor.
That’s where you will type your code.
The first program you’ll run is the micro:bit version of Hello World.
Here’s the short program:

Hello World program

Here’s what each line means:

1. from microbit import * tells MicroPython that you want to use the microbit
module. (In Python, a module is some code that is already written, ready for
you to use if you want to.)Â
2. display.scroll('Hello World') will scroll the string ‘Hello World!’ across the
LEDs on the micro:bit.
Hello World! 8

Save it, Flash it, Watch it run!

1. Now you can save your file. Click on mu’s Save button. Call the file hw.py
2. Next, you need to use the mysterious Flash button. Press the button and a
dialogue box should appear:

Flashing dialogue

After a few seconds, another dialogue will open, telling you about the mount-
able file system. You can close both dialogues.

Once your program has been flashed (installed in the micro:bit’s memory), you
should see ‘Hello World’ scroll across the LEDs on the front of the micro:bit.

Troubleshooting
The display will finish quite quickly. If you missed it, just press the button that is
underneath the microbit next to the USB cable. This will restart the micro:bit and
your program will re-run.
If you don’t see the display that you expected, here are some steps to help you find
out what went wrong.

1. Carefully check what you typed. It’s easy to make a mistake, and the computer
cannot guess what you meant to type! If you spot a mistake, correct it and
flash the program again.
Hello World! 9

2. If you can’t spot a mistake, ask someone else to check your program. It’s often
easier for them to spot a mistake than it is for you, because you may be seeing
what you meant to type rather than what is actually there!
3. If you’re using this workbook in a workshop, ask the workshop leader.
4. If that doesn’t help you can join this workbook’s private FaceBook group.

You’ll have to ask to join; then you can ask your question. Don’t be embarrassed.
Just about everyone makes some mistakes when they program.
 Images
The micro:bit only has 25 LEDs but that’s enough for it to display recognisable
images.
In this experiment you will write code to

1. display images on the LEDs.

2. change the display while your program is running,
3. display an animation and
4. create your own images

You may not have time to do all these activities today but you can try them out
later.

Displaying a happy face

Open a new tab in mu and type in this program:

1 from microbit import *

2 display.show(Image.HAPPY)

You’ve seen the first line before. It says you want to use the microbit module
(library).
The second line tells the micro:bit display to show an image. In this case, the image
is pre-defined in the microbit module, and you can refer to it as Image.HAPPY
Save your program as happy.py and click mu’s Flash button. Two dialogs will appear
again. Close the dialogs as before. When the flashing stops you should see a happy
face displayed on the micro:bit.

Changing the display to a sad face

The next program is a little longer, but it starts the same as the previous one.
In the happy.py window, add two lines to the end of the program:
 Images 11

1 sleep(1000)
2 display.show(Image.SAD)

Your editor window should look like this:

Happy then sad

Use mu’s Flash button to install your program.

When the program runs you should see a happy face appear for a second. Then
it will be replaced by a sad face which will stay on the display until you restart the
micro:bit.

Looping - repeating code

If you make a small change to your program you can tell the micro:bit to keep
changing from a happy face to a sad face and back again.
To do that you will need to add a While loop. That is one of the ways you can get a
Python program to repeat code over and over again.
Edit your program so that it reads like this:
 Images 12

1 from microbit import *

2
3 while True:
4 display.show(Image.HAPPY)
5 sleep(1000)
6 display.show(Image.SAD)
7 sleep(1000)

Make sure that:

1. The w in while is a lower case letter

2. The T in True is an upper case letter
3. The four lines after while True: start with four spaces

Saveand Flash your code. You should see a face which changes from happy to sad
and back again. Moody or what?

Making your own images

MicroPython comes with a great set of pre-defined images but you can easily
create your own.
Try creating and running this program:

1 from microbit import *

2
3 boat = Image("05050:"
4 "05050:"
5 "05050:"
6 "99999:"
7 "09990")
8
9 display.show(boat)

Each number specifies a brightness. There are five lines of five numbers so it’s
possible to specify the individual brightness for each of the five pixels on each of
the five lines on the physical display.
That’s how to create a new image.
This example and some of those that follow were copied from the MicroPython
on-line documentation
 Images 13

Animation - images that change

MicroPython makes it really easy to create animations: images displayed in se-
quence.
To see how animations work, and to discover the full power MicroPython’s show,
copy and run this program:

1 from microbit import *

2
3 while True:
4 display.show(Image.CLOCK12)
5 sleep(1000)
6 display.show(Image.CLOCK1)
7 sleep(1000)
8 display.show(Image.CLOCK2)
9 sleep(1000)
10 display.show(Image.CLOCK3)
11 sleep(1000)
12 display.show(Image.CLOCK4)
13 sleep(1000)
14 display.show(Image.CLOCK5)
15 sleep(1000)
16 display.show(Image.CLOCK6)
17 sleep(1000)

You should see a clock with the hands going round from 12 o’clock to 6 o’clock.
That’s a lot of typing. There are easier ways to do it.
First, lets change the program to create a list.
A Python list is a collection of values in a particular order.
In the program that follows you will create a list of clock images called clock and
ask Python to show the list repeatedly.
Enter and save this program:
 Images 14

1 from microbit import *

2
3 clocks = [Image.CLOCK12,
4 Image.CLOCK1,
5 Image.CLOCK2,
6 Image.CLOCK3,
7 Image.CLOCK4,
8 Image.CLOCK5,
9 Image.CLOCK6]
10
11 while True:
12 display.show(clocks)

As you see, you can create a list in Python by enclosing several values in square
brackets and separating the values with commas.
Run this program. It should produce the same output as the earlier version but it’s
simpler and shorter.
If you wanted to display all twelve clock images you could do it by creating a larger
list containing all the values.
There’s an even simpler way. The microbit module contains a pre-built list with all
twelve clock faces.
Try entering, saving and running this code:

1 from microbit import *

2
3 display.show(Image.ALL_CLOCKS, loop=True)

Image.ALL_CLOCKS is a pre-defined list of images. The loop=True parameter in show

has the same effect as enclosing the statement in a while loop.
 Buttons
In the previous experiments you saw how to tell the micro:bit to output informa-
tion using the display.
Sometimes you want to input information as well.
One way to do that is to use the micro:bit’s buttons.
The micro:bit has two buttons labelled a and b.
You can easily test to see if a button has been pressed by using a Python if
statement.
In Python, you can program an if statement like this:
if something is true: do this
Let’s look at a specific example. The next program will display a happy face if button
a is pressed.

1 from microbit import *

2
3 while True:
4 if button_a.is_pressed():
5 display.show(Image.HAPPY)

Once the happy face has been displayed, it stays there whether the button is
pressed or not.
If you use a more powerful version of the if statement you can repeatedly check
button a. If it’s pressed, display a happy face. If it’s not, you clear the display.
Here’s the code:

1 from microbit import *

2
3 while True:
4 if button_a.is_pressed():
5 display.show(Image.HAPPY)
6 else:
7 display.clear()

\newpage
Moving and shaking
In the experiments so far you have used the micro:bit LEDs and buttons, but this
cool computer has several other useful peripherals on board.
You’re about to experiment with the accelerometer - a chip which measures
acceleration.
We say that something accelerates when it changes speed or direction. Cars, bikes,
aeroplanes accelerate; so you you, when you start or stop walking, or break into a
run.
If the micro:bit is moved or shaken, it accelerates and the acceleration is measured
by its accelerometer.
The chip on the micro:bit can measure acceleration in three axes (directions), called
x, y and z.

• The x axis corresponds to acceleration to the left or right

• The y axis corresponds to acceleration forward or backwards
• The z axis corresponds to acceleration up or down

Micro:bit X axis

print() and the REPL

In the first accelerometer experiment you’ll run a program that prints out the
micro:bit’s acceleration along the x, y and z axis. That’s a bit of a challenge; you
can’t use the display becuase it’s too slow. By the time you read a displayed value,
the micro:bit might have changed direction or stopped accelerating.
Fortunately there is a faster way of showing the output from a Python program.
it’s called the print function.
Moving and shaking 17

When you run Python on a Laptop or desktop computer, a print statement in your
program will display output on the console - the window in which you started the
Python program.
The micro:bit has no console, but you can still see the output of print statements.
One way to do that is to use the Repl button on the mu program window.

mu window

Repl stands for Read, Evaluate, Print Loop

REPL

Arrow Icon made by Catalin Fertu

When you open the Repl window in mu, you can 1. Execute Python code and see
the result 1. See the printed output from a running program.
That’s enough background.
 Moving and shaking 18

Time to get coding!

Open a new mu window and enter the following program:

1 from microbit import *

2
3 while True:
4 print(accelerometer.get_x(), accelerometer.get_y(), acceleromete\
5 r.get_z())
6 sleep(100)

Now use the flash button to install it on the microbit.

When the micro:bit has finished flashing, your program will start running.
What can you see? Nothing!
The program is printing output, but you can’t see it yet.
To see it, you need to do two things:

1. Click on the repl button on mu’s interface. This will interrupt your program
and open mu’s repl window.
2. Restart your program using the micro:bit’s restart button.

Now you should see a stream of numbers scrolling in the mu repl window.

Time for some fun

Open a new mu window and enter the following program:

1 # Magic 8 ball by Nicholas Tollervey. February 2016.

2 #
3 # Ask a question then shake.
4 #
5 # This program has been placed into the public domain.
6 from microbit import *
7 import random # we'll need a random choice to pick a reply
8
9 # create a list of possible answers
10 answers = [
11 "It is certain",
12 "It is decidedly so",
13 "Without a doubt",
 Moving and shaking 19

14 "Yes, definitely",
15 "You may rely on it",
16 "As I see it, yes",
17 "Most likely",
18 "Outlook good",
19 "Yes",
20 "Signs point to yes",
21 "Reply hazy try again",
22 "Ask again later",
23 "Better not tell you now",
24 "Cannot predict now",
25 "Concentrate and ask again",
26 "Don't count on it",
27 "My reply is no",
28 "My sources say no",
29 "Outlook not so good",
30 "Very doubtful",
31 ]
32
33 # Here's the main loop. It will display an 8 and test if the micro:b\
34 it was shaken.
35 # If it was, it will pick a reply at random and display it.
36 # Finally it will go to sleep for 1/100th of a second and then go ar\
37 ound the loop again.
38
39 while True:
40 display.show('8')
41 if accelerometer.was_gesture('shake'):
42 display.clear()
43 sleep(1000)
44 display.scroll(random.choice(answers))
45 sleep(10)

The first thing to notice is that the program has lines beginning with a hash
character #.
(Its proper name is an octothorpe, but in the UK everyone calls it a hash.)
In Python, everything on a line after a hash character is ignored (by Python), so you
can type a helpful explanation for anyone who reads your code.
Comments are a great way to explain why you wrote a program the way you did,
and they can aso be used to tell the reader who it was that wrote it.
After the introductory comment, the program
Moving and shaking 20

1. imports the microbit module

2. creates a list of answers
3. when shaken, picks a random answer and displays it
4. sleeps for 1/100th of a second (10 milli-seconds)
5. loops back to step 3 for ever.
What’s next
If you want to explore the workbook later you will need a micro:bit and another
computer to program it. The mu editor runs on the Pi, but it is also available for
Microsoft Windows, MacOS and other versions of Linux.

More stuff the micro:bit can do

The micro:bit has a lot of additional hardware that we haven’t covered in this
workshop. There’s an accelerometer which can detect when the micro:bit is moved
or shaken. There’s an electronic compass which can tell you where North is. There’s
a radio, which means that two more micro:bits can send signals to each other.
There are Digital inputs which can be used to keep track of what’s happening in
the outside world, and Digital Outputs which you can use to control more LEDs or
control motors.
There are Analog Inputs which can measure voltages, and you can use them with
sensors to measure how light or dark the room is, or whether it’s hot or cold.
You can send information between the micro:bit and another computer, and you
can connect the micro:bit to other chips to add even more abilities.

Help, please
I’d appreciate your help.
I published this free book on LeanPub in order to make it easy for you to get started
with MicroPython on the micro:bit. If you get the (free) version on Leanpub, you
will also get future updates free.
To help me improve it, could you take five minutes to fill out a short online survey?

Where to find out more

You’ve seen a bit about how to program in Python but you can do much more with
the micro:bit that you have had time to cover today.
There’s a great free Python Introduction on the Raspberry Pi website.
It shows you how to program in Python on the Raspberry Pi. Python 3 on the Pi
is the same language as MicroPython. The only difference is that MicroPython has
its own modules for controlling the micro:bit.
There are several places where you can find out more about the micro:bit.
What’s next 22

• The micro:bit foundation website

• The Raspberry Pi Foundation website has several worksheets in its learning
section. I used some of their material at the start of this workbook.
• microbit playground
• RAREblog The place where I blog about my own experiments, including a lot
about the micro:bit, the Raspberry Pi and Robots.
• follow me on twitter for tweets about robots, electronics, Arduino and mi-
cro:bit
• You can join this workbook’s private FaceBook group. You’ll have to ask to
join. (That helps us keep spammers at bay!)

You can contact me by email: I’m romilly.cocking@gmail.com

Have fun and keep learning!
Licence
Unless otherwise specified, everything in this repository is covered by the following
licence:

MicroPython and micro:bit in 60 minutes by Romilly Cocking is licenced under a

Creative Commons Attribution 4.0 International License.
Based on works at https://github.com/raspberrypilearning/getting-started-with-
microbits and https://github.com/romilly/pi-towers-workshop
Getting started with micro:bits by the Raspberry Pi Foundation is licenced under
a Creative Commons Attribution 4.0 International License.