Controlador de retransmissão Alexa Raspberry Pi: 6 etapas

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

Criei este Instructable para compartilhar minhas experiências com a integração de dispositivos IOT com Alexa da Amazon.

Este projeto permite que uma placa de relé conectada a um pi de framboesa seja controlada a partir do controlador smarthome.

Foi testado com Alexa, mas também parece funcionar bem com Samsung Smartthings e outras interfaces de controle, pois emula uma série de soquetes Belkin Wemo.

Existem MUITOS exemplos baseados no excelente código FAUXMO, mas isso significava aprender Python e não me deu o controle detalhado que eu precisava para meus dispositivos, então decidi recriar um do zero usando C como minha linguagem de codificação base.

Eu também não queria ir às profundezas do código lambda na Amazon.com, então mantive-o bem simples.

Eu postei a fonte e as notas no Github:

github.com/Switchdoctorstu/StuPiMo

O tutorial é realmente para cobrir como fazê-lo funcionar e publicar minhas notas caso isso ajude outras pessoas.

Etapa 1: suprimentos e conexões

As coisas de que você precisa estão prontamente disponíveis na Amazon / EBay:

• Raspberry Pi *
• Fonte de alimentação Pi
• Conectores Dupont
• Placa de Relé
• Cabo micro USB antigo (para cortar pela metade para alimentação do cartão de retransmissão)

Qualquer Raspberry Pi funcionará, eu testei isso em um Modelo B e Zero.

* Se estiver usando Pi Zero, você precisará de um adaptador de rede OTG (a menos que compre a versão 'W' com acesso Wi-Fi)

Você precisará conectar o Pi à rede.

Use os conectores dupont para conectar a placa de relé ao Pi.

Observe que a placa de relé deve usar alimentação externa (remova o link e conecte a 5v externo). Ele funcionará com o PI, mas não é recomendado para execução em produção.

Para minha configuração, usei um HUB USB alimentado externamente. Isso fornece energia para o PI.

Também cortei a ponta de um cabo USB antigo e alimentei os relés de uma segunda conexão USB ao hub para ficar seguro. Minha versão de 'produção' usa uma pequena fonte de alimentação comutada 5V 5A. Mais uma vez, cortei um cabo USB pela metade para alimentar o Pi via Micro-USB e cortei dois dos conectores duplos para alimentar a placa de relé. Existem 4 fios no cabo USB, a maioria usa vermelho / preto para denotar a alimentação de 5v, mas em caso de dúvida, use um medidor para ter certeza de obter os fios corretos.

Os pinos de relé na placa são conectados aos pinos GPIO relevantes no cabeçalho PI.

O código permite que você escolha os pinos GPIO, mas o padrão que usei foi:

1. Pino de relé 1 - Terra
2. Relé Pino 2 - Relé 1 - GPIO 0
3. Relé Pino 3 - Relé 2 - GPIO 1
4. Relé Pino 4 - Relé 3 - GPIO 2
5. Pino 5 do relé - Relé 4 - GPIO 3
6. Pino 6 do relé - Relé 5 - GPIO 4
7. Relé Pino 7 - Relé 6 - GPIO 5
8. Pino 8 do relé - Relé 7 - GPIO 6
9. Relé Pino 9 - Relé 8 - GPIO 7
10. Pino do relé 10 - + 5v para lógica

Etapa 2: Configuração de PI

Não vou recriar um tutorial sobre como colocar seu PI em funcionamento e conectado à rede.

Existem muitos guias, incluindo um excelente instrutível em:

www.instructables.com/id/Ultimate-Raspberr…

Você precisará chegar ao ponto onde o PI é visível na rede e você pode se conectar a ele.

Não importa se é via Ethernet ou sem fio.

Este projeto pode ser concluído apenas com o Raspberry PI usando o Geany Programmers Editor, mas eu pessoalmente acho mais fácil fazer minha preparação de código em um PC usando Visual Studio ou Eclipse (ou mesmo Notepad ++) e, em seguida, enviá-lo para o PI para depuração usando um Conexão VNC. Novamente, não vou cobrir isso aqui, pois há muitos instructables excelentes sobre como configurar o VNC em um RPi.

Tudo que você precisa é chegar ao ponto em que possa fazer upload e compilar o código.

Uma observação importante é que, como o manipulador UPNP requer multicast UDP, as interfaces usadas devem ser definidas para o modo 'Promíscuo'.

Isso pode ser feito na linha de comando:

pi @ raspberrypi: ~ $ ifconfig eth0 promisc

e / ou

pi @ raspberrypi: ~ $ ifconfig wlan0 promisc

Isso precisa se tornar permanente, então editei o /etc/rc.local

sudo nano / etc / rc.local

para incluir a linha:

sudo ifconfig eth0 promisc

após o primeiro conjunto de linhas # do banner para garantir que as interfaces foram definidas na inicialização.

Etapa 3: Baixar e compilar o código

O próprio código fica em meu repositório Github;

