En este tutorial de Arduino, le mostraré cómo puede hacer este radar de aspecto atractivo utilizando la placa Arduino y el entorno de desarrollo de procesamiento. Puede ver el siguiente video o leer el tutorial escrito a continuación para obtener más detalles.

Componentes necesarios para este proyecto Arduino

• Sensor ultrasónico HC-SR04
• Servomotor
• Placa Arduino
• Protoboard y cables de salto 

Construyendo el 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 aseguré al servomotor con un tornillo como este.

• También adjunté un encabezado de pin en el que soldé 4 cables de puente para conectar el sensor.

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

Esquemas de circuito

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

 Aquí está el código fuente de Arduino con la descripción de cada línea del código:

// Incluye la biblioteca Servo
#include <Servo.h>. 
// Define los pines Tirg y Echo del sensor ultrasónico
const int trigPin = 10; 
const int echoPin = 11; 
// Variables para la duración y la distancia
larga duración;
int distancia;
Servo myServo; // Crea un objeto servo para controlar el servomotor
configuración vacía () {  
  pinMode ( trigPin, SALIDA ) ; // Establece el trigPin como salida
  pinMode ( echoPin, INPUT ) ; // Establece el echoPin como entrada
  De serie. comenzar ( 9600 ) ;
  myServo. adjuntar ( 12 ) ; // Define en qué pin está conectado el servomotor
}
bucle vacío () {  
  // gira el servomotor de 15 a 165 grados
  para ( int i = 15; i < = 165; i ++ ) {  
  myServo. escribir ( i ) ;
  retraso ( 30 ) ;
  distancia = calcularDistancia () ; // Llama a una función para calcular la distancia medida por el sensor ultrasónico para cada grado
  
  De serie. imprimir ( i ) ; // Envía el grado actual al puerto serie
  De serie. imprimir ( "," ) ; // Envía un carácter de adición justo al lado del valor anterior necesario más adelante en el IDE de procesamiento para la indexación
  De serie. imprimir ( distancia ) ; // Envía el valor de la distancia al puerto serie
  De serie. imprimir ( "." ) ; // Envía un carácter de adición justo al lado del valor anterior necesario más adelante en el IDE de procesamiento para la indexación
  }
  // Repite las líneas anteriores de 165 a 15 grados
  para ( int i = 165; i > 15; i-- ) {  
  myServo. escribir ( i ) ;
  retraso ( 30 ) ;
  distancia = calcularDistancia () ;
  De serie. imprimir ( i ) ;
  De serie. imprimir ( "," ) ;
  De serie. imprimir ( distancia ) ;
  De serie. imprimir ( "." ) ;
  }
}
// Función para calcular la distancia medida por el sensor ultrasónico
int calcularDistancia () {  
  
  digitalWrite ( trigPin, BAJO ) ;
  delayMicroseconds ( 2 ) ;
  // Establece el trigPin en estado ALTO durante 10 microsegundos
  digitalWrite ( trigPin, HIGH ) ;
  delayMicroseconds ( 10 ) ;
  digitalWrite ( trigPin, BAJO ) ;
  duración = pulseIn ( echoPin, HIGH ) ; // Lee el echoPin, devuelve el tiempo de viaje de la onda de sonido en microsegundos
  distancia = duración * 0.034 / 2;
  distancia de regreso ;
}

Ahora recibiremos los valores para el ángulo y la distancia medidos por el sensor desde la placa Arduino al IDE de procesamiento 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. Esta variable se utilizará para dibujar el radar, las líneas, los objetos detectados y parte del texto.

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

void drawRadar () {  
  pushMatrix () ;
  traducir ( 960,1000 ) ; // mueve las coordenadas iniciales a una nueva ubicación
  noFill () ;
  strokeWeight ( 2 ) ;
  accidente cerebrovascular ( 98,245,31 ) ;
  // dibuja las líneas del arco
  arco ( 0,0,1800,1800, PI, TWO_PI ) ;
  arco ( 0,0,1400,1400, PI, TWO_PI ) ;
  arco ( 0,0,1000,1000, PI, TWO_PI ) ;
  arco ( 0,0,600,600, PI, TWO_PI ) ;
  // dibuja las líneas angulares
  línea ( -960,0,960,0 ) ;
  line ( 0,0, -960 * cos ( radianes ( 30 )) , -960 * sin ( radianes ( 30 ))) ;
  line ( 0,0, -960 * cos ( radianes ( 60 )) , -960 * sin ( radianes ( 60 ))) ;
  line ( 0,0, -960 * cos ( radianes ( 90 )) , -960 * sin ( radianes ( 90 ))) ;
  line ( 0,0, -960 * cos ( radianes ( 120 )) , -960 * sin ( radianes ( 120 ))) ;
  line ( 0,0, -960 * cos ( radianes ( 150 )) , -960 * sin ( radianes ( 150 ))) ;
  línea ( -960 * cos ( radianes ( 30 )) , 0,960,0 ) ;
  popMatrix () ;
}

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 vuelve a dibujar para cada grado.

