Controlando uma luz LED com PC usando HAN baseado em ESP8266 e HiveMQ Broker: IOT Parte 20

Nos tutoriais anteriores, o protocolo MQTT foi implementado para configurar a comunicação de dados entre Celular e PC, PC e PC e Celular e Celular. O verdadeiro poder dos protocolos IOT só pode ser alcançado com dispositivos IOT da vida real. Neste tutorial, será projetado um aplicativo IOT da vida real baseado no protocolo MQTT.
A Internet das Coisas tem como objetivo capacitar objetos de uso diário com eletrônica embarcada e infraestrutura de TI. Tem como objetivo conectar esses objetos em tempo real com a rede da Internet e permitir que eles se comuniquem com outros objetos co-localizados ou remotos. Para se comunicarem entre si, os dispositivos IOT precisam seguir protocolos. Um desenvolvedor de aplicativos precisa cuidar principalmente da implementação dos protocolos da camada de aplicação, enquanto normalmente a implementação dos protocolos da camada de rede e de transporte permanece nas mãos de administradores de rede ou programadores de rede. Neste projeto IOT, o protocolo MQTT será usado para conectar o dispositivo IOT projetado à Internet.
Neste projeto, uma rede doméstica simples (HAN) será projetada usando o módulo Wi-Fi ESP8266. Esta rede doméstica pode ser controlada a partir de um PC remoto usando a Internet. A rede residencial projetada neste projeto é mais simplista, com uma luz LED controlada pela Internet. Supõe-se que o PC remoto que controla a luz LED (Home Area Network) esteja instalado em um escritório distante da casa.
Portanto, o dispositivo IOT projetado neste projeto é um controlador de luz LED simples que é projetado pela interface da luz LED diretamente com o módulo Wi-Fi ESP-8266. O módulo Wi-Fi, bem como a luz LED, são alimentados continuamente com a ajuda de um conversor USB para serial. O módulo Wi-Fi precisa ser carregado com um firmware que possa interpretar os dados recebidos pela internet e usar esses dados para controlar a luz do LED. O Arduino UNO é usado para atualizar o código do firmware no módulo ESP8266. O módulo ESP também pode ser atualizado com código usando um conversor FTDI como o CP2102. O firmware em si é escrito no Arduino IDE.
O PC remoto atua como outro dispositivo IOT no projeto. O PC se conecta ao dispositivo baseado em ESP8266 por meio do corretor MQTT. O hiveMQ é usado como corretor MQTT neste projeto. O PC se conecta ao corretor usando um complemento do Chrome – MQTTLens.
Componentes necessários –
Lista de componentes necessários para controlador de luz LED baseado em ESP8266 HAN e HiveMQ Broker
Fig. 1: Lista de componentes necessários para controlador de luz LED baseado em ESP8266 HAN e HiveMQ Broker
Software necessário –
1. ArduinoIDE
2. Corretor HiveMQ
3. MQTTlens (complemento cromado)
Diagrama de bloco –
Diagrama de blocos do controlador IOT LED baseado em ESP8266
Fig. 2: Diagrama de blocos do controlador IOT LED baseado em ESP8266
Conexões de Circuito –
Primeiramente, a placa ESP8266 precisa ser carregada com o código do firmware. Neste tutorial, o código do firmware é escrito usando Arduino IDE. Ele é carregado na placa ESP8266 usando o Arduino UNO. Uma placa ESP8266 genérica é usada neste projeto. Esta placa não possui resistores de inicialização, regulador de tensão, circuito de reinicialização e adaptador serial USB. O módulo ESP8266 opera com fonte de alimentação de 3,3V com corrente maior ou igual a 250mA. Portanto, o adaptador CP2102 USB para serial é usado para fornecer tensão de 3,3 V com corrente suficiente para executar o ESP8266 de maneira confiável em todas as situações.
O Módulo Wi-Fi ESP8266 é um SOC independente com pilha de protocolo TCP/IP integrada que pode acessar uma rede Wi-Fi. O ESP8266 é capaz de hospedar um aplicativo ou descarregar todas as funções de rede Wi-Fi de outro processador de aplicativo. Cada módulo ESP8266 vem pré-programado com um firmware de conjunto de comandos AT. O módulo está disponível em dois modelos – ESP-01 e ESP-12. O ESP-12 possui 16 pinos disponíveis para interface, enquanto o ESP-01 possui apenas 8 pinos disponíveis para uso. O ESP-12 possui a seguinte configuração de pinos –
Tabela de listagem de configuração de pinos do modem Wi-Fi ESP8266 ESP-12
Fig. 3: Tabela listando a configuração dos pinos do modem Wi-Fi ESP8266 ESP-12
O modelo ESP-01 é usado no projeto. O modelo ESP-01 tem a seguinte configuração de pinos –
Tabela de listagem de configuração de pinos do modem Wi-Fi ESP8266 ESP-12
Fig. 4: Tabela listando a configuração dos pinos do modem Wi-Fi ESP8266 ESP-12
Os pinos Chip Enable e VCC do módulo são conectados a 3,3 V DC enquanto o pino Ground está conectado ao terra comum. O pino de habilitação do chip é conectado ao VCC por meio de um resistor pull up de 10K. O pino RESET é conectado ao terra por meio de uma chave tátil, onde o pino é fornecido VCC por meio de um resistor pull up de 10K por padrão. Os pinos Tx e Rx do módulo são conectados aos pinos RX e TX do Arduino UNO. O pino GPIO-0 do módulo é conectado ao terra por meio de uma chave tátil onde o pino é fornecido VCC por meio de um resistor pull up de 10K por padrão. Esses resistores pull-up atuam como circuito divisor de tensão que protege a placa ESP8266 de alta tensão. A placa Arduino opera a 5 V e também a 3,3 V, enquanto o ESP8266 opera a 3,3 V. Embora a própria placa Arduino seja alimentada por meio de seu pino de alimentação de 3,3 V, este circuito divisor de tensão adiciona ainda mais proteção contra qualquer pico de tensão. O uso de resistores pull-up aumenta a estabilidade do circuito. Com essas conexões de circuito, a própria placa Arduino atua como adaptador USB para serial. As conexões do circuito entre o módulo Arduino UNO e ESP8266 para carregamento de inicialização podem ser resumidas a seguir –
Tabela de listagem de conexões de circuito entre o modem ESP8266 e o ​​Arduino Uno
Fig. 5: Tabela listando as conexões do circuito entre o Modem ESP8266 e o ​​Arduino Uno
Durante a compilação do código, as chaves GPIO0 e RESET devem ser pressionadas. Para carregar o programa, a chave RESET deve ser liberada enquanto a chave de programação GPIO0 deve ser deixada pressionada, para que o ESP possa entrar no modo de programação. Após o upload do código, a chave de programação também deve ser liberada.
Escreva o código do firmware no Arduino IDE e conecte a placa Arduino ao PC via cabo USB. Abra o Arduino IDE e vá em Ferramentas->Porta e selecione a placa Arduino (Arduino UNO). Pode parecer /dev/ttyABM0 (Arduino/Genuino Uno). Selecione o nome da porta correto. O nome da porta pode ser diferente em diferentes configurações de IDE. Em seguida, abra o monitor serial no IDE do Arduino navegando até Ferramentas-> Monitor serial e defina a taxa de transmissão para 115.200 bauds por segundo. Passe os comandos 'AT' e 'AT+GMR' para testar a conexão entre o Arduino e o módulo ESP-01. Experimente configurações diferentes para a opção 'Fim de linha' do monitor serial, como NL e CR. Experimente diferentes combinações até que o módulo ESP comece a interagir corretamente com o monitor serial.
Download Python, PIP e ESPtool. Apague o firmware pré-carregado se o módulo ESP tiver algum. Atualize o código do firmware para o módulo ESP-01 escrevendo os comandos no monitor serial conforme instruções do ESPtool. Confira o link a seguir para escrever o comando adequado para atualizar o código do firmware usando ESPtool –
Comandos ESPtool
Para fazer upload do programa, a chave RESET deve ser liberada enquanto a chave de programação GPIO0 deve ser deixada pressionada. Após carregar o código, a chave de programação também deve ser liberada. Desta forma, o código do firmware pode ser carregado no ESP8266 utilizando a placa Arduino como conversor FTDI. Deve-se observar que todo GND precisa ser comum para completar o circuito. O GPIO2 é um TX alternativo para o modo bootloader.
Remova as conexões. Agora o módulo ESP está pronto para ser instalado no circuito do projeto. No circuito do projeto, o ESP8266 faz interface com o adaptador CP2102 e um LED.
O CP2102 é um USB de chip único para ponte UART. É usado para fornecer energia ao módulo ESP. Ele também pode ser usado para bootloading. Um IC CP2102 tem a seguinte configuração de pinos –
Tabela de listagem de configuração de pinos do IC CP2102
Fig. 6: Tabela listando a configuração dos pinos do IC CP2102
Tabela de listagem de configuração de pinos do IC CP2102

