Super Simple Raspberry Pi 433 MHz Domótica: 7 etapas

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

Este tutorial é um entre muitos quando se trata de usar um Raspberry Pi para controlar dispositivos sem fio em casa. Como muitos outros, ele mostrará como usar um par transmissor / receptor barato conectado ao seu Pi para interagir com dispositivos operando na faixa de frequência de rádio de 433 MHz comumente usada. Ele mostrará especificamente como ligar ou desligar qualquer dispositivo elétrico usando seu Pi, transmitindo comandos para um conjunto de tomadas de 433 MHz controladas remotamente.

Por que criei este tutorial se já existem tantos? Principalmente porque quase todos os outros tutoriais que encontrei pareciam complicar as coisas, especialmente no lado do software. Percebi que eles dependiam muito de bibliotecas, scripts ou fragmentos de código de terceiros para fazer todo o trabalho. Muitos nem mesmo explicariam o que o código subjacente estava fazendo - eles apenas pediam que você enfiasse dois ou três softwares em seu Pi e executasse um monte de comandos, sem fazer perguntas. Eu realmente queria tentar usar meu Pi para ligar e desligar dispositivos elétricos em minha casa usando um conjunto de tomadas de controle remoto de 433 MHz, mas queria criar minha própria versão do sistema que pudesse entender, eliminando a necessidade de usar as bibliotecas ou scripts de outra pessoa.

É disso que trata este tutorial. O lado do software deste sistema consiste em dois scripts Python muito simples - um para receber e gravar sinais e outro para transmitir esses sinais de volta aos soquetes de energia sem fio. A recepção / transmissão real do sinal depende apenas da biblioteca RPi. GPIO fácil de usar que, pelo menos para mim, vem pré-instalada com Raspbian. Essa biblioteca também pode ser importada diretamente para o Python.

Para este projeto, você precisará de:

A Raspberry Pi. Qualquer modelo deve funcionar, usei um kit inicial completo, mas talvez você precise apenas da unidade central

Um par transmissor / receptor de 433 MHz. Os mais comumente usados neste tipo de projeto parecem ser estes. Comprar um pacote de cinco como o vinculado garante que você tenha alguns sobressalentes

Um conjunto de tomadas elétricas de 433 MHz com controle remoto. Eu usei estes que recomendo, mas existem inúmeros modelos disponíveis. Certifique-se de que operam nesta frequência

Alguns acessórios de construção de circuitos. Eu recomendo usar uma placa de ensaio e alguns cabos jumper para tornar o processo de construção do circuito o mais fácil possível.

[Se você decidir comprar qualquer um desses produtos, eu agradeceria muito se você acessasse as listagens usando os links acima - assim, eu recebo uma pequena parte dos lucros sem nenhum custo extra para você!]

Etapa 1: Configurando a unidade receptora

Antes de usar seu Pi para enviar comandos aos soquetes controlados remotamente, você precisa saber a quais sinais específicos eles respondem. A maioria dos soquetes de controle remoto vem com um monofone que pode ser usado para ligar ou desligar unidades específicas. No caso dos que comprei, o monofone tem quatro filas de botões ON / OFF emparelhados, cada um dos quais envia um sinal ON ou OFF para uma unidade de soquete específica.

Isso levanta uma questão - como sabemos quais botões correspondem a quais soquetes? Na verdade, isso depende do modelo que você possui. Um dos principais motivos pelos quais escolhi meu estilo específico de tomada (linkado na introdução) é que as unidades podem ser configuradas com um interruptor físico para fazer uma tomada específica responder a um determinado conjunto de botões LIGA / DESLIGA no aparelho. Isso também significa que você pode desconectar e mover as tomadas pela casa, sabendo que cada unidade sempre responderá aos mesmos sinais ON / OFF.

Depois de descobrir como seus soquetes interagem com o monofone, você precisará usar sua unidade receptora de 433 MHz (foto acima) para 'farejar' os códigos enviados pelo monofone. Depois de registrar as formas de onda desses códigos, você pode replicá-los usando Python e enviá-los usando a unidade transmissora.

A primeira coisa a fazer aqui é conectar os pinos do receptor aos pinos GPIO corretos do Pi. A unidade receptora possui quatro pinos, mas apenas três deles são necessários. Eu acho que os dois pinos centrais fornecem a mesma saída, então você só precisa se conectar a um deles (a menos que você queira transmitir os sinais recebidos para dois pinos GPIO separados).

