UbiDots - conectando um ESP32 e publicando dados de sensores múltiplos: 6 etapas

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:37

ESP32 e ESP 8266 são SoC muito familiares no campo da IoT. Isso é uma espécie de benção para os projetos de IoT. O ESP 32 é um dispositivo com WiFi e BLE integrados. Basta fornecer o seu SSID, senha e configurações de IP e integrar as coisas na nuvem. Aqui neste instrutível, refletiremos sobre alguns dos termos básicos da IoT, como plataforma IoT, MQTT, portais cativos etc.

• A Arquitetura IoT em palavras muito simples consiste em um dispositivo integrado e uma plataforma IoT para colocar o dispositivo na nuvem. Aqui, estamos usando a plataforma UbiDots IoT para visualizar os dados do sensor.
• Gerenciar as configurações de IP e as credenciais do usuário pode ser uma dor de cabeça para o usuário. E se o usuário quiser alterar as credenciais do WiFi? E se o usuário quiser mudar as configurações de DHCP / IP estático? Atualizar o ESP32 sempre não é confiável e nem mesmo a solução para esses problemas. Portanto, iremos através do portal cativo para salvar as credenciais WiFi e outras configurações.
• MQTT agora está se tornando um termo muito comum no mundo da IoT. ele ultrapassou solicitações e respostas (HTTP) por Publicar e Assinar devido à arquitetura rápida, robusta e enxuta.

Aqui neste instrutível, iremos demonstrar.

• Dando credenciais de WiFi e MQTT usando o Captive Portal.
• Publicação e assinatura de dados de vários sensores para UbiDots.
• Lendo os dados do sensor dos sensores sem fio de temperatura e umidade.
• Hospedar um formulário da web do ESP32.
• Leitura e gravação de SPIFFS ESP32.

Etapa 1: Especificação de Hardware e Software

• ESP32 WiFi / BLE
• Sensor de temperatura e umidade sem fio

Especificação de Software

IDE Arduino

Etapa 2: Criação de um portal cativo

Um portal cativo é uma página da web exibida para usuários recém-conectados antes que eles tenham acesso mais amplo aos recursos da rede. Aqui, estamos servindo três páginas da web para selecionar entre as configurações de DHCP e IP estático. podemos definir o endereço IP para ESP de duas maneiras.

• Endereço IP DHCP - é uma forma de atribuir dinamicamente o endereço IP ao dispositivo. O endereço IP padrão do ESP é 192.168.4.1
• O endereço IP estático - atribuindo um endereço IP permanente ao nosso dispositivo de rede. para fornecer o IP estático ao dispositivo, precisamos definir o endereço IP, o endereço do gateway e a máscara de sub-rede.

A primeira página da Web está sendo hospedada em 192.168.1.77. Aqui, o usuário recebe os botões de rádio para selecionar entre as configurações de DHCP e IP estático. Na próxima página da Web, temos que fornecer as informações relacionadas ao IP para prosseguirmos.

Código HTML

O código HTML para páginas da web pode ser encontrado neste repositório Github. Você pode usar qualquer IDE ou editor de texto como Sublime ou notepad ++ para criar páginas da web em HTML.

• Primeiro, crie uma página da Web em HTML contendo dois botões de opção para escolher entre as configurações de DHCP e IP estático.
• Agora crie o botão para enviar sua resposta
• Dê algum nome aos botões de opção.
• A classe do servidor ESP Web tomará esses nomes como argumentos e obterá a resposta dos botões de opção usando esses argumentos
• Agora insira um botão 'ENVIAR' para enviar a resposta ao dispositivo. Nas outras páginas da web, temos caixas de texto.
• Dê o valor do nome e o tipo de entrada à caixa de texto e adicione um botão de envio para 'ENVIAR' para enviar a resposta.
• Crie um botão 'RESET' para redefinir o conteúdo do campo de texto.

Etapa 3: Fornecimento de credenciais de WiFi e UbiDots

O principal problema ocorre durante o gerenciamento das credenciais WiFi. Mesmo que tenhamos a biblioteca WiFiMulti para isso, podemos dar vários SSIDs e senhas ao dispositivo e o dispositivo se conectará à rede disponível. Mas, e se a rede disponível não estiver na lista WiFiMulti. Atualizar o dispositivo ESP32 o tempo todo não é uma solução confiável.

Para resolver este problema, estamos hospedando uma página onde o usuário pode enviar o SSID e a senha da rede disponível. Funciona da seguinte maneira.

• A página da web é hospedada no IP estático ou IP DHCP escolhido pelo usuário no portal cativo
• Esta página da Web contém campos de texto para inserir SSID, senha e ID de token UBIDOTS para conectar o dispositivo a UbiDots.
• Insira o SSID e a senha do seu WiFi local nos campos de entrada, insira o ID do token do UbiDot e insira SUBMIT
• Essas credenciais são salvas na EEPROM do ESP32
• Após 60 segundos, o dispositivo se desconectará automaticamente do AP
• Na próxima vez que você ligar o dispositivo, o usuário não precisará seguir este procedimento. O dispositivo buscará automaticamente as credenciais do usuário na EEPROM e continuará publicando as leituras do sensor no UbiDots.

Etapa 4: Publicação de leituras de sensor para UbiDots

