WiFi

The WiFi Server utility provides UDP-based wireless communication for the Echo microcontroller. Designed for robotics applications requiring higher bandwidth than BLE, it creates a WiFi access point .

Key Features

• Automatic WiFi access point creation

• UDP protocol for low-latency communication

• Automatic client detection and connection management

• Support for large data transmissions with automatic packet fragmentation

• Built-in connection timeout handling

• Optional debug output for development

Performance Note: UDP communication provides lower latency than TCP, making it ideal for real-time robot control applications.

---

Overview

Method/Constructor	Description
WiFiServerBridge(const char* _ssid, const char* _password, unsigned int _port)	Constructor. Initializes the class with the WiFi SSID, password, and UDP listening port. Also initializes internal state variables like _isConnected and _debugMode(Both False by default).
void begin()	Starts the WiFi Access Point with the given SSID and password, and begins listening for UDP packets on the specified port. Prints debug information if debug mode is enabled.
void processIncoming()	Checks for incoming UDP packets. Updates connection status (_isConnected), stores the last client IP/port, records the last packet time, and saves received data. Also handles connection timeout after 2 seconds of inactivity. Should be called repeatedly in loop().
void sendData(const String& data)	Sends data to the last connected client. If the client is not “connected” (no recent packets received), it does nothing.
String readData()	Returns the last received data as a String and clears the internal buffer. If multiple packets arrive before this is called, previous data may be lost.
bool getStatus() const	Returns the current connection status (true if a client has sent a packet within the last 2 seconds, false otherwise).
void enableDebug(bool enable)	Enables or disables debug printing for received and sent data, connection events, and other internal state information.
void setTimeout(unsigned long ms)	Configures the connection timeout in milliseconds. Default is 2000 ms. Affects when _isConnected is set to false after inactivity.
void setTimeoutConnectionDependent(bool enable)	f set to true, _isConnected will now depend on whether a WiFi client is associated with the access point, rather than waiting for a packet timeout. Overrides the normal packet-timeout behavior. Pass false to revert to the default packet-based timeout.

---

Quick Start

#include <EchoLib.h>

WiFiServerBridge wifi("EchoRobot", "password123", 8888);

void setup() {
    Serial.begin(115200);
    wifi.begin();
}

void loop() {
    wifi.processIncoming();
}

Your Echo now creates a WiFi network named "EchoRobot" and listens for UDP packets on port 8888.

---

API Reference

WiFiServerBridge(const char* ssid, const char* password, unsigned int port)

Creates a WiFi server instance that will host an access point.

Parameters:

• ssid: The WiFi network name

• password: Network password (minimum 8 characters)

• port: UDP port number for communication (typically 8888 or 9999)

Example:

WiFiServerBridge wifi("EchoRobot", "robot2024", 8888);

---

begin()

void begin()

Initializes the WiFi access point and starts the UDP server. Must be called once during setup.

Example:

void setup() {
    Serial.begin(115200);
    wifi.begin();
    Serial.println("WiFi server started");
}

---

processIncoming()

void processIncoming()

Checks for incoming UDP packets and updates connection status. Must be called regularly in the main loop for the server to function.

Example:

void loop() {
    wifi.processIncoming();  // Essential - processes all incoming data
}

Important: Without calling this method, the server cannot receive data or detect client connections.

---

sendData(const String& data)

void sendData(const String& data)

Sends raw data to the connected client via UDP. Automatically handles packet fragmentation for large transmissions.

Parameters:

• data: String data to transmit

Example:

int sensorValue = analogRead(A0);
wifi.sendData("Sensor: " + String(sensorValue));

wifi.sendData("Robot ready");

Note: Data is only sent if a client is currently connected. Check connection status with getStatus() before sending critical data.

---

readData()

String readData()

Retrieves the most recent data received from the client. Returns an empty string if no new data is available.

Returns:

• String: The received data, or empty string if no data available

Example:

String command = wifi.readData();
if (command.length() > 0) {
    Serial.println("Command: " + command);
    
    if (command == "FORWARD") {
        digitalWrite(MOTOR_PIN, HIGH);
    }
}

Important: Data is cleared after being read. Store the returned value if needed for subsequent operations.

---

getStatus()

bool getStatus() const

Returns the current connection state. A client is considered connected if data has been received within the last 2 seconds.

Returns:

• true: A client is connected and communication is active

• false: No active connection

Example:

if (wifi.getStatus()) {
    wifi.sendData("Connected");
} else {
    Serial.println("Waiting for client...");
}