A imagem acima resume a fiação. Cada pino do receptor pode ser conectado diretamente ao pino correspondente no Pi. Eu uso uma placa de ensaio e cabos jumper para tornar o processo um pouco mais elegante. Observe que você pode escolher qualquer pino de dados GPIO para conectar a qualquer um dos pinos do receptor central. Usei o pino marcado como '23' no cabeçalho Pi.

IMPORTANTE: Se você conectar o pino marcado '3v3' na imagem acima a um pino de tensão mais alta no Pi (por exemplo, 5v), provavelmente danificará o Pi, pois os pinos GPIO não podem tolerar tensões acima de 3v3. Alternativamente, você pode alimentá-lo com 5 V e configurar um divisor de tensão para enviar uma tensão segura para o pino DATA.

O alcance do receptor não será muito grande nesta voltagem, especialmente se uma antena não estiver conectada. No entanto, você não precisa de um longo alcance aqui - contanto que o receptor possa captar os sinais do fone quando eles estiverem próximos um do outro, isso é tudo de que precisamos.

Etapa 2: farejar os códigos do aparelho

Agora que seu receptor está conectado ao Pi, você pode iniciar o primeiro estágio emocionante deste projeto - o sniff. Isso envolve o uso do script Python anexado para registrar o sinal transmitido pelo aparelho quando cada botão é pressionado. O script é muito simples e eu recomendo fortemente que você dê uma olhada nele antes de executá-lo - afinal, o objetivo deste projeto é que você não executará cegamente o código de outra pessoa!

Antes de iniciar este processo, você precisará certificar-se de que possui as bibliotecas Python necessárias para executar o script sniffer. Eles estão listados na parte superior do script:

de datetime import datetime

import matplotlib.pyplot como pyplot import RPi. GPIO como GPIO

As bibliotecas RPi. GPIO e datetime foram incluídas na minha distribuição Raspbian, mas tive que instalar a biblioteca matplotlib da seguinte maneira:

sudo apt-get install python-matplotlib

Esta biblioteca é uma biblioteca de plotagem de gráficos comumente usada que é muito útil mesmo fora deste projeto, portanto, instalá-la definitivamente não fará mal! Assim que suas bibliotecas estiverem atualizadas, você estará pronto para começar a registrar os dados. Veja como o script funciona:

Quando for executado (usando o comando 'python ReceiveRF.py'), ele configurará o pino GPIO definido como uma entrada de dados (pino 23 por padrão). Em seguida, ele irá amostrar continuamente o pino e registrar se está recebendo um digital 1 ou 0. Isso continua por um determinado período (5 segundos por padrão). Quando esse limite de tempo for atingido, o script interromperá a gravação de dados e fechará a entrada GPIO. Em seguida, ele executa um pequeno pós-processamento e plota o valor de entrada recebido em relação ao tempo. Novamente, se você tiver dúvidas sobre o que o script está fazendo, provavelmente você mesmo poderá respondê-las depois de ver como ele funciona. Tentei tornar o código o mais legível e simples possível.

O que você precisa fazer é ficar atento quando o script indica que ** iniciou a gravação **. Assim que esta mensagem aparecer, você deve manter pressionado um dos botões do monofone por cerca de um segundo. Certifique-se de segurá-lo próximo ao receptor. Assim que o script terminar de gravar, ele usará matplotlib para traçar uma forma de onda gráfica do sinal que recebeu durante o intervalo de gravação. Observe que se você estiver conectado ao seu Pi usando um cliente SSH como o PuTTY, também precisará abrir um aplicativo X11 para permitir a exibição da forma de onda. Eu uso o xMing para isso (e para outras coisas, como a área de trabalho remota no meu Pi). Para permitir que o gráfico seja exibido, basta iniciar o xMing antes de executar o script e esperar que os resultados apareçam.

Assim que sua janela matplotlib aparecer, a área de interesse dentro do gráfico deve ser bastante óbvia. Você pode usar os controles na parte inferior da janela para aumentar o zoom até conseguir identificar os altos e baixos do sinal transmitido pelo fone enquanto o botão estava sendo pressionado. Veja a imagem acima para um exemplo de um código completo. O sinal provavelmente consistirá em pulsos muito curtos separados por períodos semelhantes de tempo em que nenhum sinal é recebido. Este bloco de pulsos curtos provavelmente será seguido por um período mais longo em que nada é recebido, após o qual o padrão se repetirá. Depois de identificar o padrão pertencente a uma única instância do código, faça uma captura de tela como essa no topo desta página e continue na próxima etapa para interpretá-lo.

Etapa 3: transcrever o sinal resultante

