Real-World IoT Implementation Examples
smart home, environmental monitoring, servo control, relay switching, MQTT, automation
By the end of this chapter, you will be able to:
This chapter shows how sensors and actuators work together in complete projects, like a smart thermostat that reads the temperature and automatically turns a fan on or off. These are the kinds of projects that make IoT tangible – instead of just reading numbers from a sensor, you build systems that sense the environment and take action in response, just like a real commercial smart home device.
This chapter brings together sensor interfacing, data processing, and actuation into complete, practical IoT applications. Each example demonstrates the full sensor-to-action pipeline, from reading physical measurements to triggering real-world responses.
A complete environmental monitoring system combining multiple sensors with cloud connectivity and automated responses.
// Complete environmental monitoring system
#include <WiFi.h>
#include <PubSubClient.h>
#include <DHT.h>
#include <Wire.h>
#include <BH1750.h>
// Sensors
DHT dht(4, DHT22);
BH1750 lightMeter;
// Wi-Fi and MQTT
WiFiClient espClient;
PubSubClient mqtt(espClient);
// Thresholds
#define TEMP_HIGH 28.0
#define TEMP_LOW 18.0
#define HUMIDITY_HIGH 70.0
#define LIGHT_THRESHOLD 200.0
void setup() {
Serial.begin(115200);
// Initialize sensors
dht.begin();
Wire.begin();
lightMeter.begin();
// Connect to Wi-Fi
connectWiFi();
// Connect to MQTT
mqtt.setServer("mqtt.example.com", 1883);
connectMQTT();
}
void loop() {
if (!mqtt.connected()) {
connectMQTT();
}
mqtt.loop();
// Read sensors
float temp = dht.readTemperature();
float humidity = dht.readHumidity();
float light = lightMeter.readLightLevel();
// Check conditions and take actions
if (temp > TEMP_HIGH) {
Serial.println("Temperature too high! Turning on AC");
mqtt.publish("home/ac", "ON");
} else if (temp < TEMP_LOW) {
Serial.println("Temperature too low! Turning on heater");
mqtt.publish("home/heater", "ON");
}
if (humidity > HUMIDITY_HIGH) {
Serial.println("Humidity too high! Turning on dehumidifier");
mqtt.publish("home/dehumidifier", "ON");
}
if (light < LIGHT_THRESHOLD) {
Serial.println("Dark! Turning on lights");
mqtt.publish("home/lights", "ON");
} else {
mqtt.publish("home/lights", "OFF");
}
// Publish sensor data
String payload = "{\"temp\":" + String(temp) +
",\"humidity\":" + String(humidity) +
",\"light\":" + String(light) + "}";
mqtt.publish("home/sensors", payload.c_str());
delay(60000); // 1 minute
}
void connectWiFi() {
WiFi.begin("SSID", "password");
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("\nWi-Fi connected");
}
void connectMQTT() {
while (!mqtt.connected()) {
if (mqtt.connect("ESP32_Home_Sensor")) {
Serial.println("MQTT connected");
} else {
delay(5000);
}
}
}This HVAC control system uses simple threshold logic with potential rapid switching issues. Consider a room at 27.9°C approaching the TEMP_HIGH = 28.0°C threshold. DHT22 accuracy: ±0.5°C. Measurement noise: ±0.2°C typical. The AC turns ON at 28.0°C, cools to 27.9°C, turns OFF, temperature drifts to 28.1°C, AC turns ON again – cycling every 2-3 minutes.
Better approach: hysteresis with separate thresholds: - Turn AC ON when \(T > 28.0°C\) - Turn AC OFF when \(T < 27.0°C\)
Hysteresis band: ΔT = 28.0 - 27.0 = 1.0°C. With typical cooling rate 0.5°C/min and natural warming rate 0.5°C/min, the full cycle time is t_cycle = (2 × ΔT) / rate = (2 × 1.0°C) / (0.5°C/min) = 4 min/cycle.
This means 15 cycles/hour (60 min ÷ 4 min). A 1°C hysteresis band reduces AC cycles from ~30/hour (no hysteresis) to 15/hour, extending compressor life by 50% and reducing energy consumption by 8-12% through fewer startup transients.
Interactive Hysteresis Calculator:
Servo Motors in IoT: Servo motors provide precise angular positioning, making them ideal for automated control systems. Combined with sensors, they create feedback-controlled actuators.
Specifications (SG90 Servo):
#include <ESP32Servo.h>
#define SERVO_PIN 18
#define LDR_PIN 34
Servo blindsServo;
void setup() {
Serial.begin(115200);
// Attach servo
blindsServo.attach(SERVO_PIN, 1000, 2000); // min, max pulse width
// Configure ADC
analogReadResolution(12);
analogSetAttenuation(ADC_11db);
Serial.println("Automated Blinds Control");
}
void loop() {
// Read light sensor
int lightLevel = analogRead(LDR_PIN);
float lightPercent = (lightLevel / 4095.0) * 100;
// Map light level to servo angle
// High light = close blinds (180 degrees)
// Low light = open blinds (0 degrees)
int servoAngle = map(lightLevel, 0, 4095, 0, 180);
// Move servo
blindsServo.write(servoAngle);
// Display status
Serial.print("Light: ");
Serial.print(lightPercent, 1);
Serial.print("% | Servo Angle: ");
Serial.print(servoAngle);
Serial.print(" deg | Blinds: ");
if (servoAngle < 45) {
Serial.println("Fully Open");
} else if (servoAngle < 135) {
Serial.println("Partially Open");
} else {
Serial.println("Fully Closed");
}
delay(1000);
}Observe:
Interactive Servo Mapping Calculator:
Control Logic:
High Light (bright) -> Angle 180 deg -> Blinds CLOSED (shade interior)
Medium Light -> Angle 90 deg -> Blinds HALF (moderate light)
Low Light (dark) -> Angle 0 deg -> Blinds OPEN (maximize daylight)Real-World Applications:
Experiment:
Relays in IoT: Relays are electrically operated switches that allow low-power microcontrollers to control high-power AC/DC devices safely. Essential for home automation and industrial control.
Relay Specifications:
#include <DHT.h>
#define DHT_PIN 4
#define RELAY_PIN 13
#define TEMP_THRESHOLD_ON 28.0 // Turn fan ON above 28C
#define TEMP_THRESHOLD_OFF 26.0 // Turn fan OFF below 26C (hysteresis)
DHT dht(DHT_PIN, DHT22);
bool fanState = false;
void setup() {
Serial.begin(115200);
pinMode(RELAY_PIN, OUTPUT);
digitalWrite(RELAY_PIN, LOW); // Fan initially OFF
dht.begin();
Serial.println("Temperature-Controlled Fan System");
}
void loop() {
float temperature = dht.readTemperature();
float humidity = dht.readHumidity();
if (isnan(temperature) || isnan(humidity)) {
Serial.println("Failed to read from DHT sensor!");
delay(2000);
return;
}
// Control logic with hysteresis to prevent rapid switching
if (!fanState && temperature > TEMP_THRESHOLD_ON) {
// Turn fan ON
fanState = true;
digitalWrite(RELAY_PIN, HIGH);
Serial.println("Temperature HIGH - Fan turned ON");
}
else if (fanState && temperature < TEMP_THRESHOLD_OFF) {
// Turn fan OFF
fanState = false;
digitalWrite(RELAY_PIN, LOW);
Serial.println("Temperature OK - Fan turned OFF");
}
// Display status
Serial.print("Temp: ");
Serial.print(temperature, 1);
Serial.print("C | Humidity: ");
Serial.print(humidity, 1);
Serial.print("% | Fan: ");
Serial.println(fanState ? "ON" : "OFF");
delay(2000);
}Observe:
Hysteresis Explanation:
Temperature Rising: 24C -> 26C -> 28C -> [FAN TURNS ON]
Temperature Falling: 30C -> 28C -> 26C -> [FAN TURNS OFF]
Without Hysteresis (bad):
27.9C -> OFF, 28.1C -> ON, 27.9C -> OFF... (rapid switching damages relay!)
With Hysteresis (good):
Temperature must fall to 26C before turning off againReal-World Applications:
Safety Considerations:
Experiment:
| Sensor | Range | Accuracy | Iface | Power | Cost Tier | Primary Use |
|---|---|---|---|---|---|---|
| DHT22 | -40 to 80°C | ±0.5°C | 1-Wire | 1.5 mA | Low | General indoor sensing |
| DS18B20 | -55 to 125°C | ±0.5°C | 1-Wire | 1.5 mA | Low | Multipoint or waterproof probes |
| LM35 | -55 to 150°C | ±0.5°C | Analog | 60 µA | Low | Simple low-power analog input |
| BME280 | -40 to 85°C | ±1°C | I2C/SPI | 3.6 µA | Mid | Combined environmental sensing |
| TMP117 | -55 to 125°C | ±0.1°C | I2C | 3.5 µA | High | Precision temperature control |
Objective: Build a multi-sensor system using I2C bus and resolve address conflicts.
Scenario: Connect BMP280 (pressure, 0x76), BH1750 (light, 0x23), and two MPU6050 IMUs (both default to 0x68) to an ESP32.
Tasks:
Implementation Starter:
#include <Wire.h>
void scanI2C() {
Serial.println("Scanning I2C bus...");
for(byte addr = 1; addr < 127; addr++) {
Wire.beginTransmission(addr);
if (Wire.endTransmission() == 0) {
Serial.printf("Found device at 0x%02X\n", addr);
}
}
}
// Exercise: Add code to read from all 4 sensors
// Exercise: Add error handling for sensor failuresObjective: Minimize power consumption for battery-powered sensor node.
Scenario: Battery-powered weather station (ESP32 + BME280 + BH1750) transmitting via LoRa every 15 minutes. Battery: 2000 mAh. Target lifetime: 1 year.
Tasks:
Implementation Starter:
#define SENSOR_POWER_PIN 13
void powerOnSensors() {
digitalWrite(SENSOR_POWER_PIN, HIGH);
delay(100); // Sensor stabilization time
}
void powerOffSensors() {
digitalWrite(SENSOR_POWER_PIN, LOW);
}
void loop() {
powerOnSensors();
// Read sensors
float temp = bme.readTemperature();
powerOffSensors();
// Buffer and transmit logic
esp_deep_sleep(15 * 60 * 1000000); // 15 minutes
}Objective: Build complete data pipeline with calibration, filtering, validation, and anomaly detection.
Scenario: Industrial temperature monitoring using 10 DS18B20 sensors. Sensors require calibration and readings must be validated before sending to cloud.
Tasks:
Scenario: You’re deploying a complete smart home monitoring system with the following actuators and sensors operating simultaneously:
System Components:
Step 1: Calculate worst-case peak current
When do all components draw maximum power simultaneously? When both servos are moving (adjusting blinds) while the relay activates the AC unit:
Step 2: Apply safety margins
Step 3: Select power supply rating
Choose a 5V 2A regulated power supply (common size, provides 18% headroom above 1.69A).
Step 4: Calculate average power consumption
Most of the time, the system is idle: - Duty cycle: Servos move 10 seconds every 10 minutes (1.67% active) - Relay ON: 30% of the time when temperature exceeds threshold - DHT22 reading: 1 second every 300 seconds (0.33% active)
Average current = 80 + 0.12 + (2.5×0.0033) + (70×0.30) + (2×100×0.0167) ≈ 104mA typical
Battery life estimate (if using 10,000mAh USB power bank for backup): 10,000mAh ÷ 104mA = 96 hours (4 days) backup runtime
Key Insight: Peak current (1.15A) is 11x higher than average current (104mA). Designing for average would cause brownout resets when servos activate. Always design power supplies for worst-case peak, not average load.
Interactive Power Budget Calculator:
Building real-world IoT applications requires combining sensors, processing logic, and actuators into complete feedback loops. The three critical patterns demonstrated here – threshold-based control with hysteresis (relay), proportional control with mapping (servo), and multi-sensor monitoring with cloud connectivity (MQTT) – form the foundation for virtually all IoT automation systems, from smart homes to industrial processes.
Max the Microcontroller gathered the team for a home automation demo day. “Alright squad, let’s show how a smart home works!”
Sammy the Sensor went first. “I’m watching the temperature, humidity, AND light levels – all at the same time! Right now it’s 29 degrees… that’s too hot!”
“Leave it to me!” said Lila the LED, flashing red. “I just told the air conditioner to turn ON through our message system called MQTT. It’s like sending a text message that says ‘home/ac: ON’ and the AC gets the message instantly!”
“But what about the blinds?” asked Bella the Battery. “The sun is super bright!”
Sammy checked the light sensor. “The light level is really high – 90%! So the servo motor turns the blinds almost all the way closed. When it gets cloudy and light drops to 20%, the blinds open up again. It’s like the house has sunglasses that adjust automatically!”
Max explained the cleverest part: “And see the fan? It turns ON when temperature hits 28 degrees, but it doesn’t turn OFF until it drops to 26 degrees. That 2-degree gap is called hysteresis – it’s like how you don’t put your jacket back on until it’s actually cold, not just slightly cooler!”
“So the house basically takes care of itself?” Bella asked, impressed.
“Exactly!” Max beamed. “Sensors watch, I think, and actuators act. That’s the IoT magic – sense, decide, act, repeat!”
This chapter covered real-world sensor applications:
Instrumenting everything and storing raw sensor streams without a clear analytical goal wastes storage, bandwidth, and compute. Define the decision you need to make first, then instrument only what supports that decision.
Missing values, stuck readings, and out-of-range spikes propagate silently through pipelines and corrupt analytics. Implement data validation and anomaly flagging close to the sensor source.
Many sensor applications do not require sub-second response. Batching readings and transmitting periodically reduces energy use and network load. Reserve streaming for safety-critical or time-sensitive use cases.
Hard-coding sensor model assumptions (scale factors, units, pin assignments) into application logic makes it fragile when sensors are upgraded. Use abstraction layers and configuration files to separate hardware from application logic.
| If you want to… | Read this |
|---|---|
| Explore specific vertical application domains | Smart Home and Building Automation |
| Learn about industrial IoT sensor applications | Industrial IoT Sensing |
| Understand the data platforms that receive sensor data | IoT Reference Architectures |
| See how edge processing fits into sensor applications | Edge and Fog Computing |
The next chapter provides a hands-on Sensor Calibration Lab using the Wokwi simulator, where you will implement two-point calibration, signal conditioning, and EEPROM storage.