Estación meteorológica IoT con RPi y ESP8266: 10 pasos

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:42

En tutoriales anteriores, hemos estado jugando con NodeMCU, sensores y aprendiendo cómo capturar y registrar datos en ThingSpeak (una plataforma de Internet de las cosas (IoT) que le permite recopilar y almacenar datos de sensores en la nube y desarrollar aplicaciones de IoT):

IOT FÁCIL: CAPTURA DE DATOS METEOROLÓGICOS REMOTOS: TEMPERATURA Y HUMEDAD DEL AIRE Y UV

Con este nuevo tutorial, aprenderemos cómo hacer lo mismo pero en este momento, usando una Raspberry Pi para capturar datos de varios sensores diferentes y también explorando diferentes formas de comunicación entre dispositivos y la web:

Sensores y tipo de comunicación:

• DHT22 (temperatura y humedad) ==> comunicación digital
• BMP180 (temperatura y presión) ==> Protocolo I2C
• DS18B20 (temperatura) ==> Protocolo de 1 cable

El diagrama de bloques muestra lo que obtendremos al final con este proyecto:

Paso 1: BoM - Lista de materiales

1. Raspberry Pi V3 - US $ 32,00
2. Sensor de temperatura y humedad relativa DHT22 - USD 9,95
3. Resistencia 4K7 ohmios
4. Sensor de temperatura impermeable DS18B20 - USD 5,95
5. Resistencia 4K7 ohmios
6. Sensor de altitud, temperatura y presión barométrica BMP180 - USD 6,99

Paso 2: instalación del sensor de temperatura y humedad

El primer sensor que se instalará será el DHT22 para capturar datos de temperatura del aire y humedad relativa. El sitio de ADAFRUIT proporciona gran información sobre esos sensores. A continuación, alguna información recuperada de allí:

Visión general

Los sensores de temperatura y humedad DHT de bajo costo son muy básicos y lentos, pero son excelentes para los aficionados que desean realizar un registro de datos básico. Los sensores DHT están hechos de dos partes, un sensor de humedad capacitivo y un termistor. También hay un chip muy básico en el interior que realiza una conversión analógica a digital y escupe una señal digital con la temperatura y la humedad. La señal digital es bastante fácil de leer con cualquier microcontrolador.

DHT22 Características principales:

• Bajo costo
• E / S y potencia de 3 a 5 V
• Uso de corriente máxima de 2.5mA durante la conversión (mientras se solicitan datos)
• Bueno para lecturas de humedad del 0 al 100% con una precisión del 2 al 5%
• Bueno para lecturas de temperatura de -40 a 125 ° C ± 0.5 ° C de precisión
• No más de 0,5 Hz de frecuencia de muestreo (una vez cada 2 segundos)
• Tamaño del cuerpo 15,1 mm x 25 mm x 7,7 mm
• 4 pines con espaciado de 0.1"

Una vez que, por lo general, usará el sensor en distancias inferiores a 20 m, se debe conectar una resistencia de 4K7 ohmios entre los pines Data y VCC. El pin de datos de salida DHT22 se conectará a Raspberry GPIO 16. Verifique el diagrama eléctrico anterior, conectando el sensor a los pines RPi como se muestra a continuación:

1. Pin 1 - Vcc ==> 3.3V
2. Pin 2 - Datos ==> GPIO 16
3. Pin 3 - No conectar
4. Pin 4 - Gnd ==> Gnd

No olvide instalar la resistencia de 4K7 ohmios entre los pines Vcc y Data

Una vez conectado el sensor, también debemos instalar su librería en nuestro RPi.

Instalación de la biblioteca DHT:

En su Raspberry, comenzando en / home, vaya a / Documents

documentos en cd

Cree un directorio para instalar la biblioteca y muévase allí:

mkdir DHT22_Sensor

cd DHT22_Sensor

En su navegador, vaya a Adafruit GitHub:

github.com/adafruit/Adafruit_Python_DHT

Descargue la biblioteca haciendo clic en el enlace zip de descarga a la derecha y descomprima el archivo en su carpeta recientemente creada de Raspberry Pi. Luego vaya al directorio de la biblioteca (subcarpeta que se crea automáticamente cuando descomprimió el archivo) y ejecute el comando:

sudo python3 setup.py instalar

Abra un programa de prueba (DHT22_test.py) desde mi GITHUB

