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

1. Introduzione

Cosa creerai

In questo codelab impareremo a utilizzare TensorFlow Lite for Microcontrollers per eseguire un modello di deep learning sulla scheda di sviluppo SparkFun Edge. Utilizzeremo il modello di rilevamento vocale integrato nella scheda, che utilizza una rete neurale convoluzionale per rilevare le parole "sì" e "no" pronunciate tramite i due microfoni della scheda.

bf256d403a1821af.gif

Machine learning sui microcontrollori

Il machine learning può essere utilizzato per creare strumenti intelligenti che semplificano la vita degli utenti, come l'Assistente Google. Spesso, però, queste esperienze richiedono molte risorse o calcoli, che possono includere un potente server cloud o un computer. Tuttavia, ora è possibile eseguire l'inferenza di machine learning su hardware minuscolo e a basso consumo energetico, come i microcontrollori.

I microcontrollori sono estremamente comuni, economici, richiedono pochissima energia e sono molto affidabili. Sono presenti in tutti i tipi di dispositivi per la casa: elettrodomestici, auto e giocattoli. Infatti, ogni anno vengono prodotti circa 30 miliardi di dispositivi alimentati da microcontrollori.

1360b61fbfa33657.jpeg

Portando il machine learning su microcontrollori minuscoli, possiamo aumentare l'intelligenza di miliardi di dispositivi che utilizziamo nella nostra vita, senza fare affidamento su hardware costoso o connessioni a internet affidabili. Immagina elettrodomestici intelligenti che si adattano alla tua routine quotidiana, sensori industriali intelligenti che comprendono la differenza tra problemi e funzionamento normale e giocattoli magici che possono aiutare i bambini a imparare in modo divertente e piacevole.

