ESP8266 pronóstico del tiempo

¿Quieres saber qué tiempo hará mañana? ¡El ESP8266 puede ayudarte! En este artículo, te mostraremos cómo utilizar este módulo para obtener un pronóstico preciso del tiempo en tu área. ¡No te lo pierdas!

En esta publicación, construirá un pronosticador del tiempo utilizando un ESP8266.

Odio estar afuera sin paraguas en un día lluvioso y estoy bastante seguro de que todos los demás sienten lo mismo.

A menudo, el widget del tiempo de nuestros smartphones muestra la previsión meteorológica, pero cuando tenemos prisa nos olvidamos de prestarle atención.

Por eso sería bueno tener un dispositivo colgado en la parte trasera de la puerta que te recuerde salir de casa con un paraguas en un día en el que podría llover. Este dispositivo te indica la previsión meteorológica cambiando el color del LED. Este dispositivo no tendría alarma ni pantalla, solo unos pocos LED que se mezclarían naturalmente con su entorno.

Piezas requeridas

Aquí hay una lista completa de los componentes que necesitará para este proyecto (haga clic en los enlaces a continuación para encontrar el mejor precio en Asesor de creadores):

• ESP8266-12-E – leer Las mejores placas de desarrollo Wi-Fi ESP8266
• 4x LED (diferentes colores representan diferentes condiciones climáticas)
• 4x resistencias (220 o 330 ohmios deberían ser suficientes)
• tablero de circuitos
• Cables de puente

Puedes utilizar los enlaces anteriores o ir directamente MakerAdvisor.com/tools ¡Para encontrar todas las piezas para tus proyectos al mejor precio!

Abrir mapa del tiempo

Este proyecto se basa en la API Open Weather Map. Por lo tanto, es necesario registrarse en su plataforma y obtener una clave API antes de que podamos comenzar a ensamblar los esquemas y escribir el código.

El plan gratuito de OpenWeatherMap tiene todo lo que necesitas para este ejemplo. Para utilizar la API, necesita una clave API, llamada APIID. Cómo obtener un APIID:

1. Abra un navegador y vaya a OpenWeatherMap
2. presione el Acceso Haga clic y cree una cuenta gratuita
3. Una vez creada su cuenta, se le presentará un panel de múltiples pestañas (vea la imagen a continuación).
4. Elegir Clave API y copia tu único Llave

Esta es una clave única que necesita para recuperar información del sitio. Copie y pegue esta clave en algún lugar; la necesitará pronto.

Para obtener información sobre el clima en la ubicación seleccionada, ingrese la siguiente URL, reemplazando las secciones entre llaves con la información de la ubicación seleccionada y su clave API única:

http://api.openweathermap.org/data/2.5/forecast?q={your city},{your country code}&APPID={your API Key}&mode=json&units=metric&cnt=2

Sustituto {tu ciudad} con la ciudad de la que quieres datos, {su código de país} con el código de país de esta ciudad y {Su clave API} con su clave API única que encontramos anteriormente. Por ejemplo, nuestra URL API para la ciudad de Oporto en Portugal después de reemplazarla con los detalles sería:

http://api.openweathermap.org/data/2.5/forecast?q=Porto,PT&APPID=801d2603e9f2e1c70e042e4------&mode=json&units=metric&cnt=2

nota: Hay más información disponible sobre el uso de la API para recuperar información meteorológica. Aquí.

Copie su URL en su navegador. Luego debería recibir una variedad de información consistente con los datos de pronóstico del tiempo local.

Mantenga segura su clave API única y luego podremos pasar a la sección de código.

Instalación de la biblioteca ArduinoJson

Para este proyecto, necesita instalar la biblioteca ArduinoJson en su IDE de Arduino, que le permite decodificar y codificar JSON usando Arduino o ESP8266. Siga estos siguientes pasos:

1. Haga clic aquí para descargar ArduinoJson. Deberías tener una carpeta .zip en tu carpeta de Descargas.
2. Extraiga la carpeta .zip y debería obtener la carpeta maestra ArduinoJson.
3. Cambie el nombre de su carpeta de Maestro ArduinoJson A ArduinoJson
4. Mueva la carpeta ArduinoJson a la carpeta de bibliotecas de instalación de su IDE de Arduino.
5. Finalmente, vuelva a abrir su IDE de Arduino

