Publishing sensor data in Raspberry Pi - Step-by-Step Execution

Concept Flow - Publishing sensor data

Initialize sensor

↓

Read sensor data

↓

Format data for sending

↓

Connect to network/broker

↓

Publish data

↓

Wait or repeat

The program starts by setting up the sensor, then reads data, formats it, connects to the network, publishes the data, and repeats.

Execution Sample

Raspberry Pi

import time
import random

def read_sensor():
    return random.uniform(20.0, 30.0)

while True:
    data = read_sensor()
    print(f"Publishing temperature: {data:.2f} C")
    time.sleep(2)

This code simulates reading temperature data from a sensor and publishes it by printing every 2 seconds.

Execution Table

Step	Action	Sensor Data	Formatted Data	Output	Wait
1	Initialize sensor	N/A	N/A	N/A	N/A
2	Read sensor data	24.57	24.57 C	Publishing temperature: 24.57 C	Sleep 2s
3	Read sensor data	29.12	29.12 C	Publishing temperature: 29.12 C	Sleep 2s
4	Read sensor data	21.03	21.03 C	Publishing temperature: 21.03 C	Sleep 2s
5	Read sensor data	27.89	27.89 C	Publishing temperature: 27.89 C	Sleep 2s
6	Read sensor data	22.45	22.45 C	Publishing temperature: 22.45 C	Sleep 2s
...	Repeat reading and publishing	...	...	...	...

💡 Loop runs indefinitely, reading and publishing sensor data every 2 seconds.

Variable Tracker

Variable	Start	After 1	After 2	After 3	After 4	After 5	...final
data	N/A	24.57	29.12	21.03	27.89	22.45	...

Key Moments - 3 Insights

Why do we format the sensor data before publishing?

Formatting the data (like adding units) makes it clear and readable in the output, as shown in execution_table rows 2-5 where 'Formatted Data' includes 'C' for Celsius.

Why is there a sleep or wait after publishing?

The sleep pauses the program so it doesn't flood the network with data too fast. Execution_table shows 'Sleep 2s' after each publish to control timing.

What happens if the sensor reading fails or returns unexpected data?

In this simple example, sensor data is simulated and always valid. In real cases, you would add error checks before publishing to avoid sending wrong data.

Visual Quiz - 3 Questions

Look at the execution_table at step 3, what is the sensor data value?

A 24.57

B 29.12

C 21.03

D 27.89

💡 Hint

Check the 'Sensor Data' column in execution_table row with Step 3.

At which step does the program wait for 2 seconds before reading again?

A After every publish step

B Step 1

C Step 5

D Step 2

💡 Hint

Look at the 'Wait' column in execution_table; it shows 'Sleep 2s' after each publish.

If the sensor data was not formatted before publishing, what would change in the output?

A Program would crash

B Output would include extra text

C Output would show raw numbers without units

D Sleep time would increase

💡 Hint

Refer to 'Formatted Data' and 'Output' columns in execution_table to see the effect of formatting.

Concept Snapshot

Publishing sensor data:
1. Initialize sensor
2. Read data
3. Format data (add units)
4. Connect and publish
5. Wait before next read
Repeat continuously

Full Transcript

This example shows how a Raspberry Pi program reads sensor data, formats it with units, publishes it by printing, and waits 2 seconds before repeating. The flow starts with sensor initialization, then reading data, formatting it, publishing, and waiting. Variables like 'data' change each read. Formatting helps make output clear. The sleep controls timing to avoid flooding. The loop runs forever, simulating continuous sensor publishing.

Practice

1.

What is the main purpose of publishing sensor data from a Raspberry Pi?

easy

A. To share sensor readings with other devices or systems

B. To store data only on the Raspberry Pi without sharing

C. To turn off the sensor automatically

D. To update the Raspberry Pi operating system

Solution

1. Step 1: Understand the concept of publishing sensor data

   Publishing sensor data means sending sensor readings to other devices or systems so they can use the information.

2. Step 2: Identify the correct purpose

   Sharing data is the key reason, not storing locally or system updates.

3. Final Answer:

   To share sensor readings with other devices or systems -> Option A