TensorFlow Lite for Microcontrollers (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, progettata per eseguire modelli TensorFlow su dispositivi piccoli e relativamente a basso consumo energetico, come i cellulari.

TensorFlow Lite for Microcontrollers è un framework software, una versione ottimizzata di TensorFlow, progettata per eseguire modelli TensorFlow su hardware di piccole dimensioni e a basso consumo energetico, come i microcontrollori. Rispetta i vincoli richiesti in questi ambienti incorporati, ovvero ha una dimensione binaria ridotta, non richiede il supporto del sistema operativo, librerie C o C++ standard o allocazione dinamica della memoria e così via.

SparkFun Edge (hardware)

SparkFun Edge è una piattaforma basata su microcontrollore: un piccolo computer su un'unica scheda di circuito. È dotato di un processore, memoria e hardware I/O che gli consentono di inviare e ricevere segnali digitali ad altri dispositivi. Ha quattro LED controllabili via software, nei tuoi colori Google preferiti.

aa4493835a2338c6.png

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

I microcontrollori non sono computer potenti. Hanno processori piccoli e poca memoria. Tuttavia, poiché sono progettati per essere il più semplici possibile, un microcontrollore può utilizzare pochissima energia. A seconda delle attività del programma, SparkFun Edge può funzionare per settimane con una sola 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 nuovamente il deployment

Che cosa ti serve

Avrai bisogno del seguente hardware:

Avrai bisogno dei seguenti software:

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

2. Configurare l'hardware

Il microcontrollore SparkFun Edge viene fornito con un binario preinstallato in grado di eseguire il modello vocale. Prima di sovrascriverlo con la nostra versione, eseguiamo questo modello.

Alimenta la tua bacheca:

  1. Inserisci 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 una batteria già inserita, estrai la linguetta di plastica e spingi la batteria per assicurarti che sia inserita completamente.

25a6cc6b208e8a4e.png

  1. Se non hai una batteria a bottone, puoi utilizzare il programmatore seriale di base USB-C SparkFun per alimentare la scheda. Per collegare questo dispositivo alla tua bacheca, svolgi i seguenti passaggi:
  • Individua l'intestazione a sei pin sul lato di SparkFun Edge.
  • Collega SparkFun USB-C Serial Basic a questi pin, assicurandoti che i pin etichettati "BLK" e "GRN" su ogni dispositivo siano allineati correttamente.
  • Collega un cavo USB-C tra SparkFun USB-C Serial Basic e il computer.

b140822f0019f92a.png

Una volta alimentata la scheda inserendo la batteria o collegando il programmatore USB, la scheda si riattiverà e inizierà ad ascoltare con i suoi microfoni. La spia blu dovrebbe iniziare a lampeggiare.

Il modello di machine learning sulla scheda è addestrato a riconoscere le parole "sì" e "no" e a rilevare la presenza e l'assenza di parlato. Comunica i risultati illuminando i LED colorati. La tabella seguente mostra il significato di ogni colore del LED:

Risultato del rilevamento

Colore del LED

"Sì"

Giallo

"No"

Rosso

Discorso sconosciuto

Verde

Nessuna voce rilevata

Nessun LED acceso

Facciamo una prova

Tieni la scheda vicino alla bocca e dì "sì" alcune volte. Vedrai il LED giallo lampeggiare. Se non succede nulla quando rispondi "Sì", ecco alcune cose da provare:

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

3. Configurare il software

Ora scaricheremo, installeremo ed eseguiremo il modello vocale sul microcontrollore. Per questo, scarichiamo prima il codice sorgente di questo programma e le dipendenze necessarie per compilarlo. Il programma è scritto in C++, che deve essere compilato in un binario prima di essere scaricato sulla scheda. Un 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, nella seguente posizione:

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

Apri un terminale sul computer, passa a una directory in cui di solito memorizzi 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 nostro binario e caricarlo sul dispositivo. Gli script Python dipendono dalla disponibilità di determinate librerie. Esegui questo comando per installare queste dipendenze:

pip3 install pycrypto pyserial --user

4. Crea e prepara il file binario

Creeremo il file binario ed eseguiremo i comandi che lo preparano per il download sul dispositivo.

Crea il file binario

Per scaricare tutte le dipendenze richieste e creare il file 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 verificare che il binario sia 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 nella console. Se vedi Binary is missing, si è verificato un problema con la procedura di compilazione che richiederà il debug.

Preparare il binario

Il binario deve essere firmato con chiavi crittografiche per essere implementato sul dispositivo. Ora eseguiamo alcuni comandi che firmeranno il nostro binario in modo che possa essere scaricato su SparkFun Edge.

Inserisci questo comando per configurare alcune chiavi crittografiche fittizie che possiamo 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 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 eseguiamo un altro comando per creare una versione finale del file che può essere utilizzata per flashare il dispositivo con lo script del 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

Ora dovresti avere un file chiamato main_nonsecure_wire.bin nella directory in cui hai eseguito i comandi. Questo è il file che verrà caricato sul dispositivo.

5. Preparati a flashare il binario

Che cos'è il flashing?

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

Questa procedura è chiamata "flashing" e la utilizzeremo per inviare il nostro programma alla scheda.

Collega il programmatore alla scheda

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

Per collegare questo dispositivo alla tua bacheca, svolgi i seguenti passaggi:

  1. Individua l'intestazione a sei pin sul lato di SparkFun Edge.
  2. Collega SparkFun USB-C Serial Basic a questi pin, assicurandoti che i pin etichettati "BLK" e "GRN" su ogni dispositivo siano allineati correttamente.

b140822f0019f92a.png

Collega il programmatore al computer

Collegheremo la scheda al computer tramite USB. Per programmare la scheda, dobbiamo sapere il nome che il computer assegna al dispositivo. Il modo migliore per farlo è elencare tutti i dispositivi del computer prima e dopo il collegamento e verificare quale dispositivo è nuovo.

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 di 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 seguente comando:

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

Dovresti vedere un elemento aggiuntivo nell'output, 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

Innanzitutto, creiamo una variabile di ambiente per identificare il nome del dispositivo:

export DEVICENAME=put your device name here

A questo punto, creiamo una variabile di ambiente per specificare la velocità di trasmissione, ovvero la velocità con cui i dati verranno inviati al dispositivo:

export BAUD_RATE=921600

6. Esegui il flashing del binario

Esegui lo script per programmare la scheda

Per eseguire il flashing della scheda, dobbiamo metterla in uno stato speciale di "bootloader" che la prepara a ricevere il nuovo binario. Dopodiché, eseguiamo uno script per inviare il binario alla scheda.

Scopriamo i seguenti pulsanti sulla scheda:

64c620570b9d2f83.png

Per reimpostare e aggiornare la scheda, segui questi passaggi:

  1. Assicurati che la scheda sia collegata al programmatore e che l'intera configurazione sia connessa al computer tramite USB.
  2. Inizia tenendo premuto il pulsante contrassegnato con 14 sulla scheda. Continua a tenerlo premuto fino al passaggio 6.
  3. Tenendo ancora premuto il pulsante contrassegnato con 14, fai clic sul pulsante contrassegnato con RST per reimpostare la scheda e riportarla allo stato di bootloader.
  4. 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 finché 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. Tenendo premuto il pulsante contrassegnato da 14, dovresti vedere sullo schermo un messaggio 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 con 14 sulla scheda dopo aver visto Sending Data Packet of length 8180 (ma non preoccuparti se continui a tenerlo premuto). Il programma continuerà a stampare righe sul terminale. Alla fine, l'aspetto sarà simile al seguente:
[...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 flashing è riuscito. Se l'output del programma termina con un errore, controlla se è stato stampato Sending Reset Command. In questo caso, è probabile che il flashing sia riuscito nonostante l'errore.

Su una macchina Linux, potresti riscontrare un NoResponse Error. Questo perché il driver seriale ch34x è stato installato insieme al driver seriale esistente, il che può essere risolto nel seguente modo:

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 scheda USB ed esegui:

dmesg | grep "ch34x"

Dovresti visualizzare un messaggio simile a questo:

[ 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 utilizzato sia "ch34x".

7. Demo

Prova il programma

Una volta eseguito il flashing della scheda, premi il pulsante contrassegnato con

RST per riavviare la scheda e avviare il programma. Se il LED blu inizia a lampeggiare, il flashing è andato a buon fine. In caso contrario, scorri verso il basso fino alla sezione "Cosa succede se non ha funzionato?" di seguito.

bf256d403a1821af.gif

Il modello di machine learning sulla scheda è addestrato a riconoscere le parole "sì" e "no" e a rilevare la presenza e l'assenza di parlato. Comunica i risultati illuminando i LED colorati. La tabella seguente mostra il significato di ogni colore del LED:

Risultato del rilevamento

Colore del LED

"Sì"

Giallo

"No"

Rosso

Discorso sconosciuto

Verde

Nessuna voce rilevata

Nessun LED acceso

Facciamo una prova

Tieni la scheda vicino alla bocca e dì "sì" alcune volte. Vedrai il LED giallo lampeggiare. Se non succede nulla quando rispondi "Sì", ecco alcune cose da provare:

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

Cosa succede se non funziona?

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

Problema: dopo il flashing, 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 eseguire di nuovo il flashing della scheda.

Problema: il LED blu si accende, ma è molto fioco.

Soluzione:sostituisci la batteria perché è in esaurimento. In alternativa, la scheda può essere alimentata dal computer utilizzando il programmatore e il cavo.

8. (Facoltativo) Leggi l'output di debug

Consulta questa sezione se riscontri problemi e devi eseguire il debug del codice in dettaglio. Per capire cosa succede in un microcontrollore quando viene eseguito il codice, puoi stampare le informazioni di debug tramite la connessione seriale della scheda. Utilizzi il computer per connetterti alla scheda e visualizzare i dati che invia.

Aprire una connessione seriale

Per impostazione predefinita, il nostro codice di esempio SparkFun Edge registra tutti i comandi vocali, insieme al relativo livello di confidenza. Per visualizzare l'output della scheda, puoi eseguire questo comando:

screen ${DEVICENAME} 115200

Inizialmente potresti visualizzare un output simile al seguente: (questo viene visualizzato solo se la scheda viene reimpostata una volta connessa, altrimenti potresti iniziare a visualizzare informazioni di debug)

Apollo3 Burst Mode is Available

                               Apollo3 operating in Burst Mode (96MHz)

Prova a dare alcuni comandi dicendo "sì" o "no". Dovresti visualizzare le informazioni di debug della stampa della scheda per ogni comando:

 Heard yes (202) @65536ms

Nel log riportato sopra, yes si riferisce al comando. Il numero 202 si riferisce al livello di confidenza che il comando sia stato ascoltato (200 è il minimo). Infine, 65536ms si riferisce al tempo trascorso dall'ultimo ripristino del microcontrollore.

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

Scrivere log di debug

Puoi visualizzare il codice che registra queste informazioni nel file command_responder.cc con cui hai appena lavorato:

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 standard printf per l'interpolazione di stringhe, che puoi utilizzare per includere informazioni importanti nei log:

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

Questo metodo ti sarà utile quando apporterai le tue modifiche al codice nella sezione successiva.

9. Estendi il codice (facoltativo)

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

Leggi il codice

Un buon punto di partenza per 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 in questo file, RespondToCommand, viene chiamato quando viene rilevato un comando vocale. Il codice esistente accende un LED diverso a seconda che sia stato ascoltato "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 (maggiori dettagli in seguito).
  • current_time rappresenta l'ora in cui è stato rilevato il comando.
  • found_command indica il comando rilevato.
  • score indica il grado di affidabilità con cui abbiamo rilevato un comando.
  • is_new_command ci consente di sapere se è la prima volta che viene ascoltato il comando.

score è un numero intero compreso tra 0 e 255 che rappresenta la probabilità che un comando sia stato rilevato. Il codice di esempio considera un comando valido solo se il punteggio è superiore a 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 è in corso il riconoscimento. Puoi visualizzarlo 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);
}

Poiché abbiamo una banca di quattro LED, modifichiamo il programma per utilizzarli come indicatore visivo del score di un determinato comando. Un punteggio basso corrisponderà a un solo LED acceso, mentre un punteggio alto comporterà l'accensione di più LED.

Per assicurarci di sapere che il programma è in esecuzione, faremo lampeggiare continuamente il LED rosso anziché quello blu. I LED blu, verde e giallo adiacenti verranno utilizzati per mostrare la potenza del score più recente. Per semplicità, accenderemo i LED solo se viene pronunciata la parola "sì". 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, is_new_command sarà true. Cancelleremo i LED blu, verde e giallo, poi li riaccenderemo in base ai valori di found_command e score.

Ricompila e flasha

Dopo aver apportato modifiche al codice, testalo eseguendo tutti i passaggi descritti in Crea e prepara il binario.

10. Passaggi successivi

Congratulazioni, hai creato il tuo primo rilevatore vocale su un microcontrollore.

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

Documentazione di riferimento

26699b18f2b199f.png

Grazie e buon divertimento!