Subir código

Después de instalar el complemento ESP8266 para Arduino IDE (Cómo instalar la placa ESP8266 en Arduino IDE), vaya a Herramientas y seleccione «NodeMCU (módulo ESP-12E)».

Copie el siguiente código en su IDE de Arduino y cárguelo en su placa ESP8266.

Revise el código para agregar su SSID, contraseña, ciudad, código de país y clave API de Open Weather Map.

 /*
  * Author: Emmanuel Odunlade 
  * Complete Project Details https://randomnerdtutorials.com
  */
  
#include <ArduinoJson.h>
#include <ESP8266WiFi.h>
#include <WiFiClient.h>

// Replace with your SSID and password details
char ssid[] = "REPLACE_WITH_YOUR_SSID";        
char pass[] = "REPLACE_WITH_YOUR_PASSWORD";   

WiFiClient client;

// Open Weather Map API server name
const char server[] = "api.openweathermap.org";

// Replace the next line to match your city and 2 letter country code
String nameOfCity = "REPLACE_WITH_YOUR_CITY,REPLACE_WITH_YOUR_COUNTRY_CODE"; 
// How your nameOfCity variable would look like for Lagos on Nigeria
//String nameOfCity = "Lagos,NG"; 

// Replace the next line with your API Key
String apiKey = "REPLACE_WITH_YOUR_API_KEY"; 

String text;

int jsonend = 0;
boolean startJson = false;
int status = WL_IDLE_STATUS;

int rainLed = 2;  // Indicates rain
int clearLed = 3; // Indicates clear sky or sunny
int snowLed = 4;  // Indicates snow
int hailLed = 5;  // Indicates hail

#define JSON_BUFF_DIMENSION 2500

unsigned long lastConnectionTime = 10 * 60 * 1000;     // last time you connected to the server, in milliseconds
const unsigned long postInterval = 10 * 60 * 1000;  // posting interval of 10 minutes  (10L * 1000L; 10 seconds delay for testing)

void setup() {
  pinMode(clearLed, OUTPUT);
  pinMode(rainLed, OUTPUT);
  pinMode(snowLed, OUTPUT);
  pinMode(hailLed, OUTPUT);
  Serial.begin(9600);
  
  text.reserve(JSON_BUFF_DIMENSION);
  
  WiFi.begin(ssid,pass);
  Serial.println("connecting");
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("WiFi Connected");
  printWiFiStatus();
}

void loop() { 
  //OWM requires 10mins between request intervals
  //check if 10mins has passed then conect again and pull
  if (millis() - lastConnectionTime > postInterval) {
    // note the time that the connection was made:
    lastConnectionTime = millis();
    makehttpRequest();
  }
}

// print Wifi status
void printWiFiStatus() {
  // print the SSID of the network you're attached to:
  Serial.print("SSID: ");
  Serial.println(WiFi.SSID());

  // print your WiFi shield's IP address:
  IPAddress ip = WiFi.localIP();
  Serial.print("IP Address: ");
  Serial.println(ip);

  // print the received signal strength:
  long rssi = WiFi.RSSI();
  Serial.print("signal strength (RSSI):");
  Serial.print(rssi);
  Serial.println(" dBm");
}

// to request data from OWM
void makehttpRequest() {
  // close any connection before send a new request to allow client make connection to server
  client.stop();

  // if there's a successful connection:
  if (client.connect(server, 80)) {
    // Serial.println("connecting...");
    // send the HTTP PUT request:
    client.println("GET /data/2.5/forecast?q=" + nameOfCity + "&APPID=" + apiKey + "&mode=json&units=metric&cnt=2 HTTP/1.1");
    client.println("Host: api.openweathermap.org");
    client.println("User-Agent: ArduinoWiFi/1.1");
    client.println("Connection: close");
    client.println();
    
    unsigned long timeout = millis();
    while (client.available() == 0) {
      if (millis() - timeout > 5000) {
        Serial.println(">>> Client Timeout !");
        client.stop();
        return;
      }
    }
    
    char c = 0;
    while (client.available()) {
      c = client.read();
      // since json contains equal number of open and close curly brackets, this means we can determine when a json is completely received  by counting
      // the open and close occurences,
      //Serial.print(c);
      if (c == '{') {
        startJson = true;         // set startJson true to indicate json message has started
        jsonend++;
      }
      if (c == '}') {
        jsonend--;
      }
      if (startJson == true) {
        text += c;
      }
      // if jsonend = 0 then we have have received equal number of curly braces 
      if (jsonend == 0 && startJson == true) {
        parseJson(text.c_str());  // parse c string text in parseJson function
        text = "";                // clear text string for the next time
        startJson = false;        // set startJson to false to indicate that a new message has not yet started
      }
    }
  }
  else {
    // if no connction was made:
    Serial.println("connection failed");
    return;
  }
}

