Reconocimiento de voz con IA con TensorFlow Lite para microcontroladores y SparkFun Edge

1. Introducción

Qué compilarás

En este codelab, aprenderemos a usar TensorFlow Lite para microcontroladores y ejecutar un modelo de aprendizaje profundo en la placa de desarrollo SparkFun Edge. Trabajaremos con el modelo de detección de voz integrado en la placa, que usa una red neuronal convolucional para detectar las palabras "sí" y "no" que se dicen a través de los dos micrófonos de la placa.

bf256d403a1821af.gif

Aprendizaje automático en microcontroladores

El aprendizaje automático se puede usar para crear herramientas inteligentes que faciliten la vida de los usuarios, como Asistente de Google. Sin embargo, a menudo, estas experiencias requieren muchos recursos o procesamiento, lo que puede incluir un servidor en la nube potente o una computadora de escritorio. Sin embargo, ahora es posible ejecutar la inferencia de aprendizaje automático en hardware pequeño y de bajo consumo, como los microcontroladores.

Los microcontroladores son muy comunes, económicos, requieren muy poca energía y son muy confiables. Forman parte de todo tipo de dispositivos domésticos, como electrodomésticos, automóviles y juguetes. De hecho, cada año se producen alrededor de 30,000 millones de dispositivos con microcontroladores.

1360b61fbfa33657.jpeg

Al incorporar el aprendizaje automático a microcontroladores pequeños, podemos potenciar la inteligencia de miles de millones de dispositivos que usamos en nuestra vida cotidiana, sin depender de hardware costoso ni de conexiones a Internet confiables. Imagina electrodomésticos inteligentes que se adapten a tu rutina diaria, sensores industriales inteligentes que entiendan la diferencia entre los problemas y el funcionamiento normal, y juguetes mágicos que puedan ayudar a los niños a aprender de formas divertidas y agradables.

TensorFlow Lite para microcontroladores (software)

358ffdb9eb758b90.png

TensorFlow es el framework de aprendizaje automático de código abierto de Google para entrenar y ejecutar modelos. TensorFlow Lite es un framework de software, una versión optimizada de TensorFlow, diseñada para ejecutar modelos de TensorFlow en dispositivos pequeños y de potencia relativamente baja, como teléfonos celulares.

TensorFlow Lite para microcontroladores es un framework de software, una versión optimizada de TensorFlow, diseñada para ejecutar modelos de TensorFlow en hardware pequeño y de bajo consumo, como microcontroladores. Se ajusta a las restricciones requeridas en estos entornos integrados, es decir, tiene un tamaño binario pequeño, no requiere compatibilidad con el sistema operativo, ninguna biblioteca C o C++ estándar, ni asignación de memoria dinámica, etcétera.

SparkFun Edge (hardware)

La SparkFun Edge es una plataforma basada en microcontroladores: una computadora pequeña en una sola placa de circuito. Tiene un procesador, memoria y hardware de E/S que le permiten enviar y recibir señales digitales a otros dispositivos. Tiene cuatro luces LED controladas por software en tus colores favoritos de Google.

aa4493835a2338c6.png

A diferencia de una computadora, un microcontrolador no ejecuta un sistema operativo. En cambio, los programas que escribes se ejecutan directamente en el hardware. Escribes tu código en una computadora y lo descargas en el microcontrolador a través de un dispositivo llamado programador.

Los microcontroladores no son computadoras potentes. Tienen procesadores pequeños y poca memoria. Sin embargo, como están diseñados para ser lo más simples posible, los microcontroladores pueden usar muy poca energía. Según lo que haga tu programa, el SparkFun Edge puede funcionar durante semanas con una sola batería de celda tipo moneda.

Qué aprenderás

  • Compila el programa de muestra para SparkFun Edge en tu computadora
  • Implementa el programa en tu dispositivo
  • Realiza cambios en el programa y vuelve a implementarlo

Requisitos

Necesitarás el siguiente hardware:

Necesitarás el siguiente software:

  • Git (para verificar si está instalado, ejecuta git en la línea de comandos)
  • Python 3 (ejecuta python3 o python --version en la línea de comandos para verificar si está instalado)
  • Pip para Python 3 ( respuesta útil de StackOverflow)
  • Make 4.2.1 o una versión posterior (ejecuta make --version en la línea de comandos para verificar si está instalado)
  • Controladores básicos de SparkFun Serial

