Protocol Buffers (protobuf) in IOT Protocols - Step-by-Step Execution

Process Flow - Protocol Buffers (protobuf)

Define .proto schema

↓

Compile schema with protoc

↓

Generate code for target language

↓

Use generated code to serialize data

↓

Send serialized data over network

↓

Receive data

↓

Use generated code to deserialize data

↓

Use data in application

Protocol Buffers flow starts with defining a schema, compiling it to generate code, then using that code to serialize and deserialize data for efficient communication.

Execution Sample

IOT Protocols

syntax = "proto3";
message SensorData {
  int32 id = 1;
  float temperature = 2;
  string status = 3;
}

This .proto file defines a message named SensorData with three fields: id, temperature, and status.

Process Table

Step	Action	Input/Code	Output/Result
1	Define schema	message SensorData { int32 id=1; float temperature=2; string status=3; }	Schema file created (sensor.proto)
2	Compile schema	protoc --python_out=. sensor.proto	Python code generated (sensor_pb2.py)
3	Create message instance	data = SensorData(id=101, temperature=23.5, status='OK')	Message object with fields set
4	Serialize message	data.SerializeToString()	Binary serialized data (bytes)
5	Send data	Send bytes over network	Data transmitted
6	Receive data	Receive bytes	Binary data received
7	Deserialize message	SensorData.FromString(bytes)	Message object reconstructed
8	Use data	print(data.status)	Output: OK

💡 Process ends after data is deserialized and used in the application.

Status Tracker

Variable	Start	After Step 3	After Step 4	After Step 7	Final
data	undefined	{id:101, temperature:23.5, status:'OK'}	b'\x08e\x15\x00\x00\xbcA\x1a\x02OK'	{id:101, temperature:23.5, status:'OK'}	{id:101, temperature:23.5, status:'OK'}

Key Moments - 3 Insights

Why do we need to compile the .proto file before using it?

Compiling the .proto file generates code in your target language that knows how to create, serialize, and deserialize the messages. Without this generated code (see Step 2 in execution_table), you cannot work with the data format.

What does serialization actually do to the data?

Serialization converts the message object into a compact binary format (Step 4) that is smaller and faster to send over networks compared to plain text.

How do we get back the original data after sending it?

After receiving the binary data (Step 6), deserialization (Step 7) uses the generated code to reconstruct the original message object with all fields intact.

Visual Quiz - 3 Questions

Look at the execution_table, what is the output after Step 4 (Serialize message)?

A Binary serialized data (bytes)

B Schema file created

C A Python object with fields set

D Data transmitted over network

💡 Hint

Check the 'Output/Result' column for Step 4 in the execution_table.

At which step is the .proto schema compiled to generate code?

A Step 3

B Step 2

C Step 1

D Step 5

💡 Hint

Look for the step mentioning 'Compile schema' in the execution_table.

If the message field 'status' was changed to 'error' before serialization, what would change in variable 'data' after Step 3?

A The serialized bytes would be the same

B The schema file would change

C The 'status' field in 'data' would be 'error'

D The deserialization step would fail

💡 Hint

Refer to variable_tracker for 'data' after Step 3 showing field values.

Concept Snapshot

Protocol Buffers (protobuf) quick guide:
- Define message schema in .proto file
- Compile schema with protoc to generate code
- Use generated code to create message objects
- Serialize objects to compact binary format
- Send/receive binary data over network
- Deserialize binary back to objects for use

Full Transcript

Protocol Buffers (protobuf) is a way to define data structures in a .proto file. You first write the schema describing your data fields. Then you compile this schema using the protoc tool, which generates code in your programming language. This code lets you create message objects, set their fields, and convert them into a small binary format called serialization. This binary data is easy and fast to send over networks. When the data is received, you use the generated code again to convert the binary back into the original message object, called deserialization. This process ensures efficient and reliable data exchange between devices or services.