No tutorial anterior, os fundamentos da tecnologia Ethernet foram discutidos. Neste tutorial, a tecnologia Ethernet será usada para conectar uma placa Arduino pela internet com um PC. O dispositivo IOT baseado em Arduino e o PC serão configurados para se comunicar usando o protocolo MQTT via HiveMQ Broker.
Um dispositivo IOT baseado em Arduino será projetado neste projeto. O Arduino terá interface com um Arduino Ethernet Shield para conectar-se a um roteador via cabo Ethernet (Cat 5e). O modem Ethernet possui uma pilha TCP/IP e o protocolo MQTT pode ser implementado na pilha TCP/IP. Portanto, um modem Ethernet é usado para conectar o dispositivo à Internet. A placa Arduino também terá interface com um sensor de temperatura e umidade DHT-11 e um LED.
O dispositivo Arduino se comunicará com um PC remoto via corretor MQTT. Portanto, tanto o dispositivo baseado em Arduino quanto o PC atuarão como clientes MQTT. O esboço do Arduino será escrito para ler as informações de temperatura do sensor e enviá-las ao corretor MQTT. Um PC remoto configurado como outro cliente MQTT receberá as leituras de temperatura e as exibirá no navegador. Ele também controlará o LED conectado ao dispositivo IOT baseado em Arduino, enviando comandos de controle apropriados através do protocolo MQTT. O PC se conecta ao corretor usando um complemento do Chrome – MQTTLens.
Componentes necessários –
Fig. 1: Lista de componentes necessários para comunicação Arduino para PC baseada no protocolo MQTT
Software necessário –
• IDE do Arduino
• Corretor HiveMQ
• MQTTlens (complemento do Chrome)
Diagrama de bloco –
Fig. 2: Visão geral da comunicação Arduino-PC baseada no protocolo MQTT
Conexões de circuito –
Há um monitor de temperatura baseado em Arduino projetado neste projeto. O dispositivo IOT foi projetado conectando um Ethernet Shield, sensor de temperatura e umidade DHT-11 e um LED com o Arduino UNO.
Fig. 3: Protótipo de monitor de temperatura baseado em Arduino Ethernet controlado por HiveMQ Broker
O dispositivo possui as seguintes conexões de circuito –
Arduino UNO – Arduino UNO é uma das placas de prototipagem mais populares. É uma placa controladora baseada em Atmega 328 que possui 14 pinos GPIO, 6 pinos PWM, 6 entradas analógicas e interfaces UART, SPI e TWI integradas. A placa pode se comunicar com o Arduino Ethernet Shield usando a interface SPI. O Atmega 328 é o MCU instalado na placa Arduino. O controlador tem a seguinte configuração de pinos –
Fig. 4: Tabela listando a configuração dos pinos do Arduino Uno
Arduino Ethernet Shield – O Arduino combinado com o Arduino Ethernet Shield é chamado Arduino Ethernet. O Arduino Ethernet shield permite conectar o Arduino à Internet para que o Arduino possa se tornar parte da IOT e possa se comunicar com outros dispositivos na mesma rede. Ele é baseado no chip Ethernet Wiznet W5200 (de acordo com a folha de dados). O chip Ethernet fornece uma pilha de rede (IP) capaz de TCP e UDP. Ele suporta até quatro conexões de soquete simultâneas. Ele usa o barramento SPI (interface periférica serial) para se comunicar com o Arduino. Os pinos 10, 11, 12 e 13 do escudo Ethernet são usados para comunicação SPI. O Wiznet 5200 IC tem o seguinte diagrama de pinos –
Fig. 5: Diagrama de pinos do Wiznet W5200 Ethernet IC
Para mais informações sobre o IC, confira sua ficha técnica –
Folha de dados do Wiznet 5200
O Arduino pode ser conectado à blindagem Ethernet colocando a blindagem Ethernet na parte superior do Arduino UNO ou conectando fios (quando necessário!). A blindagem Ethernet é conectada ao roteador (LAN) via cabo Ethernet (Cat 5e). O Arduino está conectado ao escudo Ethernet conforme mostrado na imagem abaixo –
Fig. 6: Imagem do Arduino Ethernet Shield conectado na parte superior do Arduino UNO
Sensor DHT-11 – DHT-11 é um sensor de temperatura e umidade. O sensor DHT11 consiste em dois componentes principais – um é o componente de detecção de umidade e o outro é o sensor de temperatura NTC (ou termistor). O termistor é na verdade um resistor variável que muda sua resistência com a mudança de temperatura. Ambos detectam a temperatura e a umidade da área e fornecem saída para o IC (que é colocado na parte traseira do sensor). O sensor possui quatro pinos – VCC, Terra, saída de dados e NC. Os pinos VCC e Terra são conectados ao VCC e Terra comuns, respectivamente. O pino Data Out do sensor é conectado ao pino PD7 da placa Arduino por meio de um resistor pull-up de 10K.
Fig. 7: Diagrama de pinos do sensor de temperatura e umidade DHT-11
LED – Um LED é interligado no pino PD2 da placa Arduino. O LED é conectado com seu ânodo conectado ao pino Arduino e cátodo ao aterramento comum por meio de um resistor série de 220 ohms.
No lado do PC, instale o MQTTLens no navegador Chrome. O MQTTlens suporta o protocolo MQTT e pode ser usado para publicação e assinatura de mensagens. O cliente do PC deve receber uma ID de cliente exclusiva para que o broker MQTT possa identificar facilmente qual cliente está publicando e assinando o tópico e a carga útil. Saiba mais sobre como configurar o PC como cliente MQTT no tutorial a seguir –
Como configurar PC e celular como clientes MQTT
Aprenda sobre como criar e assinar tópicos no broker HiveMQ e publicar mensagens neles no seguinte tutorial –
Comunicação entre PC e Mobile usando o protocolo MQTT via HiveMQ Broker
Fig. 8: Protótipo de monitor de temperatura baseado em Arduino Ethernet controlado pelo corretor HiveMQ
Como funciona o circuito –
O Arduino é conectado ao roteador de internet via shield Ethernet e cabo Ethernet. A placa é configurada como um cliente MQTT pelo seu firmware. Após carregar o firmware e as conexões do circuito, o Arduino UNO está pronto para receber e enviar dados pelo protocolo MQTT do roteador de internet disponível. O cliente PC também está pronto para receber dados (temperatura e umidade) e enviar comandos de controle via add-on MQTTLens. O Arduino e os clientes PC se comunicam e enviam mensagens um ao outro por meio de um broker MQTT chamado HiveMQ.
O cliente Arduino configura-se como publicador para o tópico “current_temeprature” e como assinante para o tópico “Ethernet/LED_status”. O cliente PC configura-se como assinante para o tópico “current_temeprature” e como editor para o tópico “Ethernet/LED_status”.
O Arduino lê os valores de temperatura e umidade do sensor DHT-11. O Sensor de Temperatura e Umidade DHT11 é um sensor digital com sensor de umidade capacitivo embutido e termistor. Ele transmite uma leitura de temperatura e umidade em tempo real a cada 2 segundos. O sensor opera com alimentação de 3,5 a 5,5 V e pode ler temperatura entre 0° C e 50° C e umidade relativa entre 20% e 95%. O DHT11 detecta vapores de água medindo a resistência elétrica entre os dois eletrodos. O componente sensor de umidade é um substrato que retém a umidade com eletrodos aplicados na superfície. Quando os vapores de água são absorvidos pelo substrato, os íons são liberados pelo substrato, o que aumenta a condutividade entre os eletrodos. A mudança na resistência entre os dois eletrodos é proporcional à umidade relativa. Uma umidade relativa mais alta diminui a resistência entre os eletrodos, enquanto uma umidade relativa mais baixa aumenta a resistência entre os eletrodos. O DHT11 mede a temperatura com um sensor de temperatura NTC montado na superfície (termistor) embutido na unidade.
O sensor DHT 11 envia dados em formato digital para a placa Arduino no protocolo one-wire que deve ser implementado no lado do firmware. Primeiro, o pino de dados é configurado para entrada e um sinal de início é enviado a ele. O sinal de início compreende um LOW por 18 milissegundos seguido por um HIGH por 20 a 40 microssegundos seguido por um LOW novamente por 80 microssegundos e um HIGH por 80 microssegundos. Após enviar o sinal de início, o pino é configurado para saída digital e dados de 40 bits compreendendo a leitura de temperatura e umidade são travados. Dos dados de 5 bytes, os dois primeiros bytes são parte inteira e decimal da leitura para umidade relativa, respectivamente, o terceiro e o quarto bytes são parte inteira e decimal da leitura para temperatura e o último é o byte de soma de verificação. O protocolo one-wire é implementado no firmware usando uma biblioteca de código aberto disponível para Arduino. O Arduino também se conecta à Ethernet usando uma biblioteca de código aberto.
Os valores lidos de temperatura e umidade são enviados como mensagens para o tópico “current_temeprature”. O PC cliente recebe mensagens sobre o tema e exibe a leitura como mensagem recebida.
O PC Client após conectar-se à internet pode publicar mensagens no tópico “Ethernet/LED_status”. O PC Client deve ser operado por um humano. No tópico “Ethernet/LED_status”, a mensagem 'on' ou 'off' pode ser enviada. Se a mensagem ON for publicada pelo PC client, ela será recebida pelo Arduino client e seu código de firmware interpretará a mensagem para ligar a luz LED. Se a mensagem OFF for publicada pelo PC client, ela será recebida pelo Arduino client e seu código de firmware interpretará a mensagem para desligar a luz LED.
Guia de programação –
O Arduino é programado para ler a temperatura do sensor DHT-11, ligar e desligar o LED e se comunicar com o Ethernet Shield via interface SPI. O protocolo MQTT também é implementado dentro do código Arduino. O cliente Arduino Ethernet é conectado à rede do roteador pelo Ethernet Shield com um MAC ID exclusivo atribuído. O MAC ID (ID exclusivo) e o endereço IP do cliente Arduino Ethernet são inicializados no código da seguinte forma –
//Endereço MAC do seu dispositivo Arduino exclusivo
byte mac = {0x00, 0xAA, 0xBB, 0xCC, 0xDD, 0xEF};
//Endereço IP do shield Ethernet do Arduino
EndereçoIP(192.168.1.110);
O código a seguir é usado na função setup para iniciar a comunicação Ethernet –
//Inicia a comunicação Ethernet
Ethernet.begin(mac, ip);
O cliente Arduino Ethernet é conectado ao broker HiveMQ. O código a seguir no sketch Arduino é usado para definir o broker MQTT com o qual o Arduino tem que se comunicar.
//Inicialização do nome de domínio do broker ou servidor
const char* mqtt_server = “broker.mqtt-dashboard.com”;
O cliente Arduino é conectado ao broker MQTT chamando a seguinte função na configuração.
//ao definir a função de retorno de chamada do servidor e da mensagem, o cliente está pronto para usar
cliente.setServer(mqtt_server, 1883);
O cliente do PC é conectado à rede do roteador sem fio e também conectado ao broker HiveMQ com um ID de cliente exclusivo. Quando o cliente Arduino Ethernet é conectado ao broker MQTT, o cliente registra o tópico “current_temperature” no broker MQTT e publica continuamente a temperatura em tempo real no broker MQTT em um período repetitivo de 3 segundos. O código a seguir define para publicar tópicos no cliente Arduino –
//publica o valor da temperatura
client.publish (“temperatura_atual”, tempC);
O broker MQTT armazena a mensagem do cliente no tópico específico até e a menos que nenhum assinante tenha se inscrito naquele tópico. O cliente do PC então se inscreve no tópico “current_temperature” do broker MQTT. O broker MQTT verifica o tópico, ele é solicitado e então a mensagem com aquele tópico é entregue ao cliente do PC. O cliente do PC recebe continuamente os dados do sensor de temperatura em um período repetitivo de 3 segundos até e a menos que ele cancele a inscrição no tópico novamente. É um tipo de processo de pesquisa porque uma vez que o cliente assina o tópico, ele recebe continuamente a mensagem naquele tópico até que não cancele a inscrição no tópico novamente.
O cliente PC também registra o tópico “Ethernet/LED_status” no corretor MQTT e o cliente Arduino Ethernet assina o tópico do corretor MQTT. O código a seguir define a assinatura de tópicos no cliente Arduino –
//inscreve-se no tópico
cliente.subscribe(“Ethernet/LED_status”);
O cliente do PC obtém continuamente o valor da temperatura e verifica a faixa de temperatura. Quando a temperatura está acima de 35 °C, ele publica a mensagem 'ON' no tópico “Ethernet/LED_status” para acender o LED, se a temperatura estiver abaixo de 35 °C, ele publica a mensagem 'OFF' naquele tópico para desligar o LED. Isso é gerenciado por um operador humano. O cliente Arduino Ethernet se inscreveu no tópico, então ele aguardará a mensagem. Após receber a mensagem do broker MQTT, ele ligará ou desligará o LED de acordo. O código a seguir é usado para controlar o LED –
//O cliente recebe a mensagem e funciona de acordo
voidReceived_Message(char* tópico, byte* carga útil, comprimento interno não assinado) {
if((char)payload(0) == 'o' && (char)payload(1) == 'n') //em
digitalWrite(2, ALTO);
elseif((char)carga útil(0) == 'o' && (char)carga útil(1) == 'f' && (char)carga útil(2) == 'f') //desligado
digitalWrite(2, BAIXO);
}
Dessa forma, o Arduino Ethernet e os PC Clients se comunicam entre si por uma rede de comunicação via broker MQTT. A tecnologia Ethernet é usada para conectar o Arduino com a rede de internet enquanto o PC se conecta com o roteador por Wi-Fi. Confira o código completo para você mesmo projetar o projeto. No próximo tutorial, aprenda sobre a tecnologia GPRS e seu uso na Internet das Coisas.
Código fonte do projeto
###
//Program to
/*
* File Name - Device_communication_over_Ethernet_technology_&_MQTT_Protocol.ino
* Main Source Code for Publish temperature sensor data to PC client and controlling the LED on Arduino Ethernet client using MQTT
* Tested on ATmega328 based Arduino board running on Internal Oscillator at 16MHz
*/
//Include the Libraries
#include //include library for serial communication
#include //include library for Ethernet communication
#include //include library for MQTT pub sub protocol
#include //include library for Temperature sensor
#define DHTPIN 7 //DHT temperature sensor connected to pin 7
#define DHTTYPE DHT11 //TYPE of DHT 11 or 22
DHT dht(DHTPIN, DHTTYPE); //Create the instance of DHT
#define ledPin 2 //led connected to pin 2
char* tempC; //Variable to hold the temperature of the hall
char message_buffer(100); //initialize a buffer for incoming temperature values
byte mac = {0x00, 0xAA, 0xBB, 0xCC, 0xDD, 0xEF}; //MAC address of your unique Arduino device
IPAddress ip(192,168,1,111); //IP address of the Arduin Etherent shield
const char* mqtt_server = "broker.mqtt-dashboard.com"; //The broker or server domain name
EthernetClient ethClient; //Create an Ethernet Client class to connect to the MQTT server.
PubSubClient client(ethClient); //create the MQTT client objects
int timer1_count = 46874; //Timer1-16 bit, Required time = 3 sec, F_CPU= 16MHz
void timer1_init
{
//Initialize registers
TCCR1A = 0; //set entire TCCR1A register to 0
TCCR1B = 0; //set entire TCCR1B register to 0
//Initialize counter
TCNT1 = 0;
// Set the Compare value that
// was calculated for generating a Delay Time period
// This updates the temperature after every Delay Time Period
OCR1A = timer1_count;
//Start timer1
//Set up timer with prescaler = 1024 and CTC mode
TCCR1B = (1 << WGM12) (1 << CS12) (1 << CS10);
}
void setup {
pinMode(ledPin,OUTPUT); //configure the led pin as OUTPUT
Serial.begin(115200); //Set the baudrate of ESP8266 to show the process on serial monitor
Ethernet.begin(mac, ip); //Start the Ethernet communication
dht.begin ; //start the dht sensor to sense temperature
timer1_init ; //Initialize the timer function
//By setting server and messgae callback function, the client is ready to use
client.setServer(mqtt_server, 1883);
client.setCallback(Received_Message);
}
/*
* Function name = Received_message
* Client receives the message and functions accordingly
* Input parameter = Topic, Payload and message length
* Output parameter = void
*/
void Received_Message(char* topic, byte* payload, unsigned int length) {
Serial.print("Message arrived (");
Serial.print(topic);
Serial.print(") ");
for (int i = 0; i < length; i++) {
Serial.print((char)payload(i));
}
// Handle the message we received
// Here, we are only looking at the characters of the received message (payload(0))
// If it is on, turn the led will be on.
// If it is off, turn the led will be off.
if((char)payload(0) == 'o' && (char)payload(1) == 'n') //on
digitalWrite(2,HIGH);
else if((char)payload(0) == 'o' && (char)payload(1) == 'f' && (char)payload(2) == 'f') //off
digitalWrite(2,LOW);
Serial.println ;
}
/*
* Function Name = Reconnect
* To establish the connection of Ethernet with MQTT broker
* and Will publish and subsribe to the topic
*/
void reconnect {
// Loop until we're reconnected
while (!client.connected ) {
Serial.print("Attempting MQTT connection...");
//Attempt to connect
if (client.connect("ethClient")) {
Serial.println("connected");
//and resubscribe
client.subscribe("Ethernet/LED_status");
}
else {
Serial.print("failed, rc=");
Serial.print(client.state );
Serial.println(" try again in 5 seconds");
// Wait 5 seconds before retrying
delay(5000);
}
}
}
void loop {
//When Ethernet client will be connected to the broker,
//then call the function reconnect and publish and subscribe the data from broker.
if (!client.connected ) {
reconnect ;
}
client.loop ;
float tempF = dht.readTemperature ; //Read the temperature from DHT sensor
//There is a useful c function called dtostrf which will convert a float to a char array so it can then be printed easily.
//The format is: dtostrf(floatvar, StringLengthIncDecimalPoint, numVarsAfterDecimal, charbuf);
tempC = dtostrf(tempF,5,2,message_buffer);
// check whether the flag bit is set
// if set, it means that there has been a compare match
// and the timer has been cleared
// use this opportunity to publish the temperature value
if(TIFR1 & (1 << OCF1A))
{
//publish the temperature value
client.publish("current_temperature", tempC);
}
// wait! we are not done yet!
// clear the flag bit manually since there is no ISR to execute
// clear it by writing '1' to it (as per the datasheet)
TIFR1 = (1 << OCF1A);
}
###
Diagramas de circuito
| Diagrama de circuito-HiveMQ-controlado por corretor-Arduino-Ethernet-Monitor de temperatura |
 |
Vídeo do projeto