CCC - Moon Buggies

Creating your first micro:bit program

Click here to find the starter program, with the imports ready.

Open the Mu editor on your computer. If there is code on the screen, start a New program from the menu.

Type these lines of code into your blank window:

from microbit import *
import radio

display.show(Image.HAPPY)

Plug your micro:bit into the computer, then click Flash:

Some code should be running on your micro:bit!

If you get a message scrolling across the micro:bit's screen, this is an error message!

Debug your code, then click Flash again to test your changes.

Once your code is working - change it!

Instead of HAPPY, can you think of another Image the micro:bit could show on its display?

Testing your Moonbuggy

If you are in Science Oxford's workshop, your robot is named after a current astronaut, and has a number.

If you not in a Science Oxford, download MoonBuggy.py, edit the channel numnber, and flash to your robot's micro:bit.

Look at the information on your table to find out more about your astronaut, and find out what number they are - this is your radio channel number.

Add the below code to your program, between import radio and before display.show():

radio.on()
radio.config(channel=0)

Edit the channel number to be your robot's number!

Flash your code to your micro:bit, and check for errors.

Click the 'REPL' button on Mu's menu, this will open a terminal at the bottom of your screen.

Turn your micro:bit over and click the Reset button on the back (between the USB socket and the white battery socket).

You can now type commands directly into the terminal, to interact with your micro:bit. Try this:

 >> display.show(Image.YES)

Does your micro:bit's display change?

Now try to send a message to your robot on the moon:

 >> radio.send('forward 500 500')

Did your robot move? Check for error messages in the terminal, and try again.

• Check your spelling
• Make sure there is a space between forward and each number

Practice driving your moon buggy by combining these commands:

• directions = forward, backward, left, right
• The first number is the speed - maximum 1023
• The second number is time - maximum 10000 (10s)

Back to Earth

You probably noticed that your robot doesn't obey your commands immediately.

Information takes approximately 1.255 seconds to travel from Earth to the Moon, so if you were really sending commands one at a time to a robot on the Moon, then there would be a delay.

Scientists always test everything out on Earth before sending things to space, as testing is much easier this way!

For the rest of the workshop, you can turn this delay on and off, to make the robot behave as though it is on the Moon or on Earth, depending on what you are doing.

Send this command using the terminal to remove the delay:

radio.send('earth')

What do you think you could send to put the buggy back on the Moon?

Using the Grabber

Your robot has a grabbing claw on the front - this can open and close to varying amounts to help you collect moon rock samples to bring back to base camp.

 >> radio.send('grab 6')
 >> radio.send('grab 1')

The grabbers have 6 position options - 6 is fully open, 1 is fully closed.

Test it out - what options work best for the moon rocks?

Can you successfully transport moon rocks around the surface?

Type more quickly with Functions

Typing every command in one at a time is really slow.

Now that you have practiced with the moon buggies, you know which commands you use most often - you can shorten what you need to write to make this happen, by using functions.

A function is like a recipe - you teach the micro:bit a set of instructions and give these instructions a name. Then you just need to use the name, and the micro:bit knows what to do.

Example 1: shorten radio.send()

def do(message):
    radio.send(message)

The function allows you to replace radio.send with do:

 >> do('forward 500 500')
 >> radio.send('forward 500 500')

This saves you 8 letters of typing each time, which adds up to a lot when you are sending lots of commands.

How it works:

• def is short for 'define', it means you are creating your function
• We are naming this function do and it takes an argument called message
• When you call the function (use it), whatever you type inside the brackets after do() will have the function's instruction applied to it
• So if we type do('forward 500 500')
• The message 'forward 500 500' is sent over the radio.

Example 2: combine instructions

def grabber1():
    radio.send('grab 5')
    sleep(10)
    radio.send('forward 500 1000')
    sleep(10)
    radio.send('grab 2')
    sleep(10)

We can now use just one command in the terminal to send three radio messages at once:

 >> grabber1()

This one instruction will open the grabber, drive a small amount forward, then close the grabber again - hopefully picking up a moon rock!

After testing out commands one at time, decide what would be useful to combine together.

• You can send up to 8 instructions at once.
• Add a sleep(10) between each instruction to slow the messages down - too many at once can cause a memory error!

What next?

• We have three different kinds of moon rocks to collect, that might need different combinations of instructions to pick up correctly - write a different function for each type of rock.


• Space research needs lots of funding! Can you make your robot do something cool, to attract investors to your project? A funky dance routine, driving in the shape of a letter... what do you think would increase interest in space research?


• There is no air on the Moon, so sound cannot travel there. But it is still a useful tool for the Earth-based researchers - your HQ micro:bit can play music and sound effects, so try adding them into your functions.


• Typing commands into the terminal, even with your functions, takes a while - use the micro:bits A and B buttons as shortcuts to send your most-used instructions to your robot.