Construye un Sistema Radar con Arduino: Sensor Ultrasónico y Servo – Guía Paso a Paso

En este tutorial de Arduino te mostraré cómo puedes hacer este radar de aspecto genial usando la placa Arduino y el entorno de desarrollo Processing. Puedes ver el siguiente vídeo o leer el tutorial escrito a continuación para más detalles.

Visión General

Todo lo que necesitas para este proyecto de Arduino es un sensor ultrasónico para detectar objetos, un pequeño servomotor de hobby para rotar el sensor y una placa Arduino para controlarlos.

Componentes Necesarios para este Proyecto Arduino

Puedes conseguir estos componentes en cualquiera de los sitios a continuación:

• Sensor Ultrasónico HC-SR04 …………
• Servomotor………………………………..
• Placa Arduino ……………………………
• Protoboard y cables jumpers ………

Construcción del Dispositivo

• Primero hice un soporte de cartón para conectar el sensor ultrasónico al servomotor. Lo doblé como se muestra en la imagen de abajo, lo pegué y lo aseguré al servomotor usando un tornillo así.

• También conecté un conector de pines en el que soldé 4 cables jumpers para conectar el sensor.

• Finalmente aseguré el servomotor a la placa Arduino usando una banda elástica.

También hay soportes de montaje especiales para el sensor ultrasónico de Banggood. Puedes conseguirlos en los siguientes enlaces:

• Sensor Ultrasónico con Soporte de Montaje ………
• Soporte de Montaje para Medición Ultrasónica …….. Banggood

Esquema del Circuito Radar Arduino

Conecté el sensor ultrasónico HC-SR04 a los pines 10 y 11 y el servomotor al pin 12 en la placa Arduino.

Códigos Fuente

Ahora necesitamos hacer un código y subirlo a la placa Arduino que permita la interacción entre Arduino y el IDE de Processing. Para entender cómo funciona la conexión, haz clic aquí para visitar mi tutorial de Arduino y Processing.

Aquí está el Código Fuente Arduino con descripción de cada línea:

// Incluye la librería Servo
 #include <Servo.h>.
// Define pines Trig y Echo del Sensor Ultrasónico
 const int trigPin = 10;
 const int echoPin = 11;
// Variables para la duración y la distancia
 long duration;
 int distance;
 Servo myServo; // Crea un objeto servo para controlar el servomotor
 void setup() {
 pinMode(trigPin, OUTPUT); // Configura trigPin como salida
 pinMode(echoPin, INPUT); // Configura echoPin como entrada
 Serial.begin(9600);
 myServo.attach(12); // Define en qué pin está conectado el servomotor
 }
 void loop() {
 // Rota el servomotor de 15 a 165 grados
 for(int i=15;i<=165;i++){
 myServo.write(i);
 delay(30);
 distance = calculateDistance();// Llama a una función para calcular la distancia medida por el sensor ultrasónico para cada grado
 Serial.print(i); // Envía el grado actual al Puerto Serie
 Serial.print(","); // Envía carácter adicional junto al valor anterior necesario luego en Processing IDE para indexar
 Serial.print(distance); // Envía el valor de distancia al Puerto Serie
 Serial.print("."); // Envía carácter adicional junto al valor anterior necesario luego en Processing IDE para indexar
 }
// Repite las líneas anteriores de 165 a 15 grados
 for(int i=165;i>15;i--){
 myServo.write(i);
 delay(30);
 distance = calculateDistance();
 Serial.print(i);
 Serial.print(",");
 Serial.print(distance);
 Serial.print(".");
 }
 }
// Función para calcular la distancia medida por el sensor ultrasónico
 int calculateDistance(){
 digitalWrite(trigPin, LOW);
 delayMicroseconds(2);
 // Pone trigPin en estado HIGH por 10 microsegundos
 digitalWrite(trigPin, HIGH);
 delayMicroseconds(10);
 digitalWrite(trigPin, LOW);
 duration = pulseIn(echoPin, HIGH); // Lee echoPin, devuelve tiempo de viaje de onda sonora en microsegundos
 distance= duration*0.034/2;
 return distance;
 } Lenguaje: Arduino (arduino)

