Estação meteorológica de IoT com RPi e ESP8266: 10 etapas

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

Em tutoriais anteriores, estivemos brincando com NodeMCU, sensores e aprendendo como capturar e registrar dados no ThingSpeak (uma plataforma de Internet das Coisas (IoT) que permite coletar e armazenar dados do sensor na nuvem e desenvolver aplicativos IoT):

IOT FÁCIL: CAPTURA DE DADOS DE TEMPO REMOTO: TEMPERATURA E UMIDADE DO AR E UV

Com este novo tutorial, aprenderemos como fazer o mesmo, mas desta vez, usando um Raspberry Pi para capturar dados de vários sensores diferentes e também explorando diferentes formas de comunicação entre dispositivos e a web:

Sensores e tipo de Cominicação:

• DHT22 (Temperatura e Umidade) ==> Comunicação digital
• BMP180 (Temperatura e Pressão) ==> Protocolo I2C
• DS18B20 (temperatura) ==> Protocolo de 1 fio

O diagrama de blocos mostra o que obteremos no final com este projeto:

Etapa 1: BoM - Lista de materiais

1. Raspberry Pi V3 - US $ 32,00
2. Sensor DHT22 de Temperatura e Umidade Relativa - US $ 9,95
3. Resistor 4K7 ohm
4. Sensor de temperatura à prova d'água DS18B20 - US $ 5,95
5. Resistor 4K7 ohm
6. Sensor de pressão barométrica, temperatura e altitude BMP180 - US $ 6,99

Etapa 2: instalação do sensor de temperatura e umidade

O primeiro sensor a ser instalado será o DHT22 para captura de dados de temperatura e umidade relativa do ar. O site ADAFRUIT fornece ótimas informações sobre esses sensores. Abaixo, algumas informações obtidas a partir daí:

Visão geral

Os sensores de temperatura e umidade DHT de baixo custo são muito básicos e lentos, mas são ótimos para entusiastas que desejam fazer alguns registros básicos de dados. Os sensores DHT são compostos por duas partes, um sensor capacitivo de umidade e um termistor. Há também um chip muito básico que faz algumas conversões de analógico para digital e emite um sinal digital com a temperatura e a umidade. O sinal digital é bastante fácil de ser lido usando qualquer microcontrolador.

DHT22 Principais características:

• Baixo custo
• 3 a 5 V de potência e E / S
• 2,5mA máximo de uso de corrente durante a conversão (ao solicitar dados)
• Bom para leituras de umidade de 0-100% com precisão de 2-5%
• Bom para leituras de temperatura de -40 a 125 ° C precisão de ± 0,5 ° C
• Taxa de amostragem não superior a 0,5 Hz (uma vez a cada 2 segundos)
• Tamanho do corpo 15,1 mm x 25 mm x 7,7 mm
• 4 pinos com espaçamento de 0,1"

Uma vez que normalmente você usará o sensor em distâncias menores que 20m, um resistor de 4 K7 ohm deve ser conectado entre os pinos de Dados e VCC. O pino de dados de saída DHT22 será conectado ao Raspberry GPIO 16. Verifique o diagrama elétrico acima, conectando o sensor aos pinos RPi como abaixo:

1. Pino 1 - Vcc ==> 3,3 V
2. Pino 2 - Dados ==> GPIO 16
3. Pino 3 - Não Conectar
4. Pino 4 - Gnd ==> Gnd

Não se esqueça de instalar o resistor de 4 K7 ohm entre Vcc e pinos de dados

Uma vez que o sensor esteja conectado, devemos também instalar sua biblioteca em nosso RPi.

Instalando a Biblioteca DHT:

No Raspberry, começando em / home, vá para / Documentos

Documentos cd

Crie um diretório para instalar a biblioteca e vá para lá:

mkdir DHT22_Sensor

cd DHT22_Sensor

Em seu navegador, acesse Adafruit GitHub:

github.com/adafruit/Adafruit_Python_DHT

Baixe a biblioteca clicando no link zip de download à direita e descompacte o arquivo na pasta Raspberry Pi criada recentemente. Em seguida, vá para o diretório da biblioteca (subpasta que é criada automaticamente quando você descompacta o arquivo) e execute o comando:

sudo python3 setup.py install

Abra um programa de teste (DHT22_test.py) no meu GITHUB

importar Adafruit_DHT

DHT22Sensor = Adafruit_DHT. DHT22 DHTpin = 16 umidade, temperatura = Adafruit_DHT.read_retry (DHT22Sensor, DHTpin) se a umidade não for Nenhuma e a temperatura não for Nenhuma: print ('Temp = {0: 0.1f} * C Umidade = {1: 0,1 f}% '. format (temperatura, umidade)) else: print (' Falha ao obter leitura. Tente novamente! ')

Execute o programa com o comando:

python3 DHT22_test.py

A tela de impressão do Terminal abaixo mostra o resultado.

Etapa 3: Instalação do DS18B20 - Sensor de temperatura

Visão geral do sensor:

Usaremos neste tutorial uma versão à prova d'água do sensor DS18B20. É muito útil para temperaturas remotas em condições úmidas, por exemplo, em um solo úmido. O sensor é isolado e pode fazer medições até 125oC (Adafrut não recomenda seu uso acima de 100oC devido ao seu revestimento de PVC do cabo).

O DS18B20 é um sensor digital, o que o torna bom para uso mesmo em longas distâncias! Esses sensores de temperatura digitais de 1 fio são bastante precisos (± 0,5 ° C em grande parte da faixa) e podem fornecer até 12 bits de precisão do conversor digital para analógico integrado. Eles funcionam muito bem com o NodeMCU usando um único pino digital, e você pode até conectar vários pinos ao mesmo pino, cada um com um ID de 64 bits exclusivo gravado na fábrica para diferenciá-los.

O sensor funciona de 3,0 a 5,0V, o que significa que pode ser alimentado diretamente do 3,3V fornecido por um dos pinos do Raspberry (1 ou 17).

O sensor tem 3 fios:

• Preto: GND
• Vermelho: VCC
• Amarelo: Dados de 1 fio

Aqui, você pode encontrar os dados completos: Folha de Dados DS18B20

Instalação do sensor:

Siga o diagrama acima e faça as conexões:

• Vcc ==> 3,3V
• Gnd ==> Gnd
• Dados ==> GPIO 4 (padrão para biblioteca)

Instalando a biblioteca Python:

A seguir, vamos instalar a biblioteca Python que manipulará o sensor:

sudo pip3 install w1thermsensor

Antes de executar o script para testar o sensor, verifique se a interface "1-Wire" está habilitada no seu RPi (veja a tela de impressão acima)

Não se esqueça de reiniciar seu RPi, após alterar sua configuração

Testando o sensor:

Para testar o sensor, um script Python simples pode ser usado:

tempo de importação

from w1thermsensor import W1ThermSensor ds18b20Sensor = W1ThermSensor () enquanto True: temperature = ds18b20Sensor.get_temperature () print ("A temperatura é% s celsius"% temperatura) time.sleep (1)

Etapa 4: Instalando o BMP180

Visão geral do sensor:

O BMP180 é o sucessor do BMP085, uma nova geração de sensores de pressão digital de alta precisão para aplicações de consumo. A eletrônica de ultra-baixa potência e baixa tensão do BMP180 é otimizada para uso em telefones celulares, PDAs, dispositivos de navegação GPS e equipamentos externos. Com um ruído de baixa altitude de apenas 0,25m em um tempo de conversão rápido, o BMP180 oferece desempenho superior. A interface I2C permite uma fácil integração do sistema com um microcontrolador. O BMP180 é baseado em tecnologia piezo-resistiva para robustez EMC, alta precisão e linearidade, bem como estabilidade de longo prazo.

