Reconhecimento de fala com IA usando o TensorFlow Lite para microcontroladores e SparkFun Edge

1. Introdução

O que você vai criar

Neste codelab, vamos aprender a usar o TensorFlow Lite para microcontroladores e executar um modelo de aprendizado profundo na placa de desenvolvimento SparkFun Edge. Vamos trabalhar com o modelo de detecção de fala integrado do quadro, que usa uma rede neural convolucional para detectar as palavras "sim" e "não" faladas pelos dois microfones do quadro.

Machine learning em microcontroladores

O aprendizado de máquina pode ser usado para criar ferramentas inteligentes que facilitam a vida dos usuários, como o Google Assistente. Mas, muitas vezes, essas experiências exigem muita computação ou recursos que podem incluir um servidor de nuvem ou um computador desktop. No entanto, agora é possível executar a inferência de machine learning em hardware pequeno e de baixa potência, como microcontroladores.

Os microcontroladores são extremamente comuns, baratos, exigem pouquíssima energia e são muito confiáveis. Eles fazem parte de todos os tipos de dispositivos domésticos, como eletrodomésticos, carros e brinquedos. Na verdade, cerca de 30 bilhões de dispositivos com microcontroladores são produzidos a cada ano.

Ao trazer o aprendizado de máquina para microcontroladores minúsculos, podemos aumentar a inteligência de bilhões de dispositivos que usamos em nossas vidas, sem depender de hardware caro ou conexões de Internet confiáveis. Imagine dispositivos inteligentes que podem se adaptar à sua rotina diária, sensores industriais inteligentes que entendem a diferença entre problemas e operações normais, e brinquedos mágicos que ajudam as crianças a aprender de maneira divertida e agradável.

TensorFlow Lite para microcontroladores (software)

O TensorFlow é o framework de machine learning de código aberto do Google para treinar e executar modelos. O TensorFlow Lite é um framework de software, uma versão otimizada do TensorFlow, projetada para executar modelos do TensorFlow em dispositivos pequenos e relativamente de baixa potência, como smartphones.

O TensorFlow Lite para microcontroladores é um framework de software, uma versão otimizada do TensorFlow, projetada para executar modelos do TensorFlow em hardware pequeno e de baixa potência, como microcontroladores. Ele obedece às restrições exigidas nesses ambientes incorporados, ou seja, tem um tamanho binário pequeno, não requer suporte a sistemas operacionais, bibliotecas C ou C++ padrão nem alocação de memória dinâmica etc.

SparkFun Edge (hardware)

O SparkFun Edge é uma plataforma baseada em microcontrolador: um pequeno computador em uma única placa de circuito. Ele tem um processador, memória e hardware de E/S que permitem enviar e receber sinais digitais para outros dispositivos. Ele tem quatro LEDs controlados por software nas suas cores favoritas do Google.

Ao contrário de um computador, um microcontrolador não executa um sistema operacional. Em vez disso, os programas que você escreve são executados diretamente no hardware. Você escreve o código em um computador e faz o download para o microcontrolador usando um dispositivo chamado programador.

Microcontroladores não são computadores potentes. Eles têm processadores pequenos e pouca memória. Mas, como são projetados para serem o mais simples possível, um microcontrolador pode usar muito pouca energia. Dependendo do que o programa faz, o SparkFun Edge pode funcionar por semanas com uma única bateria de célula tipo moeda.

O que você vai aprender

• Compile o programa de amostra para o SparkFun Edge no seu computador
• Implantar o programa no dispositivo
• Fazer mudanças no programa e implantá-lo novamente

O que é necessário

Você vai precisar do seguinte hardware:

• Computador Linux ou MacOS
• Placa SparkFun Edge
• Programador SparkFun USB-C Serial Basic
• Cabo USB-C para USB-A. Se você estiver usando um computador USB-C, use um cabo USB-C para USB-C.
• (opcional) Bateria de lítio de célula tipo moeda de 3V e 20 mm (CR2032) para executar a inferência sem um programador e um cabo

Você vai precisar do seguinte software:

• Git (verifique se ele está instalado executando git na linha de comando)
• Python 3 (verifique se ele está instalado executando python3 ou python --version na linha de comando)
• Pip para Python 3 ( resposta útil do StackOverflow)
• Make 4.2.1 ou mais recente. Verifique se ele está instalado executando make --version na linha de comando.
• Drivers básicos seriais do SparkFun

