Adicionar controle Alexa personalizado ao projeto Raspberry Pi: 5 etapas

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:36

Este projeto é destinado a qualquer pessoa que tenha um projeto Raspberry Pi que usa Python e que queira adicionar controle de voz por meio de seus dispositivos Amazon Echo existentes. Você não precisa ser um programador experiente, mas deve se sentir confortável usando a linha de comando e adaptando o código existente para atender às suas necessidades.

Inicialmente, iniciei um projeto para permitir que meu Raspberry Pi fosse controlado por voz com Alexa para que pudesse aquecer água em uma chaleira a uma temperatura específica. Embora a interação que eu queria fosse bastante simples (passar um número de Alexa para o Raspberry Pi), deu muito trabalho para chegar a esse estado a partir dos tutoriais existentes. Espero que este tutorial torne esse processo o mais rápido possível para os outros.

No meu exemplo, começo com Raspberry Pi Zero W com Raspbian. Tenho um programa Python3 no meu Pi que é capaz de escrever texto em um display SPI e tenho uma sonda de termômetro que posso ler. Para você, este programa pode ser quase qualquer coisa, mas a ideia é que você possa ter alguns dispositivos de entrada que deseja ler via Alexa e / ou alguns dispositivos de saída que deseja controlar usando Alexa.

O objetivo é passar de um programa básico como o descrito acima para um dispositivo que você pode controlar facilmente com o meu Echo. Supondo que você já tenha esse hardware, este projeto não deve custar nada. No final, você chegará ao ponto em que poderá dizer coisas como:

Eu: "Alexa, peça ao meu gadget para verificar a temperatura no sensor 1."

Resposta de Alexa: "A sonda lê 72,31 graus."

ou

Eu: "Alexa, diga ao meu gadget para escrever para George Washington"

Resposta: O visor conectado ao meu Raspberry Pi agora mostra "George Washington"

Na próxima seção, descreverei o que precisa acontecer nos bastidores para que isso funcione. Se você apenas deseja que isso funcione em seu projeto e não se importa como funciona, fique à vontade para pular (embora possa dificultar se algo der errado).

Etapa 1: Plano de fundo

