Hay algunas otras estaciones meteorológicas basadas en NodeMcu o ESP8266 publicadas en la web, pero sin embargo,casi ninguna incluyen algunos sensores  de los que vamos a ver , y sobre todo,   se programan en un lenguaje más difícil: LUA.
En este proyecto de Ingenerare, los datos recuperados  por varios sensores , se envían a través de  wifi a la plataforma  Thingspeak, para posteriormente poder  visualizar su valores en el canal de Thingspeak o en un sitio web personal.

Este canal transmitirá los siguientes datos a un canal Thingspeak:

• Temperatura  gracias a  un DHT11 / 22.
• Temperatura por medio de un BMP180.
• La humedad  gracias a un DHT11 / 22.
• La presión atmosférica   por medio de un BMP180.
• Temperatura del punto de rocío DHT11 / 22.
• Altitud por medio de un BMP180.
• La intensidad de la luz gracias  a un LDR.
• El valor lluvia.

Los componentes  usados en este  proyecto son los siguientes:

• NodeMcu board (V0.9 or V1.0), programado con Arduino
• DHT11/22 sensor
• BMP180 sensor
• Sesnsor lluvia
• Sensor LDR
• Buzzer
• Led
• Placa  de prototipos
• Diodos  2x 1N4001 1A 50V (si desea utilizar el sensor de lluvia y el sensor de luz simultáneamente)
• Resistencias 3 x 10K  (si desea utilizar el sensor de lluvia y el sensor de luz simultáneamente)

El corazón del sistema es una  placa  NodeMcu , la cual de hecho, es un Arduino  conmenos puertos analogicos  pero con un escudo wifi el cualpuede reconocerse por la placa de metal en la parte superior de la misma.  Este escudo puede ser comprado y utilizado como una controladora individual para su uso con un  Arduino para darle conectividad (de hecho incluso existe una versión conocida como la V1 esp8266 que sólo tiene 2 pines digitales,pero en versiones posteriores disponemos de mas pines digitales).

La gran ventaja de la placa  NodeMcu es que la placa  se puede programar en el entorno Arduino (el IDE  normal de Arduino). Además, la placa  incluye un convertidor de 5 voltios y así se puede conectar de forma segura mediante USB al ordenador sin tener que comprar un módulo conversor Dv-DC  de 3,3 voltios.

Si usted necesita  comprar una placa  NodeMcu se puede comprar la versión 0.9 o la versión 1.0: la única diferencia que sé es que la versión 0.9 es más ancha que la versión 1.0. ( de hecho no puede utilizar la versión 0.9 en una placa de prototipos standard  ).

Hay  gran cantidad de tutoriales en Internet donde explican como  programar esta placa  junta con el software de LUA, pero al ser  básicamente un Arduino con un escudo  wifi, también se puede usar el software Arduino IDE siguiendo estos pasos:

• Ir   a «Archivo»
• Haga clic en «Oreferencias»
• Agregue el siguiente enlace en el campo «URL de la placa adicional ‘:http: //arduino.esp8266.com/stable/package_esp8266c 
• Después de esto puede reiniciar el software y debe ser capaz de seleccionar la junta en el gestor de tabla (V1.0 o v0.9).

ThingSpeak

En esta ocasión se va a enviar   nuestros medidas a la veterana  plataforma Thingspeak  que ofrece varias opciones para la interacción con sus datos como Thingtweet, Thinghttp etc.

Lo primero que tenemos que hacer es crearnos una cuenta en thingspeak , para ello  simplemente vaya a thingspeak.com y cree  una cuenta ,donde  solo será necesario rellenar en al menos la primera y segunda en la configuración de campo.

Si se conecta un sensor de temperatura y humedad, como se describe mas adelante, rellenar «temperatura» en el campo 1, ‘humedad’ en el campo 2 y el «punto de rocío» en el campo 3. Si desea conectar otros sensores tales como el sensor de BMP, sensor de lluvia, LDR, sólo tiene que hacer lo mismo para el resto de los campos.

En este formulario puede encontrar  una clave API key  que habrá que mencionar en su código para  Arduino bajo la ‘clave de API’  , pues esta clave es necesaria para conectar el Arduino al canal Thingspeak recién creado.

Sensor DHTXX

DHT11 y  DHT22 son dos modelos de una misma familia de sensores, que permiten realizar la medición simultánea de temperatura y humedad usando ademas un único  hilo para comunicar los datos vía serie, para lo cual  ambos  disponen de un procesador interno que realiza el proceso de medición, proporcionando la medición mediante una señal digital, por lo que resulta muy sencillo obtener la medición desde un microprocesador como Arduino o ESP8266.

El sensor de BMP