A ficha técnica completa do BMP pode ser encontrada aqui: BMP180 - Sensor Digital de Pressão

Instalação do sensor: Siga o diagrama acima e faça as conexões:

• Vin ==> 3,3V
• GND ==> GND
• SCL ==> GPIO 3
• SDA ==> GPIO 2

Habilitando Interface I2C

Vá para Configuração RPi e confirme se a interface I2C está habilitada. Caso contrário, habilite-o e reinicie o RPi.

Usando o BMP180

Se tudo foi instalado corretamente e tudo está conectado corretamente, agora você está pronto para ligar seu Pi e começar a ver o que o BMP180 está lhe dizendo sobre o mundo ao seu redor.

A primeira coisa a fazer é verificar se o Pi vê seu BMP180. Experimente o seguinte em uma janela de terminal:

sudo i2cdetect -y 1

Se o comando funcionou, você deve ver algo semelhante ao Terminal Printscreen acima, mostrando que o BMP180 está no canal '77'.

Instalando a Biblioteca BMP180:

Crie um diretório para instalar a biblioteca:

mkdir BMP180_Sensorcd BMP180_Sensor

No seu navegador, acesse Adafruit GITHub:

github.com/adafruit/Adafruit_Python_BMP

Baixe a biblioteca clicando no link zip de download à direita e descompacte o arquivo na pasta criada no Raspberry Pi. Em seguida, vá até a subpasta criada e execute o seguinte comando no diretório da biblioteca:

sudo python3 setup.py install

Abra seu Python IDE e crie um programa de teste e nomeie-o, por exemplo BMP180Test.py

import Adafruit_BMP. BMP085 como BMP085sensor = BMP085. BMP085 () print ('Temp = {0: 0.2f} * C'.format (sensor.read_temperature ())) print (' Pressão = {0: 0.2f} Pa '. format (sensor.read_pressure ())) print ('Altitude = {0: 0.2f} m'.format (sensor.read_altitude ())) print (' Sealevel Pressure = {0: 0.2f} Pa'.format (sensor.read_sealevel_pressure ()))

Execute o programa de teste:

python3 BMP180Test.py

A tela de impressão do Terminal acima mostra o resultado.

Observe que essa pressão é apresentada em Pa (Pascals). Veja a próxima etapa para entender melhor esta unidade.

Etapa 5: Medir o clima e a altitude com BMP180

Vamos dedicar um tempo para entender um pouco mais sobre o que obteremos com as leituras de BMP. Você pode pular esta parte do tutorial ou retornar mais tarde.

Se você quiser saber mais sobre as leituras do sensor, vá para este ótimo tutorial:

O BMP180 foi projetado para medir com precisão a pressão atmosférica. A pressão atmosférica varia com o clima e a altitude.

O que é pressão atmosférica?

A definição de pressão atmosférica é a força que o ar ao seu redor exerce sobre tudo. O peso dos gases na atmosfera cria a pressão atmosférica. Uma unidade comum de pressão é "libras por polegada quadrada" ou psi. Usaremos aqui a notação internacional, ou seja, newtons por metro quadrado, que são chamados de pascais (Pa).

Se você pegasse 1 cm de largura, a coluna de ar pesaria cerca de 1 kg

Esse peso, pressionando a pegada dessa coluna, cria a pressão atmosférica que podemos medir com sensores como o BMP180. Como essa coluna de ar com cm de largura pesa cerca de 1 kg, segue-se que a pressão média ao nível do mar é de cerca de 101325 pascal, ou melhor, 1013,25 hPa (1 hPa também é conhecido como milibar - mbar). Isso cairá cerca de 4% para cada 300 metros que você subir. Quanto mais alto você chega, menos pressão você verá, porque a coluna no topo da atmosfera é muito mais curta e, portanto, pesa menos. É útil saber disso, porque medindo a pressão e fazendo algumas contas, você pode determinar sua altitude.

