Monitoramento de Temperatura Ambiente e Umidade Relativa do Ar via Internet
O Site do Hardware Livre - OSHW

Monitoramento de Temperatura Ambiente e Umidade Relativa do Ar via Internet

Conforme vimos no artigo “Como utilizar o sensor de temperatura e umidade relativa DHT22 com o NodeMCU”, é possível utilizar o NodeMCU juntamente com o sensor DHT22 para obter informações de temperatura ambiente e umidade relativa do ar, bem como a temperatura máxima e mínima.

Neste artigo vamos expandir um pouco mais este projeto, onde será possível ver via Internet o resultado das informações coletadas pelos sensores. Neste projeto também aprenderemos como utilizar o protocolo MQTT (Message Queuing Telemetry Transport) utilizando o Arduino IDE para programação.

 

 

Materiais necessários

Para reproduzir este projeto, iremos precisar dos seguintes materiais:

Um NodeMCU

Um sensor DHT22

Um resistor de 10k / 0,25W

Um protoboard (qualquer modelo de 400 pontos ou maior)

Alguns jumpers do tipo macho-macho

Um cabo micro-USB comum

 

É importante ressaltar que será necessário também possuir conectividade WI-FI (com acesso à Internet disponível) no local que o NodeMCU for ficar.

 

 

MQTT - informações gerais

O MQTT (Message Queue Telemetry Transport) é em um protocolo de mensagens leve / light-weight criado em 1999. O objetivo original dele era ser um protocolo adequado para comunicação entre máquinas em rede (tanto local como Internet). Este tipo de comunicação é referenciada na literatura técnica como M2M (Machine to Machine). Pelo fato de não utilizar alto poder computacional (processamento e uso de memória RAM), assim como não utilizar alta banda de Internet, o MQTT é um dos protocolos mais adequados para comunicação M2M e telemetria em dispositivos embarcados de forma geral. Justamente por isso, o MQTT é famoso no conceito IoT (Internet of Things).

Uma comunicação MQTT é composta das seguintes partes:

Publishers: o(s) dispositivo(s) que irá (irão) disponibilizar informações.

Subscribers: o(s) dispositivo(s) que irá (irão) receber as informações.

Broker: este é o servidor da comunicação MQTT. Ele fica “na nuvem” (é acessível de qualquer lugar do mundo com conexão com à Internet). Teoricamente, não há limites máximo e mínimo especificados de subscribers e publishers em uma mesma comunicação MQTT, portanto a escalabilidade de uma comunicação MQTT pode ser altíssima.

 

IMPORTANTE: apesar da distinção entre publisher e subscriber, um dispositivo pode publicar (fazer publish) em N tópicos diferentes e se subsescrever (ser subscriber) em X tópicos distintos. Ou seja, um mesmo dispositivo pode ser publisher e subscriber, o que significa que todos podem enviar e receber informações.

 

Dizendo em outras palavras: os dispositivos publishers enviam informações para o Broker. Por sua vez, os dispositivos subscribers recebem tais informações do Broker e ele gerencia a troca de mensagens. Ou seja, o “trabalho pesado” de sincronizar o envio e recebimento fica sob inteira responsabilidade do Broker, o que faz com que os sistemas embarcados (publishers e subscribers) fiquem livre para gerenciar outras coisas. Então além de utilizar poucos recursos computacionais, é possível afirmar que o MQTT leva a uma redução de consumo energético (se comparado a alguns outros protocolos de comunicação).

Observe o diagrama da comunicação MQTT mostrado na figura 1.

 

 

