Are you looking for Embedded Systems Course – Contact ETDA Experts

Embedded Tech Development Academy

Facebook Instagram Linkedin

9845870904

IoT Weather Station Using FreeRTOS and ESP32

Learn how to build an Internet of Things (IoT) weather station using ESP32 and FreeRTOS with sensors, MQTT, HTTP, Wi-Fi, OLED display, cloud monitoring and task management.

Table of Contents

IoT Weather Station Using FreeRTOS and ESP32

Introduction to IoT Weather Station Using ESP32 and FreeRTOS

Environmental monitoring is an important application of modern Internet of Things (IoT) technology. A weather station can continuously measure parameters such as temperature, humidity, atmospheric pressure, air quality, rainfall, and wind speed and transmit the collected information to a cloud platform or local monitoring dashboard. When an ESP32 microcontroller is combined with FreeRTOS, the system can execute sensor acquisition, display updates, Wi-Fi communication, cloud transmission, and error-handling tasks concurrently.

The ESP32 is well suited for Internet of Things (IoT) weather stations because it provides processing capability, GPIO interfaces, ADC functionality, Wi-Fi, Bluetooth, timers, and peripheral interfaces such as I2C and SPI. FreeRTOS provides a multitasking environment where individual operations can be implemented as independent tasks with priorities, delays, queues, semaphores, and synchronization mechanisms.

A practical weather station therefore demonstrates several important embedded systems concepts, including sensor interfacing, real-time task scheduling, inter-task communication, Wi-Fi networking, MQTT/HTTP protocols, watchdog management, memory monitoring, and low-power operation.

For engineers learning embedded systems, this project provides a practical connection between microcontroller programming and cloud-connected Internet of Things (IoT) development. Embedded Tech Development Academy (ETDA) provides hands-on training in Embedded C, ESP32, FreeRTOS, Internet of Things (IoT) communication, sensors, and embedded development. Learners searching for a Top Embedded Training Institute in Bangalore can build practical project skills with assured placement support.

Hardware Components Required

ESP32 Development Board

The ESP32 acts as the central controller. It executes FreeRTOS tasks, interfaces with sensors, manages the OLED display, connects to Wi-Fi, and communicates with cloud services.

Environmental Sensors

Typical sensors include:

  • DHT22 for temperature and humidity
  • BME280 for temperature, humidity, and pressure
  • MQ-series sensors for gas or air-quality measurements
  • Rain sensors
  • Anemometers for wind-speed measurement
Display and Storage

An OLED display using SSD1306 or a similar controller can show real-time measurements. An SD card module can additionally store historical weather data for offline analysis.

Software Tools and Communication Technologies

Development Environment

The project can be developed using Arduino IDE or PlatformIO. ESP32 development environments provide libraries for GPIO, I2C, SPI, Wi-Fi, sensors, and display controllers.

FreeRTOS

FreeRTOS provides the task-management layer required to execute multiple operations concurrently.

IoT Communication

The weather station can communicate with cloud platforms using:

  • MQTT
  • HTTP/HTTPS
  • REST APIs
  • ThingSpeak
  • Blynk
  • Node-RED
  • Custom cloud servers

System Architecture

Functional Architecture

The system can be divided into independent functional blocks:

             +----------------------+
             |        ESP32         |
             +----------+-----------+
                        |
        +---------------+----------------+
        |               |                |
        v               v                v
   Sensor Task     Display Task     Wi-Fi Task
        |               |                |
        +-------+-------+                |
                |                        v
                v                 Cloud Communication
          Sensor Data Queue             |
                                         v
                                  MQTT / HTTP Server

FreeRTOS Task Separation

Each major operation can execute as an independent FreeRTOS task. A queue can transfer sensor measurements from the sensor task to display and communication tasks.

Advantages of the Architecture

Task separation prevents a slow network operation from unnecessarily blocking sensor acquisition. It also makes the firmware easier to debug, extend, and maintain.

