Für gewisse Aufgaben gibt es zwei Versionen: Basic und Advanced. Hier hast du die Wahl. Hast du keine Probleme mit den Aufgaben, solltest du die Advanced-Aufgaben lösen. Für TALITs sollte dies eigentlich der Standard sein.

Schreibe ein Programm, das eine Ente auf dem Display zeigt.

Schreibe ein Programm, das eine Animation aus fünf Bildern deiner Wahl zeigt. Jedes Bild soll eine Sekunde lang angezeigt werden.

Das Display soll eine Animation zeigen, bei der das gesamte Display anfangs nur schwach, dann immer heller leuchtet. Erstelle dazu eine Liste aus selbst erstellten Bildern. Verwende dazu die Image(...) Funktion. Recherchiere selbst dazu, wie man diese verwendet.

• Ähnlich wie 'Basic'. Das Display soll aber regelmässig pulsieren (heller werden, dann wieder dunkler, wieder heller, …). Verwende keine Liste, sondern schreibe eine Funktion, die dir das passende Image erstellt.

• Mit den beiden Tasten soll nun die Pulsgeschwindigkeit (in einer vorgegebenen Range) eingestellt werden können.

Mit set_pixel() und get_pixel() kannst du einzelne Pixel direkt ansteuern (siehe Hier findest du alle Funktionen, mit denen du das Display ansteuern kannst.)

Ein einzelnes Pixel soll nun die ganze LED-Matrix ablaufen: oberste Zeile von links nach rechts, dann zweite Zeile von links nach rechts …

Drückt man die linke Taste, wird ein Herz (oder eine Ente) angezeigt. Drückt man die rechte Taste, so erlöscht das Bild.

Würfeln: Programmiere einen digitalen Würfel. Drückt man eine der beiden Tasten, so wird eine Zufallszahl (1-6) bestimmt und das entsprechende Würfelbild angezeigt.

Tipps:

• Definiere zuerst Bilder für die sechs Seiten des Würfels.
• Verwende das random-Modul, um eine random Zahl (resp. random Bild) zu bestimmen.

Spiele mit einer Kolleg:in (die den Würfel auch bereits korrekt programmiert hat) das Leiterspiel. Spiele maximal 5 Minuten. Klicke auf das Bild, damit es gross angezeigt wird.

Fotostrecke: Befülle eine Liste mit einigen Bildern. Mit der linken und rechten Taste soll man die Bilder durchgehen können. Ist man am Ende der Liste angelangt, passiert nichts, wenn man weiter drückt.

Ist es hier besser, is_pressed() oder was_pressed() oder get_presses() zu verwenden? Warum?

Zwei Spielerinnen würfeln abwechslungsweise (eine mit linkem, eine mit rechtem Knopf). Es wird immer die jeweils gewürfelte Zahl angezeigt. Im Hintergrund werden für beide Spielerinnen diese Werte aufsummiert. Wer zuerst die Summe 42 (oder mehr) erreicht hat, hat gewonnen. Von dieser Spielerin wird dann das Lieblingstier angezeigt.

from microbit import *
 
while True:
    if button_a.get_presses():
        display.show(Image.HEART)
    if button_b.get_presses():
        display.clear()

from microbit import *
import random
 
dice_1 = Image("00000:00000:00900:00000:00000")
dice_2 = Image("00000:09000:00000:00090:00000")
dice_3 = Image("00000:00090:00900:09000:00000")
dice_4 = Image("00000:09090:00000:09090:00000")
dice_5 = Image("00000:09090:00900:09090:00000")
dice_6 = Image("00000:09990:00000:09990:00000")
 
dice_all = [dice_1,dice_2,dice_3,dice_4,dice_5,dice_6]
 
while True:
    if button_a.get_presses() or button_b.get_presses():
        dice = random.choice(dice_all)
        display.show(dice)

from microbit import *
 
images = [Image.SAD, Image.MEH, Image.YES, Image.NO, Image.COW]
n = len(images) # just a convenience: can use n instead of len(images) from now on
 
i = 0 # image position
 
while True:
    display.show(images[i])
    if button_b.get_presses() and i < n-1: # increase position (if not yet at end)
        i += 1
    if button_a.get_presses() and i > 0: # decrease position (if not yet at beginning)
        i -= 1

Rechenaufgabe (ohne micro:bit). Stelle dir vor, ein vom micro:bit gemessener Beschleunigungswert sei $2642$.