Nesta imagem (crédito: https://developer.amazon.com/en-US/docs/alexa/alex … podemos ver a arquitetura geral dos Gadgets Alexa.

Quando você diz algo ao seu dispositivo Echo, ele envia o áudio para a Alexa Cloud, onde é processado e uma resposta é gerada para responder a você. Quando você pergunta como está o tempo, é apenas esses dois em comunicação. Agora, suponha que você queira adicionar controle de voz a um de seus pequenos projetos em um Raspberry Pi. Processar tudo a bordo exigiria hardware significativo e uma base de código muito sofisticada para fazer as coisas andarem. Uma solução melhor seria aproveitar a Alexa Cloud, que é muito sofisticada e se tornou muito boa em lidar com padrões de fala complexos. Alexa Gadgets são uma boa maneira de fazer isso.

Um Alexa Gadget se comunica com um dispositivo Echo usando bluetooth. Uma vez que a conexão é estabelecida, os dois trocam mensagens usando a codificação UTF-8. Quando o Echo passa algo para o gadget, isso é chamado de diretiva. A outra direção é chamada de evento. Antes de entrar no fluxo exato de tudo isso, devemos apresentar outro elemento-chave: habilidades Alexa personalizadas.

Alexa permite que os desenvolvedores criem suas próprias habilidades personalizadas, o que lhes permite projetar suas próprias interações e comportamentos para uso em todos os dispositivos Echo. Por exemplo, um desenvolvedor pode criar uma habilidade personalizada para informar a distância entre dois aeroportos nos EUA. Um usuário diria: "Alexa, pergunte à minha calculadora de distâncias personalizada qual é a distância entre LAX e JFK" e ela responderia com "2475 milhas". Como isso faz? Quando um desenvolvedor cria uma habilidade customizada, ele define o que é chamado de "intents customizados" com "expressões de amostra" contendo "slots". Por exemplo, nesta habilidade eu posso ter a intenção "calc_dist" para calcular a distância entre dois pontos. Um exemplo de expressão seria "qual a distância entre {slot1} e {slot2}" ou "a distância entre {slot1} e {slot2}". Os slots mostrados entre colchetes têm tipos específicos. Nesse caso, esses tipos seriam códigos de aeroporto, como LAX, JFK, BOS, ATL. Quando um usuário pede a habilidade customizada, a Alexa Cloud tenta combinar o que o usuário diz a uma intenção customizada usando as expressões de amostra fornecidas e tenta encontrar valores de slot válidos para essa solicitação. Neste exemplo, ele descobriria que o usuário queria o intent "calc_dist" e que o slot1 é LAX e o slot2 é JFK. Nesse ponto, a Alexa Cloud passa o trabalho para o código do próprio desenvolvedor. Basicamente, ele informa ao código do desenvolvedor qual intenção recebeu e quais foram todos os valores de slot, entre outros detalhes.

O desenvolvedor decide onde seu código reside, mas uma opção muito popular é usar uma função do AWS Lambda. Se você não sabe o que é isso, é essencialmente um serviço que permite fazer upload de código que pode ser executado a qualquer momento e, em seguida, cobra apenas pela quantidade de tempo que seu código é executado. Se continuarmos com nosso exemplo, o código do desenvolvedor pode ser uma função Python que recebe os dois códigos de aeroporto, procura suas localizações, calcula as distâncias e, em seguida, envia uma resposta de volta à Alexa Cloud para falar algo ao usuário. A Alexa Cloud enviaria essas informações de fala de volta ao dispositivo do usuário e eles obteriam a resposta.

Agora podemos voltar ao gadget. Podemos criar habilidades personalizadas que são projetadas para funcionar especificamente com gadgets. Um desenvolvedor pode escrever uma habilidade que envia uma diretiva a um dispositivo conectado. Essa diretiva tem uma carga útil que pode ser usada da maneira que for necessária para o gadget. Essa habilidade também pode enviar uma diretiva e, em seguida, ouvir um evento do gadget para que o código da habilidade possa ter acesso às informações enviadas do gadget.

Estabelecer esse fluxo permite a criação de uma ferramenta muito poderosa porque dispositivos baratos podem ter a capacidade de se comunicar com o código na nuvem e responder a comandos de voz usando alguns dos melhores reconhecimentos de voz disponíveis.

Deve-se notar que a maioria das habilidades permite várias maneiras de interagir com eles. Por exemplo, um usuário pode ir direto para um intent dizendo "Alexa, pergunte à minha calculadora de distância personalizada qual é a distância entre LAX e JFK" (chamada de invocação única) ou pode simplesmente usar um intent de inicialização: "Alexa, abra minha calculadora de distância personalizada ". Este último exemplo normalmente seria seguido por Alexa respondendo com um prompt para obter mais informações. Este tutorial omite intencionalmente o suporte para o último. Mais especificamente, sem modificar a função Lambda, você só pode invocar a habilidade usando uma invocação única. Essa escolha de design permite que o modelo seja mais simples (não precisa suportar intents de inicialização ou fluxo de conversa), e descobri que geralmente desejo interagir com meus gadgets usando invocações únicas, já que geralmente são mais rápidos.

Etapa 2: registrar o gadget no console do desenvolvedor do Alexa Voice Service

A seguir está uma descrição das etapas necessárias. Criei um vídeo equivalente que mostra como fazer todas essas etapas. Você pode usar um ou ambos para concluir esta etapa.

1. Navegue para
2. Se você ainda não tem uma conta gratuita, crie uma
3. Clique em "Produtos"
4. Preencha os rótulos e selecione "Alexa Gadget"
5. Preencha o que quiser para o resto dos campos
6. Clique em Terminar

Etapa 3: Criar função AWS Lambda e habilidade personalizada

Crie habilidades personalizadas no console do desenvolvedor do Alexa Skills Kit

O código para este tutorial pode ser encontrado aqui

Antes de concluir esta etapa, você precisará criar um arquivo.zip que contém o pacote de implantação para a função AWS Lambda, conforme mostrado no tutorial aqui.

1. Baixe a pasta "lambda" do meu Github que contém "lambda_function.py" e "requirements.txt"
2. Abra o terminal e altere o diretório atual para estar dentro desta pasta.
3. Execute a seguinte sequência:

pip install -r requisitos.txt -t skill_env

cp lambda_function.py skill_env cd skill_env zip -r../../skill-code.zip

Seu arquivo.zip agora estará localizado no diretório onde a pasta lambda estava e será chamado de "skill-code.zip".

Uma observação sobre o custo de hospedagem na AWS: este tutorial requer que você tenha uma conta da AWS (para criar gratuitamente). As funções Lambda custam dinheiro, no entanto, seu preço atual na região da Virgínia do Norte é de US $ 0,000000208 por 100 ms de uso com 128 MB de memória. Para referência, cada invocação de minha habilidade fatura cerca de 800 ms de uso neste nível. Para acumular uma conta de $ 1,00USD, você teria que invocar essa função cerca de 600.000 vezes, o que (se levar 5 segundos por invocação) levaria mais de 34 dias sem parar para chamar sua função. O custo não deve ser um problema significativo, a menos que você publique sua habilidade e um grande número de pessoas comece a usá-la. Se você está preocupado em receber contas na AWS, considere configurar alarmes de uso que o notificam se o uso ultrapassar um limite definido.

A seguir está uma descrição das etapas necessárias. Criei um vídeo equivalente que mostra como fazer todas essas etapas. Você pode usar um ou ambos para concluir esta etapa.

1. Acesse https://aws.amazon.com/ e faça login no console ou crie uma conta gratuita se ainda não tiver uma
2. Pesquise e clique em Lambda em serviços
3. Clique em "Criar Função"
4. Selecione "Autor do zero", dê um nome e escolha a versão mais recente do Python 3 para o tempo de execução
5. Altere "editar código inline" para "fazer upload de um arquivo.zip" e selecione o arquivo.zip criado acima
6. Em uma nova janela, navegue para https://developer.amazon.com/alexa/console/ask e faça login
7. Clique em "Criar habilidade"
8. Rotule-o, escolha o modelo "Personalizado" e "Provisione seu próprio" e clique em "Criar habilidade"
9. Clique em "Começar do zero" e clique em "Escolher"
10. Em "Intents", clique em "Add"
11. Crie um intent personalizado chamado "alexa_to_pi" e preencha "write {person}" como um exemplo de expressão
12. Crie um slot de intenção chamado "pessoa" com o tipo "AMAZON. Person"
13. Crie um intent personalizado chamado "pi_to_alexa" e preencha "verificar a temperatura do sensor {sensor_num}
14. Faça um slot de intent chamado "sensor_num" com o tipo "AMAZON. NUMBER"
15. Em Interfaces, ative "Custom Interface Controller"
16. Em Endpoint, selecione "AWS Lambda ARN" e copie o "Your Skill ID"
17. Navegue de volta para o AWS Console
18. Clique em "Adicionar acionador"
19. Selecione "Alexa Skills Kit", marque "Enable" em Skill ID verification, cole a Skill ID que você acabou de copiar e clique em adicionar
20. Copie o Lambda ARN no canto superior direito
21. Navegue de volta para o Alexa Developer Console e cole o Lambda ARN no campo "Default Region"
22. Em Invocação, defina o Nome de Invocação da Habilidade como "meu gadget"
23. Clique em "Salvar modelo" e depois em "Construir modelo"
24. Clique em "Teste" nas guias superiores e altere o seletor de "Desligado" para "Desenvolvimento"
25. Observe que os logs para a função Lambda são encontrados no serviço "CloudWatch" na AWS.

Etapa 4: configure o código no seu Raspberry Pi

Para que seu Raspberry Pi se comunique com o dispositivo Alexa, ele precisa de algum código para facilitar a passagem de informações pelo bluetooth e a manutenção dessa conexão, além de alguns outros arquivos. A maneira mais fácil de começar a usar os arquivos mais atualizados da Amazon é clonar seu repositório Raspberry Pi Gadgets. Navegue até o diretório do seu projeto atual e execute

git clone

Isso carregará todo o repositório com todo o código necessário em seu Pi. Ele tem alguns projetos de exemplo que mostram alguns dos recursos do Alexa Gadgets. Se você quiser mais informações, consulte o leia-me na página do Github.

Execute sua função de configuração para obter tudo configurado.

cd / home / pi / Alexa-Gadgets-Raspberry-Pi-Samples

sudo python3 launch.py --setup

Siga os prompts e responda "y" quando perguntado se deseja configurar usando suas credenciais de gadget. Lembre-se do Amazon ID e do Gadget Secret ao configurar seu gadget no console do desenvolvedor, pois eles serão solicitados aqui. Escolhi o modo de transmissão "bt" para meu Raspberry Pi Zero W. BLE não é compatível com todos os dispositivos Echo mais antigos, mas você pode verificar do que seu hardware é capaz. Se você estiver usando seu Pi no modo Desktop, a Amazon recomenda clicar com o botão direito do mouse no ícone do bluetooth no canto superior direito e clicar em "Remover" Bluetooth "do painel" para evitar problemas de conectividade.

Nota: esta etapa pode demorar um pouco dependendo de quanto precisa ser instalado.

Agora você terá todos os arquivos de suporte necessários para voltar ao seu projeto e começar a adicionar as funções para permitir a comunicação com o seu Echo.

Se desejar, você pode excluir a pasta "examples" em "Alexa-Gadgets-Raspberry-Pi-Samples / src"

Você pode ter o código do projeto onde quiser, mas farei uma pasta no diretório inicial para ele, como alternativa, você pode baixar a pasta com o código do meu Github, apenas certifique-se de editar os arquivos.ini conforme descrito abaixo.

cd / home / pi

mkdir my_project cd my_project touch my_gadget.py touch my_gadget.ini

Agora criei dois arquivos em uma pasta chamada "my_project". O arquivo.ini é importante. Certifique-se de que contém o seguinte e substitua em seu ID da Amazon e segredo do gadget:

[GadgetSettings]

amazonId = INSERT_AMAZON_ID_HERE alexaGadgetSecret = INSERT_ALEXA_GADGET_SECRET_HERE [GadgetCapabilities] Custom. MyGadget = 1.0

Agora, vamos dar uma olhada no arquivo python antes de entrar nos detalhes:

import json

de agt import AlexaGadget

classe MyGadget (AlexaGadget):

def _init _ (self):

super ()._ init _ ()

def on_custom_mygadget_alexatopi (self, diretiva):

carga útil = json.loads (diretiva.payload.decode ("utf-8")) print ("Dados recebidos:" + str (carga útil)) write_text (str (carga útil ['dados'] ['pessoa'] ['valor ']))

def on_custom_mygadget_pitoalexa (self, diretiva):

carga útil = json.loads (diretiva.payload.decode ("utf-8")) print ("Dados recebidos:" + str (carga útil)) carga útil = {'dados': "A sonda lê" + str (get_temp (carga útil ['dados'] ['sensor_num'] ['valor'])) + "graus."} self.send_custom_event ('Custom. MyGadget', 'PiToAlexa', carga útil) MyGadget (). main ()

Primeiro você notará que ele chama duas funções: write_text () e get_temp (). No meu código, defino essas funções no mesmo arquivo, mas elas dependem do meu hardware, então optei por omiti-las. Anexei este arquivo com as funções definidas para apenas imprimir e retornar dados fictícios no caso de você querer executar este código exato. Eu sugeriria testar com este código exato antes de modificá-lo para trabalhar com seu projeto. Também anexei o arquivo.ini, mas certifique-se de entrar e alterar o ID e o segredo do gadget. A função superior recebe dados passados da Alexa. A função bottom recebe dados no mesmo formato, mas o dispositivo Alexa esperará cinco segundos para que um evento seja devolvido com sua própria carga útil. Essa carga útil é especial porque o dispositivo Alexa falará seu conteúdo.

Depois de ter esses arquivos, navegue até a pasta "my_project" e execute o arquivo python.

sudo reboot

cd / home / pi / my_project sudo python3./my_gadget.py

Se esta for a primeira vez que você está executando o programa, você precisará emparelhá-lo com o seu dispositivo Echo. Certifique-se de que seu dispositivo Echo esteja próximo ao Raspberry Pi, pois precisamos permitir uma conexão bluetooth.

No aplicativo Alexa em seu dispositivo móvel, clique em "dispositivos" no canto inferior direito.

Clique em "Echo & Alexa" no canto superior esquerdo.

Clique no seu dispositivo Echo.

Em "SEM FIO", toque em "Dispositivos Bluetooth".

Toque em "EMPARELHAR UM NOVO DISPOSITIVO" e você verá seu gadget na lista.

Toque no seu gadget. Você deve ver o relatório Pi que foi emparelhado com sucesso.

Enquanto observa a saída do seu Pi, tente dar um comando de voz ao Echo:

Você: "Alexa, peça ao meu gadget para verificar a temperatura do sensor um"

Se tudo funcionou corretamente, você deve ouvir:

Eco: "A sonda lê 120,505 graus."

Você: "Alexa, diga ao meu gadget para escrever para George Washington."

O Pi deve imprimir:

Dados recebidos: {'data': {'person': {'name': 'person', 'value': 'George Washington', 'confirmationStatus': 'NONE'}}}

George Washington"

Etapa 5: Concluindo

O vídeo mostrado aqui é um exemplo do gadget trabalhando com a leitura da temperatura (a mesma sonda em F vs. C) e escrevendo nomes em um display simples.

Agora que você espera ter algo funcionando, você deve tentar personalizar isso para tornar seu próprio projeto mais capaz. Lembre-se de que você pode editar facilmente os intents no Alexa Developer Console e que todos os slots usados serão passados para o seu Pi na carga útil. Além disso, você pode fazer com que Alexa diga o que quiser, apenas editando a carga útil que você passa de volta no evento do seu código Raspberry Pi.

Observe que este tutorial não pretende ser a solução final para todos os recursos que você poderia desejar com um gadget Alexa. Ele é intencionalmente limitado para fornecer a você duas funções simples para passar dados em cada direção entre Alexa e um Gadget. Se você estiver interessado em construir modelos de interação mais sofisticados, eu encorajo você a ler todos os arquivos leia-me em https://github.com/alexa/Alexa-Gadgets-Raspberry-P… e a tentar todos os exemplos que eles fornecem. Também sugiro que você leia a documentação do Alexa Gadgets Toolkit e do Alexa Skills Kit.