Published July 26, 2025

Weather Station With Real Time Data Collection

Collecting real time weather data and storing it within a database, and then using the database to display the live data from anywhere.

IntermediateFull instructions provided270

Weather Station With Real Time Data Collection

Things used in this project

Hardware components

Arduino Nano esp32

DHT11 Temperature & Humidity Sensor (3 pins)

Adafruit Anemometer Wind Speed Sensor w/Analog Voltage Output

9V Battery Clip

Battery, 9 V

Particle Photon 2

Resistor 10k ohm

TaydaElectronics DC POWER JACK 2.1MM BARREL-TYPE PCB MOUNT

Digilent 5V 2.5A Switching Power Supply

Button

1602 LCD Display Module 16x02

I2C Serial Interface for 1602 LCD

Software apps and online services

Arduino IDE

Particle Build Web IDE

Hand tools and fabrication machines

Soldering iron (generic)

Solder Wire, Lead Free

Perf Borad

Pin Headers

Solid Core Wire

Wire Stripper & Cutter, 18-10 AWG / 0.75-4mm² Capacity Wires

Story

Overview

In the Midwest the temperature alone doesn't fully tell you how it will actually be like outside. Most of the time to get an accurate sense of temperature outside you need to look at the wind chill or heat index depending on the season you are in. The main feature of the weather station is that it will update the temperature and the feels like temperature in real time, giving you the ability to keep track of what the weather conditions are like from anywhere.

Showcase

Live Updating Weather Showcase

Weather Station

The weather station is be based around the Arduino Nano ESP32 board. The two sensors that will be used for the weather station are the DHT11 sensor and the Adafruit anemometer. The DHT11 sensor measures both temperature and humidity. For greater accuracy, you can also use the DHT22 sensor. to pull data from the DHT11 sensor, we will be using the DHT sensor Library by Adafruit. Using this library allows for easy sensor readings as well as flexibility to use other DHT sensors such as the DHT22 temperature and humidity sensor. To measure wind speed using the anemometer, you will need to measure the input voltage from the anemometer. This can be done by measuring the analog signal value, from the analog-digital-converter (ADC), coming in and multiplying it by the VCC voltage and dividing it by the ADC pin resolution. Using temperature, windspeed, and humidity, we are able to calculate a feels like temperature. The main two equations are the windchill and heat index equations which can be found national weather service website.

Sample Live Updating Data in Realtime Database

To store the weather data, we will be using Google's Firebase Realtime Database to store the data. To set up the Realtime Database, you can use some of the many resources and tutorials provided by Google. To send data to the Realtime Database from the ESP32, we will be using the Firebase_ESP_Client library. In the setup you must first connect to the WiFi then configure the Firebase using the API key and the Realtime Database URL. Then to send the data to the database you can use one of the library's set functions, depending on the variable type, to update the data in your database.

Live Weather Display

The display portion of the weather station is based around the Particle Photon 2. This microcontroller was chosen due to the easy use of webhooks using the Particle system. To set up your webhook you will need to create a new integration using the particle cloud services and select custom webhook. In the URL section you will put the URL of your Realtime Database plus forward slash followed by your data path dot json. Your data path will define what to pull from the database, which is Sensors in the case of the shown project. The request type should also be set to GET. To process the data from the webhook, we will be using the ArduinoJson library to deserialize the data after every webhook publish. For the display, we will be using a 1602 LCD display in conjunction with the I2C Serial Interface for 1602 LCD to allow for I2C communication with the LCD screen. I2C allows use to save space on the microcontroller because we no longer need parallel communication with LCD display and only need two pins to communicate with the LCD display. To display data to the LCD screen we will be using the LiquidCrystal_I2C_Spark library. When wiring the LCD screen make sure to have two 10k ohm pulldown resistors on the SCL and SDA data lines. This is to ensure that there aren't any interruptions to the Photon 2's start up sequence. Since the LCD screen is not very large, we will need a way to cycle through the data. You can use the auto scroll function from the LCD library, but using a button allows the use to have more control over what data they want to look at. To set up the button module we simply have to connect the button to ground, VCC, and any digital pin. From there we can read the button state using the digital read function and, setting a shot debounce to not accidently set two off multiple button clicks.

