Índice

– Introducción

– Materiales necesarios       

– Fase de pruebas previas       

– Realización y diseño del prototipo            

– Montaje del Hardware y Circuito             

– Desarrollo del Software   

– Comentarios Personales         

– Anexo            

Introducción

El sonar es una tecnología que solemos asociar con los submarinos o la navegación marítima, aunque también está presente en la naturaleza en animales como los murciélagos o los delfines. Su funcionamiento se basa en un principio físico fundamental: emitir un sonido y escuchar el eco que rebota para saber a qué distancia se encuentra un objeto.

El objetivo de nuestro proyecto es replicar esta tecnología a nivel de prototipo. La idea principal ha sido diseñar y construir un sistema de sonar funcional que sea capaz de detectar obstáculos en su entorno y representar su posición en la pantalla de un ordenador en tiempo real, junto con un LED, el cual permanecerá de un color mientras no se detecte ningún objeto y cambiará en el momento en que se produzca una detección, se incorporará también un zumbador que permanecerá silencioso durante la fase de búsqueda y que, en cuanto se detecte cualquier objeto a una cierta distancia que impondremos, emitirá una melodía.

Para hacerlo posible, hemos combinado dos potentes herramientas del mundo de la electrónica y la programación: Arduino y Processing. La placa Arduino actúa como el «cerebro» del sistema, controlando el movimiento de los sensores y tomando las medidas de distancia. Por otro lado, el entorno Processing se encarga de la parte visual, recibiendo esos datos y dibujando una interfaz gráfica similar a la de un radar convencional.

A lo largo de esta memoria, explicaremos paso a paso cómo hemos llevado a cabo el montaje de los componentes, cómo funcionan los programas informáticos que controlan el sistema y, finalmente, analizaremos los resultados obtenidos tras realizar las pruebas de funcionamiento.

Materiales necesarios

Para la construcción de nuestro prototipo de sonar, hemos empleado una combinación de componentes electrónicos, materiales de montaje y software específico. A continuación, detallamos la lista completa de los elementos necesarios:

1. Componentes Electrónicos y Módulos

• Placa de desarrollo Arduino: Hemos utilizado un Arduino Uno R3, que actúa como la unidad central de control del proyecto.
• Sensor Ultrasónico: Se empleó un módulo HC-SR04. Este componente es el responsable de emitir el pulso de sonido y recibir el eco para medir la distancia.
• Servomotor: Utilizamos un micro servomotor, modelo SG90. Su función es rotar el sensor ultrasónico para realizar el barrido angular.
• Placa de Pruebas (Protoboard): Una protoboard estándar para facilitar las conexiones temporales del circuito sin necesidad de soldar.
• Cables de Conexión: Varios cables tipo macho-macho y macho-hembra para interconectar el Arduino, el sensor , el led , el buzzer y el servomotor.
• LED RGB: Una luz led, que cambiará de color durante la búsqueda y la detección de objetos.
• Zumbador: Conectado a la protoboard y activado con la señal eléctrica de la Arduino y que se mantendrá en silencio durante la búsqueda y emitirá una melodía cuando se detecta un objeto a menos de 30 cm.
• Resistencias 220Ω: Hemos colocado dos resistencias de 220Ω en algunas patillas del LED RGB.

2. Materiales de Montaje y Estructura

• Pieza de Cartón Rígido: Un pequeño rectángulo de cartón (dimensiones aproximadas 8×4 cm) que sirve como soporte para montar el sensor ultrasónico sobre el brazo del servomotor.
• Caja de cartón: Esta caja emula la estructura de un submarino, luego decorado para darle más realismo, actuando como soporte del servomotor, y de la placa protoboard y la Arduino.
• Cinta de precinto: Utilizada para fijar el cuerpo del servomotor a la caja de cartón que actúa como estructura del submarino.
• Cinta de pintor: Esta nos sirvió de ayuda para realizar la pintura con los sprays de manera que no ensuciáramos y destrozáramos las partes ya pintadas, y así poder hacerlo de manera precisa y perfecta.
• Sprays de pintura: Compramos unos sprays, de colores azul y amarillo, para proporcionar un toque más llamativo y decorado a nuestro prototipo, dándole un mayor acercamiento a la imagen de un submarino.
• Cutter: Utilizamos un cutter afilado para poder recortar y darle más rango de giro al servomotor, y espacio al cableado que lo conecta para su funcionamiento.