A pressão do ar a 3,810 metros é apenas metade daquela ao nível do mar.

O BMP180 emite pressão absoluta em pascal (Pa). Um pascal é uma pressão muito pequena, aproximadamente a quantidade que uma folha de papel exercerá sobre uma mesa. Você verá com mais frequência as medições em hectopascais (1 hPa = 100 Pa). A biblioteca usada aqui fornece resultados de valores de ponto flutuante em hPa, que também equivalem a um milibar (mbar).

Aqui estão algumas conversões para outras unidades de pressão:

• 1 hPa = 100 Pa = 1 mbar = 0,001 bar
• 1 hPa = 0,75006168 Torr
• 1 hPa = 0,01450377 psi (libras por polegada quadrada)
• 1 hPa = 0,02953337 inHg (polegadas de mercúrio)
• 1 hpa = 0,00098692 atm (atmosferas padrão)

Efeitos de temperatura

Como a temperatura afeta a densidade de um gás, e a densidade afeta a massa de um gás, e a massa afeta a pressão (ufa), a pressão atmosférica mudará dramaticamente com a temperatura. Os pilotos conhecem isso como “altitude de densidade”, o que facilita a decolagem em um dia frio do que quente, pois o ar é mais denso e tem maior efeito aerodinâmico. Para compensar a temperatura, o BMP180 inclui um sensor de temperatura bastante bom, bem como um sensor de pressão.

Para realizar uma leitura de pressão, primeiro você faz uma leitura de temperatura e, em seguida, combina-a com uma leitura de pressão bruta para chegar a uma medição de pressão compensada por temperatura final. (A biblioteca torna tudo isso muito fácil.)

Medindo a pressão absoluta

Se sua aplicação requer medição de pressão absoluta, tudo que você precisa fazer é obter uma leitura de temperatura e, em seguida, realizar uma leitura de pressão (consulte o esboço de exemplo para obter detalhes). A leitura final da pressão será em hPa = mbar. Se desejar, você pode convertê-lo em uma unidade diferente usando os fatores de conversão acima.

Observe que a pressão absoluta da atmosfera variará com a altitude e os padrões climáticos atuais, sendo que ambos são itens úteis para medir.

Observações do tempo

A pressão atmosférica em qualquer local da Terra (ou em qualquer lugar com uma atmosfera) não é constante. A complexa interação entre a rotação da Terra, a inclinação do eixo e muitos outros fatores resultam em áreas móveis de maior e menor pressão, que por sua vez causam as variações no clima que vemos todos os dias. Ao observar as mudanças na pressão, você pode prever mudanças de curto prazo no clima. Por exemplo, a queda de pressão geralmente significa tempo chuvoso ou uma tempestade se aproximando (um sistema de baixa pressão está se aproximando). O aumento da pressão geralmente significa que o tempo claro está se aproximando (um sistema de alta pressão está se movendo). Mas lembre-se de que a pressão atmosférica também varia com a altitude. A pressão absoluta na minha casa, Lo Barnechea no Chile (altitude 950m) será sempre menor do que a pressão absoluta em San Francisco por exemplo (menos de 2 metros, quase nível do mar). Se as estações meteorológicas apenas relatassem sua pressão absoluta, seria difícil comparar diretamente as medições de pressão de um local para outro (e as previsões meteorológicas em grande escala dependem das medições do maior número de estações possível).

Para resolver esse problema, as estações meteorológicas sempre removem os efeitos da altitude de suas leituras de pressão relatadas, adicionando matematicamente a pressão fixa equivalente para fazer parecer que a leitura foi feita ao nível do mar. Quando você fizer isso, uma leitura mais alta em São Francisco do que em Lo Barnechea sempre será por causa dos padrões do clima, e não por causa da altitude.

