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 para ejecutar un modelo de aprendizaje profundo en la placa de desarrollo SparkFun Edge. Trabajaremos con el modelo de detección de voz integrado de la placa, que usa una red neuronal convolucional para detectar las palabras "sí" y "no" hablado a través de los dos micrófonos de la placa.

bf256d403a1821af.gif

Aprendizaje automático en microcontroladores

El aprendizaje automático puede usarse para crear herramientas inteligentes la vida más fácil, como Asistente de Google. A menudo, estas experiencias requieren mucho procesamiento o recursos, que pueden incluir un servidor en la nube potente o una computadora de escritorio. Sin embargo, ahora es posible ejecutar la inferencia del aprendizaje automático en un hardware pequeño de baja potencia, como los microcontroladores.

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

1360b61fbfa33657.jpeg

Si llevamos el aprendizaje automático a pequeños microcontroladores, podemos potenciar la inteligencia de miles de millones de dispositivos que usamos en nuestras vidas, sin depender de hardware costoso ni de conexiones a Internet confiables. Imagina electrodomésticos inteligentes que puedan adaptarse a tu rutina diaria, sensores industriales inteligentes que comprendan 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 marco de trabajo de aprendizaje automático de código abierto de Google para entrenar y ejecutar modelos. TensorFlow Lite es un marco de trabajo de software, una versión optimizada de TensorFlow, destinada a ejecutar modelos de TensorFlow en dispositivos pequeños y de potencia relativamente baja, como los teléfonos celulares.

TensorFlow Lite para microcontroladores es un marco de trabajo de software, una versión optimizada de TensorFlow, destinada a ejecutar modelos de TensorFlow en un hardware pequeño y de baja potencia, como los microcontroladores. Cumple con las restricciones requeridas en estos entornos incorporados; es decir, tiene un tamaño binario pequeño, no requiere compatibilidad con el sistema operativo, ninguna biblioteca C o C++ estándar, asignación de memoria dinámica, etcétera.

SparkFun Edge (Hardware)

SparkFun Edge es una plataforma basada en microcontroladores: una pequeña computadora alojada en una sola placa de circuitos. 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 que puedes controlar 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 al microcontrolador a través de un dispositivo llamado programador.

Los microcontroladores no son computadoras potentes. Tienen procesadores pequeños y poca memoria. Sin embargo, dado que están diseñados para ser lo más sencillos posible, un microcontrolador puede consumir muy poca energía. Según lo que haga el programa, SparkFun Edge puede ejecutarse durante semanas con una batería de tipo botón.

Qué aprenderás

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

Requisitos

Necesitarás el siguiente hardware:

Necesitarás el siguiente software:

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

2. Configura el hardware

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

Potencia la placa de la siguiente manera:

  1. Inserta una batería de tipo botón en el conector de batería ubicado en la parte posterior de la placa (con el lado "+" de la batería hacia arriba). Si ya tienes una batería insertada en la placa, tira de la lengüeta y presiona la batería para asegurarte de que esté bien insertada).

25a6cc6b208e8a4e.png

  1. Si no tienes una batería tipo moneda, puedes usar el dispositivo programador SparkFun USB-C Serial Basic para alimentar la placa. Para conectar este dispositivo a la placa, sigue estos pasos:
  • Localiza el encabezado de seis pines en el costado de SparkFun Edge.
  • Conecta el SparkFun USB-C Serial Basic a estos pines y asegúrate de que los pines tengan la etiqueta "BLK" y "GRN" de 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 hayas enchufado la placa al insertar la batería o conectar 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 en la pizarra está entrenado para reconocer las palabras “sí” y "no", y para detectar la presencia y ausencia de voz. Comunica los resultados mediante luces LED de colores. En la siguiente tabla, se muestra el significado de cada color de las luces LED:

Resultado de la detección

Color de las luces LED

"Sí"

Amarillo

"No"

Rojo

Voz desconocida

Verde

No se detecta voz

No hay luces LED encendidas

Pruébala

Acerca el tablero a tu boca y di "sí" varias veces. Verás una luz LED amarilla que parpadea. Si no sucede nada cuando respondes "sí", puedes probar lo siguiente:

  • Sostén el tablero a unos 25 cm de tu boca
  • Evita el ruido de fondo excesivo
  • Repite "sí" varias veces seguidas rápidamente (intenta decir "sí, sí, sí")