Fig. 7: Tabela listando a configuração dos pinos do IC CP2102

Tabela de listagem de configuração de pinos do IC CP2102
Fig. 8: Tabela listando a configuração dos pinos do CP2102 IC
A placa ESP está conectada ao CP2102 para modo de bootloading e finalidade de uso. Para bootloading, o pino TX do ESP-01 é conectado ao pino RX do CP2102 e o pino RX do ESP é conectado ao TX do CP2102 para que ambos possam enviar e receber os dados. O ESP8266-01 precisa de fonte de alimentação de 3,3 V, então o VCC do ESP está conectado ao 3V3 do CP2102 e os GNDs de ambos precisam estar conectados entre si. O pino de reset do ESP8266 junto com o resistor pull-up de 10k (resistor de bootstrap) é conectado ao pino RTS do CP2102. O GPIO0 é um pino de programação usado para colocar o ESP-01 no modo de programação. O GPIO0 junto com o resistor pull-up de 10K é conectado ao pino DTR do CP2102. O pino CHPD do ES-01 é puxado com um resistor de 10K. As conexões do circuito entre o módulo ESP e o CP2102 estão resumidas na tabela a seguir –
Tabela de listagem de conexões de circuito entre o modem ESP8266 ESP-01 e o IC CP2102
Fig. 9: Tabela listando as conexões do circuito entre o modem ESP8266 ESP-01 e o IC CP2102
Após conectar o módulo ESP ao adaptador CP2102, o adaptador deve ser conectado ao PC e o módulo ESP deve ser carregado com o código do firmware de maneira semelhante à demonstrada com o Arduino.
Após carregar o código, o módulo ESP acessará automaticamente o ponto Wi-Fi com o SSID fornecido no firmware. Um LED é conectado ao módulo ESP. O pino do ânodo do LED é conectado ao GPIO2 com resistor em série de 220 ohms e o pino do cátodo é conectado ao GND. O módulo ESP agora está pronto para receber dados da internet via roteador Wi-Fi e controlará o LED adequadamente.
No lado do PC instale o MQTTLens no navegador Chrome. MQTTlens suporta o protocolo MQTT e pode ser usado para publicação e assinatura de mensagens. O cliente PC deve receber um ID de cliente exclusivo para que o corretor 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 seguinte tutorial –
Como configurar PC e celular como clientes MQTT
Aprenda sobre como criar e assinar tópicos no corretor HiveMQ e publicar mensagens neles no tutorial a seguir –
Comunicação entre PC e celular usando protocolo MQTT via HiveMQ Broker
As seguintes precauções devem ser tomadas ao montar o circuito –
1) O ESP8266 precisa de energia de 3,3 V para funcionar, portanto não forneça 5 V.
2) Algumas pessoas dizem que o ESP8266 não tem entradas tolerantes a 5 V, mas quando o Arduino foi usado como adaptador USB para serial, ele forneceu com sucesso a comunicação serial. De acordo com a folha de dados do ESP8266, também foi escrito que os GPIOs do ESP8266 podem tolerar mais energia de até 6 V.
3) Se o erro espcomm_sync-failed.md for mostrado durante o upload do código do firmware, primeiro verifique a porta selecionada na qual o módulo ESP está conectado e depois verifique se o módulo está entrando no modo de bootloading ou não. Isso pode ser verificado conectando os pinos RX e GND do conversor aos pinos TX e GND do ESP. Em seguida, abra um terminal e verifique se a seguinte mensagem foi recebida na janela serial ou não.
ets 8 de janeiro de 2017, primeira causa: 2, modo de inicialização: (x, y).
4) Verifique se os pinos do módulo estão recebendo tensão adequada ou não usando multímetro.
5) Se o módulo estiver funcionando, mas começar a queimar depois de algum tempo, pode haver um problema de requisito atual. Nesse caso, use uma fonte de alimentação externa para fornecer 3,3 V ao ESP8266.
Protótipo de controlador IOT LED baseado em ESP8266
Fig. 10: Protótipo de controlador IOT LED baseado em ESP8266
Como funciona o circuito –
Após carregar o firmware e as conexões do circuito, o módulo ESP8266 está pronto para receber dados pelo protocolo MQTT do ponto de acesso Wi-Fi disponível. O cliente PC também está pronto para enviar comandos de controle através do complemento MQTTLens. Os clientes ESP8266 e PC se comunicam e enviam mensagens entre si por meio de um corretor MQTT chamado HiveMQ.
O cliente ESP8266 configura-se como publicador para o tópico “ESP8266/status da conexão” e como assinante para o tópico “ESP8266/LED status”. O PC cliente configura-se como assinante para o tópico “ESP8266/status da conexão” e como editor para o tópico “ESP8266/LED status”. O cliente ESP8266 inicia a conexão publicando uma mensagem 'Conectado' ao broker MQTT.
Ao receber a mensagem, o PC cliente poderá publicar mensagens 'ON' e 'OFF' no tópico “ESP8266/LED status”. Caso a mensagem ON seja publicada pelo PC cliente, ela será recebida pelo cliente ESP8266 e seu código de firmware interpretará a mensagem para acender a luz do LED. Caso a mensagem OFF seja publicada pelo PC cliente, ela será recebida pelo cliente ESP8266 e seu código de firmware interpretará a mensagem para desligar a luz do LED.
Guia de programação –
O cliente ESP8266 é carregado com um esboço do Arduino. É usada uma biblioteca de código aberto para publicação e assinatura por meio do cliente ESP. Nessas bibliotecas públicas nada é alterado ou modificado.
O cliente ESP8266 é conectado à rede doméstica definindo o SSID e a senha do roteador Wi-Fi. O SSID e a senha do ponto de acesso Wi-Fi são inicializados no código Arduino da seguinte forma –
//Configuração do Wi-Fi
const char*ssid = “ABCDEF”;
const char* senha = “qwerty”;
Este trecho de código pode ser inicializado na configuração, bem como definindo uma função separada com alguns outros casos de teste. A função a seguir é usada para iniciar a conexão Wi-Fi.
WiFi.begin(ssid, senha); //Iniciar conexão sem fio
Após conectar o ESP8266 com a Rede, o ESP8266 iniciará a conexão com o broker MQTT. O código a seguir no sketch do Arduino é usado para definir o broker MQTT com o qual o módulo ESP tem que se comunicar.
//O nome do domínio do broker ou do servidor
const char* mqtt_server = “broker.mqtt-dashboard.com”;
O cliente baseado no módulo ESP é conectado ao corretor MQTT chamando a seguinte função na configuração.
cliente.setServer(mqtt_server, 1883);
Agora o cliente ESP8266 está conectado ao corretor MQTT. Ele registrará o tópico no corretor MQTT e publicará uma mensagem para o tópico. O dispositivo ESP8266 publicará continuamente a mensagem sobre o tópico “ESP8266/status da conexão” para o corretor. Agora, onde quer que o cliente PC assine o tópico, ele receberá a mensagem “conectado”. O Cliente ESP8266 também se inscreveu no tópico “Status do ESP8266/LED” e aguardará continuamente a mensagem do broker para controlar o LED. O trecho de código a seguir define a publicação e assinatura de tópicos no cliente ESP8266.
client.publish(“ESP8266/status da conexão”, “Conectado!”); //para publicação
client.subscribe(“Status do ESP8266/LED”);
O cliente ESP8266 registrou ou assinou o tópico do corretor MQTT. Portanto, sempre que receber uma mensagem, ele chamará uma função de mensagem recebida. Esta função de mensagem recebida é uma função de retorno de chamada e as coisas que estão escritas nesta função de retorno de chamada serão chamadas sempre que o cliente PC publicar uma mensagem. A função procurará os dados da carga útil. Se os caracteres 'on' forem recebidos, o pino GPIO2 será definido como HIGH e o LED começará a brilhar. Se caracteres 'desligados' forem recebidos na carga útil, o pino GPIO2 será definido como LOW e o LED irá parar de brilhar.
// Lidar com a mensagem que recebemos
// Aqui estamos apenas olhando os caracteres da mensagem recebida
// Se estiver ligado, o led ficará aceso.
//Se estiver apagado, o led ficará apagado.
if((char)carga útil(0) == 'o' && (char)carga útil(1) == 'n') //ligado
digitalWrite(2,ALTO);
senão if((char)carga útil(0) == 'o' && (char)carga útil(1) == 'f' && (char)carga útil(2) == 'f') //desligado
digitalWrite(2,BAIXO);
Sempre que o cliente PC publicar a mensagem ON no tópico, este cliente chamará esta função de retorno de chamada e o LED conectado ao GPIO2 será colocado no estado ON e quando receber uma mensagem OFF, o LED será colocado no estado OFF.
Desta forma, o cliente ESP8266 e o ​​cliente PC se comunicam entre si. Este é apenas um código básico para verificar como dois dispositivos podem se comunicar. No lugar do LED, também pode ser usado um sensor de temperatura que pode fornecer a temperatura e a umidade do ambiente. Até um motor pode ser controlado desta forma. Pode haver muitas coisas que podem ser feitas após o estabelecimento de uma conexão entre os dois dispositivos.
No próximo tutorial – Monitor de temperatura IOT baseado em ESP8266 usando o corretor Adafruit, o cliente ESP8266 terá interface com um sensor de temperatura (como foi feito a interface com um LED neste tutorial) e as leituras de temperatura serão observadas no cliente PC. No próximo tutorial, em vez do HiveMQ, será usado o Adafruit MQTT Broker.

