Integração com o contador Geiger Home Assistant: 8 etapas

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

Neste tutorial, vou mostrar como adicionar sensores personalizados ao HASS (assistente de casa), mais especificamente um contador Geiger, mas o processo é semelhante para outros sensores também.

Estaremos usando a placa NodeMCU, um contador Geiger baseado em Arduino e um assistente doméstico já instalado.

A integração será baseada em um servidor MQTT (público ou privado) e irei acompanhá-lo passo a passo com isso.

Caso você não saiba o que é assistente de casa, visite a página https://www.home-assistant.io/. É uma plataforma de automação residencial bem conhecida, muito bem mantida e altamente personalizável.

Você aprenderá sobre:

- configuração avançada para Home Assistant

- NodeMCU (placa de desenvolvimento) e como programá-lo com o Arduino IDE

- OTA (atualizações remotas) usando o IDE Arduino para a placa NodeMCU

- como conectar um dispositivo serial ao NodeMCU

- instalar manualmente um servidor MQTT no Linux (opcional)

Suposições básicas:

- você tem o Home Assistant instalado e funcionando

- você sabe um pouco sobre eletrônica

- você tem Arduino IDE instalado

Etapa 1: Peças e Ferramentas

Partes:

1. Placa NodeMCU

2. breadbord

3. fios juper macho-macho e macho-fêmea

3. cabo usb para micro usb

4. Contador Arduino Geiger com interface serial

(pesquise no Ebay por "arduino geiger couter")

5. material radioativo (opcional, uma pequena amostra de teste)

Ferramentas:

1. Arduino IDE

2. Home Assistant instalado

Etapa 2: Princípio de Trabalho

Nosso objetivo é mostrar no HomeAssistat (HASS) as leituras do contador Geiger. De um lado, temos um servidor HASS instalado e funcionando em algum lugar, pode ser um raspberry pi ou outro dispositivo e, do outro lado, temos o contador Geiger.

O contador Geiger possui uma porta serial, uma solução será conectar diretamente a porta serial ao RaspberryPi em que o HASS é executado.

Algumas razões pelas quais pode não ser uma boa ideia:

- não há espaço físico lá

- temos algum outro dispositivo na porta serial

- queremos anexar um sensor ambiental que deve ser colocado do lado de fora em vez do contador Geiger

Ok, então vamos explorar outra possibilidade de fazer a conexão via WIFI:

O HASS suporta a leitura de dados do sensor e a exibição de que por meio de um servidor MQTT, esse tipo de servidor é uma conexão de peso leve para dispositivos pequenos, um dispositivo publica uma mensagem em um "tópico" e o outro escuta nesse tópico para receber a mensagem. Portanto, a HASS ouvirá e precisamos de algo que publique a mensagem.

Nosso sensor sabe apenas se comunicar pela linha serial, então usaremos uma placa que pode ler uma linha serial e que pode se conectar por WIFI e se comunicar com o servidor MQTT. Uma placa barata que faz isso é a NodeMCU.

O NodeMCU pode ser programado com Arduino IDE. O esboço é muito simples, ele faz o seguinte:

- conecta-se a WIFI

- mantém uma conexão MQTT com o servidor e tenta a conexão novamente quando falha ou desconectada

- escuta os dados de entrada seriais como uma série de números inteiros

- quando um número inteiro chega, ele o envia por meio de MQTT para um tópico específico

Etapa 3: montar o dispositivo

Usaremos placas de ensaio e fios, então é bastante simples, temos algumas etapas:

- coloque o NodeMCU na placa de ensaio

- conecte o tubo Geiger ao contador Geiger (cuidado com a polaridade)

- VIN vai para o contador Geiger +

- GND goest to Geiger counter -

- NodeMCU D7 (pino 13) vai para Geiger TX

- NodeMCU D8 (pino 15) vai para geiger RX

- alimentar o NodeMCU por meio de micro USB do computador

Etapa 4: faça upload do código

Vamos usar o IDE Arduino e ter certeza de que temos a placa NodeMCU instalada e a biblioteca Adafruit_MQTT instalada.

1. Clone o repositório github: https://github.com/danionescu0/arduino e copie o esboço de projetos / HASSGeigerIntegration para o local do caderno de esboços do Arduino

2. Abra o Arduino IDE e instale o NodeMCU

- vá para Arquivo -> Preferências, nos URLs do Gerenciador de Placas Adicionais adicione https://arduino.esp8266.com/stable/package_esp8266com_index.json se você já tiver algo lá coloque um coma na frente e clique em ok

- em Ferramentas -> Placa -> Administrador da placa digite "nodemcu" e selecione a entrada esp8266 da Comunidade ESP8266 e pressione instalar

3. Instale Adafruit_MQTT