//to parse json data recieved from OWM
void parseJson(const char * jsonString) {
  //StaticJsonBuffer<4000> jsonBuffer;
  const size_t bufferSize = 2*JSON_ARRAY_SIZE(1) + JSON_ARRAY_SIZE(2) + 4*JSON_OBJECT_SIZE(1) + 3*JSON_OBJECT_SIZE(2) + 3*JSON_OBJECT_SIZE(4) + JSON_OBJECT_SIZE(5) + 2*JSON_OBJECT_SIZE(7) + 2*JSON_OBJECT_SIZE(8) + 720;
  DynamicJsonBuffer jsonBuffer(bufferSize);

  // FIND FIELDS IN JSON TREE
  JsonObject& root = jsonBuffer.parseObject(jsonString);
  if (!root.success()) {
    Serial.println("parseObject() failed");
    return;
  }

  JsonArray& list = root["list"];
  JsonObject& nowT = list[0];
  JsonObject& later = list[1];

  // including temperature and humidity for those who may wish to hack it in
  
  String city = root["city"]["name"];
  
  float tempNow = nowT["main"]["temp"];
  float humidityNow = nowT["main"]["humidity"];
  String weatherNow = nowT["weather"][0]["description"];

  float tempLater = later["main"]["temp"];
  float humidityLater = later["main"]["humidity"];
  String weatherLater = later["weather"][0]["description"];

  // checking for four main weather possibilities
  diffDataAction(weatherNow, weatherLater, "clear");
  diffDataAction(weatherNow, weatherLater, "rain");
  diffDataAction(weatherNow, weatherLater, "snow");
  diffDataAction(weatherNow, weatherLater, "hail");
  
  Serial.println();
}

//representing the data
void diffDataAction(String nowT, String later, String weatherType) {
  int indexNow = nowT.indexOf(weatherType);
  int indexLater = later.indexOf(weatherType);
  // if weather type = rain, if the current weather does not contain the weather type and the later message does, send notification
  if (weatherType == "rain") { 
    if (indexNow == -1 && indexLater != -1) {
      digitalWrite(rainLed,HIGH);
      digitalWrite(clearLed,LOW);
      digitalWrite(snowLed,LOW);
      digitalWrite(hailLed,LOW);
      Serial.println("Oh no! It is going to " + weatherType + " later! Predicted " + later);
    }
  }
  // for snow
  else if (weatherType == "snow") {
    if (indexNow == -1 && indexLater != -1) {
      digitalWrite(snowLed,HIGH);
      digitalWrite(clearLed,LOW);
      digitalWrite(rainLed,LOW);
      digitalWrite(hailLed,LOW);
      Serial.println("Oh no! It is going to " + weatherType + " later! Predicted " + later);
    }
    
  }
  // can't remember last time I saw hail anywhere but just in case
  else if (weatherType == "hail") { 
   if (indexNow == -1 && indexLater != -1) {
      digitalWrite(hailLed,HIGH);
      digitalWrite(clearLed,LOW);
      digitalWrite(rainLed,LOW);
      digitalWrite(snowLed,LOW);
      Serial.println("Oh no! It is going to " + weatherType + " later! Predicted " + later);
   }

  }
  // for clear sky, if the current weather does not contain the word clear and the later message does, send notification that it will be sunny later
  else {
    if (indexNow == -1 && indexLater != -1) {
      Serial.println("It is going to be sunny later! Predicted " + later);
      digitalWrite(clearLed,HIGH);
      digitalWrite(rainLed,LOW);
      digitalWrite(snowLed,LOW);
      digitalWrite(hailLed,LOW);
    }
  }
}