FreeRTOS Task Design

Sensor Acquisition Task

The sensor task periodically reads environmental parameters.

Sensor Task Operation

A typical sequence is:

  1. Wake after a defined period.
  2. Read temperature and humidity.
  3. Read pressure if using BME280.
  4. Validate sensor values.
  5. Package measurements into a data structure.
  6. Send the structure to a FreeRTOS queue.
  7. Delay until the next sampling period.
Sampling Interval

The sampling interval depends on the application. Weather monitoring generally does not require millisecond-level sampling, so a period of a few seconds or longer can reduce CPU activity and power consumption.

Display Task

The display task receives measurements and updates the OLED.

Display Processing

It can show:

  • Temperature
  • Relative humidity
  • Atmospheric pressure
  • Wi-Fi status
  • Cloud connection status
Display Scheduling

The display task can use a lower priority than time-sensitive communication or sensor tasks because a small display refresh delay normally does not affect measurement accuracy.

Wi-Fi and Network Task

The network function establishes the ESP32’s Wi-Fi connection.

Reconnection Handling

If the access point becomes unavailable, the firmware should detect the connection failure and perform controlled reconnection attempts rather than continuously retrying in a tight loop.

Network Reliability

Connection management should include timeout handling, retry delays, and state monitoring to prevent network failures from blocking unrelated tasks.

MQTT and HTTP Communication

MQTT-Based Weather Data

MQTT is particularly suitable for Internet of Things (IoT) systems because it uses a lightweight publish/subscribe architecture.

MQTT Topics

Example topics include:

weather_station/temperature
weather_station/humidity
weather_station/pressure
weather_station/status
Publishing Sensor Data

The cloud communication task can receive validated measurements from a queue and publish them periodically to an MQTT broker.

HTTP-Based Communication

HTTP can be used when the cloud platform provides REST APIs.

POST Request

The ESP32 can transmit values using an HTTP POST request containing fields such as temperature, humidity, and pressure.

Cloud Platforms

Platforms such as ThingSpeak, Blynk, Node-RED-based systems, or custom REST servers can visualize and store weather measurements.

FreeRTOS Inter-Task Communication

Queue-Based Data Transfer

A FreeRTOS queue is useful for passing structured sensor data between tasks.

Example Data Structure 

typedef struct {
    float temperature;
    float humidity;
    float pressure;
} WeatherData;
Queue Operation

The sensor task can use xQueueSend() while the display or cloud task can use xQueueReceive(). This provides controlled communication between concurrent tasks without requiring every task to access shared sensor variables directly.

Optimization, Watchdog and Error Handling

Fault Detection

A robust weather station should validate sensor readings and detect sensor disconnection or communication errors.

Watchdog Protection

The ESP32 watchdog mechanisms can help recover from tasks that become stuck due to unexpected software conditions.

Memory and Stack Monitoring

uxTaskGetStackHighWaterMark() can be used to inspect remaining task-stack capacity. Developers should also monitor heap usage and avoid unnecessary dynamic allocation in long-running firmware.

Debugging and Testing

Serial Debugging

The ESP32 serial console can report:

  • Sensor readings
  • Task execution
  • Wi-Fi connection state
  • MQTT/HTTP errors
  • Queue failures
  • Reconnection events

FreeRTOS Monitoring

Functions such as vTaskList() can help inspect task states during debugging when the required FreeRTOS configuration is enabled.

Failure Testing

Testing should deliberately simulate:

  • Wi-Fi disconnection
  • Cloud-server unavailability
  • Invalid sensor readings
  • Sensor disconnection
  • Queue saturation
  • Repeated reconnection attempts

Future Improvements

Additional Environmental Sensors

The system can be extended with rainfall, wind-speed, wind-direction, and air-quality sensors.

Local Web Server

The ESP32 can host a lightweight web server so users can view weather information without depending entirely on a cloud dashboard.

