By completing this lab, you will be able to:
A network packet is a small chunk of data that travels across a network, like a postcard traveling through the postal system. Each packet carries an address (header), the message itself (payload), and a verification stamp (checksum) to make sure nothing was damaged in transit. In this lab, you will simulate sending packets between devices, watching LEDs indicate what is happening at each step. It is a hands-on way to understand what normally happens invisibly inside your Wi-Fi network.
| Component | Quantity | Purpose |
|---|---|---|
| ESP32 DevKit | 1 | Microcontroller for packet simulation |
| Red LED | 1 | Error indicator (checksum failure) |
| Green LED | 1 | Success indicator (valid packet) |
| Yellow LED | 1 | Transmission in progress |
| Blue LED | 1 | Packet received indicator |
| 220 ohm Resistors | 4 | Current limiting for LEDs |
| Breadboard | 1 | Circuit assembly |
| Jumper Wires | Several | Connections |
Use the embedded simulator below to build and test your packet simulator circuit. Click “Start Simulation” to begin.
Before diving into the code, consider how packet structure affects transmission efficiency. For a packet with a 4-byte header, a variable-length payload, and a 2-byte checksum, the overhead ratio depends on how much payload you send relative to the fixed header and checksum bytes.
Copy this code into the Wokwi editor and upload to the ESP32.
/*
* Network Packet Simulator for ESP32
*
* This program demonstrates basic networking concepts:
* - Packet structure (header, payload, checksum)
* - Transmission state visualization with LEDs
* - Error detection using checksum verification
*
* LED Indicators:
* - Red (GPIO 2): Error - checksum verification failed
* - Green (GPIO 4): Success - packet transmitted/received correctly
* - Yellow (GPIO 5): Transmitting - packet in transit
* - Blue (GPIO 18): Received - packet arrival indicator
*/
// LED Pin Definitions
#define LED_ERROR 2 // Red LED - Error indicator
#define LED_SUCCESS 4 // Green LED - Success indicator
#define LED_TRANSMIT 5 // Yellow LED - Transmission in progress
#define LED_RECEIVED 18 // Blue LED - Packet received
// Packet Structure Constants
#define HEADER_SIZE 4 // Bytes for header (version, type, length, sequence)
#define MAX_PAYLOAD 32 // Maximum payload size in bytes
#define CHECKSUM_SIZE 2 // 16-bit checksum
// Packet Types
#define PKT_DATA 0x01 // Data packet
#define PKT_ACK 0x02 // Acknowledgment packet
#define PKT_NACK 0x03 // Negative acknowledgment
#define PKT_PING 0x04 // Ping/heartbeat packet
// Protocol Version
#define PROTOCOL_VERSION 0x01
// Structure representing a network packet
struct Packet {
// Header fields (4 bytes)
uint8_t version; // Protocol version
uint8_t type; // Packet type (DATA, ACK, NACK, PING)
uint8_t length; // Payload length
uint8_t sequence; // Sequence number for ordering
// Payload (variable length, max 32 bytes)
uint8_t payload[MAX_PAYLOAD];
// Checksum (2 bytes)
uint16_t checksum;
};
// Global variables
uint8_t sequenceNumber = 0;
bool simulateError = false; // Toggle to simulate transmission errors
// Function prototypes
void initializeLEDs();
void setLEDState(int led, bool state);
void blinkLED(int led, int times, int delayMs);
uint16_t calculateChecksum(Packet* pkt);
bool verifyChecksum(Packet* pkt);
void createPacket(Packet* pkt, uint8_t type, const char* data);
void transmitPacket(Packet* pkt);
void receivePacket(Packet* pkt);
void printPacketDetails(Packet* pkt, const char* label);
void demonstratePacketFlow();
void setup() {
// Initialize serial communication for debugging
Serial.begin(115200);
delay(1000);
Serial.println("\n");
Serial.println("========================================");
Serial.println(" Network Packet Simulator v1.0");
Serial.println(" ESP32 IoT Learning Lab");
Serial.println("========================================\n");
// Initialize LED pins
initializeLEDs();
// Startup LED test sequence
Serial.println("Testing LEDs...");
blinkLED(LED_ERROR, 2, 200);
blinkLED(LED_SUCCESS, 2, 200);
blinkLED(LED_TRANSMIT, 2, 200);
blinkLED(LED_RECEIVED, 2, 200);
Serial.println("\nLED Test Complete!");
Serial.println("- Red: Error indicator");
Serial.println("- Green: Success indicator");
Serial.println("- Yellow: Transmission indicator");
Serial.println("- Blue: Received indicator\n");
delay(1000);
}
void loop() {
// Demonstrate packet transmission and reception
demonstratePacketFlow();
// Wait before next demonstration cycle
Serial.println("\n--- Waiting 5 seconds before next cycle ---\n");
delay(5000);
}
// Initialize all LED pins as outputs
void initializeLEDs() {
pinMode(LED_ERROR, OUTPUT);
pinMode(LED_SUCCESS, OUTPUT);
pinMode(LED_TRANSMIT, OUTPUT);
pinMode(LED_RECEIVED, OUTPUT);
// Turn off all LEDs initially
digitalWrite(LED_ERROR, LOW);
digitalWrite(LED_SUCCESS, LOW);
digitalWrite(LED_TRANSMIT, LOW);
digitalWrite(LED_RECEIVED, LOW);
}
// Set LED state (on/off)
void setLEDState(int led, bool state) {
digitalWrite(led, state ? HIGH : LOW);
}
// Blink an LED a specified number of times
void blinkLED(int led, int times, int delayMs) {
for (int i = 0; i < times; i++) {
digitalWrite(led, HIGH);
delay(delayMs);
digitalWrite(led, LOW);
delay(delayMs);
}
}
// Calculate 16-bit checksum using ones' complement sum
// This is a simplified version of the Internet Checksum (RFC 1071)
uint16_t calculateChecksum(Packet* pkt) {
uint32_t sum = 0;
// Add header bytes
sum += pkt->version;
sum += pkt->type;
sum += pkt->length;
sum += pkt->sequence;
// Add payload bytes
for (int i = 0; i < pkt->length; i++) {
sum += pkt->payload[i];
}
// Fold 32-bit sum into 16-bit (handle overflow)
while (sum >> 16) {
sum = (sum & 0xFFFF) + (sum >> 16);
}
// Return one's complement
return ~((uint16_t)sum);
}
// Verify packet checksum by recomputing and comparing
bool verifyChecksum(Packet* pkt) {
uint16_t stored = pkt->checksum;
pkt->checksum = 0;
uint16_t computed = calculateChecksum(pkt);
pkt->checksum = stored;
return (stored == computed);
}
// Create a new packet with specified type and data
void createPacket(Packet* pkt, uint8_t type, const char* data) {
// Clear packet memory
memset(pkt, 0, sizeof(Packet));
// Set header fields
pkt->version = PROTOCOL_VERSION;
pkt->type = type;
pkt->sequence = sequenceNumber++;
// Copy payload data
if (data != NULL) {
pkt->length = min(strlen(data), (size_t)MAX_PAYLOAD);
memcpy(pkt->payload, data, pkt->length);
} else {
pkt->length = 0;
}
// Calculate and set checksum
pkt->checksum = calculateChecksum(pkt);
}
// Simulate packet transmission
void transmitPacket(Packet* pkt) {
Serial.println(">>> TRANSMITTING PACKET >>>");
// Turn on transmission LED
setLEDState(LED_TRANSMIT, true);
// Print packet being sent
printPacketDetails(pkt, "TX");
// Simulate transmission delay (represents actual network latency)
Serial.println(" Transmitting...");
delay(500);
// Simulate network effects
if (simulateError) {
Serial.println(" [!] Simulating network error - corrupting data");
// Corrupt one byte of payload to demonstrate error detection
if (pkt->length > 0) {
pkt->payload[0] ^= 0xFF; // Flip all bits of first byte
}
}
delay(500);
// Turn off transmission LED
setLEDState(LED_TRANSMIT, false);
Serial.println(" Transmission complete.\n");
}
// Simulate packet reception and verification
void receivePacket(Packet* pkt) {
Serial.println("<<< RECEIVING PACKET <<<");
// Turn on received LED
setLEDState(LED_RECEIVED, true);
delay(300);
// Print received packet
printPacketDetails(pkt, "RX");
// Verify checksum
Serial.println(" Verifying checksum...");
delay(300);
bool checksumValid = verifyChecksum(pkt);
if (checksumValid) {
Serial.println(" [OK] Checksum VALID - Packet integrity confirmed!");
// Success indication
setLEDState(LED_RECEIVED, false);
setLEDState(LED_SUCCESS, true);
blinkLED(LED_SUCCESS, 3, 150);
setLEDState(LED_SUCCESS, false);
} else {
Serial.println(" [ERROR] Checksum INVALID - Packet corrupted!");
Serial.println(" [ERROR] Request retransmission (NACK)");
// Error indication
setLEDState(LED_RECEIVED, false);
setLEDState(LED_ERROR, true);
blinkLED(LED_ERROR, 5, 100);
setLEDState(LED_ERROR, false);
}
Serial.println();
}
// Print detailed packet information
void printPacketDetails(Packet* pkt, const char* label) {
Serial.println(" +------------------------------------------+");
Serial.printf(" | %s Packet Details |\n", label);
Serial.println(" +------------------------------------------+");
// Header section
Serial.println(" | HEADER: |");
Serial.printf(" | Version: 0x%02X |\n", pkt->version);
Serial.printf(" | Type: 0x%02X ", pkt->type);
// Print packet type name
switch(pkt->type) {
case PKT_DATA: Serial.println("(DATA) |"); break;
case PKT_ACK: Serial.println("(ACK) |"); break;
case PKT_NACK: Serial.println("(NACK) |"); break;
case PKT_PING: Serial.println("(PING) |"); break;
default: Serial.println("(UNKNOWN) |"); break;
}
Serial.printf(" | Length: %d bytes |\n", pkt->length);
Serial.printf(" | Sequence: %d |\n", pkt->sequence);
// Payload section
Serial.println(" | PAYLOAD: |");
if (pkt->length > 0) {
Serial.print(" | Data: \"");
for (int i = 0; i < pkt->length && i < 20; i++) {
if (pkt->payload[i] >= 32 && pkt->payload[i] < 127) {
Serial.print((char)pkt->payload[i]);
} else {
Serial.print('.');
}
}
if (pkt->length > 20) Serial.print("...");
Serial.println("\"");
// Hex dump of payload
Serial.print(" | Hex: ");
for (int i = 0; i < min(pkt->length, (uint8_t)8); i++) {
Serial.printf("%02X ", pkt->payload[i]);
}
if (pkt->length > 8) Serial.print("...");
Serial.println();
} else {
Serial.println(" | (empty) |");
}
// Checksum section
Serial.println(" | CHECKSUM: |");
Serial.printf(" | Value: 0x%04X |\n", pkt->checksum);
Serial.println(" +------------------------------------------+");
}
// Main demonstration function
void demonstratePacketFlow() {
static int demoStep = 0;
Packet packet;
Serial.println("============================================");
Serial.printf(" DEMONSTRATION CYCLE %d\n", demoStep + 1);
Serial.println("============================================\n");
switch (demoStep) {
case 0:
// Demo 1: Simple data packet (no errors)
Serial.println("[Demo 1] Sending DATA packet - Normal transmission\n");
simulateError = false;
createPacket(&packet, PKT_DATA, "Hello IoT World!");
transmitPacket(&packet);
receivePacket(&packet);
break;
case 1:
// Demo 2: Sensor reading packet
Serial.println("[Demo 2] Sending sensor data packet\n");
simulateError = false;
createPacket(&packet, PKT_DATA, "TEMP:25.5C,HUM:65%");
transmitPacket(&packet);
receivePacket(&packet);
break;
case 2:
// Demo 3: Corrupted packet (simulated error)
Serial.println("[Demo 3] Simulating CORRUPTED packet\n");
simulateError = true;
createPacket(&packet, PKT_DATA, "Critical Alert!");
transmitPacket(&packet);
receivePacket(&packet);
simulateError = false;
break;
case 3:
// Demo 4: Ping packet
Serial.println("[Demo 4] Sending PING packet (heartbeat)\n");
simulateError = false;
createPacket(&packet, PKT_PING, NULL);
transmitPacket(&packet);
receivePacket(&packet);
break;
case 4:
// Demo 5: ACK packet
Serial.println("[Demo 5] Sending ACK packet\n");
simulateError = false;
createPacket(&packet, PKT_ACK, "OK");
transmitPacket(&packet);
receivePacket(&packet);
break;
}
// Cycle through demos
demoStep = (demoStep + 1) % 5;
}Watch the Serial Monitor for detailed packet information:
Study the Serial Monitor output to identify:
+------------------------------------------+
| TX Packet Details |
+------------------------------------------+
| HEADER: |
| Version: 0x01 | <-- Protocol version
| Type: 0x01 (DATA) | <-- Packet type
| Length: 16 bytes | <-- Payload size
| Sequence: 0 | <-- Order tracking
| PAYLOAD: |
| Data: "Hello IoT World!" | <-- Actual data
| Hex: 48 65 6C 6C 6F 20 49 6F ... | <-- Binary representation
| CHECKSUM: |
| Value: 0xF8E2 | <-- Error detection code
+------------------------------------------+The demo automatically shows a corrupted packet in cycle 3. Observe how:
When running the simulation, your Serial Monitor should display:
========================================
Network Packet Simulator v1.0
ESP32 IoT Learning Lab
========================================
Testing LEDs...
LED Test Complete!
- Red: Error indicator
- Green: Success indicator
- Yellow: Transmission indicator
- Blue: Received indicator
============================================
DEMONSTRATION CYCLE 1
============================================
[Demo 1] Sending DATA packet - Normal transmission
>>> TRANSMITTING PACKET >>>
+------------------------------------------+
| TX Packet Details |
+------------------------------------------+
| HEADER: |
| Version: 0x01 |
| Type: 0x01 (DATA) |
| Length: 16 bytes |
| Sequence: 0 |
| PAYLOAD: |
| Data: "Hello IoT World!" |
| Hex: 48 65 6C 6C 6F 20 49 6F ... |
| CHECKSUM: |
| Value: 0xF8E2 |
+------------------------------------------+
Transmitting...
Transmission complete.
<<< RECEIVING PACKET <<<
[... packet details ...]
Verifying checksum...
[OK] Checksum VALID - Packet integrity confirmed!
--- Waiting 5 seconds before next cycle ---Modify the code to implement a complete ACK/NACK system:
Hint: Create a new function sendAcknowledgment(bool success, uint8_t seqNum) that creates and transmits the appropriate response.
Network packets can arrive out of order. Add sequence number tracking:
Hint: Store lastReceivedSequence as a global variable and compare incoming packets against it.
For advanced learners with two ESP32 boards:
Hint: Use Serial2.begin(9600, SERIAL_8N1, RX_PIN, TX_PIN) for the second serial port.
In resource-constrained IoT systems, every byte counts. Adding error detection increases packet size but prevents silent data corruption. The following worked example quantifies this trade-off.
Scenario: An industrial IoT sensor transmits 10-byte temperature readings every second over an IEEE 802.15.4 wireless link (250 kbps) with a 1% packet error rate.
Given:
Analysis:
| Option | Overhead Bytes | Total Bytes | Overhead % | Errors Detected | Undetected Errors |
|---|---|---|---|---|---|
| No checksum | 4 | 14 | 28.6% | 0 | 864/day |
| 2-byte checksum | 6 | 16 | 37.5% | ~863/day | ~1/day |
| 4-byte CRC32 | 8 | 18 | 44.4% | ~864/day | ~0 |
Energy Cost (at 10 mW transmit power, 250 kbps data rate):
Impact Over 1 Year:
Decision: A 2-byte checksum is optimal for most IoT sensors – it catches nearly all errors with minimal overhead. CRC32 is only justified for safety-critical applications (medical devices, industrial control systems) where even a single undetected error per day is unacceptable.
How the packet networking concepts in this lab interconnect:
| Concept | Relates To | Key Insight |
|---|---|---|
| Packet Header | Protocol Metadata | Version, type, length, and sequence fields identify the packet and enable processing |
| Payload | Application Data | The actual sensor readings, commands, or messages being transmitted |
| Checksum | Error Detection | Mathematical verification that data was not corrupted during transmission |
| Sequence Numbers | Ordering and Loss Detection | Track packets across unreliable links, detect gaps and duplicates |
| ACK/NACK | Reliability | Confirm receipt or request retransmission to ensure delivery |
| Protocol Overhead | Efficiency | Headers and checksums consume bandwidth – minimize for constrained networks |
| LED State Machine | Visualization | Physical representation of transmission, reception, success, and error states |
A single simulation run produces one sample from a random process. Fix: run at least 30 independent runs with different random seeds and report the mean and 95% confidence interval.
Metrics collected during the initialisation period (when routing tables are forming) skew the results. Fix: discard the first 10–20% of simulation time as a warm-up period before recording metrics.
The default free-space path loss model ignores walls, furniture, and interference. Fix: use a more realistic model (log-distance, Two-Ray Ground, or measured empirical values) and document which model was used.
This lab demonstrated essential packet networking concepts through hands-on simulation:
| Topic | Chapter | Description |
|---|---|---|
| Network Performance | Network Performance Lab | Measure bandwidth, latency, and jitter with ESP32 experiments |
| Packet Journey Game | Packet Journey Game | Interactive adventure tying together all networking concepts through gamified learning |
| TCP/IP Protocol | TCP/IP Fundamentals | How real TCP protocols implement packet structure, flow control, and error handling |
| Error Detection | Error Detection Methods | CRC, checksums, and forward error correction techniques compared |
| Protocol Overhead | Transport Overhead Analysis | Minimising header waste in constrained IoT networks |
| Routing Structures | Network Topologies Fundamentals | How packets route through star, mesh, and tree network structures |