Ver código sin formato

Esquema

Conecte su circuito de acuerdo con el siguiente diagrama:

demostración

La siguiente figura describe lo que indica cada LED: (D2) lluvia, (D3) cielo despejado, (D4) nieve y (D5) granizo:

Aquí tenéis una foto del circuito terminado:

Envolver

Hoy en día, el objetivo de la informática es crear una interfaz de usuario natural entre humanos y computadoras. Estamos recurriendo a cosas como AR (Realidad Aumentada) para hacer esto realidad, pero la verdad es que todos estamos cansados ​​de mirar constantemente nuestros teléfonos y PC en busca de la más mínima información.

Me resulta extremadamente útil colgar este proyecto en algún lugar de la casa donde puedas seguir fácilmente el clima cuando salgas de casa.

Para llevar este proyecto más lejos, puedo agregar un estuche impreso en 3D con una función de batería de respaldo para que parezca aún más elegante. Definitivamente te avisaré cuando esté listo.

¡Gracias por leer!

Quizás también te interese nuestro libro electrónico “Domótica con ESP8266”.

Construye un Pronóstico del Tiempo con ESP8266

En este post, aprenderás a construir un pronóstico del tiempo con un ESP8266.

Este proyecto fue escrito por Emmanuel Odunlade y editado por Rui Santos.

¡Nadie quiere estar atrapado bajo la lluvia sin un paraguas! A menudo, la widget del clima en nuestros teléfonos muestra el pronóstico del tiempo, pero cuando estamos de prisa, a veces se nos olvida prestarle atención.

Por eso, sería genial contar con un dispositivo cerca de la puerta que nos recuerde llevar un paraguas en días lluviosos. Este dispositivo te indica el pronóstico del tiempo con un cambio en el color de los LEDs. No tiene alarma ni pantalla, solo unos LEDs que se adaptarían perfectamente a tu entorno.

Parts requeridos

Aquí tienes una lista de los componentes necesarios para este proyecto:

– ESP8266 12-E
– 4 LEDs (de diferentes colores para representar diferentes condiciones climáticas)
– 4 Resistencias (220 o 330 ohmios)
– Proto board
– Cables de conexión

Puedes encontrar los mejores precios para estos componentes en MakerAdvisor.

Open Weather Map

Este proyecto se basa en la API de Open Weather Map, por lo que es necesario registrarse en su plataforma y obtener una clave de API antes de empezar a armar el esquema y escribir el código.

La clave de API es necesaria para obtener información meteorológica de la API. Puedes obtener tu clave de API siguiendo las instrucciones en la página de OpenWeatherMap.

Instalación de la librería ArduinoJson

Para este proyecto, necesitas instalar la librería ArduinoJson en tu IDE de Arduino.

Sigue los pasos a continuación:

1. Descarga la librería ArduinoJson.
2. Descomprime la carpeta y renómbrala a «ArduinoJson».
3. Mueve la carpeta ArduinoJson a la carpeta de librerías de tu IDE de Arduino.
4. Reabre tu IDE de Arduino.

Subir el código

Una vez que tengas el complemento ESP8266 para tu IDE de Arduino instalado, copia el código proporcionado en tu IDE y súbelo a tu placa ESP8266.

Asegúrate de modificar el SSID, contraseña, ciudad, código de país y clave de API de Open Weather Map en el código antes de subirlo a tu placa.

Esquemático

Conecta tu circuito siguiendo el esquema proporcionado en el artículo.

Conclusión

En resumen, este proyecto te permite tener un pronóstico del tiempo visible en tu hogar de manera sencilla y efectiva. ¡No vuelvas a olvidar tu paraguas en un día lluvioso!

Para llevar este proyecto un paso más allá, podrías considerar imprimir una carcasa en 3D con una batería de respaldo para que luzca más ordenado. ¡Compartiré los resultados contigo cuando esté listo!

¡Gracias por leer!

Recuerda que puedes ampliar tus conocimientos en electrónica con nuestro eBook sobre Automatización del Hogar utilizando ESP8266.

Referencias:

– Maker Advisor
– ArduinoJson Library
– Open Weather MapAPI

Fuente: RandomNerdTutorials.com