Ahora recibiremos los valores del ángulo y la distancia medida por el sensor desde la placa Arduino en el IDE de Processing usando la función SerialEvent() que lee los datos del puerto serie y pondremos los valores del ángulo y la distancia en las variables iAngle e iDistance. Estas variables se usarán para dibujar el radar, las líneas, los objetos detectados y parte del texto.

Para dibujar el radar hice esta función drawRadar() que consiste en funciones arc() y line().

void drawRadar() {
 pushMatrix();
 translate(960,1000); // mueve las coordenadas de inicio a nueva ubicación
 noFill();
 strokeWeight(2);
 stroke(98,245,31); // dibuja las líneas de arco
 arc(0,0,1800,1800,PI,TWO_PI);
 arc(0,0,1400,1400,PI,TWO_PI);
 arc(0,0,1000,1000,PI,TWO_PI);
 arc(0,0,600,600,PI,TWO_PI);
// dibuja las líneas de ángulo
 line(-960,0,960,0);
 line(0,0,-960*cos(radians(30)),-960*sin(radians(30)));
 line(0,0,-960*cos(radians(60)),-960*sin(radians(60)));
 line(0,0,-960*cos(radians(90)),-960*sin(radians(90)));
 line(0,0,-960*cos(radians(120)),-960*sin(radians(120)));
 line(0,0,-960*cos(radians(150)),-960*sin(radians(150)));
 line(-960*cos(radians(30)),0,960,0);
 popMatrix();
 }Lenguaje: Arduino (arduino)

Para dibujar la línea que se mueve a lo largo del radar hice esta función drawLine(). Su centro de rotación se establece con la función translate() y usando la función line() en la que se usa la variable iAngle, la línea se redibuja para cada grado.

void drawLine() {
 pushMatrix();
 strokeWeight(9);
 stroke(30,250,60);
 translate(960,1000); // mueve las coordenadas de inicio a nueva ubicación
 line(0,0,950*cos(radians(iAngle)),-950*sin(radians(iAngle))); // dibuja la línea según el ángulo
 popMatrix();
 }Lenguaje: Arduino (arduino)

Para dibujar los objetos detectados hice esta función drawObject() . Obtiene la distancia del sensor ultrasónico, la transforma en píxeles y en combinación con el ángulo del sensor dibuja el objeto en el radar.

void drawObject() {
 pushMatrix();
 translate(960,1000); // mueve las coordenadas de inicio a nueva ubicación
 strokeWeight(9);
 stroke(255,10,10); // color rojo
 pixsDistance = iDistance*22.5; // convierte la distancia del sensor de cm a píxeles
 // limitando el rango a 40 cms
 if(iDistance<40){
 // dibuja el objeto según el ángulo y la distancia
 line(pixsDistance*cos(radians(iAngle)),-pixsDistance*sin(radians(iAngle)),950*cos(radians(iAngle)),-950*sin(radians(iAngle)));
 }
 popMatrix();
 }Lenguaje: Arduino (arduino)

Para el texto en la pantalla hice la función drawText() que dibuja textos en ubicaciones particulares.

Todas estas funciones se llaman en la función principal draw() que se repite todo el tiempo y dibuja la pantalla. También aquí estoy usando esta función fill() con 2 parámetros para simular desenfoque de movimiento y desvanecimiento lento de la línea en movimiento.

void draw() {
 fill(98,245,31);
 textFont(orcFont);
// simulando desenfoque de movimiento y desvanecimiento lento de la línea en movimiento
 noStroke();
 fill(0,4);
 rect(0, 0, width, 1010);
 fill(98,245,31); // color verde
 // llama a las funciones para dibujar el radar
 drawRadar();
 drawLine();
 drawObject();
 drawText();
 }Lenguaje: Arduino (arduino)

Aquí está la apariencia final del radar:

Aquí está el código fuente completo de Processing del Radar Arduino:

import processing.serial.*; // importa librería para comunicación serial
 import java.awt.event.KeyEvent; // importa librería para leer datos del puerto serie
 import java.io.IOException;
 Serial myPort; // define Objeto Serial
 // define variables
 String angle="";
 String distance="";
 String data="";
 String noObject;
 float pixsDistance;
 int iAngle, iDistance;
 int index1=0;
 int index2=0;
 PFont orcFont;
 void setup() {
 size (1920, 1080);
 smooth();
 myPort = new Serial(this,"COM4", 9600); // inicia la comunicación serial
 myPort.bufferUntil('.'); // lee los datos del puerto serie hasta el carácter '.'. Así que en realidad lee esto: ángulo,distancia.
 orcFont = loadFont("OCRAExtended-30.vlw");
 }
 void draw() {
 fill(98,245,31);
 textFont(orcFont);
// simulando desenfoque de movimiento y desvanecimiento lento de la línea en movimiento
 noStroke();
 fill(0,4);
 rect(0, 0, width, 1010);
 fill(98,245,31); // color verde
 // llama a las funciones para dibujar el radar
 drawRadar();
 drawLine();
 drawObject();
 drawText();
 }
 void serialEvent (Serial myPort) {
// comienza a leer datos del Puerto Serie
 // lee los datos del Puerto Serie hasta el carácter '.' y los pone en la variable String "data".
 data = myPort.readStringUntil('.');
 data = data.substring(0,data.length()-1);
 index1 = data.indexOf(","); // encuentra el carácter ',' y lo pone en la variable "index1"
 angle= data.substring(0, index1); // lee los datos de la posición "0" a la posición de la variable index1 o ese es el valor del ángulo que la placa Arduino envió al Puerto Serie
 distance= data.substring(index1+1, data.length()); // lee los datos de la posición "index1" al final de los datos que es el valor de la distancia
 // convierte las variables String en Integer
 iAngle = int(angle);
 iDistance = int(distance);
 }
 void drawRadar() {
 pushMatrix();
 translate(960,1000); // mueve las coordenadas de inicio a nueva ubicación
 noFill();
 strokeWeight(2);
 stroke(98,245,31);
// dibuja las líneas de arco
 arc(0,0,1800,1800,PI,TWO_PI);
 arc(0,0,1400,1400,PI,TWO_PI);
 arc(0,0,1000,1000,PI,TWO_PI);
 arc(0,0,600,600,PI,TWO_PI);
// dibuja las líneas de ángulo
 line(-960,0,960,0);
 line(0,0,-960*cos(radians(30)),-960*sin(radians(30)));
 line(0,0,-960*cos(radians(60)),-960*sin(radians(60)));
 line(0,0,-960*cos(radians(90)),-960*sin(radians(90)));
 line(0,0,-960*cos(radians(120)),-960*sin(radians(120)));
 line(0,0,-960*cos(radians(150)),-960*sin(radians(150)));
 line(-960*cos(radians(30)),0,960,0);
 popMatrix();
 }
 void drawObject() {
 pushMatrix();
 translate(960,1000); // mueve las coordenadas de inicio a nueva ubicación
 strokeWeight(9);
 stroke(255,10,10); // color rojo
 pixsDistance = iDistance*22.5; // convierte la distancia del sensor de cm a píxeles
 // limitando el rango a 40 cms
 if(iDistance<40){
 // dibuja el objeto según el ángulo y la distancia
 line(pixsDistance*cos(radians(iAngle)),-pixsDistance*sin(radians(iAngle)),950*cos(radians(iAngle)),-950*sin(radians(iAngle)));
 }
 popMatrix();
 }
 void drawLine() {
 pushMatrix();
 strokeWeight(9);
 stroke(30,250,60);
 translate(960,1000); // mueve las coordenadas de inicio a nueva ubicación
 line(0,0,950*cos(radians(iAngle)),-950*sin(radians(iAngle))); // dibuja la línea según el ángulo
 popMatrix();
 }
 void drawText() {
// dibuja los textos en la pantalla
 pushMatrix();
 if(iDistance>40) {
 noObject = "Out of Range";
 } else {
 noObject = "In Range";
 }
 fill(0,0,0);
 noStroke();
 rect(0, 1010, width, 1080);
 fill(98,245,31);
 textSize(25);
 text("10cm",1180,990);
 text("20cm",1380,990);
 text("30cm",1580,990);
 text("40cm",1780,990);
 textSize(40);
 text("Object: " + noObject, 240, 1050);
 text("Angle: " + iAngle + " °", 1050, 1050);
 text("Distance: ", 1380, 1050);
 if(iDistance<40) {
 text(" " + iDistance + " cm", 1400, 1050);
 }
 textSize(25);
 fill(98,245,60);
 translate(961+960*cos(radians(30)),982-960*sin(radians(30)));
 rotate(-radians(-60));
 text("30°",0,0);
 resetMatrix();
 translate(954+960*cos(radians(60)),984-960*sin(radians(60)));
 rotate(-radians(-30));
 text("60°",0,0);
 resetMatrix();
 translate(945+960*cos(radians(90)),990-960*sin(radians(90)));
 rotate(radians(0));
 text("90°",0,0);
 resetMatrix();
 translate(935+960*cos(radians(120)),1003-960*sin(radians(120)));
 rotate(radians(-30));
 text("120°",0,0);
 resetMatrix();
 translate(940+960*cos(radians(150)),1018-960*sin(radians(150)));
 rotate(radians(-60));
 text("150°",0,0);
 popMatrix();
 } Lenguaje: Arduino (arduino)

