IoT & Embedded
Systems

Chapter 1: IoT Architecture Stack

Every IoT system, from a $5 soil sensor to a billion-dollar smart grid, is built from the same four layers. Understanding these layers is the skeleton key to designing any IoT solution.

The four-layer IoT architecture:

Let's trace a concrete path through all four layers. Imagine a greenhouse monitoring system:

json
{
  "deviceId": "greenhouse-01",
  "timestamp": "2026-05-16T10:30:00Z",
  "temperature": 24.6,
  "humidity": 38.2,
  "pressure": 1013.25
}

At each layer, you make choices. Those choices cascade. Picking LoRaWAN at Layer 2 means your payload is limited to 51-222 bytes — you can't send raw images. Picking BLE means your range is ~100m — you need a gateway for anything larger than a room.

Chapter 2: Sensors & Edge Processing

A sensor converts a physical quantity into an electrical signal. That signal gets digitized by an ADC (Analog-to-Digital Converter), processed by a microcontroller, and packaged for transmission. Every IoT system starts here — at the physical interface between the digital and analog worlds.

Sensor categories by what they measure:

But here's the critical insight: you almost never want to send raw sensor data to the cloud.

The solution is edge processing — compute at the device or gateway level before transmitting. This is where the "intelligence" in AIoT lives.

Edge processing strategies:

Worked example — let's calculate the edge vs cloud tradeoff:

If we also apply delta encoding (only report if temp changed by >0.5°C), we might only send 1 in 3 intervals:

python
# Edge aggregation on ESP32 (MicroPython)
import time
from machine import I2C, Pin
from bme280 import BME280

i2c = I2C(0, scl=Pin(22), sda=Pin(21))
sensor = BME280(i2c=i2c)

class EdgeAggregator:
    def __init__(self, window_sec=60, threshold=0.5):
        self.window = window_sec
        self.threshold = threshold
        self.buffer = []
        self.last_sent = None

    def add_reading(self, temp, hum, pres):
        self.buffer.append((temp, hum, pres))

    def should_send(self):
        if not self.buffer:
            return False
        avg_t = sum(r[0] for r in self.buffer) / len(self.buffer)
        if self.last_sent is None:
            return True
        return abs(avg_t - self.last_sent) > self.threshold

    def get_aggregate(self):
        """Returns {min, max, mean} for each channel."""
        temps = [r[0] for r in self.buffer]
        result = {
            "temp_min": min(temps),
            "temp_max": max(temps),
            "temp_mean": sum(temps) / len(temps),
        }
        self.last_sent = result["temp_mean"]
        self.buffer = []
        return result

Chapter 3: Connectivity & MQTT

Your sensor has a reading. Now it needs to get that reading to the cloud. The choice of connectivity technology is the most consequential architectural decision in IoT — it determines battery life, range, cost, and what data you can realistically transmit.

Once you've chosen how to connect, you need a protocol to structure the conversation. For IoT, that protocol is almost always MQTT (Message Queuing Telemetry Transport).

MQTT uses a publish/subscribe model. This is fundamentally different from HTTP's request/response:

MQTT Topics are hierarchical strings separated by /. They support wildcards:

mqtt topics
# Specific sensor
farm/field1/moisture

# All sensors in field1 (+ = single level wildcard)
farm/field1/+

# All sensors in all fields (# = multi-level wildcard)
farm/#

# Real-world Azure IoT Hub topic format
devices/{device-id}/messages/events/

QoS Levels — the trade-off between reliability and overhead:

python
# MQTT publish with Paho client (the standard Python MQTT library)
import paho.mqtt.client as mqtt
import json, time

def on_connect(client, userdata, flags, rc):
    print(f"Connected with result code {rc}")
    client.subscribe("farm/+/moisture", qos=1)

def on_message(client, userdata, msg):
    data = json.loads(msg.payload)
    print(f"{msg.topic}: moisture={data['value']}%")

client = mqtt.Client(client_id="gateway-01")
client.tls_set()  # Enable TLS encryption
client.username_pw_set("user", "password")
client.on_connect = on_connect
client.on_message = on_message

client.connect("your-hub.azure-devices.net", 8883)
client.loop_start()

# Publish sensor data
payload = json.dumps({"value": 42.5, "unit": "%"})
client.publish("farm/field1/moisture", payload, qos=1)

