WiFi Hardware Compatible with WiFi DensePose: A Complete Guide to CSI-Capable Routers and NICs

WiFi DensePose requires WiFi hardware that exposes Channel State Information (CSI), specifically Atheros-based routers like the TP-Link Archer C7/C9 or Intel 5300 NICs, which the system auto-discovers via the UnifiedRouterInterface class.

WiFi DensePose is an open-source project by ruvnet/wifi-densepose that estimates human pose using WiFi signals. To function, the system depends on specific WiFi hardware compatible with WiFi DensePose that can extract raw Channel State Information (CSI) from wireless packets.

What Makes WiFi Hardware Compatible with WiFi DensePose?

Compatible devices must expose Channel State Information (CSI) through debug filesystems or modified drivers. The wifi-densepose repository implements a Hardware Abstraction Layer (HAL) that standardizes access to these devices, allowing the system to work with any router or NIC that provides CSI data via /sys/kernel/debug/ieee80211/.../csi_* entries.

Officially Supported WiFi Hardware for WiFi DensePose

The project maintains explicit support for several chipsets and router families through driver-specific implementations in plans/phase2-architecture/hardware-integration.md.

Atheros-Based Routers (Recommended)

Atheros chipsets are the primary target for WiFi DensePose due to robust OpenWRT support and stable CSI extraction. Compatible models include:

• TP-Link Archer C7/C9
• Netgear Nighthawk R7000
• ASUS RT-AC68U
• Linksys WRT1900ACS

These routers run the csi_streamer utility on the device itself, which UDP-streams raw CSI packets to the host machine for processing by the AtherosDriver class.

Intel 5300 NIC

The Intel 5300 mini-PCIe network interface card is explicitly supported through the Intel5300Driver and Intel5300CSIFormat parser. This NIC is commonly used in research environments and connects directly to the host machine rather than operating as a remote router.

Broadcom and Other CSI-Capable Chips

The HAL architecture supports extensibility for Broadcom and other chipsets that expose CSI through driver extensions. Adding support requires implementing the corresponding driver class and extending the RouterConfiguration map in the hardware integration layer.

How WiFi DensePose Detects and Configures Compatible Hardware

The UnifiedRouterInterface class in plans/phase2-architecture/hardware-integration.md handles automatic discovery and configuration of WiFi hardware compatible with WiFi DensePose.

The discovery process follows these steps:

1. Network Scanning: discover_routers() scans the local network (default 192.168.1.0/24) for SSH-accessible devices.
2. Router Identification: _identify_router() checks for OpenWRT installations and the presence of CSI debug files (csi_enable, csi_rate).
3. Driver Selection: Based on the identified chipset, the system instantiates the appropriate driver (AtherosDriver or Intel5300Driver).
4. Configuration: RouterConfiguration supplies firmware-specific commands to enable monitor mode and activate CSI streaming.

Listing Compatible Routers on Your Network

from wifi_densepose.hardware import UnifiedRouterInterface
import asyncio

async def list_routers():
    router_iface = UnifiedRouterInterface()
    routers = await router_iface.discover_routers(network_range="192.168.1.0/24")
    for r in routers:
        print(f"{r['ip']} – {r['model']} ({r['type']})")

asyncio.run(list_routers())

This script prints discovered devices such as 192.168.1.12 – ASUS RT‑AC68U (atheros).

Connecting to WiFi Hardware and Extracting CSI Data

Once a compatible router is identified, the connect_router() method establishes the connection and initiates CSI streaming. The HardwareService in v1/src/services/hardware_service.py orchestrates this process.

import asyncio
from wifi_densepose.hardware import UnifiedRouterInterface

async def start_csi(router_info):
    iface = UnifiedRouterInterface()
    router_id = await iface.connect_router(router_info)
    print(f"Router {router_id} streaming CSI → queue")
    
    # Pull a single CSI sample

    csi = await iface.get_csi_data(router_id)
    print("Timestamp:", csi["timestamp"], "Matrix shape:", csi["csi_matrix"].shape)

# Example usage

