Riconoscimento vocale basato sull'IA con TensorFlow Lite per microcontroller e SparkFun Edge

1. Introduzione

Cosa creerai

In questo codelab imparerai a utilizzare TensorFlow Lite per microcontroller per eseguire un modello di deep learning sulla scheda di sviluppo Edge SparkFun. Lavoreremo con il modello di rilevamento vocale integrato della lavagna, che utilizza una rete neurale convoluzionale per rilevare le parole "sì" e "no" viene parlato tramite i due microfoni della lavagna.

bf256d403a1821af.gif

Machine learning su microcontroller

Il machine learning può essere utilizzato per creare strumenti intelligenti che semplificano le è tutto più semplice, come l'Assistente Google. Spesso, tuttavia, queste esperienze richiedono molte risorse di calcolo o di calcolo, ad esempio un potente server cloud o un desktop. Tuttavia, ora è possibile eseguire l'inferenza del machine learning su hardware di piccole dimensioni e a basso consumo, come i microcontroller.

I microcontroller sono estremamente comuni, economici, richiedono poca energia e sono molto affidabili. Fanno parte di tutti i tipi di dispositivi per la casa, ad esempio elettrodomestici, auto e giocattoli. Infatti, ogni anno vengono prodotti circa 30 miliardi di dispositivi alimentati da microcontroller.

1360b61fbfa33657.jpeg

Fornendo il machine learning a microcontroller di piccole dimensioni, possiamo aumentare l'intelligenza di miliardi di dispositivi che usiamo nelle nostre vite, senza dover fare affidamento su hardware costoso o connessioni a internet affidabili. Immagina elettrodomestici smart in grado di adattarsi alla tua routine quotidiana, sensori industriali intelligenti in grado di comprendere la differenza tra problemi e normale funzionamento e giocattoli magici che possono aiutare i bambini a imparare in modi divertenti e piacevoli.

TensorFlow Lite per microcontroller (software)

358ffdb9eb758b90.png

TensorFlow è il framework di machine learning open source di Google per l'addestramento e l'esecuzione di modelli. TensorFlow Lite è un framework software, una versione ottimizzata di TensorFlow, destinata all'esecuzione di modelli TensorFlow su dispositivi di piccole dimensioni e con potenza relativamente bassa, come i telefoni cellulari.

TensorFlow Lite per microcontroller è un framework software, una versione ottimizzata di TensorFlow, destinata all'esecuzione di modelli TensorFlow su hardware minuscolo e a bassa potenza come i microcontroller. È conforme ai vincoli richiesti in questi ambienti incorporati, ovvero ha dimensioni binarie ridotte, non richiede il supporto del sistema operativo, alcuna libreria C o C++ standard, né allocazione di memoria dinamica e così via.

SparkFun Edge (hardware)

SparkFun Edge è una piattaforma basata su microcontroller: un piccolo computer su un unico circuito stampato. Dispone di un processore, di una memoria e di un hardware di I/O che gli consentono di inviare e ricevere segnali digitali ad altri dispositivi. È dotata di quattro LED controllabili da software, nei tuoi colori Google preferiti.

aa4493835a2338c6.png

A differenza di un computer, un microcontroller non esegue un sistema operativo. I programmi che scrivi vengono invece eseguiti direttamente sull'hardware. Scrivi il codice su un computer e lo scarichi sul microcontroller tramite un dispositivo chiamato programmatore.

I microcontroller non sono computer potenti. Hanno processori piccoli e poca memoria. Ma dato che sono progettati per essere il più semplici possibile, un microcontroller può utilizzare pochissima energia. In base al programma, SparkFun Edge può funzionare per settimane con una singola batteria a bottone!

Cosa imparerai a fare

  • Compila il programma di esempio per SparkFun Edge sul tuo computer
  • Esegui il deployment del programma sul tuo dispositivo
  • Apporta modifiche al programma ed esegui di nuovo il deployment

Che cosa ti serve

Avrai bisogno del seguente hardware:

Avrai bisogno del seguente software:

  • Git (controlla se è installato eseguendo git sulla riga di comando)
  • Python 3 (controlla se è installato eseguendo python3 o python --version sulla riga di comando)
  • Pip per Python 3 ( risposta utile di StackOverflow)
  • Versione 4.2.1 o successiva (controlla se è installata eseguendo make --version sulla riga di comando)
  • Driver di SparkFun Serial Basic

2. Configura l'hardware

Il microcontroller SparkFun Edge viene fornito con un programma binario preinstallato in grado di eseguire il modello vocale. Prima di sovrascrivere il modello con la nostra versione, eseguiamo il modello.

Alimenta la tua lavagna:

  1. Inserimento di una batteria a bottone nel connettore della batteria sul retro della scheda (con il lato "+" della batteria rivolto verso l'alto. Se la scheda è stata fornita con la batteria già inserita, estrai la linguetta di plastica e spingi la batteria per assicurarti che sia completamente inserita.

25a6cc6b208e8a4e.png

  1. Se non hai una batteria a bottone, puoi usare il dispositivo programmatore SparkFun USB-C Serial Basic per alimentare la scheda. Per collegare questo dispositivo alla lavagna, segui questi passaggi:
  • Individua l'intestazione a sei pin sul lato di SparkFun Edge.
  • Collega il connettore seriale USB-C SparkFun a questi pin, assicurandoti che i pin con l'etichetta "BLK" e "GRN" su ciascun dispositivo siano allineati correttamente.
  • Collega un cavo USB-C tra il dispositivo SparkFun USB-C Serial Basic e il computer.

b140822f0019f92a.png

Dopo aver alimentato la scheda inserendo la batteria o collegando il programmatore USB, la scheda si riattiva e inizia ad ascoltare con i microfoni. La spia blu dovrebbe iniziare a lampeggiare.

Il modello di machine learning sulla lavagna è addestrato a riconoscere le parole "sì" e "no" e per rilevare la presenza e l'assenza di voce. Comunica i suoi risultati accendendo LED colorati. La tabella seguente mostra il significato di ogni colore dei LED:

Risultato del rilevamento

Colore LED

"Sì"

Giallo

"No"

Rosso

Voce sconosciuta

di colore verde

Nessun discorso rilevato

Nessun LED acceso

Prova

Tieni il tabellone vicino alla bocca e di' "sì" alcune volte. Vedrai il LED giallo lampeggiare. Se non succede niente quando dici "sì", ecco alcune cose da provare:

  • Tieni il tabellone a circa 25 cm dalla bocca
  • Evitare rumori di fondo eccessivi
  • Ripeti "sì" diverse volte in rapida successione (prova a dire "sì sì sì")

3. Configura il software

Ora scaricheremo, installiamo ed eseguiamo personalmente il modello vocale sul microcontroller. A questo scopo, scarichiamo prima il codice sorgente del programma e le dipendenze necessarie per crearlo. Il programma è scritto in C++, che deve essere compilato in un file binario prima di essere scaricato sulla lavagna. Un programma binario è un file che contiene il programma in un formato che può essere eseguito direttamente dall'hardware SparkFun Edge.

Le seguenti istruzioni sono scritte per Linux o MacOS.

Scarica il repository TensorFlow

Il codice è disponibile nel repository TensorFlow su GitHub, alla seguente posizione:

https://github.com/tensorflow/tensorflow/tree/master/tensorflow/lite/micro

Apri un terminale sul computer, passa a una directory in cui archivi di solito i progetti di programmazione, scarica il repository TensorFlow e inserisci la directory creata, come mostrato di seguito:

cd ~  # change into your home (or any other) directory
git clone --depth 1 https://github.com/tensorflow/tensorflow.git
cd tensorflow

Scarica le dipendenze Python

Utilizzeremo Python 3 per preparare il file binario e inserirlo nel dispositivo tramite flashing. Gli script Python dipendono da determinate librerie disponibili. Esegui questo comando per installare queste dipendenze:

pip3 install pycrypto pyserial --user

4. Crea e prepara il programma binario

A questo punto creeremo il programma binario ed eseguiremo i comandi che lo preparano per il download sul dispositivo.

Crea il programma binario

Per scaricare tutte le dipendenze richieste e creare il programma binario, esegui questo comando:

make -f tensorflow/lite/micro/tools/make/Makefile TARGET=sparkfun_edge micro_speech_bin

Se la build funziona correttamente, l'ultima riga dell'output dovrebbe essere visualizzata come segue:

arm-none-eabi-objcopy tensorflow/lite/micro/tools/make/gen/sparkfun_edge_cortex-m4/bin/micro_speech tensorflow/lite/micro/tools/make/gen/sparkfun_edge_cortex-m4/bin/micro_speech.bin -O binary

Per confermare che il programma binario è stato creato correttamente, esegui questo comando:

test -f \
tensorflow/lite/micro/tools/make/gen/sparkfun_edge_cortex-m4/bin/micro_speech.bin && \
 echo "Binary was successfully created" || echo "Binary is missing"

Dovresti vedere Binary was successfully created stampato sulla console. Se viene visualizzato Binary is missing, si è verificato un problema con il processo di compilazione che richiede il debug.

Prepara il programma binario

Il file binario deve essere firmato con chiavi di crittografia per poter eseguire il deployment sul dispositivo. Ora eseguiremo alcuni comandi che firmano il file binario in modo che possa essere scaricato su SparkFun Edge.

Inserisci il seguente comando per configurare alcune chiavi di crittografia fittizie da utilizzare per lo sviluppo:

cp tensorflow/lite/micro/tools/make/downloads/AmbiqSuite-Rel2.2.0/tools/apollo3_scripts/keys_info0.py tensorflow/lite/micro/tools/make/downloads/AmbiqSuite-Rel2.2.0/tools/apollo3_scripts/keys_info.py

Ora esegui questo comando per creare un file binario firmato:

python3 tensorflow/lite/micro/tools/make/downloads/AmbiqSuite-Rel2.2.0/tools/apollo3_scripts/create_cust_image_blob.py \
--bin tensorflow/lite/micro/tools/make/gen/sparkfun_edge_cortex-m4/bin/micro_speech.bin \
--load-address 0xC000 \
--magic-num 0xCB \
-o main_nonsecure_ota \
--version 0x0

Verrà creato il file main_nonsecure_ota.bin. Ora eseguiremo un altro comando per creare una versione finale del file che può essere utilizzata per eseguire il flashing del nostro dispositivo con lo script bootloader che utilizzeremo nel passaggio successivo:

python3 tensorflow/lite/micro/tools/make/downloads/AmbiqSuite-Rel2.2.0/tools/apollo3_scripts/create_cust_wireupdate_blob.py \
--load-address 0x20000 \
--bin main_nonsecure_ota.bin \
-i 6 \
-o main_nonsecure_wire \
--options 0x1

A questo punto dovresti avere un file denominato main_nonsecure_wire.bin nella directory in cui hai eseguito i comandi. Questo è il file che eseguiremo in flash sul dispositivo.

5. Preparati a eseguire il flashing del file binario

Cosa significa lampeggiare?

SparkFun Edge archivia il programma attualmente in esecuzione nei suoi 512 kilobyte di memoria flash. Se vogliamo che la lavagna esegua un nuovo programma, dobbiamo inviarlo alla lavagna, che lo memorizzerà nella memoria flash, sovrascrivendo qualsiasi programma salvato in precedenza.

Questa procedura è chiamata "lampeggiamento" e la utilizzeremo per inviare il nostro programma alla lavagna.

Fissa il programmatore alla lavagna

Per scaricare nuovi programmi sulla lavagna, utilizzeremo il programmatore seriale SparkFun USB-C Serial Basic. Questo dispositivo consente al computer di comunicare con il microcontroller tramite USB.

Per collegare questo dispositivo alla lavagna, segui questi passaggi:

  1. Individua l'intestazione a sei pin sul lato di SparkFun Edge.
  2. Collega il connettore seriale USB-C SparkFun a questi pin, assicurandoti che i pin con l'etichetta "BLK" e "GRN" su ciascun dispositivo siano allineati correttamente.

b140822f0019f92a.png

Collega il programmatore al tuo computer

Collegheremo la scheda al computer tramite USB. Per programmare la lavagna, avremo bisogno di conoscere il nome che il tuo computer assegna al dispositivo. Il modo migliore per farlo è elencare tutti i dispositivi del computer prima e dopo averlo collegato e controllare quali sono i nuovi dispositivi.

Prima di collegare il dispositivo tramite USB, esegui questo comando:

If you are using Linux: ls /dev/tty*
If you are using MacOS: ls /dev/cu*

Dovrebbe essere visualizzato un elenco dei dispositivi collegati simile al seguente:

/dev/cu.Bluetooth-Incoming-Port
/dev/cu.MALS
/dev/cu.SOC

Ora, collega il programmatore alla porta USB del computer. Inserisci di nuovo il comando seguente:

If you are using Linux: ls /dev/tty*
If you are using MacOS: ls /dev/cu*

Nell'output dovresti vedere un elemento aggiuntivo, come nell'esempio seguente. Il nuovo elemento potrebbe avere un nome diverso. Questo nuovo elemento è il nome del dispositivo.

/dev/cu.Bluetooth-Incoming-Port
/dev/cu.MALS
/dev/cu.SOC
/dev/cu.wchusbserial-1450

Per prima cosa, creeremo una variabile di ambiente per identificare il nome del dispositivo:

export DEVICENAME=put your device name here

Poi creeremo una variabile di ambiente per specificare la velocità in baud, ossia la velocità con cui i dati verranno inviati al dispositivo:

export BAUD_RATE=921600

6. Esegui il flashing del file binario

Esegui lo script per eseguire il flashing della lavagna

Per far lampeggiare la lavagna, dobbiamo metterla in uno speciale "bootloader" che lo prepara alla ricezione del nuovo programma binario. Eseguiremo quindi uno script per inviare il programma binario alla lavagna.

Esaminiamo i seguenti pulsanti della lavagna:

64c620570b9d2f83.png

Per resettare e aggiornare la lavagna, procedi nel seguente modo:

  1. Assicurati che la tua scheda sia collegata al programmatore e che l'intera configurazione sia collegata al computer tramite USB.
  2. Inizia a tenere premuto il pulsante 14 sulla lavagna. Tienilo premuto fino al passaggio 6.
  3. Tenendo ancora premuto il pulsante contrassegnato con 14, per ripristinare lo stato di bootloader della scheda, fai clic sul pulsante RST per resettarla.
  4. Sempre tenendo premuto il pulsante contrassegnato con 14, incolla il seguente comando nel terminale e premi Invio per eseguirlo (Per comodità, puoi incollare questo comando nel terminale prima di iniziare a tenere premuto il pulsante, ma non premere Invio fino a quando non raggiungi questo passaggio)
python3 tensorflow/lite/micro/tools/make/downloads/AmbiqSuite-Rel2.2.0/tools/apollo3_scripts/uart_wired_update.py -b ${BAUD_RATE} ${DEVICENAME} -r 1 -f main_nonsecure_wire.bin -i 6
  1. Se continui a tenere premuto il pulsante contrassegnato con 14, ora dovresti vedere sullo schermo qualcosa di simile al seguente:
Connecting with Corvette over serial port /dev/cu.usbserial-1440...
Sending Hello.
Received response for Hello
Received Status
length =  0x58
version =  0x3
Max Storage =  0x4ffa0
Status =  0x2
State =  0x7
AMInfo =
0x1
0xff2da3ff
0x55fff
0x1
0x49f40003
0xffffffff
[...lots more 0xffffffff...]
Sending OTA Descriptor =  0xfe000
Sending Update Command.
number of updates needed =  1
Sending block of size  0x158b0  from  0x0  to  0x158b0
Sending Data Packet of length  8180
Sending Data Packet of length  8180
[...lots more Sending Data Packet of length  8180...]
  1. Smetti di tenere premuto il pulsante contrassegnato da 14 sulla lavagna dopo aver visto Sending Data Packet of length 8180 (ma non importa se continui a tenerlo premuto). Il programma continuerà a stampare linee sul terminale. Alla fine avrà il seguente aspetto:
[...lots more Sending Data Packet of length  8180...]
Sending Data Packet of length  8180
Sending Data Packet of length  6440
Sending Reset Command.
Done.

Se vedi Done, significa che il lampeggiamento è stato corretto correttamente. Se l'output del programma termina con un errore, controlla se Sending Reset Command è stato stampato. In questo caso è probabile che il flashing abbia avuto esito positivo nonostante l'errore.

Su un computer Linux, potresti riscontrare un errore NoResponse Error. Questo accade perché il driver seriale ch34x è stato installato insieme al driver seriale esistente, il che può essere risolto come segue:

Passaggio 1: reinstalla la versione corretta della libreria ch34x. Assicurati che il dispositivo sia scollegato dal computer durante l'installazione.

git clone https://github.com/juliagoda/CH341SER.git
cd CH341SER/
make
sudo insmod ch34x.ko
sudo rmmod ch341

Passaggio 2: collega la porta USB della scheda ed esegui:

dmesg | grep "ch34x"

Dovresti vedere un messaggio simile al seguente:

[ 1299.444724]  ch34x_attach+0x1af/0x280 [ch34x]
[ 1299.445386] usb 2-13.1: ch34x converter now attached to ttyUSB0

Se il driver utilizzato non è "ch34x" (ad es. ch341), prova a disattivare l'altro driver eseguendo:

rmmod <non-ch34x driver name>

Scollega e ricollega il dispositivo e assicurati che il driver in uso sia "ch34x".

7. Demo

Prova il programma

Una volta che la bacheca è stata lampeggiata, premi il pulsante contrassegnato

RST per riavviare la lavagna e avviare il programma. Se il LED blu inizia a lampeggiare, il lampeggio è stato eseguito correttamente. In caso contrario, scorri verso il basso fino alla sezione "Cosa succede se non funziona?" di seguito.

bf256d403a1821af.gif

Il modello di machine learning sulla lavagna è addestrato a riconoscere le parole "sì" e "no" e per rilevare la presenza e l'assenza di voce. Comunica i suoi risultati accendendo LED colorati. La tabella seguente mostra il significato di ogni colore dei LED:

Risultato del rilevamento

Colore LED

"Sì"

Giallo

"No"

Rosso

Voce sconosciuta

di colore verde

Nessun discorso rilevato

Nessun LED acceso

Prova

Tieni il tabellone vicino alla bocca e di' "sì" alcune volte. Vedrai il LED giallo lampeggiare. Se non succede niente quando dici "sì", ecco alcune cose da provare:

  • Tieni il tabellone a circa 25 cm dalla bocca
  • Evitare rumori di fondo eccessivi
  • Ripeti "sì" diverse volte in rapida successione (prova a dire "sì sì sì")

E se non funzionasse?

Di seguito sono riportati alcuni possibili problemi e come eseguirne il debug:

Problema: dopo aver lampeggiato, nessuno dei LED si accende.

Soluzione: prova a premere il pulsante RST o a scollegare e ricollegare la scheda dal programmatore. Se nessuna di queste soluzioni funziona, prova a far lampeggiare di nuovo la lavagna.

Problema: il LED blu si illumina, ma è molto attenuato.

Soluzione:sostituisci la batteria perché sta per esaurirsi. In alternativa, la scheda può essere alimentata tramite computer utilizzando il programmatore e il cavo.

8. Leggi l'output di debug (facoltativo)

Consulta questa sezione se riscontri problemi e devi eseguire il debug del codice in modo dettagliato. Per capire cosa succede in un microcontroller quando il tuo codice è in esecuzione, puoi stampare le informazioni di debug tramite la connessione seriale della scheda. Puoi usare il computer per connetterti alla lavagna e visualizzare i dati che sta inviando.

Aprire una connessione seriale

Per impostazione predefinita, il codice campione di SparkFun Edge registra tutti i comandi vocali, insieme all'attendibilità. Per vedere l'output della lavagna puoi eseguire questo comando:

screen ${DEVICENAME} 115200

Inizialmente potresti vedere un output simile al seguente: (viene visualizzato solo se la lavagna viene reimpostata dopo il collegamento, altrimenti potresti iniziare a vedere le informazioni di debug)

Apollo3 Burst Mode is Available

                               Apollo3 operating in Burst Mode (96MHz)

Prova a inviare alcuni comandi dicendo "sì" o "no". Dovresti vedere le informazioni di debug della stampa della scheda per ciascun comando:

 Heard yes (202) @65536ms

Nel log precedente, yes si riferisce al comando. Il numero 202 si riferisce al livello di sicurezza che il comando è stato ascoltato (200 è il minimo). Infine, 65536ms si riferisce alla quantità di tempo trascorso dall'ultimo reset del microcontroller.

Per interrompere la visualizzazione dell'output di debug, premi Ctrl+A, subito seguito dal tasto K, quindi premi il tasto Y.

Scrittura dei log di debug

Puoi vedere il codice che registra queste informazioni nel file command_responder.cc che stavi utilizzando:

tensorflow/lite/micro/examples/micro_speech/sparkfun_edge/command_responder.cc

Per registrare i dati, puoi chiamare il metodo error_reporter->Report(). Supporta i token printf standard per l'interpolazione delle stringhe, che puoi utilizzare per includere informazioni importanti nei log:

error_reporter->Report("Heard %s (%d) @%dms", found_command, score, current_time);

Questo metodo dovrebbe risultare utile quando apporti le tue modifiche al codice nella sezione successiva.

9. (Facoltativo) Estendi il codice

Ora che sai come creare ed eseguire il flashing di SparkFun Edge, puoi iniziare a giocare con il codice e a eseguirne il deployment sul dispositivo per vedere i risultati.

Leggi il codice

Un buon punto di partenza per iniziare a leggere il codice è il seguente file, command_responder.cc..

tensorflow/lite/micro/examples/micro_speech/sparkfun_edge/command_responder.cc

Puoi visualizzare il file su GitHub qui.

Il metodo utilizzato in questo file, RespondToCommand, viene chiamato quando viene rilevato un comando vocale. Il codice esistente accende un LED diverso a seconda che sia stato sentito un "sì", "no" o un comando sconosciuto. Il seguente snippet mostra come funziona:

if (found_command[0] == 'y') {
  am_hal_gpio_output_set(AM_BSP_GPIO_LED_YELLOW);
}
if (found_command[0] == 'n') {
  am_hal_gpio_output_set(AM_BSP_GPIO_LED_RED);
}
if (found_command[0] == 'u') {
  am_hal_gpio_output_set(AM_BSP_GPIO_LED_GREEN);
}

L'argomento found_command contiene il nome del comando rilevato. Controllando il primo carattere, questo insieme di istruzioni if determina quale LED accendere.

Il metodo RespondToCommand viene chiamato con diversi argomenti:

void RespondToCommand(tflite::ErrorReporter* error_reporter,
    int32_t current_time, const char* found_command,
    uint8_t score, bool is_new_command) {
  • error_reporter viene utilizzato per registrare le informazioni di debug (ulteriori informazioni in seguito).
  • current_time rappresenta l'ora in cui è stato rilevato il comando.
  • found_command ci indica quale comando è stato rilevato.
  • score ci indica quanto siamo sicuri di aver rilevato un comando.
  • is_new_command ci fa sapere se è la prima volta che senti il comando.

score è un numero intero compreso tra 0 e 255 che rappresenta la probabilità che sia stato rilevato un comando. Il codice di esempio considera valido un comando solo se il punteggio è maggiore di 200. In base ai nostri test, la maggior parte dei comandi validi rientra nell'intervallo 200-210.

Modificare il codice

La scheda SparkFun Edge ha quattro LED. Al momento il LED blu lampeggia per indicare che il riconoscimento è in corso. Puoi verificarlo nel file command_responder.cc:

static int count = 0;

// Toggle the blue LED every time an inference is performed.
++count;
if (count & 1) {
  am_hal_gpio_output_set(AM_BSP_GPIO_LED_BLUE);
} else {
  am_hal_gpio_output_clear(AM_BSP_GPIO_LED_BLUE);
}

Dato che abbiamo una serie di quattro LED, modifichiamo il programma per usarli come indicatore visivo del score di un determinato comando. Un punteggio basso merita un singolo LED acceso, mentre un punteggio alto si tradurrà in più luci.

Per consentirci di capire se il programma è in esecuzione, faremo lampeggiare continuamente il LED rosso anziché quello blu. I LED blu, verdi e gialli adiacenti verranno utilizzati per mostrare l'intensità del nostro score più recente. Per semplicità, i LED si accendono solo se la parola "sì" viene parlato. Se viene rilevata un'altra parola, i LED si spengono.

Per apportare questa modifica, sostituisci tutto il codice nel file command_responder.cc con il seguente snippet:

#include "tensorflow/lite/micro/examples/micro_speech/command_responder.h"

#include "am_bsp.h"

// This implementation will light up the LEDs on the board in response to different commands.
void RespondToCommand(tflite::ErrorReporter* error_reporter,
                      int32_t current_time, const char* found_command,
                      uint8_t score, bool is_new_command) {
  static bool is_initialized = false;
  if (!is_initialized) {
    // Setup LEDs as outputs
    am_hal_gpio_pinconfig(AM_BSP_GPIO_LED_RED, g_AM_HAL_GPIO_OUTPUT_12);
    am_hal_gpio_pinconfig(AM_BSP_GPIO_LED_BLUE, g_AM_HAL_GPIO_OUTPUT_12);
    am_hal_gpio_pinconfig(AM_BSP_GPIO_LED_GREEN, g_AM_HAL_GPIO_OUTPUT_12);
    am_hal_gpio_pinconfig(AM_BSP_GPIO_LED_YELLOW, g_AM_HAL_GPIO_OUTPUT_12);
    // Ensure all pins are cleared
    am_hal_gpio_output_clear(AM_BSP_GPIO_LED_RED);
    am_hal_gpio_output_clear(AM_BSP_GPIO_LED_BLUE);
    am_hal_gpio_output_clear(AM_BSP_GPIO_LED_GREEN);
    am_hal_gpio_output_clear(AM_BSP_GPIO_LED_YELLOW);
    is_initialized = true;
  }
  static int count = 0;

   // Toggle the red LED every time an inference is performed.
   ++count;
   if (count & 1) {
     am_hal_gpio_output_set(AM_BSP_GPIO_LED_RED);
   } else {
     am_hal_gpio_output_clear(AM_BSP_GPIO_LED_RED);
   }

  if (is_new_command) {
    // Clear the last three LEDs
    am_hal_gpio_output_clear(AM_BSP_GPIO_LED_BLUE);
    am_hal_gpio_output_clear(AM_BSP_GPIO_LED_GREEN);
    am_hal_gpio_output_clear(AM_BSP_GPIO_LED_YELLOW);
    error_reporter->Report("Heard %s (%d) @%dms", found_command, score,
                           current_time);
    // Only indicate a 'yes'
    if (found_command[0] == 'y') {
      // Always light the blue LED
      am_hal_gpio_output_set(AM_BSP_GPIO_LED_BLUE);
      // Light the other LEDs depending on score
      if (score >= 205) {
        am_hal_gpio_output_set(AM_BSP_GPIO_LED_GREEN);
      }
      if(score >= 210) {
        am_hal_gpio_output_set(AM_BSP_GPIO_LED_YELLOW);
      }
    }
  }
}

Se viene rilevato un nuovo comando, il valore is_new_command sarà true. I LED blu, verde e giallo verranno cancellati e poi illuminati di nuovo a seconda dei valori di found_command e score.

Ricrea e fai lampeggiare

Dopo aver apportato le modifiche al codice, testalo eseguendo tutti i passaggi in Creazione e preparazione del file binario.

10. Passaggi successivi

Congratulazioni, hai costruito correttamente il tuo primo rilevatore vocale su un microcontroller.

Ci auguriamo che questa breve introduzione allo sviluppo con TensorFlow Lite per microcontroller ti sia piaciuta. L'idea del deep learning sui microcontroller è nuova ed entusiasmante e ti invitiamo a uscire e a sperimentare.

Documenti di riferimento

26699b18f2b199f.png

Grazie e divertiti a costruire!