Aqui, estamos usando sensores sem fio de temperatura e umidade com o dispositivo ESP 32 para obter os dados de temperatura e umidade. Estamos enviando os dados para UbiDots usando o protocolo MQTT. MQTT segue um mecanismo de publicação e assinatura em vez de solicitação e resposta. É mais rápido e confiável do que HTTP. Isso funciona da seguinte maneira.

• Estamos fazendo uso do Agendador de Tarefas para Agendar a tarefa, como buscar dados de sensores, Publicar as leituras do sensor, Inscrever-se no tópico MQTT.
• Primeiro, inclua os arquivos de cabeçalho do Agendador de Tarefas, sua instância e agende as tarefas.
• Agendamos duas tarefas referentes a duas operações de controle diferentes.

#define _TASK_TIMEOUT # include

Scheduler ts;

// --------- Tarefas ------------ // Tarefa tSensor (4 * TASK_SECOND, TASK_FOREVER, & taskSensorCallback, & ts, false, NULL, & taskSensorDisable); Tarefa tWiFi (10 * TASK_SECOND, TASK_FOREVER, & taskWiFiCallback, & ts, false, NULL, & taskWiFiDisable);

A tarefa 1 é para ler o valor do sensor, esta tarefa é executada por 1 segundo até atingir o tempo limite de 10 segundos

• Quando a Tarefa1 atinge o seu tempo limite, estamos nos conectando ao Wifi local e ao corretor MQTT.

• Agora a Tarefa 2 está ativada e estamos desativando a Tarefa 1

• A tarefa 2 é para publicar os dados do sensor no broker MQTT UbiDots, esta tarefa é executada por 20 segundos até atingir o tempo limite de 20 segundos
• Quando a Tarefa2 atinge seu tempo limite, a Tarefa 1 é habilitada novamente e a Tarefa2 é desabilitada. Novamente, estamos obtendo o valor atualizado e o processo continua.

Lendo os dados do sensor I2C

Estamos obtendo um quadro de 29 bytes dos sensores sem fio de temperatura e umidade. Este quadro é manipulado para obter dados reais de temperatura e umidade

dados uint8_t [29];

dados [0] = Serial1.read (); atraso (k); // chck para byte inicial if (data [0] == 0x7E) {while (! Serial1.available ()); para (i = 1; i <29; i ++) {dados = Serial1.read (); atraso (1); } if (data [15] == 0x7F) /////// para verificar se os dados recive estão corretos {if (data [22] == 1) //////// certifique-se do tipo de sensor está correto {

umidade = ((((dados [24]) * 256) + dados [25]) /100,0); umidade /=10,0; cTempint = (((uint16_t) (dados [26]) << 8) | dados [27]); cTemp = (flutuante) cTempint /100,0; cTemp / = 10,0; fTemp = cTemp * 1,8 + 32; fTemp / = 10,0; bateria = aleatório (100, 327); tensão = bateria / 100; nodeId = dados [16];}

Conectando-se à UbiDots MQTT API

Inclua o arquivo de cabeçalho para o processo MQTT

#incluir

definir outras variáveis para MQTT como nome do cliente, endereço do corretor, ID do token (estamos buscando o ID do token de EEPROM)

#define MQTT_CLIENT_NAME "ClientVBShightime123"

char mqttBroker = "things.ubidots.com";

carga útil char [100]; tópico char [150];

// cria uma variável para armazenar o ID do token

String tokenId;

Crie variáveis para armazenar diferentes dados do sensor e crie uma variável char para armazenar o tópico

#define VARIABLE_LABEL_TEMPF "tempF" // Atribuindo o rótulo da variável # define VARIABLE_LABEL_TEMPC "tempC" // Atribuindo o rótulo da variável #define VARIABLE_LABEL_BAT "bat" #define VARIABLE_LABEL_HUMID "úmido" // Atribuindo o rótulo da variável

char topic1 [100]; char topic2 [100]; char topic3 [100];

publicar os dados no tópico MQTT mencionado, a carga útil será semelhante a {"tempc": {value: "tempData"}}

sprintf (tópico1, "% s", ""); sprintf (tópico1, "% s% s", "/v1.6/dispositivos/", DEVICE_LABEL); sprintf (carga útil, "% s", ""); // Limpa a carga útil sprintf (carga útil, "{"% s / ":", VARIABLE_LABEL_TEMPC); // Adiciona o valor sprintf (carga útil, "% s {" valor / ":% s}", carga útil, str_cTemp); // Adiciona o valor sprintf (payload, "% s}", payload); // Fecha os colchetes do dicionário Serial.println (carga útil); Serial.println (client.publish (tópico1, carga útil)? "Publicado": "não publicado");

// Faça o mesmo para outro tópico também

client.publish () publica os dados para UbiDots

Etapa 5: visualizando os dados

• Vá para Ubidots e faça login em sua conta.
• Navegue até o Painel a partir da guia Dados listada na parte superior.
• Agora clique no ícone "+" para adicionar os novos widgets.
• Selecione um widget da lista e adicione uma variável e dispositivos.
• Os dados do sensor podem ser visualizados no painel usando diferentes widgets.

Etapa 6: Código geral

O código Over para HTML e ESP32 pode ser encontrado neste repositório GitHub.

Créditos

• placa de breakout ncd ESP32.
• Sensores de umidade e temperatura sem fio ncd.
• pubsubclient
• UbiDots
• Agendador de tarefas