Introdução ao AWS IoT com sensor de temperatura sem fio usando MQTT: 8 etapas

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

Em Instructables anteriores, passamos por diferentes plataformas de nuvem como Azure, Ubidots, ThingSpeak, Losant etc. Temos usado o protocolo MQTT para enviar os dados do sensor para a nuvem em quase todas as plataformas de nuvem. Para obter mais informações sobre MQTT, suas vantagens e benefícios sobre o protocolo HTTP, você pode consultar este manual.

Neste instrutível, vamos dar um zoom em outra plataforma de nuvem mais familiar, Amazon Web Services. Muitos de vocês podem estar familiarizados com o AWS, também conhecido como Amazon Web Services e a funcionalidade de nuvem fornecida pela AWS. Ele tem sido o núcleo do desenvolvimento web por muitos anos. Com a escala crescente dos aplicativos IoT, a AWS surgiu com a solução AWSIoT. AWSIoT é uma solução confiável para hospedar nossos aplicativos IoT.

Seguindo este instrutível:

• Você será capaz de configurar uma conta AWS para seu aplicativo IoT
• Você será capaz de conectar o ESP32 ao núcleo AWS IoT
• Envie e receba mensagens usando o protocolo MQTT e
• Visualize os dados enviados no AWS

Etapa 1: Configurando uma conta AWS

Configurar uma conta AWS é bastante fácil. Você só precisa fazer o upload de alguns certificados, anexar políticas a ele, registrar o dispositivo e começar a receber as mensagens de dados do sensor no AWS.

Para configurar a conta da AWS, siga este tutorial.

Etapa 2: Especificações de hardware e software

Especificação de Software

Uma conta AWS

Especificação de Hardware

• ESP32
• Sensor de temperatura e vibração sem fio
• Receptor Zigmo Gateway

Etapa 3: Sensores de vibração e temperatura sem fio

Este é um sensor de vibração e temperatura industrial IoT de longo alcance, ostentando um alcance de até 2 milhas usando uma arquitetura de rede mesh sem fio. Incorporando um sensor de vibração e temperatura de 16 bits, este sensor transmite dados de vibração altamente precisos em intervalos definidos pelo usuário. Possui os seguintes recursos:

• Sensor de vibração de 3 eixos de grau industrial com faixa de ± 32g
• Calcula RMS, MAX e MIN g vibração
• Remoção de ruído usando filtro passa-baixa
• Faixa de frequência (largura de banda) até 12.800 Hz
• Taxa de amostragem de até 25, 600 Hz
• Comunicação criptografada com alcance sem fio de 2 milhas
• Faixa de temperatura operacional -40 a +85 ° C
• Instalado na parede ou montado com ímã IP65, software de exemplo de gabinete para Visual Studio e LabVIEW
• Sensor de vibração com opção de sonda externa
• Até 500.000 transmissões a partir de 4 baterias AAMany gateway e opções de modem disponíveis

Etapa 4: Firmware ESP32 AWS

Para se conectar à AWS e começar a enviar os dados, siga as seguintes etapas

• Baixe a biblioteca AWS do seguinte repositório Github
• clone o repo e coloque o arquivo AWS_IOT na pasta da biblioteca do diretório Arduino

git clone

Agora vamos examinar o código:

• Neste aplicativo, utilizamos um portal cativo para salvar as credenciais de WiFi e passar o mouse sobre as configurações de IP. Para obter uma introdução detalhada sobre o portal cativo, você pode seguir as instruções a seguir.
• O portal cativo nos dá a opção de escolher entre configurações estáticas e DHCP. Basta inserir as credenciais como IP estático, máscara de sub-rede, gateway e o gateway do sensor sem fio será configurado nesse IP.
• Uma página da web está sendo hospedada onde uma lista mostrando as redes WiFi disponíveis e RSSI. Selecione a rede WiFi e a senha e insira enviar. As credenciais serão salvas na EEPROM e a configuração de IP será salva no SPIFFS. Mais sobre isso pode ser encontrado neste instrutível.