1. Wie vielen $g$'s entspricht dies?
2. Wandle um in $\text{m}/\text{s}^2$.

Rechenaufgabe (ohne micro:bit). Unten sind die gemessenen Werte für die Beschleunigungen in die drei Koordinatenrichtungen angegeben. Berechne jeweils die Gesamtbeschleunigung:

1. $(1728, 2020, 2040)$
2. $(-508, -60, 892)$

Zeige in der Konsole („Show serial“) die Beschleunigungen der drei Koordinatenrichtungen an. Pausiere den micro:bit nach jeder Messung z.B. für eine halbe Sekunde, damit du nicht mit Werten überflutest wirst.

1. Laufe nun mit dem micro:bit und dem Computer durch das Zimmer und zwar so, dass die $x-$ und die $y-$Beschleunigung möglichst klein sind.
2. Wie musst du den micro:bit halten und wie musst du dich bewegen?

1. Schreibe ein Programm, welches die Gesamtbeschleunigung misst und den Wert in der Konsole ausgibt. Füge nach jeder Messung wieder eine Pause ein.
2. Hältst du den micro:bit still, sollten der bekannte Wert $9.81$ (oder zumindest Wert in der Nähe davon) angezeigt werden, unabhängig davon, in welche Richtung der micro:bit zeigt.
3. Bewege den micro:bit nun so, dass du eine möglichst grosse Beschleunigung misst. Beschädige ihn aber nicht!
4. Erweiterung: Mit den Tasten sollst du nun zwischen drei Modi umstellen können:
   1. Anzeige in mg (z.B. $1018$)
   2. Anzeige in $g$'s (z.B. $1.02$)
   3. Anzeige in $\text{m}/\text{s}^2$ (z.B. $9.98$)

Je fester der micro:bit beschleunigt wird, desto heller soll die LED-Matrix leuchten.

Tipp 1: Verwende evtl. deine Funktion aus A3 (Advanced 1), mit der du ein Bild von gewünschter Helligkeit erstellen kannst.

Tipp 2: Verwende die Funktion int(), um aus einer Kommazahl eine Ganzzahl zu machen.

from microbit import *
 
while True:
    a = accelerometer.get_values()
    print(a)
    sleep(500)

from microbit import *
import math
 
i = 0
 
while True:
    ax,ay,az = accelerometer.get_values()
    a = math.sqrt(ax*ax + ay*ay + az*az)
    a_g = a / 1000
    a_si = a_g * 9.81
    a_list = [round(a),round(a_g,2),round(a_si,2)]
 
    if button_b.get_presses() and i < 2:
        i = i + 1
    if button_a.get_presses() and i > 0:
        i = i - 1
 
    print(a_list[i])
 
    sleep(1000)

from microbit import* 
import math
 
def all_pixels(brightness):
    for x in range(5):
        for y in range(5):
            display.set_pixel(x,y,brightness)
 
while True: 
    x,y,z = accelerometer.get_values()
    total = math.sqrt(x*x + y*y + z*z)
    max = 4000
    fraction = total / max
    brightness = int(fraction * 9)
    all_pixels(brightness)
    sleep(200)

Studiere zuerst den kurzen Theorieteil zum Erkennen von Gesten.

Schreibe ein Programm, das eine Ente anzeigt, wenn du den Microbit schüttelst und ein Haus, wenn du ihn nach oben drehst.

Probiere den Code für den Magic8Ball aus:

• Versuche zuerst, den Code zu verstehen. Kopiere ihn dann in deinen Editor und speichere das Programm.
• Lade das Programm auf den Microbit – jetzt kann dein Microbit in die Zukunft sehen:
• Stelle ihm eine ja/nein-Frage zu deiner Zukunft und schüttle den Microbit – er wird dir eine hilfreiche Antwort anzeigen!

Schreibe ein Würfel-Programm, das immer dann, wenn der Microbit geschüttelt wird, eine zufällige Zahl zwischen 1 und 6 anzeigt. Nach einer Sekunde soll das Display wieder dunkel werden. Benutze die Funktion randint() aus dem Modul random.

Programmiere Schere-Stein-Papier. Die Idee ist, dass du gegen eine Kolleg:in spielen kannst. Beide schütteln jeweils ihren Microbit und dann wird per Zufall eines der drei Symbole ausgewählt und angezeigt. Spiele Best of 5 (also wer zuerst drei Punkte hat).

Weitere Ideen:

• Erweitere das Spiel zur 'The Big Bang Theory'-Variante Rock, Paper, Scissors, Lizard, Spock:
  • https://bigbangtheory.fandom.com/wiki/Rock,_Paper,_Scissors,_Lizard,_Spock
• Füge am Anfang ein Menu ein, mit dem man z.B. folgendes festlegen kann:
  • die Anzahl Runden
  • den Spielmodus (falls du bereits 'Rock, Paper, Scissors, Lizard, Spock' implementiert hast)
  • jede Spieler:in kann zu beginn aus einer Reihe von Bildern ihr Bild auswählen. Am Schluss wird das Bild der Sieger:in angezeigt.

Programmiere deine eigene Gesten-Erkennung nur mit dem Accelerometer-Sensor:

• face up / down
• up / down / left / right
• shake
• freefall

Schreibe eine Programm, das auf Knopfdruck einen Ton mit music.pitch abspielt. Welche Frequenz musst du wählen, damit beim Button B eine Oktave zum Ton bei Button A ertönt?

Schreibe eine Programm, das eine Melodie abspielt.

• Verwende eingebaute Sounds mit audio.play().
• Codiere deine eigene Melodie mit music.play().

Schreibe ein Programm, das die Umgebungslautstärke auf dem Display angezeigt (microphone.sound_level() - Dokumentation). Je lauter, desto mehr und hellere Punkte sollen leuchten. Wie reagiert der Microbit auf das Programm aus E1 / E2, das auf einem anderen Gerät abgespielt wird?

from microbit import *
 
while True:
    # Sound level from 0..250
    level = microphone.sound_level()
    # How many leds do we light up?
    leds = int(25 * level / 250)
    # How bright ist the last led?
    brightness = level % 10
 
    for x in range(5):
        for y in range(5):
            value = x * 5 + y
            if value < leds:
                display.set_pixel(x,y,9)
            elif value == leds:
                display.set_pixel(x,y,brightness)
            else:
                display.set_pixel(x,y,0)
 
    sleep(10)

from microbit import *
 
 
while True:
    # Sound level from 0..250
    level = microphone.sound_level()
    # How many leds do we light up?
    leds = int(5 * level / 250)
    # How bright ist the last led?
    brightness = level % 10
 
    for x in range(5):
        for y in range(5):
            if x < 4:
                display.set_pixel(x, y, display.get_pixel(x+1,y))
            elif 4-y < leds:
                display.set_pixel(x, y, 9)
            elif 4-y == leds:
                display.set_pixel(x, y, brightness)
            else:
                display.set_pixel(x, y, 0)
 
    sleep(200)

Schreibe ein Programm, um Musik abzuspielen. Verwende das pin_logo, pin1 und pin2 als berührungsempfindlicher Sensor (pin1.set_touch_mode(pin1.CAPACITIVE)). Wieviele Kombinationen der drei Pins gibt es? Das sollte für eine diatonische Tonleiter reichen…

from microbit import *
import music
 
for pin in [pin0, pin1, pin2, pin_logo]:
    pin.set_touch_mode(pin.CAPACITIVE)
 
# We have three touch pins, giving us
# 8 states. The all-zero state is silence.
# Let's choose a diatonic scale at intervals
# Do: 0/12
# Re: 2/12
# Mi: 4/12
# Fa: 5/12
# So: 7/12
# La: 9/12
# Ti: 11/12
exponents = [-1,0,2,4,5,7,9,11]
base = 440
while True:
    index = 0
    if pin_logo.is_touched():
        index += 1
    if pin1.is_touched():
        index += 2
    if pin2.is_touched():
        index += 4
 
    # Chromatic stepping using buttons
    if button_a.was_pressed():
        base = (int) (base * 2**(-1/12))
    if button_b.was_pressed():
        base = (int) (base * 2**(1/12))
 
    if index == 0:
        music.stop()
    else:
        exponent = exponents[index] / 12
        freq = (int) (base * 2**exponent)    
        print(base, exponent, freq)
        music.pitch(freq, duration=-1, wait=False)
 
    sleep(10)

• Arbeite für diese Aufgaben in einer 2er-Gruppe.
• Studiere zuerst die Theorie zu den Grundlagen.

Sendet euch geheime Nachrichten quer durch den Raum. Stellt sicher, dass ihr auf einem eigenen Kanal kommuniziert.

