14  Hands-On Labs Hub

Practical IoT Learning Through Guided Experiments

14.1 Learning Objectives

After completing this chapter, you will be able to:

  • Implement MQTT publish/subscribe messaging using Python and a public broker
  • Build an end-to-end IoT data pipeline from sensor simulation through MQTT, InfluxDB, and Grafana
  • Apply structured lab methodologies with clear objectives, validation checkpoints, and success criteria
  • Select appropriate lab exercises based on your skill level (beginner, intermediate, or advanced)

These labs are guided experiments where you build real IoT systems step by step. Each lab tells you exactly what you need, walks you through the process, and includes checkpoints to verify you are on track. Even if you have never programmed a microcontroller before, the beginner labs start with the basics – like sending your first message between two devices – and gradually build up to more complex projects.

In 60 Seconds

Structured laboratory exercises spanning beginner to advanced levels, including MQTT messaging, sensor data pipelines (MQTT to InfluxDB to Grafana), LoRaWAN simulation, sensor calibration, TLS security setup, and edge computing architecture labs. Each lab includes objectives, materials, step-by-step instructions, and validation checkpoints.

Chapter Scope (Avoiding Duplicate Hubs)

This chapter focuses on guided lab execution and validation checkpoints.

  • Use Simulations Hub when you need exploratory experimentation before implementation.
  • Use Tool Discovery Hub to browse all available interactive tools.
  • Use this chapter when you are ready to implement, validate, and document practical outcomes.

14.2 Hands-On Labs Hub

Learning by Doing

This hub provides structured laboratory exercises that take you from theory to practice. Each lab includes clear objectives, required materials, step-by-step instructions, and validation checkpoints.

Dual-Track Lab Pattern (Deep + Guided)

To keep labs rigorous and accessible:

  1. Deep prep: Read the underlying theory chapter first.
  2. Guided execution: Follow the lab steps and checkpoints exactly.
  3. Reinforcement: Pair each lab with one simulator run and one quiz/game check.
  4. Transfer: Write one design decision based on measured results.

This prevents “copy-paste completion” and builds real engineering judgment.

14.3 Lab Difficulty Levels

Lab Difficulty Beginner

30-60 min Basic programming

Suitable for: New to IoT.

Lab Difficulty Intermediate

1-2 hours Completed beginner labs

Suitable for: Building skills.

Lab Difficulty Advanced

2-4 hours Strong foundation

Suitable for: Project preparation.

Lab Time Planner:

14.4 Reinforcement Mapping

Reinforcement Mapping MQTT Publish/Subscribe Understanding Reinforcement tool: Simulations Hub

Validation: Quiz Hub.

Reinforcement Mapping End-to-End Data Pipeline Confidence Reinforcement tool: Tool Discovery Hub

Validation: Dashboard checkpoint + quiz.

Reinforcement Mapping Wireless Design Trade-Off Decisions Reinforcement tool: LoRaWAN simulations

Validation: Design note with margin calculations.

Reinforcement Mapping Security Configuration Readiness Reinforcement tool: Zero-trust and segmentation tools

Validation: Threat-model checklist.

Reinforcement Mapping Long-Term Retention Reinforcement tool: IoT Games Hub

Validation: Challenge completion.

14.5 Networking & Protocols Labs

14.5.1 Lab 1: Your First MQTT Message (Beginner)

Duration: 45 minutes | Difficulty: Beginner

Learning Objectives:

  • Understand publish/subscribe messaging pattern
  • Connect to an MQTT broker
  • Send and receive messages programmatically
  • Observe message flow in real-time

Materials Needed:

  • Computer with Python 3.8+
  • Internet connection
  • Text editor or IDE

Prerequisites: Basic Python knowledge

14.5.1.1 Step 1: Environment Setup (10 min)

# Install the MQTT client library
pip install paho-mqtt

# Verify installation
python -c "import paho.mqtt.client as mqtt; print('MQTT library ready!')"

14.5.1.2 Step 2: Connect to Public Broker (10 min)

Create a file called mqtt_subscriber.py:

import paho.mqtt.client as mqtt

# Callback when connected
def on_connect(client, userdata, flags, rc):
    print(f"Connected with result code {rc}")
    # Subscribe to a test topic
    client.subscribe("iotclass/lab1/temperature")

# Callback when message received
def on_message(client, userdata, msg):
    print(f"Received: {msg.topic} -> {msg.payload.decode()}")

# Create client and set callbacks
client = mqtt.Client()
client.on_connect = on_connect
client.on_message = on_message

# Connect to public broker (test.mosquitto.org)
client.connect("test.mosquitto.org", 1883, 60)

# Start listening
print("Waiting for messages... Press Ctrl+C to stop")
client.loop_forever()

MQTT publish/subscribe messaging adds protocol overhead to every message. For a 20-byte sensor payload, the total packet size includes MQTT headers.

\[ \text{Total Size} = \text{MQTT Fixed Header (2 bytes)} + \text{Topic Length} + \text{Payload} \]