OTA and Home Automation

Over-The-Air (OTA) firmware updates can simplify maintenance. MQTT integration can also connect the weather station to home-automation platforms such as Home Assistant.

Frequently Asked Questions

Why is FreeRTOS useful in an ESP32 weather station?

FreeRTOS allows sensor acquisition, display updates, Wi-Fi management, and cloud communication to operate as separate tasks with controlled priorities and timing.

A queue provides structured inter-task communication. Sensor data can be transferred safely from one task to another without requiring all tasks to directly access shared variables.

MQTT is often efficient for continuous telemetry because of its lightweight publish/subscribe architecture. HTTP can be preferable when communicating with REST-based APIs. The correct choice depends on the cloud architecture.

DHT22 can provide temperature and humidity, while BME280 can provide temperature, humidity, and atmospheric pressure. The sensor should be selected according to required accuracy, interface, sampling rate, and environmental conditions.

Use sensor validation, watchdog protection, controlled Wi-Fi reconnection, queue monitoring, stack and heap analysis, error handling, and systematic testing of network and sensor failures.

Conclusion

An Internet of Things (IoT) weather station using FreeRTOS and ESP32 is a practical project that combines microcontroller programming, environmental sensing, real-time task management, wireless networking, and cloud communication. The project demonstrates how an ESP32 can acquire temperature, humidity, pressure, and other environmental parameters while simultaneously managing an OLED display, Wi-Fi connectivity, and MQTT or HTTP-based cloud transmission.

From a FreeRTOS perspective, dividing the firmware into sensor, display, network, and cloud-communication tasks provides a clean software architecture. Queues can transfer measurements between tasks, while task priorities and periodic delays control processor utilization. Watchdog mechanisms, stack monitoring, queue management, and error handling further improve firmware reliability.

The project also introduces important Internet of Things (IoT) concepts such as MQTT topics, HTTP APIs, cloud dashboards, telemetry, remote monitoring, OTA updates, and local web interfaces. These concepts are directly applicable to industrial monitoring, smart agriculture, home automation, environmental monitoring, and other connected embedded systems.

Embedded Tech Development Academy (ETDA) provides practical training in ESP32, FreeRTOS, Embedded C, Internet of Things (IoT) protocols, sensors, Wi-Fi, MQTT, and embedded systems development. Learners looking for a Top Embedded Training Institute in Bangalore can work on industry-oriented embedded projects with assured placement support.

For engineers developing connected embedded systems, the project can be extended with wind-speed measurement, rainfall detection, air-quality monitoring, SD-card logging, local web dashboards, OTA firmware updates, and Home Assistant integration. These extensions transform a basic sensor project into a more complete Internet of Things (IoT) edge device.

Embedded Tech Development Academy (ETDA) helps learners connect theoretical concepts with practical hardware and firmware development. A Top Embedded Training Institute in Bangalore learning environment that includes FreeRTOS scheduling, sensor interfacing, Wi-Fi, MQTT, cloud integration, debugging, and hardware testing provides a strong technical foundation with assured placement support.

As Internet of Things (IoT) deployments continue to expand, engineers need practical knowledge of both embedded firmware and network communication. Embedded Tech Development Academy (ETDA) supports this learning path through hands-on technical development, assured placement support, and an industry-oriented approach expected from a Top Embedded Training Institute in Bangalore.

Ultimately, this weather-station project is more than a sensor-reading application. It demonstrates how FreeRTOS task management, inter-task communication, ESP32 peripherals, environmental sensors, Wi-Fi networking, MQTT/HTTP protocols, cloud monitoring, watchdog mechanisms, and embedded debugging can be combined into a reliable connected device. These skills provide a practical foundation for developing modern embedded systems and production-oriented Internet of Things (IoT) products.

Author: ETDA Trainers
Experience: 10+ Years of Industry Experience in Embedded Systems, IoT, and Embedded C Programming

Home