Skip to content

Exercise Solutions

These are a solution to each exercise. There are many ways to solve a programming problem. If your program produces the required result, it solves the problem.

Your First Program

Exercise 1

1
2
3
4
5
6
7
from microbit import *

# Main loop
while True:
    display.scroll("Coding is fun!")
    display.show(Image.HEART)
    sleep(1000)

Exercise 2

1
2
3
4
5
6
7
8
9
from microbit import *

# Main loop
while True:
    display.scroll("Hello world!")
    display.show(Image.HAPPY)
    sleep(1000)
    display.show(Image.DUCK)
    sleep(1000)

Exercise 3

The micro:bit shows the message and the heart once, then stops. Without the while True: loop the code runs in sequence from top to bottom, reaches the end and finishes. The loop sends the program back to the top so it repeats.

Exercise 4

The micro:bit turns off when unplugged because it gets its power from the computer. When it is plugged back in, nothing happens because the program is still only on the computer. It hasn't been uploaded to the micro:bit.

Display

Exercise 1

1
2
3
4
5
6
from microbit import *

# Main loop
while True:
    display.show("Year 8", delay=500)
    sleep(1000)

Exercise 2

1
2
3
4
5
6
from microbit import *

# Main loop
while True:
    display.show(3.14159, delay=200)
    sleep(1000)

Exercise 3

1
2
3
4
from microbit import *

# Setup
display.show(3.14159, delay=500, loop=True)

Exercise 4

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
from microbit import *

# Main loop
while True:
    display.show(Image.HEART)
    sleep(200)
    display.show(Image.HEART_SMALL)
    sleep(200)
    display.show(Image.HEART)
    sleep(200)
    display.show(Image.HEART_SMALL)
    sleep(600)

Exercise 5

1
2
3
4
5
from microbit import *

# Main loop
while True:
    display.show(Image.ALL_CLOCKS, delay=500)

Exercise 6

1
2
3
4
5
6
7
8
from microbit import *

# Main loop
while True:
    display.show(Image.DIAMOND_SMALL)
    sleep(200)
    display.show(Image.SQUARE_SMALL)
    sleep(200)

Exercise 7

The pixels flash on and off too quickly to see. The micro:bit runs much faster than our eyes can follow, so each pixel is cleared almost as soon as it is turned on. sleep(50) keeps each pixel lit long enough to be seen.

Exercise 8

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
from microbit import *

# Setup
display.clear()

# Main loop
while True:
    for y in range(5):
        for x in range(5):
            display.set_pixel(x, y, 9)
            sleep(50)
            display.clear()

Exercise 9

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
from microbit import *

# Setup
glasses = Image("05050:"
                "99999:"
                "05050:"
                "90009:"
                "09990")

# Main loop
while True:
    display.show(glasses)
    sleep(1000)

Buttons

Exercise 1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
from microbit import *

import random

# Setup
target = random.randint(5, 15)

# Main loop
while True:
    display.scroll("Press A " + str(target) + " times")
    button_a.get_presses()
    display.show(Image.YES)
    sleep(5000)
    presses = button_a.get_presses()
    if presses >= target:
        display.show(Image.HAPPY)
    else:
        display.show(Image.SAD)
    sleep(2000)
    target = random.randint(5, 15)

Exercise 2

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
from microbit import *

# Setup
count = 0

# Main loop
while True:
    if button_a.was_pressed():
        count = count + 1
    if button_b.was_pressed():
        count = 0
    display.show(count)

Exercise 3

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
from microbit import *

import random

# Main loop
while True:
    target = random.choice(["A", "B"])
    for number in [3, 2, 1]:
        display.show(number)
        sleep(1000)
    display.show(target)
    button_a.was_pressed()
    button_b.was_pressed()
    start = running_time()
    while True:
        if target == "A" and button_a.was_pressed():
            break
        if target == "B" and button_b.was_pressed():
            break
    reaction = running_time() - start
    display.scroll(str(reaction) + "ms")
    sleep(1000)

Exercise 4

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
from microbit import *

import random

# Main loop
while True:
    pattern = ""
    for i in range(6):
        pattern = pattern + random.choice(["A", "B"])
    display.scroll(pattern)
    display.show("?")
    button_a.was_pressed()
    button_b.was_pressed()
    guess = ""
    while len(guess) < 6:
        if button_a.was_pressed():
            guess = guess + "A"
            display.show("A")
        if button_b.was_pressed():
            guess = guess + "B"
            display.show("B")
    if guess == pattern:
        display.show(Image.HAPPY)
    else:
        display.show(Image.SAD)
    sleep(2000)

Accelerometer

Exercise 1

Readings between -100 and 100 count as level. Change this range to make the level more or less sensitive.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
from microbit import *

# Main loop
while True:
    x = accelerometer.get_x()
    if x > 100:
        display.show("L")
    elif x < -100:
        display.show("R")
    else:
        display.show("-")
    sleep(100)