Para fazer isso, existe uma função na biblioteca chamada nível do mar (P, A). Isso leva a pressão absoluta (P) em hPa e a altitude atual da estação (A) em metros e remove os efeitos da altitude da pressão. Você pode usar a saída desta função para comparar diretamente suas leituras do tempo com outras estações ao redor do mundo.

Determinando Altitude

Como a pressão varia com a altitude, você pode usar um sensor de pressão para medir a altitude (com algumas ressalvas). A pressão média da atmosfera ao nível do mar é 1013,25 hPa (ou mbar). Isso cai para zero conforme você sobe em direção ao vácuo do espaço. Como a curva dessa queda é bem compreendida, você pode calcular a diferença de altitude entre duas medições de pressão (p e p0) usando uma equação específica.

Se você usar a pressão ao nível do mar (1013,25 hPa) como a pressão de linha de base (p0), a saída da equação será sua altitude atual acima do nível do mar. Há uma função na biblioteca chamada altitude (P, P0) que permite obter a "altitude calculada".

A explicação acima foi extraída do tutorial do BMP 180 Sparkfun.

Etapa 6: O HW completo

Etapa 7: Enviando dados para ThingSpeak

Neste ponto, aprendemos como preparar o RPi para capturar dados de todos os 3 sensores, imprimindo-os no terminal. Agora, é hora de ver como enviar esses dados para a plataforma IoT, o ThingSpeak.

Vamos começar!

Primeiro, você deve ter uma conta no ThinkSpeak.com

Siga as instruções para criar um canal e anote o ID do canal e a chave de API de gravação

Baixe o Python Script do meu GitHub: localData ToTS_v1_EXT.py

Vamos comentar as partes mais importantes do código:

Primeiro, vamos importar a biblioteca ThingSpeak, definir o cliente WiFi e definir suas credenciais de Roteador e Thinkspeak locais:

import Thingspeak

Existem várias maneiras de se comunicar com o ThingSpeak, a maneira mais simples seria usar a biblioteca do cliente para a API do thingspeak.com desenvolvida por Mikolaj Chwaliz e Keith Ellis.

A biblioteca pode ser baixada em https://github.com/mchwalisz/thingspeak ou usando PIP no terminal:

sudo pip3 install thingspeak

Em seguida, dentro do script, atualize as credenciais do canal ThingSpeak

chId = 9999999 # Insira com o Id do canal

tsKey = 'ENTRE COM A CHAVE DE ESCRITA DO CANAL' tsUrl = 'https://api.thingspeak.com/update' ts = thingspeak. Channel (chId, tsUrl, tsKey)

Agora, vamos inicializar os 3 sensores:

# DS18B20 Biblioteca de 1 fio

from w1thermsensor import W1ThermSensor ds18b20Sensor = W1ThermSensor () # Por padrão, o GPIO 4 é usado pela biblioteca # DHT22 Importação da biblioteca Adafruit_DHT DHT22Sensor = Adafruit_DHT. DHT22 DHTpin = 16 # BMP180 BMP180 biblioteca import Adafruit0. BMP85. BMP85 BMP85 BMP85 BMP80 as80B85 (BMP85 BMP85) Você deve definir a altitude real onde sua estação meteorológica está localizada, atualizando a variável global "altReal". No meu caso, minha estação está localizada a 950m acima do nível do mar

altReal global

altReal = 950

Depois de inserir a altitude real da estação como entrada, podemos obter a pressão absoluta, pressão ao nível do mar, temperatura e altitude usando a função bmp180GetData (altitude):

def bmp180GetData (altitude):

temp = bmp180Sensor.read_temperature () pres = bmp180Sensor.read_pressure () alt=bmp180Sensor.read_altitude () presSeaLevel = pres / pow (1.0 - altitude / 44330.0, 5.255) temp = round (temp, 1) pres = round (pres / 100, 2) # pressão absoluta em hPa (ou mbar) alt=round (alt) presSeaLevel = round (presSeaLevel / 100, 2) # pressão absoluta em hPa (ou mbar) temperatura de retorno, pres, alt, presSeaLevel