- vá para Ferramentas -> Gerenciar Bibliotecas -> pesquise "Adafruit_MQTT" e instale a "biblioteca Arduino MQTT"

4. Conecte o cabo USB em seu computador e configure a placa:

- vá para Ferramentas -> Placa -> selecione NodeMcu 1.0

- Ferramentas -> Porta -> sua porta USB

- deixe as outras configurações inalteradas

4. No esboço, altere suas credenciais WIFI para corresponder às suas:

#define STASSID "ssid" // Substitua por seu SSID WIFI

#define STAPSK "pass" // Substitua pela sua senha WIFI

5. Faça o upload do esboço para o seu quadro e, após o upload, reinicie o quadro a partir do botão

6. Abra o monitor serial, se tudo tiver corrido bem, você deverá ver alguma saída como esta:

Inicializando

Endereço IP: 192.168.1.168 OTA habilitado Conectando ao MQTT… MQTT conectado! {"radiação": 0,03}..

Etapa 5: configurar o HomeAssistant

Vamos supor que você tenha o assistente doméstico instalado e funcionando. No meu sistema, tenho o HASSOS versão 3.12 em um RaspberryPi. Se a sua versão do assistente doméstico for muito antiga ou muito nova, alguns recursos podem ser diferentes. Este tutorial funciona com certeza com a versão 3.12.

Se você não tem o Home Assistant instalado, verifique o guia oficial de instalação:

Antes de avançar com a instalação, certifique-se de que o NodeMCU está conectado e publicando dados.

Ok, teremos uma série de etapas aqui também para a configuração:

1. Instale o "editor de arquivos" se não o tiver no menu, aqui está o tutorial oficial:

2. Edite o arquivo "/config/configuration.yaml", adicione o seguinte e salve-o

- a seção mqtt se você ainda não a tiver

mqtt:

broker: broker.hivemq.com discovery: true discovery_prefix: ha

- a seção de sensores

sensor:

- plataforma: nome mqtt: "Radiação" state_topic: "ha / radiação" unit_of_measurement: 'uSv' unique_id: "radiação" value_template: "{{value_json.radiation}}"

3. Em Configuração -> Controles do servidor: pressione "Verificar configuração", verifique se há erros no arquivo de configuração yaml e, em seguida, pressione "reiniciar" e espere até que seja reiniciado

4. Em Visão geral -> menu do canto superior direito -> Configurar IU -> pressione o botão + no canto inferior direito

5. Selecione "sensor" na lista -> no campo "entidade" procure por "sensor.radiação", no campo nome escreva "Radiação" e clique em ok, deve estar na página principal agora

Etapa 6: Configurando Seu Próprio Servidor MQTT [Opcional]

Vamos discutir um pouco sobre MQTT

“MQTT é um protocolo de transporte de mensagens de publicação / assinatura do Client Server. É leve, aberto, simples e projetado para ser fácil de implementar. Essas características o tornam ideal para uso em muitas situações, incluindo ambientes restritos, como para comunicação em contextos Machine to Machine (M2M) e Internet of Things (IoT), onde uma pequena pegada de código é necessária e / ou a largura de banda da rede é preciosa.”

Citação da especificação oficial MQTT 3.1.1.

Então, basicamente, podemos publicar uma mensagem em algum lugar de um lado e do outro lado podemos ouvir essas mensagens e fazer algo com os dados. "Tópicos" de suporte MQTT, tópicos são sequências que o broker usa para filtrar mensagens para cada cliente, portanto, se publicarmos uma mensagem no tópico "/ radiação", um ouvinte deverá se inscrever no mesmo tópico para obter as mensagens que estamos enviando.

Aqui está um ótimo tutorial sobre MQTT em detalhes:

Usando o servidor hive gratuito, existem algumas desvantagens, como:

- qualquer pessoa que ouvir seu tópico receberá suas mensagens

- se ele cair ou exigir pagamento posteriormente, você não poderá usá-lo (a menos que você pague)

- se alguém que publicar mensagens no mesmo tópico, você também receber suas mensagens, poderá publicar mensagens incompatíveis e quebrar seus gráficos HASS

Usando um servidor privado

Se você não quiser usar o servidor público gratuito, você tem a opção de um servidor privado. Vamos instalar o Mosquitto MQTT em um servidor ubuntu / debian como um raspberry pi ou computador.

Mosquitto é um servidor que implementa o protocolo MQTT e é gratuito.

Para instalá-lo, faça login em seu raspnerry pi ou outro servidor debian e execute:

atualização do apt sudo

sudo apt install -y mosquitto mosquitto-clients sudo systemctl enable mosquitto.service

Isso atualizará o repositório, instalará o servidor e o cliente do mosquiito e permitirá que um serviço seja executado na inicialização

Para fazer com que o ip do servidor execute:

hostname -I

e vai gerar algo como:

192.168.1.52 172.17.0.1 172.18.0.1

Então meu ip é 192.168.1.52, nos comandos abaixo substitua-o pelo seu próprio ip

Você pode testar o servidor MQTT publicando uma mensagem e recebendo-a com a ferramenta do console, para esses dois terminais deve ser aberto um que atenda a mensagem, outro que publicará a mensagem.

Primeiro, em um terminal, execute este comando para ouvir uma mensagem em "/ algum-tópico"

mosquitto_sub -h 192.168.1.52 -t / algum-tópico

Abra outro terminal e publique uma mensagem nesse tópico:

mosquitto_pub -h 192.168.1.52 -t / algum-tópico -m '{"umidade": 74,0}'

No primeiro terminal você deve ver '{"umidade": 74.0}' impresso.

Atenção especial:

- esta configuração assume que HASS, Mosquitto e NodeMCU estão conectados à mesma rede WIFI e não há regras de firewall e podem se comunicar livremente

- o servidor Mosquitt MQTT não tem nome de usuário / senha, se você deseja configurar as credenciais, verifique: https://www.steves-internet-guide.com/mqtt-username-password-example/ Além disso, você precisa configurar as credenciais no Home Assistant e no esboço do Arduino

Etapa 7: OTA (atualizações pelo ar) para o NodeMCU

As atualizações sem fio significam que a placa de desenvolvimento pode ser flasheada sem fio sem a necessidade de um cabo físico.

Arduino IDE oferece suporte a essa funcionalidade para a série ESP8266 e algumas outras placas:

- requer flash inicial no cabo USB

- cria uma porta virtual sobre WIFI e é visível apenas no Arduino IDE

- nenhuma informação de depuração serial está disponível

- suporta proteção com senha

Para habilitar OTA em um esboço ESP8266, primeiro inclua a biblioteca:

#include "ArduinoOTA.h"

Defina também esta constante de senha de esboço:

#define SKETCHPASS "alguma_senha"

Na seção de configuração, adicione estas linhas:

while (WiFi.waitForConnectResult ()! = WL_CONNECTED) {

Serial.println ("Falha na conexão! Reinicializando…"); atraso (5000); ESP.restart (); } ArduinoOTA.setPassword (SKETCHPASS); ArduinoOTA.onStart ( () {String type; if (ArduinoOTA.getCommand () == U_FLASH) {type = "sketch";} else {// U_FS type = "filesystem";} Serial.println ("Começar a atualizar "+ tipo);}); ArduinoOTA.onEnd ( () {Serial.println ("\ nEnd");}); ArduinoOTA.onProgress ( (progresso int não assinado, total int não assinado) {Serial.printf ("Progresso:% u %% / r", (progresso / (total / 100)));}); ArduinoOTA.onError ( (ota_error_t erro) {Serial.printf ("Erro [% u]:", erro); if (erro == OTA_AUTH_ERROR) {Serial.println ("Falha");} outra autenticação if (erro == OTA_BEGIN_ERROR) {Serial.println ("Begin Failed");} else if (error == OTA_CONNECT_ERROR) {Serial.println ("Connect Failed");} else if (error == OTA_RECEIVE_ERROR) {Serial.println (" Falha no recebimento ");} else if (erro == OTA_END_ERROR) {Serial.println (" Falha no final ");}}); ArduinoOTA.begin (); Serial.print ("endereço IP:"); Serial.println (WiFi.localIP ());

E na seção de loop adicione esta linha:

ArduinoOTA.handle ();

Após o upload do código inicial após a inicialização da placa, você deve ver no IDE do Arduino na seção Ferramentas-> Porta dois tipos de portas:

Portas seriais: / dev / ttyUSB0 (por exemplo)

Portas de rede: esp8266-xxxxx em 192.168.1.xxx

Agora você pode selecionar a porta de rede e fazer o upload do esboço remoto, será solicitada a senha do esboço (aquela que você definiu em uma constante acima)

Etapa 8: Conclusões, Trabalho Futuro

Este tutorial pode ser facilmente modificado para enviar dados sobre outros tipos de sensores:

- se o seu sensor for diretamente suportado pelo NodeMCU por meio de uma biblioteca, apenas reúna os dados do sensor e envie-os diretamente através do MQTT

- se a biblioteca de sensores não funciona com NodeMCU, mas é apenas para Arduino, então carregue seu código para o arduino, envie o valor através da linha serial e leia no NodeMCU e empurre-o (assim como fizemos com o contador Geiger)

Podemos até modificá-lo para enviar dados de vários sensores, como:

- conecte seus sensores ao NodeMCU

- dados de pesquisa de cada sensor

- para cada sensor publique os dados em um tópico diferente

- no HASS definir vários sensores (como fizemos com o Geiger) que ouvirão diferentes tópicos