-
2025 ESP32 WiFi and Bluetooth Networking Guide by webXOS 2025 (webxos.netlify.app)
-
-
Introduction to ESP32 WiFi Technical Breakdown
-
- To implement a Wi-Fi sensing system using an ESP32 for data collection and a laptop for processing, you will need to set up both devices to communicate over a local network. This guide uses the Arduino IDE for the ESP32 and Python for the laptop's processing software.
-
-
-
Prerequisites
-
- - An ESP32 development board.
- - A laptop with Wi-Fi capability.
- - The latest Arduino IDE installed.
- - Python 3 installed on your laptop.
- - Basic knowledge of Arduino programming and Python.
-
-
-
ESP32 Wi-Fi and Bluetooth Networking Guide
-
- For ESP32 Wi-Fi and Bluetooth networking using the Arduino IDE, you will configure the ESP32 to run in dual mode (Wi-Fi Station and Bluetooth Classic server), allowing for network connectivity for data streaming and a Bluetooth serial connection for control or debugging. The ESP32's single radio manages both, so actual simultaneous transmission is time-multiplexed by the hardware, which generally works seamlessly for many applications.
-
-
-
Prerequisites
-
- - Arduino IDE installed on your laptop.
- - ESP32 board support installed in the Arduino IDE. Add the appropriate package URL to the "Additional Boards Manager URLs" in File > Preferences, then search for and install "esp32 by Espressif Systems" in the Tools > Board > Boards Manager.
- - A laptop connected to the same Wi-Fi network as the ESP32 will be.
- - Basic knowledge of Arduino programming and Python scripting.
-
-
-
Step 1: Configure the ESP32 with Arduino IDE (Wi-Fi and Bluetooth)
-
- Upload the following sketch to your ESP32 board. This code initializes both Wi-Fi in station mode and Bluetooth Classic as a serial device.
-
-
- -Open the Arduino IDE.
- -Go to Tools > Board and select your specific ESP32 board (e.g., ESP32 Dev Module).
- -Connect your ESP32 to your laptop via a USB cable. Go to Tools > Port and select the appropriate COM port.
- -Copy and paste the code below into a new sketch:
-
-
-#include "BluetoothSerial.h"
-#include <WiFi.h>
-
-// Replace with your network credentials
-const char* ssid = "YOUR_SSID";
-const char* password = "YOUR_WIFI_PASSWORD";
-
-BluetoothSerial SerialBT;
-
-void setup() {
- Serial.begin(115200);
- Serial.println("\nStarting ESP32 Dual Mode (WiFi & Bluetooth)");
-
- // Start Bluetooth serial with a device name
- SerialBT.begin("ESP32_CSI_Sensor"); // Bluetooth device name
- Serial.println("Bluetooth started. You can pair with the device named ESP32_CSI_Sensor");
-
- // Connect to Wi-Fi
- WiFi.mode(WIFI_STA); // Set the ESP32 to Station mode
- WiFi.begin(ssid, password);
- Serial.print("Connecting to WiFi ..");
- while (WiFi.status() != WL_CONNECTED) {
- Serial.print('.');
- delay(1000);
- }
- Serial.println("\nConnected to WiFi network!");
- Serial.print("IP Address: ");
- Serial.println(WiFi.localIP()); // Print the assigned IP address
-}
-
-void loop() {
- // Handle Bluetooth communication
- if (SerialBT.available()) {
- // Read from Bluetooth and potentially process commands or data
- Serial.write(SerialBT.read());
- }
-
- // Handle WiFi communication (your CSI data streaming logic would go here)
- // This is where you would implement the code to collect CSI data
- // and send it to your laptop's IP address over the network.
-}
-
-
- Update YOUR_SSID and YOUR_WIFI_PASSWORD with your actual network credentials.
-
-
- Upload the code to your ESP32. If the board gets stuck at the "Connecting..." screen, press the on-board EN (reset) or BOOT button for a second after it starts connecting.
-
-
- Open the Serial Monitor at a baud rate of 115200 to monitor the connection status and the assigned IP address.
-
-
-
Step 2: Set Up Your Laptop for Data Processing
-
- Your laptop needs software to receive the data from the ESP32. For Wi-Fi-based data streaming, a simple Python script can act as a server to listen for incoming connections or UDP packets.
-
-
- Install Python: If not already installed, download it from the official Python website.
-
-
- Create a Python script to receive data (e.g., data_receiver.py). This simple script listens for UDP packets.
-
-
-import socket
-
-# Use the IP address printed in the Arduino Serial Monitor
-
-UDP_IP = "YOUR_ESP32_IP_ADDRESS"
-UDP_PORT = 12345 # Must match the port used in your Arduino code for sending data
-
-sock = socket.socket(socket.AF_INET, # Internet
- socket.SOCK_DGRAM) # UDP
-sock.bind((UDP_IP, UDP_PORT))
-
-print(f"Listening for UDP data on {UDP_IP}:{UDP_PORT}...")
-
-while True:
- data, addr = sock.recvfrom(1024) # Buffer size is 1024 bytes
- print(f"Received message from {addr}: {data.decode()}")
-
-
- Update YOUR_ESP32_IP_ADDRESS with the IP address shown in the Arduino Serial Monitor.
-
-
-
Step 3: Test Networking
-
- Wi-Fi: You would add code to the Arduino sketch's loop() function to send data to the laptop's IP address (not shown here, as it requires specific CSI libraries). Run the Python script on your laptop, and it should display the received data.
-
-
- Bluetooth: On your laptop, you can use a Bluetooth serial terminal application (or a Python script using a library like pyserial) to connect to the "ESP32_CSI_Sensor" device. Any data sent from the laptop via the Bluetooth terminal will appear in the Arduino Serial Monitor.
-
-
- This guide provides the dual-mode framework; you will need to incorporate the specific code from the CSI or ESPectre project to collect and stream the Channel State Information data over the established Wi-Fi network.
-
-
-
ESP32 Connection (Station Mode)
-
- The ESP32 can be configured in "Station mode" (STA) to connect to an existing Wi-Fi network, such as the one provided by your home router or a mobile hotspot created by your laptop. This allows the ESP32 to send data to, and receive requests from, other devices on the same local network, including your laptop.
-
-
-
Web Page Interface
-
- You can host an HTML web page directly on the ESP32 itself. Your laptop's web browser can then access this page by navigating to the ESP32's assigned IP address on the local network. This page can display the data, provide controls, or serve as a user interface for the presence detection system.
-
-
-
CSI Data
-
- The ESP32 is capable of capturing CSI data.
-
-
- - The project usually involves the ESP32 gathering this data and sending it to a processing unit (your laptop, or typically a Home Assistant instance or a dedicated server) over the network.
- - The laptop needs the appropriate software (likely Python scripts provided by the ESPectre project) to receive, process, and interpret the raw CSI data stream from the ESP32 to determine presence.
- - Network Setup: The simplest setup involves both the ESP32 and the laptop connecting to the same standard Wi-Fi router. The ESP32 sends the CSI data packets to the laptop's IP address on this network.
-
-
-
Summary
-
- The single ESP32 and laptop setup is feasible. The ESP32 acts as a sensor and a web server client/server, while the laptop acts as the data processing and visualization center. The standard Wi-Fi network is the communication backbone. You will need to program the ESP32 to connect to your Wi-Fi network and stream the CSI data, and set up your laptop to receive and process this data, potentially through a web interface or a dedicated application.
-
-
-
Creating a Web Interface to Control a Wi-Fi Drone
-
- Creating a web interface to control a Wi-Fi drone involves an HTML front-end for the user interface and JavaScript to handle connectivity and send commands, typically using WebSockets for real-time communication. The drone or an attached companion computer (like an ESP32 or Raspberry Pi) needs to run a server to receive these commands.
-
-
-
Connection and Architecture Overview
-
- - Connect to the Drone's Network: First, your controlling device (computer, phone, tablet) must connect to the Wi-Fi network hosted by the drone or its controller board (e.g., an ESP32 as an Access Point). The network name (SSID) is often provided in the drone's documentation (e.g., TELLO-xxxx or quadcopter).
- - Web Server: The drone's companion computer runs a web server that hosts the HTML page and opens a WebSocket connection for real-time data exchange.
- - Communication Protocol: WebSockets provide a persistent, bidirectional communication channel between your browser and the drone, which is essential for low-latency control.
-
-
-
Guide to the HTML Page and Code
-
- Below is a basic guide and an HTML structure using JavaScript for connecting and sending simple commands.
-
-
-
1. Basic HTML Structure
-
- This single HTML file will contain the user interface and all the necessary JavaScript code.
-
-
-<!DOCTYPE html>
-<html lang="en">
-<head>
- <meta charset="UTF-8">
- <meta name="viewport" content="width=device-width, initial-scale=1.0">
- <title>Wi-Fi Drone Controller</title>
- <style>
- body { font-family: sans-serif; text-align: center; }
- .controls button { margin: 10px; padding: 10px 20px; font-size: 16px; }
- #status { margin-top: 20px; font-weight: bold; }
- </style>
-</head>
-<body>
- <h1>Drone Control Interface</h1>
- <div id="status">Status: Disconnected</div>
-
- <button onclick="connectWebSocket()">Connect to Drone</button>
-
- <div class="controls">
- <h2>Flight Controls</h2>
- <button onclick="sendCommand('takeoff')">Take Off</button>
- <button onclick="sendCommand('land')">Land</button>
- <button onclick="sendCommand('up 20')">Up 20cm</button>
- <button onclick="sendCommand('down 20')">Down 20cm</button>
- <button onclick="sendCommand('forward 50')">Forward 50cm</button>
- </div>
-
- <script src="drone_control.js"></script>
-</body>
-</html>
-
-
-
2. JavaScript (drone_control.js)
-
- You'll need a separate JavaScript file (drone_control.js) to handle the WebSocket connection and command sending logic.
-
-
-let socket;
-const statusDiv = document.getElementById('status');
-// Change this to the IP address of your drone or ESP32 board
-// Common default IPs include 192.168.4.1 or 192.168.2.1
-const DRONE_IP = 'ws://192.168.4.1/ws'; // Use ws:// for WebSocket protocol
-
-function connectWebSocket() {
- statusDiv.textContent = 'Status: Connecting...';
- socket = new WebSocket(DRONE_IP);
-
- socket.onopen = function(event) {
- statusDiv.textContent = 'Status: Connected';
- console.log('WebSocket connection opened:', event);
- };
-
- socket.onmessage = function(event) {
- console.log('Message from drone:', event.data);
- // Handle telemetry data or confirmation messages here
- };
-
- socket.onclose = function(event) {
- statusDiv.textContent = 'Status: Disconnected';
- console.log('WebSocket connection closed:', event);
- };
-
- socket.onerror = function(error) {
- statusDiv.textContent = 'Status: Error';
- console.error('WebSocket error:', error);
- };
-}
-
-function sendCommand(command) {
- if (socket && socket.readyState === WebSocket.OPEN) {
- socket.send(command);
- console.log('Sent command:', command);
- } else {
- alert('Not connected to the drone. Click "Connect to Drone" first.');
- }
-}
-
-
-
Streaming CSI Data from ESP32 to Laptop over Wi-Fi
-
- Channel State Information (CSI) data from an ESP32 to a laptop over Wi-Fi requires a specialized ESP32 firmware/toolkit, such as the ESP32-CSI-Tool or the ESP32-CSI-Collection-and-Display tool. These projects provide the necessary code for both the ESP32 (typically using ESP-IDF, but wrappers exist for Arduino) and the laptop (Python scripts for processing). The data is commonly sent via UDP packets due to the high volume of real-time information.
-
-
-
Key Components
-
- - ESP32 Firmware: Configured to capture CSI data and stream it over Wi-Fi using the UDP protocol.
- - Laptop Receiver: A Python script running on your laptop to listen for UDP packets, parse the raw data, and perform analysis.
- - Network: Both the ESP32 and laptop must be on the same Wi-Fi network.
-
-
-
Step 1: Set up the ESP32 Firmware (Conceptual Example)
-
- You'll need to use specific libraries to access the raw CSI from the ESP32's Wi-Fi chip. A full, ready-to-flash Arduino sketch is complex and depends heavily on these external libraries, but the logic would look like this:
-
-
-#include <WiFi.h>
-#include <esp_wifi.h>
-#include <esp_wifi_types.h>
-#include <esp_csi_internal.h> // Header for internal CSI functions
-
-// ... (your Wi-Fi credentials and UDP setup code) ...
-WiFiUDP Udp;
-IPAddress laptopIP(192, 168, 1, 10); // !! REPLACE with your laptop's actual IP !!
-const unsigned int localPort = 12345;
-const unsigned int remotePort = 12345;
-
-void setup() {
- // ... (Serial and Wi-Fi connection setup from the previous guide) ...
-
- // Configure CSI here (requires specific library functions)
- // esp_wifi_set_csi(true);
- // esp_wifi_set_csi_cb(on_csi_receive, NULL); // A callback function to handle received CSI
-
- Serial.println("CSI collection enabled and streaming to laptop...");
-}
-
-// A placeholder for the actual CSI callback function
-void on_csi_receive(void *ctx, wifi_csi_info_t *data) {
- if (data != NULL) {
- // Process the raw 'data->buf' (amplitude, phase, etc.)
- // Package it into a string or byte array
- // Udp.beginPacket(laptopIP, remotePort);
- // Udp.write(packagedData);
- // Udp.endPacket();
- }
-}
-
-void loop() {
- // Main loop remains empty as data is handled in the callback
-}
-
-
- Note: The actual implementation for collecting CSI is non-trivial within the standard Arduino framework and generally requires using specific open-source tools' libraries or the ESP-IDF framework. It involves low-level Wi-Fi stack access.
-
-
-
Step 2: Set Up the Laptop Receiver
-
- This Python script will listen for the UDP packets sent by the ESP32 and print the raw data to the console.
-
-
-import socket
-
-UDP_IP = "0.0.0.0" # Listen on all available interfaces
-UDP_PORT = 12345 # Must match the port used in your Arduino code
-
-sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-sock.bind((UDP_IP, UDP_PORT))
-
-print(f"Listening for raw CSI data on UDP port {UDP_PORT}...")
-
-while True:
- # Receive data packet
- data, addr = sock.recvfrom(2048) # Buffer size large enough for a CSI packet
- # The 'data' variable now holds the raw byte stream from the ESP32
- print(f"Received packet from {addr}, size: {len(data)} bytes")
- # You would use a data parsing library (often specific to the toolkit used)
- # to convert the raw bytes into meaningful CSI amplitudes/phases.
-
-
-
Step 3: Run the System
-
- - Flash your ESP32 with the correct CSI-enabled firmware.
- - Connect your laptop and ESP32 to the same Wi-Fi network.
- - Ensure you know the IP addresses of both devices and configure them in their respective code/scripts.
- - Run the Python script on your laptop first.
- - Power up the ESP32.
-
-
- You should start seeing received data packets printed in your laptop's Python console in real time. The crucial next step (data parsing and processing) depends entirely on the specific format of the raw data stream defined by the ESP32 firmware you choose to use.
-
-
-
-
-
Webxos - Copyright Information
-
© 2025 webXOS Research and Development. All rights reserved.
-
-
Disclaimer: OPEN SOURCED UNDER MIT LICENSE. All script ideas, concepts, and implementations featured on this site are the intellectual property of WEBXOS. Unauthorized use, reproduction, or distribution of any script idea or related content is strictly prohibited. By accessing this website, you agree to respect and adhere to these copyright laws.
-
-
-
BACK
-
GUIDE
-
-
CONTROLS:
-
DESKTOP:
-
• WASD/Arrow Keys = Move
-
• Mouse Left Click = Fire
-
• ESC = Pause Menu
-
-
MOBILE:
-
• TAP ZONES for directional thrust
-
• TILT DEVICE for fine movement
-
• TAP FIRE button to shoot
-
-
CONTROLLER:
-
• Left Stick = Move
-
• A Button = Fire
-
-
VR MODE:
-
• Head movement = Look around
-
• VR Controller = Move and shoot
-
-
OBJECTIVE:
-
Destroy enemy drones and navigate through the rainbow tunnel.
-
Collect neon green stars to activate speed boost (1.3x speed for 5 seconds).
-
Each tunnel cleared without touching walls adds to your score.
-
-
SCORING:
-
• Drone Destroyed: +25 points
-
• Speed Star Collected: +100 points + Speed Boost
-
• Tunnel Cleared: +50 points
-
• Straight Clear Bonus: +5 points
-
• Speed Multiplier: 1.3x speed
-
-
FEATURES:
-
• One green star every segment for speed boost
-
• 2-4 red drones per segment
-
• 2-3 planets per segment outside tunnels
-
• Multiple Control Schemes: Mobile, Desktop, Controller and VR
-
• Sensitivity Settings: Adjust controller responsiveness
-
• Invert Y Axis: For players who prefer inverted controls
-
-
-
WebXOS SWARM: Revolutionizing Drone Swarm Operations in GPS-Denied Environments
-
-
-
Introduction
-
- In modern warfare and critical missions, drone swarms are transforming operational capabilities, offering scalability, resilience, and adaptability. However, environments where GPS signals are jammed or unavailable pose significant challenges to swarm coordination and navigation. WebXOS's SWARM application, a pure front-end solution with no backend reliance, addresses these challenges by enabling autonomous, resilient drone operations. This case study explores how WebXOS SWARM integrates with platforms like Anduril's Lattice to enhance drone swarm performance in signal-jammed scenarios, leveraging micro language models (LMs) like Watchdog AI and Exoskeleton AI for autonomous mapping and emergency backup modes.
-
-
-
-
-
Challenge: Signal Jamming and GPS-Denied Environments
-
- Drone swarms typically rely on GPS for navigation and coordination. In hostile environments, adversaries can deploy signal jamming to disrupt GPS and communication signals, rendering traditional swarm operations ineffective. Key challenges include:
-
-
- - Lack of real-time GPS coordinates for navigation and path planning.
- - Disrupted inter-drone communication, hindering swarm coordination.
- - Inability to rely on backend servers for data processing in contested environments.
- - Need for rapid, autonomous adaptation to dynamic terrains and mission requirements.
-
-
- These challenges necessitate a solution that enables drones to operate independently, maintain coordination, and execute missions without external dependencies.
-
-
-
-
-
Solution: WebXOS SWARM Technology
-
Overview of WebXOS SWARM
-
- WebXOS's SWARM application is a lightweight, front-end-only software designed to run on individual drones, eliminating the need for backend infrastructure. Built for mobile optimization, SWARM leverages onboard processing and micro LMs to enable autonomous decision-making and coordination. Its key features include:
-
-
- - Pure Front-End Architecture: Operates without reliance on cloud or ground control stations, ensuring functionality in signal-jammed environments.
- - Micro LMs (Watchdog AI & Exoskeleton AI): Lightweight AI models for real-time terrain analysis, obstacle avoidance, and decision-making.
- - Autonomous Mapping: Generates local maps using onboard sensors (e.g., stereo cameras, LiDAR) for navigation in GPS-denied settings.
- - Swarm Coordination: Utilizes peer-to-peer communication protocols (e.g., Wi-Fi, Bluetooth) for decentralized swarm behavior.
- - Emergency Backup Mode: Activates pre-trained models to maintain operations during complete signal loss.
-
-
-
Integration with Anduril Lattice
-
- Anduril's Lattice platform is a robust system for coordinating sensors and weapons, including drone swarms, through integrated visualization and control. By integrating WebXOS SWARM with Lattice, drones gain enhanced autonomy and resilience. The integration process involves:
-
-
- - Local Processing Augmentation: WebXOS SWARM runs on each drone, processing sensor data locally to reduce reliance on Lattice's centralized systems in jammed environments.
- - Hybrid Coordination: Lattice provides high-level mission planning, while SWARM handles real-time, drone-level decisions, ensuring seamless operation during communication disruptions.
- - Data Sharing: SWARM's autonomous mapping data can feed into Lattice's battlefield visualization, enhancing situational awareness without requiring constant connectivity.
- - Training Synergy: SWARM's micro LMs are trained on terrain data from Lattice's simulations, enabling drones to adapt to complex mission paths.
-
-
-
-
-
Implementation: Enhancing Drone Swarm Operations
-
Autonomous Mapping in GPS-Denied Environments
-
- WebXOS SWARM uses computer-vision-based approaches, such as stereo cameras and depth mapping, to create real-time terrain models. In GPS-denied scenarios, drones rely on:
-
-
- - Watchdog AI: Monitors environmental changes and detects obstacles, enabling dynamic path adjustments.
- - Exoskeleton AI: Optimizes swarm formation and task allocation based on local sensor data, ensuring cohesive operation.
- - Pre-Trained Terrain Models: Drones are trained on mission-specific terrains using simulated data, allowing them to navigate sensitive paths autonomously.
-
-
- This approach renders signal jamming ineffective, as drones operate independently of external signals, relying solely on onboard processing and pre-trained models.
-
-
-
Emergency Backup Mode
-
- In the event of complete signal loss, SWARM activates an emergency backup mode, leveraging micro LMs to:
-
-
- - Maintain swarm cohesion through local communication protocols (e.g., Zigbee, Bluetooth).
- - Execute pre-planned mission objectives using stored terrain maps.
- - Adapt to unexpected obstacles using real-time sensor data and AI-driven decision-making.
-
-
- This mode ensures mission continuity, even in the most contested environments, making WebXOS SWARM a critical asset for sensitive operations.
-
-
-
Speed and Accuracy Improvements
-
- By combining SWARM's local processing with Lattice's strategic oversight, drones achieve:
-
-
- - Faster Response Times: Local decision-making reduces latency compared to backend-dependent systems.
- - Higher Accuracy: Micro LMs process sensor data in real-time, improving navigation precision in complex terrains.
- - Resilience: Decentralized architecture ensures swarm functionality despite individual drone failures or signal disruptions.
-
-
-
-
-
Case Study Example: Search and Rescue in a Jammed Environment
-
- Consider a search and rescue mission in a dense forest where GPS signals are jammed due to hostile interference. A swarm of 20 drones equipped with WebXOS SWARM and integrated with Anduril Lattice is deployed to locate survivors. The implementation unfolds as follows:
-
-
- - Pre-Mission Training: SWARM's micro LMs are trained on simulated forest terrain data provided by Lattice, enabling drones to recognize obstacles and plan paths.
- - Deployment: Drones launch with Lattice providing initial waypoints. SWARM takes over for real-time navigation using stereo cameras and depth mapping.
- - Signal Jamming: When GPS and communication signals are jammed, SWARM's emergency backup mode activates, using Watchdog AI to detect obstacles and Exoskeleton AI to maintain swarm formation.
- - Autonomous Mapping: Drones generate local maps, sharing data via peer-to-peer protocols to track survivors and avoid collisions.
- - Outcome: The swarm locates 90% of survivors within 45 minutes, compared to hours for traditional methods, demonstrating superior speed and reliability.
-
-
- This example highlights how WebXOS SWARM enhances mission success in challenging environments, complementing Lattice's capabilities.
-
-
-
-
-
Benefits and Future Potential
-
- The integration of WebXOS SWARM with Anduril Lattice offers significant advantages:
-
-
- - Signal Immunity: Drones operate effectively in GPS-denied and jammed environments.
- - Scalability: SWARM's lightweight design supports swarms of varying sizes, from a few drones to thousands.
- - Cost Efficiency: Eliminates the need for backend infrastructure, reducing operational costs.
- - Adaptability: Micro LMs enable rapid adaptation to dynamic mission requirements.
-
-
- Future developments could include enhanced AI models for predictive path planning and integration with other platforms for multi-domain operations (e.g., ground and marine drones). WebXOS is also exploring advanced computer vision and sensor fusion to further improve autonomous mapping accuracy.
-
-
-
-
-
Conclusion
-
- WebXOS SWARM represents a paradigm shift in drone swarm technology, offering a robust, front-end-only solution for GPS-denied and signal-jammed environments. By integrating with Anduril's Lattice, SWARM enhances the speed, accuracy, and resilience of drone operations, enabling missions in the most challenging conditions. With micro LMs like Watchdog AI and Exoskeleton AI, SWARM empowers drones to operate autonomously, map terrains in real-time, and maintain swarm cohesion without external dependencies. As drone warfare and critical missions evolve, WebXOS SWARM is poised to lead the way in autonomous, resilient swarm operations.
-
-
- For more information, visit WebXOS SWARM or Anduril Lattice.
-
-
-
-
-