Networking and Communications

Goals

group assignment

• send a message between two projects

Individual Assignment

• design, build, and connect wired or wireless node(s) with network or bus addresses and local input &/or output device(s)

Individual Assignment

1. Assignment Objective

The objective of this assignment is to:

• Design and build a basic communication network system consisting of two nodes;
• Each node is a XIAO ESP32S3 microcontroller;
• They communicate with each other via wired UART serial communication;
• On the receiving node, a received message will trigger a response by lighting up an LED;
• Each node should be recognized as an independent device (logical address) by the program;
• The local output device is: LED module.

2. Brief Introduction to Communication Principle

I chose UART (Universal Asynchronous Receiver/Transmitter) as the communication method. It has the following characteristics:

• It is one of the most basic serial communication protocols;
• Usually requires only 3 wires: TX (transmit), RX (receive), and GND (ground);
• On the XIAO ESP32S3, I used Serial1 to implement UART communication;
• The sender periodically transmits strings, and the receiver reads them to trigger LED actions.

What is UART Communication?

UART (Universal Asynchronous Receiver/Transmitter) is a serial communication protocol used to asynchronously transmit data between two devices using just a few pins (typically two wires).

It is commonly used for:

• Communication between microcontrollers (e.g., two XIAO ESP32S3 boards)
• Serial debugging between microcontroller and computer
• Communication with modules like Bluetooth, GPS, or GSM

Basic Features of UART

UART Pins

Note: Connect TX to RX and RX to TX between devices. GND must also be connected.

UART Data Frame Format

UART sends data in a frame structure:

Start bit | Data bits (usually 8) | Optional parity bit | Stop bit

Example: Standard UART frame (8N1)

“8N1” = 8 data bits, No parity, 1 stop bit.

UART Communication Parameters

Example in Arduino:

Serial1.begin(9600, SERIAL_8N1, RX, TX);

Common UART Use Cases

• Microcontroller-to-PC debugging via Serial Monitor
• Bluetooth, GPS, GSM module communication
• Control systems with multiple devices (as in your project)
• RS232 / USB-to-Serial converter cables

Comparison: UART vs Other Protocols

Notes and Common Errors

3. Node Design and Role Assignment — UART Pin Selection Based on Pinout

The default UART pins for the XIAO ESP32S3 are as follows (refer to the blue UART section in the pinout diagram):

This pair of pins can be used to build a Serial1 (secondary UART) communication channel, making them ideal for node-to-node communication in this Fab Academy assignment.

Hardware Wiring Plan (Based on Pinout Diagram)

Wiring between two XIAO ESP32S3 boards:

LED Module Wiring on Receiver Side:

4. Hardware Connection

Bill of Materials:

Wiring Instructions:

1. Communication wires between nodes (TX ↔ RX, RX ↔ TX, GND ↔ GND)

2. LED module on receiving node (Node 2)

5. Arduino Code (for Both Nodes)

Before writing the code, I had some doubts about the baud rate for transmission, so I first researched related information and documented my findings.

ESP32S3 Baud Rate Is Not Fixed

The ESP32S3 supports a wide range of common baud rates:

🔧 How to Set Baud Rate in UART

To set the baud rate in Arduino for ESP32S3, use the following code:

Serial1.begin(9600, SERIAL_8N1, RX, TX);  // 9600 is the baud rate

You can replace 9600 with any other supported baud rate:

Serial1.begin(115200, SERIAL_8N1, RX, TX);  // Faster communication

Summary of Program Logic

Node 1 (Sender) Code:

This code initializes UART communication using Serial1 on the XIAO ESP32S3. It sends a string "Hello from Node 1" every second to the receiver node.

#define XIAO_ESP32S3_D6 
            #define XIAO_ESP32S3_D7 
            #define TXD 43
            #define RXD 44

            void setup() {
            Serial1.begin(9600, SERIAL_8N1, RXD, TXD);
            }

            void loop() {
            Serial1.println("Hello from Node 1");
            delay(1000);
            }
            

Node 2 (Receiver) Code:

This code sets up UART communication using Serial1 on the XIAO ESP32S3 and configures a digital pin for controlling an LED. When it receives a message containing the word "Hello" from Node 1, it briefly lights up the LED.

#define XIAO_ESP32S3_D2 
            #define XIAO_ESP32S3_D6 
            #define XIAO_ESP32S3_D7 
            #define TXD 43
            #define RXD 44
            #define LED_PIN 3

            void setup() {
            pinMode(LED_PIN, OUTPUT); // Set LED pin as output
            Serial1.begin(9600, SERIAL_8N1, RXD, TXD); // Initialize UART communication
            }

            void loop() {
            if (Serial1.available()) {
                String msg = Serial1.readStringUntil('\n'); // Read incoming serial message
                if (msg.indexOf("Hello") >= 0) {
                digitalWrite(LED_PIN, HIGH);  // Turn on LED
                delay(300);                   // Wait 300 ms
                digitalWrite(LED_PIN, LOW);   // Turn off LED
                }
            }
            }
            

6. Program Upload Steps

1. Open the Arduino IDE;
2. Plug in the Node 1 board and select the correct board and port:
   • Go to Tools → Board → XIAO_ESP32S3
   • Select the corresponding COM port (e.g., COMx)
3. Upload the sender code to Node 1;
4. Disconnect Node 1 and connect Node 2 via USB;
5. Upload the receiver code to Node 2;
6. Make sure TX/RX/GND are correctly connected between the two boards;
7. Power both boards — the communication test will begin automatically.

7. Testing and Validation Process

After completing all hardware connections and uploading the programs, I began system testing to verify whether the nodes could communicate properly.

First, I powered both XIAO ESP32S3 boards by connecting them to the computer via USB data cables. Once powered, Node 1 (sender) started its main loop and transmitted a message "Hello from Node 1" via UART every second.

Meanwhile, Node 2 (receiver) continuously monitored the UART interface. Whenever it received a string containing the keyword "Hello", it triggered the LED module connected to GPIO2 to light up for 300 milliseconds, then turned it off automatically.

To verify the stability and responsiveness of the system, I performed the following tests:

• Test 1: Observe Normal Communication
  • Opened the Serial Monitor and confirmed that Node 1 was sending a message every second;
  • Observed that Node 2’s LED flashed once per second — this indicated successful communication;
  • This confirmed the correctness of TX/RX connections and matched baud rates.
• Test 2: Modify Message Content
  • Changed Node 1's message to "LED_ON_SIGNAL";
  • Updated Node 2 to trigger the LED only when receiving "LED_ON";
  • After uploading, the LED still responded correctly, showing the receiver can recognize specific message content.

  Updated Node 1 (Sender) Code

  This version of the sender code not only sends the message "LED_ON_SIGNAL" via Serial1 every second, but also prints debugging output to the Serial Monitor via Serial, which helps track transmission in real time.

  
              #define XIAO_ESP32S3_D6 
              #define XIAO_ESP32S3_D7 
              #define TXD 43
              #define RXD 44
              
              void setup() {
                Serial.begin(115200);  // Debug output to Serial Monitor
                Serial1.begin(9600, SERIAL_8N1, RXD, TXD);  // Initialize UART communication
                Serial.println("Sender setup complete.");
              }
              
              void loop() {
                Serial1.println("LED_ON_SIGNAL");  // Modified message content
                Serial.println("Sent: LED_ON_SIGNAL");  // Visible in Serial Monitor
                delay(1000);
              }
              

  Explanation:

  • I changed the original message "Hello from Node 1" to a more specific one: "LED_ON_SIGNAL".
  • This allows us to test whether the receiver can correctly match and respond to messages containing "LED_ON".
  • I also added Serial.println() statements to make it easier to observe the program status via the Serial Monitor.

  Updated Node 2 (Receiver) Code

  This code listens for UART messages using Serial1, and if the incoming string contains "LED_ON", it briefly turns on an LED connected to GPIO2. It also prints all received messages and LED actions to the Serial Monitor for easier debugging.

  
              #define XIAO_ESP32S3_D2 
              #define XIAO_ESP32S3_D6 
              #define XIAO_ESP32S3_D7 
              #define TXD 43
              #define RXD 44
              #define LED_PIN 2
              
              void setup() {
                pinMode(LED_PIN, OUTPUT);
                Serial.begin(115200);  // Enable serial monitor output
                Serial1.begin(9600, SERIAL_8N1, RXD, TXD);  // Initialize UART
                Serial.println("Receiver setup complete.");
              }
              
              void loop() {
                if (Serial1.available()) {
                  String msg = Serial1.readStringUntil('\n');  // Read UART data
                  Serial.print("Received: ");
                  Serial.println(msg);  // Print received string to Serial Monitor
              
                  if (msg.indexOf("LED_ON") >= 0) {  // Match command containing "LED_ON"
                    digitalWrite(LED_PIN, HIGH);
                    delay(300);
                    digitalWrite(LED_PIN, LOW);
                    Serial.println("LED blinked.");
                  }
                }
              }
              

  Explanation:

  • I used msg.indexOf("LED_ON") >= 0 to check whether the received command contains the keyword "LED_ON".
  • Since "LED_ON_SIGNAL" includes "LED_ON", the condition is satisfied and the LED is triggered.
  • Added Serial.print() and Serial.println() for debugging purposes and real-time feedback in the Serial Monitor.
  • If the string does not contain "LED_ON", the LED will not blink, which confirms the condition works as expected.
• Test 3: Adjust LED Blink Duration
  • Modified delay(300) to delay(1000) in Node 2’s code;
  • The LED stayed on longer, making the blink more noticeable;
  • This helped me better understand how digitalWrite() and delay() affect output device control.
• Test 4: Fault Test – Disconnect TX Line
  • Manually unplugged the jumper wire from Node 1’s TX to Node 2’s RX;
  • The LED stopped blinking, confirming that communication was lost;
  • Reconnecting the wire restored LED response, highlighting the importance of proper wiring.

Through these tests, I not only verified the functionality of the system but also deepened my understanding of UART communication — including TX/RX crossover, baud rate matching, and signal-triggered output. The overall testing process was smooth and met expectations.

Issues and Solutions

During the setup and testing process, I encountered a few minor problems. However, all of them were resolved through careful troubleshooting and learning. Below are some typical issues and how I solved them:

This debugging process helped me realize that even the smallest detail — like the direction of one wire or a single configuration parameter — can directly affect the system’s operation.

Personal Assignment Summary

Through this individual assignment, I successfully completed a two-node communication system using XIAO ESP32S3 and UART serial communication.

During the entire process, I not only built two independent nodes—one as the sender and one as the receiver—but also mastered several key concepts:

• Learned how to use Serial1.begin() to enable the second UART on the ESP32S3, and how to use specific pins (GPIO43 and GPIO44) for TX/RX communication;
• Gained a deeper understanding of how UART communication works, including frame structure, baud rate, and the importance of crossing TX and RX connections;
• Successfully implemented code that sends a specific string from the sender, which is recognized by the receiver to control an LED — realizing a full loop from data communication to physical action;
• Performed multiple tests including changing message content, adjusting LED response time, and simulating faults to verify system stability;
• Learned to use Serial.println() for real-time debugging in the Serial Monitor, improving development efficiency;
• Also learned to troubleshoot common issues such as upload failures, garbled serial output, and unresponsive receivers—and resolved them successfully.

This experiment not only helped me fulfill Fab Academy’s requirements for node communication but also deepened my understanding of low-level communication between IoT devices. It lays a solid foundation for exploring more advanced protocols in the future, such as ESP-NOW or Wi-Fi MQTT.

The entire experience showed me that even a simple data exchange between two boards involves an interweaving of circuit design, data protocols, program logic, and debugging skills. By building and debugging it myself, I truly understood the core principles of “how devices talk to each other.”

                #define XIAO_ESP32S3_D6 
                #define XIAO_ESP32S3_D7     
                #define TXD 43
                #define RXD 44

                void setup() {
                Serial.begin(115200);  // For debug output
                Serial1.begin(9600, SERIAL_8N1, RXD, TXD);  // UART initialization
                Serial.println("Node A ready. Sending Ping...");
                }

                void loop() {
                Serial1.println("Ping");  // Send Ping
                Serial.println("Sent: Ping");  // Log to Serial Monitor
                delay(3000);  // Wait 3 seconds before sending again
                }
                

                #define XIAO_ESP32S3_D6 
                #define XIAO_ESP32S3_D7    
                #define TXD 43
                #define RXD 44

                void setup() {
                Serial.begin(115200);  // For debug output
                Serial1.begin(9600, SERIAL_8N1, RXD, TXD);  // UART initialization
                Serial.println("Node B ready. Waiting for Ping...");
                }

                void loop() {
                if (Serial1.available()) {
                    String msg = Serial1.readStringUntil('\n');  // Read message
                    Serial.print("Received: ");
                    Serial.println(msg);

                    if (msg.indexOf("Ping") >= 0) {
                    Serial1.println("Pong");  // Send response
                    Serial.println("Sent: Pong");
                    }
                }
                }