El sensor de BMP180  mide la de la temperatura y la presión del aire. Sí, ya tenemos un sensor de temperatura añadido en el paso anterior, pero no un sensor de presión de aire. Conectar la clavija de alimentación a la línea de 3,2 voltios de la NodeMCU y el conector de tierra en el pin GND de la NodeMCU. El SCL tiene que estar conectado a D1 y la SDA a D2.

Sensor de lluvia y sensor de luz

El sensor utiliza materiales de doble cara FR-04 de alta calidad, donde el área extensa es de 5.0 * 4.0CM, y la superficie niquelada, eficaz contra la oxidación, la conductividad, el funcionamiento superior y las áreas de la vida.

El sensor de lluvia no requiere ninguna  otra placa cuando queremos leer el valor analógico.Si queremos leer valores  binarios  en cambio podemos utilizar la placa adicional  que ofrece  una  conexión a los pines digitales . Gracias a un potenciómetro   que contiene  esta placa , se puede establecer el valor  de umbral con que se dispara pues el  formato de salida  puede ser  de conmutación digital (0 y 1) gracias a  un comparador de amplio voltaje LM393 (y salida de tensión analógica AO).

También en este proyecto se ha añadido un LDR , por lo que podemos  tener dos lecturas analógicas. Esta es una parte difícil pues el NodeMCU sólo tiene un pin analógico , pero podemos resolver este problema mediante la multiplexación de los pines analógicos de modo que con la ayuda de dos diodos y dos pines GPIO , podemos suministrar energía a ambos sensores en secuencia para tomar la lectura de ambos ( eso sí tendrá que controlar esta secuencia desde el  propio programa)

Como se puede ver el sensor de lluvia está activada por el pin D7  (GPIO13)  yel LDR es alimentado por el   pin D8  (GPIO15).

Este es el trozo de código que permite la lectura de ambas señales analógicas:

int sensorPin = A0; // selecciona  el pi, t the input pin for the potentiometer
int enable1 = 10; // activar lectura  sensor A
int enable2 = 11; // acvtivar lectura sensor B

int sensorValue1 = 0; // variable to store the value coming from sensor A
int sensorValue2 = 0; // variable to store the value coming from sensor B

void setup() {
Serial.begin(9600);
// declare the enable and ledPin as an OUTPUT:
pinMode(enable1, OUTPUT);
pinMode(enable2, OUTPUT);
}

void loop() {
// read the value from sensor A:
digitalWrite(enable1, HIGH);
sensorValue1 = analogRead(sensorPin);
Serial.println(sensorValue1);
digitalWrite(enable1, LOW);

delay(100);

// read the value from sensor A:
digitalWrite(enable2, HIGH);
sensorValue2 = analogRead(sensorPin);
Serial.println(sensorValue2);
digitalWrite(enable2, LOW);
Serial.println(«—————————————-«);
delay(1000);
}

Las conexión  de todos los sensores  queda pues como en la figura siguiente:

Finalmente una vez montado el circuito  solo nos queda  programar el ESP por ejemplo usando el código de más abajo.

No debemos olvidar  de cambiar el apikey con el de su cuenta de thingspeak, pues si no se hace NO  se podrán enviar datos a su canal

Es asimismo importante añadir el nombre SSID  de su red Wi-FI (esto es simplemente el nombre que aparece cuando se hace clic en la esquina derecha de Bottum a filtrar) así como añadir la contraseña de esta red wifi.

Si ha cargado el boceto se puede comprobar en el monitor serie cómo funciona. Basta con abrir el monitor pulsando CNTR + M.

*
This sketch is a combination of two other sketches:
1.
Plot DTH11 data on thingspeak.com using an ESP8266
April 11 2015
Author: Jeroen Beemster
Website: http://www.arduinesp.com
2.
Example sketch: adafruit BMP 085
Sensor api BMP180
*/
//library DHT22
#include

//library esp
#include

//library bmp180
#include
#include
#include

// replace with your channel’s thingspeak API key,
String apiKey = «»; //fill in the api key from thingspeak
const char* ssid = «»; //fill in your wifi name
const char* password = «»; //fill in your wifi password

const char* server = «api.thingspeak.com»;
#define DHTPIN 2 // what pin we’re connected to

DHT dht(DHTPIN, DHT22,15);
WiFiClient client;