2. Configurar o hardware

O microcontrolador SparkFun Edge vem com um binário pré-instalado que pode executar o modelo de fala. Antes de substituir isso pela nossa versão, vamos executar o modelo.

Para ligar a placa:

1. Inserir uma bateria tipo moeda no conector de bateria na parte de trás da placa (com o lado "+" da bateria voltado para cima). Se a placa veio com uma bateria já inserida, puxe a guia de plástico e empurre a bateria para garantir que ela esteja totalmente inserida.

Observação:a placa SparkFun Edge não tem um botão de desligar. Portanto, para preservar a duração da bateria, remova-a quando não estiver em uso. Para fazer isso, use um objeto pequeno, como uma caneta, um lápis ou uma pinça, para empurrar a bateria para fora do conector. Tenha cuidado para não danificar a placa nem juntar os dois lados da bateria.

2. Se você não tiver uma bateria tipo moeda, use o dispositivo programador básico serial USB-C SparkFun para alimentar a placa. Para anexar esse dispositivo ao quadro, siga estas etapas:

• Localize o conector de seis pinos na lateral do SparkFun Edge.
• Conecte o SparkFun USB-C Serial Basic a esses pinos, garantindo que os pinos marcados como "BLK" e "GRN" em cada dispositivo estejam alinhados corretamente.
• Conecte um cabo USB-C entre o SparkFun USB-C Serial Basic e o computador.

Depois de inserir a bateria ou conectar o programador USB, a placa vai ativar e começar a ouvir com os microfones. A luz azul vai começar a piscar.

O modelo de machine learning no quadro é treinado para reconhecer as palavras "sim" e "não" e para detectar a presença e a ausência de fala. Ele comunica os resultados acendendo LEDs coloridos. A tabela a seguir mostra o significado de cada cor do LED:

Resultado da detecção	Cor do LED
"Sim"	Amarelo
"Não"	Vermelho
Fala desconhecida	Verde
Nenhuma fala detectada	Nenhum LED aceso

Experimente.

Coloque a placa na frente da boca e diga "sim" algumas vezes. O LED amarelo vai piscar. Se nada acontecer quando você disser "sim", tente o seguinte:

• Segure a placa a cerca de 25 cm da boca.
• Evite ruídos de fundo excessivos
• Repita "sim" várias vezes em rápida sucessão (tente dizer "sim sim sim")

3. Configurar o software

Agora vamos fazer o download, instalar e executar o modelo de fala no microcontrolador. Para isso, primeiro faça o download do código-fonte do programa e das dependências necessárias para criá-lo. O programa é escrito em C++, que precisa ser compilado em um binário antes de ser baixado na placa. Um binário é um arquivo que contém o programa em um formato que pode ser executado diretamente pelo hardware do SparkFun Edge.

As instruções a seguir são escritas para Linux ou MacOS.

Baixe o repositório do TensorFlow

O código está disponível no repositório do TensorFlow no GitHub, no seguinte local:

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

Abra um terminal no computador, mude para um diretório em que você costuma armazenar projetos de programação, faça o download do repositório do TensorFlow e entre no diretório criado, conforme mostrado abaixo:

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

Baixar dependências do Python

Vamos usar o Python 3 para preparar o binário e gravar no dispositivo. Os scripts Python dependem da disponibilidade de determinadas bibliotecas. Execute o comando a seguir para instalar essas dependências:

pip3 install pycrypto pyserial --user

4. Criar e preparar o binário

Vamos criar o binário e executar comandos que o preparam para download no dispositivo.

Criar o binário

Para fazer o download de todas as dependências necessárias e criar o binário, execute o seguinte comando:

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

Se a build funcionar corretamente, a linha final da saída vai aparecer assim:

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 se o binário foi criado com sucesso, execute o seguinte 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"

Você vai ver Binary was successfully created impresso no console. Se você encontrar Binary is missing, houve um problema com o processo de build que vai exigir depuração.

Preparar o binário

O binário precisa ser assinado com chaves criptográficas para ser implantado no dispositivo. Agora vamos executar alguns comandos que vão assinar nosso binário para que ele possa ser baixado no SparkFun Edge.

