Communicating with Arduino over UART in Raspberry Pi - Step-by-Step Execution

Concept Flow - Communicating with Arduino over UART

Start Raspberry Pi UART Setup

↓

Open UART Port

↓

Send Data to Arduino

↓

Arduino Receives Data

↓

Arduino Sends Response

↓

Raspberry Pi Reads Response

↓

Close UART Port

↓

End

This flow shows how Raspberry Pi opens a UART port, sends data to Arduino, waits for a response, reads it, and then closes the port.

Execution Sample

Raspberry Pi

import serial

ser = serial.Serial('/dev/serial0', 9600)
ser.write(b'Hello Arduino')
response = ser.readline()
print(response.decode())
ser.close()

This code opens UART, sends 'Hello Arduino', reads a line from Arduino, prints it, then closes UART.

Execution Table

Step	Action	UART Port State	Data Sent	Data Received	Output
1	Open UART port '/dev/serial0' at 9600 baud	Open
2	Send bytes b'Hello Arduino'	Open	b'Hello Arduino'
3	Wait and read a line from Arduino	Open	b'Hello Arduino'	b'Hi Pi\n'
4	Decode received bytes to string	Open	b'Hello Arduino'	b'Hi Pi\n'	Hi Pi
5	Print decoded response	Open	b'Hello Arduino'	b'Hi Pi\n'	Hi Pi
6	Close UART port	Closed	b'Hello Arduino'	b'Hi Pi\n'	Hi Pi

💡 UART port closed after communication completes

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	Final
ser	None	Serial('/dev/serial0', 9600)	Serial('/dev/serial0', 9600)	Serial('/dev/serial0', 9600)	Closed
Data Sent		b'Hello Arduino'	b'Hello Arduino'	b'Hello Arduino'	b'Hello Arduino'
Data Received			b'Hi Pi\n'	b'Hi Pi\n'	b'Hi Pi\n'
response			b'Hi Pi\n'	Hi Pi\n	Hi Pi\n

Key Moments - 3 Insights

Why do we use b'Hello Arduino' instead of 'Hello Arduino' when sending data?

UART communication sends bytes, not strings. Using b'' converts the string to bytes, which matches the UART data format, as shown in step 2 of the execution_table.

Why do we decode the received data before printing?

The data received from UART is in bytes (step 3). Decoding converts bytes to a readable string (step 4), so print shows human-readable text.

What happens if we forget to close the UART port?

The port remains open, which can block other programs from using it. Step 6 shows closing the port to free it for future use.

Visual Quiz - 3 Questions

Look at the execution_table at step 3. What data does Raspberry Pi receive from Arduino?

A b'Hi Pi\n'

B b'Hello Arduino'

C b'' (empty)

D b'Error'

💡 Hint

Check the 'Data Received' column at step 3 in the execution_table.

At which step is the UART port closed?

A Step 4

B Step 6

C Step 2

D Step 5

💡 Hint

Look at the 'UART Port State' column to find when it changes to 'Closed'.

If we send 'Hello Arduino' without b'' (bytes), what will happen?

A Data sends correctly

B Data is sent as string automatically

C Program raises an error

D UART port closes immediately

💡 Hint

Refer to key_moments about why bytes are needed for UART sending.

Concept Snapshot

Communicating with Arduino over UART on Raspberry Pi:
- Open UART port with serial.Serial('/dev/serial0', baudrate)
- Send bytes using ser.write(b'data')
- Read response with ser.readline()
- Decode bytes to string before printing
- Close port with ser.close() to free resource

Full Transcript

This visual execution shows how Raspberry Pi communicates with Arduino using UART. First, the UART port '/dev/serial0' is opened at 9600 baud. Then, Raspberry Pi sends the byte string b'Hello Arduino' to Arduino. Arduino responds with b'Hi Pi\n', which Raspberry Pi reads using readline(). The received bytes are decoded to a string 'Hi Pi\n' for printing. Finally, the UART port is closed to finish communication. Key points include sending bytes, decoding received bytes, and closing the port to avoid resource conflicts.

Practice

1. What is the main purpose of UART communication between Raspberry Pi and Arduino?

easy

A. To power the Arduino from the Raspberry Pi

B. To send and receive data serially between devices

C. To connect to the internet

D. To display graphics on a screen

Solution

1. Step 1: Understand UART communication

   UART is a serial communication protocol used to send and receive data between devices like Raspberry Pi and Arduino.

