Optimizing Windows PC WebSocket Server Settings for Arduino (ESP32) Connections

Comprehensive guide to configuring WebSocket communication between PC and ESP32

---

Key Takeaways

• Ensure Compatibility: Align WebSocket server settings on the PC with client configurations on the ESP32 to maintain a stable connection.
• Handle Ping/Pong Mechanism: Properly manage heartbeat messages to keep the connection alive and detect disconnections promptly.
• Implement Robust Error Handling: Incorporate mechanisms on both PC and ESP32 sides to handle connection issues and retries effectively.

---

Introduction

Establishing a reliable WebSocket connection between a Windows PC and an Arduino-based ESP32 device is pivotal for numerous IoT applications. This comprehensive guide delves into the necessary configurations and considerations to ensure seamless communication using the ArduinoWebsockets.h library on the ESP32 side and the websockets.serve method on the PC side.

PC WebSocket Server Configuration

Overview

The Windows PC acts as the WebSocket server, facilitating bi-directional communication with the ESP32 client. Proper configuration of server parameters is essential to accommodate the specifics of the ESP32's WebSocket client implementation.

Ping Interval and Timeout Settings

The server is configured using:

self.server = await websockets.serve(self.handler, self.host, self.port, ping_interval=5, ping_timeout=5)

- Ping Interval (ping_interval=5): The server sends a ping every 5 seconds to verify the client's availability. - Ping Timeout (ping_timeout=5): The server waits for a pong response within 5 seconds before considering the connection as timed out.
Modification Consideration: - If the ESP32 struggles to respond within the specified timeout due to processing delays or network issues, consider increasing both ping_interval and ping_timeout values to provide a more forgiving window.

Network Considerations

- Same Network Requirement: Ensure that both the PC and ESP32 are connected to the same local network to facilitate direct communication. - Firewall Settings: Adjust Windows Firewall or any other security software to allow incoming connections on the specified WebSocket port (e.g., 8080). - Static IP Assignment: Assign a static IP to the PC to prevent address changes that could disrupt the ESP32's ability to connect consistently.

Security Settings

