Serial protocol design in Raspberry Pi - Step-by-Step Execution

Concept Flow - Serial protocol design

Start Transmission

↓

Send Start Bit

↓

Send Data Bits

↓

Send Parity Bit (optional)

↓

Send Stop Bit(s)

↓

Wait for Acknowledgment

↓

End Transmission

This flow shows how data is sent step-by-step in a serial protocol, starting with a start bit, followed by data bits, optional parity, stop bits, and then waiting for acknowledgment.

Execution Sample

Raspberry Pi

start_bit = 0
 data_bits = [1,0,1,1,0,0,1,0]
 parity_bit = 1
 stop_bit = 1

# Transmit sequence: start_bit + data_bits + parity_bit + stop_bit

This code prepares bits for a serial transmission sequence including start, data, parity, and stop bits.

Execution Table

Step	Action	Bit Sent	Description
1	Send Start Bit	0	Start bit signals beginning of data
2	Send Data Bit 1	1	First data bit sent
3	Send Data Bit 2	0	Second data bit sent
4	Send Data Bit 3	1	Third data bit sent
5	Send Data Bit 4	1	Fourth data bit sent
6	Send Data Bit 5	0	Fifth data bit sent
7	Send Data Bit 6	0	Sixth data bit sent
8	Send Data Bit 7	1	Seventh data bit sent
9	Send Data Bit 8	0	Eighth data bit sent
10	Send Parity Bit	1	Parity bit for error checking
11	Send Stop Bit	1	Stop bit signals end of data
12	Wait for Ack	-	Wait for acknowledgment from receiver
13	End Transmission	-	Transmission complete

💡 Transmission ends after stop bit sent and acknowledgment received

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	After Step 5	After Step 6	After Step 7	After Step 8	After Step 9	After Step 10	After Step 11	Final
bit_index	0	1	2	3	4	5	6	7	8	9	10	11	Transmission Complete
current_bit	-	0	1	0	1	1	0	0	1	0	1	1	-

Key Moments - 3 Insights

Why do we send a start bit before data bits?

The start bit signals the receiver that data is coming, so it knows when to start reading bits. See execution_table row 1.

What is the purpose of the parity bit?

The parity bit helps detect errors in data transmission by making the total number of 1s even or odd. See execution_table row 10.

Why do we wait for an acknowledgment after sending stop bit?

Waiting for acknowledgment ensures the receiver got the data correctly before ending transmission. See execution_table row 12.

Visual Quiz - 3 Questions

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

A 0

B Start bit

C 1

D Parity bit

💡 Hint

Check execution_table row 5 under 'Bit Sent' column

At which step does the parity bit get sent?

A Step 9

B Step 10

C Step 11

D Step 12

💡 Hint

Look for 'Send Parity Bit' in execution_table under 'Action'

If we remove the stop bit, what happens to the transmission end step?

A Transmission never ends properly

B It happens at step 11 as usual

C It happens earlier at step 10

D Acknowledgment is skipped

💡 Hint

Refer to exit_note and execution_table rows 11-13

Concept Snapshot

Serial protocol sends data bit by bit.
Start bit signals start.
Data bits follow.
Optional parity bit checks errors.
Stop bit signals end.
Receiver sends acknowledgment.

Full Transcript

In serial protocol design, data is sent one bit at a time. The transmission starts with a start bit to tell the receiver data is coming. Then the data bits are sent in order. An optional parity bit can be added to help detect errors. After that, a stop bit signals the end of the data. Finally, the sender waits for an acknowledgment from the receiver to confirm the data was received correctly. This step-by-step process ensures reliable communication between devices like a Raspberry Pi and peripherals.

Practice

1. What is the main purpose of using start and end bytes in a serial protocol?

easy

A. To increase the speed of data transfer

B. To mark the beginning and end of a message

C. To encrypt the message data

D. To compress the message content

Solution

1. Step 1: Understand message framing

   Start and end bytes are special markers that show where a message begins and ends in a data stream.

2. Step 2: Identify their role in communication

   They help the receiver know exactly which bytes belong to one message, avoiding confusion with other data.

3. Final Answer:

   To mark the beginning and end of a message -> Option B

4. Quick Check:

   Start/end bytes = message boundaries [OK]

Hint: Start/end bytes frame messages clearly [OK]

Common Mistakes:

• Thinking start/end bytes encrypt data
• Confusing start/end bytes with speed control
• Assuming they compress data

2. Which of the following is the correct way to represent a start byte in a serial protocol in Python code?

easy

A. start_byte = 02