4. Quick Check:

   Publishing = Sharing data [OK]

Hint: Publishing means sending data out to others [OK]

Common Mistakes:

• Thinking publishing only stores data locally
• Confusing publishing with system updates
• Assuming publishing turns off sensors

2.

Which of the following is the correct way to publish a message using the paho-mqtt library in Python?

client = mqtt.Client()
client.connect('broker.hivemq.com', 1883)
# What next?

easy

A. client.push('sensor/data', '25.5')

B. client.send('sensor/data', '25.5')

C. client.publish('sensor/data', '25.5')

D. client.post('sensor/data', '25.5')

Solution

1. Step 1: Recall the paho-mqtt publish method

   The correct method to send data is publish, not send, push, or post.

2. Step 2: Match method with syntax

   Using client.publish(topic, message) is the right syntax.

3. Final Answer:

   client.publish('sensor/data', '25.5') -> Option C

4. Quick Check:

   Use publish() to send MQTT messages [OK]

Hint: Use client.publish() to send MQTT messages [OK]

Common Mistakes:

• Using non-existent methods like send or push
• Forgetting to call publish before disconnect
• Mixing HTTP verbs with MQTT methods

3.

What will be the output of this Python code snippet on a Raspberry Pi publishing sensor data?

import paho.mqtt.client as mqtt
client = mqtt.Client()
client.connect('broker.hivemq.com', 1883)
result = client.publish('sensor/temp', '22.4')
print(result.rc)

medium

A. 1

B. 0

C. None

D. Error

Solution

1. Step 1: Understand the publish return value

   The publish method returns an object with a rc attribute indicating the result code. 0 means success.

2. Step 2: Check the printed value

   Printing result.rc will show 0 if the publish succeeded.

3. Final Answer:

   0 -> Option B

4. Quick Check:

   MQTT publish success code = 0 [OK]

Hint: Check publish().rc for success (0 means success) [OK]

Common Mistakes:

• Expecting publish() to return message content
• Confusing rc with error codes
• Not calling connect() before publish()

4.

Identify the error in this Raspberry Pi Python code that publishes sensor data:

import paho.mqtt.client as mqtt
client = mqtt.Client()
client.publish('sensor/humidity', '55')
client.connect('broker.hivemq.com', 1883)
client.disconnect()

medium

A. Calling publish before connect

B. Missing import statement

C. Using wrong topic name

D. Not disconnecting after publish

Solution

1. Step 1: Check the order of MQTT calls

   The client must connect to the broker before publishing messages.

2. Step 2: Identify the incorrect sequence

   Here, publish is called before connect, which will cause an error.

3. Final Answer:

   Calling publish before connect -> Option A

4. Quick Check:

   Connect before publish [OK]

Hint: Always connect before publishing data [OK]

Common Mistakes:

• Publishing before connecting
• Forgetting to disconnect
• Using invalid topic names

5.

You want to publish temperature and humidity data from a Raspberry Pi to two MQTT topics sensor/temp and sensor/humidity. Which code snippet correctly publishes both values and disconnects properly?

import paho.mqtt.client as mqtt
client = mqtt.Client()
client.connect('broker.hivemq.com', 1883)
# Fill in the blanks
client.publish('sensor/temp', '23.1')
client.publish('sensor/humidity', '60')
client.disconnect()

hard

A. Must publish only one topic per connection

B. Missing client.loop_start() before publishing

C. Should call disconnect() before publishing

D. Correct as shown, publishes both then disconnects

Solution

1. Step 1: Verify connection and publishing order

   Connect first, then publish each topic's data, then disconnect.

2. Step 2: Check if loop_start() is required

   For simple publish, loop_start() is optional; synchronous publish works fine.

3. Step 3: Confirm multiple publishes per connection

   Multiple publishes can be done before disconnecting.

4. Final Answer:

   Correct as shown, publishes both then disconnects -> Option D

5. Quick Check:

   Connect -> publish multiple -> disconnect [OK]

Hint: Publish multiple topics after connect, then disconnect [OK]

Common Mistakes:

• Disconnecting before publishing
• Thinking loop_start() is always needed
• Believing only one publish per connection allowed