Radar mmWave RD-03D con Arduino: qué materiales atraviesa y cuáles no

Un sensor PIR deja de verte apenas te quedas quieto. Es el problema clásico de la automatización de iluminación: te sientas a leer o a trabajar, dejas de moverte, y la luz se apaga sola. Los sensores de radar mmWave existen justamente para resolver eso, y el RD-03D es uno de los más baratos que puedes conseguir.

Este tutorial recorre tres cosas concretas. Primero, por qué el RD-03D no funciona con un Arduino Nano y sí con un Uno R4. la explicación es puramente de comunicación serial, y entenderla te sirve para cualquier sensor rápido. . Segundo, cómo conectarlo y leer posición, distancia, ángulo y velocidad del objetivo. Y tercero, la parte entretenida: qué materiales atraviesa el radar y cuáles lo detienen, probado contra cartón, plástico, madera, vidrio, cortinas y muro.

Al final vas a tener un detector de presencia que sigue viéndote aunque estés inmóvil, sepas por qué, y sepas también dónde puedes esconderlo para que no se vea.

Qué hace este sensor y en qué se diferencia de un PIR

El RD-03D es un radar de onda milimétrica que trabaja en la banda de 24 GHz. En vez de detectar cambios de calor como un PIR, emite y recibe radiofrecuencia, y mide el eco que devuelve una persona. Eso cambia dos cosas de fondo.

La primera: detecta presencia, no movimiento. Un PIR es un detector diferencial de infrarrojo: si la escena térmica no cambia, no dispara. El radar mide distancia y velocidad del blanco en cada barrido, así que una persona sentada e inmóvil sigue siendo un blanco a 2,3 metros. En las pruebas del tutorial original la detección se mantuvo con la persona de pie sin moverse, sentada en el suelo, e incluso reptando. una postura para la que el sensor no está pensado. sin que el LED se apagara ni una vez, y sin ningún temporizador en el código que sostuviera artificialmente la detección.

La segunda: el módulo entrega coordenadas, no un booleano. Por su salida serial recibes, para cada blanco:

O sea, no es un interruptor de presencia: es un rastreador. Sabes dónde está la persona, a qué distancia y si se está moviendo.

Dónde encaja frente a las otras opciones

Antes de comprar conviene ubicar el mmWave en el mapa completo, porque no siempre es la respuesta correcta:

La columna que decide casi siempre es la primera. Si tu proyecto tolera que la detección se caiga cuando la persona se queda quieta, un PIR de mil pesos hace el trabajo. Si no la tolera. iluminación de escritorio, control de clima por ocupación, cuidado de adultos mayores. el mmWave deja de ser un lujo y pasa a ser el único componente que resuelve el problema en ese rango de precio.

El problema del Arduino Nano (y por qué no es culpa de tu código)

Esta es la duda que más se repite con este módulo, y vale la pena resolverla antes de conectar nada.

El síntoma es siempre el mismo. Cargas el sketch, abres el Monitor Serie, aparece el mensaje === Radar Sensor Started ===… y después, nada. Ni un valor. El puerto queda mudo.

No es un problema de código ni de cableado. El RD-03D transmite a 256000 baudios por defecto, y ahí está todo.

Hagamos el número, porque es el que explica el fracaso. A 256000 baudios, cada bit dura 1 / 256000 ≈ 3,9 microsegundos. Un Arduino Nano corre a 16 MHz, o sea 62,5 nanosegundos por ciclo de reloj: te quedan unos 62 ciclos de instrucción por bit. La librería SoftwareSerial no tiene un periférico que reciba por ella; tiene que detectar el flanco de inicio por interrupción, esperar medio bit, y después muestrear cada bit contando ciclos en un bucle. En 62 ciclos no alcanza a hacer eso de forma confiable, y menos si hay cualquier otra interrupción activa. el propio millis() de Arduino es una. . El resultado no es un error: es basura o silencio.

La solución no es pelear con la librería. Es usar una placa cuyo hardware sí pueda: el Arduino Uno R4. Su microcontrolador Renesas RA4M1 corre a 48 MHz y tiene periféricos UART de verdad, que reciben el byte completo por hardware y solo avisan cuando está listo. La CPU no tiene que contar ciclos.

Regla general que puedes llevarte de acá: cada vez que un sensor especifique más de 38400 baudios, revisa si tu placa lo va a recibir por hardware. Sobre esa velocidad, el serial por software deja de ser una alternativa razonable en un AVR de 16 MHz. Otra salida, si estás casado con el Nano, es bajar la velocidad del propio sensor por comando de configuración; pero eso implica hablarle al módulo por la línea RX y guardar la configuración, que es bastante más trabajo que cambiar de placa.