Chapter 4: Azure IoT Architecture

Your sensor published a message. It left the device over WiFi, became an MQTT packet, and hit the cloud. Now what? The cloud platform is where raw telemetry becomes actionable intelligence. We'll use Azure IoT as our reference architecture — the concepts map directly to AWS IoT Core and Google Cloud IoT.

The core Azure IoT services form a pipeline:

IoT Hub is the most critical component. It handles:

json
// Device Twin for greenhouse-01
{
  "deviceId": "greenhouse-01",
  "properties": {
    "desired": {
      "telemetryInterval": 60,
      "temperatureThreshold": 30,
      "firmwareVersion": "2.1.0"
    },
    "reported": {
      "telemetryInterval": 60,
      "temperatureThreshold": 30,
      "firmwareVersion": "2.0.3",
      "battery": 78,
      "lastBoot": "2026-05-16T08:00:00Z"
    }
  }
}

Notice: the desired firmware is 2.1.0 but reported is 2.0.3. The device sees this mismatch and initiates an OTA update. No human intervention required.

Stream Analytics query — detect temperature spikes in real-time:

sql
-- Alert when any device exceeds threshold for 5 minutes
SELECT
    deviceId,
    AVG(temperature) AS avg_temp,
    MAX(temperature) AS max_temp,
    System.Timestamp() AS window_end
INTO
    alertOutput
FROM
    iothub TIMESTAMP BY EventEnqueuedUtcTime
GROUP BY
    deviceId,
    TumblingWindow(minute, 5)
HAVING
    AVG(temperature) > 30

python
# Register device and send telemetry with Azure IoT SDK
from azure.iot.device import IoTHubDeviceClient, Message
import json

# Connection string from Azure Portal > IoT Hub > Device
conn_str = "HostName=myhub.azure-devices.net;DeviceId=greenhouse-01;SharedAccessKey=..."

client = IoTHubDeviceClient.create_from_connection_string(conn_str)
client.connect()

# Send telemetry
payload = json.dumps({
    "temperature": 24.6,
    "humidity": 38.2
})
msg = Message(payload)
msg.content_type = "application/json"
msg.content_encoding = "utf-8"
msg.custom_properties["alert"] = "false"

client.send_message(msg)
print("Telemetry sent")

# Listen for Device Twin updates (desired properties)
def twin_patch_handler(patch):
    print(f"Received twin patch: {patch}")
    if "telemetryInterval" in patch:
        # Adjust our sending rate
        global INTERVAL
        INTERVAL = patch["telemetryInterval"]

client.on_twin_desired_properties_patch_received = twin_patch_handler

Chapter 5: Device Programming

You've designed the architecture. Now you need to actually write the firmware that runs on the microcontroller. This is embedded programming — writing software for devices with 256KB of RAM, no operating system (or a minimal RTOS), and the need to run for years on a coin cell battery.

Framework choices for IoT device programming:

The fundamental embedded programming loop is deceptively simple:

WiFi Provisioning — how does a headless device (no screen, no keyboard) connect to your WiFi network for the first time?

OTA (Over-The-Air) Updates — critical for any deployed fleet. You cannot physically visit 10,000 sensors to update firmware.

c
// ESP-IDF: Complete IoT device firmware skeleton
// Connects to WiFi, publishes BME280 data via MQTT to Azure IoT Hub

#include "esp_wifi.h"
#include "esp_event.h"
#include "mqtt_client.h"
#include "esp_sleep.h"
#include "driver/i2c.h"

#define SLEEP_DURATION_US  (60 * 1000000)  // 60 seconds
#define MQTT_BROKER        "mqtts://myhub.azure-devices.net:8883"
#define MQTT_TOPIC         "devices/sensor-01/messages/events/"

static esp_mqtt_client_handle_t mqtt_client;

void wifi_init(void) {
    esp_netif_init();
    esp_event_loop_create_default();
    esp_netif_create_default_wifi_sta();

    wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
    esp_wifi_init(&cfg);

    wifi_config_t wifi_config = {
        .sta = { .ssid = "MyNetwork", .password = "MyPassword" }
    };
    esp_wifi_set_mode(WIFI_MODE_STA);
    esp_wifi_set_config(WIFI_IF_STA, &wifi_config);
    esp_wifi_start();
    esp_wifi_connect();
}