• Schreibe ein Programm, mit dem du deiner Kolleg:in deinen Gemütszustand per Funk mitteilen kannst. Je nachdem, welche Taste (inkl. Touch-Logo) du drückst, wird bei ihr ein anderes Smiley (Happy,Meh,Sad) angezeigt.
• Gleichzeitig soll dein micro:bit auch den Gemütszustand deiner Kolleg:in empfangen können.
• Achtung: Das Versenden von Bildern ist etwas umständlich. Deshalb ist es einfacher, z.B. Zahlen zu verschicken: 1 für Happy, 2 für Meh, 3 für Sad. Möchtest du aber wirklich ein Bild versenden, kannst du hier nachlesen, wie es geht.
• Das Programm kann auch benutzt werden, um auf Fragen zu antworten: yes (happy), maybe (meh), no (sad). Interviewt euch gegenseitig, wobei ihr euch nur über den micro:bit Antworten geben dürft.

• Schreibe ein Programm, mit dem du deiner Kolleg:in eine Melodie senden kannst. Je nachdem, welche Taste (inkl. Touch-Logo) du drückst, wird bei ihr ein anderer Ton abgespielt.
• Gleichzeitig soll dein micro:bit auch Töne empfangen können.
• Erweiterungen:
  • Kannst du auch eine ganze Melodie versenden? Du könntest zum Beispiel die Töne mit Kommas trennen und nach dem Empfang mit string.split() in eine Liste aufteilen.
  • Statt eines Tons könntest du auch ein Bild versenden. Achtung: Das Versenden von Bildern ist etwas umständlich. Lies hier nach, wie es geht.

• Schreibe ein Programm, welches gleichzeitig Morse-Zeichen senden und empfangen kann.
• Die Symbole sollen auf der LED-Matrix angezeigt werden.
• Verwende die Tasten, um eine Nachricht einzugeben: Linke Taste: Lang (Strich) , Rechte Taste: Kurz (Punkt)
• Morsealphabet: https://www.kidstreff.ch/download/XjUbSs_fPR8/31_Geheimschriften_Morsen.pdf
• Beispiel: S.O.S: ooo---ooo
• Es gibt verschiedene Möglichkeiten, wie die Nachrichten übermittelt werden können, zum Beispiel:
  • 'Schreibe' zuerst ganze Nachricht und schicke sie erst, wenn sie ganz fertig ist (z.B. mit Touch-Logo).
  • Schicke jedes Symbol einzeln. Dann müssen die alten Nachrichten aber jeweils nach unten geschoben werden.

Studiere die folgende Theorie zu Signalstärke und Distanzmessungen.

Die beiden micro:bits sollen beide ein HAPPY, MEH oder SAD-Smiley anzeigen - je nachdem wie weit sie auseinander sind. Da sie verliebt ineinander sind, sollen sie HAPPY sein, wenn sie möglichst nahe beieinander sind.

1. Programmiere deinen Microbit so, dass du mit Mitschüler:innen Abstimmungen durchführen kannst:
   1. Wenn die A-Taste gedrückt wurde, sendet dein Micorbit die Nachricht „YES“ und zeigt auf dem Display das Bild Image.YES.
   2. Wenn die B-Taste gedrückt wurde, sendet dein Micorbit die Nachricht „NO“ und zeigt auf dem Display das Bild Image.NO.
   3. Wenn das Touch-Logo (pin_logo) berührt wird, zeigt das Display, wie viele YES- und wie viele NO-Nachrichten empfangen wurden. Der Text, der durch das Display scrollt, soll beispielsweise so aussehen: „Y: 3. N: 2“. Nach dieser Anzeige soll die Zähler wieder auf 0 gesetzt werden.
2. Stimmt ab in Gruppen von drei oder mehr Personen
   • A stellt eine Frage, die anderen stimmen mit den Microbits ab.
   • A schaut auf ihrem Microbit, wie abgestimmt wurde.
   • Simmt beispielsweise darüber ab, wohin ihr Mittagessen gehen sollt oder ob das Fach Informatik besser ist als Physik.
   • Testet zuerst und überprüft, ob alle den gleichen Kanal / die gleiche Gruppe eingestellt haben.