Etapa 5: Obtendo os dados do sensor do sensor de temperatura e vibração sem fio

Estamos obtendo um quadro de 54 bytes dos sensores de temperatura e vibração sem fio. Este quadro é manipulado para obter os dados reais de temperatura e vibração.

ESP32 tem três UARTs disponíveis para uso em série

1. RX0 GPIO 3, TX0 GPIO 1
2. RX1 GPIO9, TX1 GPIO 10
3. RX2 GPIO 16, TX2 GPIO 17

e 3 portas seriais de hardware

• Serial
• Serial1
• Serial2

Primeiro, inicialize o arquivo de cabeçalho serial do hardware. Aqui estaremos usando RX2 e TX2 aka. Pinos GPIO 16 e GPIO 17 da placa ESP32 para obter os dados seriais.

#incluir

# define RXD2 16 # define TXD2 17

Serial2.begin (115200, SERIAL_8N1, RXD2, TXD2); // pinos 16 rx2, 17 tx2, 19200 bps, 8 bits sem paridade 1 bit de parada

As etapas a seguir o levarão adiante para obter os valores reais do sensor

• Crie variáveis para armazenar temperatura, umidade, bateria e outros valores de sensor
• Defina o Rx, pino tx, taxa de transmissão e bits de paridade para o serial do hardware
• Primeiro, verifique se há algo para ler usando Serial1.available ()
• Obteremos o quadro de 54 bytes.
• Verifique se há 0x7E, que é o byte inicial.
• Os dados de vibração consistem no valor RMS para os 3 eixos, valores mínimos para os 3 eixos, valores máximos para os 3 eixos.
• os valores de temperatura e bateria conterão 2 bytes de dados
• obter o nome do sensor, tipo, versão do sensor conterá 1 byte de dados e poderá ser obtido a partir do respectivo endereço

if (Serial2.available ()) {Serial.println ("Ler Serial"); dados [0] = Serial2.read (); atraso (k); if (dados [0] == 0x7E) {Serial.println ("Pacote obtido"); while (! Serial2.available ()); para (i = 1; i <55; i ++) {dados = Serial2.read (); atraso (1); } if (data [15] == 0x7F) /////// para verificar se os dados recive estão corretos {if (data [22] == 0x08) //////// certifique-se do tipo de sensor está correto {rms_x = ((uint16_t) (((dados [24]) << 16) + ((dados [25]) << 8) + (dados [26])) / 100); rms_y = ((uint16_t) (((dados [27]) << 16) + ((dados [28]) << 8) + (dados [29])) / 100); rms_z = ((uint16_t) (((dados [30]) << 16) + ((dados [31]) << 8) + (dados [32])) / 100); int16_t max_x = ((uint16_t) (((dados [33]) << 16) + ((dados [34]) << 8) + (dados [35])) / 100); int16_t max_y = ((uint16_t) (((dados [36]) << 16) + ((dados [37]) << 8) + (dados [38])) / 100); int16_t max_z = ((uint16_t) (((dados [39]) << 16) + ((dados [40]) << 8) + (dados [41])) / 100);

int16_t min_x = ((uint16_t) (((dados [42]) << 16) + ((dados [43]) << 8) + (dados [44])) / 100); int16_t min_y = ((uint16_t) (((dados [45]) << 16) + ((dados [46]) << 8) + (dados [47])) / 100); int16_t min_z = ((uint16_t) (((dados [48]) << 16) + ((dados [49]) << 8) + (dados [50])) / 100);

cTemp = ((((dados [51]) * 256) + dados [52])); bateria flutuante = ((dados [18] * 256) + dados [19]); tensão = 0,00322 * bateria; Serial.print ("Número do sensor"); Serial.println (dados [16]); senseNumber = dados [16]; Serial.print ("Tipo de sensor"); Serial.println (dados [22]); Serial.print ("Versão do firmware"); Serial.println (dados [17]); Serial.print ("Temperatura em Celsius:"); Serial.print (cTemp); Serial.println ("C"); Serial.print ("vibração RMS no eixo X:"); Serial.print (rms_x); Serial.println ("mg"); Serial.print ("vibração RMS no eixo Y:"); Serial.print (rms_y); Serial.println ("mg"); Serial.print ("vibração RMS no eixo Z:"); Serial.print (rms_z); Serial.println ("mg");

Serial.print ("Vibração mínima no eixo X:");

Serial.print (min_x); Serial.println ("mg"); Serial.print ("Vibração mínima no eixo Y:"); Serial.print (min_y); Serial.println ("mg"); Serial.print ("Vibração mínima no eixo Z:"); Serial.print (min_z); Serial.println ("mg");

Serial.print ("valor ADC:");

Serial.println (bateria); Serial.print ("Voltagem da bateria:"); Serial.print (voltagem); Serial.println ("\ n"); if (voltagem <1) {Serial.println ("Hora de substituir a bateria"); }}} else {for (i = 0; i <54; i ++) {Serial.print (data ); Serial.print (","); atraso (1); }}}}