Conexión con el Arduino Uno R4

El cableado es de tres cables, y hay un cuarto que deliberadamente no se conecta.

Sobre el pin RX: en este proyecto no hace falta. El módulo transmite su trama de forma continua apenas se alimenta, y el Arduino solo escucha. El RX se usa cuando quieres configurar el sensor. cambiar el modo de blanco único a multiblanco, ajustar la velocidad de comunicación. , y en ese caso además tendrías que preocuparte de los niveles lógicos. Para leer, tres cables bastan.

Un detalle práctico que conviene cuidar: el radar es sensible a su propia orientación. Móntalo con la cara de la antena mirando hacia la zona que quieres cubrir y, si lo vas a fijar dentro de una caja, deja al menos un par de centímetros libres frente a la antena. Un objeto pegado a la antena satura el eco cercano.

Montaje físico: altura, orientación e interferencias

El cableado es lo fácil; dónde queda el módulo decide la mitad del resultado. Cuatro criterios que valen para cualquier radar de presencia:

• Altura. Montado a la altura del torso, el radar ve el blanco más grande que ofrece una persona. Montado en el cielo apuntando hacia abajo, cubre un área bien definida pero el eco es menor y el alcance útil se acorta. Elige según lo que quieras: cobertura amplia de una pieza, o una zona precisa sobre un escritorio o una cama.
• Orientación de la antena. La cara de la antena tiene que mirar la zona de interés, sin nada apoyado encima. Un módulo montado de canto o girado 90° cambia por completo el significado del eje X.
• Qué queda detrás. Una superficie metálica inmediatamente detrás del módulo devuelve energía hacia la antena y sube el piso de ruido. Deja aire, o material plástico.
• Qué se mueve en el campo. Un ventilador de techo, una cortina que se mueve con la corriente de aire o una planta cerca de una ventana abierta son blancos móviles reales para el radar. No es un falso positivo del sensor: efectivamente hay algo moviéndose. Si tu instalación tiene uno de estos, sácalo del campo de visión o descarta esa zona por software con el filtro de coordenadas que veremos más abajo.

Sobre los niveles lógicos: acá el sensor solo transmite, así que la línea que importa va del módulo al Arduino y no hay riesgo de aplicar 5 V a una entrada de 3,3 V. Eso cambia si más adelante decides conectar el RX para configurar el módulo, y es exactamente el momento en que conviene revisar la hoja de datos antes de cablear.

El código base: leer y mostrar

Este primer sketch no hace nada más que leer la trama y volcarla al Monitor Serie. Es el que tienes que hacer funcionar antes de complicarte con lógica.

#include <RadarSensor.h>

// RX, TX pins connected to sensor TX, RX
RadarSensor radar(2, 3);

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

  radar.begin(256000);

  Serial.println("\n=== Radar Sensor Started ===\n");
}

void loop() {
  if (radar.update()) {

    RadarTarget tgt = radar.getTarget();

    Serial.println("----- Target Data -----");

    Serial.print("X (mm): ");
    Serial.println(tgt.x);

    Serial.print("Y (mm): ");
    Serial.println(tgt.y);

    Serial.print("Distance (mm): ");
    Serial.println(tgt.distance);

    Serial.print("Angle (degrees): ");
    Serial.println(tgt.angle);

    Serial.print("Speed (cm/s): ");
    Serial.println(tgt.speed);

    Serial.println("-----------------------\n");

    delay(100);
  }
}

Fíjate en las dos velocidades distintas: Serial.begin(115200) es la del puerto USB hacia tu computador, y radar.begin(256000) es la del sensor. Son cosas separadas, y confundirlas es otra fuente clásica de "no aparece nada".

Para compilar necesitas la librería RadarSensor. Se instala desde el IDE de Arduino con Sketch → Incluir librería → Añadir biblioteca .ZIP, apuntando al archivo comprimido. El autor del tutorial original la distribuye a través de su Patreon junto con el resto de los archivos del proyecto.

Con el sketch cargado y el Monitor Serie abierto a 115200, deberías ver bloques de datos actualizándose varias veces por segundo.

Camina hacia el sensor y verás bajar la distancia; retrocede y sube. Muévete a un lado y el par X/angle cambia de signo. Eso es seguimiento en tiempo real, no una detección binaria.

Encender un LED por rango de distancia

El siguiente paso convierte esos números en algo que se ve sin mirar la pantalla: el LED de la placa se enciende cuando hay una persona dentro de un rango definido. Es también el instrumento con el que se hacen las pruebas de penetración de la sección siguiente, porque permite ver el resultado de un vistazo.

