pyserial library usage in Raspberry Pi - Step-by-Step Execution

Concept Flow - pyserial library usage

Import serial

↓

Open serial port

↓

Write or Read data

↓

Process data

↓

Close serial port

This flow shows how to use pyserial: import it, open a port, communicate, then close it.

Execution Sample

Raspberry Pi

import serial
ser = serial.Serial('/dev/ttyUSB0', 9600)
ser.write(b'Hello')
data = ser.read(5)
ser.close()

This code opens a serial port, sends 'Hello', reads 5 bytes, then closes the port.

Execution Table

Step	Action	Evaluation	Result
1	Import serial	serial module loaded	serial available
2	Open serial port '/dev/ttyUSB0' at 9600 baud	Port opened successfully	ser is Serial object
3	Write bytes b'Hello'	Data sent to device	5 bytes written
4	Read 5 bytes	Wait for 5 bytes from device	data contains 5 bytes
5	Close serial port	Port closed	ser closed

💡 Serial port closed, communication ended

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	After Step 5
ser	undefined	Serial('/dev/ttyUSB0', 9600)	Same	Same	Closed
data	undefined	undefined	undefined	b'Hello'	b'Hello'

Key Moments - 3 Insights

Why do we use b'Hello' instead of 'Hello' when writing?

pyserial requires bytes, not string. b'Hello' means bytes. See execution_table step 3 where write expects bytes.

What happens if the device sends fewer than 5 bytes when reading?

The read call waits until 5 bytes arrive or timeout. See execution_table step 4 where read(5) waits for 5 bytes.

Why must we close the serial port?

Closing frees the port for other programs and cleans up resources. See execution_table step 5 where ser.close() ends communication.

Visual Quiz - 3 Questions

Look at the execution_table, what type is the variable 'ser' after step 2?

A An integer baud rate

B A Serial object representing the open port

C A string with port name

D Undefined

💡 Hint

Check execution_table row 2, 'Result' column shows 'ser is Serial object'

At which step does the program send data to the device?

A Step 4

B Step 1

C Step 3

D Step 5

💡 Hint

Look at execution_table step 3, action is 'Write bytes b'Hello''

If we forget to call ser.close(), what is the likely effect?

A The port remains open and may block other programs

B The program crashes immediately

C Data is lost during write

D The port automatically closes without issues

💡 Hint

See key_moments about closing port and execution_table step 5

Concept Snapshot

pyserial usage:
1. Import serial
2. Open port: serial.Serial(port, baudrate)
3. Write bytes: ser.write(b'data')
4. Read bytes: ser.read(size)
5. Close port: ser.close()
Always use bytes, not strings.

Full Transcript

This visual trace shows how to use the pyserial library on Raspberry Pi. First, import the serial module. Then open the serial port with the device name and baud rate. Next, write bytes data to the port using ser.write with a bytes object like b'Hello'. Then read bytes from the port with ser.read specifying how many bytes to read. Finally, close the port with ser.close to free resources. Variables like ser hold the Serial object after opening, and data holds bytes read from the device. Remember to use bytes, not strings, when writing. The read call waits for the specified number of bytes or times out. Closing the port is important to avoid blocking other programs. This step-by-step trace helps beginners see how pyserial works in practice.

Practice

1. What is the main purpose of the pyserial library when used with Raspberry Pi?

easy

A. To communicate with devices over serial ports

B. To create graphical user interfaces

C. To manage Wi-Fi connections

D. To control GPIO pins directly

Solution

1. Step 1: Understand pyserial's role

   pyserial is designed to handle serial communication, which means sending and receiving data over serial ports.

2. Step 2: Compare options with pyserial's function

   Options B, C, and D relate to GUI, Wi-Fi, and GPIO control, which are not pyserial's purpose.

3. Final Answer:

   To communicate with devices over serial ports -> Option A

4. Quick Check:

   pyserial = serial communication [OK]

Hint: pyserial = serial port communication library [OK]

Common Mistakes:

• Confusing pyserial with GPIO control libraries
• Thinking pyserial manages network connections
• Assuming pyserial creates user interfaces

2. Which of the following is the correct way to open a serial port using pyserial in Python?