Etapa 6: Conectando-se ao AWS

• Incluir arquivos de cabeçalho AWS_IOT.h, WiFi.h para configurar uma conexão com o hub AWSIoT
• Digite seu endereço de host, ID do cliente, que será o nome da política, e o nome do tópico, que será o nome da coisa

// ********* Credenciais da AWS ************* // char HOST_ADDRESS = "a2smbp7clzm5uw-ats.iot.us-east-1.amazonaws.com"; char CLIENT_ID = "ncdGatewayPolicy"; char TOPIC_NAME = "ncdGatewayThing";

Crie uma variável char para armazenar seu JSON, neste caso, criamos um formato para armazenar JSON

const char * format = "{" SensorId / ": \"% d / ", \" messageId / ":% d, \" rmsX / ":% d, \" rmsY / ":% d, \" rmsZ / ":% d, \" cTemp / ":% d, \" voltagem / ":%. 2f}";

Crie uma instância da classe AWS_IOT

AWS_IOT esp; // Instância da classe AWS_IOT

Agora conecte-se ao hub AWSIoT usando o método a seguir

void reconnectMQTT () {if (hornbill.connect (HOST_ADDRESS, CLIENT_ID) == 0) {Serial.println ("Conectado ao AWS"); atraso (1000);

if (0 == hornbill.subscribe (TOPIC_NAME, mySubCallBackHandler))

{Serial.println ("Assinatura bem-sucedida"); } else {Serial.println ("Falha na assinatura, verifique o nome e os certificados da coisa"); enquanto (1); }} else {Serial.println ("Falha na conexão AWS, verifique o endereço do HOST"); enquanto (1); }

atraso (2000);

}

publique os dados do sensor a cada 1 minuto

if (tick> = 60) // publicar no tópico a cada 5 segundos {tick = 0; carga útil char [PAYLOAD_MAX_LEN]; snprintf (carga útil, PAYLOAD_MAX_LEN, formato, senseNumber, msgCount ++, rms_x, rms_y, rms_z, cTemp, tensão); Serial.println (carga útil); if (hornbill.publish (TOPIC_NAME, carga útil) == 0) {Serial.print ("Publicar mensagem:"); Serial.println (carga útil); } else {Serial.println ("Falha na publicação"); }} vTaskDelay (1000 / portTICK_RATE_MS); tick ++;

Etapa 7: Visualização de dados na AWS

• Faça login em sua conta da AWS.
• no canto esquerdo da barra de ferramentas, você encontrará a guia Serviços
• Clique nesta guia e, sob o título Internet das Coisas, selecione IoT Core.
• Selecione o QoS e não. de mensagens para assinantes. Insira o nome do tópico.

Etapa 8: Código geral

Você pode encontrar o código geral neste Repositório Github.

Créditos

• Arduino Json
• Sensores de temperatura e umidade sem fio
• ESP32
• PubSubClient