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

> Discover WiFi hardware compatible with WiFi DensePose. Find Atheros routers like TP-Link Archer C7/C9 and Intel 5300 NICs that support CSI for enhanced WiFi analysis.

- Repository: [rUv/wifi-densepose](https://github.com/ruvnet/wifi-densepose)
- Tags: how-to-guide
- Published: 2026-02-16

---

**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`](https://github.com/ruvnet/wifi-densepose/blob/main/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`](https://github.com/ruvnet/wifi-densepose/blob/main/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

```python
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`](https://github.com/ruvnet/wifi-densepose/blob/main/v1/src/services/hardware_service.py) orchestrates this process.

```python
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`](https://github.com/ruvnet/wifi-densepose/blob/main/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`](https://github.com/ruvnet/wifi-densepose/blob/main/v1/src/config/settings.py):

```python
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`](https://github.com/ruvnet/wifi-densepose/blob/main/README.md)** – Quick reference list of tested routers and NICs under the *Supported Hardware* section.
- **[`plans/phase2-architecture/hardware-integration.md`](https://github.com/ruvnet/wifi-densepose/blob/main/plans/phase2-architecture/hardware-integration.md)** – Complete hardware integration architecture, including the `RouterConfiguration` dictionary and `UnifiedRouterInterface` class implementation.
- **[`v1/src/services/hardware_service.py`](https://github.com/ruvnet/wifi-densepose/blob/main/v1/src/services/hardware_service.py)** – Service that reads `wifi_interface` from settings and initializes the HAL.
- **[`v1/src/hardware/router_interface.py`](https://github.com/ruvnet/wifi-densepose/blob/main/v1/src/hardware/router_interface.py)** – Low-level SSH-based commands for router configuration and driver management.
- **[`v1/src/hardware/csi_extractor.py`](https://github.com/ruvnet/wifi-densepose/blob/main/v1/src/hardware/csi_extractor.py)** – Parses raw CSI packets from UDP streams into structured NumPy arrays.
- **[`v1/src/config/settings.py`](https://github.com/ruvnet/wifi-densepose/blob/main/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`](https://github.com/ruvnet/wifi-densepose/blob/main/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`](https://github.com/ruvnet/wifi-densepose/blob/main/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.