router_info = {
    "ip": "192.168.1.12",
    "type": "atheros",
    "channel": 6,
    "model": "ASUS RT‑AC68U",
    "firmware": "openwrt"
}
asyncio.run(start_csi(router_info))

The CSI data flows through csi_extractor.py, which parses the UDP stream into NumPy matrices using format-specific parsers (AtherosCSIFormat or Intel5300CSIFormat).

Configuring Custom WiFi Interfaces

By default, WiFi DensePose uses wlan0 as the WiFi interface. You can change this via the Settings class in v1/src/config/settings.py:

from wifi_densepose.config import Settings

settings = Settings()
settings.wifi_interface = "wlan1"
settings.save()
print(f"Wi‑Fi interface set to {settings.wifi_interface}")

The HardwareService automatically picks up this configuration on the next application start, passing the interface name to the HAL for monitor mode configuration.

Key Implementation Files for WiFi Hardware Compatibility

The following files in the ruvnet/wifi-densepose repository define how the system interacts with compatible WiFi hardware:

• README.md – Quick reference list of tested routers and NICs under the Supported Hardware section.
• plans/phase2-architecture/hardware-integration.md – Complete hardware integration architecture, including the RouterConfiguration dictionary and UnifiedRouterInterface class implementation.
• v1/src/services/hardware_service.py – Service that reads wifi_interface from settings and initializes the HAL.
• v1/src/hardware/router_interface.py – Low-level SSH-based commands for router configuration and driver management.
• v1/src/hardware/csi_extractor.py – Parses raw CSI packets from UDP streams into structured NumPy arrays.
• v1/src/config/settings.py – Configuration management for WiFi interface names and hardware parameters.

Summary

• WiFi DensePose requires CSI-capable WiFi hardware, specifically Atheros-based routers (TP-Link Archer C7/C9, ASUS RT-AC68U, Netgear R7000) or Intel 5300 NICs.
• The UnifiedRouterInterface class automatically discovers compatible routers on your network via SSH scanning and identifies CSI capability through debug filesystem checks.
• Driver abstraction via AtherosDriver and Intel5300Driver classes allows the system to parse CSI streams from different hardware without changing application code.
• Configuration is managed through v1/src/config/settings.py, defaulting to wlan0 but supporting custom interface names.
• Adding new hardware requires extending the RouterConfiguration map and implementing the corresponding driver class in the hardware abstraction layer.

Frequently Asked Questions

Can I use any WiFi router with WiFi DensePose?

No, you cannot use any standard WiFi router. WiFi DensePose requires routers or NICs that expose Channel State Information (CSI) through debug filesystems like /sys/kernel/debug/ieee80211/. Consumer routers without modified firmware (such as OpenWRT) or specific chipsets (primarily Atheros) will not work with the system.

What is the best WiFi hardware for WiFi DensePose?

The Atheros-based routers are the most recommended WiFi hardware compatible with WiFi DensePose, specifically the TP-Link Archer C7/C9, ASUS RT-AC68U, and Netgear Nighthawk R7000. These devices offer stable OpenWRT support, reliable CSI extraction via the csi_streamer utility, and are explicitly tested in the RouterConfiguration definitions within the hardware integration architecture.

How does WiFi DensePose handle different WiFi drivers?

WiFi DensePose uses a Hardware Abstraction Layer (HAL) with driver-specific classes like AtherosDriver and Intel5300Driver. The UnifiedRouterInterface automatically selects the appropriate driver based on router identification during the discovery phase. Each driver implements format-specific parsers (AtherosCSIFormat, Intel5300CSIFormat) to convert raw UDP packets into standardized NumPy matrices, allowing the pose estimation pipeline to remain agnostic to the underlying WiFi hardware.

Can I use a USB WiFi dongle instead of a router?

Yes, you can use a USB WiFi dongle if it contains a CSI-capable chipset (such as specific Atheros or Intel 5300 chips) and supports monitor mode on Linux. However, most consumer USB dongles lack CSI extraction capabilities. For WiFi DensePose, you would configure the dongle's interface name (e.g., wlan1) in v1/src/config/settings.py instead of using a remote router, but the hardware must still expose CSI data through the Linux wireless debug filesystem to be compatible.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}