#include <RadarSensor.h>

// RX, TX pins connected to sensor TX, RX
RadarSensor radar(2, 3);

#define LED_PIN LED_BUILTIN

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

  pinMode(LED_PIN, OUTPUT);

  Serial.println("\n=== Radar Sensor Started ===\n");
}

void loop() {
  if (radar.update()) {

    RadarTarget tgt = radar.getTarget();

    // Convert mm to feet (1 mm = 0.00328084 feet)
    float distanceFeet = tgt.distance * 0.00328084;

    Serial.println("----- Target Data -----");

    Serial.print("Distance (feet): ");
    Serial.println(distanceFeet);

    // LED Control Logic
    if (distanceFeet > 2.0 && distanceFeet < 14.0) {
      digitalWrite(LED_PIN, HIGH);  // Turn ON LED
      Serial.println("Led Turned ON");
    } else {
      digitalWrite(LED_PIN, LOW);   // Turn OFF LED
    }

    Serial.println("-----------------------\n");

    delay(100);
  }
}

El código original trabaja en pies. Si prefieres pensar en metros. que es lo razonable acá. , la conversión es directa: reemplaza el factor 0.00328084 por 0.001 para pasar de milímetros a metros, y cambia el rango 2.0 a 14.0 por los valores en metros que te sirvan. Los 2 a 14 pies del ejemplo equivalen aproximadamente a 0,6 a 4,3 metros.

Dos observaciones sobre este sketch que vale la pena tener presentes al llevarlo a un proyecto real:

• No tiene histéresis. Una persona parada justo en el límite del rango va a hacer parpadear el LED. Si esto va a manejar un relé o una ampolleta, agrega dos umbrales distintos para encender y apagar, o un contador de lecturas consecutivas antes de cambiar de estado.
• El delay(100) bloquea el bucle. Para una demostración da lo mismo; para un proyecto con más tareas, cámbialo por una comparación con millis() y deja el bucle libre.

Del dato al plano: usar X e Y en vez de solo la distancia

El sketch anterior tira a la basura la mitad de la información. distance te dice a qué distancia está la persona, pero no dónde. Si el sensor entrega X, Y y angle, puedes definir zonas en vez de un anillo.

La geometría es la de siempre. El sensor está en el origen, Y crece hacia adelante y X hacia los lados (positivo a un lado, negativo al otro). Con eso:

• La distancia es sqrt(X² + Y²), que es justamente lo que el módulo ya te entrega en distance.
• El ángulo es atan2(X, Y) en radianes; multiplicado por 57.2958 queda en grados, que es el angle del sensor.

Lo útil de tener X e Y por separado es que una zona rectangular se expresa con cuatro comparaciones y nada más. Por ejemplo, "hay alguien en el escritorio" con el sensor montado en la pared del frente, midiendo en milímetros, es algo tan simple como comprobar que tgt.y esté entre 800 y 2000 y que tgt.x esté entre, 600 y 600. Compara eso con intentar lo mismo usando solo la distancia: un anillo de radio fijo también se activa con alguien que pasa por el pasillo lateral.

Un par de recomendaciones para que esas zonas no parpadeen:

• Filtra antes de decidir. Un promedio móvil de las últimas cinco lecturas de X e Y estabiliza muchísimo el resultado, a costa de medio segundo de retardo. Para presencia, ese retardo no le importa a nadie.
• Usa speed como pista, no como condición. Que speed sea cero no significa que no haya nadie: significa que la persona no se está acercando ni alejando. Es un error frecuente filtrar por velocidad distinta de cero y volver a construir, sin querer, un PIR.
• Define las zonas con el sensor ya montado en su posición final. Los números cambian por completo si después mueves el módulo veinte centímetros o lo inclinas.

Qué materiales atraviesa el radar

Acá está la parte interesante, y la razón por la que este sensor sirve para cosas que un PIR ni sueña: el mmWave puede quedar escondido. Un PIR necesita ver la escena; el radar no.

Estos son los resultados de las pruebas del tutorial original, con el sensor tapado por cada material y una persona entrando al rango:

La regla física detrás de la tabla es más simple de lo que parece. A 24 GHz la longitud de onda es de unos 12,5 mm. Los materiales que dejan pasar esa onda son los dieléctricos secos y poco densos: cartón, plásticos, maderas y derivados, telas, vidrio común. Lo que la detiene es el metal. que la refleja por completo. y el agua, que la absorbe. De ahí sale todo lo demás:

• Un muro de albañilería u hormigón combina espesor, densidad y humedad retenida en el material. La atenuación de ida y vuelta se come el eco. Por eso el muro es el único "no" de la lista, y es el resultado esperable.
• Un tabique de volcanita. yeso cartón sobre perfiles. es un caso mixto: el yeso cartón por sí solo es bastante transparente al radar, pero los perfiles metálicos cada 40 o 60 cm forman una reja que refleja. Vas a ver detección en los tramos entre perfiles y pérdidas justo sobre ellos.
• Un vidrio con película metalizada o low-E no se comporta como el vidrio común de la prueba: la capa conductora lo convierte prácticamente en un espejo de radar. Si vas a montar el sensor detrás de una vitrina moderna, pruébalo antes de dar el proyecto por cerrado.
• Una caja estanca plástica funciona, y esa es probablemente la aplicación más útil de toda la lista: puedes dejar el radar sellado contra la humedad en un exterior techado sin perder alcance.

Un apunte que el tutorial original no hace y que conviene decir en voz alta: un sensor que ve a través de una puerta y que no se ve desde afuera es, exactamente, un sensor con implicancias de privacidad. Si lo instalas en un espacio compartido. una oficina, un arriendo, un edificio. avisa que está ahí. La tecnología es entretenida; instalarla sin avisar, no.

Cómo hacer tu propia prueba, sin engañarte

Vas a querer probar con el material específico de tu instalación, y ahí es fácil obtener un resultado que parece bueno y no lo es. Tres precauciones:

1. Prueba primero sin obstáculo y anota el alcance. Si no sabes hasta dónde llega el sensor al aire libre, no puedes saber cuánto te costó el material. La pregunta correcta no es "¿detecta?", es "¿cuántos metros de alcance perdí?".
2. Cuida por dónde se cuela la señal. Una plancha apoyada delante del sensor no es lo mismo que una plancha instalada: si queda una ranura al costado, la detección puede estar entrando por ahí y no a través del material. Tapa generosamente, con margen a los lados.
3. Repite parado y en movimiento. Atravesar un material atenúa el eco, y el eco de una persona quieta ya es el más débil de todos. Es perfectamente posible que el radar te detecte caminando detrás de una puerta y te pierda sentado detrás de la misma puerta. Si tu aplicación es de presencia, la prueba válida es la de quedarse quieto.

Y una advertencia de montaje que ahorra confusiones: no pegues el radar contra una superficie metálica ni lo metas en una caja de aluminio. La antena necesita un frente despejado; el metal detrás también reflecta y ensucia la lectura.

La interfaz de radar en el computador

Como el módulo entrega coordenadas y no solo presencia, se puede dibujar. La idea es simple: el Arduino escupe una línea de texto con los cinco valores separados por coma, y un programa en el computador la lee del puerto serie y pinta un punto en una pantalla tipo radar.

El sketch del lado del Arduino es el más corto de los tres, porque lo único que hace es formatear:

#include <RadarSensor.h>

RadarSensor radar(2, 3);

void setup() {
  Serial.begin(115200); 
  radar.begin(256000);
}

void loop() {
  if (radar.update()) {
    RadarTarget tgt = radar.getTarget();
    // Format: X,Y,Distance,Angle,Speed
    Serial.print(tgt.x); Serial.print(",");
    Serial.print(tgt.y); Serial.print(",");
    Serial.print(tgt.distance); Serial.print(",");
    Serial.print(tgt.angle); Serial.print(",");
    Serial.println(tgt.speed);
  }
}

Ese formato CSV es deliberadamente genérico: lo puede leer un script de Python con pyserial, un flujo de Node RED, una hoja de cálculo o cualquier cosa que sepa abrir un puerto serie. La aplicación de radar del artículo original está escrita en Python y se distribuye por Patreon, pero con esta salida no dependes de ella: son cinco números por línea.

Si no te funciona: lista de verificación

En orden, de lo más frecuente a lo menos:

1. ¿Aparece el mensaje de inicio y nada más? Es el síntoma de la velocidad de comunicación. Estás en un AVR de 16 MHz con serial por software. Cambia de placa; ver la primera sección.
2. ¿No aparece ni siquiera el mensaje de inicio? Entonces el problema es el otro puerto: el Monitor Serie no está a 115200, o la placa seleccionada en el IDE no corresponde. Revisa el selector de velocidad abajo a la derecha del Monitor Serie.
3. ¿Compila con error en #include <RadarSensor.h>? La librería no está instalada. Se agrega con Sketch → Incluir librería → Añadir biblioteca .ZIP, no descomprimiendo la carpeta a mano.
4. ¿Salen valores, pero son basura o saltan sin sentido? Revisa la tierra. Es el cable que más se olvida y el que produce exactamente ese síntoma: sin GND común, el receptor no tiene referencia para decidir qué es un 1 y qué es un 0.
5. ¿Detecta permanentemente, incluso con la pieza vacía? Algo está reflejando muy cerca de la antena: un tornillo, una pared a diez centímetros, el propio cable enrollado por delante del módulo. Despeja el frente y vuelve a probar.
6. ¿Detección intermitente a distancia media? Alimentación. El módulo tira picos de corriente y un cable USB largo y delgado hacia el computador puede no dar el ancho. Prueba con una fuente aparte de 5 V, con la tierra unida a la del Arduino.