2. Configura tu hardware

El microcontrolador SparkFun Edge incluye un objeto binario preinstalado que puede ejecutar el modelo de voz. Antes de reemplazarlo con nuestra propia versión, primero ejecutemos este modelo.

Para encender la placa, haz lo siguiente:

  1. Inserta una batería de celda tipo moneda en el conector de la batería que se encuentra en la parte posterior de la placa (con el lado "+" de la batería hacia arriba). Si la placa ya tiene una batería insertada, tira de la lengüeta de plástico y empuja la batería para asegurarte de que esté bien insertada.

25a6cc6b208e8a4e.png

  1. Si no tienes una batería de botón, puedes usar el dispositivo programador básico serial USB-C de SparkFun para alimentar la placa. Para conectar este dispositivo a la placa, sigue estos pasos:
  • Ubica el conector de seis pines en el costado de la SparkFun Edge.
  • Conecta el SparkFun USB-C Serial Basic a estos pines y asegúrate de que los pines etiquetados como "BLK" y "GRN" en cada dispositivo estén alineados correctamente.
  • Conecta un cable USB-C entre el SparkFun USB-C Serial Basic y tu computadora.

b140822f0019f92a.png

Una vez que enciendas la placa insertando la batería o conectando el programador USB, la placa se activará y comenzará a escuchar con sus micrófonos. La luz azul debería comenzar a parpadear.

El modelo de aprendizaje automático de la placa está entrenado para reconocer las palabras “sí” y “no”, y para detectar la presencia y la ausencia de voz. Comunica sus resultados encendiendo luces LED de colores. En la siguiente tabla, se muestra el significado de cada color de la luz LED:

Resultado de la detección

Color del LED

"Sí"

Amarillo

"No"

Rojo

Voz desconocida

Verde

No se detecta voz

No se enciende ninguna luz LED

¡Pongámoslo a prueba!

Sostén la tabla cerca de tu boca y di "sí" varias veces. Verás que la luz LED amarilla parpadea. Si no sucede nada cuando dices "sí", prueba lo siguiente:

  • Sostén la placa a unos 25 cm de tu boca.
  • Evita el ruido de fondo excesivo
  • Repite "sí" varias veces en rápida sucesión (intenta decir "sí, sí, sí").

3. Configura el software

Ahora descargaremos, instalaremos y ejecutaremos el modelo de voz en el microcontrolador por nuestra cuenta. Para ello, primero descargamos el código fuente de este programa y las dependencias que necesitamos para compilarlo. El programa está escrito en C++, que se debe compilar en un binario antes de descargarse en la placa. Un objeto binario es un archivo que contiene el programa en un formato que puede ejecutar directamente el hardware de SparkFun Edge.

Las siguientes instrucciones están escritas para Linux o macOS.

Descarga el repo de TensorFlow

El código está disponible en el repositorio de TensorFlow en GitHub, en la siguiente ubicación:

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

Abre una terminal en tu computadora, cambia a un directorio en el que sueles almacenar proyectos de codificación, descarga el repositorio de TensorFlow y, luego, ingresa al directorio creado, como se muestra a continuación:

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

Descarga las dependencias de Python

Usaremos Python 3 para preparar nuestro archivo binario y grabarlo en el dispositivo. Las secuencias de comandos de Python dependen de la disponibilidad de ciertas bibliotecas. Ejecuta el siguiente comando para instalar estas dependencias:

pip3 install pycrypto pyserial --user

4. Compila y prepara el objeto binario

Compilaremos el objeto binario y ejecutaremos comandos que lo prepararán para descargarlo en el dispositivo.

Compila el objeto binario

Para descargar todas las dependencias requeridas y crear el objeto binario, ejecuta el siguiente comando:

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

Si la compilación funciona correctamente, la última línea del resultado debería aparecer de la siguiente manera:

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

Para confirmar que el binario se creó correctamente, ejecuta el siguiente 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"

Deberías ver Binary was successfully created impreso en la consola. Si ves Binary is missing, hubo un problema con el proceso de compilación que requerirá depuración.

Prepara el objeto binario

El archivo binario debe firmarse con claves criptográficas para implementarse en el dispositivo. Ahora ejecutaremos algunos comandos que firmarán nuestro archivo binario para que se pueda descargar en SparkFun Edge.