Worked example: Topic "iotclass/lab1/temperature" = 27 bytes. Payload = 5 bytes ("25.3C"). MQTT QoS 0 overhead = 2-byte fixed header. Total packet size = 2 + 27 + 5 = 34 bytes. For 500 sensors publishing every 15 minutes: 500 × 96 msgs/day × 34 bytes = 1.632 MB/day. At $0.10/MB cellular data cost = $0.16/day or $4.90/month for the entire network.

Try it yourself:

Checkpoint 1

Run the subscriber: python mqtt_subscriber.py

You should see: “Connected with result code 0”

If you see a different code, check your internet connection.

14.5.1.3 Step 3: Publish Messages (15 min)

Create a file called mqtt_publisher.py:

import paho.mqtt.client as mqtt
import time
import random

client = mqtt.Client()
client.connect("test.mosquitto.org", 1883, 60)

# Simulate temperature readings
for i in range(5):
    temperature = round(20 + random.uniform(-5, 10), 1)
    message = f"{temperature}C"

    client.publish("iotclass/lab1/temperature", message)
    print(f"Published: {message}")
    time.sleep(2)

client.disconnect()
print("Done!")
Checkpoint 2

With subscriber running in one terminal, run publisher in another:

python mqtt_publisher.py

You should see messages appear in the subscriber terminal.

14.5.1.4 Step 4: Experiment (10 min)

Try these modifications:

  1. Change the topic: Use iotclass/lab1/yourname/temperature
  2. Add QoS: Modify publish to use qos=1 for guaranteed delivery
  3. JSON payload: Send {"temp": 25.5, "unit": "C"} instead of plain text

14.5.1.5 Lab Validation

Success Criteria

You have completed this lab when you can:

14.5.1.6 What’s Next?

14.5.2 Lab 2: Sensor Data Pipeline (Intermediate)

Duration: 90 minutes | Difficulty: Intermediate

Learning Objectives:

  • Build end-to-end data pipeline: Sensor -> MQTT -> Database -> Dashboard
  • Store time-series data in InfluxDB
  • Create real-time visualizations with Grafana
  • Understand data flow in IoT architectures

Materials Needed:

  • Docker installed on your computer
  • Completed Lab 1
  • 2GB free disk space

Prerequisites: Lab 1, basic Docker knowledge helpful

14.5.2.1 Step 1: Start Infrastructure (15 min)

Create docker-compose.yml:

version: '3'
services:
  mosquitto:
    image: eclipse-mosquitto:2
    ports:
      - "1883:1883"
    volumes:
      - ./mosquitto.conf:/mosquitto/config/mosquitto.conf

  influxdb:
    image: influxdb:2.7
    ports:
      - "8086:8086"
    environment:
      - DOCKER_INFLUXDB_INIT_MODE=setup
      - DOCKER_INFLUXDB_INIT_USERNAME=admin
      - DOCKER_INFLUXDB_INIT_PASSWORD=adminpassword
      - DOCKER_INFLUXDB_INIT_ORG=iotclass
      - DOCKER_INFLUXDB_INIT_BUCKET=sensors

  grafana:
    image: grafana/grafana:latest
    ports:
      - "3000:3000"
    depends_on:
      - influxdb

Create mosquitto.conf:

listener 1883
allow_anonymous true

Start the stack:

docker-compose up -d
Checkpoint 1

Verify all services are running:

docker-compose ps

All three services should show “Up” status.

14.5.2.2 Step 2: Bridge MQTT to InfluxDB (20 min)

Create mqtt_to_influx.py:

import paho.mqtt.client as mqtt
from influxdb_client import InfluxDBClient, Point
from influxdb_client.client.write_api import SYNCHRONOUS
import json

# InfluxDB connection
influx_client = InfluxDBClient(
    url="http://localhost:8086",
    token="your-token-here",  # Get from InfluxDB UI
    org="iotclass"
)
write_api = influx_client.write_api(write_options=SYNCHRONOUS)

def on_message(client, userdata, msg):
    try:
        # Parse JSON payload
        data = json.loads(msg.payload.decode())

        # Create InfluxDB point
        point = Point("sensor_reading") \
            .tag("sensor", msg.topic.split("/")[-1]) \
            .field("temperature", float(data.get("temp", 0))) \
            .field("humidity", float(data.get("humidity", 0)))

        # Write to InfluxDB
        write_api.write(bucket="sensors", record=point)
        print(f"Stored: {data}")

    except Exception as e:
        print(f"Error: {e}")

# MQTT setup
mqtt_client = mqtt.Client()
mqtt_client.on_message = on_message
mqtt_client.connect("localhost", 1883)
mqtt_client.subscribe("sensors/#")

print("Bridge running... Press Ctrl+C to stop")
mqtt_client.loop_forever()

14.5.2.3 Step 3: Simulate Sensors (15 min)

Create sensor_simulator.py:

import paho.mqtt.client as mqtt
import json
import time
import random

client = mqtt.Client()
client.connect("localhost", 1883)

