Radar Gráfico Con Arduino Y Processing

3,820

70

7

Hago locuras mezcladas con ciencia y tecnologia.

Intro: Radar Gráfico Con Arduino Y Processing

Hola! Mi nombre es Tadeo del canal de Youtube El Taller De TD, en el tutorial de hoy aprenderás a construir un radar con Arduino que grafica los resultados en tiempo real en tu computadora, todo esto usando pocos y simples materiales que puedes conseguir fácilmente. ¡Manos a la obra!

Step 1: Video Explicativo En Youtube

Si en algún momento del tutorial llegas a tener un problema o queres buscar una explicación hablada, entra al vídeo explicativo que hice para mi canal de Youtube. ¡Ahora si vamos a lo bueno!

Step 2: Materiales

Antes de empezar aclaro que este proyecto fue originalmente creado por How to Mechatronics, un sitio web de electrónica en ingles. Yo realice algunas modificaciones en el proyecto y en el código, pero a pesar de eso los invito a que visiten el proyecto original.

Los materiales que nesesitaremos son:

  1. Un Arduino UNO
  2. Un Sensor ultrasónico, en este caso utilizaremos el HC-SR04
  3. Un servo motor
  4. Un Buzzer
  5. Un protoboard
  6. Una buena cantidad de cables
  7. Y algo de cartón, como para fabricar una base.


Step 3: ¡Hagamos Las Conexiones!

Antes que nada fijamos el servo en un extremo de la base de cartón , no importa el método de fijación que utilices solo asegurate de que el componente quede bien adherido a la base. En mi caso utilice una pistola de silicona para todas las fijaciones

Luego de esto toma el resto de los componentes y algunos cables, es hora de realizar las conexiones.

Si ya conectaste todo lo que te debería de faltar es adherir el sensor ultrasónico al servo, para que este pueda trabajar correctamente y graficar los resultados. Para hacer esto tenemos 2 opciones, una es hacer una pequeña base de cartón donde entre el sensor y pegarla a la parte superior del servo, si no, podés imprimir un soporte más profesional y que te va a servir en futuros proyectos con una impresora 3D. Yo utilize el segundo método y te puedo decir que te podes ahorrar unos cuantos dolores de cabeza. La base que se ve en el video es impresa en 3D, la podes encontrar en este proyecto de Thingiverse, es una creación de drmcland.

Step 4: ¡Hora De Programar!

Ahora que ya tenemos la parte física del proyecto terminada toca adentrarse en el software del mismo, para esto utilizaremos dos herramientas diferentes, el IDE de Arduino y el IDE de Processing.

Toma el codigo de Arduino y copialo y pegalo en el editor. Si queres saber como funciona puedes leer los comentarios de cada línea.

Ahora que ya tenemos el código de Arduino proba con subirlo a la placa y asegurate de que el sistema se mueve y registre los datos correctamente, si es así continuemos con Processing.

Copia y pega el codigo de Processing en su IDE

En el código vemos que Processing se asemeja mucho a Java, esto se debe a que es un un lenguaje de programación y entorno de desarrollo integrado de código abierto basado en el mítico lenguaje de programación. De nuevo, mira los comentarios en el código y asegurate de entender el programa.

CódigoRadarArduino.ino

/*
Codigo originalmente creado por Dejan Nedelkovski de howtomechatronics.com
Traducido y modificado por El Taller de TD de youtube/eltallerdetd
*/
// Importa la libreria Servo
#include<Servo.h>.
// Define los pines del sensor ultrasonico Trig y Echo
constint trigPin = 10;
constint echoPin = 11;
// Variables de duracion y distancia
long duration;
int distance;
Servo myServo; // Crea el objeto myServo
voidsetup() {
pinMode(trigPin, OUTPUT); // Setea el pin trigPin como un Output
pinMode(echoPin, INPUT); // Setea el pin echoPin como un Input
Serial.begin(9600);
myServo.attach(12); // Define en que pin esta conectado el Servo motor
pinMode(8, OUTPUT); //Setea el pin 8 del buzzer como output
}
voidloop() {
// Rota el servo de 15 a 165 grados
for(int i=15;i<=165;i++){
myServo.write(i);
delay(30);
distance = calculateDistance();// Llama a esta funcion para calcular la distancia por cada grado
Serial.print(i); // Envia el grado de inclinacion actual al puerto serial
Serial.print(","); // Envia una , como caracter de separacion
Serial.print(distance); // Envia la distancia al puerto serial
Serial.print("."); // Envia un . como final de la orden
if(distance<20){ // Si la distancia es menor a 20cm el ruido sera mas agudo que si la distancia esta entre mayor a 20 y menor a 40
tone(8, 500, 100);
}elseif(distance>20 && distance<40){
tone(8, 200, 100);
}
}
// Repite las lineas previas y hace que ahora el servo vaya 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(".");
if(distance<20){ // Si la distancia es menor a 20cm el ruido sera mas agudo que si la distancia esta entre mayor a 20 y menor a 40
tone(8, 500, 100);
}elseif(distance>20 && distance<40){
tone(8, 200, 100);
}
}
}
// Funcion que calcula la distancia real con los datos que nos devuelve el sensor ultrasonico
intcalculateDistance(){
digitalWrite(trigPin, LOW);
delayMicroseconds(2);
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);
duration = pulseIn(echoPin, HIGH);
distance= duration*0.034/2;
return distance;
}