2. Step 2: Identify the purpose in context

   The main goal is to exchange data serially, not to power devices or connect to the internet.

3. Final Answer:

   To send and receive data serially between devices -> Option B

4. Quick Check:

   UART = Serial data exchange [OK]

Hint: UART is for serial data transfer, not power or internet [OK]

Common Mistakes:

• Confusing UART with power supply
• Thinking UART connects to the internet
• Assuming UART is for display output

2. Which Python code snippet correctly opens a UART serial connection at 9600 baud on Raspberry Pi?

easy

A. serial.connect('/dev/ttyS0', 9600)

B. serial.open('/dev/ttyS0', 9600)

C. serial.Serial('/dev/ttyS0', 9600)

D. serial.start('/dev/ttyS0', 9600)

Solution

1. Step 1: Recall Python serial library usage

   The correct method to open a serial port is using serial.Serial() with device and baud rate as arguments.

2. Step 2: Check each option's method name

   Only serial.Serial() is valid; others like open(), connect(), start() do not exist in pyserial.

3. Final Answer:

   serial.Serial('/dev/ttyS0', 9600) -> Option C

4. Quick Check:

   Use serial.Serial() to open UART [OK]

Hint: Use serial.Serial() to open UART port [OK]

Common Mistakes:

• Using non-existent methods like open() or connect()
• Forgetting to specify baud rate
• Using wrong device path

3. What will be the output of this Python code on Raspberry Pi communicating with Arduino over UART?

import serial
ser = serial.Serial('/dev/ttyS0', 9600, timeout=1)
ser.write(b'Hello Arduino')
response = ser.readline().decode().strip()
print(response)

medium

A. Prints the response string sent by Arduino

B. Prints 'Hello Arduino'

C. Prints an empty line

D. Raises a syntax error

Solution

1. Step 1: Analyze the code behavior

   The code sends 'Hello Arduino' bytes to Arduino and waits to read a line response with timeout.

2. Step 2: Understand the output

   It prints the decoded and stripped response from Arduino, not the sent message or empty line unless no response.

3. Final Answer:

   Prints the response string sent by Arduino -> Option A

4. Quick Check:

   ser.readline() reads Arduino reply [OK]

Hint: ser.readline() reads Arduino reply, not sent data [OK]

Common Mistakes:

• Confusing sent data with received data
• Expecting print to show sent bytes
• Ignoring decode and strip steps

4. Identify the error in this Python code snippet for UART communication on Raspberry Pi:

import serial
ser = serial.Serial('/dev/ttyS0', 115200)
ser.write('Hello')
response = ser.readline()
print(response)

medium

A. Using readline() instead of read()

B. Incorrect baud rate 115200

C. Missing import of time module

D. Using string instead of bytes in ser.write()

Solution

1. Step 1: Check ser.write() argument type

   ser.write() requires bytes, but 'Hello' is a string, causing a TypeError.

2. Step 2: Verify other parts

   Baud rate 115200 is valid, time module is not needed here, and readline() is appropriate for line reading.

3. Final Answer:

   Using string instead of bytes in ser.write() -> Option D

4. Quick Check:

   ser.write() needs bytes, not string [OK]

Hint: Always send bytes with ser.write(b'...') [OK]

Common Mistakes:

• Passing string instead of bytes to ser.write()
• Assuming baud rate is wrong without checking
• Confusing readline() with read()

5. You want to send sensor data from Arduino to Raspberry Pi over UART and store it in a Python dictionary with keys as sensor names and values as readings. Which approach is best?

hard

A. Send data as JSON string; use json.loads() in Python

B. Send raw bytes without format; decode directly to dict

C. Send data as separate lines without keys; assign manually in Python

D. Send data as 'temp:25,hum:40' string; parse in Python with split and dict comprehension

Solution

1. Step 1: Consider data format for easy parsing

   JSON format is standard, easy to parse with json.loads() into Python dict directly.

2. Step 2: Evaluate other options

   Custom string formats require manual parsing and are error-prone; raw bytes lack structure; separate lines without keys make mapping difficult.

3. Final Answer:

   Send data as JSON string; use json.loads() in Python -> Option A

4. Quick Check:

   JSON format simplifies UART data parsing [OK]

Hint: Use JSON strings for structured UART data exchange [OK]

Common Mistakes:

• Sending unstructured raw bytes
• Parsing custom formats manually
• Omitting keys in data lines