Nueva versión actualizada del código Radar Arduino para adaptarse a cualquier resolución de pantalla:

Solo cambia los valores en la función size(), con tu resolución de pantalla.

/* Proyecto Radar Arduino
 *
 * Versión actualizada. ¡Se adapta a cualquier resolución de pantalla!
 * Solo cambia los valores en la función size(),
 * con tu resolución de pantalla.
 *
 * por Dejan Nedelkovski,
 * www.HowToMechatronics.com
 * */
 import processing.serial.*; // importa librería para comunicación serial
 import java.awt.event.KeyEvent; // importa librería para leer datos del puerto serie
 import java.io.IOException;
 Serial myPort; // define Objeto Serial
 // define variables
 String angle="";
 String distance="";
 String data="";
 String noObject;
 float pixsDistance;
 int iAngle, iDistance;
 int index1=0;
 int index2=0;
 PFont orcFont;
 void setup() {
 size (1920, 1080); // ***CAMBIA ESTO A TU RESOLUCIÓN DE PANTALLA***
 smooth();
 myPort = new Serial(this,"COM4", 9600); // inicia la comunicación serial
 myPort.bufferUntil('.'); // lee los datos del puerto serie hasta el carácter '.'. Así que en realidad lee esto: ángulo,distancia.
 orcFont = loadFont("OCRAExtended-30.vlw");
 }
 void draw() {
 fill(98,245,31);
 textFont(orcFont);
// simulando desenfoque de movimiento y desvanecimiento lento de la línea en movimiento
 noStroke();
 fill(0,4);
 rect(0, 0, width, height-height*0.065);
 fill(98,245,31); // color verde
 // llama a las funciones para dibujar el radar
 drawRadar();
 drawLine();
 drawObject();
 drawText();
 }
 void serialEvent (Serial myPort) {
// comienza a leer datos del Puerto Serie
 // lee los datos del Puerto Serie hasta el carácter '.' y los pone en la variable String "data".
 data = myPort.readStringUntil('.');
 data = data.substring(0,data.length()-1);
 index1 = data.indexOf(","); // encuentra el carácter ',' y lo pone en la variable "index1"
 angle= data.substring(0, index1); // lee los datos de la posición "0" a la posición de la variable index1 o ese es el valor del ángulo que la placa Arduino envió al Puerto Serie
 distance= data.substring(index1+1, data.length()); // lee los datos de la posición "index1" al final de los datos que es el valor de la distancia
 // convierte las variables String en Integer
 iAngle = int(angle);
 iDistance = int(distance);
 }
 void drawRadar() {
 pushMatrix();
 translate(width/2,height-height*0.074); // mueve las coordenadas de inicio a nueva ubicación
 noFill();
 strokeWeight(2);
 stroke(98,245,31);
// dibuja las líneas de arco
 arc(0,0,(width-width*0.0625),(width-width*0.0625),PI,TWO_PI);
 arc(0,0,(width-width*0.27),(width-width*0.27),PI,TWO_PI);
 arc(0,0,(width-width*0.479),(width-width*0.479),PI,TWO_PI);
 arc(0,0,(width-width*0.687),(width-width*0.687),PI,TWO_PI);
// dibuja las líneas de ángulo
 line(-width/2,0,width/2,0);
 line(0,0,(-width/2)*cos(radians(30)),(-width/2)*sin(radians(30)));
 line(0,0,(-width/2)*cos(radians(60)),(-width/2)*sin(radians(60)));
 line(0,0,(-width/2)*cos(radians(90)),(-width/2)*sin(radians(90)));
 line(0,0,(-width/2)*cos(radians(120)),(-width/2)*sin(radians(120)));
 line(0,0,(-width/2)*cos(radians(150)),(-width/2)*sin(radians(150)));
 line((-width/2)*cos(radians(30)),0,width/2,0);
 popMatrix();
 }
 void drawObject() {
 pushMatrix();
 translate(width/2,height-height*0.074); // mueve las coordenadas de inicio a nueva ubicación
 strokeWeight(9);
 stroke(255,10,10); // color rojo
 pixsDistance = iDistance*((height-height*0.1666)*0.025); // convierte la distancia del sensor de cm a píxeles
 // limitando el rango a 40 cms
 if(iDistance<40){
 // dibuja el objeto según el ángulo y la distancia
 line(pixsDistance*cos(radians(iAngle)),-pixsDistance*sin(radians(iAngle)),(width-width*0.505)*cos(radians(iAngle)),-(width-width*0.505)*sin(radians(iAngle)));
 }
 popMatrix();
 }
 void drawLine() {
 pushMatrix();
 strokeWeight(9);
 stroke(30,250,60);
 translate(width/2,height-height*0.074); // mueve las coordenadas de inicio a nueva ubicación
 line(0,0,(height-height*0.12)*cos(radians(iAngle)),-(height-height*0.12)*sin(radians(iAngle))); // dibuja la línea según el ángulo
 popMatrix();
 }
 void drawText() {
// dibuja los textos en la pantalla
 pushMatrix();
 if(iDistance>40) {
 noObject = "Out of Range";
 } else {
 noObject = "In Range";
 }
 fill(0,0,0);
 noStroke();
 rect(0, height-height*0.0648, width, height);
 fill(98,245,31);
 textSize(25);
 text("10cm",width-width*0.3854,height-height*0.0833);
 text("20cm",width-width*0.281,height-height*0.0833);
 text("30cm",width-width*0.177,height-height*0.0833);
 text("40cm",width-width*0.0729,height-height*0.0833);
 textSize(40);
 text("Object: " + noObject, width-width*0.875, height-height*0.0277);
 text("Angle: " + iAngle + " °", width-width*0.48, height-height*0.0277);
 text("Distance: ", width-width*0.26, height-height*0.0277);
 if(iDistance<40) {
 text(" " + iDistance + " cm", width-width*0.225, height-height*0.0277);
 }
 textSize(25);
 fill(98,245,60);
 translate((width-width*0.4994)+width/2*cos(radians(30)),(height-height*0.0907)-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();
 translate(width-width*0.513+width/2*cos(radians(120)),(height-height*0.07129)-width/2*sin(radians(120)));
 rotate(radians(-30));
 text("120°",0,0);
 resetMatrix();
 translate((width-width*0.5104)+width/2*cos(radians(150)),(height-height*0.0574)-width/2*sin(radians(150)));
 rotate(radians(-60));
 text("150°",0,0);
 popMatrix();
 }Lenguaje: Arduino (arduino)