Vocês já devem ter percebido que eu gosto bastante de MicroPython e que tenho o hábito de criar meus próprios firmwares usando esta linguagem. Por falar nisso, nosso site tem alguns artigos que te ensinam como instalar e como usar diversas bibliotecas desta ferramenta para criar seus agentes por conta própria.
Bom, mas será que sempre preciso fazer meu próprio firmware? Não há agentes que são tão básicos e simples que poderiam ser criados de forma bem mais rápida e sem que eu precise desenvolver uma solução própria? E caso eu não saiba programar? Me dei mal?
Calma! Existe uma solução para você, que acho sensacional, e que atende pelo nome de ESPHome. Com este amigão, você não precisa saber coisa alguma de C, C++, Python… basta apenas configurar algumas poucas linhas de um arquivo de configuração, digitar um comando no Terminal e pronto, seu agente estará pronto e funcionando em um ESP32/ESP8266 como num passe de mágica.
Parece propaganda enganosa, não é? Mas você verá que não é. Neste artigo, vamos explorar um pouco desta ferramenta e criar uma aplicação básica que vai obter os dados de um sensor ultrassônico e envia-los para um tópico em um servidor MQTT. Parece uma tarefa difícil, certo? Com o ESPHome, na verdade, é bem simples!
ESPHoquê?
Então, você nunca ouviu falar do ESPHome? Vamos tentar sintetizar o que ele é em poucas palavras: trata-se de uma ferramenta que te permite criar firmwares para ESP32/ESP8266 usando apenas arquivos de configuração. O ESPHome interpreta seu arquivo de configuração, gerando o binário correspondente. Além de gerar o binário, o ESPHome também te ajuda a fazer o upload desse arquivo para o dispositivo.
Como já dissemos, o ESPHome dá suporte não apenas aos módulos de desenvolvimento baseados no ESP32 e no ESP8266, como o ESP32 DevKit V1 e o NodeMCU Lolin. Você pode instalar o firmware resultante até mesmo em uma controladora de LED, como eu já fiz em minha casa (imagem abaixo).
Aliás, eu uso o ESPHome para outras tarefas também e oportunamente as publicarei aqui no site! Ah! Você também pode instala-lo em um Sonoff Basic! Aliás, em tese, seu firmware pode ser instalado em qualquer dispositivo baseado no ESP32 ou no ESP8266!
O ESPHome é composto por diversos componentes que podem ser usados tanto isoladamente, como em conjunto para executar tarefas complexas. Aliás, a composição desses componentes é quase obrigatória, pois só um componente não fará muita coisa útil por você!
Quer ver um exemplo prático? Imagine o seguinte cenário: você acabou de comprar um ESP32 e um sensor ultrassônico para medir distâncias do modelo HC-SR04 (imagem abaixo). Agora, você quer criar um firwmare bem simples, que apenas obtém os dados desse sensor e os envia para um determinado tópico em um broker MQTT. Para realizar esta tarefa, precisaremos utilizar, de forma simplificada, três componentes do ESPHome:
- WiFi – https://esphome.io/components/wifi.html
- Sensor Ultrassônico – https://esphome.io/components/sensor/ultrasonic.html
- MQTT – https://esphome.io/components/mqtt.html
Tá parecendo simples demais pra ser verdade, não é? Então, vamos ver na prática que aí eu tenho certeza que você vai gostar do ESPHome tanto quanto eu gosto.
Preparando o Terreno
Antes de iniciarmos nosso pequeno projeto de teste, vamos ver a lista de ferramentas e peças que precisaremos?
- Python 3.X
- ESP32 DevKit V1
- Sensor Ultrassônico HC-SR04
- Jumpers
- ESPHome
- Cliente MQTT
Python 3
Inicialmente, será necessário que você tenha a versão 3.X do Python instalada em seu sistema operacional. Caso você use Linux, é bem provável que você já a tenha, mas, se não a tiver, é possível fazer isso através do gerenciador de pacotes específico da sua distribuição. Por exemplo, para o Ubuntu, você pode usar o comando sudo apt install python3.6 no Terminal.
Já no Mac, você certamente tem o Python 2.X e provavelmente precisará instalar a versão 3.X. Existem diversas formas de instalar o Python 3 no Mac! Pode ser utilizando o Homebrew ou através do pacote de instalação fornecido através do próprio site do Python em https://www.python.org/downloads/mac-osx/.
Já para o Windows 10, eu recomendo que você baixe o pacote de instalação do próprio site do Python. Eu já tentei usar o Python 3 distribuído pela Microsoft Store mas encontrei diversos problemas com essa forma de distribuição. O pacote pode ser encontrado em https://www.python.org/downloads/windows/
Instalando o ESPHome
Uma vez que você tem o Python 3.X instalado, precisamos agora instalar o próprio ESPHome. Para tal, abra o Terminal de sua preferência (no Windows, use o Windows Terminal com o PowerShell). Agora, digite o comando pip install esphome. Pronto!
Ah! Lembre de sempre verificar se há atualizações usando pip install -U esphome. É sempre bom estar em dia com as versões mais recentes do ESPHome! 🙂
O Projeto: Chocolate Forever!
Imagine que você é um chocólatra. Não pode viver sem uma boa dose de achocolatado gelado que você mesmo prepara. Para isso, você tem uma vasilha de 10 litros de chocolate em pó. Só tem um poblema: as vezes você esquece de comprar mais chocolate e repor sua vasilha. Nesses dias, você fica estressado, mal humorado, praticamente um ogro.
Você não quer ser uma pessoa rude assim, então, resolveu que vai instalar um sensor ultrassônico na tampa da vasilha. Esse sensor vai medir a distância da tampa até o conteúdo (chocolaaaaate) e enviar esse dado para um tópico de um servidor MQTT. De lá, você fará outras automações que irão te notificar do perigo iminente.
Fios, Placas, Protoboard…
Você já conhece o sensor HC-SR04? Trata-se de um sensor ultrassônico. A ideia é bem simples. Ele emite um ultrassom, aguarda que esse ultrassom encontre uma barreira, “bata” nessa barreira e volte para ele. O tempo que levou entre o envio e o retorno do ultrassom será o valor que ele te dará. Com essas informações, podemos simplesmente calcular a distância, pois sabemos a velocidade do som!
Entretanto, não vamos entrar em muitos detalhes sobre esses cálculos de distância aqui, viu? Só precisamos saber que esse sensor tem dois pinos. O pino Trigger, que solicita o envio do ultrassom, e o pino Echo, que recebe o retorno.
Vamos ver como vão ficar as conexões entre o sensor e o nosso ESP32? Dá uma olhadinha na imagem logo abaixo, que tem como ficou aqui (tá feio, né?).
Simplificando, temos as seguintes conexões:
- Trigger Pin do Sensor -> D4 (GPIO4) do ESP32
- Echo Pin do Sensor -> D2 (GPIO2) do ESP32
- Vin do Sensor -> Vin do ESP32
- GND do Sensor -> GND do ESP32
Aqui embaixo, temos a imagem do Fritzing que exemplifica visualmente como estão essas conexões.
A Mágica!
Vamos para a parte mais interessante de todas: criar nosso firmware! Para tal, precisaremos criar um arquivo no formato YAML (a pronuncia é iémô). Portanto, crie um diretório e dentro desse diretório, crie um arquivo chamado chocolate.yaml. Vamos por partes! Inicialmente, copie e cole o conteúdo abaixo.
esphome:
name: chocolate
platform: ESP32
board: esp32doit-devkit-v1
Esta primeira seção é muito importante. Além de você informar o nome do seu firmware, também define para qual plataforma ele será compilado. No nosso caso, vamos criar um firmware para um ESP32, lembra? Logo depois, definimos exatamente qual a “placa” (board) para a qual estamos fazendo nosso projeto. Como usarei um ESP32 DevKit V1, usei esp32doit-devkit-v1. A depender de qual placa de desenvolvimento você tem, a board poderá ser diferente.
Quer saber quais são as boards disponíveis para o ESP32? Dá uma olhadinha aqui ó: https://docs.platformio.org/en/latest/platforms/espressif32.html#boards.
Ué, cara, esse link é do PlatformIO. Tá errado!
Não tá, não! Por debaixo dos panos, o ESPHome usa o PlatformIO para gerar o binário do seu firmware! Engenhoso, não é? Agora, concatene o código acima com este aqui:
wifi:
ssid: "ssid"
password: "password"
Preciso explicar alguma coisa aqui? 🙂 É isso aí, estamos apenas informando os dados da conexão WiFi! Simples! Vamos então para a próxima seção.
mqtt:
broker: 192.168.25.18
port: 1883
username: user
password: password
Esse código já é um pouco mais extenso mas ainda assim muito fácil de entender. Estamos apenas definindo as informações para conectar em um servidor MQTT. Caso você não tenha um instalado em sua máquina, pode usar este broker público para seus testes (use somente para testes): test.mosquitto.org. Vamos adiante!
sensor:
- platform: ultrasonic
id: sensor_distancia
trigger_pin: 4
echo_pin: 2
update_interval: 2s
name: "Ultrasonic Sensor"
on_value:
then:
- mqtt.publish_json:
topic: home/sensores/ultrasonic
payload: |-
root["valor"] = id(sensor_distancia).state;
Agora sim, chegamos na cereja do bolo: definir os dados para que possamos conectar no sensor ultrassônico e enviar estes dados para o broker MQTT que configuramos anteriormente!
O que estamos fazendo neste trecho? Na primeira linha, definimos que queremos usar o componente sensor. Em seguida, na segunda linha, definimos que esse sensor é da plataforma ultrasonic, ou seja, um sensor ultrassônico.
A terceira linha informa um ID para este sensor (podemos usar esse ID para outras coisas, como a integração com outros componentes). Já a quarta linha e quinta linhas definem em quais pinos do ESP32 nós conectamos o Trigger e o Echo do sensor. Lembra que definimos o Trigger para o pino 4 e o Echo para o pino 2 na seção sobre pinagem?
A sexta linha determina o intervalo de tempo, em segundos, que o sensor deve ser consultado para obter as leituras. A sétima só define um nome para nosso sensor.
A oitava linha é o que o ESPHome chama de automação! Basicamente, as automações nos permitem reagir a determinados eventos. Neste caso, vamos reagir ao evento que informa que um determinado valor foi lido do sensor: on_value. Na linha seguinte, temos apenas a instrução then, que define o que faremos assim que o valor for lido.
O que será feito? Isso está na próxima linha: mqtt.publish_json. Vou colocar esse código de novo logo abaixo, para ficar mais fácil de entender. Neste trecho, estamos pedindo para publicar uma mensagem MQTT no tópico home/sensores/ultrasonic com o conteúdo de um JSON.
- mqtt.publish_json:
topic: home/sensores/ultrasonic
payload: |-
root["valor"] = id(sensor_distancia).state;
Qual o conteúdo desse JSON? Estamos definindo isso no payload. A notação |- é do YAML e serve para informar que a seguir vem um bloco (para mais detalhes consulte a documentação do YAML). Em seguida, informamos que na raiz do JSON teremos um atributo chamado valor e que ele contém do estado do sensor que tem o ID sensor_distancia.
Lembra que nós definimos o ID do sensor logo acima para ser exatamente este? Pois é, agora estamos usando a função id() para obter este sensor e ler os valores do estado dele, que é onde temos a leitura da distância.
Tudo pronto, amigos! Nosso YAML final está logo abaixo:
esphome:
name: chocolate
platform: ESP32
board: esp32doit-devkit-v1
wifi:
ssid: "ssid"
password: "password"
mqtt:
broker: 192.168.25.18
port: 1883
username: user
password: password
sensor:
- platform: ultrasonic
id: sensor_distancia
trigger_pin: 4
echo_pin: 2
update_interval: 2s
name: "Ultrasonic Sensor"
on_value:
then:
- mqtt.publish_json:
topic: home/sensores/ultrasonic
payload: |-
root["valor"] = id(sensor_distancia).state;
Muito simples, não é?
O Upload!
Ótimo, amigão, mas como eu subo isso para o ESP32? Vamos abrir um Terminal na sua máquina. Agora, digite esphome chocolate.yaml compile. Logo em seguida, dá uma olhadinha no diretório onde está esse arquivo. Apareceu um monte de pasta aí, correto? Pois é, seu binário e todas as dependências de bibliotecas externas necessárias para ele rodar estão nesses diretórios. Tudo pronto já.
Só precisamos fazer o upload com o comando esphome chocolate.yaml upload. O seu Terminal deverá ter um output parecido com o da imagem abaixo! É o PlatformIO fazendo o upload do firmware para o ESP32. Vamos conferir se funcionou mesmo? Vou usar, para isso, o aplicativo MQTT Explorer.
Dá uma olhadinha na imagem acima. Tem um monte de informação, não é? Bom, peço desculpas! É que esse aí é o meu servidor MQTT. Ele que recebe mensagens de diversos dispositivos em minha casa, por isso essa poluição toda. Só que eu marquei ali com um retângulo onde está o nosso sensor. Viu lá? ultrasonic: { “valor”: NaN }.
Ué, por que esse NaN? Mais uma vez desculpas! Quando eu tirei essa screenshot, o sensor não estava conectado no ESP32! Deu aquela preguiça danada de conectar tudo de novo só pra tirar essa screenshot! Mas, pode confiar, no seu caso, vai aparecer o valor medido exatamente no mesmo lugar.
Possíveis Problemas
Vamos aos possíveis problemas que você pode encontrar.
Não está fazendo o upload
Aqui isso acontece de vez em quando e não sei exatamente qual o problema. Pode ser o cabo USB, por exemplo. A questão é que lá pela terceira tentativa, o upload é feito. Outra questão, é que algumas placas de desenvolvimento tem um botão BOOT, que fica ao lado da entrada USB. Nesses casos, você pode apertar esse botão para colocar o ESP32 em modo de upload.
Fez o upload mas não aparece nada no servidor MQTT
Você pode conectar no dispositivo usando PuTTy e verificar se está tudo rodando por lá. Só que, para ver o log do que está sendo feito, você precisará adicionar mais um componente no seu arquivo YAML. Coisa simples, apenas coloque um logger:. Pelo log, você pode ver se não é um problema na conexão Wifi, a conexão dos pinos, a conexão com o servidor MQTT e por aí vai.