3. Software

• Arduino IDE: El entorno de desarrollo integrado oficial de Arduino (versión 1.8.x o superior). Lo usamos para programar y cargar el sketch (sonarduino.ino) en la placa.
• Processing IDE: El entorno de desarrollo de Processing utilizado para ejecutar el programa (sonarduino.pde) que recibe los datos del puerto serie y genera la visualización gráfica del sonar.

4. Herramientas Auxiliares

• Computadora Personal: Necesaria para utilizar los entornos IDE y para ejecutar la visualización de Processing.
• Cable USB: Para conectar la placa Arduino a la computadora, tanto para alimentarla como para la comunicación de datos.

Fase de pruebas previas

Antes de ensamblar el proyecto final, consideramos fundamental realizar una serie de pruebas preliminares. El objetivo de esta fase era validar el funcionamiento de cada componente de hardware (sensor ultrasónico y servomotor) de forma aislada. Este enfoque nos permite aislar problemas y asegurarnos de que cada pieza funciona según lo esperado antes de integrarlas.

Prueba 1: Radar Estático (Validación del Sensor HC-SR04)

La primera prueba consistió en implementar un «radar» estático, como el mencionado anteriormente. El objetivo era verificar la correcta conexión y la precisión del sensor ultrasónico HC-SR04.

Metodología: Se montó un circuito simple con el Arduino y el sensor. El código de prueba no utiliza el servomotor, simplemente mide la distancia de un objeto colocado frente al sensor y muestra el resultado en centímetros a través del Monitor Serie del IDE de Arduino.

Código de Prueba (Sensor Ultrasónico): Este sketch nos permitió confirmar que el sensor estaba cableado correctamente y que la fórmula para convertir el tiempo de eco en distancia era la adecuada.

Resultados de la Prueba 1: Al ejecutar este código y mover un objeto (como la mano) delante del sensor, pudimos observar en el Monitor Serie cómo los valores de distancia cambiaban de forma coherente y precisa. Esto validó el funcionamiento del sensor.

Prueba 2: Barrido del Servomotor

La segunda prueba se centró en asegurar el correcto funcionamiento y el rango de movimiento del servomotor SG90.

Metodología: Utilizamos el ejemplo «Sweep» (barrido) de la librería estándar Servo.h de Arduino. El objetivo era verificar que el servo podía moverse suavemente en el rango angular que necesitaríamos para el sonar (de 15 a 165 grados).

Código de Prueba (Servomotor): Este sketch simplemente mueve el servo de un extremo al otro de su rango.

Prototipo inicial

Después de realizar estas pruebas iniciales, diseñamos un prototipo inicial, que mostraremos su funcionamiento con videos en el a nexo.

Se basaba en el mismo funcionamiento, pero estaba toda la placa sobre nuestro soporte, y encontramos varios problemas, como que nuestra protoboard se tambaleaba mucho, ya que tenia mucho peso encima y el servomotor la estaba girando, y no aguantaba el equilibrio bien. Otra razón fue, que el servo y el HC consumían mucho voltaje los dos juntos, ya que estaban conectados a través de un cable puente a 5V, y el servomotor necesitaba más voltaje para funcionar fluido.

Por estas razones decidimos cambiar el protototipo inicial al final, el que os explicaremos a continuación como intentamos solventar estos problemas.

Realización y diseño del prototipo

Esta sección describe el proceso de ensamblaje y programación del sistema de sonar. Hemos dividido el proceso en dos grandes fases: el montaje del hardware y la configuración del software que le da vida.

1. Montaje del Hardware y Circuito

El primer paso fue ensamblar la parte física del sonar. El objetivo era crear una unidad compacta donde el servomotor pudiera rotar el sensor ultrasónico de forma estable.

Montaje Estructural:

1. Primero, fijamos el servomotor (SG90) al cartón que simulamos como si fuese el submarino y lo unimos con los cables a la placa Arduino Uno. Para esto, utilizamos cinta de precinto para que quede fijo al cartón de manera que no se mueva el servomotor pero si su hélice.
2. A continuación, unimos el pequeño trozo de cartón al brazo (o hélice) del servomotor a través de cinta de precinto dejando únicamente un hueco para que se una con el servomotor.
3. Ahora insertamos los 4 pines del sensor ultrasónico (HC-SR04) a través del cartón, de manera que el sensor «mire» hacia adelante. Este soporte de cartón es lo que permite que, al girar el servo, gire también el sensor. Para conectar los pines del sensor a la placa se ha usado cables macho hembra
4. Finalmente pintamos la caja que simula el submarino y que es la base de todo de color amarillo y azul para que quedara un poco más estético.

Conexiones Eléctricas:

Las conexiones se realizaron de la siguiente manera:

Alimentación General

• Conectamos el pin GND (Tierra) del Arduino a la línea negativa (-) de la protoboard.

Servomotor (SG90)

• Cable Rojo (VCC): Conectado al pin 5V del Arduino
  • Cable Marrón (GND): Conectado a la línea negativa (-) de la protoboard.
  • Cable Amarillo (Señal): Conectado al pin digital D12 del Arduino.

Sensor Ultrasónico (HC-SR04)

• Pin VCC: Conectado al pin digital D6 del Arduino
  • Pin GND: Conectado a la línea negativa (-) de la protoboard.
  • Pin Trig: Conectado al pin digital D10 del Arduino.
  • Pin Echo: Conectado al pin digital D11 del Arduino.

Led RGB

• Patilla Larga (Cátodo): Conectamos a la línea negativa (-) de la protoboard.
  • Patilla Roja (R):
    • Colocamos una resistencia 220 Ω en esta pata.
    • Conectamos el otro extremo de la resistencia al Pin Digital 8.
  • Patilla Verde (G):
    • Colocamos una resistencia 220 Ω en esta pata.
    • Conectamos el otro extremo de la resistencia al Pin Digital 9
  • Patilla Azul (B):
    • La dejamos desconectada, ya que nuestro código indica Azul=unused y no se utiliza.

Buzzer

• Positivo (+) / Patilla larga: Conectar al Pin Digital 7
  • Negativo (-) / Patilla corta: Conectar a línea negativa (-) protoboard.

Con estos pasos, el hardware queda completamente ensamblado y listo para recibir el software.

2. Desarrollo del Software

ARDUINO

Importa la librería Servo de Arduino que permite controlar fácilmente el servomotor.

Estas constantes nos indican donde conectamos los pines de los diferentes componentes de Arduino.

ANG_MIN es el ángulo mínimo del barrido del radar y ANG_MAX el máximo. SERVO_DELAY es el tiempo en miliseg que esperas entre cada paso del servo.

Crea un objeto tipo Servo para controlar el attach() y write(). La variable angulo guarda el ángulo actual, inicializado en 90 grados. Paso indica de cuánto en cuánto cambia el ángulo en cada iteración. Distancia guarda la última distancia medida por el HC-SR04.

Esto nos permite hacer el pitido cuando el objeto está cerca.

Primero necesitamos que el pin TRIG esté en LOW para resetear el sensor. Después enviamos un pulso de 10 microsegundos al pin TRIG usando ese tiempo para medirlo posteriormente. En la variable duracion se mide con pulseIn() cuánto tiempo ha estado el pin en HIGH. Convertimos ese tiempo en distancia.

Se configuran los pines para que sean de salida o entrada, dependiendo de si van a enviar algo o recibirlo. Sespués se inicia la comunicación serie a 9600 baudios. Después ponemos el servo en la posición inicial con write() y por último, le decimos al Servo en qué pin está conectado.

Primero se mueve el servo al ángulo actual esperando un poco entre cada movimiento con SERVO_DELAY. La variable distancia llama a medirDistanciaCM(). Envía los datos al Processing con el formato correcto (distancia;angulo). A continuación actualiza el barrido sumando o restando uno a paso, dependiendo de donde esté. Por último si el objeto está a menos de 30 cm el led se pone en rojo y suena la melodía en el buzzer. Si está lejos el led se ilumina en verde y no suena melodía.

PROCESSING

El código comienza con un import, permitiendo a Processing hablar con el Arduino por el puerto COM. Después se declara una variable llamada puerto de tipo Serial; será el canal de comunicación entre Processing y Arduino.

Se guarda en la variable PORT el nombre del puerto serie que usa Arduino. En nuestro caso es COM3. También se define la velocidad de comunicación en baudios, coincidiendo con el Serial.begin(9600) de Arduino.