Código-fonte do projeto

###



//Program to 

/*

 * File Name - ESP8266_with_PC_client.ino

 * Created: 20/3/2017 11:02:11 AM

 * Main Source Code for PC and ESP8266 clients communication with HiveMQ broker

 */ 


 /*

 * Output Pins of the ESP8266

 *GPIO02 - ledPin

*/


//Include libraries

#include                             //Include the library for WiFI Initialization                                                  

#include                            //Include the library for MQTT pubsub protocol


//WIFI setup

const char* ssid = "Replace it with the SSID of the Wi-Fi Network";                        //SSID of the WIFI network

const char* password = "Replace it with the password of the Wi-Fi Network";                //Password of the WIFI network


//The broker or server domain name

const char* mqtt_server = "broker.mqtt-dashboard.com";


// Create an ESP8266 WiFiClient class to connect to the MQTT server.

WiFiClient espClient;

//create the MQTT client objects                

PubSubClient client(espClient);                   


void setup  {

  pinMode(2,OUTPUT);                                  //configure the led pin as OUTPUT

  Serial.begin(115200);                               //Set the baudrate of ESP8266 to show the process on serial monitor

  setup_wifi ;                                       //Initialize the Wifi

  

  //By setting server and messgae callback function, the client is ready to use 

  //& 1883 is the listener port for the broker

  client.setServer(mqtt_server, 1883);

  client.setCallback(Received_Message);

}


/*

* Function Name = setup_wifi

* To establish the WIFI connection with ESP8266

*/

void setup_wifi {


  delay(10);

  // We start by connecting to a WiFi network

  Serial.println ;

  Serial.print("Connecting to ");

  Serial.println(ssid);

  //Connect to the WIFI

  WiFi.begin(ssid, password);

  // Wait until the connection has been confirmed before continuing

  while (WiFi.status  != WL_CONNECTED) {

    delay(500);

    Serial.print(".");

  }


  Serial.println("");

  Serial.println("WiFi connected");

  Serial.println("IP address: ");

  Serial.println(WiFi.localIP );

}


/*

* 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

    // 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 ESP8266 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("ESP8266Client")) {

      Serial.println("connected");

      // Once connected, publish an announcement...

      client.publish("ESP8266/connection status", "Connected!");

      // ... and resubscribe

      client.subscribe("ESP8266/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 ESP8266 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 ;

}


###

Diagramas de circuito

Diagrama de circuito-ESP8266-ESP-01-Servidor MQTT baseado em modem
Diagrama de circuito Arduino MQTT cliente

Vídeo do Projeto

contenido relacionado

Regresar al blog

Deja un comentario

Ten en cuenta que los comentarios deben aprobarse antes de que se publiquen.