Agora que você identificou o bloco de altas e baixas periódicas correspondente ao sinal de um botão específico, você precisará de uma maneira de armazená-lo e interpretá-lo. No exemplo de sinal acima, você notará que existem apenas dois padrões exclusivos que compõem todo o bloco de sinal. Às vezes você vê uma alta curta seguida por uma baixa longa, e às vezes é o oposto - uma alta longa seguida por uma baixa curta. Quando estava transcrevendo meus sinais, decidi usar a seguinte convenção de nomenclatura:

1 = short_on + long_off0 = long_on + short_off

Olhe novamente para a forma de onda rotulada e você verá o que quero dizer. Depois de identificar os padrões equivalentes em seu sinal, tudo o que você precisa fazer é contar os 1s e 0s para construir a sequência. Quando transcrito, o sinal acima pode ser escrito da seguinte forma:

1111111111111010101011101

Agora você só precisa repetir este processo para gravar e transcrever os sinais correspondentes aos outros botões do seu aparelho, e você concluiu a primeira parte do processo!

Antes que você possa reenviar os sinais usando o transmissor, há um pouco mais de trabalho a fazer. O tempo entre os altos e baixos correspondentes a 1 ou 0 é muito importante, e você precisa ter certeza de que sabe quanto tempo realmente dura um 'short_on' ou 'long_off'. Para meus códigos, havia três informações de tempo que eu precisava extrair para replicar os sinais:

• A duração de um intervalo 'curto', ou seja, o início de um 1 ou o final de um 0.
• A duração de um intervalo 'longo', ou seja, o final de um 1 ou o início de um 0.
• A duração de um intervalo 'estendido'. Percebi que, quando mantive um botão pressionado no aparelho, havia um período de 'extend_off' entre cada instância repetida do bloqueio de sinal. Esse atraso é usado para sincronização e tem uma duração fixa.

Para determinar esses valores de tempo, você pode usar a função de zoom na janela matplotlib para ampliar totalmente e colocar o cursor sobre as partes relevantes do sinal. A leitura da localização do cursor na parte inferior da janela deve permitir que você determine a largura de cada parte do sinal que corresponde a um intervalo longo, curto ou estendido. Observe que o eixo x do gráfico representa o tempo e o componente x da leitura do cursor está em unidades de segundos. Para mim, as larguras foram as seguintes (em segundos):

• short_delay = 0,00045
• long_delay = 0,00090 (duas vezes mais que um 'curto')
• extended_delay = 0,0096

Etapa 4: Configurando a Unidade Transmissora

Depois de coletar seus códigos e dados de tempo, você pode desconectar sua unidade receptora, pois não precisará mais dela. Você pode então conectar o transmissor diretamente aos pinos Pi GPIO relevantes, conforme mostrado na imagem acima. Descobri que os pinos nas unidades transmissoras são etiquetados, o que torna o processo mais fácil.

Neste caso, é normal alimentar a unidade usando a alimentação de 5 V do Pi, pois o pino DATA não enviará sinais para o Pi, apenas os receberá. Além disso, uma fonte de alimentação 5v fornecerá mais alcance de transmissão do que usar a fonte 3v3. Novamente, você pode conectar o pino DATA a qualquer pino apropriado no Pi. Usei o pino 23 (o mesmo do receptor).

Outra coisa que eu recomendo fazer é adicionar uma antena ao pequeno orifício no canto superior direito do transmissor. Usei um pedaço de arame reto de 17 cm de comprimento. Algumas fontes recomendam um fio enrolado de comprimento semelhante. Não tenho certeza do que é melhor, mas o fio reto fornece alcance suficiente para ligar / desligar os soquetes de qualquer local do meu pequeno apartamento. É melhor soldar a antena, mas acabei de remover um pouco do plástico do fio e enrolei o cobre pelo orifício.

Assim que o transmissor estiver conectado, toda a configuração do hardware estará concluída! A única coisa que falta fazer agora é instalar as tomadas pela casa e dar uma olhada no programa do transmissor.

Etapa 5: transmissão de sinais usando o Pi

É aqui que entra o segundo script Python. Ele foi projetado para ser tão simples quanto o primeiro, se não mais. Novamente, faça o download e examine o código. Você precisará editar o script para transmitir os sinais corretos de acordo com os dados registrados na etapa 3, então agora é um bom momento para dar uma olhada rápida nele.

As bibliotecas necessárias para executar este script foram todas pré-instaladas no meu Pi, portanto, nenhuma instalação adicional foi necessária. Eles estão listados na parte superior do script:

tempo de importação

import sys import RPi. GPIO as GPIO

Abaixo das importações da biblioteca estão as informações que você terá que editar. Esta é a aparência padrão (esta é a informação correspondente aos meus soquetes, conforme determinado na etapa 3):