importar Adafruit_DHT

DHT22Sensor = Adafruit_DHT. DHT22 DHTpin = 16 humedad, temperatura = Adafruit_DHT.read_retry (DHT22Sensor, DHTpin) si la humedad no es Ninguna y la temperatura no es Ninguna: print ('Temp = {0: 0.1f} * C Humedad = {1: 0.1 f}% '. formato (temperatura, humedad)) else: print (' No se pudo obtener la lectura. ¡Inténtalo de nuevo! ')

Ejecute el programa con el comando:

python3 DHT22_test.py

La siguiente pantalla de impresión de Terminal muestra el resultado.

Paso 3: Instalación del DS18B20 - Sensor de temperatura

Descripción general del sensor:

Usaremos en este tutorial una versión impermeabilizada del sensor DS18B20. Es muy útil para temperaturas remotas en condiciones húmedas, por ejemplo en un suelo húmedo. El sensor está aislado y puede tomar medidas hasta 125oC (Adafrut no recomienda utilizarlo por encima de 100oC debido a su cable forrado de PVC).

El DS18B20 es un sensor digital que lo hace bueno para usar incluso en largas distancias. Estos sensores de temperatura digitales de 1 cable son bastante precisos (± 0,5 ° C en gran parte del rango) y pueden proporcionar hasta 12 bits de precisión desde el convertidor de digital a analógico integrado. Funcionan muy bien con NodeMCU usando un solo pin digital, e incluso puede conectar varios al mismo pin, cada uno tiene una identificación única de 64 bits grabada en la fábrica para diferenciarlos.

El sensor funciona de 3.0 a 5.0V, lo que significa que puede ser alimentado directamente desde los 3.3V proporcionados por uno de los pines Raspberry (1 o 17).

El sensor tiene 3 cables:

• Negro: GND
• Rojo: VCC
• Amarillo: datos de 1 cable

Aquí puede encontrar los datos completos: Hoja de datos DS18B20

Instalación del sensor:

Siga el diagrama anterior y realice las conexiones:

• Vcc ==> 3,3 V
• Gnd ==> Gnd
• Datos ==> GPIO 4 (predeterminado para biblioteca)

Instalación de la biblioteca de Python:

A continuación, instalemos la biblioteca de Python que manejará el sensor:

sudo pip3 instalar w1thermsensor

Antes de ejecutar el script para probar el sensor, verifique si la interfaz "1-Wire" está habilitada en su RPi (vea la pantalla de impresión anterior)

No olvide reiniciar su RPi, luego de cambiar su configuración

Probando el sensor:

Para probar el sensor, se puede usar un script de Python simple:

tiempo de importación

from w1thermsensor import W1ThermSensor ds18b20Sensor = W1ThermSensor () while True: temperature = ds18b20Sensor.get_temperature () print ("La temperatura es% s celsius"% temperature) time.sleep (1)

Paso 4: Instalación del BMP180

Descripción general del sensor:

El BMP180 es el sucesor del BMP085, una nueva generación de sensores de presión digitales de alta precisión para aplicaciones de consumo. La electrónica de bajo voltaje y potencia ultrabaja del BMP180 está optimizada para su uso en teléfonos móviles, PDA, dispositivos de navegación GPS y equipos para exteriores. Con un ruido de baja altitud de solo 0,25 m en un tiempo de conversión rápido, el BMP180 ofrece un rendimiento superior. La interfaz I2C permite una fácil integración del sistema con un microcontrolador. El BMP180 se basa en tecnología piezorresistiva para robustez EMC, alta precisión y linealidad, así como estabilidad a largo plazo.

La hoja de datos completa de BMP se puede encontrar aquí: BMP180 - Sensor de presión digital

Instalación del sensor: siga el diagrama anterior y realice las conexiones:

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

Habilitación de la interfaz I2C

Vaya a Configuración de RPi y confirme que la interfaz I2C está habilitada. Si no es así, habilítelo y reinicie el RPi.

Usando el BMP180

Si todo se instaló correctamente y todo se conectó correctamente, ahora está listo para encender su Pi y comenzar a ver lo que la BMP180 le dice sobre el mundo que lo rodea.

Lo primero que debe hacer es verificar si el Pi ve su BMP180. Intente lo siguiente en una ventana de terminal:

sudo i2cdetect -y 1

Si el comando funcionó, debería ver algo similar en la pantalla de impresión de terminal anterior, que muestra que el BMP180 está en el canal '77'.

Instalación de la biblioteca BMP180:

Cree un directorio para instalar la biblioteca:

mkdir BMP180_Sensorcd BMP180_Sensor

En su navegador, vaya a Adafruit GITHub:

github.com/adafruit/Adafruit_Python_BMP

Descargue la biblioteca haciendo clic en el enlace zip de descarga a la derecha y descomprima el archivo en la carpeta creada por Raspberry Pi. Luego vaya a la subcarpeta creada y ejecute el siguiente comando en el directorio de la biblioteca:

sudo python3 setup.py instalar

Abra su Python IDE y cree un programa de prueba y asígnele un nombre, por ejemplo, BMP180Test.py

importar Adafruit_BMP. BMP085 como BMP085sensor = BMP085. BMP085 () print ('Temp = {0: 0.2f} * C'.format (sensor.read_temperature ())) print (' Pressure = {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 ()))

Ejecute el programa de prueba:

python3 BMP180Test.py

La pantalla de impresión de Terminal anterior muestra el resultado.

Tenga en cuenta que esa presión se presenta en Pa (Pascales). Consulte el siguiente paso para comprender mejor esta unidad.

Paso 5: Medición del clima y la altitud con BMP180

Tomemos un tiempo para comprender un poco más sobre lo que obtendremos con las lecturas de BMP. Puede omitir esta parte del tutorial o regresar más tarde.

Si desea saber más sobre las lecturas del sensor, vaya a este excelente tutorial:

El BMP180 fue diseñado para medir con precisión la presión atmosférica. La presión atmosférica varía tanto con el clima como con la altitud.

¿Qué es la presión atmosférica?

La definición de presión atmosférica es una fuerza que el aire que te rodea ejerce sobre todo. El peso de los gases en la atmósfera crea presión atmosférica. Una unidad común de presión es "libras por pulgada cuadrada" o psi. Usaremos aquí la notación internacional, es decir, newtons por metro cuadrado, que se llaman pascales (Pa).

Si tomara una columna de aire de 1 cm de ancho, pesaría aproximadamente 1 kg

Este peso, presionando la huella de esa columna, crea la presión atmosférica que podemos medir con sensores como el BMP180. Debido a que esa columna de aire de cm de ancho pesa aproximadamente 1 kg, se deduce que la presión promedio al nivel del mar es de aproximadamente 101325 pascales, o mejor, 1013.25 hPa (1 hPa también se conoce como milibar - mbar). Esto bajará aproximadamente un 4% por cada 300 metros que asciendas. Cuanto más alto llegue, menos presión verá, porque la columna hasta la parte superior de la atmósfera es mucho más corta y, por lo tanto, pesa menos. Es útil saber esto, porque midiendo la presión y haciendo algunos cálculos, puede determinar su altitud.

La presión del aire a 3.810 metros es sólo la mitad que al nivel del mar.

El BMP180 emite presión absoluta en pascales (Pa). Un pascal es una cantidad muy pequeña de presión, aproximadamente la cantidad que ejercerá una hoja de papel sobre una mesa. Verá más a menudo mediciones en hectopascales (1 hPa = 100 Pa). La biblioteca utilizada aquí proporciona valores de punto flotante de salida en hPa, que también es igual a un milibar (mbar).

A continuación, se muestran algunas conversiones a otras unidades de presión:

• 1 hPa = 100 Pa = 1 mbar = 0,001 bar
• 1 hPa = 0,75006168 Torr
• 1 hPa = 0.01450377 psi (libras por pulgada cuadrada)
• 1 hPa = 0.02953337 inHg (pulgadas de mercurio)
• 1 hpa = 0.00098692 atm (atmósferas estándar)

Efectos de la temperatura

Debido a que la temperatura afecta la densidad de un gas y la densidad afecta la masa de un gas, y la masa afecta la presión (uf), la presión atmosférica cambiará drásticamente con la temperatura. Los pilotos conocen esto como “altitud de densidad”, lo que facilita el despegue en un día frío que en uno caluroso porque el aire es más denso y tiene un mayor efecto aerodinámico. Para compensar la temperatura, el BMP180 incluye un sensor de temperatura bastante bueno, así como un sensor de presión.

Para realizar una lectura de presión, primero toma una lectura de temperatura, luego la combina con una lectura de presión bruta para obtener una medición de presión final compensada por temperatura. (La biblioteca hace que todo esto sea muy fácil).

Medición de la presión absoluta

Si su aplicación requiere medir la presión absoluta, todo lo que tiene que hacer es obtener una lectura de temperatura y luego realizar una lectura de presión (consulte el boceto de ejemplo para obtener más detalles). La lectura de presión final estará en hPa = mbar. Si lo desea, puede convertir esto a una unidad diferente utilizando los factores de conversión anteriores.

Tenga en cuenta que la presión absoluta de la atmósfera variará tanto con su altitud como con los patrones climáticos actuales, los cuales son elementos útiles para medir.

Observaciones meteorológicas

La presión atmosférica en cualquier lugar de la Tierra (o en cualquier lugar con atmósfera) no es constante. La compleja interacción entre el giro de la Tierra, la inclinación del eje y muchos otros factores dan como resultado áreas en movimiento de mayor y menor presión, que a su vez provocan las variaciones en el clima que vemos todos los días. Al observar los cambios en la presión, puede predecir cambios a corto plazo en el clima. Por ejemplo, la caída de presión generalmente significa que se avecina un clima húmedo o una tormenta (se está moviendo un sistema de baja presión). El aumento de la presión generalmente significa que se acerca un clima despejado (se está moviendo un sistema de alta presión). Pero recuerde que la presión atmosférica también varía con la altitud. La presión absoluta en mi casa, Lo Barnechea en Chile (altitud 950m) siempre será menor que la presión absoluta en San Francisco por ejemplo (menos de 2 metros, casi al nivel del mar). Si las estaciones meteorológicas solo informaran su presión absoluta, sería difícil comparar directamente las mediciones de presión de un lugar a otro (y las predicciones meteorológicas a gran escala dependen de las mediciones de tantas estaciones como sea posible).

Para resolver este problema, las estaciones meteorológicas siempre eliminan los efectos de la altitud de sus lecturas de presión informadas agregando matemáticamente la presión fija equivalente para que parezca que la lectura se tomó al nivel del mar. Cuando haga esto, una lectura más alta en San Francisco que en Lo Barnechea siempre será debido a los patrones climáticos y no a la altitud.

Para hacer esto, hay una función en la biblioteca llamada nivel del mar (P, A). Esto toma la presión absoluta (P) en hPa y la altitud actual de la estación (A) en metros, y elimina los efectos de la altitud de la presión. Puede utilizar la salida de esta función para comparar directamente sus lecturas meteorológicas con otras estaciones de todo el mundo.

Determinación de la altitud

Dado que la presión varía con la altitud, puede usar un sensor de presión para medir la altitud (con algunas advertencias). La presión media de la atmósfera al nivel del mar es 1013,25 hPa (o mbar). Esto desciende a cero a medida que asciende hacia el vacío del espacio. Debido a que se comprende bien la curva de esta caída, puede calcular la diferencia de altitud entre dos mediciones de presión (p y p0) utilizando una ecuación específica.

Si utiliza la presión a nivel del mar (1013,25 hPa) como presión de referencia (p0), la salida de la ecuación será su altitud actual sobre el nivel del mar. Hay una función en la biblioteca llamada altitud (P, P0) que le permite obtener la "altitud calculada".

La explicación anterior se extrajo del tutorial BMP 180 Sparkfun.

Paso 6: El HW completo

Paso 7: Envío de datos a ThingSpeak

En este punto, aprendimos cómo preparar el RPi para capturar datos de los 3 sensores e imprimirlos en el terminal. Ahora es el momento de ver cómo enviar esos datos a nuestra plataforma de IoT, ThingSpeak.

¡Vamos a empezar!

Primero, debe tener una cuenta en ThinkSpeak.com

Sigue las instrucciones para crear un canal y toma nota de tu ID de canal y escribe la clave de API.

Descargue el script de Python desde mi GitHub: localData ToTS_v1_EXT.py

Comentemos las partes más importantes del código:

Primero, importemos la biblioteca ThingSpeak, definamos el cliente WiFi y definamos las credenciales de su enrutador local y Thinkspeak:

importar cosas

Hay varias formas de comunicarse con ThingSpeak, la forma más sencilla sería utilizar la biblioteca cliente para la API thingspeak.com desarrollada por Mikolaj Chwaliz y Keith Ellis.

La biblioteca se puede descargar desde https://github.com/mchwalisz/thingspeak o usar PIP en la terminal:

sudo pip3 instalar thingspeak

A continuación, dentro del script, actualice las credenciales del canal ThingSpeak

chId = 9999999 # Ingresa con tu ID de canal

tsKey = 'ENTRAR CON SU CLAVE DE ESCRITURA DE CANAL' tsUrl = 'https://api.thingspeak.com/update' ts = thingspeak. Channel (chId, tsUrl, tsKey)

Ahora, inicialicemos los 3 sensores:

# DS18B20 Biblioteca de 1 cable

de w1thermsensor import W1ThermSensor ds18b20Sensor = W1ThermSensor () # Por defecto GPIO 4 es usado por la biblioteca # DHT22 Importación de biblioteca Adafruit_DHT DHT22Sensor = Adafruit_DHT. DHT22 DHTpin = 16 # BMP180 importación de biblioteca Adafruit_BMP. BMP085 as180 Debe definir la altitud real donde se encuentra su Estación Meteorológica, actualizando la variable Global "altReal". En mi caso, mi Estación se encuentra a 950 m sobre el nivel del mar.

global altReal

altReal = 950

Una vez ingresada con la altitud real de la estación como entrada, podemos obtener la presión absoluta, presión a nivel del mar, temperatura y altitud usando la función bmp180GetData (altitud):

def bmp180GetData (altitud):

temp = bmp180Sensor.read_temperature () pres = bmp180Sensor.read_pressure () alt=bmp180Sensor.read_altitude () presSeaLevel = pres / pow (1.0 - altitud / 44330.0, 5.255) temp = round (temp, 1) pres = round (pres / 100, 2) # presión absoluta en hPa (o mbar) alt=round (alt) presSeaLevel = round (presSeaLevel / 100, 2) # presión absoluta en hPa (o mbar) temperatura de retorno, pres, alt, presSeaLevel

La función getLocalData (), devolverá todos los datos locales que son capturados por nuestra estación:

def getLocalData ():

global timeString global humLab global tempExt global tempLab global presSL global altLab global presAbs # Obtener hora de lectura ahora = datetime.datetime.now () timeString = now.strftime ("% Y-% m-% d% H:% M") # Leer temperatura exterior (1 metro de distancia) tempExt = round (ds18b20Sensor.get_temperature (), 1) tempLab, presAbs, altLab, presSL = bmp180GetData (altReal) humDHT, tempDHT = Adafruit_DHT.read_retry (DHT22Sensor, DHTpin no es ninguno) si y tempDHT no es None: humLab = round (humDHT

Una vez que tenga todos los datos capturados por las funciones anteriores, debe enviarlos a ThingSpeak. Lo harás usando la función sendDataTs ():

def sendDataTs ():

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

Con los datos de su canal actualizados, guarde el script y ejecútelo en su terminal:

sudo Python3 localData_ToTs_v1_EXT.py

Acerca de los protocolos de comunicación

Tenga en cuenta que al usar la "biblioteca thingspeak", se importa la "biblioteca de solicitudes", que es una biblioteca HTTP con licencia de Apache2, escrita en Python. La documentación oficial de solicitud de instalación se puede encontrar aquí:

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

Si es necesario, antes de ejecutar su script, puede verificar si la biblioteca de solicitudes está instalada:

solicitudes de instalación de sudo pip3

Opcionalmente, puede utilizar MTTQ como método para enviar datos a ThingSpeak. MQTT es diferente de HTTP, una vez que está diseñado específicamente para ser liviano y destinado a dispositivos integrados con bajo rendimiento de RAM y CPU. Además, en la mayoría de los casos, MQTT usa menos ancho de banda.

Consulte este tutorial: Actualice un canal ThingSpeak usando MQTT en una Raspberry Pi para obtener más detalles.

Paso 8: Envío de datos remotos a ThingSpeak usando ESP8266

Para este paso usaremos el mismo HW que se explicó en mi tutorial:

IOT FÁCIL: CAPTURA DE DATOS METEOROLÓGICOS REMOTOS: TEMPERATURA Y HUMEDAD DEL AIRE Y UV

El código que usaremos aquí es básicamente el mismo que se usó en ese tutorial. Comentemos las partes más importantes del código:

Primero, llamemos a la biblioteca ESP8266, definamos el cliente WiFi y definamos sus credenciales de enrutador local y Thinkspeak:

/ * NodeMCU ESP12-E * /

#incluir cliente WiFiClient; const char * MY_SSID = "ENTRAR CON SU SSDID"; const char * MY_PWD = "ENTRAR CON SU CONTRASEÑA"; / * Thinkspeak * / const char * TS_SERVER = "api.thingspeak.com"; String TS_API_KEY = "ENTRAR CON SU CLAVE DE ESCRITURA";

En segundo lugar, incluyamos una biblioteca muy importante para proyectos de IoT: SimpleTimer.h:

/* TEMPORIZADOR */

#incluir temporizador SimpleTimer;

En tercer lugar, durante la configuración (), iniciaremos la comunicación en serie, llamaremos a la función connectWiFi () y definiremos los temporizadores. Tenga en cuenta que la línea de código: timer.setInterval (60000L, sendDataTS); llamará a la función sendDataTS () cada 60 segundos, para cargar datos al canal ThinkSpeak.

configuración vacía ()

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

Por último, pero no menos importante, durante el bucle (), el único comando necesario es iniciar el temporizador y ¡listo!

bucle vacío ()

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

A continuación, puede ver las dos funciones importantes que se utilizan para manejar la comunicación Thinkspeak:

Conexión ESP12-E con su red WiFi:

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

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

ESP12-E enviando datos a ThinkSpeak:

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

* Envío de datos al 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 (zumbido); postStr + = "& field8 ="; postStr + = String (dataSensorUV); postStr + = "\ r / n / r / n"; client.print ("POST / actualización HTTP / 1.1 / n"); client.print ("Host: api.thingspeak.com / n"); client.print ("Conexión: cerrar / n"); client.print ("X-THINGSPEAKAPIKEY:" + TS_API_KEY + "\ n"); client.print ("Tipo de contenido: aplicación / x-www-form-urlencoded / n"); client.print ("Content-Length:"); client.print (postStr.length ()); client.print ("\ n / n"); client.print (postStr); retraso (1000); } enviado ++; client.stop (); }