Radar Processing

/* Arduino Radar Project
*
* Version Actualizada. Se ajusta a cualquier resolucion!
* Tan solo cambia los valores en la funcion size() con los de tu pantalla.
*
*
* Codigo hecho por Dejan Nedelkovski,
* www.HowToMechatronics.com
*
* Traducido por El Taller De TD
* youtube/eltallerdetd
*
*/
import processing.serial.*; // Importa la libreria nesesaria para la comunicacion Serial
import java.awt.event.KeyEvent; // Importa la libreria para leer datos desde el puerto Serial
import java.io.IOException;
Serial myPort; // define el objeto serial
// define las 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 CON LOS VALORES DE TU RESOLUCION***
smooth();
myPort = new Serial(this,"COM3", 9600); // Comienza la comunicacion Serial, cambia el COM3 por el puerto que uses
myPort.bufferUntil('.'); // Lee los datos enviados al puerto serial, angulo,distancia.
orcFont = loadFont("OCRAExtended-30.vlw");
}
void draw() {
fill(98,245,31);
textFont(orcFont);
// Simulas efectos visuales y de transicion
noStroke();
fill(0,4);
rect(0, 0, width, height-height*0.065);
fill(98,245,31); // color verde
// Llama las funciones para dibujar el radar
drawRadar();
drawLine();
drawObject();
drawText();
}
void serialEvent (Serial myPort) { // Comienza a leer datos del puerto serial
// Pone la informacion leida en la variable data
data = myPort.readStringUntil('.');
data = data.substring(0,data.length()-1);
index1 = data.indexOf(","); // busca la , y la coloca en la variable index1
angle= data.substring(0, index1); // Lee desde la posicion 0 hasta el index1, osea el angulo
distance= data.substring(index1+1, data.length()); // Lee el resto, osea la distancia
// convierte los Strings a enteros
iAngle = int(angle);
iDistance = int(distance);
}
void drawRadar() {
pushMatrix();
translate(width/2,height-height*0.074);
noFill();
strokeWeight(2);
stroke(98,245,31);
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);
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);
strokeWeight(9);
stroke(255,10,10);
pixsDistance = iDistance*((height-height*0.1666)*0.025);
if(iDistance<40){
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); // moves the starting coordinats to new location
line(0,0,(height-height*0.12)*cos(radians(iAngle)),-(height-height*0.12)*sin(radians(iAngle))); // draws the line according to the angle
popMatrix();
}
void drawText() {
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();
}
view rawRadar Processing hosted with ❤ by GitHub

Step 5: Hora De Probar Nuestro Radar

Ahora que ya tenes todo lo que resta por hacer es subir nuevamente el código a nuestra placa Arduino y correr nuestro programa en Processing, si seguiste todos los pasos correctamente deberías ver la interfaz del radar en tu monitor. Si intentas poner algo adelante del sensor, las líneas verdes se tornaran rojas y sonaría nuestro buzzer avisandonos que el sistema encontró un obstáculo. El buzzer sonara con un tono diferente dependiendo de la distancia a la que se encuentre el obstáculo.

Step 6: ¡Choquemos Los 5!

¡Muy bien! Lo lograste ya tenes tu propio radar que grafica en tiempo real creado con Arduino y Processing. Si tienes alguna duda o algo salio mal no olvides dejar un comentario asi te ayudo a solucionarla. Y acordate que en mi canal de Youtube, o mas arriba en este instructable, podes encontrar un video explicativo sobre como desarollar este proyecto.

Share

    Recommendations

    • Audio Contest 2018

      Audio Contest 2018
    • Fix It! Contest

      Fix It! Contest
    • Tiny Home Contest

      Tiny Home Contest

    7 Discussions

    0
    None
    HGC

    4 months ago on Step 1

    This looks interesting, can you translate to English?

    2 replies
    0
    None
    Cold_War_RelicHGC

    Reply 3 months ago

    I opened the webpage in Chrome and it translated it automatically.

    0
    None
    eltallerdetdHGC

    Reply 4 months ago

    Hi HGC! I think that there are similar projects in english out there. Anyways i will try to do it! Thanks!