Insira o comando a seguir para configurar algumas chaves criptográficas fictícias que podem ser usadas para desenvolvimento:

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

Agora, execute o seguinte comando para criar um binário assinado:

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

Isso vai criar o arquivo main_nonsecure_ota.bin. Agora, vamos executar outro comando para criar uma versão final do arquivo que pode ser usada para atualizar o dispositivo com o script do carregador de inicialização que usaremos na próxima etapa:

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

Agora, você tem um arquivo chamado main_nonsecure_wire.bin no diretório em que executou os comandos. Esse é o arquivo que vamos gravar no dispositivo.

5. Planeje e prepare para atualizar o binário

O que é flashing?

O SparkFun Edge armazena o programa que está executando nos 512 kilobytes de memória flash. Se quisermos que a placa execute um novo programa, precisamos enviá-lo para ela, que o armazenará na memória flash, substituindo qualquer programa salvo anteriormente.

Esse processo é chamado de "flashing", e vamos usá-lo para enviar nosso programa à placa.

Conecte o programador ao Jamboard

Para baixar novos programas na placa, vamos usar o programador serial básico USB-C da SparkFun. Esse dispositivo permite que o computador se comunique com o microcontrolador via USB.

Para anexar esse dispositivo ao quadro, siga estas etapas:

1. Localize o conector de seis pinos na lateral do SparkFun Edge.
2. Conecte o SparkFun USB-C Serial Basic a esses pinos, garantindo que os pinos marcados como "BLK" e "GRN" em cada dispositivo estejam alinhados corretamente.

Conecte o programador ao computador

Vamos conectar a placa ao computador via USB. Para programar a placa, precisamos saber o nome que o computador dá ao dispositivo. A melhor maneira de fazer isso é listar todos os dispositivos do computador antes e depois de conectar o novo e verificar qual deles é novo.

Antes de conectar o dispositivo por USB, execute o seguinte comando:

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

Isso vai gerar uma lista de dispositivos conectados semelhante a esta:

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

Agora, conecte o programador à porta USB do computador. Digite o seguinte comando novamente:

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

Você vai ver um item extra na saída, como no exemplo abaixo. O novo item pode ter um nome diferente. Esse novo item é o nome do dispositivo.

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

Observação:alguns usuários relataram que dois dispositivos aparecem na lista. Se você vir dois dispositivos, o correto para usar começa com as letras "wch", por exemplo, "/dev/wchusbserial-1450".

Primeiro, vamos criar uma variável de ambiente para identificar o nome do dispositivo:

export DEVICENAME=put your device name here

Observação:neste exemplo, o comando é: export DEVICENAME=/dev/cu.wchusbserial-1450

Em seguida, vamos criar uma variável de ambiente para especificar a taxa de transmissão, que é a velocidade em que os dados serão enviados ao dispositivo:

export BAUD_RATE=921600

Observação:se você recebeu sua placa SparkFun Edge na conferência TensorFlow Dev Summit, tem uma versão inicial do hardware que se comunica usando uma taxa de transmissão diferente. Use o seguinte comando:

export BAUD_RATE=115200

6. Atualizar o binário

Execute o script para atualizar o firmware da placa

Para atualizar a placa, é preciso colocá-la em um estado especial de "bootloader" que a prepara para receber o novo binário. Em seguida, vamos executar um script para enviar o binário à placa.

Vamos conhecer os seguintes botões no quadro:

Siga estas etapas para redefinir e atualizar a placa:

1. Verifique se a placa está conectada ao programador e se toda a configuração está conectada ao computador via USB.
2. Comece pressionando o botão marcado como 14 no tabuleiro. Continue segurando até a etapa 6.
3. Ainda pressionando o botão marcado com 14, clique no botão marcado com RST para redefinir a placa e colocá-la no estado de carregador de inicialização.
4. Ainda segurando o botão marcado com 14, cole o seguinte comando no terminal e pressione "Enter" para executá-lo. Para sua conveniência, você pode colar esse comando no terminal antes de começar a segurar o botão, mas não pressione "Enter" até chegar a esta etapa.

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

5. Ainda pressionando o botão marcado como 14, você vai ver algo parecido com o seguinte na tela:

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...]