a_on = '1111111111111010101011101'

a_off = '1111111111111010101010111' b_on = '1111111111101110101011101' b_off = '1111111111101110101010111' c_on = '1111111111101011101011101' c_off = '1111111111101011101010111' d_on = '1111111111101010111011101' d_off = '1111111111101010111010111' short_delay = 0,00045 = 0,00090 long_delay extended_delay = 0,0096

Aqui temos oito strings de código (duas para cada par de botões liga / desliga em meu aparelho - você pode ter mais ou menos códigos) seguidas pelas três informações de tempo também determinadas na etapa 3. Reserve um tempo para ter certeza de que inseriu essas informações corretamente.

Quando estiver satisfeito com os códigos / atrasos inseridos no script (você pode renomear as variáveis da string de código, se desejar), você estará pronto para experimentar o sistema! Antes de fazer isso, dê uma olhada na função transmit_code () no script. É aqui que ocorre a interação real com o transmissor. Esta função espera que uma das strings de código seja enviada como um argumento. Em seguida, ele abre o pino definido como uma saída GPIO e faz um loop por cada caractere na string de código. Em seguida, ele liga ou desliga o transmissor de acordo com as informações de tempo que você inseriu para construir uma forma de onda que corresponda à string de código. Ele envia cada código várias vezes (10 por padrão) para reduzir a chance de ser perdido e deixa um atraso estendido entre cada bloco de código, assim como o aparelho.

Para executar o script, você pode usar a seguinte sintaxe de comando:

python TransmitRF.py code_1 code_2…

Você pode transmitir várias sequências de código com uma única execução do script. Por exemplo, para ativar os soquetes (a) e (b) e desativar o soquete (c), execute o script com o seguinte comando:

python TransmitRF.py a_on b_on c_off

Etapa 6: uma nota sobre a precisão do tempo

Conforme mencionado, o tempo entre os pulsos de ativação / desativação transmitidos é muito importante. O script TransmitRF.py usa a função time.sleep () do python para construir as formas de onda com os intervalos de pulso corretos, mas deve-se observar que essa função não é totalmente precisa. O comprimento pelo qual ele faz com que o script espere antes de executar a próxima operação pode depender da carga do processador naquele determinado instante. Essa é outra razão pela qual TransmitRF.py envia cada código várias vezes - apenas no caso de a função time.sleep () não ser capaz de construir adequadamente uma determinada instância do código.

Eu pessoalmente nunca tive problemas com time.sleep () quando se trata de enviar os códigos. No entanto, sei que meu time.sleep () tende a apresentar um erro de cerca de 0,1 ms. Eu determinei isso usando o script SleepTest.py anexado, que pode ser usado para dar uma estimativa de quão precisa é a função time.sleep () de seu Pi. Para meus soquetes controlados remotamente específicos, o menor atraso que precisei implementar foi de 0,45 ms. Como eu disse, não tive problemas com soquetes que não respondiam, então parece que 0,45 ± 0,1ms é bom o suficiente.

Existem outros métodos para garantir que o atraso seja mais preciso; por exemplo, você poderia usar um chip PIC dedicado para gerar os códigos, mas coisas assim estão além do escopo deste tutorial.

Etapa 7: Conclusão

Este projeto apresentou um método para controlar qualquer aparelho elétrico usando um Raspberry Pi e um conjunto de tomadas de 433 MHz com controle remoto, com foco na simplicidade e transparência. Este é o projeto mais excitante e flexível para o qual usei meu Pi, e há aplicações ilimitadas para ele. Aqui estão algumas coisas que posso fazer graças ao meu Pi:

• Ligue um aquecedor elétrico ao lado da minha cama meia hora antes de meu alarme tocar.
• Desligue o aquecedor uma hora depois de dormir.
• Acenda minha luz de cabeceira quando meu despertador tocar para que eu não volte a dormir.
• e muitos mais…

Para a maioria dessas tarefas, uso a função crontab no Linux. Isso permite que você configure tarefas agendadas automáticas para executar o script TransmitRF.py em horários específicos. Você também pode usar o comando Linux at para executar tarefas únicas (que, para mim, precisavam ser instaladas separadamente usando 'sudo apt-get install at'). Por exemplo, para ligar meu aquecedor meia hora antes de meu alarme tocar na manhã seguinte, tudo que preciso fazer é digitar:

às 05:30

python TransmitRF.py c_on

Você também pode usar este projeto em conjunto com meu sistema de monitoramento doméstico Dropbox para controlar aparelhos pela Internet! Obrigado pela leitura, e se você gostaria de esclarecer algo ou compartilhar sua opinião, por favor poste um comentário!