# MicroPython Handleiding
## Download codebestand
Opmerking: Alle cursuscode is hier beschikbaar om te downloaden. Downloadlinks worden later niet meer verstrekt. Om te voorkomen dat u het vergeet, raden we u aan de code nu te downloaden voor toekomstige tutoriallessen.
[Klik om te downloaden](./MiroPython_Resource.7z)
## 1. MU IDE
### 1. 1 Installeer MU IDE
Mu is een Python-code-editor voor beginnende programmeurs, gebaseerd op docenten en studenten. De eenvoudigste manier om Mu te verkrijgen is via de officiële installer voor Windows of Mac OSX (Mu ondersteunt geen 32-bit Windows meer). De huidige aanbevolen versie is Mu 1.0-beta 2.
#### Stap 1 - Bepaal de versie en download de Mu installer
Open de link: [https://codewith.mu/en/download](https://codewith.mu/en/download) om de corresponderende Mu softwareversie te downloaden.
Zoek uit of uw computer Windows of Mac OSX draait, en open de Verkenner, klik op "Deze pc", selecteer vervolgens Eigenschappen om te weten of uw Windows-systeem 32-bit of 64-bit is.
**Bekijk het systeemtype:**
#### Stap 2 - Voer de installer uit
Zoek de installer die u zojuist hebt gedownload (deze kan in uw downloadmap staan) en dubbelklik om het installerbestand te openen.
Downloadlink voor Mac OSX-systeem: [https://codewith.mu/en/howto/1.1/install_macos](https://codewith.mu/en/howto/1.1/install_macos)
**Windows 10 Systeem**
Tik op "Meer info"
Voer "Toch uitvoeren" in
#### Stap 3 - Protocol
Controleer de licentie en klik vervolgens op Installeren.
#### Stap 4 - Installatie
Het duurt een paar seconden om Mu op uw computer te installeren.
#### Stap 5 - Voltooien
Tik op Voltooien
#### Stap 6 - Start de Mu
U kunt Mu starten door op het pictogram in het Startmenu te klikken, of door Mu in het zoekvak te typen (beide methoden worden hieronder weergegeven).
De hoofdinterface van Mu wordt hieronder weergegeven:
### 1.2 Compilerinstellingen en introductie van de werkbalk
Stel eerst de "modus" in op micro:bit
Open de Mu-software, klik op de knop Mode in de menubalk en selecteer "BBC micro:bit", tik vervolgens op "OK".
### 1.3 Installeer het bibliotheekbestand
Voordat u de bibliotheek importeert, moet u een .py-code uploaden naar micro:bit. Hier nemen we de RGB-module "code_1.py" in de tutorial als voorbeeld.
Importeer het bestand "keyes_MiniCar.py"
De standaardmap voor het opslaan van Mu is de "Mu_code"-map, die zich in de hoofdmap van de gebruikersmap bevindt.
Als uw systeem bijvoorbeeld op de C-schijf van uw computer is geïnstalleerd en de gebruikersnaam Administrator is, is het pad naar de mu_code-map C:\Users\Administrator\mu_code. Op Linux is het pad ~/home/mu_code.
**Ga naar het bestand "mu_code"**
Kopieer het bibliotheekbestand "keyes_MiniCar.py" naar de map "mu_code". Het codepad is als volgt:
Open de Mu-software en verbind de micro:bit met uw computer, klik vervolgens op de knop "Files" en sleep het bibliotheekbestand "keyes_MiniCar.py" naar de micro:bit.
Nadat de import succesvol is, ziet u het in het linkervak.
Tik op "Check" om de code op fouten te controleren. Als er een regel verschijnt met een cursor of een onderstrepingsteken, zit er een fout in het programma voor die regel.
Deze tips zijn slechts waarschuwingen, geen foutmeldingen in de code.
U moet er ook voor zorgen dat de micro-USB-kabel is aangesloten op de micro:bit en de computer, en klik vervolgens op de knop "Flash" om de code naar de micro:bit te downloaden.
Als er een fout optreedt na het klikken op de knop "Flash", controleer dan of u het bibliotheekbestand naar micro:bit hebt geïmporteerd.
Opmerking:
Als u andere programma's op het micro:bit-bord hebt gedownload, behalve het bibliotheekbestand "keyes_MiniCar.py". Voordat u in Micropython programmeert, moet u het bibliotheekbestand importeren in de micro:bit.
Als u altijd hetzelfde micro:bit-bord gebruikt voor Micropython-programmering, hoeft u het niet opnieuw naar de micro:bit te sturen.
### 1.4 Code toevoegen aan compiler
We nemen het eerste project van de basistutorial "Hartslag" als voorbeeld, open de map "Program" in de eerste projectmap en zoek het bestand "microbit-Heartbeat".
Of open de Mu-software en tik op het bestand "microbit-Heartbeat.py", sleep het vervolgens naar de Mu-software:
zoals hieronder weergegeven:
### 1.5 Code downloaden naar Micro:bit
Verbind het micro:bit-bord en de computer via de micro-USB-kabel.
Tik op "Flash" om de code naar micro:bit te downloaden.
 sleep(500) display.show(val3) sleep(500) | LED op (1,0) knippert 0,5s |
| display.show(val2) sleep(500) display.show(val3) sleep(500) | LED op (3,4) knippert 0,5s |
#### 2.2.5 Testresultaat
Na het downloaden van de code en het aansluiten van de stroom met een USB-kabel, ziet u de LED op (1,0) 0,5s knipperen, waarna de LED op (3,4) 0,5s knippert, in een lus.
### 2.3 5 x 5 LED-puntmatrix
#### 2.3.1 Beschrijving
Puntmatrices winnen aan populariteit in ons leven, zoals LED-schermen, busstations en de mini-tv in de lift.
De puntmatrix van het Micro:bit-bord bestaat uit 25 lichtgevende diodes. In de vorige les hebben we de LED van het Micro:bit-bord bestuurd om patronen, cijfers en tekenreeksen te vormen door de coördinaten in te stellen. Bovendien kunnen we een andere manier gebruiken om de weergave van patronen, cijfers en tekenreeksen te voltooien.
#### 2.3.2 Benodigde componenten
|  |  |
| :-----------------------: | :------------------: |
| Micro:bit * 1 | Micro:bit * 1 |
#### 2.3.3 Testcode
U kunt de code rechtstreeks uploaden vanuit de tutorial (lees het bestand "Ontwikkelomgeving configuratie" bij twijfel).
```python
from microbit import *
val = Image("00900:""00900:""90909:""09990:""00900")
display.show(val)
```
**Testresultaat:** Upload `2.3-5× 5 LED Dot Matrix-1.py` naar micro:bit, dan verschijnt er een pijl naar beneden.
```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 Codeverklaring
| code | Uitleg |
| ------------------------------------------------------------ | ------------------------------------------------------------ |
| from microbit import * | importeer het bibliotheekbestand van micro:bit |
| val = Image("09000:""00000:""00000:""0000 0:""00000:") | Stel Image() in op variabele val |
| display.show(val) | micro:bit toont “→” |
| display.show('1') | display.show('1') |
| sleep(500) | sleep(500) |
| display.scroll("hello!") | micro:bit scrolt om “hello!” te tonen |
| display.show(Image.HEART) | micro:bit toont “❤” |
| display.show(Image.ARROW_NE) display.show(Image.ARROW_SE) display.show(Image.ARROW_SW) display.show(Image.ARROW_NW) | micro:bit toont “Noordoost” pijl micro:bit toont “Zuidoost” pijl micro:bit toont “Zuidwest” pijl micro:bit toont “Noordwest” pijl |
| display.clear() | De LED-puntmatrix van micro:bit wordt gewist |
#### 2.3.5 Testresultaat
Download `2.3-5×5 LED Dot Matrix-2.py` naar micro:bit, dan zal de LED-puntmatrix "1", "2",
"3", "4", "5", "↓", "hallo!", "❤", , , ,  patronen weergeven. Elk interval is 500ms.
### 2.4 Programmeerbare knoppen
#### 2.4.1 Beschrijving
De knop kan het aan- en uitzetten van het circuit regelen, dat aan het circuit is bevestigd. Het circuit is onderbroken wanneer de knop niet wordt ingedrukt. Het circuit is verbonden zodra het wordt ingedrukt, maar het is onderbroken nadat het is losgelaten.
Beide uiteinden van de knop zijn als twee bergen. Er is een rivier tussenin. Het interne metalen stuk verbindt de twee zijden om de stroom door te laten, net als het bouwen van een brug om de twee bergen te verbinden.
**Werkingsprincipe**: Voordat de knop wordt ingedrukt, zijn 1, 2, 3 en 4 ingeschakeld, maar 1, 3 of 1, 4 of 2, 3 of 2, 4 is onderbroken (geblokkeerd), wat ingeschakeld zal zijn wanneer de knop wordt ingedrukt.
Het Micro:bit-bord heeft drie knoppen, de resetknop zit aan de achterkant en twee programmeerbare knoppen zitten aan de voorkant. Druk respectievelijk op A, B en AB tegelijk, en het bijbehorende scherm toont ze respectievelijk.
#### 2.4.2 Benodigde componenten
|  |  |
| :-----------------------: | :------------------: |
| Micro:bit * 1 | Micro:bit * 1 |
#### 2.4.3 Testcode
U kunt de code rechtstreeks uploaden vanuit de tutorial (lees het bestand "Ontwikkelomgeving configuratie" bij twijfel).
```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")
```
**Testresultaat:** Upload `2.4-Programmable Buttons-1.py` en sluit micro:bit aan via een USB-kabel, druk op "A" op het Micro:bit-bord, karakter "A" wordt weergegeven; als B wordt ingedrukt, verschijnt letter "B". "AB" wordt weergegeven als u de knoppen A en B tegelijkertijd indrukt.
```python
| sleep(500) | Vertraging van 500ms |
| **if** temperature() >= 35: display.show(Image.HEART) **else**: display.show(Image.HEART_SMALL) | Als temperatuurwaarde ≥35℃ micro:bit toont“ ” Als temperatuurwaarde<35℃ micro:bit toont“ ” |
### 2.6 Kompas
#### 2.6.1 Beschrijving
Dit project introduceert voornamelijk het gebruik van het kompas van de Micro:bit. Het kan worden gebruikt om de richting te bepalen. We moeten het Micro:bit-bord kalibreren wanneer de magnetische sensor werkt. De juiste kalibratiemethode is om het Micro:bit-bord te roteren.
Bovendien kunnen objecten in de buurt de nauwkeurigheid van metingen en kalibratie beïnvloeden.
#### 2.6.2 Benodigde componenten
|  |  |
| :-----------------------: | :------------------: |
| Micro:bit * 1 | Micro:bit * 1 |
#### 2.6.3 Testcode
U kunt de code direct uploaden vanuit de tutorial (lees het bestand "Ontwikkelomgeving configuratie" bij twijfel).
```python
from microbit import *
compass.calibrate()
while True:
if button_a.is_pressed():
display.scroll(compass.heading())
```
**Code uitleg:** We moeten micro:bit kalibreren vanwege verschillende magnetische velden in verschillende gebieden. Micro:bit zal u vragen om te kalibreren wanneer u het voor de eerste keer gebruikt.
Zet `2.6-Magnetic sensor-1.py` over naar micro:bit, sluit micro:bit aan via een USB-kabel en druk op knop A. "TILT TO FILL SCREEN" verschijnt op micro:bit. Ga vervolgens naar de kalibratie-interface, de kalibratiemethode is om het micro:bit-bord te roteren en een volledig vierkant patroon weer te geven (25 LED's branden), zoals weergegeven in de volgende figuur:
De kalibratie is voltooid wanneer u het lachende patroon  ziet.
De seriële monitor toont 0°, 90°, 180° en 270° wanneer u op A drukt.
--------
```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"))
```
Laat het micro:bit-bord horizontaal naar het noorden, zuiden, oosten en westen wijzen, de LED-puntmatrix toont de overeenkomstige richtingpatronen.
Zoals hieronder weergegeven, wijst de pijl naar rechtsboven wanneer de waarde varieert van 292,5 tot 337,5. 0,5 kan niet in de code worden ingevoerd, vandaar dat de waarden die we krijgen 293 en 338 zijn.
Upload `2.6-Magnetic sensor-2.py` naar het micro:bit-bord en koppel de USB-kabel niet los. Na kalibratie, kantel het Micro:bit-bord, de LED-puntmatrix toont de richtingstekens.
#### 2.6.4 Code uitleg
| code | Uitleg |
| ------------------------------------------------------------ | ------------------------------------------------------------ |
| from microbit import * | Importeer het bibliotheekbestand van micro:bit |
| compass.calibrate() | Kompas kalibratie |
| while True: | Dit is een permanente lus, die ervoor zorgt dat micro:bit de code ervan uitvoert |
| **if** button_a.is_pressed(): display.scroll(compass.heading()) | Wanneer knop A wordt ingedrukt Micro:bit scrolt om de waarde van het kompas te tonen |
| x = 0 | Stel variabele x=0 in |
| x = compass.heading() | Stel de waarde van het kompas in op variabele x |
| **if**...**elif**...**else** | Stel de waarde van het kompas in op variabele x |
| 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 toont het Noordoostelijke pijlteken Micro:bit toont het Noordwestelijke pijlteken Micro:bit toont het westelijke pijlteken Micro:bit toont het Zuidwestelijke pijlteken Micro:bit toont het Zuidoost
| from microbit import * | Importeer het bibliotheekbestand van micro:bit |
| gesture = accelerometer.current_gesture() | Stel accelerometer.current_gesture() in op gesture |
| while True: | Dit is een permanente lus, en micro:bit voert de code uit |
| Lightintensity = display.read_light_level() | Stel display.read_light_level() in op Lightintensity |
| print("Light intensity:", Lightintensity) | BBC microbit REPL print de gedetecteerde lichtintensiteitswaarde |
| sleep(100) | Vertraging van 100ms |
#### 2.8.5 Testresultaat
Download de code naar het micro:bit-bord, koppel de USB-kabel niet los. Klik op "REPL" en druk op de resetknoppen, de lichtintensiteitswaarde wordt weergegeven, zoals hieronder getoond.
Als de LED-matrix wordt afgedekt, is de intensiteitswaarde 0; integendeel, de intensiteitswaarde neemt toe wanneer het micro:bit-bord in de zon wordt geplaatst.
### 2.9 Luidspreker
#### 2.9.1 Beschrijving
Het micro:bit-moederbord heeft een ingebouwde luidspreker, waardoor het heel eenvoudig is om geluid aan je project toe te voegen. De luidspreker kan worden geprogrammeerd om verschillende tonen uit te zenden, zoals het schrijven van een lied: Ode aan de Vreugde, en het afspelen ervan.
#### 2.9.2 Benodigde componenten
|  |  |
| :-----------------------: | :------------------: |
| Micro:bit * 1 | Micro:bit * 1 |
#### 2.9.3 Testcode
U kunt de code rechtstreeks vanuit de tutorial uploaden (lees het bestand "Ontwikkelomgeving configuratie" bij twijfel).
```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 uitleg
| code | Uitleg |
| ------------------------ | ------------------------------------------------------- |
| from microbit import * | Importeer het bibliotheekbestand van micro:bit |
| import audio | audio bibliotheekbestand |
| while True: | Dit is een permanente lus, en micro:bit voert de code uit |
| audio.play(Sound.GIGGLE) | Maak een giechelend geluid |
| sleep(1000) | Vertraging van 1000ms |
#### 2.9.5 Testresultaat
Download de code naar het micro:bit-bord, koppel de USB-kabel niet los, dan zal de luidspreker geluid uitzenden en zal de LED-matrix een muzieklogo-patroon weergeven.
### 2.10 Aanraakgevoelig logo
#### 2.10.1 Beschrijving
Als je een micro:bit-moederbord hebt, is het logisch om een goudkleurig aanraakgevoelig logo te gebruiken als een extra invoer in je project, wat als een extra knop fungeert. Het maakt gebruik van een capacitieve aanraaksensor die kleine veranderingen in elektrische velden detecteert wanneer je erop drukt (of aanraakt) met je vinger. Wanneer je het aanraakt, kun je het micro:bit-bord besturen om bepaalde functies uit te voeren.
#### 2.10.2 Benodigde componenten
|  |  |
| :-----------------------: | :------------------: |
| Micro:bit * 1 | Micro:bit * 1 |
#### 2.10.3 Testcode
U kunt de code rechtstreeks vanuit de tutorial uploaden (lees het bestand "Ontwikkelomgeving configuratie" bij twijfel).
```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 uitleg
(1) Micro:bit registreert de tijd in ms (duizendsten van een seconde) wanneer het wordt gestart. Dit wordt de looptijd genoemd.
(2) Wanneer u op knop A drukt, wordt een variabele genaamd 'start' ingesteld op de huidige looptijd.
(3) Wanneer u op knop B drukt, wordt de starttijd afgetrokken van de nieuwe looptijd om te bepalen hoeveel tijd is verstreken sinds u de stopwatch startte. Dit verschil wordt opgeteld bij de totale tijd, die is opgeslagen in een variabele genaamd 'time'.
(4) Als u op het gouden LOGO-pictogram drukt, geeft het programma de totale verstreken tijd weer op het LED-display. Het converteert tijd van ms (duizendsten van een seconde) naar seconden door te delen door 1000. Het gebruikt de integer-delingoperator om het resultaat als een geheel getal te geven.
(5) Het programma gebruikt ook een Booleaanse variabele genaamd 'running' om het programma te besturen. Booleaanse variabelen hebben slechts twee waarden: waar of onwaar. Als 'running' waar is, is de stopwatch gestart. Als 'running' onwaar is, is de stopwatch niet gestart of gestopt.
(6) Als 'running' waar is, wordt het kloppende hart weergegeven op het LED-dot-scherm.
(7) Als de stopwatch is gestopt, als "running" onwaar is, wordt alleen de tijd weergegeven wanneer u op het gouden LOGO-pictogram drukt.
(8) Als de stopwatch al is gestart, als "running" waar is, voorkomt de code ook valse metingen door ervoor te zorgen dat de tijdvariabele alleen verandert wanneer knop B wordt ingedrukt.
#### 2.10.5 Testresultaat
Upload de code en sluit de micro:bit aan via een USB-kabel. Druk op knop A om de stopwatch te starten. Wanneer de timer loopt, toont de LED-matrix een kloppend hart, tik op knop B om deze te stoppen. Het blijft tijd toevoegen, net als een echte stopwatch.
Druk op het gouden LOGO-pictogram aan de voorkant van de micro:bit om de gemeten tijd in seconden weer te geven. Om de tijd op nul te zetten, drukt u op de Reset-knop aan de achterkant van het micro:bit-bord.
### 2.11 Microfoon
#### 2.11.1 Beschrijving
Het micro:bit-moederbord beschikt over een ingebouwde microfoon, die kan worden gebruikt om het omgevingsgeluidsniveau te meten. Wanneer u klapt, gaat de LED-indicator op het micro:bit-moederbord branden. Het kan de intensiteit van geluid meten. In dit verband kunt u een geluidsniveaugrafiek of discobeleuchtung maken die op de muziek is afgestemd.
#### 2.11.2 Benodigde componenten
|  |  |
| :-----------------------: | :------------------
| ------ | ------------------ | -------- | ------------------ |
| Zwart | 255,255,255 | Rood | 0,255,255 |
| Groen | 255,0,255 | Blauw | 255,255,0 |
| Cyaan | 255,0,0 | Donkerrood | 0,255,0 |
| Geel | 0,0,255 | Wit | 0,0,0 |
| ...... | ....... | ...... | ...... |
Aangezien onze LED-lampen een gemeenschappelijke anode hebben, is 255 de laagste waarde en 0 de helderste waarde.
In dit project gaan we twee experimenten doen. Eén is om twee RGB-lampen drie kleuren rood, groen en blauw te laten oplichten, de andere is om twee RGB-lampen geleidelijk verschillende kleuren te laten weergeven.
#### 3.1.2 Voorbereiding
(1) Plaats de micro:bit correct in het uitbreidingsbord
(2) Sluit de batterijhouder aan op het uitbreidingsbord
(3) Zet de aan/uit-schakelaar aan (Schuif de POWER-schakelaar naar de ON-stand)
(4) Verbind de micro:bit en computer via een micro USB-kabel
(5) Open de MU IDE
Als je de Mini car uitbreidingsbibliotheek wilt toevoegen (je kunt de "1.4 Installeer het bibliotheekbestand" raadplegen).
#### 3.1.3 Schematisch Diagram
**Werkingsprincipe:** Microbit, als host, stuurt instructies naar de slave STC8G1K08 via de IIC, waarna de slave PWM uitvoert om RGB LED-lampen te bedienen. Dit bespaart aanzienlijk de IO-poorten van het microbit-bord, want de IIC maakt het mogelijk om twee motoren en twee RGB LED-lampen te bedienen.
#### 3.1.4 Code Uitleg
Functies van RGB-LED's in het Keyes_MiniCar.py-bestand:
Left.red(0-255): Stelt de linker RGB in op rood, 0 is het helderst en 255 is het donkerst.
Left.green(0-255): Stelt de linker RGB in op groen, 0 is het helderst en 255 is het donkerst.
Left.blue(0-255): Stelt de linker RGB in op blauw, 0 is het helderst en 255 is het donkerst.
right.red(0-255): Stelt de rechter RGB in op rood, 0 is het helderst en 255 is het donkerst.
right.green(0-255): Stelt de rechter RGB in op groen, 0 is het helderst en 255 is het donkerst.
right.blue(0-255): Stelt de rechter RGB in op blauw, 0 is het helderst en 255 is het donkerst.
#### 3.1.5 Testcode
U kunt het bestand `3.1-RGB LED-1.py` rechtstreeks vanuit de tutorial uploaden (lees het bestand "Ontwikkelomgeving Configuratie" als u twijfelt).
```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()
```
**Testresultaat:** Na het uploaden van de code zal de RGB LED elke seconde wisselen in de volgorde rood, groen en blauw.
-------
Importeer het bestand `3.1-RGB LED-2.py`
```python
from microbit import *
from keyes_MiniCar import *
minicar = MiniCar()
while True:
for num in range(0 , 255): #Het is een lusinstructie, het bereik is 0 tot 255
num += 1 #Het is gelijk aan 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)
```
**Testresultaat:** Na het uploaden van de code zal de RGB LED rood zijn, dan groen, dan zal een mengsel van rood en groen verschijnen. Wanneer het rode licht uit is, zal het blauwe licht aan zijn, dan zal een mengsel van blauw en groen worden weergegeven.
Echter, wanneer het groene licht uit is, zal het rode licht aan zijn, dan zal een mengsel van blauw en rood worden getoond. Tot slot zullen de rode en blauwe lichten uit zijn.
#### 3.1.6 Uitgebreide Kennis
1s = 1000ms; 1ms = 1000us; 1us = 1000nm
Dan is de 1000 ms die we in het project gebruikten 1 s
Misschien bent u in staat om zelf de gewenste lichtkleur te configureren. U hoeft alleen de rode, groene en blauwe PWM voor de RGB te configureren.
### 3.2 Motoraandrijving
#### 3.2.1 Beschrijving
De robotauto is uitgerust met twee DC-reductiemotoren, die zijn ontwikkeld op basis van gewone DC-motoren. Hij beschikt over een bijpassende tandwielreductiekast, die een lagere snelheid maar een groter koppel levert. Bovendien kunnen verschillende reductieverhoudingen van de kast verschillende snelheden en koppels leveren.
De reductiemotor is de integratie van tandwielmotor en motor, die veel wordt toegepast in de staal- en machine-industrie.
Bovendien beschikt de auto over een STC8G1K08 en een HR8833MTE-chip. Om de IO-poorten te besparen, sturen we instructies naar de STC8G1K08-chip via
minicar.Motor_L(1, 70) #Het is een code voor vooruit
minicar.Motor_R(1, 70)
elif LDR_L > 650 and LDR_R <= 650: #Beoordeel of de linker helderheid＞650, rechter≤650
minicar.Motor_L(0, 70) #Code voor linksaf
minicar.Motor_R(1, 70)
elif LDR_L <= 650 and LDR_R > 650: #Beoordeel of de linkerkant van de auto≤650, rechter＞650
minicar.Motor_L(1, 70) #De auto slaat rechtsaf
minicar.Motor_R(0, 70)
else:
minicar.Motor_stop() #De auto stopt
```
#### 3.3.7 Testresultaat
Na het uploaden van de code, zet de schakelaar aan de achterkant van de auto aan, dan kun je de zaklamp gebruiken om met de auto te spelen. Het werkt het beste in een relatief donkere omgeving. Wanneer de omgevingslichtintensiteit boven de 650 is, blijft de auto bewegen.
### 3.4 Lijnvolgende slimme auto
#### 3.4.1 Beschrijving
De auto wordt geleverd met twee lijnvolgsensoren en twee potentiometers.
Bovendien maakt het gebruik van een TCRT5000 IR-buis, die een IR-zendbuis en een IR-ontvangstbuis bevat. Wanneer de infraroodsignalen van de zendbuis door reflectie worden ontvangen door de ontvangstbuis, zal de weerstand van de ontvangstbuis veranderen, wat over het algemeen wordt weerspiegeld in de spanningsverandering op het circuit.
De weerstand varieert afhankelijk van de intensiteit van de infraroodsignalen die door de ontvangstbuis worden ontvangen, wat vaak afhangt van de kleur van het reflecterende oppervlak en de afstand tot de ontvangstbuis. Bij detectie is zwart hoog niveau actief en wit laag niveau actief.
**Werkingsprincipe:** Wanneer de auto over een witte weg rijdt, zendt de onder de auto geïnstalleerde IR-zendbuis infraroodsignalen uit om de weg te detecteren en de ontvangstbuis zal signalen terug ontvangen. Dan geeft de uitgang een laag niveau (0) af. Wanneer het zwarte lijnen detecteert, geeft het een hoog niveau (1) af.
Stuur het gedetecteerde signaal naar de I/O-poort van de microcontroller. Wanneer het hoog niveau (1) is, bevindt de auto zich op de zwarte lijn. Op dezelfde manier, wanneer het laag niveau (0) is, bevindt de auto zich op de witte ondergrond.
De twee lijnvolgsensoren op het uitbreidingsbord worden bestuurd door P12 en P13 van het micro:bit besturingsbord, de linker wordt bestuurd door P13, en de rechter door P12. Stel de lijnvolgsensoren af, en plaats de auto op een zwarte ondergrond, draai de potentiometers totdat de LED (D3, D2) aan is, stel ze dan af totdat ze uit zijn.
#### 3.4.2 Voorbereiding
(1) Plaats de micro:bit correct in het uitbreidingsbord
(2) Sluit de batterijhouder aan op het uitbreidingsbord
(3) Zet de aan/uit-schakelaar aan (Schuif de POWER-schakelaar naar de ON-stand)
(4) Verbind de micro:bit en computer via een micro-USB-kabel
(5) Open de MU IDE
Als je de Mini car uitbreidingsbibliotheek wilt toevoegen (je kunt verwijzen naar het bestand "1.4 Install the Library File").
#### 3.4.3 Schakelschema
#### 3.4.4 Lees de lijnvolgsensor
Je kunt de code `3.4-Read the Line Tracking Sensor.py` direct uploaden vanuit de tutorial (lees het bestand "Development Environment Configuration" als je twijfelt).
```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)
```
**Testresultaat:** Download de code naar het micro:bit-bord, koppel de USB-kabel niet los. Klik op "REPL" en druk op de resetknop, de metingen die door de lijnvolgsensor zijn gedetecteerd, worden op de monitor weergegeven.
Wanneer de lijnvolgsensor een wit object detecteert, wordt 0 weergegeven en gaan D2, D3 aan; wanneer geen witte objecten en alleen zwarte objecten worden gedetecteerd, wordt 1 weergegeven en gaan D2, D3 uit, zoals hieronder weergegeven.
#### 3.4.5 Stroomschema
#### 3.4.6 Testcode
Je kunt de code `3.4-Patrol car.py` direct uploaden vanuit de tutorial (lees het bestand "Development Environment Configuration" als je twijfelt).
```python
from microbit import *
from keyes_MiniCar import * #Importeer het bibliotheekbestand
minicar = MiniCar() #Instantieer een object MiniCar() als minicar
pin12.set_pull(pin12.PULL_UP) #Stel pin12 in op pull up
pin13.set_pull(pin13.PULL_UP)
sensor_L = 0
sensor_R = 0
while True:
sensor_L = pin13.read_digital() #Lees de waarde van de sensor
sensor_R = pin12.read_digital()
print("sensor_L:", sensor_L)
print("sensor_R:", sensor_R)
if sensor_L == 1 and sensor_R == 1: #Beoordeel of sensor_L en sensor_R =1
minicar.Motor_L(1, 70) #Vooruit code
minicar.Motor_R(1, 70)
elif sensor_L == 0 and sensor_R == 1: #Beoordeel of sensor_L =0 en sensor_R=1
minicar.Motor_L(1, 70) #Rechtsaf code
minicar.Motor_R(0, 70)
elif sensor_L == 1 and sensor_R == 0: #Beoordeel of sensor_L=1 en sensor_R=0
minicar.Motor_L(0, 70)
minicar.Motor_R(1, 70)
else:
minicar.Motor_stop()
```
**Testresultaat:** Upload de code en zet de aan/uit-schakelaar op de auto aan. Plaats de auto op het lijnvolgpapier, dan zal deze de zwarte lijn volgen om te bewegen.
**De potentiometer afstellen:**
Als de wagen de lijn niet goed volgt, stel dan de potentiometer als volgt af.
1. Upload de cursuscode.
2. Plaats de auto met de voorkant naar u toe. Dra