Multi-device MQTT network in Raspberry Pi - Step-by-Step Execution

Concept Flow - Multi-device MQTT network

Start Devices

↓

Connect to MQTT Broker

↓

Subscribe to Topics

↓

Publish Messages

↓

Receive Messages

↓

Process Messages

↓

Repeat Publish/Receive

↓

Disconnect Devices

↓

End

Each device connects to the MQTT broker, subscribes to topics, publishes messages, receives messages, processes them, and repeats until disconnect.

Execution Sample

Raspberry Pi

import paho.mqtt.client as mqtt

def on_message(client, userdata, msg):
    print(f"Received {msg.payload.decode()} on {msg.topic}")

client = mqtt.Client("device1")
client.on_message = on_message
client.connect("broker.hivemq.com")
client.subscribe("home/temperature")
client.loop_start()
client.publish("home/temperature", "22.5")

This code connects a device to an MQTT broker, subscribes to a topic, listens for messages, and publishes a temperature reading.

Execution Table

Step	Action	Evaluation	Result
1	Create MQTT client with ID 'device1'	Client created	Client object ready
2	Assign on_message callback	Callback set	Ready to receive messages
3	Connect to broker 'broker.hivemq.com'	Connection attempt	Connected successfully
4	Subscribe to topic 'home/temperature'	Subscription request	Subscribed successfully
5	Start network loop	Loop running	Listening for messages
6	Publish message '22.5' to 'home/temperature'	Publish request	Message sent
7	Receive message on 'home/temperature'	Message received	on_message called, prints message
8	Process message in on_message	Print output	Output: Received 22.5 on home/temperature
9	Loop continues	Waiting for more messages	Ready for next messages
10	Disconnect client	Disconnect request	Disconnected cleanly

💡 Client disconnects or program ends, stopping message loop

Variable Tracker

Variable	Start	After Step 3	After Step 4	After Step 6	After Step 8	Final
client	None	Connected client object	Subscribed client	Published message	Received message processed	Disconnected client

Key Moments - 3 Insights

Why do we need to start the network loop with loop_start()?

The network loop listens for incoming messages and handles communication. Without loop_start(), the client won't receive messages or keep the connection alive, as shown in step 5 of the execution_table.

What happens if we publish a message before subscribing to the topic?

Publishing before subscribing is allowed, but the client won't receive messages on that topic until it subscribes. The execution_table shows subscription happens before publishing to ensure messages are received.

Why does the on_message callback print the received message?

The on_message function is called automatically when a message arrives on a subscribed topic. It prints the message to show the device received and processed it, as seen in steps 7 and 8.

Visual Quiz - 3 Questions

Look at the execution_table, at which step does the client start listening for incoming messages?

A Step 3

B Step 6

C Step 5

D Step 8

💡 Hint

Refer to step 5 where loop_start() is called to start the network loop.

According to variable_tracker, what is the state of 'client' after step 6?

A Disconnected client

B Published message

C Subscribed client

D None

💡 Hint

Check the 'After Step 6' column for 'client' in variable_tracker.

If the client never subscribes to a topic, what will happen when a message is published to that topic?

A The client will ignore the message

B The client will receive and print the message

C The client will disconnect automatically

D The client will crash

💡 Hint

Refer to key_moments about subscription order and message reception.

Concept Snapshot

Multi-device MQTT network:
- Devices connect to a broker
- Subscribe to topics to receive messages
- Publish messages to topics
- Use a network loop to listen continuously
- on_message callback processes incoming messages
- Disconnect cleanly when done

Full Transcript

In a multi-device MQTT network, each device connects to a central broker. Devices subscribe to topics to receive messages and publish messages to share data. The network loop runs continuously to listen for messages. When a message arrives, the on_message function processes it. Devices repeat publishing and receiving until they disconnect. This example shows a device connecting, subscribing to 'home/temperature', publishing a temperature value, receiving it back, and printing it. The network loop is essential to keep communication active.