Live Updating Weather Data

Code

#include <WiFi.h>
#include <Firebase_ESP_Client.h>
#include "addons/TokenHelper.h"
#include "addons/RTDBHelper.h"
#include <DHT.h>

#define WIFI_SSID "SSID"
#define WIFI_PASSWORD "PASSWORD"
#define API_KEY "FIREBASE_KEY"
#define URL "REALTIME_DATABASE_URL"

//pin dht is plugged in
#define DHTPIN 2
//pin ds18b20 is plugged in
#define ONE_WIRE_BUS 4
//dht type
#define DHTTYPE DHT11
//sensor pin for anemometer
#define SENSORPIN A0
//min anemometer voltage
#define MINVOLTAGE 0.4
//max anemometer voltage
#define MAXVOLTAGE 2.0

FirebaseData fbdo;
FirebaseAuth auth;
FirebaseConfig config;

bool dataChnage = false;
bool signupOK = false;

//sensor inputs
int sensorVal = 0;
float voltage = 0.0;
float windSpeed = 0.0;
float windSpeedMPH = 0.0;
float temp = 0.0;
float humid = 0.0;

//old values
float tempOld = 0.0;
float humidOld = 0.0;
float windSpeedMPHOld = 0.0;

DHT dht(DHTPIN, DHTTYPE);

void setup() {
  dht.begin();

  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);

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

  config.api_key = API_KEY;
  config.database_url = URL;

  if(Firebase.signUp(&config, &auth, "", "")){
    signupOK = true;
  }
  else{
    signupOK = false;
  }

  config.token_status_callback = tokenStatusCallback;
  Firebase.begin(&config, &auth);
  Firebase.reconnectWiFi(true);
}

//this function only workds with farenheit and wind speeds in mph
//if the requiremnets for windchill or heat index aren't met then the function returns the temperature
float feelsLike(float temp, float humid, float windSpeed){
  float feel = temp;

  //windchill only works temperatures below 50ºF and wind speeds above 3 mph and below 110 mph
  if(temp < 10.0 && windSpeed > 1.3 && windSpeed < 49.2){
    feel = 35.74 + (0.6215 * (temp)) - (35.75 * pow(windSpeed, 0.16)) + (0.4275 * temp * pow(windSpeed, 0.16));;
  }

  //heat index only works for temperatures above 80ºF and relative humidity above 40%
  else if(humid > 40 && temp > 80){
    feel = -42.379 + (2.04901523 * temp) + (10.14333127 * humid) - (0.22475541 * temp * humid) - (0.00683783 * temp * temp) - (0.05481717 * humid * humid) + (0.00122874 * temp * temp * humid) + (0.00085282 * temp * humid * humid) - (0.00000199 * temp * temp * humid * humid);
  }

  return feel;
}

void loop() {
  humid = dht.readHumidity();
  temp = dht.readTemperature(true);
  sensorVal = analogRead(SENSORPIN);

  //wind speed calculations
  voltage = sensorVal * (3.3 / 4095.0);
  if(voltage <= MINVOLTAGE){
    windSpeed = 0.0;
  }
  else{
    windSpeed = (voltage - MINVOLTAGE) * (32.4 / (MAXVOLTAGE - MINVOLTAGE));
  }

  windSpeedMPH = windSpeed * 2.237;

  //changes in sensor values
  float tempDiff = abs(temp - tempOld);
  float humidDiff = abs(humid - humidOld);
  float windSpeedMPHDiff = abs(windSpeed - windSpeedMPHOld);

  //windchill and heatindex calculations
  float feels = feelsLike(tempOld, humidOld, windSpeedMPHOld);

  if(tempDiff >= 1 || humidDiff >= 1 || windSpeedMPHDiff >= 2){
    dataChnage = true;
    tempOld = temp;
    humidOld = humid;
    windSpeedMPHOld = windSpeedMPH;
  }
  else{
    dataChnage = false;
  }

  if(Firebase.ready() && signupOK && !(isnan(humid) || isnan(temp)) && dataChnage){
    Firebase.RTDB.setFloat(&fbdo, "Sensor/temp", temp);
    Firebase.RTDB.setFloat(&fbdo, "Sensor/wind_speed", windSpeedMPH);
    Firebase.RTDB.setFloat(&fbdo, "Sensor/humid", humid);
    Firebase.RTDB.setFloat(&fbdo, "Sensor/feels", feels);
  }

  delay(1000);
}

