# Tutoriale MicroPython
## Scarica il file del codice
Nota: Tutto il codice del corso è disponibile per il download qui. I link per il download non verranno forniti in seguito. Per evitare di dimenticare, consigliamo di scaricare il codice ora per il futuro apprendimento del tutorial.
[Clicca per scaricare](./MiroPython_Resource.7z)
## 1. MU IDE
### 1. 1 Installa MU IDE
Mu è un editor di codice Python per programmatori principianti basato su insegnanti e studenti. Il modo più semplice per ottenere Mu è tramite l'installer ufficiale per Windows o Mac OSX (Mu non supporta più Windows a 32 bit). La versione consigliata attuale è Mu 1.0-beta 2.
#### Passo 1 - Determina la versione e scarica l'installer di Mu
Apri il link: [https://codewith.mu/en/download](https://codewith.mu/en/download) per scaricare la versione del software Mu corrispondente.
Scopri se il tuo computer esegue Windows o Mac OSX, e apri Esplora file, clicca su "Questo PC", quindi seleziona Proprietà per sapere se il tuo sistema Windows è a 32 o 64 bit.
**Visualizza il tipo di sistema:**
#### Passo 2 - Esegui l'installer
Individua l'installer appena scaricato (potrebbe essere nella cartella dei download) e fai doppio clic per aprire il file dell'installer.
Link per il download del sistema Mac OSX: [https://codewith.mu/en/howto/1.1/install_macos](https://codewith.mu/en/howto/1.1/install_macos)
**Sistema Windows 10**
Tocca "Maggiori informazioni"
Inserisci "Esegui comunque"
#### Passo 3 - Protocollo
Controlla la licenza, quindi clicca su Installa.
#### Passo 4 - Installazione
Ci vorranno alcuni secondi per installare Mu sul tuo computer.
#### Passo 5 - Fine
Tocca Fine
#### Passo 6 - Avvia Mu
Puoi avviare Mu cliccando sull'icona nel menu Start, o digitando Mu nella casella di ricerca (entrambi i metodi sono mostrati di seguito).
L'interfaccia principale di Mu è mostrata di seguito:
### 1.2 Configurazione del compilatore e introduzione alla barra degli strumenti
Imposta prima la "modalità" su micro bit
Apri il software Mu, clicca sul pulsante Mode nella barra dei menu e seleziona "BBC micro: bit", quindi tocca "OK".
### 1.3 Installa il file della libreria
Prima di importare la libreria, è necessario caricare un codice .py su microbit. Qui prendiamo come esempio il modulo RGB "code_1.py" nel tutorial.
Importa il file "keyes_MiniCar.py"
La directory predefinita per il salvataggio di Mu è il file "Mu_code", che si trova nella radice della directory utente.
Ad esempio, in Windows, se il tuo sistema è installato sull'unità C del tuo computer e il nome utente è Administrator, il percorso della directory mu_code è C:\Users\Administrator\mu_code. Su Linux, il percorso è ~/home/mu_code.
**Entra nel file "mu_code"**
Copia il file della libreria "keyes_MiniCar.py" nella cartella "mu_code". Il percorso del codice è il seguente:
Apri il software Mu e collega il micro:bit al tuo computer, quindi clicca sul pulsante "Files" e trascina il file della libreria "keyes_MiniCar.py" nel micro:bit.
Dopo che l'importazione è riuscita, lo vedrai nella casella a sinistra.
Tocca "Check" per controllare il codice per errori. Se appare una riga con un cursore o un trattino basso, c'è un errore nel programma per quella riga.
Questi suggerimenti sono solo avvisi, non suggerimenti di errore del codice.
Devi anche assicurarti che il cavo micro USB sia collegato al micro:bit e al computer, quindi clicca sul pulsante "Flash" per scaricare il codice sul micro:bit.
Se c'è un errore dopo aver cliccato sul pulsante "Flash", conferma se hai importato il file della libreria nel micro:bit.
Nota:
Se hai scaricato altri programmi sulla scheda micro:bit, eccetto il file della libreria "keyes_MiniCar.py". Prima di programmare in Micropython, devi importare il file della libreria nel micro:bit.
Se usi sempre la stessa scheda micro:bit per la programmazione Micropython, non è necessario inviarla di nuovo al micro:bit.
### 1.4 Aggiungi codice al compilatore
Prendiamo come esempio il primo progetto del tutorial di base "Battito cardiaco", apri la cartella "Program" nella prima cartella del progetto e individua il file "microbit-Heartbeat".
Oppure apri il software Mu e tocca il file "microbit-Heartbeat.py", quindi trascinalo nel software Mu:
come mostrato di seguito:
### 1.5 Scarica il codice su Micro:bit
Collega la scheda micro:bit e il computer tramite il cavo micro USB.
Tocca "Flash" per scaricare il codice su micro:bit.
Se c'è un errore nel codice, puoi scaricare il codice sul micro:bit con successo, ma non funzionerà. Se sleep è sleeps, clicca su "Flash", e il codice verrà scaricato anche sul micro
| display.show(val1) sleep(500) display.show(val3) sleep(500) | Il LED in (1,0) lampeggia per 0,5s |
| display.show(val2) sleep(500) display.show(val3) sleep(500) | Il LED in (3,4) lampeggia per 0,5s |
#### 2.2.5 Risultato del test
Dopo aver scaricato il codice, collegare l'alimentazione con un cavo USB, si vedrà il LED in (1,0) lampeggiare per 0,5s, quindi il LED in (3,4) lampeggiare per 0,5s, in modo ciclico.
### 2.3 Matrice di punti LED 5 x 5
#### 2.3.1 Descrizione
La matrice di punti sta guadagnando popolarità nella nostra vita, come gli schermi LED, le stazioni degli autobus e i mini TV negli ascensori.
La matrice di punti della scheda Micro:bit è composta da 25 diodi a emissione di luce. Nella lezione precedente, abbiamo controllato i LED della scheda Micro:bit per formare schemi, numeri e stringhe di caratteri impostando i punti coordinati. Inoltre, potremmo adottare un altro modo per completare la visualizzazione di schemi, numeri e stringhe di caratteri.
#### 2.3.2 Componenti necessari
|  |  |
| :-----------------------: | :------------------: |
| Micro:bit * 1 | Micro:bit * 1 |
#### 2.3.3 Codice di test
È possibile caricare il codice direttamente dal tutorial (leggere il file "Configurazione dell'ambiente di sviluppo" in caso di dubbi).
```python
from microbit import *
val = Image("00900:""00900:""90909:""09990:""00900")
display.show(val)
```
**Risultato del test:** Caricare `2.3-5× 5 LED Dot Matrix-1.py` su micro:bit, quindi apparirà una freccia verso il basso.
```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 Spiegazione del codice
| codice | Spiegazione |
| :----------------------------------------------------------- | :----------------------------------------------------------- |
| from microbit import * | importa il file di libreria di micro:bit |
| val = Image("09000:""00000:""00000:""0000 0:""00000:") | Imposta Image() sulla variabile val |
| display.show(val) | micro:bit mostra "→" |
| display.show('1') | display.show('1') |
| sleep(500) | sleep(500) |
| display.scroll("hello!") | micro:bit scorre per mostrare "hello!" |
| display.show(Image.HEART) | micro:bit visualizza "❤" |
| display.show(Image.ARROW_NE) display.show(Image.ARROW_SE) display.show(Image.ARROW_SW) display.show(Image.ARROW_NW) | micro:bit mostra la freccia "Nord-Est" micro:bit visualizza la freccia "Sud-Est" micro:bit mostra la freccia "Sud-Ovest" micro:bit visualizza la freccia "Nord-Ovest" |
| display.clear() | La matrice di punti LED di micro:bit si cancella |
#### 2.3.5 Risultato del test
Scaricare `2.3-5×5 LED Dot Matrix-2.py` su micro:bit, quindi la matrice di punti LED visualizzerà "1", "2",
"3", "4", "5", "↓", "hello!", "❤", , , ,  schemi. Ogni intervallo è di 500ms.
### 2.4 Pulsanti programmabili
#### 2.4.1 Descrizione
Il pulsante può controllare l'accensione e lo spegnimento del circuito, a cui è collegato. Il circuito è disconnesso quando il pulsante non viene premuto. Il circuito è connesso non appena viene premuto, ma si disconnette dopo essere stato rilasciato.
Entrambe le estremità del pulsante sono come due montagne. C'è un fiume in mezzo. Il pezzo di metallo interno collega i due lati per far passare la corrente, proprio come costruire un ponte per collegare le due montagne.
**Principio di funzionamento**: Prima di premere il pulsante, 1, 2, 3 e 4 sono accesi, ma 1, 3 o 1, 4 o 2, 3 o 2, 4 sono disconnessi (bloccati), che si accenderanno quando il pulsante viene premuto.
La scheda Micro:bit ha tre pulsanti, il pulsante di reset è sul retro e due pulsanti programmabili sono sul davanti. Premere A, B e AB contemporaneamente rispettivamente, e lo schermo corrispondente li visualizzerà rispettivamente.
#### 2.4.2 Componenti necessari
|  |  |
| :-----------------------: | :------------------: |
| Micro:bit * 1 | Micro:bit * 1 |
#### 2.4.3 Codice di test
È possibile caricare il codice direttamente dal tutorial (leggere il file "Configurazione dell'ambiente di sviluppo" in caso di dubbi).
```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")
```
**Risultato del test:** Caricare `2.4-Programmable Buttons-1.py` e collegare micro:bit tramite cavo USB, premere "A" sulla scheda Micro:bit, verrà visualizzato il carattere "A"; nel caso in cui venga premuto B, apparirà la lettera "B". "AB" verrà visualizzato se si premono contemporaneamente i pulsanti A e B.
```python
from microbit import *
a = 0
b = 0
val1 = Image("00000:""00000:""00000:""00000:""00900")
val2 = Image("00000
| sleep(500) | Ritardo di 500ms |
| **if** temperature() >= 35: display.show(Image.HEART) **else**: display.show(Image.HEART_SMALL) | Se il valore della temperatura ≥35℃ micro:bit mostra “ ” Se il valore della temperatura<35℃ micro:bit mostra “ ” |
### 2.6 Bussola
#### 2.6.1 Descrizione
Questo progetto introduce principalmente l'uso della bussola di Micro:bit. Può essere utilizzata per determinare la direzione. Dobbiamo calibrare la scheda Micro:bit quando il sensore magnetico funziona. Il metodo di calibrazione corretto è ruotare la scheda Micro:bit.
Inoltre, gli oggetti vicini possono influenzare la precisione delle letture e della calibrazione.
#### 2.6.2 Componenti necessari
|  |  |
| :-----------------------: | :------------------: |
| Micro:bit * 1 | Micro:bit * 1 |
#### 2.6.3 Codice di prova
È possibile caricare il codice direttamente dal tutorial (leggere il file "Configurazione dell'ambiente di sviluppo" in caso di dubbi).
```python
from microbit import *
compass.calibrate()
while True:
if button_a.is_pressed():
display.scroll(compass.heading())
```
**Spiegazione del codice:** Dobbiamo calibrare micro:bit a causa del diverso campo magnetico in diverse aree. Micro:bit ti chiederà di calibrare quando lo userai per la prima volta.
Trasferisci `2.6-Magnetic sensor-1.py` su micro:bit, collega micro:bit tramite cavo USB e premi il pulsante A. "TILT TO FILL SCREEN" appare su micro:bit. Quindi entra nell'interfaccia di calibrazione, il metodo di calibrazione è ruotare la scheda micro:bit e visualizzare un motivo quadrato completo (25 LED accesi), come mostrato nella figura seguente:
La calibrazione è terminata quando visualizzi il motivo del sorriso .
Il monitor seriale mostrerà 0°, 90°, 180° e 270° quando si preme A.
--------
```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"))
```
Fai puntare la scheda micro:bit a nord, sud, est e ovest orizzontalmente, la matrice di punti LED visualizza i corrispondenti schemi di direzione.
Come mostrato di seguito, la freccia punta in alto a destra quando il valore è compreso tra 292.5 e 337.5. 0.5 non può essere inserito nel codice, quindi i valori che otteniamo sono 293 e 338.
Carica `2.6-Magnetic sensor-2.py` sulla scheda micro:bit e non scollegare il cavo USB. Dopo la calibrazione, inclina la scheda Micro:bit, la matrice di punti LED visualizza i segni di direzione.
#### 2.6.4 Spiegazione del codice
| codice | Spiegazione |
| ------------------------------------------------------------ | ------------------------------------------------------------ |
| from microbit import * | Importa il file di libreria di micro:bit |
| compass.calibrate() | Calibrazione della bussola |
| while True: | Questo è un ciclo permanente, che fa eseguire a micro:bit il codice al suo interno |
| **if** button_a.is_pressed(): display.scroll(compass.heading()) | Quando il pulsante A viene premuto Micro:bit scorre per mostrare il valore della bussola |
| x = 0 | Imposta la variabile x=0 |
| x = compass.heading() | Imposta il valore della bussola sulla variabile x |
| **if**...**elif**...**else** | Imposta il valore della bussola sulla variabile 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 mostra la freccia Nord-Est Micro:bit mostra la freccia Nord-Ovest Micro:bit mostra la freccia Ovest Micro:bit mostra la freccia Sud-Ovest Micro:bit mostra la freccia Sud-Est Micro:bit mostra la freccia Sud Micro:bit mostra la freccia Est Micro:bit mostra la freccia Nord |
### 2.7 Accelerometro
#### 2.7.1
| from microbit import * | Importa il file di libreria di micro:bit |
| gesture = accelerometer.current_gesture() | Imposta accelerometer.current_gesture() su gesture |
| while True: | Questo è un ciclo permanente, e micro:bit esegue il codice |
| Lightintensity = display.read_light_level() | Imposta display.read_light_level() su Lightintensity |
| print("Light intensity:", Lightintensity) | La REPL di BBC micro:bit stampa il valore di intensità luminosa rilevato |
| sleep(100) | Ritardo di 100ms |
#### 2.8.5 Risultato del Test
Scarica il codice sulla scheda micro:bit, non scollegare il cavo USB. Clicca su "REPL" e premi i pulsanti di reset, il valore di intensità luminosa verrà visualizzato, come mostrato di seguito.
Coprendo la matrice di punti LED, il valore di intensità è 0; al contrario, il valore di intensità aumenta quando si posiziona la scheda micro:bit sotto il sole.
### 2.9 Altoparlante
#### 2.9.1 Descrizione
La scheda madre micro:bit ha un altoparlante integrato, il che rende molto facile aggiungere un suono al tuo progetto. L'altoparlante può essere programmato per emettere una varietà di toni, come scrivere una canzone: Inno alla Gioia, e riprodurla.
#### 2.9.2 Componenti Necessari
|  |  |
| :-----------------------: | :------------------: |
| Micro:bit * 1 | Micro:bit * 1 |
#### 2.9.3 Codice di Test
Puoi caricare il codice direttamente dal tutorial (leggi il file "Configurazione dell'ambiente di sviluppo" in caso di dubbi).
```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 Spiegazione del Codice
| codice | Spiegazione |
| ------------------------ | ------------------------------------------------------- |
| from microbit import * | Importa il file di libreria di micro:bit |
| import audio | file di libreria audio |
| while True: | Questo è un ciclo permanente, e micro:bit esegue il codice |
| audio.play(Sound.GIGGLE) | Emette un suono di risatina |
| sleep(1000) | Ritardo di 1000ms |
#### 2.9.5 Risultato del Test
Scarica il codice sulla scheda micro:bit, non scollegare il cavo USB, quindi l'altoparlante emetterà un suono e la matrice di punti LED visualizzerà un motivo di logo musicale.
### 2.10 Logo Sensibile al Tocco
#### 2.10.1 Descrizione
Se hai una scheda madre micro:bit, ha senso usare un logo dorato sensibile al tocco come un altro input nel tuo progetto, che è come un pulsante extra. Utilizza un sensore tattile capacitivo che rileva piccole variazioni nei campi elettrici quando lo premi (o lo tocchi) con il dito. Quando lo tocchi, puoi controllare la scheda micro:bit per eseguire determinate funzioni.
#### 2.10.2 Componenti Necessari
|  |  |
| :-----------------------: | :------------------: |
| Micro:bit * 1 | Micro:bit * 1 |
#### 2.10.3 Codice di Test
Puoi caricare il codice direttamente dal tutorial (leggi il file "Configurazione dell'ambiente di sviluppo" in caso di dubbi).
```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 Spiegazione del Codice
（1）Micro:bit registra il tempo in ms (migliaia di minuti al secondo) quando viene avviato. Questo è chiamato tempo di esecuzione.
（2）Quando premi il pulsante A, una variabile chiamata start viene impostata sul tempo di esecuzione corrente.
（3）Quando premi il pulsante B, il tempo di inizio verrà sottratto dal nuovo tempo di esecuzione per calcolare quanto tempo è trascorso da quando hai avviato il cronometro. Questa differenza viene aggiunta al tempo totale, che è memorizzato in una variabile chiamata time.
（4）Se premi l'icona del LOGO dorato, il programma visualizza il tempo totale trascorso sul display LED. Converte il tempo da ms (millesimi di secondo) a secondi dividendo per 1000. Utilizza l'operatore di divisione intera per dare il risultato di un numero intero.
（5）Il programma utilizza anche una variabile booleana chiamata running per controllare il programma. Le variabili booleane vantano solo due valori: vero o falso. Se running è vero, il cronometro è avviato. Se running è falso, il cronometro non è avviato o è fermo.
（6）Se running è vero, il cuore che batte viene visualizzato sullo schermo a punti LED.
（7）Se il cronometro si è fermato, se "running" è falso, mostrerà solo il tempo quando premi l'icona del LOGO dorato.
（8）Se il cronometro è già avviato, se "running" è vero, il codice impedisce anche letture false assicurando che la variabile time cambi solo quando il pulsante B viene premuto.
#### 2.10.5 Risultato del Test
Carica il codice e collega micro:bit tramite un cavo USB. Premi il pulsante A per avviare il cronometro. Quando il timer è attivo, la matrice di punti LED visualizza un cuore che batte, toccando il pulsante B puoi fermarlo. Continuerà ad aggiungere tempo, come un vero cronometro.
Premendo il logo LOGO dorato sulla parte anteriore del micro:bit è possibile visualizzare il tempo misurato in secondi. Per azzerare il tempo, premi il pulsante Reset sul retro della scheda micro:bit.
### 2.11 Microfono
#### 2.11.1 Descrizione
La scheda madre micro:bit vanta un microfono integrato, che può essere utilizzato per misurare il livello del suono ambientale. Quando batti le mani, l'indicatore LED sulla scheda madre micro:bit si accenderà. Può misurare l'intensità del suono. A questo proposito, puoi creare un grafico del livello del suono o luci da discoteca che sono in sintonia con la musica.
#### 2.11.2 Componenti Necessari
|  |  |
| :-----------------------: | :------------------: |
| Micro:bit * 1 | Micro:bit * 1 |
#### 2.11.3 Codice di Test
Puoi caricare il codice direttamente dal tutorial (leggi il file "Configurazione dell'ambiente di sviluppo" in caso di dubbi).
```python
from microbit import *
while True:
if microphone
| ------ | ------------------ | -------- | ------------------ |
| Nero | 255,255,255 | Rosso | 0,255,255 |
| Verde | 255,0,255 | Blu | 255,255,0 |
| Ciano | 255,0,0 | Rosso scuro | 0,255,0 |
| Giallo | 0,0,255 | Bianco | 0,0,0 |
| ...... | ....... | ...... | ...... |
Poiché le nostre luci LED sono ad anodo comune, 255 è il valore più basso e 0 è il valore più luminoso.
In questo progetto, faremo due esperimenti. Uno è far accendere due luci RGB con i tre colori rosso, verde e blu, l'altro è far visualizzare gradualmente colori diversi a due luci RGB.
#### 3.1.2 Preparazione
（1）Inserire correttamente il micro:bit nella scheda di espansione
（2）Collegare il portabatterie alla scheda di espansione
（3）Accendere l'interruttore di alimentazione（Far scorrere l'interruttore POWER su ON）
（4）Collegare il micro:bit e il computer tramite un cavo micro USB
（5）Aprire l'IDE MU
Se si desidera aggiungere la libreria di estensione Mini car (fare riferimento al file "1.4 Installare il file della libreria").
#### 3.1.3 Schema elettrico
**Principio di funzionamento:** Microbit, come host, invia istruzioni allo slave STC8G1K08 tramite IIC, quindi lo slave emette PWM per controllare le luci LED RGB. Ciò consente di risparmiare notevolmente le porte IO della scheda microbit, poiché l'IIC consente di controllare due motori e due luci LED RGB.
#### 3.1.4 Spiegazione del codice
Funzioni dei LED RGB nel file Keyes_MiniCar.py:
Left.red(0-255): Imposta il LED RGB sinistro su rosso, 0 è il più luminoso e 255 è il più scuro.
Left.green（0-255): Imposta il LED RGB sinistro su verde, 0 è il più luminoso e 255 è il più scuro.
Left.blue（0-255）: Imposta il LED RGB sinistro su blu, 0 è il più luminoso e 255 è il più scuro.
right.red（0-255）: Imposta il LED RGB destro su rosso, 0 è il più luminoso e 255 è il più scuro.
right.green（0-255）: Imposta il LED RGB destro su verde, 0 è il più luminoso e 255 è il più scuro.
right.blue（0-255）: Imposta il LED RGB destro su blu, 0 è il più luminoso e 255 è il più scuro.
#### 3.1.5 Codice di prova
È possibile caricare il file `3.1-RGB LED-1.py` direttamente dal tutorial (leggere il file "Configurazione dell'ambiente di sviluppo" in caso di dubbi).
```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()
```
**Risultato del test:** Dopo aver caricato il codice, il LED RGB cambierà ogni secondo nell'ordine rosso, verde e blu.
-------
Importare il file `3.1-RGB LED-2.py`
```python
from microbit import *
from keyes_MiniCar import *
minicar = MiniCar()
while True:
for num in range(0 , 255): #È un'istruzione di ciclo, l'intervallo è da 0 a 255
num += 1 #È uguale a 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)
```
**Risultato del test:** Dopo aver caricato il codice, il LED RGB sarà rosso, poi verde, quindi apparirà una miscela di rosso e verde. Quando la luce rossa è spenta, la luce blu sarà accesa, quindi verrà visualizzata una miscela di blu e verde.
Tuttavia, quando la luce verde è spenta, la luce rossa sarà accesa, quindi verrà mostrata una miscela di blu e rosso. Infine, le luci rossa e blu si spegneranno.
#### 3.1.6 Conoscenze aggiuntive
1s = 1000ms ； 1ms = 1000us ；1us = 1000nm
Quindi i 1000 ms che abbiamo usato nel progetto sono 1 s
Forse sei in grado di configurare il colore della luce che desideri da solo. Devi solo configurare il PWM rosso, verde e blu per l'RGB.
### 3.2 Guida del motore
#### 3.2.1 Descrizione
L'auto robot è dotata di due motori DC a ingranaggi, sviluppati sui normali motori DC. Gode di un riduttore di velocità abbinato, che fornisce una velocità inferiore ma una coppia maggiore. Inoltre, diversi rapporti di riduzione del riduttore possono fornire diverse velocità e coppie.
Il motore di riduzione è l'integrazione di motoriduttore e motore, ampiamente applicato nell'industria siderurgica e meccanica.
Inoltre, l'auto vanta un chip STC8G1K08 e un chip HR8833MTE. Per risparmiare le porte IO, inviamo istruzioni al chip STC8G1K08 tramite l'IIC del micro:bit, quindi il chip STC8G1K08 controlla il chip HR8833MTE in base alle istruzioni corrispondenti per controllare la direzione di rotazione e la velocità dei due motori DC a riduzione (il processo di controllo è il seguente).
 #È un codice di avanzamento
minicar.Motor_R(1, 70)
elif LDR_L > 650 and LDR_R <= 650: #Valuta se la luminosità sinistra＞650, destra≤650
minicar.Motor_L(0, 70) #Codice svolta a sinistra
minicar.Motor_R(1, 70)
elif LDR_L <= 650 and LDR_R > 650: #Valuta se il lato sinistro dell'auto≤650, destro＞650
minicar.Motor_L(1, 70) #L'auto gira a destra
minicar.Motor_R(0, 70)
else:
minicar.Motor_stop() #L'auto si ferma
```
#### 3.3.7 Risultato del Test
Dopo aver caricato il codice, accendere l'interruttore sul retro dell'auto, quindi è possibile utilizzare la torcia per giocare con l'auto. È meglio usarla in un ambiente relativamente buio. Quando l'intensità della luce ambientale è superiore a 650, l'auto continuerà a muoversi.
### 3.4 Auto Intelligente con Segui Linea
#### 3.4.1 Descrizione
L'auto è dotata di due sensori di tracciamento linea e due potenziometri.
Inoltre, adotta un tubo IR TCRT5000, che contiene un tubo IR emettitore e un tubo IR ricevitore. Quando i segnali infrarossi del tubo emettitore vengono ricevuti dal tubo ricevitore tramite riflessione, la resistenza del tubo ricevitore cambierà, il che si riflette generalmente nella variazione di tensione sul circuito.
La resistenza varia a seconda dell'intensità dei segnali infrarossi ricevuti dal tubo ricevitore, che è spesso nel colore della superficie riflettente e nella sua distanza dal tubo ricevitore. Al momento del rilevamento, il nero è attivo ad alto livello e il bianco è attivo a basso livello.
**Principio di Funzionamento:** Quando l'auto corre sopra una strada bianca, il tubo IR emettitore installato sotto l'auto emette segnali infrarossi per rilevare la strada e il tubo ricevitore riceverà i segnali di ritorno. Quindi l'uscita emette un livello basso (0). Quando rileva linee nere, emette un livello alto (1).
Invia il segnale rilevato alla porta I/O del microcontrollore. Quando è a livello alto (1), l'auto è sulla linea nera. Allo stesso modo, quando è a livello basso (0), l'auto è sul terreno bianco.
I due sensori di tracciamento linea sulla scheda di espansione sono controllati da P12 e P13 della scheda di controllo micro:bit, quello sinistro è controllato da P13 e quello destro da P12. Regolare i sensori di tracciamento linea e posizionare l'auto su un terreno nero, ruotare i potenziometri finché il LED (D3, D2) non si accende, quindi regolarli finché non si spegne.
#### 3.4.2 Preparazione
(1) Inserire correttamente il micro:bit nella scheda di espansione
(2) Collegare il portabatterie alla scheda di espansione
(3) Accendere l'interruttore di alimentazione (Far scorrere l'interruttore POWER su ON)
(4) Collegare il micro:bit e il computer tramite un cavo micro USB
(5) Aprire l'IDE MU
Se si desidera aggiungere la libreria di estensione Mini car (fare riferimento al file "1.4 Installare il file della libreria").
#### 3.4.3 Schema Elettrico
#### 3.4.4 Lettura del Sensore di Tracciamento Linea
È possibile caricare il codice `3.4-Read the Line Tracking Sensor.py` direttamente dal tutorial (leggere il file "Configurazione dell'ambiente di sviluppo" in caso di dubbi).
```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)
```
**Risultato del Test:** Scaricare il codice sulla scheda micro:bit, non scollegare il cavo USB. Cliccare su "REPL" e premere il pulsante di reset, le letture rilevate dal sensore di tracciamento linea verranno visualizzate sul monitor.
Quando il sensore di tracciamento linea rileva un oggetto bianco, verrà mostrato 0 e D2, D3 si accenderanno; quando non vengono rilevati oggetti bianchi ma solo oggetti neri, verrà visualizzato 1 e D2, D3 si spegneranno, come mostrato di seguito.
#### 3.4.5 Diagramma di Flusso
#### 3.4.6 Codice di Test
È possibile caricare il codice `3.4-Patrol car.py` direttamente dal tutorial (leggere il file "Configurazione dell'ambiente di sviluppo" in caso di dubbi).
```python
from microbit import *
from keyes_MiniCar import * #Importa il file della libreria
minicar = MiniCar() #Istanzia un oggetto MiniCar() come minicar
pin12.set_pull(pin12.PULL_UP) #Imposta pin12 su pull up
pin13.set_pull(pin13.PULL_UP)
sensor_L = 0
sensor_R = 0
while True:
sensor_L = pin13.read_digital() #Leggi il valore del sensore
sensor_R = pin12.read_digital()
print("sensor_L:", sensor_L)
print("sensor_R:", sensor_R)
if sensor_L == 1 and sensor_R == 1: #Valuta se sensor_L e sensor_R =1
minicar.Motor_L(1, 70) #Codice di avanzamento
minicar.Motor_R(1, 70)
elif sensor_L == 0 and sensor_R == 1: #Valuta se sensor_L =0 e sensor_R=1
minicar.Motor_L(1, 70) #Codice svolta a destra
minicar.Motor_R(0, 70)
elif sensor_L == 1 and sensor_R == 0: #Valuta se sensor_L=1 e sensor_R=0
minicar.Motor_L(0, 70)
minicar.Motor_R(1, 70)
else:
minicar.Motor_stop()
```
**Risultato del Test:** Caricare il codice e accendere l'interruttore di alimentazione sull'auto. Posizionare l'auto sulla carta di tracciamento linea, quindi seguirà la linea nera per muoversi.
**Regolazione del potenziometro:**
Quando il carrello non riesce a seguire correttamente la linea, si prega di regolare il potenziometro come segue.
1. Caricare il codice del corso.
2. Posizionare l'auto con la parte anteriore