easy

A. serial.Open(port='/dev/ttyUSB0', speed=9600)

B. serial.connect('/dev/ttyUSB0', 9600)

C. serial.Serial(port='/dev/ttyUSB0', baudrate=9600, timeout=1)

D. serial.start(port='/dev/ttyUSB0', baud=9600)

Solution

1. Step 1: Recall pyserial syntax for opening ports

   The correct method is to create a Serial object with parameters: port, baudrate, and optionally timeout.

2. Step 2: Check each option's method and parameters

   Only serial.Serial(port='/dev/ttyUSB0', baudrate=9600, timeout=1) uses serial.Serial() with correct parameter names and values.

3. Final Answer:

   serial.Serial(port='/dev/ttyUSB0', baudrate=9600, timeout=1) -> Option C

4. Quick Check:

   Use serial.Serial() with port and baudrate [OK]

Hint: Use serial.Serial() with port and baudrate [OK]

Common Mistakes:

• Using incorrect method names like Open or connect
• Using wrong parameter names like speed or baud
• Omitting required parameters

3. What will be the output of this code snippet if the serial device sends the bytes b'OK'?

import serial
ser = serial.Serial('/dev/ttyUSB0', 9600, timeout=1)
response = ser.read(2)
print(response)
ser.close()

medium

A. b'OK'

B. 'OK'

C. OK

D. b"\x00\x00"

Solution

1. Step 1: Understand ser.read(2) behavior

   The read(2) method reads 2 bytes from the serial port and returns them as a bytes object.

2. Step 2: Interpret the print output

   Printing a bytes object shows it with a leading b and quotes, so b'OK' will be printed.

3. Final Answer:

   b'OK' -> Option A

4. Quick Check:

   ser.read() returns bytes, printed as b'...' [OK]

Hint: ser.read() returns bytes, print shows b'...' [OK]

Common Mistakes:

• Expecting a string instead of bytes
• Confusing print output with raw string
• Assuming null bytes if device sends data

4. Identify the error in this pyserial code snippet:

import serial
ser = serial.Serial('/dev/ttyUSB0', 9600)
ser.write('Hello')
ser.close()

medium

A. The close method should be called before write

B. The Serial constructor is missing the timeout parameter

C. The port name '/dev/ttyUSB0' is invalid

D. The write method requires bytes, not a string

Solution

1. Step 1: Check the write method argument type

   pyserial's write() expects bytes, but 'Hello' is a string, causing a TypeError.

2. Step 2: Verify other parts of the code

   Timeout is optional, port name can be valid, and close() should be after write().

3. Final Answer:

   The write method requires bytes, not a string -> Option D

4. Quick Check:

   write() needs bytes, encode strings first [OK]

Hint: Always encode strings to bytes before write() [OK]

Common Mistakes:

• Passing string directly to write() without encoding
• Thinking timeout is mandatory
• Closing port before writing data

5. You want to read lines from a serial device that sends text ending with newline characters. Which pyserial method and parameters should you use to read a full line safely with a 2-second timeout?

hard

A. Use serial.Serial('/dev/ttyUSB0', 9600, timeout=None) and ser.readline()

B. Use serial.Serial('/dev/ttyUSB0', 9600, timeout=2) and ser.readline()

C. Use serial.Serial('/dev/ttyUSB0', 9600) and ser.read(100)

D. Use serial.Serial('/dev/ttyUSB0', 9600, timeout=0) and ser.readline()

Solution

1. Step 1: Set timeout for safe reading

   Setting timeout=2 seconds ensures readline() waits up to 2 seconds for a line, avoiding blocking forever.

2. Step 2: Use readline() to read full lines

   readline() reads until newline character, perfect for line-based text from serial devices.

3. Final Answer:

   Use serial.Serial('/dev/ttyUSB0', 9600, timeout=2) and ser.readline() -> Option B

4. Quick Check:

   timeout + readline() = safe line read [OK]

Hint: Use timeout with readline() to avoid blocking [OK]

Common Mistakes:

• Using read() instead of readline() for lines
• Setting timeout=None causes blocking
• Setting timeout=0 causes non-blocking read with no wait