Ingresa el siguiente comando para configurar algunas claves criptográficas simuladas que podamos usar para el desarrollo:

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

Ahora, ejecuta el siguiente comando para crear un objeto binario firmado:

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

Esto creará el archivo main_nonsecure_ota.bin. Ahora, ejecutaremos otro comando para crear una versión final del archivo que se puede usar para escribir en la memoria flash de nuestro dispositivo con la secuencia de comandos del cargador de arranque que usaremos en el siguiente paso:

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

Ahora deberías tener un archivo llamado main_nonsecure_wire.bin en el directorio en el que ejecutaste los comandos. Este es el archivo que grabaremos en el dispositivo.

5. Prepárate para escribir el binario en la memoria flash

¿Qué es el flashing?

El SparkFun Edge almacena el programa que se está ejecutando en sus 512 kilobytes de memoria flash. Si queremos que la placa ejecute un programa nuevo, debemos enviarlo a la placa, que lo almacenará en la memoria flash y sobrescribirá cualquier programa que se haya guardado anteriormente.

Este proceso se denomina "flashing" y lo usaremos para enviar nuestro programa a la placa.

Cómo conectar el programador a la placa

Para descargar programas nuevos en la placa, usaremos el programador serial básico SparkFun USB-C Serial Basic. Este dispositivo permite que tu computadora se comunique con el microcontrolador a través de USB.

Para conectar este dispositivo a la placa, sigue estos pasos:

  1. Ubica el conector de seis pines en el costado de la SparkFun Edge.
  2. Conecta el SparkFun USB-C Serial Basic a estos pines y asegúrate de que los pines etiquetados como "BLK" y "GRN" en cada dispositivo estén alineados correctamente.

b140822f0019f92a.png

Cómo conectar el programador a la computadora

Conectaremos la placa a tu computadora a través de un puerto USB. Para programar la placa, necesitamos saber el nombre que le asigna tu computadora al dispositivo. La mejor manera de hacerlo es enumerar todos los dispositivos de la computadora antes y después de conectarlo, y buscar qué dispositivo es nuevo.

Antes de conectar el dispositivo a través de USB, ejecuta el siguiente comando:

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

Esto debería mostrar una lista de dispositivos conectados similar a la siguiente:

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

Ahora, conecta el programador al puerto USB de la computadora. Vuelve a ingresar el siguiente comando:

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

Deberías ver un elemento adicional en el resultado, como en el siguiente ejemplo. Es posible que tu artículo nuevo tenga un nombre diferente. Este nuevo elemento es el nombre del dispositivo.

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

Primero, crearemos una variable de entorno para identificar el nombre del dispositivo:

export DEVICENAME=put your device name here

A continuación, crearemos una variable de entorno para especificar la velocidad de transmisión, que es la velocidad a la que se enviarán los datos al dispositivo:

export BAUD_RATE=921600

6. Escribe el objeto binario en la memoria flash

Ejecuta la secuencia de comandos para escribir en la memoria flash de la placa

Para grabar la placa, debemos ponerla en un estado especial de "cargador de arranque" que la prepare para recibir el nuevo objeto binario. Luego, ejecutaremos una secuencia de comandos para enviar el objeto binario a la placa.

Familiarízate con los siguientes botones de la tarjeta:

64c620570b9d2f83.png

Sigue estos pasos para restablecer y escribir la placa en la memoria flash:

  1. Asegúrate de que la placa esté conectada al programador y de que toda la configuración esté conectada a la computadora a través de USB.
  2. Comienza manteniendo presionado el botón marcado con 14 en la placa. Sigue sosteniéndolo hasta el paso 6.
  3. Sin soltar el botón marcado con 14, haz clic en el botón marcado con RST para restablecer la placa y que vuelva a su estado de cargador de arranque.
  4. Sin soltar el botón marcado con 14, pega el siguiente comando en la terminal y presiona Intro para ejecutarlo (para mayor comodidad, puedes pegar este comando en la terminal antes de comenzar a mantener presionado el botón, pero no presiones Intro hasta que llegues a este paso).
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. Sin soltar el botón marcado con 14, deberías ver algo similar a lo siguiente en la pantalla:
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. Deja de mantener presionado el botón marcado con 14 en la placa después de ver Sending Data Packet of length 8180 (pero no pasa nada si lo sigues manteniendo presionado). El programa seguirá imprimiendo líneas en la terminal. Finalmente, se verá de la siguiente manera:
[...lots more Sending Data Packet of length  8180...]
Sending Data Packet of length  8180
Sending Data Packet of length  6440
Sending Reset Command.
Done.