void mqtt_publish_telemetry(float temp, float hum) {
    char payload[128];
    snprintf(payload, sizeof(payload),
        "{\"temperature\":%.1f,\"humidity\":%.1f}", temp, hum);

    esp_mqtt_client_publish(mqtt_client, MQTT_TOPIC,
        payload, 0, 1, 0);  // QoS 1
}

void app_main(void) {
    wifi_init();
    // ... wait for connection ...

    esp_mqtt_client_config_t mqtt_cfg = {
        .broker.address.uri = MQTT_BROKER,
        .credentials.authentication.certificate = device_cert,
    };
    mqtt_client = esp_mqtt_client_init(&mqtt_cfg);
    esp_mqtt_client_start(mqtt_client);

    // Read sensor
    float temp = bme280_read_temperature();
    float hum = bme280_read_humidity();

    // Publish
    mqtt_publish_telemetry(temp, hum);

    // Deep sleep
    esp_deep_sleep(SLEEP_DURATION_US);
}

Chapter 6: Smart Agriculture System [SHOWCASE]

Everything comes together now. We'll simulate a complete smart agriculture irrigation system end-to-end: soil moisture sensors in the field, LoRa radio to a gateway, MQTT to Azure IoT Hub, Stream Analytics for decision-making, and an irrigation valve that opens automatically when the soil is too dry.

The architecture:

What happens when the gateway goes offline? The sensor node stores readings in flash memory (up to 72 hours of data at 1-minute intervals = 4,320 readings × 8 bytes = 34 KB). When the gateway comes back, the node replays stored data with timestamps. The cloud sees the gap and processes the backlog. This is store-and-forward — a critical IoT resilience pattern.

What happens when the cloud goes down? The gateway itself has a local rule engine: "if latest moisture < 20%, open valve." This is edge fallback — the system degrades gracefully from "smart" (cloud analytics with historical context) to "functional" (simple threshold at the gateway).

Chapter 7: Security & Privacy

In October 2016, the Mirai botnet enslaved 600,000 IoT devices (cameras, routers, DVRs) and used them to launch the largest DDoS attack in history, taking down Twitter, Netflix, Reddit, and GitHub for hours. The devices were compromised because they used default passwords like "admin/admin" and had no mechanism for firmware updates.

IoT security is not optional. It's existential. A compromised insulin pump can kill a patient. A hijacked traffic controller can cause accidents. A breached smart lock lets burglars in.

The OWASP IoT Top 10 (2024) — the most critical IoT vulnerabilities:

Defense layers for a secure IoT deployment:

Privacy — GDPR and IoT:

Under GDPR (and similar regulations worldwide), IoT data that can identify a person is personal data. A smart meter's consumption pattern reveals when you're home, when you sleep, what appliances you use. A fitness tracker knows your heart rate, location, and sleep quality.

Chapter 8: 5G & Future Applications

4G gave us fast phones. 5G gives us a programmable network fabric for machines. The difference isn't just speed — it's three fundamentally different service types designed for three different use cases, all running simultaneously on the same physical infrastructure.

The three 5G service categories:

5G-enabled IoT applications that were impossible before:

Concrete example: smart city air quality network

Imagine deploying 10,000 air quality sensors (PM2.5, NO2, O3) across a city of 500 km². That's 20 sensors per km². Each reports every 5 minutes. With 5G mMTC:

The real value isn't raw capacity — it's the connection density. 10,000 devices can all be simultaneously connected without channel contention, sleeping most of the time, waking only to send their 64-byte payload.

Chapter 9: Mastery & Connections

You now understand the complete IoT stack: from sensor physics to cloud architecture, from MQTT packets to 5G network slicing, from edge processing to security hardening. Let's consolidate with decision frameworks you can use in real system design.

Protocol Selection Matrix — the cheat sheet for every IoT architect:

IoT Security Deployment Checklist:

Power Budget Calculator — will your battery last?

Example: ESP32 with 3000mAh battery, wakes 2s every 5 min:

To reach 1 year: either sleep longer (wake every 30 min = 465 days) or use LoRa (TX at 40mA for 100ms = 2+ years).

U.S. IoT Security Legislation:

Design Challenge: Design a city-wide air quality monitoring network for a city of 2 million people, 800 km².

Connections: