Accelerometer

This object gives you access to the on-board accelerometer.

By default MicroPython sets the accelerometer range to +/- 2000 mg (g being a unit of acceleration based on the standard gravity), which configures the maximum and minimum values returned by the accelerometer functions. The range can be changed via microbit.accelerometer.set_range().

The accelerometer also provides convenience functions for detecting gestures. The recognised gestures are represented as strings: up, down, left, right, face up, face down, freefall, 3g, 6g, 8g, shake.

Note

Gestures are not updated in the background so there needs to be constant calls to some accelerometer method to do the gesture detection. Usually gestures can be detected using a loop with a small microbit.sleep() delay.

Functions

microbit.accelerometer.get_x()
Returns:

The acceleration measurement in the x axis in milli-g, as a positive or negative integer.

microbit.accelerometer.get_y()
Returns:

The acceleration measurement in the y axis in milli-g, as a positive or negative integer.

microbit.accelerometer.get_z()
Returns:

The acceleration measurement in the z axis in milli-g, as a positive or negative integer.

microbit.accelerometer.get_values()
Returns:

The acceleration measurements in all axes at once, as a three-element tuple of integers ordered as X, Y, Z.

microbit.accelerometer.get_strength()

Get the acceleration measurement of all axes combined, as a positive integer. This is the Pythagorean sum of the X, Y and Z axes.

Returns:

The combined acceleration strength of all the axes, in milli-g.

microbit.accelerometer.current_gesture()
Returns:

String with the name of the current gesture.

microbit.accelerometer.is_gesture(name)
Parameters:

name – String with the name of the gesture to check.

Returns:

Boolean indicating if the named gesture is currently active.

microbit.accelerometer.was_gesture(name)
Parameters:

name – String with the name of the gesture to check.

Returns:

Boolean indicating if the named gesture was active since the last call.

microbit.accelerometer.get_gestures()

Get a historical list of the registered gestures.

Calling this function clears the gesture history before returning.

Returns:

A tuple of the gesture history, most recent is listed last.

microbit.accelerometer.set_range(value)

Set the accelerometer sensitivity range, in g (standard gravity), to the closest values supported by the hardware, so it rounds to either 2, 4, or 8 g.

Parameters:

value – New range for the accelerometer, an integer in g.

Examples

A fortune telling magic 8-ball. Ask a question then shake the device for an answer.

# Magic 8 ball by Nicholas Tollervey. February 2016.
#
# Ask a question then shake.
#
# This program has been placed into the public domain.
from microbit import *
import random

answers = [
    "It is certain",
    "It is decidedly so",
    "Without a doubt",
    "Yes, definitely",
    "You may rely on it",
    "As I see it, yes",
    "Most likely",
    "Outlook good",
    "Yes",
    "Signs point to yes",
    "Reply hazy try again",
    "Ask again later",
    "Better not tell you now",
    "Cannot predict now",
    "Concentrate and ask again",
    "Don't count on it",
    "My reply is no",
    "My sources say no",
    "Outlook not so good",
    "Very doubtful",
]

while True:
    display.show('8')
    if accelerometer.was_gesture('shake'):
        display.clear()
        sleep(1000)
        display.scroll(random.choice(answers))
    sleep(10)

Simple Slalom. Move the device to avoid the obstacles.

# Simple Slalom by Larry Hastings, September 2015
#
# This program has been placed into the public domain.

import microbit as m
import random

p = m.display.show

min_x = -1024
max_x = 1024
range_x = max_x - min_x

wall_min_speed = 400
player_min_speed = 200

wall_max_speed = 100
player_max_speed = 50

speed_max = 12


while True:

    i = m.Image('00000:'*5)
    s = i.set_pixel

    player_x = 2

    wall_y = -1
    hole = 0

    score = 0
    handled_this_wall = False

    wall_speed = wall_min_speed
    player_speed = player_min_speed

    wall_next = 0
    player_next = 0

    while True:
        t = m.running_time()
        player_update = t >= player_next
        wall_update = t >= wall_next
        if not (player_update or wall_update):
            next_event = min(wall_next, player_next)
            delta = next_event - t
            m.sleep(delta)
            continue

        if wall_update:
            # calculate new speeds
            speed = min(score, speed_max)
            wall_speed = wall_min_speed + int((wall_max_speed - wall_min_speed) * speed / speed_max)
            player_speed = player_min_speed + int((player_max_speed - player_min_speed) * speed / speed_max)

            wall_next = t + wall_speed
            if wall_y < 5:
                # erase old wall
                use_wall_y = max(wall_y, 0)
                for wall_x in range(5):
                    if wall_x != hole:
                        s(wall_x, use_wall_y, 0)

        wall_reached_player = (wall_y == 4)
        if player_update:
            player_next = t + player_speed
            # find new x coord
            x = m.accelerometer.get_x()
            x = min(max(min_x, x), max_x)
            # print("x accel", x)
            s(player_x, 4, 0) # turn off old pixel
            x = ((x - min_x) / range_x) * 5
            x = min(max(0, x), 4)
            x = int(x + 0.5)
            # print("have", position, "want", x)

            if not handled_this_wall:
                if player_x < x:
                    player_x += 1
                elif player_x > x:
                    player_x -= 1
            # print("new", position)
            # print()

        if wall_update:
            # update wall position
            wall_y += 1
            if wall_y == 7:
                wall_y = -1
                hole = random.randrange(5)
                handled_this_wall = False

            if wall_y < 5:
                # draw new wall
                use_wall_y = max(wall_y, 0)
                for wall_x in range(5):
                    if wall_x != hole:
                        s(wall_x, use_wall_y, 6)

        if wall_reached_player and not handled_this_wall:
            handled_this_wall = True
            if (player_x != hole):
                # collision! game over!
                break
            score += 1

        if player_update:
            s(player_x, 4, 9) # turn on new pixel

        p(i)

    p(i.SAD)
    m.sleep(1000)
    m.display.scroll("Score:" + str(score))

    while True:
        if (m.button_a.is_pressed() and m.button_a.is_pressed()):
            break
        m.sleep(100)