Variantes y mejoras

1. Automatización de iluminación que no te deja a oscuras. Es la aplicación directa y la que mejor justifica el costo frente a un PIR. Reemplaza el LED interno por un módulo de relé y controla la luz de un pasillo, una escalera o un baño. Agrega la histéresis que mencionamos antes y un retardo de apagado de un par de minutos, y tienes algo que un PIR simplemente no puede hacer: mantener la luz encendida mientras estás sentado sin moverte.

2. Publicación por MQTT hacia Home Assistant. Cambia el Uno R4 por un ESP32. que también tiene UART por hardware de sobra. y en vez de imprimir por serie, publica distance, angle y speed como sensores MQTT. Con eso el radar deja de ser un experimento y pasa a ser una entidad de presencia en tu domótica, con la ventaja de que puedes definir zonas: "persona a menos de 1,5 m del escritorio" es una automatización distinta de "hay alguien en la pieza".

3. Registro de ocupación en microSD. Con un módulo microSD por SPI y un RTC, guarda una línea con marca de tiempo cada vez que cambia el estado de presencia. En una semana tienes datos reales de uso de una sala, que es el insumo que necesitas antes de decidir dónde poner sensores de verdad en una instalación más grande.

4. Enlace de largo alcance con LoRa. La placa con la que empezó el tutorial original traía LoRa integrada, y la idea sigue siendo buena aunque el Nano no diera el ancho: con un ESP32 más un módulo LoRa puedes dejar el radar escondido en un punto remoto sin WiFi y recibir las alertas a cientos de metros. Es el paso natural si lo que quieres es vigilancia perimetral y no automatización doméstica.

Personalización para Chile

Lo que necesitas para reproducir este proyecto tal cual, disponible en MechatronicStore:

• Módulo de radar mmWave RD-03D de 24 GHz. el protagonista. Es el único componente que no tiene reemplazo directo en este tutorial: otros módulos mmWave (LD2410, LD2450) usan tramas y velocidades distintas y no funcionan con la misma librería.
• Arduino Uno R4. la placa que hace que esto funcione. Como explicamos arriba, no es un capricho: es el requisito de comunicación serial.
• Jumpers Dupont hembra hembra. tres cables bastan para conectar VCC, GND y TX.
• Protoboard 830 puntos. opcional para las pruebas, útil si vas a agregar el relé o el LED externo.
• Placa ESP32 DevKit. si vas por la variante 2 o 4 de la sección anterior, en vez del Uno R4.

Sobre equivalencias, tres advertencias honestas:

• El Arduino Nano no sirve para este proyecto, y no vale la pena comprarlo "porque es más barato". Toda la primera sección de este artículo existe por ese motivo. Si ya tienes uno, guárdalo para otra cosa.
• Donde el tutorial original enlaza a Amazon, acá el equivalente es directamente el catálogo local: te ahorras el envío internacional y, en el caso del Uno R4, la diferencia de precio suele ser menor de lo que uno espera.
• Las distancias del código vienen en pies, porque el autor original trabaja en unidades imperiales. Ya está indicada la conversión a metros más arriba; hazla antes de calibrar tu rango, o vas a estar ajustando números que no significan lo que crees.

Recursos

• Tutorial original (inglés): Arduino + RD-03D mmWave See Through Test. Can It Detect Behind Objects?
• Proyecto previo con ESP32 y seguimiento multiblanco: RD-03D mmWave Radar: Multi Human Tracking with Distance, Speed & Positioning
• Radar en tiempo real con pantalla táctil ESP32-S3: Real Time Human Tracking Radar with mmWave Sensor and ESP32-S3 Touchscreen
• Comparación de placas: Arduino Uno R4 Minima: especificaciones y comparación con el Uno R3
• Librería RadarSensor y la aplicación de radar en Python: las distribuye el autor original a través de su Patreon, junto con el resto de los archivos del proyecto.

Inspirado en el trabajo de Engr. Shahzada Fahad para Electronic Clinic. Versión chilena, reordenada como guía técnica y con componentes en stock local en MechatronicStore.