Si ves Done, significa que la escritura en la memoria flash se realizó correctamente. Si el resultado del programa termina con un error, verifica si se imprimió Sending Reset Command. Si es así, es probable que el proceso de escritura haya sido exitoso a pesar del error.

En una máquina Linux, es posible que encuentres un NoResponse Error. Esto se debe a que el controlador serial ch34x se instaló junto con el controlador serial existente, lo que se puede resolver de la siguiente manera:

Paso 1: Vuelve a instalar la versión correcta de la biblioteca ch34x. Asegúrate de que el dispositivo esté desenchufado de la computadora durante la instalación.

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

Paso 2: Conecta el USB de la placa y ejecuta el siguiente comando:

dmesg | grep "ch34x"

Deberías ver un mensaje como este:

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

Si el controlador que se usa no es "ch34x" (p. ej., ch341), intenta inhabilitar el otro controlador ejecutando el siguiente comando:

rmmod <non-ch34x driver name>

Desconecta y vuelve a conectar el dispositivo, y asegúrate de que el controlador que se usa sea "ch34x".

7. Demostración

Prueba el programa

Una vez que la placa se haya grabado correctamente, presiona el botón marcado con .

RST para reiniciar la placa y comenzar el programa Si la luz LED azul comienza a parpadear, el proceso de escritura se completó correctamente. Si no es así, desplázate hacia abajo hasta la sección "¿Qué sucede si no funcionó?" que aparece más abajo.

bf256d403a1821af.gif

El modelo de aprendizaje automático de la placa está entrenado para reconocer las palabras “sí” y “no”, y para detectar la presencia y la ausencia de voz. Comunica sus resultados encendiendo luces LED de colores. En la siguiente tabla, se muestra el significado de cada color de la luz LED:

Resultado de la detección

Color del LED

"Sí"

Amarillo

"No"

Rojo

Voz desconocida

Verde

No se detecta voz

No se enciende ninguna luz LED

¡Pongámoslo a prueba!

Sostén la tabla cerca de tu boca y di "sí" varias veces. Verás que la luz LED amarilla parpadea. Si no sucede nada cuando dices "sí", prueba lo siguiente:

  • Sostén la placa a unos 25 cm de tu boca.
  • Evita el ruido de fondo excesivo
  • Repite "sí" varias veces en rápida sucesión (intenta decir "sí, sí, sí").

¿Qué sucede si no funciona?

Estos son algunos problemas posibles y cómo depurarlos:

Problema: Después de escribir en la memoria flash, no se enciende ninguna luz LED.

Solución: Intenta presionar el botón RST o desconectar y volver a conectar la placa del programador. Si ninguno de estos pasos funciona, vuelve a escribir la placa.

Problema: La luz LED azul se enciende, pero es muy tenue.

Solución: Reemplaza la batería, ya que se está agotando. Como alternativa, la placa se puede alimentar con la computadora usando el programador y el cable.

8. Cómo leer el resultado de la depuración (opcional)

Revisa esta sección si tienes problemas y necesitas depurar tu código en detalle. Para comprender lo que sucede en un microcontrolador cuando se ejecuta tu código, puedes imprimir información de depuración a través de la conexión serial de la placa. Usas tu computadora para conectarte a la placa y mostrar los datos que esta envía.

Cómo abrir una conexión en serie

De forma predeterminada, nuestro código de muestra de SparkFun Edge registra todos los comandos de voz, junto con su nivel de confianza. Para ver el resultado de la placa, puedes ejecutar el siguiente comando:

screen ${DEVICENAME} 115200

Al principio, es posible que veas un resultado similar al siguiente (esto solo aparece si la placa se restablece una vez conectada; de lo contrario, es posible que comiences a ver información de depuración):

Apollo3 Burst Mode is Available

                               Apollo3 operating in Burst Mode (96MHz)

