IoT

WiFi DensePose: «Ve» a través de las paredes usando solo el router de casa

soloelectronicosDeja un comentario

Imagina poder saber exactamente dónde está una persona, qué postura tiene, si respira o si se ha caído, sin usar ni una sola cámara. Esto ya es una realidad gracias a WiFi DensePose: la capacidad de «ver» a través de las paredes utilizando únicamente las ondas de radio de los routers WiFi convencionales.

Este proyecto de código abierto (bajo licencia MIT) combina inteligencia artificial, procesamiento de señales y hardware asequible para crear un sistema de monitorización que respeta la privacidad como ninguna cámara podría hacerlo. Basado en el innovador sistema InvisPose, convierte los routers WiFi en potentes sensores de presencia y movimiento, reconstruyendo poses 2D y 3D en tiempo real, incluso a través de obstáculos.

¿Cómo funciona? La magia de la CSI

En esencia, WiFi DensePose utiliza la Información del Estado del Canal (CSI) de tu red WiFi. Cuando una persona se mueve, altera sutilmente la amplitud y fase de las señales de radio. El sistema captura, procesa e interpreta estas alteraciones para:

  • Reconstruir la postura corporal: Genera puntos clave de articulaciones o un mapa denso de la superficie del cuerpo (DensePose).
  • Monitorear signos vitales: Detecta la frecuencia respiratoria y el ritmo cardíaco sin ningún contacto.
  • Funcionar a través de paredes: Las señales WiFi penetran la mayoría de los materiales de construcción.
  • Ofrecer datos en tiempo real: Provee la información a través de una API REST y WebSockets para integrarla con otras aplicaciones.

Principales Características Técnicas

  • Visión por radiofrecuencia: Utiliza redes neuronales para lograr resultados comparables a los sistemas ópticos, pero sin capturar imágenes.
  • Seguimiento multi-persona: Identifica y sigue a múltiples individuos, manteniendo su identidad incluso cuando se cruzan.
  • Hardware estándar y asequible: Funciona con chips WiFi convencionales como el ESP32-S3 (~$8) y routers comerciales. Nada de equipos militares.
  • API completa para integración: Incluye endpoints REST y streaming WebSocket para conectar con cualquier plataforma SaaS, smart home o app de fitness.
  • Despliegue flexible: Compatible con Docker, Kubernetes y Ansible, con documentación exhaustiva para llevarlo a producción.

¿Qué necesitas para probarlo?

El proyecto está pensado para ser «production-ready» y se despliega fácilmente con Docker:

docker pull ruvnet/wifi-densepose:latest
docker run -p 3000:3000 ruvnet/wifi-densepose:latest

Opciones de hardware:

  • Opción Profesional (CSI completa): Necesitas hardware que exponga la CSI. La opción más recomendada y económica es usar una malla de 3 a 6 placas ESP32-S3. También funcionan tarjetas de investigación como la Intel 5300.
  • Opción Básica (Solo presencia): Si solo tienes un portátil con WiFi estándar, el sistema puede funcionar con datos RSSI, limitado a detección de presencia y movimientos gruesos.

La configuración física típica recomienda colocar los routers/ESP32 a 2-3 metros de altura, separados entre 5 y 10 metros.

Casos de Uso Reales

Las aplicaciones son enormes y abarcan múltiples campos:

  • Salud y Teleasistencia: Monitorización no intrusiva de ancianos, detección de caídas y análisis de patrones de sueño, garantizando la privacidad total al no usar cámaras.
  • Hogar Inteligente (Smart Home): Control de presencia para automatizar luces, detección de gestos para comandos y monitorización de la calidad del sueño.
  • Realidad Virtual/Aumentada (VR/AR): Seguimiento corporal para experiencias inmersivas sin necesidad de sensores en el cuerpo.
  • Respuesta a Desastres (WiFi-Mat): El proyecto incluye un módulo específico para equipos de búsqueda y rescate que puede detectar supervivientes atrapados bajo escombros.

Conectando con tu Aplicación desde Python

Acceder a los datos es muy sencillo, ya sea vía REST o WebSocket.

Ejemplo básico con REST (python):

import requests

response = requests.get("http://localhost:3000/api/v1/sensing")
data = response.json()
print(f"Personas detectadas: {len(data.get('persons', []))}")

Ejemplo de Streaming WebSocket en Tiempo Real (python):

import asyncio
import websockets
import json

async def escuchar_poses():
    uri = "ws://localhost:3001/ws/sensing"
    async with websockets.connect(uri) as websocket:
        while True:
            mensaje = await websocket.recv()
            data = json.loads(mensaje)
            print(f"Poses en vivo: {len(data.get('persons', []))}")

asyncio.run(escuchar_poses())

Privacidad: La Ventaja Estratégica

En un mundo donde cada vez más personas desconfían de las cámaras, WiFi DensePose ofrece una alternativa ética y técnicamente superior:

  • No graba imágenes: No hay rostros, ropa ni identificación visual. Solo datos de pose y presencia.
  • Permite despliegues donde las cámaras son inviables: Hospitales psiquiátricos, baños, vestuarios, habitaciones de ancianos.
  • Cumple normativas de privacidad: Al no tratar datos biométricos visuales, el marco regulatorio (GDPR, CCPA) es mucho más sencillo de navegar.

