Laboratorio Radar Antenas

Septimo Semestre˚
Facultad de Ingenierı́a, Ingenierı́a en Telecomunicaciones,
PROPAGACION Y ANTENAS
Universidad Nacional de Chimborazo, Avda. Antonio Jose de Sucre Km 1 1/2 camino a Guano, Riobamba- Ecuador.

Abstract—This report details the implementation of a basic analizarán los resultados obtenidos y se discutirán posibles
radar system using Arduino and MATLAB. The system utilized mejoras y aplicaciones futuras del sistema desarrollado.
an Arduino Uno as the main microcontroller to control and
manage an HC-SR04 ultrasonic sensor module, used for distance
measurement. A servo motor enabled horizontal scanning of the
sensor to detect objects within a specific scanning area. Devel- II. O BJETIVOS DE LA PRACTICA
opment took place in the Arduino IDE environment, program-
ming the Arduino, controlling the servo motor, and conducting
measurements using ultrasonic pulses. MATLAB was employed ‚ Crear un sistema capaz de identificar objetos y calcular
to establish serial communication with Arduino, enabling real- las distancias dentro de un área especı́fica de exploración.
time data retrieval and visualization. Graphical representations
in MATLAB provided detailed information on the distances of ‚ Crear un código para el uso del servomotor y el sensor
detected objects relative to the scanning angle. This practice ultrasonico.
highlighted the effective integration of hardware and software in ‚ Observar el la pantalla de processning el funcionamiento
creating an economical and functional radar system suitable for del radar.
applications in robotics, security, and environmental monitoring.
Furthermore, the project emphasized the practical application of
sensor technologies and data processing techniques in real-world
scenarios, promoting a deeper understanding of radar principles III. M ARCO T E ÓRICO
and their implementation using accessible hardware and software
platforms.
Index Terms—Scanning, radar, distance, pulses, detected, Ar-
duino, MATLAB, effective, control.
Radar

I. I NTRODUCCI ÓN Radar (Radio Detección y Rango), es una tecnologı́a

En la actualidad, la tecnologı́a de detección y medición que utiliza ondas de radio para detectar la presencia,
de distancias ha encontrado aplicaciones en diversos campos, dirección, distancia y velocidad, funciona transmitiendo
desde la automatización industrial hasta la robótica y la ondas electromagnéticas (ondas de radio) hacia un objetivo
seguridad. Entre las múltiples herramientas disponibles para y luego detectando y analizando las ondas que se reflejan
estas tareas, los sensores ultrasónicos destacan por su pre- (o dispersan) desde el objetivo. Esto permite a los sistemas
cisión, costo accesible y facilidad de integración en sistemas de radar determinar la posición y otras caracterı́sticas de los
electrónicos. objetos en sus proximidades.[1]
El presente informe detalla el desarrollo de una práctica
cuyo objetivo es la construcción de un radar básico empleando La tecnologı́a de radar tiene diversas aplicaciones, su ca-
una plataforma Arduino y sensores ultrasónicos. Este radar es pacidad para operar eficazmente en diversas condiciones ambi-
capaz de detectar objetos en su entorno y determinar la distan- entales, de dı́a o de noche, lo ha convertido en una herramienta
cia a la que se encuentran, proporcionando una representación crucial en la tecnologı́a y los sistemas de defensa modernos.
visual en una interfaz gráfica.
Arduino
La elección de Arduino como base de esta práctica se debe
a su versatilidad, amplia documentación y la gran comunidad
de usuarios que facilita la resolución de problemas y el acceso Arduino es una plataforma electrónica de código abierto
a recursos adicionales. Los sensores ultrasónicos, por su parte, basada en hardware y software fáciles de usar. Las placas
funcionan mediante la emisión de ondas de sonido a una Arduino pueden leer entradas (luz en un sensor, un dedo en un
frecuencia superior a la del oı́do humano y la medición del botón o un mensaje de Twitter) y convertirlas en una salida:
tiempo que tarda el eco en regresar al sensor tras rebotar en un activar un motor, encender un LED o publicar algo en lı́nea.
objeto. Este principio de operación permite obtener mediciones Puede decirle a su placa qué hacer enviando un conjunto de
de distancia precisas y fiables. instrucciones al microcontrolador de la placa. Para ello se
A lo largo de este informe, se describirán los componentes utiliza el lenguaje de programación Arduino (basado en Wiring
utilizados, el diseño y montaje del circuito, la programación ) y el Software Arduino (IDE), basado en Processing.[2]
del microcontrolador Arduino y el desarrollo de la inter- sensor HC-SR04
faz gráfica para la visualización de los datos. Además, se
 [Link](9600): Inicializa la comunicación serial a