- Unsecured vs. Secured Connections: By default, WebSocket connections are unsecured (ws://). For enhanced security, especially over public networks, consider implementing secure WebSockets (wss://) by configuring SSL/TLS certificates on the PC server. - Authentication: Implement authentication mechanisms if sensitive data is being transmitted to prevent unauthorized access.

---

Arduino (ESP32) Configuration

Library Setup

- Installation: Ensure the ArduinoWebsockets.h library is installed via the Arduino Library Manager. - Dependencies: Verify that all dependencies, such as the WiFi library for ESP32, are correctly installed and up to date.

Connection Settings

- Server Address and Port: Configure the ESP32 with the correct IP address and port number matching the PC server settings. - Connection URL: Use the appropriate WebSocket URL, e.g., ws://192.168.1.100:8080/, ensuring that the path matches if specified.
Example:

const char* host = "192.168.1.100"; // PC's IP address
const int port = 8080; // WebSocket server port

Ping/Pong Handling

- Automatic Handling: The ArduinoWebsockets.h library typically manages ping/pong frames automatically. Ensure that the ESP32's client is set to respond to pings by sending pong frames. - Manual Implementation: If the library version does not support automatic ping responses, implement a manual handler to respond to ping messages promptly.
Example:

client.onEvent([](WebsocketsEvent event, String data) {
  if(event == WebsocketsEvent::GotPing){
    client.pong();
  }
});

Non-Blocking Communication

- Polling: In the loop() function, regularly call client.poll() to process incoming messages and maintain the connection without blocking the main execution thread. - Avoid Delays: Refrain from using blocking functions like delay() which can hinder the polling process and lead to missed heartbeats.
Example:

void loop() {
  if(client.available()){
    client.poll();
  }
  // Other non-blocking tasks
}

Error Handling

- Connection Status Monitoring: Implement callbacks to handle various connection events such as successful connections, disconnections, and errors. - Reconnection Logic: Design logic to attempt reconnection if the connection drops, ensuring resilience against temporary network failures.
Example:

client.onEvent([](WebsocketsEvent event, String data) {
  if(event == WebsocketsEvent::ConnectionClosed){
    // Attempt reconnection
  }
  // Handle other events
});

---

Best Practices for Stable Connection

Consistent Library Versions

- Ensure that both the PC server and ESP32 client use compatible versions of the WebSocket libraries to prevent protocol mismatches and leverage the latest features and fixes.

Monitoring and Debugging

- Logging: Implement detailed logging on both PC and ESP32 to track connection statuses, message exchanges, and errors. - Debugging Tools: Utilize network monitoring tools like Wireshark to analyze WebSocket traffic and identify potential issues.

Example Code Snippets

PC WebSocket Server (Python)

import asyncio
import websockets

async def handler(websocket, path):
    try:
        async for message in websocket:
            print(f"Received message from ESP32: {message}")
            await websocket.send("Acknowledged")
    except websockets.exceptions.ConnectionClosed as e:
        print(f"Connection closed: {e}")

start_server = websockets.serve(handler, '192.168.1.100', 8080, ping_interval=5, ping_timeout=5)

asyncio.get_event_loop().run_until_complete(start_server)
asyncio.get_event_loop().run_forever()

ESP32 WebSocket Client (Arduino)

#include <ArduinoWebsockets.h>
#include <WiFi.h>

using namespace websockets;

// WiFi credentials
const char* ssid = "YOUR_WIFI_SSID";
const char* password = "YOUR_WIFI_PASSWORD";

// WebSocket server details
const char* host = "192.168.1.100";
const int port = 8080;

// Initialize WebSocket client
WebsocketsClient client;

void setup(){
  Serial.begin(115200);
  WiFi.begin(ssid, password);

  // Wait for WiFi connection
  while (WiFi.status() != WL_CONNECTED){
    delay(1000);
    Serial.println("Connecting to WiFi...");
  }
  Serial.println("Connected to WiFi");

  // Define WebSocket event handlers
  client.onMessage([](WebsocketsMessage message) {
    Serial.println("Msg: " + message.data());
    // Respond to server messages if necessary
  });

  client.onEvent([](WebsocketsEvent event, String data) {
    if(event == WebsocketsEvent::ConnectionOpened){
      Serial.println("Connected to WebSocket server");
    }
    else if(event == WebsocketsEvent::ConnectionClosed){
      Serial.println("Disconnected from WebSocket server");
      // Attempt reconnection
      client.connect(host, port);
    }
    else if(event == WebsocketsEvent::GotPing){
      client.pong();
    }
    else if(event == WebsocketsEvent::GotPong){
      Serial.println("Received pong");
    }
  });

  // Connect to WebSocket server
  client.connect(host, port);
}

void loop(){
  if(client.available()){
    client.poll();
  }

  // Example: Send a message every 10 seconds
  static unsigned long lastSend = 0;
  if(millis() - lastSend > 10000){
    client.send("Hello from ESP32!");
    lastSend = millis();
  }
}

Configuration Comparison

Setting	PC Server	Arduino ESP32 Client
Host IP	192.168.1.100	Specify PC's IP (e.g., 192.168.1.100)
Port	8080	8080
Ping Interval	5 seconds	Handled by library or manual setup
Ping Timeout	5 seconds	Handled by library or manual setup
Security	ws:// or wss://	ws:// or wss:// based on server
Message Format	JSON, Plain Text, etc.	JSON, Plain Text, etc.

---

Conclusion

Successfully configuring a WebSocket connection between a Windows PC and an Arduino ESP32 involves meticulous alignment of server settings and client configurations. By ensuring compatibility in ping intervals, handling ping/pong mechanisms effectively, maintaining non-blocking communication, and implementing robust error handling, you can achieve a stable and reliable connection. Regular monitoring and adhering to best practices further enhance the resilience and performance of your WebSocket communications in IoT applications.

References