A função getLocalData () retornará todos os dados locais que são capturados por nossa estação:

def getLocalData ():

global timeString global humLab global tempExt global tempLab global presSL global altLab global presAbs # Obter tempo de leitura agora = datetime.datetime.now () timeString = now.strftime ("% Y-% m-% d% H:% M") # Ler temperatura externa (1 metro de distância) tempExt = round (ds18b20Sensor.get_temperature (), 1) tempLab, presAbs, altLab, presSL = bmp180GetData (altReal) humDHT, tempDHT = Adafruit_DHT.read_retry (DHT22Sensor, DHTpin não) Nenhum e tempDHT não é Nenhum: humLab = round (humDHT

Depois de ter todos os dados capturados pelas funções acima, você deve enviá-los para ThingSpeak. Você fará isso usando a função sendDataTs ():

def sendDataTs ():

data = {"field1": tempLab, "field2": tempExt, "field3": humLab, "field4": presSL, "field5": altLab} ts.update (data) print ("[INFO] Dados enviados para 5 campos: ", tempLab, tempExt, humLab, presSL, altLab)

Com os dados do seu canal atualizados, salve o script e execute-o em seu terminal:

sudo Python3 localData_ToTs_v1_EXT.py

Sobre protocolos de comunicação

Observe que usando a "biblioteca thingspeak", a "biblioteca de solicitações" é importada, ou seja, uma biblioteca HTTP licenciada Apache2, escrita em Python. A documentação oficial do Request Installation pode ser encontrada aqui:

docs.python-requests.org/en/latest/user/install/

Se necessário, antes de executar seu script, você pode verificar se a biblioteca de solicitações está instalada:

solicitações de instalação do sudo pip3

Opcionalmente, você pode usar MTTQ como um método para enviar dados para ThingSpeak. MQTT é diferente de HTTP, uma vez que é projetado especificamente para ser leve e destinado a dispositivos integrados com baixo desempenho de RAM e CPU. Além disso, na maioria dos casos, o MQTT usa menos largura de banda.

Consulte este tutorial: Atualizar um canal ThingSpeak usando MQTT em um Raspberry Pi para obter mais detalhes.

Etapa 8: Envio de dados remotos para ThingSpeak usando ESP8266

Para esta etapa, usaremos o mesmo HW que foi explicado em muy tutorial:

IOT FÁCIL: CAPTURA DE DADOS DE TEMPO REMOTO: TEMPERATURA E UMIDADE DO AR E UV

O código que usaremos aqui é basicamente o mesmo usado naquele tutorial. Vamos comentar as partes mais importantes do código:

Primeiro, vamos chamar a biblioteca ESP8266, definir o cliente WiFi e definir suas credenciais de Roteador e Thinkspeak locais:

/ * NodeMCU ESP12-E * /

#include cliente WiFiClient; const char * MY_SSID = "ENTRE COM SEU SSDID"; const char * MY_PWD = "ENTRE COM SUA SENHA"; / * Thinkspeak * / const char * TS_SERVER = "api.thingspeak.com"; String TS_API_KEY = "ENTRE COM SUA CHAVE DE ESCRITA";

Em segundo lugar, vamos incluir uma biblioteca muito importante para projetos de IoT: SimpleTimer.h:

/* CRONÔMETRO */

#include SimpleTimer timer;

Terceiro, durante o setup (), iniciaremos a comunicação serial, chamaremos a função connectWiFi () e definiremos os temporizadores. Observe que a linha de código: timer.setInterval (60000L, sendDataTS); irá chamar a função sendDataTS () a cada 60 segundos, a fim de fazer upload de dados para o canal ThinkSpeak.

void setup ()

