micro:bit Foundations: recap

The micro:bit runs blocks in order, from top to bottom, one at a time.

Blocks in on start run once, when the micro:bit switches on. Each picture replaces the one before, so the last picture is the one that stays on.

So the order of the blocks is the order you see.

basic.showString("HI")
basic.showIcon(IconNames.Happy)
basic.showIcon(IconNames.Yes)

Blocks inside forever run again and again. When the last block finishes, forever starts again from the top. That is a loop, and it turns a few pictures into an animation.

pause keeps a picture on for longer, then the loop carries on. 1000 ms is one second.

Blocks in on start still run only once.

basic.forever(function () {
    basic.showIcon(IconNames.Heart)
    basic.showIcon(IconNames.SmallHeart)
})

Some blocks wait. on button A pressed runs its blocks every time A is pressed, and never before. That is an event.

So a micro:bit program has three kinds of block holder:

• on start: runs once, at the start
• forever: runs again and again, by itself
• on button pressed, on shake: runs each time that thing happens

basic.showIcon(IconNames.Asleep)
input.onButtonPressed(Button.A, function () {
    basic.showIcon(IconNames.Happy)
})
input.onButtonPressed(Button.B, function () {
    basic.showIcon(IconNames.Sad)
})
input.onGesture(Gesture.Shake, function () {
    basic.showIcon(IconNames.Surprised)
})
basic.forever(function () {
    basic.showIcon(IconNames.Asleep)
    basic.pause(5000)
})

A variable is a named box that holds a value. count holds a number, and it keeps it between button presses.

• set count to 0 puts 0 in the box (the old value is thrown away)
• change count by 1 adds 1 to what is already there
• show number count shows the value without changing it

Set the starting value in on start, so it happens once.

let count = 0
input.onButtonPressed(Button.A, function () {
    count += 1
    basic.showNumber(count)
})
input.onButtonPressed(Button.B, function () {
    count = 0
    basic.showNumber(count)
})

A sensor measures something and gives the program a number.

• light level: 0 (dark) to 255 (bright)
• temperature: degrees Celsius
• acceleration x: tilt left (below 0) or right (above 0)

The world keeps changing the number, so read it again in forever (or when a button is pressed) to see the new value.

let reading = 0
basic.forever(function () {
    reading = input.lightLevel()
    basic.showNumber(reading)
})

An if asks a yes-or-no question, such as light level < 50.

• True (yes): it runs the blocks inside.
• False (no): it skips them and does nothing.

So an if can turn the lights on, but it cannot turn them off by itself. That needs another question: light level ≥ 50.

< means less than, > means greater than.

basic.forever(function () {
    if (input.lightLevel() < 50) {
        basic.showLeds(`
            # # # # #
            # # # # #
            # # # # #
            # # # # #
            # # # # #
            `)
    }
})

An if … else asks one question.

• True: the first part runs.
• False: the else part runs.

Exactly one part runs each time. Never both, never neither. So one if … else does the job of two ifs with opposite questions.

basic.forever(function () {
    if (input.lightLevel() < 50) {
        basic.showLeds(`
            # # # # #
            # # # # #
            # # # # #
            # # # # #
            # # # # #
            `)
    } else {
        basic.clearScreen()
    }
})

else if adds more questions to one if block. The micro:bit asks them from the top.

• The first true question runs its part, and the rest are skipped.
• else runs only when every question above it is false.

So the order of the questions decides the ranges: ask < 15, then < 25, and the second means 15 to 24.

basic.forever(function () {
    if (input.acceleration(Dimension.X) < -300) {
        basic.showArrow(ArrowNames.West)
    } else if (input.acceleration(Dimension.X) > 300) {
        basic.showArrow(ArrowNames.East)
    } else {
        basic.showIcon(IconNames.SmallSquare)
    }
})

A list holds many values, in order, under one name.

Each item has a place, counted from 0. In Yes, No, Maybe: Yes is at 0, No at 1, Maybe at 2.

get value at takes out the item at a place. The last place is one less than the number of items.

let moods = ["Happy", "Tired", "Hungry"]
let choice = 0
input.onButtonPressed(Button.A, function () {
    choice += 1
    if (choice == 3) {
        choice = 0
    }
    basic.showString(moods[choice])
})

pick random 0 to 2 gives 0, 1 or 2, a new one each time.

To pick an item at random, pick a place, then take the item at that place: get value at (pick random 0 to length − 1).

length of list counts the items. The last place is one less, because places start at 0. Using the length means the list can grow without changing anything else.

let answers = ["Yes", "No", "Maybe"]
input.onGesture(Gesture.Shake, function () {
    basic.showString(answers[randint(0, answers.length - 1)])
})

A pocket pet is a few ideas from the course working together:

• forever with a pause makes hunger go up by itself.
• on button A pressed brings it down, with an if so it never goes below 0.
• if … else if … else turns the number into a face; the first true question wins.
• on shake picks a trick from a list with pick random 0 to length − 1.

let tricks = ["SPIN", "JUMP", "WAVE"]
let hunger = 0
input.onButtonPressed(Button.A, function () {
    if (hunger > 0) {
        hunger += -1
    }
    basic.showIcon(IconNames.Heart)
})
input.onGesture(Gesture.Shake, function () {
    basic.showString(tricks[randint(0, tricks.length - 1)])
})
basic.forever(function () {
    basic.pause(3000)
    hunger += 1
    if (hunger < 3) {
        basic.showIcon(IconNames.Happy)
    } else if (hunger < 6) {
        basic.showIcon(IconNames.Asleep)
    } else {
        basic.showIcon(IconNames.Sad)
    }
})