3. Configura el software

Ahora descargaremos, instalaremos y ejecutaremos nosotros mismos el modelo de voz en el microcontrolador. 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 debe compilarse en un binario antes de descargarse en la placa. Un objeto binario es un archivo que contiene el programa de una forma que el hardware de SparkFun Edge puede ejecutar directamente.

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

Descarga el repositorio 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 programació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 objeto binario y, luego, instalarlo en el dispositivo. Las secuencias de comandos de Python dependen de que haya ciertas bibliotecas disponibles. 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 descargarse en el dispositivo.

Compila el objeto binario

Para descargar todas las dependencias necesarias 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 línea final 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 objeto 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, significa que hubo un problema con el proceso de compilación que requerirá depuración.

Prepara el objeto binario

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

Escribe el comando siguiente para configurar algunas claves criptográficas ficticias que podemos 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 pueda usarse para escribir en la memoria flash de nuestro dispositivo la secuencia de comandos del bootloader 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 escribiremos en la memoria flash del dispositivo.

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

¿Qué significa flash?

SparkFun Edge almacena el programa que está ejecutando actualmente en sus 512 kilobytes de memoria flash. Si queremos que la placa ejecute un programa nuevo, tenemos que enviarlo a la pizarra, que lo almacenará en la memoria flash y sobrescribe cualquier programa guardado anteriormente.

Este proceso se denomina “escritura en la memoria flash” y lo usaremos para enviar nuestro programa a la placa.

Conecta el programador a la pizarra

Para descargar programas nuevos en la placa, usaremos el programador en serie 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. Localiza el encabezado de seis pines en el costado de SparkFun Edge.
  2. Conecta el SparkFun USB-C Serial Basic a estos pines y asegúrate de que los pines tengan la etiqueta "BLK" y "GRN" de cada dispositivo estén alineados correctamente.

b140822f0019f92a.png

Conecta el programador a tu computadora

Conectaremos la placa a tu computadora mediante un cable USB. Para programar la pizarra, necesitaremos saber el nombre que le asigna tu computadora al dispositivo. La mejor manera de hacer esto es hacer una lista de todos los dispositivos de la computadora antes y después de conectarla, y ver qué dispositivo es nuevo.

Antes de conectar el dispositivo mediante USB, ejecuta el siguiente comando:

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

Se 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 tu computadora. Ingresa nuevamente 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 elemento nuevo 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 tasa de baudios, 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 tu pizarra

Para escribir la placa en la memoria flash, hay que ponerla en un bootloader que lo prepara para recibir el nuevo objeto binario. Luego, ejecutaremos una secuencia de comandos para enviar el objeto binario al tablero.

Conozcamos los siguientes botones de la pizarra:

64c620570b9d2f83.png

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

  1. Asegúrate de que la placa esté conectada al programador y que toda la configuración esté conectada a la computadora por USB.
  2. Comienza presionando el botón marcado como 14 en la pizarra. Mantén presionado hasta el paso 6.
  3. Mientras mantienes presionado el botón marcado 14, haz clic en el botón marcado RST para restablecer la placa a su estado de bootloader y restablecerla.
  4. Sin soltar el botón 14, pega el siguiente comando en tu terminal y presiona Intro para ejecutarlo (para tu comodidad, puedes pegar este comando en tu terminal antes de mantener presionado el botón, pero no presiones Intro hasta llegar 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 como 14, ahora deberías ver en la pantalla algo como lo siguiente:
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. Detente y mantén presionado el botón marcado como 14 en el tablero después de ver Sending Data Packet of length 8180 (pero no pasa nada si lo mantienes presionado). El programa seguirá imprimiendo líneas en la terminal. Con el tiempo, se verá similar a lo siguiente:
[...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, esto indica un parpadeo correcto. Si el resultado del programa termina con un error, verifica si se imprimió Sending Reset Command. Si es así, es probable que la instalación se haya realizado correctamente a pesar del error.

En una máquina Linux, es posible que encuentres un NoResponse Error. Esto se debe a que el controlador en serie ch34x se instaló junto con el controlador en serie 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é desconectado 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: Enchufa la placa por USB y ejecuta lo siguiente:

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 utilizado no es "ch34x" (p. ej., ch341), ejecuta el siguiente comando para inhabilitar el otro controlador:

rmmod <non-ch34x driver name>

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

7. Demostración

Probar el programa

Una vez que la pizarra se haya escrito correctamente en la memoria flash, presiona el botón marcado

RST para reiniciar la placa y comenzar el programa. Si la luz LED azul comienza a parpadear, significa que el destello se realizó correctamente. De lo contrario, desplázate hacia abajo hasta la sección "¿Qué pasaría si no funcionó?" que aparece más abajo.

bf256d403a1821af.gif

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

Resultado de la detección

Color de las luces LED

"Sí"

Amarillo

"No"

Rojo

Voz desconocida

Verde

No se detecta voz

No hay luces LED encendidas

Pruébala

Acerca el tablero a tu boca y di "sí" varias veces. Verás una luz LED amarilla que parpadea. Si no sucede nada cuando respondes "sí", puedes probar lo siguiente:

  • Sostén el tablero a unos 25 cm de tu boca
  • Evita el ruido de fondo excesivo
  • Repite "sí" varias veces seguidas rápidamente (intenta decir "sí, sí, sí")

¿Qué sucede si no funciona?

A continuación, se indican algunos problemas posibles y cómo depurarlos:

Problema: Después de parpadear, 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 ninguna de estas opciones funciona, intenta escribir de nuevo en la memoria flash de la pizarra.

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 puede alimentarse a través de una computadora con el programador y el cable.

8. Cómo leer el resultado de 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 el código, puedes imprimir la información de depuración a través de la conexión en serie de la placa. Usas tu computadora para conectarte a la pizarra y mostrar los datos que está enviando.

Abre una conexión en serie

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

screen ${DEVICENAME} 115200

Es posible que al principio veas un resultado similar al siguiente: (esto solo aparece si la placa se restablece una vez que la conexión está conectada; de lo contrario, puedes comenzar a ver información de depuración).

Apollo3 Burst Mode is Available

                               Apollo3 operating in Burst Mode (96MHz)

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

 Heard yes (202) @65536ms

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

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

Cómo escribir registros de depuración

Puedes ver el código que registra esta información en el archivo command_responder.cc con el que estabas trabajando:

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 a fin de incluir información importante en tus registros:

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

Este método debería ser útil cuando realices tus propios cambios en el código de la siguiente sección.

9. Extiende el código (opcional)

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

Lee el código

Un buen lugar para comenzar a 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í.

Cuando se detecta un comando por voz, se llama al método de este archivo, RespondToCommand. El código existente enciende un LED diferente dependiendo de si se escuchó "yes", "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ó. Si marcas el primer carácter, este conjunto de sentencias if determina qué LED se ilumina.

Se llama al método RespondToCommand 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 la información de depuración (hablaremos sobre esto más adelante).
  • current_time representa la hora en que se detectó el comando.
  • found_command nos indica qué comando se detectó.
  • score nos indica qué tan seguros estamos de que detectamos un comando.
  • is_new_command nos permite saber si es la primera vez que escuchas el comando.

score es un número entero entre 0 y 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 LED. En este momento, parpadeamos 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 LED, modifiquemos el programa para usarlos como un indicador visual del score de un comando determinado. Si la puntuación es baja, se encenderá una sola luz LED, mientras que una puntuación alta hará que se usen varias luces.

Para asegurarnos de saber si el programa se está ejecutando, haremos que la luz LED roja destelle de forma continua en lugar de la azul. Se usarán las luces LED azules, verdes y amarillas adyacentes para mostrar la intensidad de nuestra score más reciente. Y por cuestiones de simplicidad, solo encenderemos esas luces LED si la palabra "yes" (sí) en voz alta. Si se detecta otra palabra, las luces LED se borrarán.

Para realizar este cambio, reemplaza todo el código de tu archivo command_responder.cc con 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, volveremos a encenderlas según los valores de found_command y score.

Recompilación y escritura en la memoria flash

Una vez que hayas realizado los cambios en el código, ejecuta todos los pasos de Compila y prepara el objeto binario para probarlo.

10. Próximos pasos

Felicitaciones, creaste 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 los microcontroladores es nueva y emocionante, y ¡te animamos a que salgas a experimentar!

Documentos de referencia

26699b18f2b199f.png

Gracias y que te diviertas creando.