REST API for IoT device in Raspberry Pi - Step-by-Step Execution

Concept Flow - REST API for IoT device

Start Raspberry Pi

↓

Initialize REST API Server

↓

Wait for HTTP Request

↓

Receive Request

↓

Parse Request Type

↓

Read Sensor

↓

Send Response

↓

Wait for Next Request

The Raspberry Pi starts a REST API server that waits for HTTP requests. It handles GET requests by reading sensors and POST requests by updating device settings, then sends responses.

Execution Sample

Raspberry Pi

from flask import Flask, request, jsonify
app = Flask(__name__)

@app.route('/sensor', methods=['GET'])
def get_sensor():
    return jsonify({'temperature': 22})

@app.route('/device', methods=['POST'])
def update_device():
    data = request.get_json()
    # Here you would update device settings based on data
    return jsonify({'status': 'updated'})

This code creates a simple REST API on Raspberry Pi that returns a temperature reading when '/sensor' is requested with GET and updates device settings when '/device' is requested with POST.

Execution Table

Step	Action	Request Type	Internal Process	Response Sent
1	Start server	None	Initialize Flask app	None
2	Wait for request	None	Idle, listening	None
3	Receive request	GET /sensor	Call get_sensor function	None
4	Process request	GET /sensor	Read temperature sensor (simulated 22)	None
5	Send response	GET /sensor	Return JSON {'temperature': 22}	{'temperature': 22}
6	Wait for next request	None	Idle, listening	None
7	Receive request	POST /device	Parse JSON payload	None
8	Process request	POST /device	Update device settings	None
9	Send response	POST /device	Return success message	{'status': 'updated'}
10	Wait for next request	None	Idle, listening	None

💡 Server runs continuously, stops only on manual shutdown.

Variable Tracker

Variable	Start	After Step 4	After Step 8	Final
temperature	None	22	22	22
device_settings	Default	Default	Updated	Updated
response	None	{'temperature': 22}	{'temperature': 22}	{'status': 'updated'}

Key Moments - 3 Insights

Why does the server wait after sending a response?

The server waits to listen for new requests, as shown in steps 2, 6, and 10 in the execution_table. It keeps running to handle multiple requests.

How does the server know which function to run for a request?

The server matches the request path and method (like GET /sensor) to the correct function, as in step 3 where GET /sensor calls get_sensor.

What happens if a POST request updates device settings?

In steps 7-9, the server parses the POST data, updates device_settings variable, and sends a confirmation response.

Visual Quiz - 3 Questions

Look at the execution_table, what is the response sent at step 5?

A No response sent

B {'status': 'updated'}

C {'temperature': 22}

D Error message

💡 Hint

Check the 'Response Sent' column at step 5 in the execution_table.

At which step does the device_settings variable change?

A Step 4

B Step 8

C Step 3

D Step 10

💡 Hint

Look at variable_tracker for device_settings changes and match with execution_table steps.

If the server stopped waiting after sending a response, what would happen?

A It would shut down and stop responding to new requests

B It would handle multiple requests normally

C It would send multiple responses for one request

D It would crash immediately

💡 Hint

Refer to key_moments about server waiting after responses and execution_table steps 2, 6, 10.

Concept Snapshot

REST API on Raspberry Pi:
- Start server and listen for HTTP requests
- GET requests read sensor data and return JSON
- POST requests update device settings
- Server waits after each response to handle more requests
- Use Flask or similar Python library for implementation

Full Transcript

This visual execution shows how a Raspberry Pi runs a REST API server for an IoT device. The server starts and waits for HTTP requests. When it receives a GET request at '/sensor', it reads the temperature sensor (simulated as 22) and sends back a JSON response. For POST requests to '/device', it updates device settings and confirms with a JSON message. The server waits after each response to handle more requests, running continuously until manually stopped. Variables like temperature and device_settings change as requests are processed. This step-by-step trace helps beginners see how REST APIs work on IoT devices.

Practice

1. What is the main purpose of a REST API on a Raspberry Pi IoT device?

easy

A. To connect the Raspberry Pi to a monitor

B. To allow remote communication and control over the network

C. To store large amounts of data locally

D. To increase the Raspberry Pi's processing speed

Solution

1. Step 1: Understand REST API role

   A REST API enables devices to communicate over a network using standard web protocols.

2. Step 2: Identify IoT device needs

   IoT devices use REST APIs to send sensor data or receive commands remotely.

3. Final Answer:

   To allow remote communication and control over the network -> Option B

4. Quick Check:

   REST API = Remote communication [OK]

Hint: REST APIs enable network communication for IoT devices [OK]