Intenta dar algunos comandos diciendo "sí" o "no". Deberías ver la información de depuración de impresión de la placa para cada comando:

 Heard yes (202) @65536ms

En el registro anterior, yes hace referencia al comando. El número 202 hace referencia al nivel de confianza de que se escuchó el comando (200 es el mínimo). Por último, 65536ms hace referencia a la cantidad de tiempo transcurrido desde el último restablecimiento del microcontrolador.

Para dejar de ver el resultado de la depuración, presiona Ctrl+A, seguido inmediatamente de la tecla K y, luego, presiona la tecla Y.

Escribe registros de depuración

Puedes ver el código que registra esta información en el archivo command_responder.cc con el que acabas de trabajar:

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

Para registrar datos, puedes llamar al método error_reporter->Report(). Admite los tokens printf estándar para la interpolación de cadenas, que puedes usar para incluir información importante en tus registros:

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

Este método te será útil cuando realices tus propios cambios en el código en la próxima sección.

9. Extiende el código (opcional)

Ahora que sabes cómo compilar y escribir en la memoria flash de tu SparkFun Edge, puedes comenzar a jugar con el código y a implementarlo en tu dispositivo para ver los resultados.

Lee el código

Un buen punto de partida para leer el código es el siguiente archivo: command_responder.cc.

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

Puedes ver el archivo en GitHub aquí.

El método de este archivo, RespondToCommand, se llama cuando se detecta un comando por voz. El código existente enciende un LED diferente según si se escuchó "sí", "no" o un comando desconocido. En el siguiente fragmento, se muestra cómo funciona:

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);
}

El argumento found_command contiene el nombre del comando que se detectó. Al verificar el primer carácter, este conjunto de instrucciones if determina qué LED se debe encender.

El método RespondToCommand se llama con varios argumentos:

void RespondToCommand(tflite::ErrorReporter* error_reporter,
    int32_t current_time, const char* found_command,
    uint8_t score, bool is_new_command) {
  • error_reporter se usa para registrar información de depuración (más sobre esto más adelante).
  • current_time representa la fecha y hora en que se detectó el comando.
  • found_command nos indica qué comando se detectó.
  • score nos indica el nivel de confianza que tenemos en que detectamos un comando.
  • is_new_command nos indica si es la primera vez que se escucha el comando.

El score es un número entero del 0 al 255 que representa la probabilidad de que se haya detectado un comando. El código de muestra solo considera que un comando es válido si la puntuación es superior a 200. Según nuestras pruebas, la mayoría de los comandos válidos se encuentran en el rango de 200 a 210.

Modifica el código

La placa SparkFun Edge tiene cuatro LEDs. Actualmente, hacemos parpadear la luz LED azul para indicar que se está realizando el reconocimiento. Puedes ver esto en el archivo 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);
}

Como tenemos un banco de cuatro LEDs, modifiquemos el programa para usarlos como indicador visual del score de un comando determinado. Una puntuación baja justificará una sola luz LED encendida, y una puntuación alta generará varias luces.

Para asegurarnos de que el programa se esté ejecutando, haremos que la luz LED roja parpadee continuamente en lugar de la azul. Las luces LED azules, verdes y amarillas adyacentes se usarán para mostrar la intensidad de nuestro score más reciente. Para simplificar, solo encenderemos esas luces LED si se pronuncia la palabra "sí". Si se detecta otra palabra, las luces LED se apagarán.

Para realizar este cambio, reemplaza todo el código de tu archivo command_responder.cc por el siguiente fragmento:

#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);
      }
    }
  }
}

Si se detecta un comando nuevo, is_new_command será verdadero. Borraremos las luces LED azules, verdes y amarillas, y luego las volveremos a encender según los valores de found_command y score.

Cómo recompilar y escribir en la memoria flash

Una vez que hayas realizado los cambios en el código, ejecútalo siguiendo todos los pasos de Compila y prepara el archivo binario.

10. Próximos pasos

¡Felicitaciones! Compilaste con éxito tu primer detector de voz en un microcontrolador.

Esperamos que hayas disfrutado esta breve introducción al desarrollo con TensorFlow Lite para microcontroladores. La idea del aprendizaje profundo en microcontroladores es nueva y emocionante, y te recomendamos que salgas y experimentes.

Documentos de referencia

26699b18f2b199f.png

Gracias y que disfrutes la creación.