github.com/Switchdoctorstu/StuPiMo/blob/ma…

embora existam maneiras 'corretas' de clonar o repositório. Achei mais fácil simplesmente abrir o editor Geany na área de trabalho do Pi e colar o código nele.

Da mesma forma, se você estiver usando a linha de comando;

Crie um novo diretório

mkdir Stu

Mudar para isso

cd Stu

Faça um novo arquivo de texto

nano StuPiMo.c

Copie o código do Github bruto e cole-o no novo arquivo

Salvar e sair.

Depois de ter o arquivo como um objeto de código-fonte C, você pode compilá-lo usando

gcc -o StuPiMo StuPiMo.c -l wiringPi

observe que o "-l wiringPi" é necessário para garantir que os links do compilador na biblioteca wiringPi necessária.

O código pode então ser executado usando

./StuPiMo

Novamente, se você quiser que isso seja executado na inicialização, use o comando:

sudo nano /etc/rc.local

para adicionar a seguinte linha

sudo / home / pi / Stu / StuPiMo &

ao seu arquivo /etc/rc.local. Não se esqueça de salvar seu arquivo ao sair.

Observe que o '&' é essencial para garantir que um subprocesso seja gerado para garantir que o script não esteja bloqueado neste ponto.

Etapa 4: usando

Assim que tiver o código em execução, peça a alexa para 'Descobrir dispositivos' e ela deverá encontrar todos os 8 dispositivos Wemo virtuais.

Então é só dizer: "Alexa ligue o soquete 1" ou "Alexa desligue o soquete 6" etc. e o relé relevante será alterado.

Etapa 5: Como funciona o código

O código funciona emulando uma série de dispositivos de soquete Belkin Wemo.

Para conseguir isso, ele deve lidar com 2 funções principais

• um manipulador de transmissão de descoberta UPNP
• um 'manipulador de dispositivo' (um por dispositivo virtual) para gerenciar os comandos enviados ao dispositivo e as respostas necessárias.

Um recurso 'bônus' é que também publica uma página da web para permitir o controle dos dispositivos.

Manipulador UPNP

O manipulador UPNP abre um soquete para monitorar pacotes de protocolo SSDP na porta 1900 239.255.255.250.

Ele responde a quaisquer consultas 'M-SEARCH' que chegam com um pacote de resposta de descoberta que anuncia os emuladores Wemo individuais a qualquer um que faça a pergunta.

Manipulador de dispositivo

Os manipuladores de dispositivos (um por dispositivo virtual) monitoram uma série de portas IP e respondem às solicitações.

Ele fornecerá uma resposta setup.xml quando solicitado

Servirá um arquivo de descrição do evento quando solicitado

Ele responderá a uma solicitação GETBINARYSTATE

Ele irá processar e responder a uma solicitação SETBINARYSTATE

Servidor web

O servidor web é uma rotina simples que constrói um formulário HTML contendo um botão por relé.

Ele responderá aos botões sendo pressionados e alternará o estado do relé de acordo.

Etapa 6: Personalização e nomes amigáveis

Não fiquei louco com o código para mantê-lo simples e editável.

O básico pode ser personalizado por definições no início do código:

// definições globais # define WEBPORT 5353 // porta para rodar o servidor web

#define NUMDEVICES 8 // Número de dispositivos virtuais para criar

# define PORTBASE 43450 // porta IP base para incrementar a partir de

WEBPORT é o número da porta em que o servidor da web integrado é executado. Isso poderia ser feito para sentar em 80 para tornar as coisas mais fáceis, mas descobri que entrava em conflito com o tomcat ou outros serviços executados localmente.

NUMDEVICES define o número de emuladores WEMO individuais a serem iniciados. Se você tiver uma placa de retransmissão de 2 portas, defina-a como 2, 4 portas = 4 etc.

Os nomes amigáveis para os dispositivos são definidos em uma rotina chamada setup_names:

int setup_names (char amigável [NUMDEVICES] [NAMELEN]) {int i = 0;

// use este loop

para (i = 0; i <NUMDEVICES; i ++) {

sprintf (amigável , "Soquete% d", i + 1);

}

// ou a seguinte tabela manual para preencher os nomes dos dispositivos

/*

strcpy (amigável [0], "TV do quarto");

strcpy (amigável [1], "Cobertor Elétrico");

strcpy (amigável [2], "Lâmpada do quarto");

strcpy (amigável [3], "Soquete 4");

strcpy (amigável [4], "Soquete 5");

strcpy (amigável [5], "Soquete 6");

strcpy (amigável [6], "Soquete 7");

strcpy (amigável [7], "Soquete 8");

*/

return i;

}

Usei um loop para chamar cada um dos dispositivos de 'Socket n', mas você pode excluir este loop e adicionar seus próprios nomes amigáveis (apenas certifique-se de adicionar o mesmo número de NUMDEVICES) se você excluir o / * * /

Lembre-se de recompilar o código se fizer alguma alteração.