Definimos las constantes que indican el rango completo posible del servo.

DIST_MAX_HW es el rango máximo físico del sensor HC-SR04. distMaxVisual es la escala actual del radar en pantalla, cambiando cuando se mueve la rueda del ratón. DIST_MIN_VIS es el límite mínimo del zoom. DIST_MAX_VIS es el límite máximo de zoom.

angSteps calcula cuántos valores de ángulo tenemos en total. En nuestro caso tenemos 181 valores. ultimaDist crea un array donde se guarda la última distancia medida para cada ángulo. Esto nos permite dibujar el mapa de calor.

distanciaActual guarda la últia distancia recibida por serie Se usa para mostrar en el HUD y para actualizar ultimaDist. Empieza en -1 para decir que no hay lectura. anguloActual guarda el último ángulo recibido desde Arduino. Lo usa la función dibujarBarrido() para colocar la línea del radar.

Cx y cy son las coordenadas del centro del radar en la ventana. Se inicializan en setup() usando width y height. Radar es el radio máximo del radar en píxeles. radSteps es el número de anillos internos que se usan para dibujar el heatmap. Cuantos más radSteps más suave y detallado se ve el radas, pero se dibuja más lento.

Con size(900, 600, P2D) se crea una ventana de 900×600 pixeles usando un render 2D acelerado. Smooth(8) activa el suavizado de los bordes para que las líneas y círculos no se vean pixelados. En cx coloca el radar en el centro horizontal y cy coloca el radar casi abajo del todo para que el abanico salga hacia arriba. Radio hace que el radar ocupe gran parte de la ventana.

El for reocrre todas las posiciones del array ultimaDist y pone en cada una un valor mayor que el rango máximo. Eso significa que no ha detectado nada todavía en ese ángulo, así el radar no dibuja nada de inicio hasta que recibe los datos reales. colorMode cambia el color. Por último muestra en consola la lista de puertos disponibles, abre el puerto serie COM3 a 9600 baudios usando this como sketch de Processing e indica que no llame a serialEvent() hasta que reciba un salto de línea \n.

Processing llama a draw() muchas veces por segundo. Dentro hacemos con background(0) que el fondo de la ventana se ponga en negro cada frame, borrando toda la pantalla antes de dibujar todo. dibujarAbanicoBase() dibuja la estructura del radar. dibujarHeatmap() dibuja los puntos del color según las distancias guardadas en ultimaDist. dibujarBarrido() dibuja la línea de barrido que sigue el ángulo del servo. Por último, dibujarHUD() dibuja el texto.

Esta función es clave, tansformando el ángulo que viene del servo (grados) al ángulo que se usa para dibujar en pantalla (radianes). Además, le aplico una simetría (180 – deg) para que la dirección de giro del servo coincida visualmente con la dirección de la línea en el radar.

strokeWeight(3) indica que el grosor de las líneas sea de 3 píxeles. Stroke pone el color del trazo en verde brillante. noFill() hace que no rellene el interior de figuras. La función arc(…) dibuja el semicírculo centrado en cx y cy. En el bucle se dibujan las líneas radiales. Por último line(…) dibuja una línea horizontal de izquierda a derecha en la base del semicírculo, siendo la base del radar.

noStroke() le dice a Processing que solo dibuje relleno, no contorno. Con ello conseguimos que los puntos del radar sean círculos sólidos. El primer for recorre todos los ángulos, de 0 a 180. aRad coge el ángulo en radiantes para dibujar y distMedida es la última distancia registrada para ese ángulo. En el segundo for, ir recorre desde el centro del radar hasta el borde, en radSteps. Cada map(…) convierte cada paso ir en una distancia en cm y dMid es la distancia central de esa capa. Después calculamos la intensidad con la que se pinta, contra más cerca más brillante y si la intensidad es baja ni se pinta. También si no hay intensidad no dibujamos. Se calcula la posición en pantalla con r0, r1, rMid, x e y. Se elige el color dependiendo de la intesidad mediante lerp() que interpola entre verde y rojo. B y alpha calculan el brillo y la transparencia dependiendo de la intensidad. Por último, se dibuja el punto: se calcula el color con fill(), con size() el tamaño y eclipse() dibuja el “eco”.