B. start_byte = '0x02'

C. start_byte = b'\x02'

D. start_byte = "\x02"

Solution

1. Step 1: Understand byte representation in Python

   Bytes are represented with a b prefix and escape sequences like \x02 inside single or double quotes.

2. Step 2: Check each option

   start_byte = b'\x02' uses b'\x02' which is a bytes object with hex value 0x02. start_byte = '0x02' is a string, not bytes. start_byte = 02 is an integer. start_byte = "\x02" is a string, not bytes.

3. Final Answer:

   start_byte = b'\x02' -> Option C

4. Quick Check:

   Bytes need b prefix and hex escape [OK]

Hint: Bytes start with b and use \x for hex [OK]

Common Mistakes:

• Using strings instead of bytes
• Missing the b prefix
• Using decimal numbers instead of bytes

3. Given this Python snippet for a simple serial message:

message = b'\x02HELLO\x03'
start_byte = b'\x02'
end_byte = b'\x03'
if message.startswith(start_byte) and message.endswith(end_byte):
    content = message[1:-1]
else:
    content = b''
print(content)

What will be printed?

medium

A. b'HELLO'

B. b'\x02HELLO\x03'

C. b''

D. HELLO

Solution

1. Step 1: Check message start and end bytes

   The message starts with b'\x02' and ends with b'\x03', so the condition is True.

2. Step 2: Extract content between start and end bytes

   content = message[1:-1] removes the first and last byte, leaving b'HELLO'.

3. Final Answer:

   b'HELLO' -> Option A

4. Quick Check:

   Strip start/end bytes = b'HELLO' [OK]

Hint: Slice message to remove start/end bytes [OK]

Common Mistakes:

• Printing the whole message without slicing
• Forgetting bytes notation in output
• Confusing string and bytes output

4. This code is intended to check if a serial message has a valid checksum byte at the end:

def check_checksum(msg):
    data = msg[:-1]
    checksum = msg[-1]
    calculated = sum(data) & 0xFF
    return checksum == calculated

message = b'\x02ABC\x06'
print(check_checksum(message))

What is the error in this code?

medium

A. It includes the start byte in checksum calculation

B. It does not convert checksum to integer

C. It uses bitwise AND instead of modulo

D. It compares checksum with data instead of sum

Solution

1. Step 1: Analyze checksum calculation

   The code sums all bytes except the last one, but this includes the start byte (b'\x02'), which usually should be excluded.

2. Step 2: Identify correct checksum range

   Typically, checksum is calculated only on the data bytes, excluding start and end bytes. Here, start byte is wrongly included.

3. Final Answer:

   It includes the start byte in checksum calculation -> Option A

4. Quick Check:

   Exclude start byte from checksum [OK]

Hint: Exclude framing bytes from checksum sum [OK]

Common Mistakes:

• Including start/end bytes in checksum
• Confusing bitwise AND with modulo
• Not converting bytes to int before sum

5. You want to design a serial protocol message with this format: start byte (0x7E), payload (ASCII text), checksum (sum of payload bytes mod 256), and end byte (0x7F). Which Python code correctly builds this message for payload = b'HELLO'?

hard

A. payload = b'HELLO'
start = b'\x7E'
end = b'\x7F'
checksum = sum(payload) & 0xFF
message = start + payload + checksum + end

B. payload = b'HELLO'
start = b'\x7E'
end = b'\x7F'
checksum = sum(payload) % 256
message = start + payload + checksum + end

C. payload = b'HELLO'
start = b'\x7E'
end = b'\x7F'
checksum = bytes([sum(payload)])
message = start + payload + checksum + end

D. payload = b'HELLO'
start = b'\x7E'
end = b'\x7F'
checksum = bytes([sum(payload) % 256])
message = start + payload + checksum + end

Solution

1. Step 1: Calculate checksum correctly

   Checksum is sum of payload bytes modulo 256, so sum(payload) % 256 is correct.

2. Step 2: Convert checksum to bytes and build message

   Checksum must be a single byte, so bytes([value]) converts it properly. Then concatenate start, payload, checksum, and end bytes.

3. Final Answer:

   payload = b'HELLO' start = b'\x7E' end = b'\x7F' checksum = bytes([sum(payload) % 256]) message = start + payload + checksum + end -> Option D

4. Quick Check:

   Checksum as bytes and modulo 256 [OK]

Hint: Use bytes([sum(payload) % 256]) for checksum [OK]

Common Mistakes:

• Not converting checksum to bytes
• Using bitwise AND instead of modulo
• Concatenating int with bytes directly