‚
9600 baudios.
‚ [Link](12): Asocia el servomotor al pin 12.
Bucle Principal
void loop() {
for(int i=15;i<=165;i++){
[Link](i);
delay(30);
distance = calculateDistance();
[Link](i);
[Link](",");
Fig. 1. SENSOR ULTRASONIDO HC-SR04
[Link](distance);
[Link](".");
El sensor HC-SR04 es un sensor de distancia de bajo costo
}
que utiliza ultrasonido para determinar la distancia de un
for(int i=165;i>15;i--){
objeto en un rango de 2 a 450 cm. Destaca por su pequeño
[Link](i);
tamaño, bajo consumo energético, buena precisión y excelente
delay(30);
precio. El sensor HC-SR04 es el más utilizado dentro de los
distance = calculateDistance();
sensores de tipo ultrasonido, principalmente por la cantidad
[Link](i);
de información y proyectos disponibles en la web. De igual
[Link](",");
forma es el más empleado en proyectos de robótica como
[Link](distance);
robots laberinto o sumo, y en proyectos de automatización
[Link](".");
como sistemas de medición de nivel o distancia.[3]
}
}
IV. D ESCRIPCI ÓN DEL C ÓDIGO
A. Código Arduino for(int i=15;i¡=165;i++): Bucle que recorre ángulos desde
‚
Librerı́as y Variables Globales 15 hasta 165 grados.
‚ [Link](i): Mueve el servomotor al ángulo i.
#include <ESP32Servo.h>
‚ delay(30): Espera 30 milisegundos para permitir que el
const int trigPin = 2;
servomotor se estabilice.
const int echoPin = 4;
‚ distance = calculateDistance(): Calcula la distancia a un
long duration;
objeto utilizando el sensor ultrasónico.
int distance;
‚ [Link](i): Imprime el ángulo actual.
Servo myServo;
‚ [Link](”,”): Imprime una coma para separar los val-
‚ ESP32Servo: Librerı́a para controlar el servomotor. ores.
‚ trigPin y echoPin: Pines del sensor ultrasónico (HC- ‚ [Link](distance): Imprime la distancia calculada.
SR04) conectados al ESP32. ‚ [Link](”.”): Imprime un punto para finalizar la lı́nea
‚ duration: Almacena el tiempo que tarda el pulso ul- de datos.
trasónico en regresar. ‚ for(int i=165;i¿15;i–): Bucle que recorre ángulos de re-
‚ distance: Almacena la distancia calculada a partir del greso desde 165 hasta 15 grados, realizando las mismas
tiempo del pulso. operaciones.
‚ myServo: Objeto de tipo Servo para controlar el servo- Función para Calcular la Distancia
motor.
int calculateDistance(){
Configuración Inicial
digitalWrite(trigPin, LOW);
void setup() { delayMicroseconds(2);
pinMode(trigPin, OUTPUT); digitalWrite(trigPin, HIGH);
pinMode(echoPin, INPUT); delayMicroseconds(10);
[Link](9600); digitalWrite(trigPin, LOW);
[Link](12); duration = pulseIn(echoPin, HIGH);
} distance = duration * 0.034 / 2;
return distance;
‚ pinMode(trigPin, OUTPUT): Configura el pin del trigger
}
como salida.
‚ pinMode(echoPin, INPUT): Configura el pin del echo ‚ digitalWrite(trigPin, LOW): Establece el pin del trigger
como entrada. en bajo.
 ‚ delayMicroseconds(2): Espera 2 microsegundos. // Variables para almacenar ángulo y