Exercise 2

1
2
3
4
5
6
7
8
from microbit import *

# Main loop
while True:
    if accelerometer.is_gesture("face up"):
        display.show(Image.HAPPY)
    else:
        display.show(Image.ANGRY)

Exercise 3

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
from microbit import *

# Main loop
while True:
    display.show(Image.YES)
    accelerometer.get_gestures()
    sleep(5000)
    gestures = accelerometer.get_gestures()
    shakes = gestures.count("shake")
    display.scroll(shakes)
    sleep(1000)

Exercise 4

1
2
3
4
5
6
7
8
9
from microbit import *

# Main loop
while True:
    if button_a.was_pressed():
        if accelerometer.was_gesture("3g"):
            display.show(Image.YES)
        else:
            display.show(Image.NO)

Temperature

Exercise 1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
from microbit import *

# Setup
lowest = temperature()
highest = temperature()

# Main loop
while True:
    temp = temperature()
    if temp < lowest:
        lowest = temp
    if temp > highest:
        highest = temp
    if button_a.was_pressed():
        display.scroll(lowest)
    if button_b.was_pressed():
        display.scroll(highest)
    sleep(2000)

Exercise 2

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
from microbit import *

# Main loop
while True:
    temp = temperature()
    if temp > 22:
        display.show(Image.ARROW_N)
    elif temp < 20:
        display.show(Image.ARROW_S)
    else:
        display.show(Image.HAPPY)
    sleep(1000)

Light Sensor

Exercise 1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
from microbit import *

# Setup
last_light = display.read_light_level()

# Main loop
while True:
    sleep(2000)
    light = display.read_light_level()
    if light > last_light:
        display.show(Image.ARROW_N)
    elif light < last_light:
        display.show(Image.ARROW_S)
    last_light = light

Exercise 2

The display is cleared before each reading, because lit LEDs affect the light reading.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
from microbit import *

# Setup
all_on = Image("99999:99999:99999:99999:99999")

# Main loop
while True:
    display.clear()
    sleep(10)
    light = display.read_light_level()
    if light < 100:
        display.show(all_on)
        sleep(1000)

Compass

Exercise 1

Headings from 338° to 22° count as North.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
from microbit import *

# Main loop
while True:
    heading = compass.heading()
    if heading > 337 or heading < 23:
        display.show("N")
    else:
        display.clear()
    sleep(100)

Exercise 2

Adding 22 then dividing by 45 splits the 360° circle into eight 45° slices centred on each direction.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
from microbit import *

# Setup
points = ["N", "NE", "E", "SE", "S", "SW", "W", "NW"]