El código completo se puede encontrar en mi GitHub: NodeMCU_UV_DHT_Sensor_OLED_TS_EXT

Una vez que haya cargado el código en su NodeMCU. Conectemos una batería externa y hagamos algunas mediciones bajo el sol. Pongo la estación remota en el techo y empiezo a capturar datos en ThingSpeak.com como se muestra en las fotos de arriba.

Paso 9: Notas finales

El objetivo principal de este tutorial fue mostrar cómo conectar la Raspberry Pi a ThingSpeak. Esto es excelente para capturar datos y registrarlos en una plataforma de IoT.

Aprovechando la oportunidad, también enviamos datos a ese canal específico, capturándolos desde una estación remota usando un ESP8266. Este enfoque está bien, pero no es el mejor. Debido a que tenemos una operación "asincrónica", en ocasiones, tanto RPi como ESP8266 intentan registrar al mismo tiempo (o con un pequeño intervalo) lo que ThingSpeak refuta. Lo ideal sería que el ESP8266 enviara datos de forma local a Raspberry Pi y el último se encargara de manejar todos los datos. Haciendo eso, la "Main Station" (Raspberry Pi), podría hacer 3 cosas:

• Registra todos los datos en una base de datos local
• Presente todos los datos en una página web local (usando Flask como se muestra en la foto de arriba)
• Envío de todos los datos a ThingSpeak al mismo tiempo.

En un tutorial futuro, exploraremos esas opciones.

Paso 10: Conclusión

Como siempre, espero que este proyecto pueda ayudar a otros a encontrar su camino hacia el apasionante mundo de la electrónica.

Para obtener detalles y el código final, visite mi depósito de GitHub: RPi-NodeMCU-Weather-Station

Para más proyectos, visite mi blog: MJRoBot.org

¡Manténganse al tanto! En el siguiente tutorial enviaremos datos desde una estación meteorológica remota a una central, basada en un servidor web Raspberry Pi:

¡Saludos desde el sur del mundo!

¡Nos vemos en mi próximo instructable!

Gracias, Marcelo