stroke() y strokeWight() indican el estilo de la línea de barrido. aRad usa el ángulo actual del servo recibido desde Arduino y lo pasa a ángulo de pantalla ya reflejado. Con line() se dibuja la línea desde el centro del radar hasta la punta. Por último se dibuja un punto en la punta para remarcar la posición.

Define que el color del texto es verde, alineandolo arriba a la izquierda. Muestra el titulo, la última distancia medida, el último ángulo recibido y la escala actual del radar que cambia con la rueda del ratón.

Esta función se llama automáticamente cuando llega una línea nueva por serie, gracias a puerto.bufferUntil(‘\n’). Primero lee una línea completa, quitando espacios y retornos con  trim(). Si la línea está vacía se sale. Después busca el separador “;”, ya que el formato es distancia;angulo. Si no lo encuentra descarta la línea. Separa distancia y ángulo como String. Convierte ambas distancias en enteros y las guarda en las variables locales. El constrain() limita el ángulo entre DEG_MIN y DEG_MAX. Por último se actualiza el array ultimaDist: si la distancia es válida (mayor que 0 y dentro del rango del sensor) se guarda d en el hueco del array, sino se marca como “sin objeto”.

Esta es la última función, que permite al usuario hacer zoom sobre el radar. Al mover la rueda, se ajusta el valor de distMaxVisual, que es el rango máximo de distancia que se representa gráficamente, dentro de unos límites máximos y mínimos.

Comentarios Personales

Problemas Encontrados

En un principio, durante el inicio del desarrollo de nuestro proyecto, encontramos un inconveniente, y es que el servomotor que a priori nos venía en el kit entregado, no funcionaba desde un primer momento, por lo que por nuestra cuenta hemos tenido que comprar uno de forma externa, costándonos alrededor de 14 euros, y resultando un atraso a la hora de empezar nuestro proyecto del sonar.

Luego, durante el desarrollo del prototipo, queríamos haber puesto el detector de movimiento, HC-SR04 más lejos, pero nos ha resultado imposible, ya que necesitábamos cables de tipo entrada-salida, por lo que hemos tenido que cambiar el diseño de salida que habíamos explicado.

En mitad del desarrollo, también hemos detectado que los cables que nos venían en el kit no eran los más adecuados y algunos fallaban y no funcionaban, lo que nos ha obligado a tener que cambiar de forma reiterada cada uno de ellos e ir comprobando los para poder realizarlo y que nos ha retrasado a la hora de querer continuar con el desarrollo de nuestro proyecto.

Tiempo después, en uno de los días habituales que seguimos con nuestro proyecto, la protoboard dejo de funcionar correctamente, dejándonos estancados durante el desarrollo del prototipo. Esto nos impedía el poder conectar distintas partes desde la arduino a la protoboard, ya que, el HC-SR04, el led, el zumbador y el servomotor los conectábamos a 5V en la arduino, pero no funcionaba todo correctamente, ya que cuando ejecutábamos el código, el servomotor, conectado con cables a la protoboard no giraba, ya que era como si la protoboard no consiguiera dar la suficiente corriente a los dispositivos que conectamos en ella, siendo un impedimento a la hora de poder avanzar y terminar el prototipo.

Críticas Constructivas

A la hora de elegir el proyecto a diseñar y desarrollar, podríamos a ver sido más eficientes a la hora de elegir cierto diseño, ya que los cables que nos venían en el kit no eran los más adecuados para poder construir lo pensado desde un primer momento, por lo que, debido a eso, tuvimos que realizar alguna que otra modificación al diseño, sumado al problema del servomotor. Entonces, como idea general, podríamos haber escogido un diseño más adaptado a nuestras limitaciones.

Evaluación Del Tiempo Dedicado

La realización del prototipo no ha sido fácil, y nos ha obligado a dedicar bastantes sesiones para poder llegar a la versión definitiva. Además del trabajo en casa, cuando veíamos que algo no salía como debía y debíamos solucionarlo. Aproximadamente el prototipo nos has llevado alrededor de un mes para poder concretarlo, quedando dos o tres días por semana varias horas para poder avanzar y poder dejarlo lo más preparado posible a la hora de llegar a la presentación, en nuestro caso, del día 12 de diciembre. Con esto llegamos a la suma de aproximadamente 28 horas.

Anexo