Dein Programm in obiger Aufgabe hat ein Problem: Jemand könnte bei einer Frage mehrmals drücken und so meherere Stimmen abgeben. Wie kannst du verhindern, dass jemand mehr als eine Stimme abgeben kann? Indem jeder Microbit mit jeder Ja- und Nein-Stimme seine eigene Nummer mitsendet. In einer Liste kannst du die Nummer erfassen und jeweils überprüfen, ob diese Nummer schon abgestimmt hat oder nicht. Schreibe ein Programm, das du auf mehrere Microbits laden und dann faire Abstimmungen durchführen kannst.

Was ist etwa die maximale Distanz in Sichtweite, über die zwei micro:bits miteinander kommunizieren können? Mache ein Experiment.

Wichtig: Die micro:bits müssen sich 'sehen' können.

Ähnlich wie die Morse-Aufgabe, nur soll jetzt eine normale Nachricht bestehend aus Buchstaben versendet werden können. Mit den beiden Knöpfen soll das Alphabet durchgegangen werden können. Mit dem Touch-Logo soll der Buchstabe versendet werden können.

In einer früheren Aufgabe hast du Schere-Stein-Papier bereits einmal programmiert. Programmiere es nun so (um), dass die beiden Spieler:innen beide ihren micro:bit in der Hand halten. Um einen Zug zu machen, wird der micro:bit geschüttelt. Die micro:bit kommunizieren natürlich über BLE miteinander. Das Ergebnis eines Zuges und der aktuellste Spielstand könnte auch über den Lautsprecher ausgegeben werden. Im Dossier kannst du nachlesen, wie man Sounds abspielen kann.

from microbit import *
import radio
 
radio.on()
 
while True:
    message_in = radio.receive()
    if message_in:
        display.scroll(message_in)
 
    if button_a.is_pressed():
        radio.send('Geheime Nachricht!')

from microbit import *
import radio
 
radio.on()
 
while True:
    message_in = radio.receive()
    if message_in:
        if message_in == '1':
            display.show(Image.HAPPY)
        elif message_in == '2':
            display.show(Image.MEH)
        elif message_in == '3':
            display.show(Image.SAD)
 
    if button_a.is_pressed():
        radio.send('1')
    if pin_logo.is_touched():
        radio.send('2')
    if button_b.is_pressed():
        radio.send('3')

from microbit import *
import radio
 
radio.on()
 
morse = ['','','','','']
matrix = ['00000','00000','00000','00000','00000']
 
while True:
    message_in = radio.receive()
 
    # trage neue Symbole in morse liste ein, entferne letztes Element (damit Laenge 5 bleibt)
    if message_in:
        morse.insert(0,message_in)
        morse.pop()
 
    # erstelle Matrix fuer Anzeige
    for i in range(len(morse)):
        if morse[i] == 'long':
            matrix[i] = '99999'
        elif morse[i] == 'short':
            matrix[i] = '00900'
        else:
            matrix[i] = '00000'
 
    # wandle Matrix in string um, damit angezeigt werden kann
    s = matrix[0] + ':' + matrix[1] + ':' + matrix[2] + ':' + matrix[3] + ':' + matrix[4] 
    display.show(Image(s))
 
    # Buttons
    if button_a.get_presses():
        radio.send('long')
    if button_b.get_presses():
        radio.send('short')

from microbit import *
import radio
 
radio.on()
 
morse = ['','','','','']
smth_changed = False
 
def show(m):
    display.clear()
    for y in range(len(morse)):
        if morse[y] == 'long':
            for x in range(5):
                display.set_pixel(x,y,9)
        elif morse[y] == 'short':
                display.set_pixel(2,y,9)
 
while True:
    message_in = radio.receive()
 
    # trage neue Symbole in morse liste ein, entferne letztes Element (damit Laenge 5 bleibt)
    if message_in:
        morse.insert(0,message_in)
        morse.pop()
        smth_changed = True
 
    # update led-matrix nur falls etwas geaendert hat
    if smth_changed:
        show(morse)
        smth_changed = False
 
    # Buttons
    if button_a.get_presses():
        radio.send('long')
    if button_b.get_presses():
        radio.send('short')

from microbit import *
import radio
 
radio.on()
radio.config(group = 43)
 
while True:
    # send
    radio.send('hello')
 
    # receive
    message_full = radio.receive_full()
    if message_full:
        text = message_full[0]
        signal_strength = abs(message_full[1])
        print(signal_strength)
        if signal_strength < 35:
            display.show(Image.HAPPY)
        elif signal_strength < 55:
            display.show(Image.MEH)
        else:
            display.show(Image.SAD)
 
    sleep(50)