Common Mistakes:

• Confusing REST API with hardware speed
• Thinking REST API stores data locally
• Assuming REST API connects to display devices

2. Which Python library is commonly used on Raspberry Pi to create a REST API for IoT devices?

easy

A. Flask

B. NumPy

C. Pandas

D. Matplotlib

Solution

1. Step 1: Identify common Python libraries

   NumPy, Pandas, and Matplotlib are for data processing and visualization, not REST APIs.

2. Step 2: Recognize Flask's role

   Flask is a lightweight web framework used to build REST APIs easily on Raspberry Pi.

3. Final Answer:

   Flask -> Option A

4. Quick Check:

   Flask = REST API framework [OK]

Hint: Flask is the go-to Python web framework for REST APIs [OK]

Common Mistakes:

• Choosing data libraries instead of web frameworks
• Confusing Flask with data analysis tools
• Assuming Matplotlib creates APIs

3. What will be the output of this Flask route code on a Raspberry Pi?

from flask import Flask, jsonify
app = Flask(__name__)

@app.route('/sensor')
def sensor():
    data = {'temperature': 22, 'humidity': 60}
    return jsonify(data)

# Assume app is running and /sensor is requested

medium

A. {"temperature": 22, "humidity": 60}

B. temperature=22, humidity=60

C. temperature: 22, humidity: 60

D. Error: jsonify not defined

Solution

1. Step 1: Understand jsonify function

   jsonify converts Python dict to JSON string with correct headers for API response.

2. Step 2: Analyze route output

   The route returns JSON with keys 'temperature' and 'humidity' and their values.

3. Final Answer:

   {"temperature": 22, "humidity": 60} -> Option A

4. Quick Check:

   jsonify(dict) = JSON string [OK]

Hint: jsonify returns JSON string from dict in Flask [OK]

Common Mistakes:

• Expecting plain text instead of JSON
• Confusing jsonify with HTML output
• Missing import of jsonify causing errors

4. Identify the error in this Flask route code for Raspberry Pi IoT device:

from flask import Flask
app = Flask(__name__)

@app.route('/led/on')
def led_on():
    GPIO.output(17, True)
    return 'LED is ON'

medium

A. Return statement must be JSON, not string

B. Route decorator syntax is incorrect

C. Missing import and setup for GPIO module

D. Flask app is not created properly

Solution

1. Step 1: Check GPIO usage

   GPIO module must be imported and configured before use to control pins.

2. Step 2: Verify code completeness

   Code lacks 'import RPi.GPIO as GPIO' and GPIO setup like GPIO.setmode() and GPIO.setup().

3. Final Answer:

   Missing import and setup for GPIO module -> Option C

4. Quick Check:

   GPIO needs import and setup before use [OK]

Hint: Always import and setup GPIO before controlling pins [OK]

Common Mistakes:

• Assuming Flask route syntax is wrong
• Thinking return must be JSON always
• Ignoring GPIO initialization steps

5. You want to create a REST API on Raspberry Pi that returns sensor data only if temperature is above 25°C. Which code snippet correctly implements this logic using Flask?

hard

A. from flask import Flask, jsonify
app = Flask(__name__)

@app.route('/sensor')
def sensor():
temp = 30
if temp >= 25:
return {'temperature': temp}
else:
return {'message': 'Temperature too low'}

B. from flask import Flask, jsonify
app = Flask(__name__)

@app.route('/sensor')
def sensor():
temp = 20
if temp < 25:
return jsonify({'temperature': temp})
else:
return jsonify({'message': 'Temperature too low'})

C. from flask import Flask
app = Flask(__name__)

@app.route('/sensor')
def sensor():
temp = 30
if temp > 25:
return {'temperature': temp}
else:
return {'message': 'Temperature too low'}

D. from flask import Flask, jsonify
app = Flask(__name__)

@app.route('/sensor')
def sensor():
temp = 30
if temp > 25:
return jsonify({'temperature': temp})
else:
return jsonify({'message': 'Temperature too low'})

Solution

1. Step 1: Check temperature condition logic

   We want to return data only if temperature is above 25, so 'temp > 25' is correct.

2. Step 2: Verify response format

   Flask needs jsonify to return proper JSON response with correct headers.

3. Final Answer:

   Code with temp=30, condition temp > 25, and jsonify responses -> Option D

4. Quick Check:

   Use temp > 25 and jsonify for JSON response [OK]

Hint: Use if temp > 25 and jsonify() to return JSON [OK]

Common Mistakes:

• Using wrong temperature comparison operator
• Returning dict without jsonify causing errors
• Setting temperature below threshold incorrectly