void drawLine () {  
  pushMatrix () ;
  strokeWeight ( 9 ) ;
  accidente cerebrovascular ( 30,250,60 ) ;
  traducir ( 960,1000 ) ; // mueve las coordenadas iniciales a una nueva ubicación
  línea ( 0,0,950 * cos ( radianes ( iAngle )) , -950 * sin ( radianes ( iAngle ))) ; // dibuja la línea según el ángulo
  popMatrix () ;
}

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 () ;
  traducir ( 960,1000 ) ; // mueve las coordenadas iniciales a una nueva ubicación
  strokeWeight ( 9 ) ;
  accidente cerebrovascular ( 255,10,10 ) ; // color rojo
  pixsDistance = iDistance * 22.5 ; // cubre la distancia desde el sensor de cm a píxeles
  // limitando el alcance a 40 cms
  si ( iDistance < 40 ) {
    // dibuja el objeto según el ángulo y la distancia
  line ( pixsDistance * cos ( radianes ( iAngle )) , -pixsDistance * sin ( radianes ( iAngle )) , 950 * cos ( radianes ( iAngle )) , -950 * sin ( radianes ( iAngle ))) ;
  }
  popMatrix () ;
}

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 el desenfoque de movimiento y el desvanecimiento lento de la línea en movimiento.

vacío dibujar () {  
  
  llenar ( 98,245,31 ) ;
  textFont ( orcFont ) ;
  // simulando el desenfoque de movimiento y el desvanecimiento lento de la línea en movimiento
  noStroke () ;
  llenar ( 0,4 ) ;
  rect ( 0, 0, ancho, 1010 ) ;
  
  llenar ( 98,245,31 ) ; // color verde
  // llama a las funciones para dibujar el radar
  drawRadar () ;
  drawLine () ;
  drawObject () ;
  drawText () ;
}

Aquí está el código fuente de procesamiento completo del radar Arduino:

procesamiento de importación. serial . *; // biblioteca de importaciones para comunicación en serie
importar java. awt . evento . KeyEvent ; // importa la biblioteca para leer los datos del puerto serie
importar java. io . IOException ;
Serial myPort; // define Object Serial
// defube variables
Ángulo de cuerda = "" ;
Distancia de la cuerda = "" ;
String data = "" ;
String noObject;
float pixsDistance;
int iAngle, iDistance;
int index1 = 0;
int index2 = 0;
PFont orcFont;
configuración vacía () {  
  
 tamaño ( 1920, 1080 ) ; 
 suave () ;
myPort = new Serial ( esto , "COM4" , 9600 ) ; // inicia la comunicación serial 
myPort. bufferUntil ( '.' ) ; // lee los datos desde el puerto serie hasta el carácter '.'. Entonces en realidad dice esto: ángulo, distancia.
orcFont = loadFont ( "OCRAExtended-30.vlw" ) ;
}
vacío dibujar () {  
  
  llenar ( 98,245,31 ) ;
  textFont ( orcFont ) ;
  // simulando el desenfoque de movimiento y el desvanecimiento lento de la línea en movimiento
  noStroke () ;
  llenar ( 0,4 ) ;
  rect ( 0, 0, ancho, 1010 ) ;
  
  llenar ( 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 serial   
 // lee los datos del puerto serie hasta el carácter '.' y lo coloca en la variable String "datos".
  datos = myPort. readStringUntil ( '.' ) ;
  datos = datos. subcadena ( 0, datos. longitud () -1 ) ;
  
  índice1 = datos. indexOf ( "," ) ; // busca el carácter ',' y lo coloca en la variable "index1"
  ángulo = datos. subcadena ( 0, índice1 ) ; // lee los datos desde la posición "0" hasta la posición de la variable index1 o ese es el valor del ángulo que la placa Arduino envió al puerto serie
  distancia = datos. subcadena ( índice1 + 1, datos. longitud ()) ; // lee los datos desde la posición "index1" hasta el final de los datos pr ese es el valor de la distancia
  
  // convierte las variables String en Integer
  iAngle = int ( ángulo ) ;
  iDistance = int ( distancia ) ;
}
void drawRadar () {  
  pushMatrix () ;
  traducir ( 960,1000 ) ; // mueve las coordenadas iniciales a una nueva ubicación
  noFill () ;
  strokeWeight ( 2 ) ;
  accidente cerebrovascular ( 98,245,31 ) ;
  // dibuja las líneas del arco
  arco ( 0,0,1800,1800, PI, TWO_PI ) ;
  arco ( 0,0,1400,1400, PI, TWO_PI ) ;
  arco ( 0,0,1000,1000, PI, TWO_PI ) ;
  arco ( 0,0,600,600, PI, TWO_PI ) ;
  // dibuja las líneas angulares
  línea ( -960,0,960,0 ) ;
  line ( 0,0, -960 * cos ( radianes ( 30 )) , -960 * sin ( radianes ( 30 ))) ;
  line ( 0,0, -960 * cos ( radianes ( 60 )) , -960 * sin ( radianes ( 60 ))) ;
  line ( 0,0, -960 * cos ( radianes ( 90 )) , -960 * sin ( radianes ( 90 ))) ;
  line ( 0,0, -960 * cos ( radianes ( 120 )) , -960 * sin ( radianes ( 120 ))) ;
  line ( 0,0, -960 * cos ( radianes ( 150 )) , -960 * sin ( radianes ( 150 ))) ;
  línea ( -960 * cos ( radianes ( 30 )) , 0,960,0 ) ;
  popMatrix () ;
}
void drawObject () {  
  pushMatrix () ;
  traducir ( 960,1000 ) ; // mueve las coordenadas iniciales a una nueva ubicación
  strokeWeight ( 9 ) ;
  accidente cerebrovascular ( 255,10,10 ) ; // color rojo
  pixsDistance = iDistance * 22.5 ; // cubre la distancia desde el sensor de cm a píxeles
  // limitando el alcance a 40 cms
  si ( iDistance < 40 ) {
    // dibuja el objeto según el ángulo y la distancia
  line ( pixsDistance * cos ( radianes ( iAngle )) , -pixsDistance * sin ( radianes ( iAngle )) , 950 * cos ( radianes ( iAngle )) , -950 * sin ( radianes ( iAngle ))) ;
  }
  popMatrix () ;
}
void drawLine () {  
  pushMatrix () ;
  strokeWeight ( 9 ) ;
  accidente cerebrovascular ( 30,250,60 ) ;
  traducir ( 960,1000 ) ; // mueve las coordenadas iniciales a una nueva ubicación
  línea ( 0,0,950 * cos ( radianes ( iAngle )) , -950 * sin ( radianes ( iAngle ))) ; // dibuja la línea según el ángulo
  popMatrix () ;
}
void drawText () { // dibuja los textos en la pantalla  
  
  pushMatrix () ;
  if ( iDistance > 40 ) { 
  noObject = "Fuera de rango" ;
  }
  else { 
  noObject = "Dentro del rango" ;
  }
  llenar ( 0,0,0 ) ;
  noStroke () ;
  rect ( 0, 1010, ancho, 1080 ) ;
  llenar ( 98,245,31 ) ;
  textSize ( 25 ) ;
  texto ( "10cm" , 1180,990 ) ;
  texto ( "20cm" , 1380,990 ) ;
  texto ( "30cm" , 1580,990 ) ;
  texto ( "40cm" , 1780,990 ) ;
  textSize ( 40 ) ;
  text ( "Objeto:" + noObject, 240, 1050 ) ;
  texto ( "Ángulo:" + iAngle + "°" , 1050, 1050 ) ;
  texto ( "Distancia:" , 1380, 1050 ) ;
  si ( iDistance < 40 ) { 
  texto ( "" + iDistance + "cm" , 1400, 1050 ) ;
  }
  textSize ( 25 ) ;
  llenar ( 98,245,60 ) ;
  traducir ( 961 + 960 * cos ( radianes ( 30 )) , 982-960 * sin ( radianes ( 30 ))) ;
  rotar ( - radianes ( -60 )) ;
  texto ( "30 °" , 0,0 ) ;
  resetMatrix () ;
  traducir ( 954 + 960 * cos ( radianes ( 60 )) , 984-960 * sin ( radianes ( 60 ))) ;
  rotar ( - radianes ( -30 )) ;
  texto ( "60 °" , 0,0 ) ;
  resetMatrix () ;
  traducir ( 945 + 960 * cos ( radianes ( 90 )) , 990-960 * sin ( radianes ( 90 ))) ;
  rotar ( radianes ( 0 )) ;
  texto ( "90 °" , 0,0 ) ;
  resetMatrix () ;
  traducir ( 935 + 960 * cos ( radianes ( 120 )) , 1003-960 * sin ( radianes ( 120 ))) ;
  rotar ( radianes ( -30 )) ;
  texto ( "120 °" , 0,0 ) ;
  resetMatrix () ;
  traducir ( 940 + 960 * cos ( radianes ( 150 )) , 1018-960 * sin ( radianes ( 150 ))) ;
  rotar ( radianes ( -60 )) ;
  texto ( "150 °" , 0,0 ) ;
  popMatrix () ;
}

howtomechatronics.com