---

enableDebug(bool enable)

void enableDebug(bool enable)

Enables or disables detailed debug output to Serial Monitor. Useful for development and troubleshooting.

Parameters:

• enable: true to enable debug output, false to disable

Example:

void setup() {
    Serial.begin(115200);
    wifi.enableDebug(true);  // Show all network activity
    wifi.begin();
}

Debug output includes:

• Network initialization details

• Incoming packet information with client IP and port

• Outgoing packet confirmation

• Connection timeout notifications

---

setTimeout(unsigned long ms)

void setTimeout(unsigned long ms);

Sets the timeout time in ms, by default, it's 2000ms (2 seconds). Which means that if a packet is not received within 2 seconds, the _isConnected status will be set to false.

Parameters:

• unsigned long ms represents time in ms

Example:

void setup() {
    Serial.begin(115200);
    wifi.setTimeout(5000);//will now set the new timeout time to 5 seconds rather than 2
    wifi.begin();
}

---

void setTimeoutConnectionDependent(bool enable);

By default, the server relies on the client constantly sending data to the Echo. This can cause issues in certain applications. To override the default configuration, you can call the setTimeoutConnectionDependent(bool enable) and set it to true. This will now make the status dependent on a client connection rather than a packet detection.

void setup() {
    Serial.begin(115200);
    wifi.setTimeoutConnectionDependent(true);
    wifi.begin();
}

---

Complete Example: WiFi Controlled Robot

This example demonstrates a complete WiFi-controlled Zippy robot which uses an external app that sends controller data.

#include <EchoLib.h>

WiFiServerBridge server("Zippy_Robot", "12345678", 8080);
MotorControllers motors;
TankDriveTrain drivetrain(motors, 1, 6);

bool mode = false;
int X = 0;
int Y = 0;
bool highSpeed = true;

void setup() {
  Serial.begin(115200);
  delay(1000);
  server.enableDebug(false);
  server.setTimeoutConnectionDependent(true);
  server.begin();
  Serial.println("Setup complete.");
}

String getField(const String& data, int index) {
  int start = 0;
  int end = -1;
  for (int i = 0; i <= index; i++) {
    start = end + 1;
    end = data.indexOf('|', start);
    if (end == -1 && i < index) return ""; 
  }
  return data.substring(start, end);
}

String getCellData(int cell, String cellData) {
  if (cellData.isEmpty()) return "";
  String cellStr = cellData.substring(0, cellData.indexOf(":")); // e.g. "C3"
  int cellNum = cellStr.substring(1).toInt(); // extract number (3)

  if (cellNum == cell) {
    // return everything after the colon
    return cellData.substring(cellData.indexOf(":") + 1);
  } else {
    return "";
  }
}


void loop() {
  server.processIncoming();
  Serial.println(server.getStatus());
  String data = server.readData();
  if (data.isEmpty()) return;

  String modeField = getField(data, 13);
  String yField = getField(data, 19);
  String xField = getField(data, 20);

  int colonIndex = modeField.indexOf(':');
  if (colonIndex != -1) {
    String modeStr = modeField.substring(colonIndex + 1);
    mode = (modeStr == "ENABLED");
  }

  String cell = getCellData(1, getField(data, 1));
  cell.toLowerCase();
  highSpeed = (cell != "false");

  Y = yField.toInt();
  X = xField.toInt();

  if(highSpeed){
    Y = Y/2;
    X = X/2;
  }

  // Drive
  if (mode) {
    drivetrain.drive(X, Y);
  }else {
    drivetrain.drive(0, 0);
  }
}