6. Pare de pressionar o botão marcado como 14 na placa depois de ver Sending Data Packet of length 8180 (mas não tem problema se você continuar pressionando). O programa vai continuar imprimindo linhas no terminal. Ele vai ficar parecido com isto:

[...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 você vir Done, isso indica um piscar bem-sucedido. Se a saída do programa terminar com um erro, verifique se Sending Reset Command foi impresso. Se sim, o flash provavelmente foi concluído, apesar do erro.

Observação:o conteúdo a seguir é destinado apenas a usuários que têm uma máquina Linux e não conseguiram atualizar o dispositivo. Caso contrário, avance para a próxima seção.

Em uma máquina Linux, talvez você encontre um NoResponse Error. Isso acontece porque o driver serial ch34x foi instalado junto com o driver serial atual. Para resolver o problema, faça o seguinte:

Etapa 1: reinstale a versão correta da biblioteca ch34x. Verifique se o dispositivo está desconectado do computador durante a instalação.

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

Etapa 2: conecte o USB da placa e execute:

dmesg | grep "ch34x"

Você verá uma mensagem como esta:

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

Se o driver usado não for "ch34x" (por exemplo, ch341), tente desativar o outro driver executando:

rmmod <non-ch34x driver name>

Desconecte e reconecte o dispositivo e verifique se o driver usado é "ch34x".

7. Demonstração

Testar o programa

Depois que a placa for atualizada, pressione o botão marcado com .

RST para reiniciar a placa e iniciar o programa. Se o LED azul começar a piscar, a atualização foi bem-sucedida. Caso contrário, role para baixo até a seção E se não funcionar? abaixo.

O modelo de machine learning no quadro é treinado para reconhecer as palavras "sim" e "não" e para detectar a presença e a ausência de fala. Ele comunica os resultados acendendo LEDs coloridos. A tabela a seguir mostra o significado de cada cor do LED:

Resultado da detecção	Cor do LED
"Sim"	Amarelo
"Não"	Vermelho
Fala desconhecida	Verde
Nenhuma fala detectada	Nenhum LED aceso

Experimente.

Coloque a placa na frente da boca e diga "sim" algumas vezes. O LED amarelo vai piscar. Se nada acontecer quando você disser "sim", tente o seguinte:

• Segure a placa a cerca de 25 cm da boca.
• Evite ruídos de fundo excessivos
• Repita "sim" várias vezes em rápida sucessão (tente dizer "sim sim sim")

E se não funcionar?

Confira alguns possíveis problemas e como depurá-los:

Problema: depois da atualização, nenhum dos LEDs acende.

Solução:tente pressionar o botão RST ou desconecte e reconecte a placa do programador. Se nenhuma delas funcionar, tente atualizar a placa novamente.

Problema: o LED azul está aceso, mas muito fraco.

Solução:substitua a bateria, porque ela está acabando. Como alternativa, a placa pode ser alimentada por um computador usando o programador e o cabo.

8. Leia a saída de depuração (opcional)

Consulte esta seção se tiver problemas e precisar depurar seu código em detalhes. Para entender o que está acontecendo em um microcontrolador quando seu código é executado, é possível imprimir informações de depuração pela conexão serial da placa. Você usa o computador para se conectar à placa e mostrar os dados que ela está enviando.

Abrir uma conexão serial

Por padrão, nosso exemplo de código do SparkFun Edge registra todos os comandos falados, além da confiança deles. Para ver a saída do quadro, execute o seguinte comando:

screen ${DEVICENAME} 115200

Inicialmente, você pode ver uma saída semelhante a esta: (isso só aparece se a placa for redefinida depois de conectada. Caso contrário, as informações de depuração podem começar a aparecer)

Apollo3 Burst Mode is Available

                               Apollo3 operating in Burst Mode (96MHz)

Tente dar alguns comandos dizendo "sim" ou "não". Você vai ver o quadro imprimir informações de depuração para cada comando:

 Heard yes (202) @65536ms

No registro acima, yes se refere ao comando. O número 202 se refere ao nível de confiança de que o comando foi ouvido (sendo 200 o mínimo). Por fim, 65536ms se refere à quantidade de tempo que se passou desde a última redefinição do microcontrolador.

Para parar de ver a saída de depuração, pressione Ctrl+A, seguido imediatamente pela tecla K e, depois, a tecla Y.

Gravar registros de depuração

Você pode conferir o código que registra essas informações no arquivo command_responder.cc com que você estava trabalhando:

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

Para registrar dados, chame o método error_reporter->Report(). Ele oferece suporte aos tokens printf padrão para interpolação de strings, que podem ser usados para incluir informações importantes nos seus registros:

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

Esse método será útil quando você fizer suas próprias mudanças no código na próxima seção.

9. Estender o código (opcional)

Agora que você sabe como criar e atualizar o SparkFun Edge, pode começar a testar o código e implantá-lo no dispositivo para conferir os resultados.

Leia o código

Um bom ponto de partida para ler o código é o arquivo command_responder.cc..

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

Confira o arquivo no GitHub aqui (em inglês).

O método nesse arquivo, RespondToCommand, é chamado quando um comando de voz é detectado. O código atual acende um LED diferente dependendo se "sim", "não" ou um comando desconhecido foi ouvido. O snippet a seguir mostra como isso 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);
}