int sensorPin = A0; // input for LDR and rain sensor
int enable1 = 15; // enable reading LDR
int enable2 = 13; // enable reading Rain sensor
int sensorValue1 = 0; // variable to store the value coming from sensor LDR
int sensorValue2 = 0; // variable to store the value coming from sensor Rain sensor
//————————–setup————————-
void setup() {

// declare the enable and ledPin as an OUTPUT:
pinMode(enable1, OUTPUT);
pinMode(enable2, OUTPUT);
Serial.begin(115200);
delay(10);

dht.begin();

WiFi.begin(ssid, password);

Serial.println();
Serial.println();
Serial.print(«Connecting to «);
Serial.println(ssid);
Serial.print(«……….»);
Serial.println();
WiFi.begin(ssid, password);

while (WiFi.status() != WL_CONNECTED) {
delay(500);

}
Serial.println(«WiFi connected»);
Serial.println();

}
void loop() {
//————————–DHT22/DHT11————————-

float h = dht.readHumidity();
float t = dht.readTemperature();

if (isnan(h) || isnan(t)) {
Serial.println(«Failed to read from DHT sensor!»);
return;
}
Serial.print(«Temperature: «);
Serial.print(t);
Serial.print(» degrees Celcius «);
Serial.println();

Serial.print(«Humidity: «);
Serial.print(h);
Serial.print(«%»);
Serial.println();

//— extra—- you can measure dew point with the temperature and the humidity

double gamma = log(h/100) + ((17.62t) / (243.5+t));
double dp = 243.5gamma / (17.62-gamma);

Serial.print(«Dew point: «);
Serial.print(dp);
Serial.print(» degrees Celcius «);
Serial.println();

//————————–BMP180————————

if(!bmp.begin()) {
Serial.print(«Failed to read from BMP sensor!!»);
while(1);
}

sensors_event_t event;
bmp.getEvent(&event);

Serial.print(«Pressure: «);
Serial.print(event.pressure);
Serial.println(» hPa»);

float temperature;
bmp.getTemperature(&temperature);
Serial.print(«Temperature: «);
Serial.print(temperature);
Serial.println(» degrees Celcius «);

//— extra—-you can measure the altitude with the temperature and the air pressure

float seaLevelPressure = 1015;
Serial.print(«Altitude: «);
Serial.print(bmp.pressureToAltitude(seaLevelPressure,event.pressure));
Serial.println(» m»);

//————————–LDR————————-

digitalWrite(enable1, HIGH);
sensorValue1 = analogRead(sensorPin);
sensorValue1 = constrain(sensorValue1, 300, 850);
sensorValue1 = map(sensorValue1, 300, 850, 0, 1023);
Serial.print(«Light intensity: «);
Serial.println(sensorValue1);
digitalWrite(enable1, LOW);
delay(100);

//————————–Rain Sensor————————-

digitalWrite(enable2, HIGH);

delay(500);
sensorValue2 = analogRead(sensorPin);
sensorValue2 = constrain(sensorValue2, 150, 440);
sensorValue2 = map(sensorValue2, 150, 440, 1023, 0);

Serial.print(«Rain value: «);
Serial.println(sensorValue2);
Serial.println();
delay(100);

digitalWrite(enable2, LOW);

//————————–thingspeak————————-

if (client.connect(server,80)) { // «184.106.153.149» or api.thingspeak.com
String postStr = apiKey;
postStr +=»&field1=»;
postStr += String(t);
postStr +=»&field2=»;
postStr += String(h);
postStr +=»&field3=»;
postStr += String(dp);
postStr +=»&field4=»;
postStr += String(event.pressure);
postStr +=»&field5=»;
postStr += String(temperature);
postStr +=»&field6=»;
postStr += String(sensorValue1);
postStr +=»&field7=»;
postStr += String(sensorValue2);
postStr +=»&field8=»;
postStr += String(bmp.pressureToAltitude(seaLevelPressure,event.pressure));
postStr += «\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n»;

client.print(«POST /update HTTP/1.1\n»);
client.print(«Host: api.thingspeak.com\n»);
client.print(«Connection: close\n»);
client.print(«X-THINGSPEAKAPIKEY: «+apiKey+»\n»);
client.print(«Content-Type: application/x-www-form-urlencoded\n»);
client.print(«Content-Length: «);
client.print(postStr.length());
client.print(«\n\n\n\n\n\n\n\n»);
client.print(postStr);

}
client.stop();
// thingspeak needs minimum 15 sec delay between updates
delay(20000);
}

Weather_station_for_instructables.ino

Todo el conjunto se puede meter en un pequeña caja .  El sensor de DHT y el sensor de BMP pueden posicionarse en el lado de la caja cubriendo los dos sensores con un poco de múltiplex para que la lluvia no pudo influir en las lecturas
Asimimos Thingspeak tiene un montón de opciones de plugin. Uno de ellos es que es posible hacer que los medidores  los publique en su página web de thingspeak   en la pestaña ‘vista privada’ de Thingspeak. Se pueden  vincular los medidores de su sitio web privado  mediante el uso de un iframe que tiene que estar conectado a Thingspeak para poder ver los medidores.

Fuente   aqui