É possível montar um sistema de automação residencial faça você mesmo com placa ESP e Raspberry Pi (RPi). Ambos oferecem conectividade Wi-Fi e podem se comunicar facilmente através de uma rede doméstica. No entanto, é necessário um protocolo de comunicação para a comunicação sem fio de dispositivos que operam em uma rede mais ampla.
Como os protocolos convencionais da Internet, como o HTTP, geralmente exigem muitos recursos para serem implementados com placas microcontroladoras, os protocolos IoT como o MQTT oferecem uma opção. MQTT é um protocolo de mensagens padrão para a Internet das Coisas.
Neste projeto, projetaremos um monitor meteorológico baseado em ESP e o configuraremos como um editor MQTT. Um corretor MQTT (ou seja, Mosquitto) será configurado no RPi para se comunicar com o dispositivo ESP. Um assinante MQTT será configurado no mesmo RPi para ler e registrar leituras de temperatura e umidade.
O sensor usado para ler a temperatura e umidade no ESP32/ESP8266 é o DHT11. DHT22 também pode ser usado se preferir.
Componentes necessários
1. Framboesa Pi x1
2. Monitor de exibição x1
3. Cabo micro-USB e adaptador de energia para Raspberry Pi x1
4. Cabo HDMI x1
5. Teclado e mouse x1
6. ESP8266/ESP32 x1
7. DHT11/DHT22 x1
8. Cabo micro USB para ESP8266/ESP32 x1
Configurando RPi como um corretor MQTT
Mosquitto, o corretor que usamos, é responsável por toda a comunicação na forma de mensagens associadas a tópicos entre clientes MQTT. O ESP32/ESP8266 está configurado como editor MQTT. O assinante está configurado no Raspberry Pi.
Certifique-se de que o RPi esteja configurado como um computador desktop. Em seguida, instale o Mosquitto nele. Para fazer isso, abra o terminal e execute este comando:
sudo apt-get instalar mosquito
Em seguida, instale o cliente de linha de comando Mosquitto executando o seguinte comando no terminal:
sudo apt-get install mosquito-clients -y
Após instalar o broker MQTT, precisaremos fazer alterações em seus arquivos de configuração. O arquivo de configuração padrão é armazenado em /etc/mosquitto/mosquitto.conf. Abra o arquivo de configuração padrão no editor nano executando o seguinte comando no terminal:
sudo nano /etc/mosquitto/mosquitto.conf
O arquivo de configuração deve ser semelhante a este…
No arquivo de configuração, desabilitaremos as configurações padrão com esta linha:
include_dir /etc/mosquitto/conf.d
para
# include_dir /etc/mosquitto/conf.d
A seguir, não permitiremos que usuários anônimos se conectem ao corretor adicionando esta linha:
permitir_anônimo falso
Teremos que definir um arquivo para salvar a senha adicionando esta linha:
password_file /etc/mosquitto/pwfile
Em seguida, definiremos a porta de escuta como 1883 adicionando esta linha:
ouvinte 1883
Salve as alterações pressionando Ctrl+S e saia pressionando Ctrl+X. O arquivo de configuração ficará semelhante a este depois de concluir essas edições…
Agora, vamos definir o nome de usuário e a senha para que os clientes MQTT possam acessar o broker MQTT. Para criar um nome de usuário ou redefinir a senha de um usuário existente, execute o seguinte comando no terminal:
sudo mosquitto_passwd -c /etc/mosquitto/pwfile
Para este projeto, definimos o nome de usuário como “neo” e a senha como “eglabs”. Certifique-se de escolher uma senha forte. Observe que quando você digita a senha, nada fica visível na janela.
Você pode remover um usuário existente executando este comando no terminal:
sudo mosquitto_passwd -d /etc/mosquitto/pwfile
Após gerar um nome de usuário e senha, reinicie o Raspberry Pi para que essas alterações tenham efeito. Para fazer isso, execute este comando no terminal:
sudo reiniciar
O corretor Mosquitto pode ser iniciado executando o seguinte comando no terminal:
sudo systemctl iniciar mosquito
Vamos garantir que o corretor Mosquitto esteja funcionando executando este comando no terminal:
sudo systemctl status mosquito
O corretor Mosquitto pode ser interrompido executando este comando no terminal:
sudo systemctl pare o mosquito
O corretor Mosquitto pode ser reiniciado executando este comando no terminal:
sudo systemctl reiniciar mosquito
O broker Mosquitto pode ser habilitado na inicialização executando este comando no terminal:
sudo systemctl habilitar mosquito
O corretor Mosquitto pode ser executado em segundo plano executando este comando no terminal:
mosquito -d
Configurando o monitor meteorológico
Configuraremos a estação meteorológica usando ESP32/ESP8266. Para fazer isso, você precisará conectar DHT11/DHT22 com ESP32/ESP8266
DHT11 fez interface com ESP32 para criar a estação meteorológica.
Configurando ESP32/ESP8266 como editor MQTT
Carregue o seguinte esboço no ESP32/ESP8266 para executar o ESP como uma estação meteorológica. Ele publicará os valores de temperatura e umidade para o corretor MQTT.
#incluir “DHT.h”
#incluir “PubSubClient.h”
#incluir “WiFi.h”
#define DHTPIN4
#define DHTTYPE DHT11
DHT dht(DHTPIN, DHTTYPE);
// Wi-fi
const char*ssid = “SSID”;
const char* wifi_password = “SENHA”;
//MQTT
const char* mqtt_server = “192.168.*.*”;
const char* umidade_topic = “umidade”;
const char* temperatura_topic = “temperatura”;
const char* mqtt_username = “neo”; //Nome de usuário MQTT
const char* mqtt_password = “eglabs”; // senha MQTT
const char* clientID = “Weather_Reporter”; //ID do cliente MQTT
// Inicializa os objetos WiFi e Cliente MQTT
WiFiClient wifiClient;
// 1883 é a porta listener do Broker
Cliente PubSubClient(mqtt_server, 1883, wifiClient);
// Função personalizada para conectar-se ao corretor MQTT via WiFi
void connect_MQTT {
Serial.print(“Conectando a “);
Serial.println(ssid);
//Conecte-se ao Wi-Fi
WiFi.begin(ssid, wifi_password);
//Aguarde até que a conexão seja confirmada
enquanto (WiFi.status ! = WL_CONNECTED) {
atraso(500);
Serial.print(“.”);
}
// Depuração – Gera o endereço IP do ESP8266
Serial.println(“WiFi conectado”);
Serial.print(“Endereço IP: “);
Serial.println(WiFi.localIP );
//Conecte-se ao corretor MQTT
if (client.connect(clientID, mqtt_username, mqtt_password)) {
Serial.println(“Conectado ao Broker MQTT!”);
}
outro {
Serial.println(“Falha na conexão com o Broker MQTT…”);
}
}
configuração vazia {
Serial.begin(9600);
dht.begin ;
}
loop vazio {
conectar_MQTT ;
Serial.setTimeout(2000);
float h = dht.readHumidity ;
float t = dht.readTemperature ;
Serial.print(“Umidade: “);
Serial.print(h);
Serial.println(”%”);
Serial.print(“Temperatura: “);
Serial.print
Serial.println(”*C”);
// MQTT só pode transmitir strings
String hs=”Hum: “+String((float)h)+” % “;
String ts=”Temp: “+String((float)t)+”C “;
// PUBLICAR no Broker MQTT (tópico = Temperatura)
if (client.publish(temperature_topic, String
Serial.println(“Temperatura enviada!”);
}
outro {
Serial.println(“Falha ao enviar temperatura. Reconectando ao MQTT Broker e tentando novamente”);
cliente.connect(clientID, mqtt_username, mqtt_password);
atraso(10); // Esse atraso garante que client.publish não entre em conflito com a chamada client.connect
cliente.publish(temperature_topic, String
}
// PUBLICAR para o MQTT Broker (tópico = Umidade)
if (client.publish(humidity_topic, String(h).c_str )) {
Serial.println(“Umidade enviada!”);
}
outro {
Serial.println(“Falha ao enviar umidade. Reconectando ao MQTT Broker e tentando novamente”);
cliente.connect(clientID, mqtt_username, mqtt_password);
atraso(10); // Esse atraso garante que client.publish não entre em conflito com a chamada client.connect
cliente.publish(humidity_topic, String(h).c_str );
}
cliente.disconnect ; // desconecta do corretor MQTT
atraso(1000*60); // imprime novos valores após 1 minuto
}
Como funciona o editor MQTT baseado em ESP
ESP32 está configurado como um editor MQTT. Para trabalhar com DHT11/DHT22, o DHT.h deve primeiro ser importado. A biblioteca PubSubClient.h também é importada para configurar o ESP32 como cliente MQTT. A biblioteca foi escrita por Nick O'Leary. Ele pode ser instalado no Arduino IDE navegando até Ferramentas->Gerenciar Bibliotecas e pesquisando por PubSubClient.
Observação:
- A biblioteca deve ser instalada antes de importá-la para o esboço. O WiFi.h deve ser importado para conectar o ESP32/ESP8266 à rede WiFi.
- O pino de saída do DHT11 se conecta ao pino D04.
- O objeto DHT é instanciado com DHTTYPE para DHT11 e DHTPIN para 4.
- O SSID e a senha do WiFi são armazenados nas variáveis SSID e wifi_password. Certifique-se de substituir “SSID” e “SENHA” por SSID e a chave de rede WiFi da sua própria rede WiFi.
- As variáveis são declaradas para armazenar o IP do servidor MQTT, os nomes dos tópicos, o nome de usuário e senha do MQTT e o ID do cliente.
- O endereço IP do corretor MQTT é igual ao endereço IP do Raspberry Pi na rede.
O endereço IP do Raspberry Pi pode ser obtido executando o seguinte comando no terminal:
nome do host -I
A primeira string obtida ao executar o comando acima é o endereço IPv4, que deve ser utilizado no sketch. Substitua o IP do servidor MQTT (“192.168.*.*”) pelo endereço IP do seu próprio Raspberry Pi.
Um objeto WiFiClient é instanciado e usado para instanciar o objeto cliente MQTT. A função connect_MQTT é definida para conectar-se à rede WiFi e ao corretor MQTT.
Na função setup , a taxa de transmissão para registrar informações no Serial Monitor do Arduino IDE é definida como 9600 e o DHT é inicializado chamando o método DHT.begin .
Na função loop , os valores de temperatura e umidade do DH11 são recuperados chamando os métodos dht.readHumidity e dht.readTemperature . Os valores recuperados são agrupados como strings e passados como mensagens para os tópicos MQTT de 'umidade' e 'temperatura', respectivamente, chamando o método client.publish .
Por último, o cliente é desconectado chamando o método client.disconnect . É fornecido um atraso de um minuto.
Configurando o assinante MQTT no RPi
Instale a biblioteca paho-mqtt para configurar o cliente MQTT no Raspberry Pi. Execute o seguinte comando no terminal para instalar esta biblioteca:
sudo pip instalar paho-mqtt
Abra o IDE Thonny e copie o seguinte código no editor:
importar paho.mqtt.client como mqtt
MQTT_ADDRESS = '192.168.*.*'
MQTT_USER = 'neo'
MQTT_PASSWORD = 'eglabs'
MQTT_TOPIC_TEMP = 'Temperatura'
MQTT_TOPIC_HUMD = 'Umidade'
def on_connect(cliente,userdata,flags,rc):
print('Conectado com código de resultado ' + str(rc))
cliente.subscribe(MQTT_TOPIC_TEMP)
cliente.subscribe(MQTT_TOPIC_HUMD)
def on_message(cliente, dados do usuário, mensagem):
imprimir(msg.topic + ' ' + str(msg.payload))
def principal :
mqtt_client = mqtt.Client
mqtt_client.username_pw_set(MQTT_USER, MQTT_PASSWORD)
mqtt_client.on_connect=on_connect
mqtt_client.on_message=on_message
mqtt_client.connect(MQTT_ADDRESS, 1883)
mqtt_client.loop_forever
se __nome__ == '__principal__':
print('Ponte MQTT para InfluxDB')
principal
Salve o script como RPI-Sub.py e execute o script.
Como funciona o assinante MQTT
O assinante MQTT no RPi é executado com a ajuda de um script Python. O script importa a biblioteca paho.mqtt.client. As variáveis são declaradas para armazenar o endereço IP do broker MQTT (que é igual ao endereço IP do RPi), o nome de usuário do MQTT, a senha do MQTT e os tópicos do MQTT.
O cliente assina dois tópicos, ‘temperatura’ e ‘umidade’, ao se conectar com a corretora. Para isso, a função on_connect é definida e chamada no loop main . As mensagens publicadas do editor MQTT baseado em ESP são impressas no console chamando a função on_message definida pelo usuário.
No loop main , o cliente MQTT é iniciado chamando o método mqtt.Client . O nome de usuário e a senha do MQTT são definidos chamando o método mqtt_client.username_pw_set . O cliente é conectado ao broker chamando o método mqtt_client.connect e entra em loop infinito chamando o método mqtt_client.loop_forever .
Ao se conectar com o broker MQTT, a função on_connect definida pelo usuário é chamada, inscrevendo-se nos respectivos tópicos. Ao receber mensagens do editor baseado em ESP, a função on_message definida pelo usuário é chamada, que imprime as mensagens no console.
Resultados