En Resumen

WiFi DensePose no es solo una librería interesante; es una plataforma tecnológica que cambia las reglas del juego en monitorización humana. Representa una oportunidad única para startups que buscan diferenciarse con soluciones técnicamente sólidas y éticamente responsables.

El futuro de la monitorización no se ve, se siente. Y se siente a través del WiFi que ya nos rodea. ¿Te animas a probarlo?

Enlaces de interés:

Documentación oficial

Repositorio en GitHub

Como funciona la actualización sin cable en Arduino

soloelectronicosDeja un comentario

¿Vale la pena el OTA en ESP32 si siempre pulso BOOT al cargar?

Imagina esto: Has perfeccionado tu prototipo basado en un ESP32. Lo instalas incluso integrado con Home Assistant integrado. Funciona perfecto… hasta que descubres un bug en el cálculo . ¿Y ahora? ¿Abrir el dispositivo sacar cables y pulsar BOOT otra vez? ¡Aquí entra el OTA para salvarte!
Sí, vale la pena implementarlo aunque la primera carga requiera el botón BOOT. Te explico paso a paso por qué.

La situación actual

Programar un ESP32 por USB/serial siempre exige pulsar BOOT (y a veces RESET) para entrar en modo de flasheo.
Esto es inherente al hardware, independientemente de si usas OTA o no.​

La clave del OTA

Después de esa primera carga, el OTA elimina el cable para siempre.

Paso 1 (instalación inicial):

  • Subes firmware con OTA incluido vía USB (sí, con BOOT).

Paso 2 (actualizaciones futuras):

  • El ESP32 se conecta a WiFi.
  • Envías nuevo firmware remotamente desde Arduino IDE (puerto de red), ESPHome o web server.
  • Cero cables, cero botones, cero contacto físico.

Código listo para usar (OTA básico)

Aquí un sketch mínimo basado en el ejemplo oficial BasicOTA. Cárgalo primero por USB:

#include <WiFi.h>
#include <ESPmDNS.h>
#include <WiFiUdp.h>
#include <ArduinoOTA.h>
const char* ssid = "TU_WIFI";     // Cambia por tu red
const char* password = "TU_PASS"; // Cambia por tu clave
void setup() {
  Serial.begin(115200);
  Serial.println("Booting OTA");
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
  while (WiFi.waitForConnectResult() != WL_CONNECTED) {
    Serial.println("Connection Failed! Rebooting...");
    delay(5000);
    ESP.restart();
  }
  // Config OTA
  ArduinoOTA.setHostname("OTA");  // Nombre visible en red
  // ArduinoOTA.setPassword("admin");  // Descomenta para contraseña
  ArduinoOTA
    .onStart([]() {
      String type;
      if (ArduinoOTA.getCommand() == U_FLASH)
        type = "sketch";
      else
        type = "filesystem";
      Serial.println("Start updating " + type);
    })
    .onEnd([]() {
      Serial.println("\nEnd");
    })
    .onProgress([](unsigned int progress, unsigned int total) {
      Serial.printf("Progress: %u%%\r", (progress / (total / 100)));
    })
    .onError([](ota_error_t error) {
      Serial.printf("Error[%u]: ", error);
      if (error == OTA_AUTH_ERROR) Serial.println("Auth Failed");
      else if (error == OTA_BEGIN_ERROR) Serial.println("Begin Failed");
      else if (error == OTA_CONNECT_ERROR) Serial.println("Connect Failed");
      else if (error == OTA_RECEIVE_ERROR) Serial.println("Receive Failed");
      else if (error == OTA_END_ERROR) Serial.println("End Failed");
    });
  ArduinoOTA.begin();
  Serial.println("Ready");
  Serial.print("IP address: ");
  Serial.println(WiFi.localIP());
}
void loop() {
  ArduinoOTA.handle();  // ¡Esencial! Mantiene OTA activo
  // Aquí va tu código ...
}

Pasos para usar:

  1. Cambia SSID/PASS, compila y sube por USB (con BOOT).
  2. Abre Monitor Serie: anota la IP y hostname.
  3. En Arduino IDE: Herramientas > Puerto → selecciona el puerto de red («OTA at IP»).
  4. Sube sketches futuros sin cable.

Cuándo brilla el OTA

  • Instalaciones fijas: Cuadros eléctricos, sensores ocultos ,etc.
  • Flotas de dispositivos: 10+ ESP32 sin visitas.
  • Mantenimiento remoto: Bugs corregidos desde móvil.
  • Alta disponibilidad: Rollbacks automáticos.

Consideraciones clave

  • Seguridad: Activa contraseña con ArduinoOTA.setPassword(). Para prod, usa HTTPS/firmas.
  • Estabilidad: Siempre llama ArduinoOTA.handle() en loop.
  • WiFi: Reconexión auto si signal débil.

Conclusión práctica:

OTA = libertad total post-instalación. Una carga USB inicial, luego updates inalámbricos infinitos.

2024 04 06 19 25 03 Monitorización de gases con Arduino Buscar con Google y 6 páginas más Person