Figura 1 - diagrama de comunicação MQTT (fonte: https://www.filipeflop.com/blog/controle-monitoramento-iot-nodemcu-e-mqtt/)
Figura 1 - diagrama de comunicação MQTT (fonte: https://www.filipeflop.com/blog/controle-monitoramento-iot-nodemcu-e-mqtt/)

 

 

 Sem entrar no mérito da especificação oficial do protocolo MQTT, uma mensagem MQTT publicada / enviada possui duas partes importantes:

Tópico: “chave” / identificação da informação publicada. É usado para direcionar a informação publicada / enviada a quem assina (quem “dá subscribe”) no tópico. O tópico consiste de uma string (por exemplo: MQTTTesteTopico)

 

 

Payload: informação que deseja enviar (propriamente dita).

Um publisher, conectado ao Broker (servidor MQTT) , envia/publica as informações em um dado momento. Os subscribers, assim como os publishers, também estão conectados aos brokers e “escutando” mensagens trafegadas com o tópico-alvo. Quando uma mensagem com o tópico alvo é publicada, automaticamente são direcionadas aos subscribers.

Em outras palavras: uma solução em IoT que usa MQTT possui somente um servidor (Broker), sendo todo o restante composto de clients MQTT.

 

 

Circuito esquemático

O circuito esquemático aqui é idêntico ao visto no artigo “Como utilizar o sensor de temperatura e umidade relativa DHT22 com o NodeMCU”. Veja-o na figura 2.

 

Figura 2 - circuito esquemático
Figura 2 - circuito esquemático

 

 

Instalação da biblioteca para comunicação MQTT

Agora chegou a hora de instalarmos a biblioteca PubSubClient, biblioteca na qual permitirá com que o NodeMCU se comunique com a Internet utilizando o protocolo MQTT. Tal biblioteca é open-source, podendo ser obtida gratuitamente em: https://github.com/knolleary/pubsubclient 

 

Para instalar esta biblioteca, vamos seguir o procedimento abaixo:

 

1. Acesse o repositório da biblioteca (https://github.com/knolleary/pubsubclient) e baixe-a clicando em “Clone or Download” e depois em “Download ZIP” , conforme mostra a figura 3.

  

Figura 3 - obtenção da biblioteca PubSubClient diretamente do repositório oficial
Figura 3 - obtenção da biblioteca PubSubClient diretamente do repositório oficial

 

Guarde o arquivo ZIP baixado em uma pasta conhecida / de fácil acesso para você

 

2. Agora, na Arduino IDE, vamos instalar a biblioteca que acabamos de baixar. Para isso, vamos clicar no menu “Sketch”, depois em “Incluir Biblioteca” e, por fim, clicar em “Adicionar biblioteca .ZIP”, conforme a figura 4.

 

Figura 4 - caminho para inclusão de biblioteca Arduino em formato de arquivo compactado
Figura 4 - caminho para inclusão de biblioteca Arduino em formato de arquivo compactado

 

3. Na janela que abrir, procure pela arquivo da biblioteca que você baixou (conforme passo 1 deste procedimento) e clique em “Abrir”. Desta forma, concluímos a instalação da biblioteca PubSubClient!

 

Visão geral do projeto

Este projeto trata-se de uma extensão do projeto abordado no artigo “Como utilizar o sensor de temperatura e umidade relativa DHT22 com o NodeMCU”, a diferença deste aqui é que vamos disponibilizar os dados coletados pelos sensores na internet utilizando o protocolo MQTT.

Portanto, o algoritmo que usaremos para coletar instantaneamente os dados das medições de temperatura ambiente, é o mesmo para coletarmos os dados dos sensores de umidade relativa do ar, temperatura máxima e temperatura mínima, sendo assim o que mudará aqui será apenas a parte de publicar as informações via MQTT.

Sendo assim, as funcionalidades deste projeto são:

Medição da temperatura (ºC) e umidade relativa do ar a cada cinco segundos.

Em complemento, o projeto contabilizará a máxima e mínima temperatura medidas em todo o período de funcionamento.

As medições (temperatura e umidade relativa do ar atuais e máximas e mínimas registradas) serão formatadas em strings. Tais mensagens / strings com as medições poderão ser lidas pelo monitor serial da própria Arduino IDE. Ou seja, a mensagem será enviada pela USB (USB-CDC) do NodeMCU.

Disponibilização das medições de temperatura ambiente instantânea, umidade relativa do ar instantânea, temperatura máxima e temperatura mínima via MQTT.

 

Observações:

a) Será utilizado o Broker iot.eclipse.org, um Broker free disponível a todos que desejam fazer experimentos com MQTT.

b) As informações via MQTT poderão ser lidas utilizando um client MQTT qualquer. Uma sugestão de client MQTT é o MQTTLens, que pode ser obtido gratuitamente no endereço: https://chrome.google.com/webstore/detail/mqttlens/hemojaaeigabkbcookmlgmdigohjobjm?hl=pt-BR 

 

 

Código-fonte do projeto

Abaixo, segue o código-fonte do projeto. Leia com atenção seus comentários para total compreensão do mesmo. Conforme explicado nos comentários, não se esqueça de colocar em SSID e PASSWORD o nome de sua rede WI-FI e a senha dela, respectivamente.

 

 

 

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
//Projeto: medição de temperatura e umidade relativa do ar com NodeMCU e sensor DHT22 e

//         publicação das informações por MQTT

//Autor: Pedro Bertoleti

//Data: Fevereiro/2018

#include <ESP8266WiFi.h>

#include <PubSubClient.h>

#include <DHT.h>

#include <string.h>

 

/*

* Defines do projeto

*/

//GPIO do NodeMCU que o pino de comunicação do sensor está ligado.

#define DHTPIN D1     

 

//A biblioteca serve para os sensores DHT11, DHT22 e DHT21.

//No nosso caso, usaremos o DHT22, porém se você desejar utilizar

//algum dos outros disponíveis, basta descomentar a linha correspondente.

//#define DHTTYPE DHT11   // DHT 11

#define DHTTYPE DHT22   // DHT 22  (AM2302), AM2321

//#define DHTTYPE DHT21   // DHT 21 (AM2301)

 

//defines de id mqtt e tópicos para publicação e subscribe

#define TOPICO_PUBLISH   "MQTTINCBTempUmid"    //tópico MQTT de envio de informações para Broker

                                                  //IMPORTANTE: recomenda-se fortemente alterar os nomes

                                                  //            desses tópicos. Caso contrário, há grandes

                                                  //            chances de você controlar e monitorar o NodeMCU

                                                  //            de outra pessoa (pois o broker utilizado contém

                                                  //            dispositivos do mundo todo). Altere-o para algo

                                                  //            o mais único possível para você.

 

#define ID_MQTT  "INCBTempUmid"     //id mqtt (para identificação de sessão)

                                   //IMPORTANTE: este deve ser único no broker (ou seja,

                                   //            se um client MQTT tentar entrar com o mesmo

                                   //            id de outro já conectado ao broker, o broker

                                   //            irá fechar a conexão de um deles). Pelo fato

                                   //            do broker utilizado conter  dispositivos do mundo

                                   //            todo, recomenda-se fortemente que seja alterado

                                   //            para algo o mais único possível para você.

 

#define TEMPO_MINIMO_ENTRE_LEITURAS_DHT22    5000 //tempo mínimo recomendado entre leituras do sensor SHT22 (em ms)

 

/*

* Variáveis, constantes e objetos globais

*/

//objeto para comunicação com sensor DHT22

DHT dht(DHTPIN, DHTTYPE);

 

//variáveis que armazenam os valores máximo e mínimo de temperatura registrados.

float TemperaturaMax;

float TemperaturaMin;

 

// WIFI

const char* SSID = " "; // coloque aqui o SSID / nome da rede WI-FI que deseja se conectar

const char* PASSWORD = " "; // coloque aqui a senha da rede WI-FI que deseja se conectar

 

// MQTT

const char* BROKER_MQTT = "iot.eclipse.org"; //URL do broker MQTT que se deseja utilizar

int BROKER_PORT = 1883; // Porta do Broker MQTT

 

//Variáveis e objetos globais

WiFiClient espClient; // Cria o objeto espClient

PubSubClient MQTT(espClient); // Instancia o Cliente MQTT passando o objeto espClient

 

/*

* Prototypes

*/

void AtualizaTemperaturaMaxEMinima(float TempLida);

void EnviaMedicoesParaSerial(float TempLida, float UmidLida, float TempMax, float TempMin);

void initWiFi(void);

void initMQTT(void);

void reconectWiFi(void);

void reconnectMQTT(void);

void VerificaConexoesWiFIEMQTT(void);

 

/*

* Implementações

*/

//Função: inicializa e conecta-se na rede WI-FI desejada

//Parâmetros: nenhum

//Retorno: nenhum

void initWiFi(void)

{

   delay(10);

   Serial.println("------Conexao WI-FI------");

   Serial.print("Conectando-se na rede: ");

   Serial.println(SSID);

   Serial.println("Aguarde");

   

   reconectWiFi();

}

 

//Função: inicializa parâmetros de conexão MQTT(endereço do broker e porta)

//Parâmetros: nenhum

//Retorno: nenhum

void initMQTT(void)

{

   //informa qual broker e porta deve ser conectado

   MQTT.setServer(BROKER_MQTT, BROKER_PORT);   

}

 

//Função: reconecta-se ao broker MQTT (caso ainda não esteja conectado ou em caso de a conexão cair)

//        em caso de sucesso na conexão ou reconexão, o subscribe dos tópicos é refeito.

//Parâmetros: nenhum

//Retorno: nenhum

void reconnectMQTT(void)

{

   while (!MQTT.connected())

   {

       Serial.print("* Tentando se conectar ao Broker MQTT: ");

       Serial.println(BROKER_MQTT);

       if (MQTT.connect(ID_MQTT))

           Serial.println("Conectado com sucesso ao broker MQTT!");

       else

       {

           Serial.println("Falha ao reconectar no broker.");

           Serial.println("Havera nova tentatica de conexao em 2s");

           delay(2000);

       }

   }

}

 

//Função: reconecta-se ao WiFi

//Parâmetros: nenhum

//Retorno: nenhum

void reconectWiFi(void)

{

   //se já está conectado a rede WI-FI, nada é feito.

   //Caso contrário, são efetuadas tentativas de conexão

   if (WiFi.status() == WL_CONNECTED)

       return;

       

   WiFi.begin(SSID, PASSWORD); // Conecta na rede WI-FI

   

   while (WiFi.status() != WL_CONNECTED)

   {

       delay(100);

       Serial.print(".");

   }

 

   Serial.println();

   Serial.print("Conectado com sucesso na rede ");

   Serial.print(SSID);

   Serial.println("IP obtido: ");

   Serial.println(WiFi.localIP());

}

 

//Função: verifica o estado das conexões WiFI e ao broker MQTT.

//        Em caso de desconexão (qualquer uma das duas), a conexão

//        é refeita.

//Parâmetros: nenhum

//Retorno: nenhum

void VerificaConexoesWiFIEMQTT(void)

{

   reconectWiFi(); //se não há conexão com o WiFI, a conexão é refeita

   

   if (!MQTT.connected())

       reconnectMQTT(); //se não há conexão com o Broker, a conexão é refeita    

}

 

//Função: verifica se os valores de temperatura máxima e mínima devem ser atualizados

//Parâmetros: temperatura lida

//Retorno: nenhum

void AtualizaTemperaturaMaxEMinima(float TempLida)

{

 if (TempLida > TemperaturaMax)

   TemperaturaMax = TempLida;

 

 if (TempLida < TemperaturaMin)

   TemperaturaMin = TempLida;  

}

 

 

//Função: envia, na forma de mensagens textuais, as medições para a serial e broker MQTT

//Parâmetros: - Temperatura lida

//            - Umidade relativa do ar lida

//            - Máxima temperatura registrada

//            - Mínima temperatura registrada

//Retorno: nenhum

void EnviaMedicoesParaSerialEBrokerMQTT(float TempLida, float UmidLida, float TempMax, float TempMin)

{

 char Mensagem[50];

 char MensagemMQTT[200];

 char i;

 

 //pula 80 linhas, de forma que no monitor serial seja exibida somente as mensagens atuais (impressao de refresh de tela)

 for(i=0; i<80; i++)

   Serial.println(" ");

 

 //limpa mensagem as er enviada via MQTT

 memset(MensagemMQTT,0,sizeof(MensagemMQTT));

 

 //constrói mensagens e as envia

 //- temperatura atual

 memset(Mensagem,0,sizeof(Mensagem));

 sprintf(Mensagem,"Temperatura: %d C",(int)TempLida);

 Serial.println(Mensagem);

 strcat(MensagemMQTT,Mensagem);

 strcat(MensagemMQTT,", ");

 

 //- umidade relativa do ar atual

 memset(Mensagem,0,sizeof(Mensagem));

 sprintf(Mensagem,"Umidade atual: %d \%",(int)UmidLida);

 Serial.println(Mensagem);

 strcat(MensagemMQTT,Mensagem);

 strcat(MensagemMQTT,", ");

 

 //- temperatura maxima

 memset(Mensagem,0,sizeof(Mensagem));

 sprintf(Mensagem,"Temperatura maxima: %d C",(int)TempMax);

 Serial.println(Mensagem);

 strcat(MensagemMQTT,Mensagem);

 strcat(MensagemMQTT,", ");

   

 //- temperatura minima

 memset(Mensagem,0,sizeof(Mensagem));

 sprintf(Mensagem,"Temperatura minima: %d C", (int)TempMin);

 Serial.println(Mensagem);

 strcat(MensagemMQTT,Mensagem);

 

 MQTT.publish(TOPICO_PUBLISH, MensagemMQTT);  

 

}

 

void setup() {

 //configura como saída o GPIO do LED do soldado no NodeMCU

 pinMode(D0, OUTPUT);

 digitalWrite(D0, HIGH);  

 

 //configura comunicação serial (para enviar mensgens com as medições)

 //e inicializa comunicação com o sensor.

 Serial.begin(115200);  

 dht.begin();

 

 //inicializa temperaturas máxima e mínima com a leitura inicial do sensor

 TemperaturaMax = dht.readTemperature();

 TemperaturaMin = TemperaturaMax;

 

 //inicializações do WI-FI e MQTT

 initWiFi();

 initMQTT();

}

 

/*

* Programa principal

*/

void loop() {

 float TemperaturaLida;

 float UmidadeLida;

 

 //garante funcionamento das conexões WiFi e ao broker MQTT

 VerificaConexoesWiFIEMQTT();

 

 //Faz a leitura de temperatura e umidade do sensor

 TemperaturaLida = dht.readTemperature();

 UmidadeLida = dht.readHumidity();

 

 //se houve falha na leitura do sensor, escreve mensagem de erro na serial

 if ( isnan(TemperaturaLida) || isnan(UmidadeLida) )

   Serial.println("Erro ao ler sensor DHT22!");

 else

 {

   //Se a leitura foi bem sucedida, ocorre o seguinte:

   // - Os valores mínimos e máximos são verificados e comparados à medição atual de temperatura

   //   se a temperatura atual for menor que a mínima ou maior que a máxima até então

   //   registrada, os limites máximo ou mínimo são atualizados.

   // - As medições (temperatura, umidade, máxima temperatura e mínima temperatura) são

   //   enviados pela serial na forma de mensagem textual e via MQTT para o Broker na Internet.

   //   Tais mensagens podem ser vistas também no monitor serial.

   AtualizaTemperaturaMaxEMinima(TemperaturaLida);

   EnviaMedicoesParaSerialEBrokerMQTT(TemperaturaLida,

                                      UmidadeLida,

                                      TemperaturaMax,

                                      TemperaturaMin);

   //pisca o LED rapidamente (sinalizando que a informação foi enviada por MQTT)

   digitalWrite(D0, HIGH);

   delay(200);

   digitalWrite(D0, LOW);

   delay(200);

   digitalWrite(D0, HIGH);  

 }

 

 //keep-alive da comunicação com broker MQTT

 MQTT.loop();

 

 //espera tempo minimo recomendado entre leituras do sensor

 delay(TEMPO_MINIMO_ENTRE_LEITURAS_DHT22);

}

 

 

Para compilar, enviar o software compilado ao NodeMCU e começar sua execução, basta seguirmos os mesmos passos de artigo NodeMCU – primeiros passos (MIC160) - http://www.newtoncbraga.com.br/index.php/microcontrolador/143-tecnologia/14268-nodemcu-primeiros-passos-mic160.

Assim que o Upload for feito para o NodeMCU, siga o passo-a-passo abaixo para ver o projeto funcionar.

 

Atenção: o passo-a-passo deve ser feito ainda com o NodeMCU conectado ao computador via cabo micro-USB.

 

1. Na Arduino IDE, clique em “Ferramentas” e depois em “Monitor serial”, conforme ilustra a figura 5. Se preferir, pode utilizar o atalho de teclado Ctrl + Shift + M.

 

 

Figura 5 - Caminho para acessar monitor serial
Figura 5 - Caminho para acessar monitor serial

 

 

2. Na janela do monitor serial, vamos ajustar a velocidade em 115200bps, conforme mostra a figura 6.

 

 

Figura 6 - configuração da velocidade de comunicação entre monitor serial e NodeMCU
Figura 6 - configuração da velocidade de comunicação entre monitor serial e NodeMCU

 

 

 

3. Podemos observar as mensagens com as medições aparecendo de cinco em cinco segundos no monitor serial, conforme ilustrado na figura 7

 

 

Figura 7 - Medições no monitor serial
Figura 7 - Medições no monitor serial

 

 

4. Assumindo que vamos utilizar o MQTTLens como cliente de MQTT, abra-o e clique em “Connections +”.

5. Agora, vamos preencher os campos “Connection name” e “Hostname” da janela “Add a new Connection” conforme a figura 8. Deixe os demais campos como estão.

 

Figura 8 - Dados de conexão MQTT (configuração do cliente MQTTLens)
Figura 8 - Dados de conexão MQTT (configuração do cliente MQTTLens)

 

 

6. No final da tela “Add a new Connection”, devemos agora clicar em “CREATE CONNECTION”.

7. Automaticamente, o cliente MQTTLens irá se conectar ao broker. No campo Subscribe, vamos preencher com o TOPICO_PUBLISH utilizado no código-fonte do projeto (para o exemplo dado: MQTTINCBTempUmid). Em seguida, clicaremos no botão SUBSCRIBE (em verde, à direita do campo).

8. Se o NodeMCU estiver funcionando / ligado, iremos ver as mensagens com as medições, conforme mostra a figura 9.

 

 

 

Figura 9 - mensagens
Figura 9 - mensagens

 

 

9. Pronto! Agora de qualquer lugar do mundo é possível saber quais são as medições feitas pelo projeto!!

 

 

Conclusão

Neste artigo, vimos como incrementar o projeto “Como utilizar o sensor de temperatura e umidade relativa DHT22 com o NodeMCU”, acrescentando a ele a funcionalidade de publicar as medições na Internet via MQTT. Tal funcionalidade permitirá que sejam vistas as medições feitas em qualquer lugar do planeta, desde que haja conexão à Internet disponível.

 

Tal projeto pode ser usado como base para qualquer projeto que requer algum tipo de telemetria pela Internet.

 

 

Referências / artigos relacionados

https://www.filipeflop.com/blog/controle-monitoramento-iot-nodemcu-e-mqtt/ 

http://www.dobitaobyte.com.br/como-usar-mqtt-com-arduino/ 

https://www.filipeflop.com/blog/planta-iot-com-esp8266-nodemcu/ 

 

 

BUSCAR DATASHEET


N° do componente 

(Como usar este quadro de busca)

Opinião

Fim de Férias (OP184)

Para os leitores que estudam ou ensinam e que nos acompanham, agosto marca o término das férias de meio ano. Também para os leitores que trabalham com eletrônica, o mês de agosto também encerra a temporada em que viajam com a família e os filhos justamente devido as férias.

Leia mais...

Amar
Se quiseres ser amado, ama. (Si vis amari, ama.)
Sêneca (55 a.C - 39 d.C.) - Epístolas - Ver mais frases


Instituto Newton C Braga
Entre em contato - Como Anunciar - Políticas do Site

Apoio Social
Lions Clube de Guarulhos Sul SOS Mater Amabilis
Advertise in Brazil
If your business is Electronics, components or devices, this site is the correct place to insert your advertisement (see more)