# Main loop
while True:
    if button_a.was_pressed():
        heading = compass.heading()
        index = ((heading + 22) // 45) % 8
        display.scroll(points[index])

Exercise 3

1
2
3
4
5
6
7
from microbit import *

# Main loop
while True:
    field = compass.get_field_strength()
    display.scroll(field // 1000)
    sleep(500)

Exercise 4

Test your magnet first with the get_field_strength() example, then change 500000 to suit it.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
from microbit import *

# Main loop
while True:
    field = compass.get_field_strength()
    if field > 500000:
        display.show(Image.HAPPY)
    else:
        display.show(Image.ANGRY)
    sleep(100)

Touch

Exercise 1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
from microbit import *

# Setup
pin0.set_touch_mode(pin0.CAPACITIVE)
pin2.set_touch_mode(pin2.CAPACITIVE)
x = 2

# Main loop
while True:
    if pin2.is_touched() and x < 4:
        x = x + 1
    if pin0.is_touched() and x > 0:
        x = x - 1
    display.clear()
    display.set_pixel(x, 2, 9)
    sleep(200)

Sound

Exercise 1

This plays the opening of "Mary Had a Little Lamb".

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
from microbit import *
import music

# Setup
tune = ["E4:4", "D4:4", "C4:4", "D4:4",
        "E4:4", "E4:4", "E4:8",
        "D4:4", "D4:4", "D4:8",
        "E4:4", "G4:4", "G4:8"]

# Main loop
while True:
    music.play(tune)
    sleep(1000)

Exercise 2

This depends on your College Song. Use speech.sing() with a pitch number before each sound, as in the sing() example.

Exercise 3

sound_level() goes from 0 to 255. Dividing by 51 gives a number of rows from 0 to 5.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
from microbit import *

# Main loop
while True:
    level = microphone.sound_level()
    rows = level // 51
    display.clear()
    for y in range(rows):
        for x in range(5):
            display.set_pixel(x, 4 - y, 9)
    sleep(100)

Radio

Exercise 1

Press A on one micro:bit to give it the image to start.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
from microbit import *
import radio

# Setup
radio.config(group=7)
radio.on()
has_image = False

# Main loop
while True:
    if button_a.was_pressed():
        has_image = True
    if has_image:
        display.show(Image.DUCK)
        if accelerometer.was_gesture("shake"):
            radio.send("catch")
            has_image = False
            display.clear()
    if radio.receive() == "catch":
        has_image = True

Exercise 2

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
from microbit import *
import radio

# Setup
radio.config(group=23)
radio.on()

# Main loop
while True:
    if button_a.was_pressed():
        radio.send("yes")
    if button_b.was_pressed():
        radio.send("no")
    answer = radio.receive()
    if answer == "yes":
        display.show(Image.YES)
        sleep(500)
        display.clear()
    elif answer == "no":
        display.show(Image.NO)
        sleep(500)
        display.clear()

Exercise 3

Outside micro:bit

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
from microbit import *
import radio

# Setup
radio.config(group=42)
radio.on()

# Main loop
while True:
    radio.send(str(temperature()))
    sleep(5000)

Inside micro:bit

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
from microbit import *
import radio

# Setup
radio.config(group=42)
radio.on()
outside = "?"

# Main loop
while True:
    message = radio.receive()
    if message:
        outside = message
    if button_a.was_pressed():
        display.scroll(temperature())
    if button_b.was_pressed():
        display.scroll(outside)

Atmospheric Sensor

Exercise 1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
from microbit import *
from PiicoDev_BME280 import PiicoDev_BME280

# Setup
sensor = PiicoDev_BME280()

# Main loop
while True:
    temp, pressure, humidity = sensor.values()
    if button_a.was_pressed():
        display.scroll(round(temp))
    if button_b.was_pressed():
        display.scroll(round(humidity))

Exercise 2

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
from microbit import *
from PiicoDev_BME280 import PiicoDev_BME280

# Setup
sensor = PiicoDev_BME280()
last_height = sensor.altitude()

# Main loop
while True:
    if button_a.was_pressed():
        height = sensor.altitude()
        change = round(height - last_height, 1)
        display.scroll(change)
        last_height = height

Colour Sensor

Exercise 1

white is the amount of ambient light in lux. cct is the colour temperature in kelvin: lower numbers are warmer (more orange) light, higher numbers are cooler (more blue) light.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
from microbit import *
from PiicoDev_VEML6040 import PiicoDev_VEML6040

# Setup
sensor = PiicoDev_VEML6040()

# Main loop
while True:
    print(sensor.readRGB())
    sleep(1000)

Exercise 2

classifyHue() returns None when it can't decide, so the if colour: check skips those readings.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
from microbit import *
from PiicoDev_VEML6040 import PiicoDev_VEML6040

# Setup
sensor = PiicoDev_VEML6040()

# Main loop
while True:
    colour = sensor.classifyHue()
    if colour:
        display.show(colour[0].upper())
    sleep(500)

Distance Sensor

Exercise 1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
from microbit import *
from PiicoDev_VL53L1X import PiicoDev_VL53L1X

# Setup
sensor = PiicoDev_VL53L1X()

# Main loop
while True:
    if button_a.was_pressed():
        display.scroll(sensor.read())

Real Time Clock

Exercise 1

"{:02}".format() adds a leading zero, so 9 minutes shows as 09.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
from microbit import *
from PiicoDev_RV3028 import PiicoDev_RV3028

# Setup
rtc = PiicoDev_RV3028()

# Main loop
while True:
    if button_a.was_pressed():
        rtc.getDateTime()
        display.scroll("{:02}:{:02}".format(rtc.hour, rtc.minute))
    if button_b.was_pressed():
        rtc.getDateTime()
        display.scroll("{}/{}/{}".format(rtc.day, rtc.month, rtc.year))

Exercise 2

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
from microbit import *
from PiicoDev_RV3028 import PiicoDev_RV3028

# Setup
rtc = PiicoDev_RV3028()

# Main loop
while True:
    if button_a.was_pressed():
        rtc.getDateTime()
        if rtc.hour < 12:
            display.scroll("Good morning")
        elif rtc.hour < 18:
            display.scroll("Good afternoon")
        else:
            display.scroll("Good evening")

3x RGB LED

Exercise 1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
from microbit import *
from PiicoDev_RGB import PiicoDev_RGB

# Setup
leds = PiicoDev_RGB()
red = [255, 0, 0]
amber = [255, 100, 0]
green = [0, 255, 0]

# Main loop
while True:
    leds.clear()
    leds.setPixel(2, green)
    leds.show()
    sleep(3000)
    leds.clear()
    leds.setPixel(1, amber)
    leds.show()
    sleep(1000)
    leds.clear()
    leds.setPixel(0, red)
    leds.show()
    sleep(3000)

Exercise 2

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
from microbit import *
from PiicoDev_RGB import PiicoDev_RGB

# Setup
leds = PiicoDev_RGB()

# Main loop
while True:
    temp = temperature()
    if temp < 20:
        leds.fill([0, 0, 255])
    elif temp <= 25:
        leds.fill([0, 255, 0])
    else:
        leds.fill([255, 0, 0])
    sleep(1000)