#include <ArduinoJson.h>
#include <LiquidCrystal_I2C_Spark.h>
#include <Wire.h>
#include "Particle.h"

SYSTEM_MODE(AUTOMATIC);

SerialLogHandler logHandler(LOG_LEVEL_INFO);

//button input
#define BTNPIN D5

//used for deserializing databse data
String jsonText = "";
JsonDocument doc;

//data values
float temp;
float humid;
float wind;
float feels;

// keeping track of LCD position
int yPos = 0;
int yPosOld = -1;

//degree symbol
byte customChar[] = {
  B01110,
  B01010,
  B01110,
  B00000,
  B00000,
  B00000,
  B00000,
  B00000
};

unsigned long millesOld = 0;
const unsigned long interval = 10 * (1000); //10 second interval

unsigned long buttonTimeOld = 0;
const unsigned long buttonInterval = 200; //200ms debounce time

//LCD screen
LiquidCrystal_I2C lcd(0x27, 16, 2);

void setup() {
    waitFor(Particle.connected, 10000);
    Particle.subscribe("hook-response/weather-data", handleResponse, MY_DEVICES);
    
    pinMode(BTNPIN, INPUT);
    
    Wire.begin(0x27);
    
    lcd.init();
    lcd.backlight(); 
    lcd.setCursor(0, 0);
    lcd.createChar(0, customChar);
    
    Particle.publish("weather-data");
}

void loop() {
    unsigned long buttonTimeNow = millis();
    int val = digitalRead(BTNPIN);

    if ((buttonTimeNow - buttonTimeOld) >= buttonInterval) {
        if(val == LOW){
            yPos += 1;
            buttonTimeOld = buttonTimeNow;
        }
    }
    if(yPos > 3){
        yPos = 0;
    }
    
    unsigned long millisNow = millis();
    if(millisNow - millesOld >= interval){
        millesOld = millisNow;
        
        Particle.publish("weather-data");
    }
    
    if(yPos != yPosOld){
        yPosOld = yPos;
        updateLCD();
    }
}

void handleResponse(const char *event, const char *data) {
    jsonText = data;
    
    retrieveValues();
    updateLCD();
}

void retrieveValues(){
    DeserializationError error = deserializeJson(doc, jsonText.c_str());
    if(error){
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("Error");
        return;
    }
    
    temp = doc["temp"];
    humid = doc["humid"];
    wind = doc["wind_speed"];
    feels = doc["feels"];
}

//updates the LCD to most recent information and position
void updateLCD(){
    if(yPosOld == 0){
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("Temperature:");
        lcd.setCursor(0, 1);
        lcd.print(String(temp, 1));
        lcd.write(0);
        lcd.print("F"); 
    }
    
    if(yPosOld == 1){
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("Humidity:");
        lcd.setCursor(0, 1);
        lcd.print(String(humid, 1) + "%");
    }
    
    if(yPosOld == 2){
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("Wind Speed:");
        lcd.setCursor(0, 1);
        lcd.print(String(wind, 2) + " mph");
    }

    if(yPosOld == 3){
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("Feels Like:");
        lcd.setCursor(0, 1);
        lcd.print(String(feels, 1));
        lcd.write(0);
        lcd.print("F"); 
    }
}