O argumento found_command contém o nome do comando detectado. Ao verificar o primeiro caractere, esse conjunto de instruções if determina qual LED acender.

O método "RespondToCommand" é chamado com vários argumentos:

void RespondToCommand(tflite::ErrorReporter* error_reporter,
    int32_t current_time, const char* found_command,
    uint8_t score, bool is_new_command) {

• O error_reporter é usado para registrar informações de depuração (mais sobre isso depois).
• current_time representa o horário em que o comando foi detectado.
• found_command informa qual comando foi detectado.
• score informa o nível de confiança de que detectamos um comando.
• is_new_command informa se é a primeira vez que o comando é ouvido.

O score é um número inteiro de 0 a 255 que representa a probabilidade de um comando ter sido detectado. O exemplo de código só considera um comando válido se a pontuação for maior que 200. Com base nos nossos testes, a maioria dos comandos válidos está no intervalo de 200 a 210.

Modificar o código

A placa SparkFun Edge tem quatro LEDs. No momento, estamos piscando o LED azul para indicar que o reconhecimento está em andamento. Você pode conferir isso no arquivo 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 temos um banco de quatro LEDs, vamos modificar o programa para usá-los como um indicador visual do score de um determinado comando. Uma pontuação baixa acende um LED, e uma pontuação alta acende vários.

Para garantir que o programa esteja em execução, vamos fazer o LED vermelho piscar continuamente em vez do azul. Os LEDs azuis, verdes e amarelos adjacentes serão usados para mostrar a intensidade do score mais recente. Para simplificar, só vamos acender os LEDs se a palavra "sim" for falada. Se outra palavra for detectada, os LEDs vão apagar.

Para fazer essa mudança, substitua todo o código no arquivo command_responder.cc pelo seguinte 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 um novo comando for detectado, is_new_command será verdadeiro. Vamos limpar os LEDs azul, verde e amarelo e acendê-los novamente dependendo dos valores de found_command e score.

Recompilar e atualizar

Depois de fazer as mudanças no código, teste-o executando todas as etapas em Criar e preparar o binário.

10. Próximas etapas

Parabéns! Você criou seu primeiro detector de voz em um microcontrolador.

Esperamos que você tenha gostado desta breve introdução ao desenvolvimento com o TensorFlow Lite para microcontroladores. A ideia de aprendizado profundo em microcontroladores é nova e interessante. Recomendamos que você teste essa tecnologia.

Documentos de referência

• Treine seu próprio modelo para entender diferentes comandos, agora que você já tem experiência com o programa básico. Observação: o treinamento leva algumas horas.
• Saiba mais sobre o TensorFlow Lite para microcontroladores ( site, GitHub).
• Teste outros exemplos e execute-os no SparkFun Edge, se ele for compatível.
• Consulte o livro da O'Reilly TinyML: Machine Learning with TensorFlow on Arduino and Ultra-Low Power Micro-Controllers (em inglês), que apresenta o machine learning em dispositivos pequenos e mostra vários projetos divertidos. Este codelab é baseado nos capítulos 7 e 8 do livro.

Agradecemos a atenção e divirta-se criando!