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 |