• Arbeite für diese Aufgaben in einer 2er-Gruppe.
• Hier ist erklärt, wie der Distanzsensor und die Motorsteuerung funktionieren und wie der Microbit mit diesen Modulen kommuniziert.
• Studiere auf jeden Fall die Theorie zum Maqueen Interface. Das brauchst du, damit du den Maqueen einfach steuern und seine Sensoren auslesen kannst.

Schreibe ein Programm, das das Display heller werden lässt, je näher der Maqueen zu einem Objekt ist. Betrachte zuerst den Beispiel-Code in der Theorie zum Distanzmesser.

• Das Programm soll für einen Distanz-Bereich zwischen 0 und 9 Dezimetern (1 Dezimeter = 10cm) funktionieren.
• Verwende eine bereits bekannte Methode, um die Display-Helligkeit abhängig von einer Variable zu setzen.

1. Studiere die Theorie zur Driver-Schnittstelle (Motorsteuerung)
2. Lasse den Maqueen ein Quadrat fahren.
3. Lasse deinen Maqueen eine der folgenden Optionen abfahren:
   1. Für Geometriefreaks: anspruchsvolle Geometrische Figur (z.B. Pentagramm - wie berechnet man den Winkel der Spitzen? Nicht auf Wikipedia nachschauen!)
   2. Für Narzist:innen: eigener Name / Spitzname / Initialen
   3. Für Schleimer:innen: Name / Initialen der Lehrperson (aber kein Spitzname!)
   4. Für Royalist:innen: Portrait des Königs

Verwende die Chassis-Schnittstelle. Wenn die A-Taste gedrückt wurde, soll der Roboter losfahren. Wenn er ein Hindernis (weniger als 8 cm) vor sich hat, soll er stopppen.

Programmiere einen Staubsaugroboter: Fahre geradeaus bis zu einem Hindernis. Wende um einen zufälligen Winkel und wiederhole.

Probiere den Roboter aus - würde er funktionieren?

Verwende deine Kenntnisse zur Funk-Steuerung, um folgende Aufgabe zu lösen:

• der Roboter soll kollisionsfrei herumfahren (wie der Staubsaug-Roboter)
• der Roboter soll mittels Radio andere Roboter finden und möglichst nahe zu ihnen fahren. Sind die zwei Roboter nah genug, sollen sie anhalten und ihre Bottom-LEDS auf die gleiche Farbe einstellen.

Verwende den Bodensensor, um einer schwarzen Linie zu folgen. Signalisiere den Zustand der Bodensensoren mit den Front-LEDs.

• Wie folgst du einer breiten Linie (5cm)?
• Wie einer schmalen Linie (1cm)?

Aufgabe für 2 Personen: Schreiben Sie eine Fernsteuerung für den Maqueen. Der eine Microbit sendet Signale (links / rechts / geradeaus), der andere empfängt diese und setzt sie in Steuersignale für den Roboter um.

Mögliche Steuerbelegung:

• Touch Logo: muss berührt werden, um zu fahren; ohne Buttons fährt er geradeaus.
• Button A: fährt nach links (wenn Touch Logo gleichzeitig gedrückt)
• Button B: fährt nach rechts (wenn Touch Logo gleichzeitig gedrückt)

from microbit import *
from maqueen import *
 
robot = Maqueen()
driver = robot.driver
 
while True:
    if button_a.was_pressed():
        for i in range(4):
            driver.drive(10)
            driver.right(90)

from microbit import *
from maqueen import *
 
robot = Maqueen()
chassis = robot.chassis
 
while True:
    if button_a.was_pressed():
        chassis.forward()
        while robot.front_sensor.distance() > 10:
            sleep(50)
        chassis.stop()

from microbit import *
from maqueen import *
import random
 
robot = Maqueen()
 
def hoover():
    while True:
        # Straight ahead!
        robot.chassis.forward()
        distance = robot.front_sensor.distance(attempts=3)
        print(distance)
        while distance > 15 or distance < 0:
            sleep(50)
            distance = robot.front_sensor.distance(attempts=3)
 
        # Obstacle - random turning!
        robot.chassis.stop()
 
        # Back off if we're too close.
        if distance < 15:
            robot.driver.drive(-10)
 
        degrees = random.randint(40,120)
        direction = random.randint(0,1)
        if direction == 1:
            robot.driver.left(degrees)
        else:
            robot.driver.right(degrees)
 
 
while True:
    if button_a.was_pressed():
        hoover()