Websocket from ESP32 to Python: A Slow but Steady Guide

Welcome to the world of real-time communication! In this article, we’ll embark on a fascinating journey to connect an ESP32 microcontroller to a Python server using WebSockets. Yes, you read that right – we’ll be taking it slow and steady to ensure you grasp every concept and can implement it in your projects. So, buckle up and let’s dive in!

What are WebSockets?

Before we start, let’s quickly recap what WebSockets are. WebSockets are a bi-directional, real-time communication protocol that allows a client and server to communicate over the web. They enable efficient, low-latency communication, making them perfect for applications that require real-time updates, such as live chats, gaming, and IoT projects.

Why ESP32 and Python?

The ESP32 is a powerful microcontroller that’s perfect for IoT projects. Its built-in Wi-Fi capabilities, combined with its low cost and ease of use, make it an ideal choice for many applications. Python, on the other hand, is a popular and versatile programming language that’s widely used for IoT development. By combining the two, we can create powerful, connected devices that can communicate with a server in real-time.

Hardware Requirements

To follow along with this tutorial, you’ll need the following hardware:

• ESP32 microcontroller (any model will do)
• USB cable for programming the ESP32
• A computer with Python installed
• A network connection (Wi-Fi or Ethernet)

Software Requirements

You’ll need to install the following software:

• Arduino IDE (for programming the ESP32)
• Python 3.x (we’ll be using Python 3.9 in this tutorial)
• The `websocket-client` library for Python (we’ll install this later)

Setting up the ESP32

Let’s start by setting up the ESP32. If you’re new to the ESP32, don’t worry – it’s easy to get started!

First, connect your ESP32 to your computer using a USB cable. Then, open the Arduino IDE and select the correct board and port from the Tools menu:

Tools > Board > ESP32 Dev Module
Tools > Port > [Select the correct port]

Next, install the WebSocket library for the ESP32. In the Arduino IDE, go to:

Sketch > Include Library > Manage Libraries

Search for “WebSocket” and install the “WebSocket by Links2004” library:

WebSocket by Links2004
Version: 2.3.5

ESP32 WebSocket Client Code

Now that we have the WebSocket library installed, let’s create a simple WebSocket client code for the ESP32. Create a new sketch in the Arduino IDE and paste the following code:

#include <WiFi.h>
#include <WebSocket.h>

const char* ssid = "your_wifi_ssid";
const char* password = "your_wifi_password";

WiFiClient client;
WebSocket websocket(client);

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

  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(1000);
    Serial.println("Connecting to WiFi...");
  }

  Serial.println("Connected to WiFi");
  Serial.println("Initializing WebSocket...");

  websocket.begin("ws://your_python_server_ip:port"); // Replace with your Python server IP and port
  websocket.onEvent(onEvent);
}

void loop() {
  websocket.loop();
  delay(10);
}

void onEvent(WebSocketEvent event) {
  switch (event.type) {
    case WStype_DISCONNECTED:
      Serial.println("Disconnected from WebSocket");
      break;
    case WStype_CONNECTED:
      Serial.println("Connected to WebSocket");
      break;
    case WStype_TEXT:
      Serial.println("Received text from WebSocket:");
      Serial.println(event.text);
      break;
    case WStype_BIN:
      Serial.println("Received binary data from WebSocket:");
      Serial.println(event.bin.length());
      break;
    case WStype_ERROR:
      Serial.println("Error occurred on WebSocket:");
      Serial.println(event.error);
      break;
  }
}

Replace `your_wifi_ssid` and `your_wifi_password` with your Wi-Fi credentials. Also, replace `ws://your_python_server_ip:port` with the IP address and port of your Python server (we’ll set this up later).

Setting up the Python Server

Now that we have the ESP32 client code ready, let’s set up a Python server to receive WebSocket connections.

First, install the `websocket-client` library using pip:

pip install websocket-client

Create a new Python script (e.g., `websocket_server.py`) and paste the following code:

import asyncio
import websockets

async def handle_connection(websocket, path):
    print(f"New connection from {path}")

    while True:
        try:
            message = await websocket.recv()
            print(f"Received message: {message}")

            # Send a response back to the client
            response = f"Server received: {message}"
            await websocket.send(response)
        except websockets.ConnectionClosed:
            print("Connection closed")
            break

async def main():
    async with websockets.serve(handle_connection, "localhost", 8765):
        print("WebSocket server started on port 8765")
        await asyncio.Future()  # run forever

asyncio.run(main())

This code sets up a simple WebSocket server that listens on port 8765. When a new connection is established, it prints a message and waits for incoming messages from the client. When a message is received, it sends a response back to the client.

Running the Project

Now that we have both the ESP32 client and Python server code ready, let’s run the project!

First, upload the ESP32 client code to your ESP32 board using the Arduino IDE. Once uploaded, open the Serial Monitor to see the debug output.

Next, run the Python server script using Python:

python websocket_server.py

This will start the WebSocket server on port 8765. You should see a message indicating that the server has started.

Now, go back to the Serial Monitor on the ESP32 and you should see a message indicating that the WebSocket connection has been established. You can then send messages from the ESP32 to the Python server using the `websocket.send()` function:

void loop() {
  websocket.loop();
  delay(10);

  if (millis() % 1000 == 0) {
    char message[20];
    sprintf(message, "Hello from ESP32! %d", millis());
    websocket.send(message);
  }
}

This code sends a message from the ESP32 to the Python server every second. You should see the message received on the Python server side:

Received message: Hello from ESP32! 1000
Received message: Hello from ESP32! 2000
Received message: Hello from ESP32! 3000
...

Troubleshooting

If you encounter any issues during the project, here are some common troubleshooting steps:

• Check your Wi-Fi connection: Ensure that your ESP32 is connected to the same Wi-Fi network as your Python server.
• Verify the WebSocket library: Make sure you have the correct WebSocket library installed on your ESP32.
• Check the Python server IP and port: Ensure that the IP address and port in the ESP32 code match the Python server’s IP and port.
• Check for firewall issues: If you’re running the Python server on a remote machine, ensure that the firewall allows incoming WebSocket connections.

Conclusion

And that’s it! You’ve successfully connected your ESP32 to a Python server using WebSockets. This is just the beginning of your real-time communication journey. You can now explore more advanced topics, such as implementing authentication, handling multiple clients, and optimizing performance.

Remember, the key to mastering WebSockets is to take it slow and steady. Experiment with different scenarios, and don’t be afraid to try new things. Happy coding!

Keyword	Description
WebSocket	A bi-directional, real-time communication protocol
ESP32	A microcontroller with built-in Wi-Fi capabilities
Python	A popular programming language for IoT development
websocket-client	A Python library for WebSocket communication

This article provides a comprehensive guide to

Frequently Asked Question

Get ready to unravel the mysteries of WebSockets from ESP32 to Python and troubleshoot the speed issues!