{… Serial.begin (115200); atraso (10); … ConnectWifi (); timer.setInterval (60000L, sendDataTS); …}

Por último, mas não menos importante, durante o loop (), o único comando necessário é iniciar o cronômetro e pronto!

void loop ()

{… Timer.run (); // Inicia SimpleTimer}

Abaixo, você pode ver as duas funções importantes usadas para lidar com a comunicação Thinkspeak:

Conexão ESP12-E com sua rede WiFi:

/***************************************************

* Conectando WiFi *********************************************** *** / void connectWifi () {Serial.print ("Conectando a" + * MY_SSID); WiFi.begin (MY_SSID, MY_PWD); while (WiFi.status ()! = WL_CONNECTED) {delay (1000); Serial.print ("."); } Serial.println (""); Serial.println ("WiFi conectado"); Serial.println (""); }

ESP12-E enviando dados para ThinkSpeak:

***************************************************

* Enviando dados para o canal Thinkspeak *********************************************** ****** / void sendDataTS (void) {if (client.connect (TS_SERVER, 80)) {String postStr = TS_API_KEY; postStr + = "& field6 ="; postStr + = String (temp); postStr + = "& field7 ="; postStr + = String (hum); postStr + = "& field8 ="; postStr + = String (dataSensorUV); postStr + = "\ r / n / r / n"; client.print ("POST / atualizar HTTP / 1.1 / n"); client.print ("Host: api.thingspeak.com / n"); client.print ("Conexão: fechar / n"); client.print ("X-THINGSPEAKAPIKEY:" + TS_API_KEY + "\ n"); client.print ("Content-Type: application / x-www-form-urlencoded / n"); client.print ("Content-Length:"); client.print (postStr.length ()); client.print ("\ n / n"); client.print (postStr); atraso (1000); } enviado ++; client.stop (); }

O código completo pode ser encontrado em meu GitHub: NodeMCU_UV_DHT_Sensor_OLED_TS_EXT

Depois de fazer o upload do código em seu NodeMCU. Vamos conectar uma bateria externa e fazer algumas medições sob o sol. Coloquei a estação remota no telhado e comecei a capturar dados em ThingSpeak.com, conforme mostrado nas fotos acima.

Etapa 9: Notas Finais

O objetivo principal deste tutorial foi mostrar como conectar o Raspberry Pi ao ThingSpeak. Isso é ótimo para capturar dados e registrá-los em uma plataforma IoT.

Aproveitando a oportunidade, também enviamos dados para aquele canal específico, capturando-os de uma estação remota usando um ESP8266. Esta abordagem está OK, mas não é a melhor. Como temos uma operação "assíncrona", às vezes, ambos, RPi e ESP8266 tentam registrar ao mesmo tempo (ou com um pequeno intervalo) o que é refutado por ThingSpeak. O ideal seria o ESP8266 enviando dados localmente para o Raspberry Pi e sendo o último responsável por tratar todos os dados. Fazendo isso, a "Estação Principal" (Raspberry Pi) poderia fazer 3 coisas:

• Registrar todos os dados em um banco de dados local
• Apresente todos os dados em uma página da Web local (usando o Flask como mostrado na foto acima)
• Enviando todos os dados para ThingSpeak ao mesmo tempo.

Em um tutorial futuro, exploraremos essas opções.

Etapa 10: Conclusão

Como sempre, espero que este projeto possa ajudar outras pessoas a encontrar seu caminho para o emocionante mundo da eletrônica!

Para obter detalhes e o código final, visite meu depósito no GitHub: RPi-NodeMCU-Weather-Station

Para mais projetos, visite meu blog: MJRoBot.org

Fique ligado! No próximo tutorial, enviaremos dados de uma estação meteorológica remota para uma central, com base em um servidor Web Raspberry Pi:

Saludos do sul do mundo!

Vejo você no meu próximo instrutível!

Obrigado, Marcelo