Microbit programmieren [KSR Wiki]

Diese Seite ist nicht editierbar. Du kannst den Quelltext sehen, jedoch nicht verändern. Kontaktiere den Administrator, wenn du glaubst, dass hier ein Fehler vorliegt.
====== - Microbit programmieren ======

===== - Übersicht =====

Der micro:bit ist ein Microcontroller (eine Art Mini-Computer), der speziell für den Schulbetrieb entwickelt wurde und mit Python programmiert werden kann.

{{ :gf_informatik:microbitv2_front.png?250 |}}

Er verfügt über eine Vielzahl an Komponenten, die man mit seinem Code ansteuern kann. Mit Display und Lautsprecher kann der Microbit Bild und Ton **ausgeben**. Zur **Eingabe** von Daten sind auf dem Microbit zwei Tasten, das Touch-Logo und mehrere Sensoren eingebaut. Auf dieser Seite lernst du die wichtigsten Funktionen kennen, um Display, Lautsprecher, Tasten und Sensoren anzusteuern.
{{ :gf_informatik:microbit_aufbau.png?649 |}}

Eine kurze Übersicht zu den wichtigsten Funktionen in englischer Sprache findest du im [[https://microbit.org/get-started/user-guide/python/|Microbit-Python-Guide]]

In der [[https://microbit-micropython.readthedocs.io/en/stable/|Microbit-Micropython-Dokumentation]] findest du //alle// Informationen zur Programmierung des Micro-Bit.

===== - Getting started =====

Für die Programmierung des Microbits nutzen wir den Online-Editor:
  * **Online-Editor:**
     * Link: https://python.microbit.org/
     * Verwende den Chrome Browser (oder Edge)
     * Tipp zum **Speichern:**
       * Lege auf OneNote eine Seite an, z.B. "MicroBit - Aufgaben"
       * Copy-Paste deine Codes dort hinein

<code python>
from microbit import *
display.scroll("Hello, World!")
</code>

===== - Display =====

==== Text anzeigen ====
Wir schauen uns kurz die beiden Code-Zeilen des Hello-World-Beispiels an:
<code python>
from microbit import *
display.scroll("Hello, World!")
</code>
  * Die Zeile ''from microbit import * '' bedeutet, dass alle Microbit-Funktionen und -Objekte importiert werden sollen. **Diese Zeile brauchen wir für jedes Microbit-Programm**.
  * Die zweite Zeile sagt dem Display, dass es die Zeichenkette "Hello, World!" als Laufschrift anzeigen soll – oder etwas genauer formuliert: Vom ''display''-Objekt wird die Funktion ''scroll()'' aufgerufen und dieser Funktion wird die Zeichenkette "Hello, World!" übergeben.

Über das `display`-Objekt kannst du auf weitere Display-Funktionen zugreifen. Wenn du im Mu-Editor ''display'' und dann einen Punkt eintippst, erhältst du eine Liste mit allen Display-Funktionen. Die wichtigsten sind ''clear()'' zum Löschen des Displays und ''show()'' zur Anzeige von Text oder Bildern. 

==== Bilder anzeigen ====

Folgender Code zeigt ein Herz auf dem Display:
<code python>
from microbit import *
display.show(Image.HEART)
</code>

Über das ''Image''-Objekt kannst du auf eine Reihe von vordefinierten Bildern zugreifen.

[[https://microbit-micropython.readthedocs.io/en/stable/tutorials/images.html|Hier findest du eine Übersicht über die Bilder und eine Anleitung zum Erstellen von eigenen Bildern und Animationen.]]

==== Animationen mit Bilder-Listen ====
In Python kannst du auf einfache Weise Listen erstellen. Im folgenden Code wird eine Liste von Bildern erstellt und angezeigt.

<code python>
from microbit import *

my_images = [Image.HAPPY, Image.SMILE, Image.SAD, Image.CONFUSED]

display.show(my_images)
</code>

Die Funktion ''show()'' merkt, dass sie es hier mit einer Liste zu tun hat und zeigt nun jedes Bild der Liste nacheinander.

Du kannst der Funktion weitere Parameter übergeben:
<code python>
display.show(my_images, delay = 500, loop = True)</code>

  * Mit dem Parameter ''delay'' gibst du an, wie lange (in Millisekunden) jedes Bild angezeigt werden soll.
  * Wenn du den Parameter ''loop'' auf "True" setzt, wird die Animation endlos wiederholt.


===== - Tasten =====

==== Tasten & Touch-Logo ====

Der Microbit kann über die Tasten A und B sowie per Touch-Logo bedient werden. Mit den Funktionen ''is\_pressed()'' bzw. ''is\_touched()'' kannst du fragen, ob die jeweilige Taste gedrückt ist. Das folgende Programm zeigt je nach betätigtem Bedienelement ein anderes Bild auf dem Display:

== Beispiel 1 ==
<code python>
from microbit import *

while True:
    if button_a.is_pressed():
        display.show(Image.HAPPY)
    if button_b.was_pressed():
        display.show(Image.SAD)
    if pin_logo.is_touched():
        display.show(Image.HEART)
</code>

Mit ''while True:'' wird eine Endlos-Schleife eröffnet: Der Code darunter wird endlos wiederholt: 
  * Zuerst wird gefragt, ob die Taste A //jetzt gerade gedrückt wird//: Falls ja, soll das Display das Bild HAPPY anzeigen. 
  * Dann wird gefragt, ob die Taste B// gedrückt worden ist//: Falls ja, soll das Display das Bild SAD anzeigen. 
  * Dann wird gefragt, ob das Logo jetzt gerade berührt wird: Falls ja, soll das Display das Bild HEART anzeigen.
  * Dann springt das Programm wieder zum ersten Punkt – und so weiter und so fort.

Diese If-Abfragen erfolgen so schnell, dass die Endlos-Schleife **jede Sekunde mehrere tausend Mal** durchlaufen wird. Du kannst also jederzeit eine Taste drücken und das Bild wird sofort angepasst – probiere es aus!

\\
== Beispiel 2 ==
Beachte, dass es für Tasten drei Befehle gibt: ''is\_pressed()'', `was_pressed()` und ''get\_presses()''. Um diese besser zu verstehen, hier ein weiteres Beispiel – Lade den Code auf deinen Microbit und probiere es aus:

<code python>
from microbit import *

while True:
    display.scroll("Hallo")
    if button_a.is_pressed():
        display.show(Image.DUCK) # Zeige Ente
        sleep(1000)
    if button_a.was_pressed():
        display.show(button_a.get_presses()) # Zeige, wie oft Taste A gedrückt
        sleep(1000)
</code>

  * Es dauert seine Zeit, bis der Befehl `display.scroll("Hallo")` ausgeführt ist. Wenn du während dieser Zeit die A-Taste (mehrmals) drückst, wird keine Ente angezeigt, weil das Programm noch nicht bei der ersten if-Verzweigung angelangt ist.
  * Wenn der Text fertig angezeigt ist und du die A-Taste in diesem Moment //nicht// gedrückt hältst, wird keine Ente angezeigt, denn im Moment der if-Abfrage ist die Taste nicht gedrückt. Sofern du aber vorher (mehrmals) die A-Taste gerückt hast, springt das Programm nun in die zweite if-Verzweigung und es wird eine Sekunde lang angezeigt, wie oft die A-Taste gedrückt wurde.
  * Wenn der Text fertig angezeigt ist und du die A-Taste gedrückt hältst, springt das Programm in die erste, dann in die zweite if-Verzeigung. Es wird also erst eine Sekunde lang eine Ente angezeigt, dann die Anzahl Tastendrücke.

\\
== Zusammenfassung ==
Hier nochmal die drei Funktion zusammengefasst: 
  * `is_pressed()` gibt `True` zurück, wenn die Taste im Moment des Aufrufs gedrückt ist, aber sagt nichts darüber aus, ob sie in der Vergangenheit gedrückt worden ist.
  * `was_pressed()` gibt `True` zurück, wenn die Taste seit dem letzten Aufruf der Funktion gedrückt worden ist, also auch, wenn die Taste bereits wieder losgelassen wurde. Wenn die Taste seit dem letzten Aufruf der Funktion immer noch gedrückt ist und die Funktion erneut aufgerufen wird, gibt sie `False` zurück. Nur wenn die Taste inzwischen losgelassen und //erneut// gedrückt wurde, gibt die Funktion `True` zurück.
  * `get_presses()` funktioniert ähnlich wie `was_pressed()`, aber gibt die Anzahl Klicks seit dem letzten Funktionsaufruf zurück. Der Funktionsaufruf setzt den Zähler wieder auf Null zurück.
    * Hinweis: `get_presses()` gibt eine Zahl zurück. In einer Bedingung wie `if button_a.get_presses():` wandelt Python die Zahl in einen Wahrheitswert (Wahr oder Falsch) um, wobei Null mit `False` übersetzt wird und jede andere Zahl mit `True`.


==== Pins ====

Zusätzlich befinden sich unten am micro:bit Pins, die man verwenden kann. Probiere folgenden Code aus:
<code python>
# Imports go at the top
from microbit import *

while True:
    if pin0.is_touched():
        display.show(Image.HAPPY)
    else:
        display.show(Image.SAD)
</code>
Sobald du nun den Stromkreis zwischen Ground (GND) und Pin 0 schliesst (beide gleichzeitig berühren oder mit Kabel verbinden), sollte nun ein Happy-Smile angezeigt werden.

Für mehr Infos siehe hier: https://microbit-micropython.readthedocs.io/en/stable/pin.html
===== - Beschleunigungssensor =====

Auf der Rückseite des Microbits befindet sich unten links ein Beschleunigungssensor. Der Beschleunigungssensor misst die Beschleunigung, die der Microbit in x-, y- und in z-Richtung erfährt. Du kannst dir eine Drohne vorstellen: Wenn sie immer vorwärts und rückwärts fliegt, beschleunigt sie in x-, wenn sie seitwärts hin und her fliegt in y- und wenn sie hoch oder runter fliegt in z-Richtung.

{{ :gf_informatik:drone.jpg?350 |}}

==== Beschleunigung messen ====

Folgender Code liest alle 100 ms die Werte aus dem Beschleunigungssensor und sendet sie über USB:

<code python>
from microbit import *

while True:
    sleep(100)
    print(accelerometer.get_values())
</code>

Innerhalb der Endlos-Schleife ''while True'' werden zwei Befehle ständig wiederholt: 
  * ''sleep(100)'' lässt das Programm während 100 Millisekunden in der Funktion sleep() verharren, 
  * in der zweiten Zeile sind zwei Funktionen ineinander verschachtelt: 
    - Die Funktion ''get_values()'' gibt die drei Werte vom Beschleunigungssensor für die $x-,y-$ und $z-$Achse zurück, 
    - die Funktion ''print()'' sendet diese Zeichenkette über USB, sodass sie am verbundenen Computer angezeigt werden kann.

**Probiere es aus:** Lade obigen Code auf den Microbit und öffne im Python Editor die Konsole („Show serial“). Wenn du den Microbit wild schüttelst – achte auf das Kabel und darauf, dass du nicht deinen Laptop mitreisst – dann verändern sich die drei Werte.

**Versuche jetzt, den Microbit so zu bewegen, dass jeweils nur einer der drei Werte ausschlägt.**

Zur Info: 
  * Die Funktion ''get\_values()'' gibt Werte in der Einheit **mg** zurück, $1000$ mg entsprechen 1 g: $1 g = 9.81 \text{m}/\text{s}^2$. 
  * Standardmässig beträgt der Messbereich des Beschleunigungssensors +/- 2 $g$.
  * Mit ''get\_values()'' erhältst du die Beschleunigungen $a_x,a_y,a_z$ für die drei einzelnen Koordinaten. Die **Gesamtbeschleunigung** (Betrag der Beschleunigung) ist dann gegeben durch den Satz von Pythagoras in 3D: $$a = \sqrt{a_x^2 + a_y^2 + a_z^2}$$ 
In python geht das so:
<code python>
import math
# ...
ax, ay, az = accelerometer.get_values()
a = math.sqrt(ax*ax + ay*ay + az*az)
</code>

**Achtung:** Die Gesamtbeschleunigung ist immer positiv. Du verlierst damit also sämtliche Informationen über die Richtung der Beschleunigung.



==== Gesten erkennen ====
Mit dem Beschleunigungssensor können auch bestimmte Gesten (engl. //gestures//) erkannt werden – zum Beispiel, ob der Microbit geschüttelt wurde (''"shake"''), ob er nach oben (''"face up"'') oder nach unten (''"face down"'') gedreht ist usw. Folgender Code zeigt ein //Happy Face//, wenn der Microbit nach oben gedreht ist, sonst ein //Sad Face//:

<code python>
from microbit import *

while True: 
    if accelerometer.is_gesture("face up"):
        display.show(Image.HAPPY)
    else:
        display.show(Image.SAD) 
</code>

Die Funktion ''is_gesture()'' gibt ''True'' zurück, wenn der Beschleunigungssensor die in den Klammern angegebene Geste erkannt hat. Sonst gibt sie ''False'' zurück.

[[https://microbit-micropython.readthedocs.io/en/stable/accelerometer.html|Hier findest du eine Übersicht über Funktionen des Beschleunigungssensors.]]

[[https://microbit-micropython.readthedocs.io/en/stable/tutorials/gestures.html|Hier findest du eine Übersicht über alle Gesten und eine Anleitung dazu, wie du aus deinem Microbit einen Magic8Ball programmieren kannst.]]




===== - Sounds =====

Auf der Rückseite des Microbits befindet sich in der Mitte der "Lautsprecher" (engl. //speaker//). Dieser klingt nicht wirklich laut, aber dank folgender Software-Module kannst du viel damit machen:
  * Das Modul ''music'' stellt dir eine Reihe von vordefinierten Melodien zur Verfügung. Du kannst auch selber Melodien erstellen.
  * Mit dem Modul ''speech'' kann dein Microbit einen Text sprechen oder gar singen. Allerdings lässt die Qualität noch zu wünschen übrig. Für bessere Audio-Qualität schliesst du den einen Kanal eines alten Kopfhörers an den Pins 0 und GND an. 

==== Einzelne Töne abspielen====
Folgender Code spielt einen Ton, wenn die Taste A gedrückt wird:

<code python>
from microbit import *
import music

while True:
    if button_a.is_pressed():
        music.pitch(440, 100)
</code>

  * Die Zeile ''import music'' importiert das Modul ''music''. Dieses enthält die Funktionen ''pitch()'', ''play()'' und [[https://microbit-micropython.readthedocs.io/en/stable/music.html#functions|weitere Funktionen.]]
  * Der Funktion ''pitch()'' wird die //Frequenz// des Tons in Hertz und die //Dauer// des Tons in Millisekunden übergeben.
  * Wenn du kurz testen willst, welche Frequenz wie klingt, [[https://musiclab.chromeexperiments.com/Oscillators/|klicke hier]].


==== Melodien erstellen und abspielen ====

Das Modul ''music'' enthält schon [[https://microbit-micropython.readthedocs.io/en/stable/music.html#built-in-melodies|ein paar vordefinierte Melodien.]] Folgender Code spielt eine solche Melodie ab:
<code python>
from microbit import*
import music

music.play(music.PRELUDE)
</code>

=== Melodien selber erstellen ===
Du kannst auch selbst Melodien erstellen, wie in folgendem Code:
<code python>
from microbit import*
import music

my_melody = ['g3:4', 'g3:4', 'b3:4', 'g3:4','c4:4', 'f4:4', 'c4:4', 'g3:8']

music.set_tempo(bpm = 180) # Standardeinstellung: 120 Schläge pro Minute (bpm)
music.set_tempo(ticks = 8) # Standardeinstellung: 4 Schläge pro Takt

music.play(my_melody)
</code>
  * Die Liste ''my\_melody'' enthält jede zu spielende Note und deren Dauer; es gilt die Notation ''NOTE[Oktave][:Dauer]'', also zum Beispiel '''c4:8''' für die Note C in der vierten Oktave, die acht Schläge lang gespielt wird.[[wp>Scientific_pitch_notation#Table_of_note_frequencies|Hier eine Übersicht über die Noten und Oktaven.]]
  * Mit der Funktion ''set_tempo()'' kann das Tempo (beats per minute) oder die Taktart verändert werden. 
  * Die Funktion ''play()'' spielt die Melodie ab.

**Probiere das Programm aus und verändere die Melodie**, du kannst auch Noten hinzufügen oder weglassen.

=== Melodien anders abspielen ===
Dir ist vielleicht aufgefallen, dass manche Melodien nicht so klingen, wie sie sollten. Hier zum Beispiel die Melodie für das Lied [[https://de.wikipedia.org/wiki/Frère_Jacques |Frère Jacques (Bruder Jakob)]]:
<code python>
# Frère Jacques:
melody_jacques = ['c4:4', 'd4:4', 'e4:4', 'c4:4','c4:4', 'd4:4', 'e4:4', 'c4:4',
                 'e4:4', 'f4:4', 'g4:8', 'e4:4', 'f4:4', 'g4:8',
                 'g4:2', 'a4:2', 'g4:2', 'f4:2', 'e4:4', 'c4:4',
                 'g4:2', 'a4:2', 'g4:2', 'f4:2', 'e4:4', 'c4:4',
                 'c4:4', 'g3:4', 'c4:8', 'c4:4', 'g3:4', 'c4:8']
</code>
Wenn die Funktion ''play()'' Melodien abspielt, werden die einzelnen Töne unmittelbar aufeinanderfolgend, also ohne Zwischenpause wiedergegeben. Falls zwei gleiche Töne aufeinanderfolgen (wie in //Frère Jacques// beispielsweise der 4. und 5. Ton), klingt das wie ein einziger, langer Ton. Hierzu gibt es mindestens zwei Lösungen:
  -   Mit der Note ''r'' (für engl. //rest//) können Pausen in die Melodie eingebaut werden: '' 'r:2' '' macht eine Pause von zwei Schlägen. Dann sollten aber auch die anderen Ton-Dauern angepasst werden.
  -   Da die Melodie als Liste vorliegt, kannst du sie Ton für Ton abspielen und jeweils dazwischen eine ganz kurze Pause einbauen. Zum Beispiel so:

<code python>
note = 0
while True:
    music.play(melody_jacques[note])
    sleep(30)
    if(note < len(melody_jacques)-1):
        note += 1
    else:
        note = 0
</code>
  * In obigem Code wird zuerst eine Variable ''note'' für die Auswahl der Note auf 0 gesetzt.
  * In der Endlos-Schleife (''while True:'') wird nun in jedem Durchgang //eine// Note aus der Liste ''melody_jacques'' gespielt. 
  * Dann wird 30 ms lang gewartet. 
  * Schliesslich wird die Variable ''note'' erhöht oder – falls Sie bereits der Zahl des letzten Elements der Liste ''melody\_jacques'' entspricht – auf 0 gesetzt.

=== Mikrophon ===

Mit `microphone.sound_level()` kann die Umgebungslautstärke abgefragt werden. Der Rückgabewert ist zwischen 0 (Stille) und 255 (sehr laut). 

===== - Radio =====

==== Grundlagen ====

Auf der Rückseite des Microbits siehst du oben links eine goldene Leitung, die rechtwinklig hin- und her verläuft (mäanderförmig).

{{:gf_informatik:ble_antenna.png?200|BLE-Antenne auf dem Microbit}}

Das ist die Antenne, mit der dein Microbit elektromagnetische Wellen (Funkwellen, engl.: //radio waves//) senden und empfangen und damit über **BLE** kommunizieren kann. BLE steht für [[https://youtu.be/ItV08vGqACM|Bluetooth Low Energy]], eine Weiterentwicklung der Bluetooth-Funktechnologie, die dein Smartphone nutzt, um sich beispielsweise mit kabellosen Kopfhörern zu verbinden. BLE braucht weniger Energie als Bluetooth, weil es weniger Daten sendet. BLE ist daher nicht geeignet, Musik zu senden – das wären zu viele Daten. Für kleine Textnachrichten aber eignet sich BLE sehr gut.

Hier ein einfaches Programm, das einen Text senden, empfangen und anzeigen kann:
<code python>
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("Ciao!")
</code>

  * Zuerst muss das Radio-Modul mit dem Befehl ''import radio'' geladen werden. 
* In der Endlosschleife wird zuerst die Funktion ''radio.receive()'' aufgerufen. Diese Funktion schaut, ob eine Nachricht angekommen ist. Falls ja, gibt sie die empfangene Nachricht zurück, falls nein, gibt sie ''None'' (gleichbedeutend mit ''0'' oder ''False'') zurück. Der zurückgegebene Wert wird in der Variable `message_in` gespeichert.
* Jetzt wird mit der `If`-Abfrage geprüft, ob eine Nachricht angekommen ist (wenn ''message_in'' = ''None'' ist, dann ist die Bedingung nicht erfüllt). 
* Falls ja, wird diese Nachricht mit der Funktion ''scroll()'' angezeigt.
* Wenn die Taste A gedrückt wird, wird die Nachricht "Ciao!" gesendet.
* **Achtung:** Wenn mehrere Gruppen im gleichen Raum arbeiten lohnt es sich, nur auf einer bestimmten Frequenz resp. in einer bestimmten Gruppe Nachrichten zu senden und empfangen. Für eine **private Kommunikation** gibt es zwei Möglichkeiten:
  * Ihr könnt auf einer anderen Frequenz senden: mit dem Befehl ''radio.config(channel = x)'' wählt ihr einen **Kanal zwischen 0 und 83** (für x setzt ihr die Kanal-Nummer ein). Standardmässig ist der Kanal = 7 (und die Frequenz damit 2407 MHz).
  * Ihr könnt Nachrichten herausfiltern, indem ihr mit dem Befehl ''radio.config(group = x)'' eine eigene **Gruppe-Nr. zwischen 0 und 255** wählt (standardmässig ist die Gruppe 0). So werden eure Nachrichten mit einer spezifischen Adresse versehen und eure Microbits schauen nur nach Nachrichten mit dieser Adresse.

==== Versenden von Bildern ====

Mit `radio.send()` und `radio.receive()` können nur *Strings* versendet und empfangen werden. Aus diesem Grund kann man also Bilder *nicht* direkt versenden. Zum Beispiel resultiert `radio.send(Image.HAPPY)` in einem Fehler. Es gibt aber einen Workaround:

   1. Konvertiere das Bild in einen String: `s = repr(Image.HAPPY)`
     1. Sende s mit print an die Konsole, damit du siehst, wie s aussieht. 
   1. Entferne alles, so dass String noch die Form `s = '00000:00000:00900:00000:00000'` hat.
     1. Mit [[https://www.geeksforgeeks.org/python/string-slicing-in-python/|String-Slicing]] kannst du die unnötigen Teile entfernen.
   1. Versende diesen String.
   1. Wandle den empfangenen String mit `Image()` wieder in ein Bild um und zeige es an.




==== Signalstärke & Distanzmessungen ====

Bisher haben wir mit `message_in = radio.receive()` Nachrichten empfangen. Es gibt aber noch eine zweite Möglichkeit: Mit `radio.receive_full()` empfängt man nicht nur die eigentliche Textnachricht, sondern auch die **Signalstärke**. Diese ist auch ein Indiz für die **Distanz** zwischen zwei micro:bits.

Das folgende Code-Beispiel zeigt, wie man die Textnachricht und die Signalstärke aus der erhaltenen Nachricht herauslesen kann:
<code python>
message_full = radio.receive_full()
if message_full:
    text = message_full[0]
    signal_strength = message_full[1]
</code>

Die Signalstärke (hier `signal_strength`) ist einfach eine Zahl, die grösser wird, je stärker das Signal ist. Tipp: Printe die Signalstärke in die Konsole (`print(signal_strength)` und **Show serial** klicken, um Konsole anzuzeigen) und verfolge, wie sich der Wert verändert, wenn die Distanz verändert wird. 

==== Erstes Programm ====

** Probiert das Programm zu zweit aus:**

* Ladet obiges Programm auf eure Microbits und schaut, ob ihr euch via Microbit gegenseitig "Ciao!" sagen könnt.
* **Achtung:** Wenn andere im gleichen Raum ebenfalls das Programm ausprobieren, empfangen sie ebenfalls eure Nachrichten (und ihr ihre). Um dies zu verhindern, habt ihr mindestens zwei Möglichkeiten:
  * Ihr könnt auf einer anderen Frequenz senden: mit dem Befehl ''radio.config(channel = x)'' wählt ihr einen **Kanal zwischen 0 und 83** (für x setzt ihr die Kanal-Nummer ein). Standardmässig ist der Kanal = 7 (und die Frequenz damit 2407 MHz).
  * Ihr könnt Nachrichten herausfiltern, indem ihr mit dem Befehl ''radio.config(group = x)'' eine eigene **Gruppe-Nr. zwischen 0 und 255** wählt (standardmässig ist die Gruppe 0). So werden eure Nachrichten mit einer spezifischen Adresse versehen und eure Microbits schauen nur nach Nachrichten mit dieser Adresse. Wähle *nur eine* der beiden Möglichkeiten aus.

===== - Maqueen =====

In diesem Kapitel lernst du die wichtigsten Funktionen kennen, um mit dem Microbit das Fahrwerk **Maqueen** zu steuern. Du kannst den Microbit einfach in den dafür vorgesehenen Steckplatz stecken. Sobald du den Schalter hinten am Fahrwerk auf On stellst, wird der Microbit mit Strom versorgt.

==== - Ultraschall-Sensor ====

Wenn du den Ultraschall-Sensor auf das Maqueen-Fahrwerk steckst, sieht es so aus, als hätte der kleine Roboter nun zwei Augen:

{{:gf_informatik:maqueenwithultrasonic.jpg?600|}}

Technisch gesehen sind die beiden Zylinder aber keine Augen: Der linke Zylinder ist eher ein Mund und der rechte ein Ohr. Mit dem linken werden Schallwellen ausgesendet (engl.: //transmitted//, deshalb steht da ein T); es wird quasi gerufen. Mit dem rechten Zylinder wird dann gehört; es werden also Schallwellen empfangen (engl.: //received//, deshalb steht da ein R). 

Du kennst das vom Echo-Effekt: Du rufst ganz laut "Haaallooo!" gegen eine Felswand und nach kurzer Zeit hörst du das Echo deines Rufs. Je weiter die Felswand entfernt ist, desto länger dauert es, bis du das Echo hörst, denn der Schall braucht seine Zeit, um von deinem Mund zur Felswand und zurück zu deinem Ohr zu gelangen. 

Das heisst: Du könntest die Zeit zwischen Ruf und Echo stoppen und so auf die Distanz zwischen dir und der Felswand schliessen. Genau so funktioniert der Ultraschallsensor:

{{:gf_informatik:microbit_maqueen_ultrasonic.png?800|}}

Auf der linken Seite des obigen Bildes siehst du, wie der Microbit mit dem Ultraschall-Sensor verbunden ist: Pin 1 ist mit dem Signal "Trigger" verbunden, Pin 2 mit dem Signal "Echo".

Auf der rechten Seite siehst du, wie es funktioniert: Wenn wir einen kurzen Impuls (10 µs = zehn Mikrosekunden) auf das Trigger-Signal geben, dann sendet der Ultraschall-Sensor Schallwellen in hoher, nicht hörbarer Frequenz (40 kHz) aus: Er "ruft". Wenn der Ultraschall-Sensor nun das Echo seines Rufes "hört", sendet er über das Echo-Signal einen Impuls zurück. Dieser Echo-Impuls ist so lange, wie es gedauert hat von "rufen" bis "hören".

Um nun eine Distanz zu messen, müssen wir nur ein kurzes Signal auf Pin 1 (Trigger) geben und dann an Pin 2 messen, wie lange das Echo-Signal dauert. Diese Zeit können wir in eine Distanz umrechnen: Der Schall legt ca. 340 Meter pro Sekunde zurück, das sind 0.034 cm pro Mikrosekunde. Angenommen, der Echo-Impuls ist 700 µs lang: Dann beträgt die Distanz 700 * 0.034 / 2 = 11.9 cm. Wir rechnen durch 2, weil der Schall die Distanz zweimal zurücklegt. Folgender Code misst die Distanz und zeigt sie auf dem Display an:

<code python>
from microbit import *
import utime
import machine

while True:
    # Distanz messen
    pin1.write_digital(1)   # Pin 1 (Trigger) HIGH für...
    utime.sleep_us(10)      # ...10 µs...
    pin1.write_digital(0)   # ...und wieder LOW.
    echo_pulse = machine.time_pulse_us(pin2, 1) # Messe, wie lange der Echo-Impuls an Pin 2 dauert.
    distance = echo_pulse * 0.017 # Rechne Zeit in Distanz um.

    # Ausgabe
    display.scroll(distance) # Ausgabe auf LED-Matrix
    print(distance) # Ausgabe in Konsole
  
    sleep(500)
</code>

Für die Funktion ''sleep\_us'' wird das Modul ''utime'' benötigt; für die Funktion ''time\_pulse\_in'' wird das Modul ''machine'' benötigt. Verstehst du jede Zeile des Codes? **Dann probiere den Code aus und überprüfe, ob die angezeigten Distanzen stimmen.** 

==== - Motor ====

Die beiden Räder des Maqueen-Fahrwerks werden von je einem Motor angetrieben. Die beiden Motoren werden über einen //Motor Controller (MC)// gesteuert:

{{:gf_informatik:microbit_maqueen_motors.png?400|}}

Über zwei Leitungen (Pins zwischen "3V" und "GND") ist der Microbit mit dem Motor-Controller (MC) verbunden: Diese beiden Leitungen dienen der Kommunikation über die sogenannte [[https://de.wikipedia.org/wiki/I%C2%B2C|I2C-Schnittstelle]] (I2C). Das ist eine serielle Schnittstelle, ähnlich wie USB. Auf diesem Weg sendet der Microbit dem Motor-Controller (MC) Befehle. Damit das funktioniert, muss der Microbit erst nach dem Motor-Controller suchen. Folgender Code ist dazu nötig:

<code python>
I2C_ADDR = 16 # Adresse des Motor-Controllers
while I2C_ADDR not in i2c.scan():
    display.show(Image.SAD)
display.show(Image.HAPPY)
</code> 

Obiger Code ruft die Funktion ''i2c.scan()'' so lange auf, bis der Motor-Controller an seiner Adresse gefunden wurde. Während der Suche wird ein //Sad Face// angezeigt; nach (erfolgreicher) Suche wird ein //Happy Face// angezeigt.

Jetzt können über I2C einzelne Nachrichten an die Adresse des Motor-Controllers gesendet werden. In diesen Nachrichten können wir dem MC mitteilen: 

* welcher Motor drehen soll, 
* in welche Richtung dieser drehen soll und 
* wie schnell er drehen soll.

Folgende Funktion sendet abgängig von den Parametern die richtigen Nachrichten:
<code python>
def motor_run(motors=0, direction=0x00, speed=0):
    # direction: 0 = forward, 1 = backward
    # speed range: 0...255
    i2c_buf = bytearray([motors, direction, speed])
    if motors == 0:  # left motor
        i2c_buf[0] = 0x00
        i2c.write(I2C_ADDR, i2c_buf)
    if motors == 1:  # right motor
        i2c_buf[0] = 0x02
        i2c.write(I2C_ADDR, i2c_buf)
    if motors == 2:  # both motors
        i2c_buf[0] = 0x00
        i2c.write(I2C_ADDR, i2c_buf)
        i2c_buf[0] = 0x02
        i2c.write(I2C_ADDR, i2c_buf)
</code> 

Du musst nicht jede Zeile dieser Funktion verstehen. Wichtig ist, dass du sie richtig verwendest: Hier eine kurze Übersicht:

* Mit dem Parameter ''motors'' wählst du die Motoren:
 * 0 für den linken Motor
 * 1 für den rechten Motor
 * 2 für beide Motoren
* Mit dem Parameter ''direction'' wählst du die Richtung:
 * 0 für vorwärts, 
 * 1 für rückwärts.
* Mit dem Parameter ''speed'' wählst du die Geschwindigkeit:
 * von 0 (stillstehend) bis 255 (schnell).

Wenn du zum Beispiel willst, dass der linke Motor mit der Geschwindigkeit 200 rückwärts dreht, dann rufst du die Funktion wie folgt auf:
<code python>
motor_run(0, 1, 200)
</code> 


==== - Maqueen Interface ====

Für die einfachere Steuerung des Maqueen inklusive seiner Sensoren und Aktoren gibt es eine Schnittstelle auf Github.

=== Installation ===
Zur Installation des Codes lädst du [[https://github.com/tkilla77/maqueen/releases/latest/download/maqueen.hex|maqueen.hex]] herunter und auf den Microbit drauf (an einfachsten: Datei auf die Seite ziehen).
    * Alternative: Lade [[https://github.com/tkilla77/maqueen/blob/master/maqueen/maqueen.py|maqueen.py]] und füge die Datei deinem Projekt hinzu.

**Beachte:** Du benötigst jeweils **zwei** Dateien in deinem Projekt: `maqueen.py` ist die Bibliothek für die Motorensteuerung, diese musst du weder lesen noch verstehen. In der Hauptdatei `main.py` ist dein eigener Code, der die Motorensteuerung benützt (mit `from maqueen import *`).

=== Distanzmesser ===
Der Ultraschallsensor gibt die ungefähre Distanz bis zum nächsten Objekt wieder. Lies [[#ultraschall-sensor|hier mehr dazu]]. Wenn du die `distance()` Funktion einbaust, kannst du vermeiden, dass der Roboter in Gegenstände fährt...

<code python>
from maqueen import *
from microbit import *

robot = Maqueen()
front_sensor = robot.front_sensor

dist = 10
while True:
    newdist = int(front_sensor.distance() / 10)
    if newdist != dist:
        dist = newdist
        # Show distance in decimeters
        print(str(dist) + "0cm") # print on console
        display.show(dist)       # ... and on display
    sleep(100)
</code>
=== Motorsteuerung ===
Es gibt zwei Arten, wie die Motoren des Maqueen gesteuert werden können. Am einfachsten ist der `Driver` - die Funktionen `drive`, `left`, `right` setzen den Roboter in Bewegung und blockieren die Ausführung, bis die Bewegung zu Ende ist. Achtung: die Angaben zu Distanz (in cm) und Winkel (in Grad) werden je nach Batterieladestand nicht immer genau eingehalten!

<code python>
from microbit import *
from maqueen import *

robot = Maqueen()

# High-level Driver interface:
# Fahre 20cm geradeaus, dann ein paar Kurven.
# Der Roboter stoppt automatisch nach jeder Funktion.
driver = robot.driver
driver.drive(20)
driver.left(90)
driver.right(180)
driver.left(90)
</code>

Die Driver-Steuerung ist ähnlich wie die Turtle-Bewegungen aus Programmieren 1, aber eignet sich weniger gut, um auf Ereignisse zu reagieren. Zum Beispiel möchten wir stoppen, wenn der Ultraschall-Sensor ein Hindernis detektiert.

Mit der `Chassis`-Schnittstelle kannst du den Roboter bis auf Weiteres in Bewegung setzen und erst auf ein bestimmtes Ereignis hin wieder stoppen:

<code python>
from microbit import *
from maqueen import *

robot = Maqueen()
# Die Chassis-Funktionen setzen den Roboter in Bewegung 
# und kommen dann sofort zurück. Vergiss nicht, den Roboter
# wieder zu stoppen! Dazu könntest du den Ultraschall-
# Sensor benützen:
chassis = robot.chassis

chassis.forward(speed=100) # Vorwärts fahren mit Geschwindigkeit 100
sleep(1000)     # 1s weiterfahren
chassis.stop() # Stoppen
chassis.left() # Links drehen bis auf weiteres
sleep(500)     # Wenden während einer halben Sekunde
chassis.stop() # Wieder anhalten
</code> 

=== Front LEDs ===
Schalte die zwei roten LEDs auf der Vorderseite ein und aus mit der `front_lights.set_lights` Funktion:

<code python>
from microbit import *
from maqueen import *

robot = Maqueen()

# Licht an
robot.front_lights.set_lights(1,1)

# Licht aus
robot.front_lights.set_lights(0,0)
</code>

=== Bottom LEDS ===

Du kannst die Farb-LEDs auf der Unterseite des Maqueens wie folgt kontrollieren. Die LEDs können im [[https://www.farb-tabelle.de/de/farbtabelle.htm|RGB-Farbraum]] (rot-grün-blau) programmiert werden. Jede Farbe kann Werte von 0 (aus) bis 255 annehmen.

<code python>
from maqueen import *

robot = Maqueen()
leds = robot.bottom_leds

# Setze das erste LED auf rot:
leds[0] = (255,0,0)
# Setze das zweite LED auf weiss (= alle Farben auf voll):
leds[1] = (255,255,255)
# Die LEDs werden erst geändert, wenn show() aufgerufen wird:
leds.show()

# Alle 4 LEDS in magenta:
leds.fill((255,0,255))
leds.show()

# Licht aus!
leds.clear()
</code>

=== Boden-Farbe erkennen ===
Die `read()` Funktion gibt die Helligkeit des Bodens wieder. Beide Werte sind entweder 0 (= Boden ist schwarz oder kein Boden sichtbar) oder 1 (= Boden ist weiss / hell). Auf der Oberseite zeigen zwei kleine blaue LEDs den Zustand der Sensoren an. Kannst du den Roboter einer Linie folgen lassen, wenn du diesen Code einbaust? 

<code python>
from microbit import *
from maqueen import *

robot = Maqueen()
floor_sensor = robot.floor_sensor

left, right = floor_sensor.read() # left/right nehmen Wert 0 oder 1 an
</code>