/*
|  Index | Field          | Example Value                 | Description                                       |
| :----: | :------------- | :---------------------------- | :------------------------------------------------ |
|  **0** | `DMSTART`      | `"DMSTART"`                   | Start marker                                      |
|  **1** | `C1:data`      | `"C1:U"`                      | Cell 1                                            |
|  **2** | `C2:data`      | `"C2:U"`                      | Cell 2                                            |
|  **3** | `C3:data`      | `"C3:U"`                      | Cell 3                                            |
|  **4** | `C4:data`      | `"C4:U"`                      | Cell 4                                            |
|  **5** | `C5:data`      | `"C5:U"`                      | Cell 5                                            |
|  **6** | `C6:data`      | `"C6:U"`                      | Cell 6                                            |
|  **7** | `C7:data`      | `"C7:U"`                      | Cell 7                                            |
|  **8** | `C8:data`      | `"C8:U"`                      | Cell 8                                            |
|  **9** | `C9:data`      | `"C9:U"`                      | Cell 9                                            |
| **10** | `C10:data`     | `"C10:U"`                     | Cell 10                                           |
| **11** | `C11:data`     | `"C11:U"`                     | Cell 11                                           |
| **12** | `C12:data`     | `"C12:U"`                     | Cell 12                                           |
| **13** | `MODE:`        | `"MODE:ENABLED"` *(optional)* | Only present when you call the `withMode` variant |
| **14** | `X`            | `"false"`                     | Button X                                          |
| **15** | `Y`            | `"false"`                     | Button Y                                          |
| **16** | `A`            | `"false"`                     | Button A                                          |
| **17** | `B`            | `"false"`                     | Button B                                          |
| **18** | `leftAnalogX`  | `"0"`                         | Left stick X (-100–100)                           |
| **19** | `leftAnalogY`  | `"0"`                         | Left stick Y (-100–100)                           |
| **20** | `rightAnalogX` | `"0"`                         | Right stick X (-100–100)                          |
| **21** | `rightAnalogY` | `"0"`                         | Right stick Y (-100–100)                          |
| **22** | `dUp`          | `"false"`                     | D-pad Up                                          |
| **23** | `dDown`        | `"false"`                     | D-pad Down                                        |
| **24** | `dLeft`        | `"false"`                     | D-pad Left                                        |
| **25** | `dRight`       | `"false"`                     | D-pad Right                                       |
| **26** | `rightTrigger` | `"0"`                         | Right trigger (0–100)                             |
| **27** | `leftTrigger`  | `"0"`                         | Left trigger (0–100)                              |
| **28** | `r1`           | `"false"`                     | Right bumper                                      |
| **29** | `l1`           | `"false"`                     | Left bumper                                       |
| **30** | `DMEND`        | `"DMEND"`                     | End marker                                        |
*/

---

Best Practices

Connection Management

Always call processIncoming() at the start of your loop:

void loop() {
    wifi.processIncoming();  // Must be first
    // Rest of your code
}

Connection Timeout

The server considers a client disconnected after 2 seconds without receiving data. For applications requiring persistent connections, implement periodic heartbeat messages from the client.

Safety Considerations

Implement fail-safe behavior when connections are lost:

if (!wifi.getStatus()) {
    digitalWrite(MOTOR_PIN, LOW);  // Stop movement
    // Safe state operations
}

---

Troubleshooting

Cannot Connect to WiFi Network

• Verify the network name appears in WiFi scan results

• Ensure password is at least 8 characters

• Check that the Echo board has successfully started (monitor Serial output)

• Try restarting the Echo board

• Verify your device supports 2.4GHz WiFi (5GHz is not supported)

No Data Received on Echo

• Verify processIncoming() is called in the loop

• Check that you're sending to the correct IP (192.168.4.1)

• Confirm the correct port number (8888 in examples)

• Enable debug mode to see incoming packet details

• Verify UDP mode is selected in your client application

Data Not Sent from Echo

• Confirm client connection with getStatus()

• Verify the Echo received at least one packet from the client first

• Check Serial output with debug mode enabled

• Ensure client is listening on the correct port

Intermittent Connection

• Check WiFi signal strength (move devices closer)

• Verify stable power supply to Echo board

• Reduce transmission frequency if overwhelming the network

• Check for WiFi interference from other networks

Large Data Not Received Completely

• The library automatically fragments large packets

• Ensure your client can handle multi-packet transmissions

• Check client buffer size is adequate

• Monitor Serial debug output for packet transmission status

---

Technical Specifications

Network Configuration

• Protocol: UDP (User Datagram Protocol)

• WiFi Mode: Access Point (AP)

• Default IP Address: 192.168.4.1

• Subnet Mask: 255.255.255.0

• Maximum Packet Size: 1400 bytes (single packet)

• Connection Timeout: 2000ms (2 seconds)

• Multi-packet Format: MULTI:packetId:currentPacket:totalPackets:data

Performance Characteristics

• Latency: Typically < 10ms for local network

• Throughput: Depends on network conditions and packet size

• Client Limit: Standard ESP32 AP supports up to 4 simultaneous clients

• Range: Approximately 50-100 meters in open space (varies with environment)

Power Considerations

WiFi communication requires more power than BLE:

• AP Mode (Active): ~120-150 mA

• Transmitting: ~150-200 mA

• Idle (Connected): ~80-100 mA

For battery-powered applications, consider implementing sleep modes between transmissions or using BLE for extended operation.