sensors = ["living_room", "bedroom", "kitchen"]

while True:
    for sensor in sensors:
        data = {
            "temp": round(20 + random.gauss(0, 2), 1),
            "humidity": round(50 + random.gauss(0, 5), 1)
        }
        client.publish(f"sensors/{sensor}", json.dumps(data))
        print(f"{sensor}: {data}")

    time.sleep(5)

14.5.2.4 Step 4: Configure Grafana Dashboard (30 min)

  1. Open Grafana: http://localhost:3000 (admin/admin)

  2. Add InfluxDB data source (Configuration -> Data Sources)

  3. Create new dashboard with time-series panel

  4. Use this Flux query for the first panel:

    from(bucket: "sensors")
  |> range(start: -1h)
  |> filter(fn: (r) => r._measurement == "sensor_reading")
Checkpoint 2

Your Grafana dashboard should show real-time temperature and humidity readings updating every 5 seconds.

14.5.2.5 Lab Validation

Success Criteria

14.5.3 Lab 3: LoRaWAN Network Simulation (Advanced)

Duration: 2-3 hours | Difficulty: Advanced

Learning Objectives:

  • Understand LoRaWAN network architecture
  • Configure spreading factors and their impact
  • Analyze airtime and duty cycle constraints
  • Simulate multi-gateway deployments

Materials Needed:

Full lab content continues…

14.6 Sensing & Actuation Labs

14.6.1 Lab 4: Sensor Calibration Workshop (Beginner)

Build practical sensor calibration skills with temperature and humidity sensors.

Coming soon - uses Sensor Calibration Tool

14.6.2 Lab 5: PID Controller Tuning (Intermediate)

Tune a PID controller for motor speed control using the Ziegler-Nichols method.

Coming soon - uses PID Tuner Simulator

14.7 Security Labs

14.7.1 Lab 6: TLS Certificate Setup (Intermediate)

Configure TLS for secure MQTT communications.

Coming soon - uses Zero Trust Simulator

14.7.2 Lab 7: IoT Penetration Testing Basics (Advanced)

Learn ethical security testing techniques for IoT devices.

Coming soon

14.8 Architecture Labs

14.8.1 Lab 8: Edge vs Cloud Decision Workshop (Intermediate)

Design and evaluate edge computing architectures.

Coming soon - uses Edge Cloud Decision Tool

14.9 Lab Equipment Recommendations

For physical labs (optional but recommended):

Lab Equipment ESP32 DevKit

$8-15 Wi-Fi + BLE

Purpose: Wi-Fi + BLE microcontroller.

Lab Equipment DHT22 Sensor

$5-10 Sensor

Purpose: Temperature + humidity.

Lab Equipment LoRa Module (SX1276)

$10-20 Long-range comms

Purpose: Long-range communication.

Lab Equipment Breadboard + Wires

$5-10 Prototype setup

Purpose: Prototyping.

Lab Equipment USB Power Bank

$15-25 Portable power

Purpose: Portable power.

14.11 See Also

  • Code Snippet Library — Ready-to-use code for lab implementations
  • Tool Discovery Hub — Interactive tools to complement lab work
  • Discussion Prompts Hub — Debate lab design decisions
  • Knowledge Gaps Hub — Identify lab topics needing review
  • Simulations Hub — Practice concepts before hardware labs
  • Quiz Hub — Validate each lab concept with targeted checks
  • IoT Games Hub — Reinforce key concepts with short challenge loops

Common Pitfalls

Advanced labs build on skills from foundational labs — they assume you can already set up an MQTT broker, write basic sensor code, and interpret protocol captures. Jumping to advanced labs without prerequisite completion causes frustrating failures that require debugging foundational issues mid-lab.

Most labs include a “verify your environment” section before the main exercises. Skipping this step to save time results in discovering environmental issues (missing libraries, wrong port, incorrect broker URL) mid-lab, requiring restart. Completing setup verification takes 5 minutes; debugging mid-lab takes 30-60 minutes.

Lab exercises produce measurements, configurations, and observations that are valuable for future reference. Completing labs without notes means repeating setup work when you return to a topic or troubleshoot a production system with similar characteristics. Keep a lab notebook with findings, configurations used, and unexpected behaviors observed.

14.12 What’s Next

In the next chapter, we’ll explore the Tool Discovery Hub, which helps you search and filter 280+ interactive simulations, calculators, and visualizations. You’ll learn about:

  • How to find the right interactive tool for any IoT topic using category and difficulty filters
  • Prerequisite chains and “learn next” recommendations for structured skill building
  • Curated tool learning paths for protocol mastery, power optimization, data pipelines, and security design

Before moving on, complete one full lab cycle: 1. Finish a lab with all checkpoints. 2. Run one matching simulator. 3. Complete one quiz or game challenge.

Previous Simulation Resources Move from simulation planning into practical implementation labs.

Current Hands-On Labs Hub Stay here when you need structured lab execution, checkpoints, and validation guidance.

Next Tool Discovery Hub Continue into the searchable catalog of tools that complement lab work.