paho-mqtt library usage in Raspberry Pi - Step-by-Step Execution

Concept Flow - paho-mqtt library usage

Start Program

↓

Create MQTT Client

↓

Connect to Broker

↓

Subscribe to Topic

↓

Publish Message

↓

Wait for Messages

↓

Receive Message Callback

↓

Process Message

↓

Disconnect

↓

End Program

This flow shows how a program using paho-mqtt connects to a broker, subscribes, publishes, receives messages, and disconnects.

Execution Sample

Raspberry Pi

import paho.mqtt.client as mqtt

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

client = mqtt.Client()
client.on_message = on_message
client.connect("test.mosquitto.org", 1883)
client.subscribe("test/topic")
client.loop_start()
client.publish("test/topic", "Hello MQTT")
import time
time.sleep(2)
client.loop_stop()
client.disconnect()

This code connects to a public MQTT broker, subscribes to a topic, publishes a message, waits to receive it, then disconnects.

Execution Table

Step	Action	Evaluation	Result
1	Import paho.mqtt.client as mqtt	Module imported	mqtt module ready
2	Define on_message callback	Function created	on_message ready
3	Create client instance	mqtt.Client() called	client object created
4	Assign on_message callback	client.on_message set	Callback linked
5	Connect to broker	client.connect("test.mosquitto.org", 1883)	Connected to broker
6	Subscribe to topic	client.subscribe("test/topic")	Subscribed to 'test/topic'
7	Start network loop	client.loop_start()	Background loop running
8	Publish message	client.publish("test/topic", "Hello MQTT")	Message sent
9	Wait 2 seconds	time.sleep(2)	Wait allows message processing
10	Message received	on_message called with topic and payload	Prints: Received: test/topic Hello MQTT
11	Stop network loop	client.loop_stop()	Background loop stopped
12	Disconnect client	client.disconnect()	Disconnected from broker

💡 Program ends after disconnecting from the MQTT broker

Variable Tracker

Variable	Start	After Step 3	After Step 5	After Step 6	After Step 8	After Step 10	Final
client	None	mqtt.Client() instance	Connected client	Subscribed client	Published client	Received message callback active	Disconnected client
msg.topic	N/A	N/A	N/A	N/A	N/A	"test/topic"	N/A
msg.payload	N/A	N/A	N/A	N/A	N/A	b"Hello MQTT"	N/A

Key Moments - 3 Insights

Why do we need to call client.loop_start() before publishing?

client.loop_start() starts the background network loop that handles sending and receiving messages. Without it, the client cannot process incoming or outgoing MQTT packets, so publishing or receiving won't work properly (see Step 7 and Step 8 in execution_table).

How does the program receive messages after subscribing?

When a message arrives on a subscribed topic, the on_message callback is triggered automatically by the network loop (Step 10). This callback processes the message and prints it.

Why do we sleep for 2 seconds after publishing?

The sleep allows time for the message to be sent and received before stopping the loop and disconnecting. Without this pause, the program might end before the message is processed (Step 9).

Visual Quiz - 3 Questions

Look at the execution_table, what happens at Step 6?

A The client connects to the broker

B The client publishes a message

C The client subscribes to a topic

D The client disconnects

💡 Hint

Check the 'Action' and 'Result' columns at Step 6 in the execution_table

According to variable_tracker, what is the value of msg.payload after Step 10?

A None

B b"Hello MQTT"

C "Hello MQTT"

D Empty bytes

💡 Hint

Look at the 'msg.payload' row under 'After Step 10' in variable_tracker

If we remove client.loop_start(), what will most likely happen?

A Publishing and receiving messages will fail

B The client will not connect to the broker

C Messages will still be received and printed

D The program will run faster

💡 Hint

Refer to key_moments about why loop_start() is needed for message processing

Concept Snapshot

paho-mqtt usage quick steps:
1. Import paho.mqtt.client
2. Create client and assign callbacks
3. Connect to broker
4. Subscribe to topics
5. Start network loop (loop_start)
6. Publish messages
7. Process incoming messages in callback
8. Stop loop and disconnect

Full Transcript

This example shows how to use the paho-mqtt library on a Raspberry Pi to connect to an MQTT broker, subscribe to a topic, publish a message, and receive messages. The program creates a client, assigns a callback to handle incoming messages, connects to a public broker, subscribes to a topic, and starts a background network loop to handle communication. It then publishes a message to the topic and waits briefly to receive it back. The callback prints the received message. Finally, the program stops the network loop and disconnects cleanly. Key points include starting the loop to process network events and using callbacks to handle messages asynchronously.