# MicroPython Tutorial
## Code-Datei herunterladen
Hinweis: Alle Kurscodes stehen hier zum Download bereit. Download-Links werden später nicht mehr bereitgestellt. Um zu vermeiden, dass Sie es vergessen, empfehlen wir Ihnen, den Code jetzt für zukünftiges Tutorial-Lernen herunterzuladen.
[Zum Download klicken](./MiroPython_Resource.7z)
## 1. MU IDE
### 1. 1 MU IDE installieren
Mu ist ein Python-Code-Editor für angehende Programmierer, der auf Lehrern und Schülern basiert. Der einfachste Weg, Mu zu erhalten, ist über das offizielle Installationsprogramm für Windows oder Mac OSX (Mu unterstützt keine 32-Bit-Windows mehr). Die aktuell empfohlene Version ist Mu 1.0-beta 2.
#### Schritt 1 - Version bestimmen und Mu-Installer herunterladen
Öffnen Sie den Link: [https://codewith.mu/en/download](https://codewith.mu/en/download), um die entsprechende Mu-Softwareversion herunterzuladen.
Finden Sie heraus, ob Ihr Computer Windows oder Mac OSX verwendet, und öffnen Sie den Explorer, klicken Sie auf "Dieser PC" und wählen Sie dann "Eigenschaften", um zu erfahren, ob Ihr Windows-System 32-Bit oder 64-Bit ist.
**Systemtyp anzeigen:**
#### Schritt 2 - Installer ausführen
Suchen Sie den gerade heruntergeladenen Installer (er befindet sich möglicherweise in Ihrem Download-Ordner) und doppelklicken Sie, um die Installer-Datei zu öffnen.
Download-Link für Mac OSX System: [https://codewith.mu/en/howto/1.1/install_macos](https://codewith.mu/en/howto/1.1/install_macos)
**Windows 10 System**
Tippen Sie auf „Weitere Informationen“
Geben Sie „Trotzdem ausführen“ ein
#### Schritt 3 - Protokoll
Überprüfen Sie die Lizenz und klicken Sie dann auf Installieren.
#### Schritt 4 - Installation
Es dauert einige Sekunden, Mu auf Ihrem Computer zu installieren.
#### Schritt 5 - Fertigstellen
Tippen Sie auf Fertigstellen
#### Schritt 6 - Mu starten
Sie können Mu starten, indem Sie auf das Symbol im Startmenü klicken oder Mu in das Suchfeld eingeben (beide Methoden sind unten dargestellt).
Die Hauptoberfläche von Mu ist unten dargestellt:
### 1.2 Compiler-Setup und Einführung in die Symbolleiste
Stellen Sie zuerst den „Modus“ auf micro:bit ein.
Öffnen Sie die Mu-Software, klicken Sie in der Menüleiste auf die Schaltfläche „Modus“ und wählen Sie „BBC micro:bit“ aus, dann tippen Sie auf „OK“.
### 1.3 Bibliotheksdatei installieren
Bevor Sie die Bibliothek importieren, müssen Sie einen .py-Code auf micro:bit hochladen. Hier nehmen wir das RGB-Modul "code_1.py" im Tutorial als Beispiel.
Importieren Sie die Datei „keyes_MiniCar.py“
Das Standardverzeichnis zum Speichern von Mu ist die Datei "Mu_code", die sich im Stammverzeichnis des Benutzerverzeichnisses befindet.
Wenn Ihr System beispielsweise unter Windows auf dem Laufwerk C Ihres Computers installiert ist und der Benutzername Administrator lautet, ist der Pfad zum Verzeichnis mu_code C:\Users\Administrator\mu_code. Unter Linux lautet der Pfad ~/home/mu_code.
**Geben Sie die Datei „mu_code“ ein**
Kopieren Sie die Bibliotheksdatei "keyes_MiniCar.py" in den Ordner "mu_code". Der Codepfad ist wie folgt:
Öffnen Sie die Mu-Software und verbinden Sie das micro:bit mit Ihrem Computer. Klicken Sie dann auf die Schaltfläche "Dateien" und ziehen Sie die Bibliotheksdatei "keyes_MiniCar.py" in das micro:bit.
Nach erfolgreichem Import sehen Sie es im linken Feld.
Tippen Sie auf „Prüfen“, um den Code auf Fehler zu überprüfen. Wenn eine Zeile mit einem Cursor oder einem Unterstrich erscheint, liegt in dieser Zeile ein Fehler im Programm vor.
Diese Tipps sind nur Warnungen, keine Code-Fehlermeldungen.
Sie müssen auch sicherstellen, dass das Micro-USB-Kabel mit dem micro:bit und dem Computer verbunden ist, und dann auf die Schaltfläche "Flash" klicken, um den Code auf das micro:bit herunterzuladen.
Wenn nach dem Klicken auf die Schaltfläche "Flash" ein Fehler auftritt, überprüfen Sie bitte, ob Sie die Bibliotheksdatei in das micro:bit importiert haben.
Hinweis:
Wenn Sie andere Programme auf das micro:bit-Board heruntergeladen haben, außer der Bibliotheksdatei "keyes_MiniCar.py". Bevor Sie in Micropython programmieren, müssen Sie die Bibliotheksdatei in das micro:bit importieren.
Wenn Sie immer dasselbe micro:bit-Board für die Micropython-Programmierung verwenden, müssen Sie es nicht erneut an das micro:bit senden.
### 1.4 Code zum Compiler hinzufügen
Wir nehmen das erste Projekt des Basistutorials "Herzschlag" als Beispiel, öffnen den Ordner "Programm" im ersten Projektordner und suchen die Datei "microbit-Heartbeat".
Oder öffnen Sie die Mu-Software und tippen Sie auf die Datei „microbit-Heartbeat.py“, ziehen Sie sie dann in die Mu-Software:
wie unten gezeigt:
### 1.5 Code auf Micro:bit herunterladen
Verbinden Sie das micro:bit-Board und den Computer über das Micro-USB-Kabel.
Tippen Sie auf „Flash“, um den Code auf micro:bit herunterzuladen.
 sleep(500) display.show(val3) sleep(500) | LED bei (1,0) blinkt für 0,5s |
| display.show(val2) sleep(500) display.show(val3) sleep(500) | LED bei (3,4) blinkt für 0,5s |
#### 2.2.5 Testergebnis
Nach dem Herunterladen des Codes und dem Anschließen der Stromversorgung über ein USB-Kabel sehen Sie, dass die LED bei (1,0) für 0,5 Sekunden blinkt, dann die LED bei (3,4) für 0,5 Sekunden blinkt, in einer Schleife.
### 2.3 5 x 5 LED-Punktmatrix
#### 2.3.1 Beschreibung
Punktmatrizen erfreuen sich in unserem Leben großer Beliebtheit, z. B. LED-Bildschirme, Bushaltestellen und Mini-Fernseher im Aufzug.
Die Punktmatrix des Micro:bit-Boards besteht aus 25 Leuchtdioden. In der vorherigen Lektion haben wir die LEDs des Micro:bit-Boards gesteuert, um Muster, Zahlen und Zeichenfolgen durch Setzen der Koordinatenpunkte zu bilden. Darüber hinaus könnten wir eine andere Methode anwenden, um die Anzeige von Mustern, Zahlen und Zeichenfolgen zu vervollständigen.
#### 2.3.2 Benötigte Komponenten
|  |  |
| :-----------------------: | :------------------: |
| Micro:bit * 1 | Micro:bit * 1 |
#### 2.3.3 Testcode
Sie können den Code direkt aus dem Tutorial hochladen (lesen Sie bei Zweifeln die Datei "Entwicklungsumgebungskonfiguration").
```python
from microbit import *
val = Image("00900:""00900:""90909:""09990:""00900")
display.show(val)
```
**Testergebnis:** Laden Sie `2.3-5× 5 LED Dot Matrix-1.py` auf den micro:bit hoch, dann erscheint ein Abwärtspfeil.
```python
from microbit import *
val = Image("00900:""00900:""90909:""09990:""00900")
display.show('1')
sleep(500)
display.show('2')
sleep(500)
display.show('3')
sleep(500)
display.show('4')
sleep(500)
display.show('5')
sleep(500)
display.show(val)
sleep(500)
display.scroll("hello!")
sleep(200)
display.show(Image.HEART)
sleep(500)
display.show(Image.ARROW_NE)
sleep(500)
display.show(Image.ARROW_SE)
sleep(500)
display.show(Image.ARROW_SW)
sleep(500)
display.show(Image.ARROW_NW)
sleep(500)
display.clear()
```
#### 2.3.4 Code-Erklärung
| Code | Erklärung |
| ------------------------------------------------------------ | ------------------------------------------------------------ |
| from microbit import * | Importiert die Bibliotheksdatei von micro:bit |
| val = Image("09000:""00000:""00000:""0000 0:""00000:") | Setzt Image() auf die Variable val |
| display.show(val) | micro:bit zeigt „→“ |
| display.show('1') | display.show('1') |
| sleep(500) | sleep(500) |
| display.scroll("hello!") | micro:bit scrollt, um „hello!“ anzuzeigen |
| display.show(Image.HEART) | micro:bit zeigt „❤“ |
| display.show(Image.ARROW_NE) display.show(Image.ARROW_SE) display.show(Image.ARROW_SW) display.show(Image.ARROW_NW) | micro:bit zeigt „Nordost“-Pfeil micro:bit zeigt „Südost“-Pfeil micro:bit zeigt „Südwest“-Pfeil micro:bit zeigt „Nordwest“-Pfeil |
| display.clear() | Die LED-Punktmatrix des micro:bit wird gelöscht |
#### 2.3.5 Testergebnis
Laden Sie `2.3-5×5 LED Dot Matrix-2.py` auf den micro:bit hoch, dann zeigt die LED-Punktmatrix „1“, „2“,
„3“, „4“, „5“, „↓“, „hello!“, „❤“, , , ,  Muster an. Jedes Intervall beträgt 500 ms.
### 2.4 Programmierbare Tasten
#### 2.4.1 Beschreibung
Der Taster kann das Ein- und Ausschalten des Stromkreises steuern, der an den Stromkreis angeschlossen ist. Der Stromkreis ist unterbrochen, wenn der Taster nicht gedrückt wird. Der Stromkreis wird verbunden, sobald er gedrückt wird, aber er wird nach dem Loslassen wieder unterbrochen.
Beide Enden des Tasters sind wie zwei Berge. Dazwischen fließt ein Fluss. Das interne Metallstück verbindet die beiden Seiten, um den Strom durchzulassen, genau wie eine Brücke, die die beiden Berge verbindet.
**Funktionsweise**: Vor dem Drücken des Tasters sind 1, 2, 3 und 4 eingeschaltet, aber 1, 3 oder 1, 4 oder 2, 3 oder 2, 4 sind getrennt (blockiert), die beim Drücken des Tasters eingeschaltet werden.
Das Micro:bit-Board verfügt über drei Tasten, die Reset-Taste befindet sich auf der Rückseite und zwei programmierbare Tasten auf der Vorderseite. Drücken Sie A, B und AB gleichzeitig, und der entsprechende Bildschirm zeigt sie jeweils an.
#### 2.4.2 Benötigte Komponenten
|  |  |
| :-----------------------: | :------------------: |
| Micro:bit * 1 | Micro:bit * 1 |
#### 2.4.3 Testcode
Sie können den Code direkt aus dem Tutorial hochladen (lesen Sie bei Zweifeln die Datei "Entwicklungsumgebungskonfiguration").
```python
from microbit import *
while True:
if button_a.is_pressed():
display.show("A")
elif button_a.is_pressed() and button_b.is_pressed():
display.scroll("AB")
elif button_b.is_pressed():
display.show("B")
```
**Testergebnis:** Laden Sie `2.4-Programmable Buttons-1.py` hoch und schließen Sie den micro:bit über ein USB-Kabel an. Drücken Sie „A“ auf dem Micro:bit-Board, wird der Buchstabe „A“ angezeigt; wenn „B“ gedrückt wird, erscheint der Buchstabe „B“. „AB“ wird angezeigt, wenn Sie die Tasten A und B gleichzeitig drücken.
```python
from microbit import *
a = 0
b = 0
val1 = Image("00000:""00000:""00
| sleep(500) | Verzögerung um 500ms |
| **if** temperature() >= 35: display.show(Image.HEART) **else**: display.show(Image.HEART_SMALL) | Wenn der Temperaturwert ≥35℃ ist, zeigt micro:bit „ “ an. Wenn der Temperaturwert <35℃ ist, zeigt micro:bit „“ an. |
### 2.6 Kompass
#### 2.6.1 Beschreibung
Dieses Projekt stellt hauptsächlich die Verwendung des Micro:bit-Kompasses vor. Er kann zur Bestimmung der Richtung verwendet werden. Wir müssen die Micro:bit-Platine kalibrieren, wenn der Magnetsensor arbeitet. Die korrekte Kalibrierungsmethode besteht darin, die Micro:bit-Platine zu drehen.
Zusätzlich können Objekte in der Nähe die Genauigkeit der Messwerte und der Kalibrierung beeinflussen.
#### 2.6.2 Benötigte Komponenten
|  |  |
| :-----------------------: | :------------------: |
| Micro:bit * 1 | Micro:bit * 1 |
#### 2.6.3 Testcode
Sie können den Code direkt aus dem Tutorial hochladen (lesen Sie bei Zweifeln die Datei "Entwicklungsumgebungskonfiguration").
```python
from microbit import *
compass.calibrate()
while True:
if button_a.is_pressed():
display.scroll(compass.heading())
```
**Code-Erklärung:** Wir müssen micro:bit aufgrund unterschiedlicher Magnetfelder in verschiedenen Bereichen kalibrieren. Micro:bit fordert Sie zur Kalibrierung auf, wenn Sie es zum ersten Mal verwenden.
Übertragen Sie `2.6-Magnetic sensor-1.py` auf micro:bit, schließen Sie micro:bit über ein USB-Kabel an und drücken Sie Taste A. „TILT TO FILL SCREEN“ erscheint auf micro:bit. Dann gelangen Sie in die Kalibrierungsoberfläche. Die Kalibrierungsmethode besteht darin, die micro:bit-Platine zu drehen und ein vollständiges Quadratmuster (25 LEDs leuchten) anzuzeigen, wie in der folgenden Abbildung gezeigt:
Die Kalibrierung ist abgeschlossen, sobald Sie das lächelnde Muster  sehen.
Der serielle Monitor zeigt 0°, 90°, 180° und 270° an, wenn Taste A gedrückt wird.
--------
```python
from microbit import *
compass.calibrate()
x = 0
while True:
x = compass.heading()
if x >= 293 and x < 338:
display.show(Image("00999:""00099:""00909:""09000:""90000"))
elif x >= 23 and x < 68:
display.show(Image("99900:""99000:""90900:""00090:""00009"))
elif x >= 68 and x < 113:
display.show(Image("00900:""09000:""99999:""09000:""00900"))
elif x >= 113 and x < 158:
display.show(Image("00009:""00090:""90900:""99000:""99900"))
elif x >= 158 and x < 203:
display.show(Image("00900:""00900:""90909:""09990:""00900"))
elif x >= 203 and x < 248:
display.show(Image("90000:""09000:""00909:""00099:""00999"))
elif x >= 248 and x < 293:
display.show(Image("00900:""00090:""99999:""00090:""00900"))
else:
display.show(Image("00900:""09990:""90909:""00900:""00900"))
```
Richten Sie die micro:bit-Platine horizontal nach Norden, Süden, Osten und Westen aus, die LED-Punktmatrix zeigt die entsprechenden Richtungsmuster an.
Wie unten gezeigt, zeigt der Pfeil nach oben rechts, wenn der Wert zwischen 292,5 und 337,5 liegt. 0,5 kann im Code nicht eingegeben werden, daher sind die Werte, die wir erhalten, 293 und 338.
Laden Sie `2.6-Magnetic sensor-2.py` auf die micro:bit-Platine hoch und ziehen Sie das USB-Kabel nicht ab. Nach der Kalibrierung neigen Sie die Micro:bit-Platine, die LED-Punktmatrix zeigt die Richtungssymbole an.
#### 2.6.4 Code-Erklärung
| code | Erklärung |
| ------------------------------------------------------------ | ------------------------------------------------------------ |
| from microbit import * | Importiert die Bibliotheksdatei von micro:bit |
| compass.calibrate() | Kompasskalibrierung |
| while True: | Dies ist eine Dauerschleife, die micro:bit den Code ausführen lässt. |
| **if** button_a.is_pressed(): display.scroll(compass.heading()) | Wenn Taste A gedrückt wird, scrollt micro:bit, um den Wert des Kompasses anzuzeigen. |
| x = 0 | Variable x=0 setzen |
| x = compass.heading() | Den Wert des Kompasses der Variable x zuweisen |
| **if**...**elif**...**else** | Den Wert des Kompasses der Variable x zuweisen |
| display.show(Image("00999:""0009 9:""00909:""09000:""90000")) display.show(Image("99900:""9900 0:""90900:""00090:""00009")) display.show(Image("00900:""0900 0:""99999:""09000:""00900")) display.show(Image("00009:""0009 0:""90900:""99000:""99900")) display.show(Image("00900:""0090 0:""90909:""09990:""00900")) display.show(Image("90000:""0900 0:""00909:""00099:""00999")) display.show(Image("00900:""0009 0:""99999:""00090:""00900")) display.show(Image("00900:""0999 0:""90909:""00900:""00900")) | Micro:bit zeigt das Nordost-Pfeilsymbol an. Micro:bit zeigt das Nordwest-Pfeilsymbol an. Micro:bit zeigt das West-Pfeilsymbol an. Micro:bit zeigt das Südwest-Pfeilsymbol an. Micro:bit zeigt das Südost-Pfeilsymbol an. Micro:bit zeigt das Süd-Pfeilsymbol an. Micro:bit zeigt das Ost-Pfe
| from microbit import * | Importiert die Bibliotheksdatei von micro:bit |
| gesture = accelerometer.current_gesture() | Setzt accelerometer.current_gesture() auf gesture |
| while True: | Dies ist eine Dauerschleife, und micro:bit führt den Code aus |
| Lightintensity = display.read_light_level() | Setzt display.read_light_level() auf Lightintensity |
| print("Light intensity:", Lightintensity) | BBC micro:bit REPL gibt den erkannten Lichtintensitätswert aus |
| sleep(100) | Verzögerung um 100ms |
#### 2.8.5 Testergebnis
Laden Sie den Code auf das micro:bit-Board herunter, ziehen Sie das USB-Kabel nicht ab. Klicken Sie auf „REPL“ und drücken Sie die Reset-Tasten, der Lichtintensitätswert wird angezeigt, wie unten gezeigt.
Wenn die LED-Punktmatrix abgedeckt wird, ist der Intensitätswert 0; im Gegenteil, der Intensitätswert steigt, wenn das micro:bit-Board unter die Sonne gelegt wird.
### 2.9 Lautsprecher
#### 2.9.1 Beschreibung
Das micro:bit-Mainboard verfügt über einen eingebauten Lautsprecher, der es sehr einfach macht, Ihrem Projekt einen Ton hinzuzufügen. Der Lautsprecher kann so programmiert werden, dass er eine Vielzahl von Tönen ausgibt, z. B. das Schreiben eines Liedes: Ode an die Freude, und es abspielt.
#### 2.9.2 Benötigte Komponenten
|  |  |
| :-----------------------: | :------------------: |
| Micro:bit * 1 | Micro:bit * 1 |
#### 2.9.3 Testcode
Sie können den Code direkt aus dem Tutorial hochladen (lesen Sie bei Zweifeln die Datei „Entwicklungsumgebungskonfiguration“).
```python
from microbit import *
import audio
display.show(Image.MUSIC_QUAVER)
while True:
audio.play(Sound.GIGGLE)
sleep(1000)
audio.play(Sound.HAPPY)
sleep(1000)
audio.play(Sound.HELLO)
sleep(1000)
audio.play(Sound.YAWN)
sleep(1000)
```
#### 2.9.4 Code-Erklärung
| Code | Erklärung |
| ------------------------ | ------------------------------------------------------- |
| from microbit import * | Importiert die Bibliotheksdatei von micro:bit |
| import audio | Audio-Bibliotheksdatei |
| while True: | Dies ist eine Dauerschleife, und micro:bit führt den Code aus |
| audio.play(Sound.GIGGLE) | Erzeugt ein Kichergeräusch |
| sleep(1000) | Verzögerung um 1000ms |
#### 2.9.5 Testergebnis
Laden Sie den Code auf das micro:bit-Board herunter, ziehen Sie das USB-Kabel nicht ab, dann gibt der Lautsprecher einen Ton aus und die LED-Punktmatrix zeigt ein Musiklogo-Muster an.
### 2.10 Berührungsempfindliches Logo
#### 2.10.1 Beschreibung
Wenn Sie ein micro:bit-Mainboard besitzen, ist es sinnvoll, ein goldfarbenes, berührungsempfindliches Logo als weiteren Eingang in Ihrem Projekt zu verwenden, das wie ein zusätzlicher Knopf funktioniert. Es verwendet einen kapazitiven Berührungssensor, der kleine Änderungen in elektrischen Feldern erkennt, wenn Sie es mit dem Finger drücken (oder berühren). Wenn Sie es berühren, können Sie das micro:bit-Board steuern, um bestimmte Funktionen auszuführen.
#### 2.10.2 Benötigte Komponenten
|  |  |
| :-----------------------: | :------------------: |
| Micro:bit * 1 | Micro:bit * 1 |
#### 2.10.3 Testcode
Sie können den Code direkt aus dem Tutorial hochladen (lesen Sie bei Zweifeln die Datei „Entwicklungsumgebungskonfiguration“).
```python
from microbit import *
time = 0
start = 0
running = False
while True:
if button_a.was_pressed():
running = True
start = running_time()
if button_b.was_pressed():
if running:
time += running_time() - start
running = False
if pin_logo.is_touched():
if not running:
display.scroll(int(time/1000))
if running:
display.show(Image.HEART)
sleep(300)
display.show(Image.HEART_SMALL)
sleep(300)
else:
display.show(Image.ASLEEP)
```
#### 2.10.4 Code-Erklärung
(1) Micro:bit zeichnet die Zeit in ms (Tausendstel Minuten pro Sekunde) auf, wenn es gestartet wird. Dies wird als Laufzeit bezeichnet.
(2) Wenn Sie Taste A drücken, wird eine Variable namens `start` auf die aktuelle Laufzeit gesetzt.
(3) Wenn Sie Taste B drücken, wird die Startzeit von der neuen Laufzeit subtrahiert, um herauszufinden, wie viel Zeit seit dem Start der Stoppuhr vergangen ist. Diese Differenz wird zur Gesamtzeit addiert, die in einer Variablen namens `time` gespeichert ist.
(4) Wenn Sie das goldene LOGO-Symbol drücken, zeigt das Programm die gesamte verstrichene Zeit auf der LED-Anzeige an. Es wandelt die Zeit von ms (Tausendstel Sekunden) in Sekunden um, indem es durch 1000 teilt. Es verwendet den Integer-Divisionsoperator, um das Ergebnis als Ganzzahl zu erhalten.
(5) Das Programm verwendet auch eine boolesche Variable namens `running`, um das Programm zu steuern. Boolesche Variablen haben nur zwei Werte: wahr oder falsch. Wenn `running` wahr ist, ist die Stoppuhr gestartet. Wenn `running` falsch ist, ist die Stoppuhr nicht gestartet oder gestoppt.
(6) Wenn `running` wahr ist, wird das schlagende Herz auf dem LED-Punktbildschirm angezeigt.
(7) Wenn die Stoppuhr gestoppt wurde, d.h. wenn "running" falsch ist, wird die Zeit nur angezeigt, wenn Sie das goldene LOGO-Symbol drücken.
(8) Wenn die Stoppuhr bereits gestartet ist, d.h. wenn "running" wahr ist, verhindert der Code auch Fehlmessungen, indem er sicherstellt, dass sich die Zeitvariable nur ändert, wenn Taste B gedrückt wird.
#### 2.10.5 Testergebnis
Laden Sie den Code hoch und schließen Sie das micro:bit über ein USB-Kabel an. Drücken Sie Taste A, um die Stoppuhr zu starten. Während der Timer läuft, zeigt die LED-Punktmatrix ein schlagendes Herz an. Durch Tippen auf Taste B kann sie gestoppt werden. Sie wird weiterhin Zeit hinzufügen, wie eine echte Stoppuhr.
Drücken Sie das goldene LOGO-Symbol auf der Vorderseite des micro:bit, um die gemessene Zeit in Sekunden anzuzeigen. Um die Zeit auf Null zurückzusetzen, drücken Sie die Reset-Taste auf der Rückseite des micro:bit-Boards.
### 2.11 Mikrofon
#### 2.11.1 Beschreibung
Das micro:bit-Mainboard verfügt über ein eingebautes Mikrofon, das zur Messung des Umgebungsgeräuschpegels verwendet werden kann. Wenn Sie klatschen, leuchtet die LED-Anzeige auf dem micro:bit-Mainboard auf. Es kann die Intensität des Schalls messen. In diesem Zusammenhang können Sie eine Schallpegelkarte oder Disco-Lichter erstellen, die im Takt der Musik sind.
#### 2.11.2 Benötigte Komponenten
|  |  |
| :-----------------------: | :------------------: |
| Micro:bit * 1 | Micro:bit * 1 |
#### 2.11.3 Testcode
Sie können
| ------ | ------------------ | -------- | ------------------ |
| Schwarz | 255,255,255 | Rot | 0,255,255 |
| Grün | 255,0,255 | Blau | 255,255,0 |
| Cyan | 255,0,0 | Dunkelrot | 0,255,0 |
| Gelb | 0,0,255 | Weiß | 0,0,0 |
| ...... | ....... | ...... | ...... |
Da unsere LED-Leuchten eine gemeinsame Anode haben, ist 255 der niedrigste Wert und 0 der hellste Wert.
In diesem Projekt werden wir zwei Experimente durchführen. Eines besteht darin, zwei RGB-Leuchten in den drei Farben Rot, Grün und Blau leuchten zu lassen, das andere darin, zwei RGB-Leuchten allmählich verschiedene Farben anzeigen zu lassen.
#### 3.1.2 Vorbereitung
(1) micro:bit korrekt in die Erweiterungsplatine einstecken
(2) Batteriehalter an die Erweiterungsplatine anschließen
(3) Netzschalter einschalten (Den POWER-Schalter auf ON stellen)
(4) micro:bit und Computer über ein Micro-USB-Kabel verbinden
(5) MU IDE öffnen
Wenn Sie die Mini-Car-Erweiterungsbibliothek hinzufügen möchten (siehe Datei "1.4 Install the Library File").
#### 3.1.3 Schaltplan
**Funktionsprinzip:** Microbit sendet als Host Befehle über IIC an den Slave STC8G1K08, dann gibt der Slave PWM aus, um die RGB-LED-Leuchten zu steuern. Dies spart erheblich die IO-Ports der Microbit-Platine, da das IIC zwei Motoren und zwei RGB-LED-Leuchten steuern kann.
#### 3.1.4 Code-Erklärung
Funktionen der RGB-LEDs in der Datei Keyes_MiniCar.py:
Left.red(0-255): Stellt die linke RGB auf Rot ein, 0 ist am hellsten und 255 am dunkelsten.
Left.green(0-255): Stellt die linke RGB auf Grün ein, 0 ist am hellsten und 255 am dunkelsten.
Left.blue(0-255): Stellt die linke RGB auf Blau ein, 0 ist am hellsten und 255 am dunkelsten.
right.red(0-255): Stellt die rechte RGB auf Rot ein, 0 ist am hellsten und 255 am dunkelsten.
right.green(0-255): Stellt die rechte RGB auf Grün ein, 0 ist am hellsten und 255 am dunkelsten.
right.blue(0-255): Stellt die rechte RGB auf Blau ein, 0 ist am hellsten und 255 am dunkelsten.
#### 3.1.5 Testcode
Sie können die Datei `3.1-RGB LED-1.py` direkt aus dem Tutorial hochladen (lesen Sie bei Zweifeln die Datei "Development Environment Configuration").
```python
from microbit import *
from keyes_MiniCar import *
minicar = MiniCar()
while True:
minicar.left_red(0)
minicar.right_red(0)
sleep(1000)
minicar.led_off()
minicar.left_green(0)
minicar.right_green(0)
sleep(1000)
minicar.led_off()
minicar.left_blue(0)
minicar.right_blue(0)
sleep(1000)
minicar.led_off()
```
**Testergebnis:** Nach dem Hochladen des Codes wechselt die RGB-LED jede Sekunde in der Reihenfolge Rot, Grün und Blau.
-------
Importieren Sie die Datei `3.1-RGB LED-2.py`
```python
from microbit import *
from keyes_MiniCar import *
minicar = MiniCar()
while True:
for num in range(0 , 255): #It is a loop statement, the range is 0 to 255
num += 1 #It is equal to num = num + 1
minicar.left_red(255 - num)
minicar.right_red(255 - num)
sleep(10)
for num in range(0 , 255):
num += 1
minicar.left_green(255 - num)
minicar.right_green(255 - num)
sleep(10)
for num in range(0 , 255):
num += 1
minicar.left_red(num)
minicar.right_red(num)
sleep(10)
for num in range(0 , 255):
num += 1
minicar.left_blue(255 - num)
minicar.right_blue(255 - num)
sleep(10)
for num in range(0 , 255):
num += 1
minicar.left_red(255 - num)
minicar.right_red(255 - num)
sleep(10)
for num in range(0 , 255):
num += 1
minicar.left_green(num)
minicar.right_green(num)
sleep(10)
for num in range(0 , 255):
num += 1
minicar.left_red(num)
minicar.right_red(num)
sleep(10)
for num in range(0 , 255):
num += 1
minicar.left_blue(num)
minicar.right_blue(num)
sleep(10)
```
**Testergebnis:** Nach dem Hochladen des Codes leuchtet die RGB-LED rot, dann grün, dann erscheint eine Mischung aus Rot und Grün. Wenn das rote Licht aus ist, leuchtet das blaue Licht, dann wird eine Mischung aus Blau und Grün angezeigt.
Wenn jedoch das grüne Licht aus ist, leuchtet das rote Licht, dann wird eine Mischung aus Blau und Rot angezeigt. Zum Schluss werden die roten und blauen Lichter ausgeschaltet.
#### 3.1.6 Erweitertes Wissen
1s = 1000ms; 1ms = 1000us; 1us = 1000nm
Die 1000 ms, die wir im Projekt verwendet haben, sind also 1 s.
Vielleicht sind Sie in der Lage, die gewünschte Lichtfarbe selbst zu konfigurieren. Sie müssen lediglich die roten, grünen und blauen PWM-Werte für die RGB konfigurieren.
### 3.2 Motorantrieb
#### 3.2.1 Beschreibung
Das Roboterauto ist mit zwei DC-Getriebemotoren ausgestattet, die auf gewöhnlichen DC-Motoren basieren. Es verfügt über ein passendes Getriebe, das eine geringere Geschwindigkeit, aber ein größeres Drehmoment bietet. Darüber hinaus können verschiedene Untersetzungsverhältnisse des Getriebes unterschiedliche Geschwindigkeiten und Drehmomente liefern.
Der Untersetzungsmotor ist die Integration von Getriebemotor und Motor, die in der Stahl- und Maschinenindustrie weit verbreitet ist.
Darüber hinaus verfügt das Auto über einen STC8G1K08- und einen HR8833MTE-Chip. Um die IO-Ports zu sparen, senden wir Befehle über das IIC des micro:bit an den STC8G1K08-Chip. Der STC8G1K08-Chip steuert dann den HR8833MTE-Chip gemäß den entsprechenden Anweisungen, um die Drehrichtung und Geschwindigkeit der beiden DC-Untersetzungsmotoren zu steuern (der Steuerprozess ist wie folgt).
#### 3.2.2 Vorbereitung
(1) micro
minicar.Motor_L(1, 70) #It is a code of advance
minicar.Motor_R(1, 70)
elif LDR_L > 650 and LDR_R <= 650: #Judge if the left brightness＞650，right≤650
minicar.Motor_L(0, 70) #Left turn code
minicar.Motor_R(1, 70)
elif LDR_L <= 650 and LDR_R > 650: #Judge if the left side of the car≤650，right＞650
minicar.Motor_L(1, 70) #The car turns right
minicar.Motor_R(0, 70)
else:
minicar.Motor_stop() #The car stops
```
#### 3.3.7 Testergebnis
Nach dem Hochladen des Codes schalten Sie den Schalter auf der Rückseite des Autos ein, dann können Sie eine Taschenlampe verwenden, um mit dem Auto zu spielen. Es ist am besten in einer relativ dunklen Umgebung zu verwenden. Wenn die Umgebungslichtintensität über 650 liegt, fährt das Auto weiter.
### 3.4 Linienverfolgungs-Smart-Car
#### 3.4.1 Beschreibung
Das Auto ist mit zwei Linienverfolgungssensoren und zwei Potentiometern ausgestattet.
Außerdem verwendet es eine TCRT5000 IR-Röhre, die eine IR-Emissionsröhre und eine IR-Empfangsröhre enthält. Wenn die Infrarotsignale der Emissionsröhre durch Reflexion von der Empfangsröhre empfangen werden, ändert sich der Widerstand der Empfangsröhre, was sich im Allgemeinen in der Spannungsänderung im Stromkreis widerspiegelt.
Der Widerstand variiert je nach Intensität der von der Empfangsröhre empfangenen Infrarotsignale, die oft in der Farbe der reflektierenden Oberfläche und deren Abstand zur Empfangsröhre liegen. Zum Zeitpunkt der Erkennung ist Schwarz High-Level-aktiv und Weiß Low-Level-aktiv.
**Funktionsprinzip:** Wenn das Auto über einer weißen Straße fährt, sendet die unter dem Auto installierte IR-Emissionsröhre Infrarotsignale aus, um die Straße zu erkennen, und die Empfangsröhre empfängt die zurückgesendeten Signale. Dann gibt der Ausgang Low-Level (0) aus. Wenn es schwarze Linien erkennt, gibt es High-Level (1) aus.
Senden Sie das erkannte Signal an den I/O-Port des Mikrocontrollers. Wenn es High-Level (1) ist, befindet sich das Auto auf der schwarzen Linie. Wenn es Low-Level (0) ist, befindet sich das Auto auf dem weißen Untergrund.
Die beiden Linienverfolgungssensoren auf der Erweiterungsplatine werden von P12 und P13 der Micro:bit-Steuerplatine gesteuert, der linke von P13 und der rechte von P12. Stellen Sie die Linienverfolgungssensoren ein und platzieren Sie das Auto auf einem schwarzen Untergrund. Drehen Sie die Potentiometer, bis die LEDs (D3, D2) leuchten, und stellen Sie sie dann so ein, dass sie wieder ausgehen.
#### 3.4.2 Vorbereitung
(1) Stecken Sie das micro:bit korrekt in die Erweiterungsplatine.
(2) Verbinden Sie den Batteriehalter mit der Erweiterungsplatine.
(3) Schalten Sie den Netzschalter ein (Schieben Sie den POWER-Schalter auf ON).
(4) Verbinden Sie das micro:bit und den Computer über ein Micro-USB-Kabel.
(5) Öffnen Sie die MU IDE.
Wenn Sie die Mini-Car-Erweiterungsbibliothek hinzufügen möchten (siehe Datei "1.4 Install the Library File").
#### 3.4.3 Schaltplan
#### 3.4.4 Den Linienverfolgungssensor auslesen
Sie können den Code `3.4-Read the Line Tracking Sensor.py` direkt aus dem Tutorial hochladen (lesen Sie die Datei "Development Environment Configuration", falls Sie Zweifel haben).
```python
from microbit import *
pin12.set_pull(pin12.PULL_UP)
pin13.set_pull(pin13.PULL_UP)
sensor_L = 0
sensor_R = 0
while True:
sensor_L = pin13.read_digital()
sensor_R = pin12.read_digital()
print("sensor_L:", sensor_L)
print("sensor_R:", sensor_R)
sleep(1000)
```
**Testergebnis:** Laden Sie den Code auf das micro:bit-Board herunter, ziehen Sie das USB-Kabel nicht ab. Klicken Sie auf „REPL“ und drücken Sie die Reset-Taste. Die vom Linienverfolgungssensor erfassten Messwerte werden auf dem Monitor angezeigt.
Wenn der Linienverfolgungssensor ein weißes Objekt erkennt, wird 0 angezeigt und D2, D3 leuchten; wenn keine weißen Objekte und nur schwarze Objekte erkannt werden, wird 1 angezeigt und D2, D3 sind aus, wie unten gezeigt.
#### 3.4.5 Flussdiagramm
#### 3.4.6 Testcode
Sie können den Code `3.4-Patrol car.py` direkt aus dem Tutorial hochladen (lesen Sie die Datei "Development Environment Configuration", falls Sie Zweifel haben).
```python
from microbit import *
from keyes_MiniCar import * #Import the library file
minicar = MiniCar() #Instantiate an object MiniCar（）as minicar
pin12.set_pull(pin12.PULL_UP) #Set pin12 to pull up
pin13.set_pull(pin13.PULL_UP)
sensor_L = 0
sensor_R = 0
while True:
sensor_L = pin13.read_digital() #Read the value of the sensor
sensor_R = pin12.read_digital()
print("sensor_L:", sensor_L)
print("sensor_R:", sensor_R)
if sensor_L == 1 and sensor_R == 1: #Judge if sensor_L and sensor_R =1
minicar.Motor_L(1, 70) #Advance code
minicar.Motor_R(1, 70)
elif sensor_L == 0 and sensor_R == 1: #Judge if sensor_L =0 and sensor_R=1
minicar.Motor_L(1, 70) #Right turn code
minicar.Motor_R(0, 70)
elif sensor_L == 1 and sensor_R == 0: #Judge if sensor_L=1 and sensor_R=0
minicar.Motor_L(0, 70)
minicar.Motor_R(1, 70)
else:
minicar.Motor_stop()
```
**Testergebnis:** Laden Sie den Code hoch und schalten Sie den Netzschalter am Auto ein. Platzieren Sie das Auto auf dem Linienverfolgungspapier, dann folgt es der schwarzen Linie.
**Einstellen des Potentiometers:**
Wenn das Fahrzeug die Linie nicht richtig verfolgt, stellen Sie das Potentiometer bitte wie folgt ein.
1. Laden Sie den Kurs-Code hoch.
2. Positionieren Sie das Auto so, dass die Vorderseite zu Ihnen zeigt. Drehen Sie das linke Potentiometer vollständig gegen den Uhrzeigersinn und das rechte Potentiometer vollständig im Uhrzeigersinn.
3. Platzieren Sie das Auto auf