‚ digitalWrite(trigPin, HIGH): Establece el pin del trigger distancia como enteros
en alto. int index1=0;
‚ delayMicroseconds(10): Mantiene el pin del trigger en // Índice para el primer separador de datos
alto por 10 microsegundos. int index2=0;
‚ digitalWrite(trigPin, LOW): Establece el pin del trigger // Índice para el segundo separador de datos
en bajo. PFont orcFont;
‚ duration = pulseIn(echoPin, HIGH): Mide el tiempo que // Fuente para texto
tarda el pulso en volver al pin del echo.
Configuración Inicial
‚ distance = duration * 0.034 / 2: Calcula la distancia
basándose en el tiempo medido. El factor 0.034 convierte void setup() {
el tiempo a distancia en centı́metros y el 2 divide por dos size(1200, 700); // Configura el tamaño
para obtener la distancia de ida solamente. de la ventana
‚ return distance: Retorna la distancia calculada. smooth(); // Suaviza los bordes de los
gráficos
myPort = new Serial(this, "COM5", 9600);
// Inicia la comunicación serial
[Link](’.’); // Configura el
puerto para leer hasta el carácter ’.’
}
Bucle Principal de Dibujo
void draw() {
fill(98, 245, 31);
Fig. 2. Arduino
noStroke();
fill(0, 4);
El código mueve un servomotor entre 15 y 165 grados y de rect(0, 0, width, height-height*0.065);
vuelta, mientras mide y envı́a por serial la distancia a objetos // Simula desenfoque de movimiento
detectados en cada ángulo usando un sensor ultrasónico. Esto
permite crear un escaneo de 180 grados, útil para un radar fill(98, 245, 31); // Color verde
básico que puede visualizar distancias a objetos en diferentes drawRadar();
direcciones. drawLine();
B. Código Procesing para el radar drawObject();
drawText();
Importación de Librerı́as y Declaración de Variables
}
import [Link].*; ‚ drawRadar(): Dibuja el radar.
// Librerı́a para comunicación serial ‚ drawLine(): Dibuja la lı́nea del radar en movimiento.
import [Link]; ‚ drawObject(): Dibuja los objetos detectados.
// Librerı́a para eventos de teclado ‚ drawText(): Dibuja el texto en pantalla.
import [Link];
Manejo de Datos Seriales
// Librerı́a para manejo de excepciones de E/S
void serialEvent(Serial myPort) {
Serial myPort; data = [Link](’.’);
// Objeto Serial // Lee datos hasta ’.’
String angle=""; data = [Link](0,data.
// Variable para almacenar el ángulo length() - 1);
String distance=""; // Elimina el ’.’
// Variable para almacenar la distancia
String data=""; index1 = [Link](","); // Encuentra
// Variable para almacenar datos recibidos el ı́ndice de la coma
String noObject; angle = [Link](0, index1); /
// Variable para indicar si hay objeto o no / Extrae el ángulo
float pixsDistance; distance = [Link](index1 + 1,
// Variable para almacenar la distancia en [Link]());
pı́xeles // Extrae la distancia
int iAngle, iDistance;
 iAngle = int(angle); // Convierte el line(pixsDistance*cos(radians(iAngle)),
ángulo a entero -pixsDistance*sin(radians(iAngle)),
iDistance = int(distance); // Convierte (width-width*0.505)*cos(radians(iAngle)),
la distancia a entero -(width-width*0.505)*sin(radians(iAngle)));
} }
popMatrix();
Función para Dibujar el Radar
}
void drawRadar() {
pushMatrix();
Función para Dibujar la Lı́nea del Radar
translate(width/2, height-height*0.074);
// Traslada el origen void drawLine() {
noFill(); pushMatrix();
strokeWeight(2); strokeWeight(9);
stroke(98, 245, 31); stroke(30, 250, 60);
translate(width/2, height-height*0.074);
// Dibuja los arcos // Traslada el origen
arc(0, 0, (width-width*0.0625), line(0, 0, (height-height*0.12)*cos
(width-width*0.0625), PI, TWO_PI); (radians(iAngle)), -(height-height*0.12)
arc(0, 0, (width-width*0.27), *sin(radians(iAngle)));
(width-width*0.27), PI, TWO_PI); // Dibuja la lı́nea
arc(0, 0, (width-width*0.479), popMatrix();
(width-width*0.479), PI, TWO_PI); }
arc(0, 0, (width-width*0.687),
(width-width*0.687), PI, TWO_PI);
Función para Dibujar el Texto
// Dibuja las lı́neas de ángulo void drawText() {
line(-width/2, 0, width/2, 0); pushMatrix();
line(0, 0, (-width/2)*cos(radians(30)), if(iDistance > 40) {
(-width/2)*sin(radians(30))); noObject = "Out of Range";
line(0, 0, (-width/2)*cos(radians(60)), } else {
(-width/2)*sin(radians(60))); noObject = "In Range";
line(0, 0, (-width/2)*cos(radians(90)), }
(-width/2)*sin(radians(90))); fill(0, 0, 0);
line(0, 0, (-width/2)*cos(radians(120)), noStroke();
(-width/2)*sin(radians(120))); rect(0, height-height*0.0648, width,
line(0, 0, (-width/2)*cos(radians(150)), height);
(-width/2)*sin(radians(150))); fill(98, 245, 31);
line((-width/2)*cos(radians(30)), 0, textSize(25);
width/2, 0);
popMatrix(); text("10cm", width-width*0.3854,
} height-height*0.0833);
text("20cm", width-width*0.281,
height-height*0.0833);
Función para Dibujar el Objeto
text("30cm", width-width*0.177,
void drawObject() { height-height*0.0833);
pushMatrix(); text("40cm", width-width*0.0729,
translate(width/2, height-height*0.074); height-height*0.0833);
// Traslada el origen textSize(40);
strokeWeight(9); text("FABRI creator", width-width
stroke(255, 10, 10); // Color rojo *0.875, height-height*0.0277);
pixsDistance = iDistance * ((height- text("Ángulo: " + iAngle +" °",
height*0.1666)*0.025); width-width*0.48, height-height*
// Convierte distancia a pı́xeles 0.0277);
text("Dist:", width-width*0.26,
// Limita el rango a 40 cm height-height*0.0277);
if(iDistance < 40){
 if(iDistance < 40) {
text(" " + iDistance +" cm", V. D ESCRIPCI ÓN DE LA IMPLEMENTACI ÓN F ÍSICA
width-width*0.225, height-height*
0.0277); A. Seleccion de los materiales
} Lo primero que debemos hacer es seleccionar correctamente
textSize(25); los materiales que vamos a utilizar para la implemenatcion del
fill(98, 245, 60); radar con arduino.
translate((width-width*0.4994)+width/2 Como se puede observar en la figura 3, estan todos los
*cos(radians(30)), (height-height*0.0907)-materiales que vamos a utilizar para este trabajo.
width/2*sin(radians(30)));
rotate(-radians(-60));
text("30°", 0, 0);
resetMatrix();
translate((width-width*0.503)+width/2*
cos(radians(60)), (height-height*0.0888)-
width/2*sin(radians(60)));
rotate(-radians(-30));
text("60°", 0, 0);
resetMatrix();
translate((width-width*0.507)+width/2*
cos(radians(90)), (height-height*0.0833)-
width/2*sin(radians(90)));
rotate(radians(0));
text("90°", 0, 0);
resetMatrix();
Fig. 4. Materiales necesarios para la implementación del radar con arduino.
translate(width-width*0.513+width/2*
cos(radians(120)), (height-height*0.07129)-
B. Armado del radar
width/2*sin(radians(120)));
rotate(radians(-30)); Se procede a colocar el arduino junto con el servomotor y
text("120°", 0, 0); el sensor ultrasonico en una plataforma de madera para para
resetMatrix(); que esten sujetas y se mantenga firmes para el correcto fun-
translate((width-width*0.5104)+width/2 cionamiento del mismo. Ademas, es muy importante colocar el
sensor
*cos(radians(150)), (height-height*0.0574)- mirando hacia afuera para si poder detectar los obbjetos
width/2*sin(radians(150))); que se acerquen al sensor.
rotate(radians(-60)); Debido a que el servomotor se va a mover junto con el sensor
text("150°", 0, 0); ultrasonico lo cual para evitar causar daños tanto al sevo como
popMatrix(); al sensor estos deben estar sujetos a una superficie rigida, esto
} se observa en la figura 2.
C. Conexión de los diferentes elementos del radar
Las conexiones son muy sencillar, primero energizamos el
servomotor y el sensor ultrasonico con la salida de 5 voltios
de la placa de arduino. con sus respectivas GND al mismo
GND de la placa de arduino.
Ahora conectamos el pin de control del servomotor que es el
color naranja, en el pin número 12 de la placa de arduino.
Además, el trigger del sensor ultrasonico va conectado al
pin número 10 de la placa de arduino, el echo del sensor
ultrasonico va conectado al pin número 11 de la placa de
arduino. Esto se observa en la figura 3.
D. Funcionamiento del radar
Fig. 3. Processing
El servomotor estara en constante movimiento de esquierda
a derecha y viceversa, para que el sensor ultrasonico pueda
Este código visualiza un radar en tiempo real, mostrando detectar los objetos que se acercan de distantas partes el sensor
la distancia de los objetos detectados a diferentes ángulos y ultrasonico detectara el una area de 1 metro entre los angulos
actualizándose conforme se reciben nuevos datos del Arduino. comprendidos de 15 grados a los 175 grados.
 VI. C ONCLUSIONES ‚ Ampliación del Arco de Rotación: Si es necesario,
‚ La implementación de este proyecto permitió comprender ajustar el arco de rotación del servomotor para cubrir
mejor el funcionamiento de los sensores ultrasónicos, áreas más amplias o especı́ficas según los requisitos del
su integración con servomotores y plataformas de vi- entorno de monitoreo.
sualización como Processing. La práctica brindó una R EFERENCES
experiencia valiosa en la programación y configuración
1 González-Amor Garcı́a, E. et al., “Puesta en marcha de un sistema de testeo
de sistemas de detección y monitoreo. Esta experiencia de diagramas de radiación de antenas embebidas en sistemas radar,” 2023.
es fundamental para futuros proyectos en el campo de la 2 Garcı́a-Tudela, P. A. and Marı́n-Marı́n, J.-A., “Use of arduino in primary
electrónica y la automatización, destacando la importan- education: a systematic review,” Education Sciences, vol. 13, no. 2, p. 134,
2023.
cia de adaptar las configuraciones según las capacidades 3 Martı́nez Fuentes, V., “Introducción a la plataforma arduino y al sensor
reales del hardware utilizado y las condiciones del en- ultrasónico hc-sr04: experimentado en una aplicación para medición de
torno de prueba. distancias,” B.S. thesis, 2016.
‚ El sensor ultrasónico se demostró eficiente para de-
tectar objetos a distancias de hasta 1 metro. Aunque
inicialmente se intentó configurar para 4.5 metros, las
limitaciones del sensor y las condiciones del entorno de
prueba llevaron a una configuración óptima de 1 metro,
donde las mediciones fueron precisas y consistentes.
‚ La utilización de Processing para la visualización de datos
permitió una representación clara y eficiente de la infor-
mación recolectada. Los datos de distancia, transmitidos
en tiempo real a través del puerto serie, se graficaron
en un radar digital que muestra la ubicación y distancia
de los objetos detectados. Esta visualización facilita el
análisis y la interpretación de los datos, mejorando la ca-
pacidad de tomar decisiones informadas en aplicaciones
prácticas de telecomunicaciones.
‚ La decisión de limitar el rango de detección a 1 metro
respondió a las limitaciones inherentes del sensor ul-
trasónico en condiciones experimentales especı́ficas. Fac-
tores como la dispersión de la señal, interferencias y
reflexiones en superficies irregulares afectaron las lecturas
más allá de este rango. Este ajuste es una demostración
de la importancia de calibrar los sensores y ajustar los
parámetros del sistema según las especificaciones técnicas
y las condiciones del entorno operativo.
VII. R ECOMENDACIONES
1. Optimización del Rango del Sensor
‚ Selección del Sensor: Considerar el uso de sensores
ultrasónicos de mayor precisión y alcance si se requiere
extender la distancia de detección más allá de 1 metro.
Existen sensores en el mercado que pueden ofrecer mejor
rendimiento en distancias mayores con menor atenuación
de la señal.
‚ Calibración Regular: Realizar calibraciones periódicas
del sensor para asegurar la precisión de las lecturas.
Esto es crucial en aplicaciones donde la exactitud de la
distancia es fundamental para el correcto funcionamiento
del sistema.
2. Mejora del Movimiento del Servomotor
‚ Control de Velocidad: Implementar un control más
preciso de la velocidad del servomotor para garantizar
movimientos suaves y evitar vibraciones que puedan
afectar las lecturas del sensor.