El sensor de ultrasonidos es el dispositivo ideal para medir distancias usando Arduino. Uno de los sensores de distancia más populares es el sensor HC-SR04. Este sensor ultrasónico es muy económico, versátil y muy fácil de usar y programar.
¿Qué son los ultrasonidos?
Los ultrasonidos son ondas sonoras cuyo rango de frecuencias es superior a los 20.000 Hz. Estas frecuencias no son percibidas por el oído humano, pero si pueden ser percibidas por algunos animales, entre estos, quizá el caso más conocido es el mejor amigo del hombre: el perro.
Los ultrasonidos tienen muchas aplicaciones en diferentes campos como la física, la industria, o la medicina.
Una de las aplicaciones más antiguas y conocidas en el uso de los ultrasonidos es el sonar, que, en base al efecto de la eco localización, se utiliza en la detección y la localización de objetos.
Se basa en la emisión de una señal ultrasónica hacia un objeto. Este objeto recibe esta señal refleja parte de ella hacia el emisor.
Aplicando algunos conocimientos básicos sobre la propagación de las ondas sonoras y mediante algunos sencillos cálculos matemáticos, es posible determinar a qué distancia se encuentra el objeto del emisor.
Algunos animales como el murciélago o los delfines usan este mecanismo en forma natural para para orientarse y cazar.
Esta aplicación de los ultrasonidos en muy usada en control de navegación de barcos y submarinos, así como en radares, análisis sismográfico y en las ecografías médicas.
¿Qué es un sensor de ultrasonidos?
Un sensor de ultrasonidos es un dispositivo que puede medir la distancia a un objeto mediante el uso de ondas de sonido.
El sensor mide la distancia enviando una onda de sonido a una frecuencia específica y escuchando esa onda de sonido de regreso, al rebotar esta contra algún objeto u obstáculo.
Usando un microcontrolador que registre el tiempo transcurrido entre la onda de sonido que se está generando y la onda de sonido que rebota, es posible calcular la distancia entre el sensor y el objeto.
¿Cómo funciona un sensor de ultrasonidos?
Un sensor de ultrasonidos consta básicamente de un generador de señal y un micrófono transductor. Hay modelos que usan un emisor y transductor separados, y otros que lo combinan en un solo dispositivo.
Su operación es bastante sencilla. El emisor ultrasónico vibra a una frecuencia por encima del rango de la audición humana, y el transductor recibe la señal de eco. El sensor determina la distancia a un objetivo mediante la medición del lapso de tiempo entre el envío y la recepción del pulso ultrasónico.
¿Cómo se calcula la distancia con un sensor de ultrasonidos?
El sensor de ultrasonidos fundamenta su operación en base a la física del sonido. Las señales sonoras viajan a través del aire a una velocidad aproximada de 344 m/s.
Para calcular la distancia de un objeto u obstáculo desde el sensor, se puede usar la siguiente ecuación:
Distancia = (Velocidad del sonido x Tiempo) / 2
El trayecto que recorre la señal de ultrasonido se compone de dos partes. Una inicial, que corresponde a la salida del emisor hacia el objeto, y una final, que corresponde al eco de la señal desde el objeto hacia el micrófono transductor. A mayor distancia, mayor tiempo.
Dado que la señal recorre el doble de la distancia (desde el sensor hacia el objeto y viceversa) el tiempo es el doble de lo corresponde a la distancia real del objeto respecto al sensor. Por ello, al multiplicar el tiempo por la velocidad del sonido, el resultado debe ser divido a la mitad.
Hay que considerar que la precisión del sensor ultrasónico puede verse afectada por la temperatura y la humedad del aire en el que se está utilizando.
También es importante comprender que algunos sensores ultrasónicos no detectan algunos objetos. Esto se debe a que algunos objetos son de algun material especifico, tienen forma o posición de tal manera que la onda de sonido es absorbido y/o rebota en el objeto, y el eco no llega con suficiente energia o simplemente rebota hacia otro sitio pero no hacia el sensor ultrasónico.
También es posible que el objeto sea demasiado pequeño para reflejar una cantidad suficiente de la onda de sonido para que el sensor lo detecte. Otros objetos pueden absorber la onda de sonido todos juntos (tela, alfombras, etc.), lo que significa que no hay forma de que el sensor los detecte con precisión. Estos son factores importantes a tener en cuenta al diseñar y programar, por ejemplo, un robot con un sensor ultrasónico.
El sensor de ultrasonidos HC-SR04
El sensor HC-SR04 es un sensor de distancia ultrasónico de bajo costo, con un rango de operación entre 2 cm a 400 cm.
Es uno de los sensores más populares, muy utilizado en una amplia variedad de proyectos. Destaca por su pequeño tamaño, bajo consumo energético, y buena precisión, además de ser muy económico.
El sensor HC-SR04 posee dos transductores, un emisor y un receptor piezoeléctricos, además de la electrónica necesaria para su operación.
El funcionamiento del sensor es bastante sencillo. El emisor piezoeléctrico emite 8 pulsos de ultrasonido a una frecuencia de 40KHz luego de recibir la orden en el pin TRIGGER.
La señal de rebote o eco es detectada por el receptor piezoeléctrico. El pin ECHO cambia a de nivel bajo a nivel alto al finalizar la transmisión de la señal de ultrasonidos, y cambia a nivel bajo cuando la señal de eco es recibida.
El ancho del pulso es equivalente al tiempo total desde que la señal fue emitida hasta que la señal de eco fue recibida.
La efectividad del sensor está sujeta al ángulo relativo y a la forma en que refleja y/o absorbe la señal de ultrasonidos el material del objeto u obstáculo.
Características del sensor HC-SR04
- Alimentación de 5 volts
- Interfaz sencilla: Solamente 4 hilos Vcc, Trigger, Echo, GND
- Rango de medición: desde 2 cm a 400 cm
- Corriente de alimentación: 15 mA
- Frecuencia del pulso: 40 Khz
- Apertura del pulso ultrasónico: 15º
- Señal de disparo: 10uS
- Dimensiones del módulo: 45x20x15 mm.
Como usar el sensor HC-SR04 con la placa Arduino
Para que nuestra placa Arduino pueda usar el sensor HC-SR04, solo son necesarias cuatro líneas de conexión: 2 pines digitales, alimentación 5V y GND. De los dos pines digitales a usar, uno ira destinado como salida al pin trigger el sensor, y el otro se conectará al pin echo como entrada.
El sensor iniciara su actividad al recibir un pulso de nivel alto en su pin trigger. El sensor enviara el tren de pulsos y comenzara a medir la distancia.
En el pin echo el sensor devuelve al microcontrolador un pulso, cuyo ancho es proporcional al tiempo que tarda la señal de ultrasonidos en viajar desde el emisor al objeto y luego de vuelta al sensor.
El pin echo genera un pulso de tamaño variable, entre 150uS hasta 25mS. Si no hay obstáculos, el ancho máximo del pulso es 38mS.
Para el cálculo de la distancia se usa la siguiente formula:
Distancia (cm) = Ancho de pulso (uS) / 58
Conexiones entre el sensor HC-SR04 y la placa Arduino
La conexión del sensor con Arduino UNO es muy sencilla. Esta puede hacerse o en forma directa con cables, o usando un protoboard. Para nuestro diseño de pruebas, haremos las siguientes conexiones:
- Pin 5V de Arduino con pin 5V del sensor.
- Pin GND de Arduino con pin GND del sensor.
- Pin 2 de Arduino con pin echo del sensor.
- Pin 3 de Arduino con pin trigger del sensor.
Se puede usar para los pines trigger y echo cualquiera de los pines del 2 al 12 de la placa Arduino UNO.
Ejemplos de programación del sensor HC-SR04
Tenemos a disposición dos maneras de usar el sensor HC-SR04 con la placa Arduino UNO, ambas muy sencillas, aunque una lo es más que la otra.
Una manera de usar el sensor es controlarlo en forma directa sin el uso de librerías especiales. El codigo del sketch para el Arduino IDE es el siguiente:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 |
/* * Sensor de ultrasonidos * Version de codigo sin usar librerias * * https://www.proyectoarduino.com * */ const int pinEcho = 2; const int pinTrigger = 3; int sensor(int pinTrigger, int pinEcho) { long duracionPulso, distancia; // Iniciamos el sensor enviando un pulso alto // al pin trigger por un lapso de 10uS // Prepara el sensor enviando un pulso bajo al trigger digitalWrite(pinTrigger, LOW); delayMicroseconds(5); // Envia el pulso de trigger por 10uS digitalWrite(pinTrigger, HIGH); delayMicroseconds(10); // Finaliza el pulso de trigger digitalWrite(pinTrigger, LOW); // Tomamos medida del ancho del pulso en el pin echo duracionPulso = pulseIn(pinEcho, HIGH); // La lectura del pulso esta en microsegundos // Obtenemos lectura de distancia en centimetros distancia = duracionPulso / 58; return distancia; } void setup() { // Inicia la consola Serial.begin(9600); // Configura los pines de control del sensor pinMode(pinEcho, INPUT); pinMode(pinTrigger, OUTPUT); } void loop() { // Iniciamos lectura de la distancia int distancia = sensor(pinTrigger, pinEcho); // Presenta los resultados Serial.print("Lectura de Distancia: "); Serial.println(distancia); // Espera un segundo y vuelta a empezar delay(1000); } |
La otra manera de usar el sensor es con la librería NewPing. Para instalarla, buscala en el gestor de librerías del Arduino IDE.
Las mejoras que ofrece la librería NewPing es a posibilidad de no solo usar el sensor HC-SR04, sino también el sensor HC-SR05. Este último se diferencia del HC-SR04 en que combina en un solo pin las señales de trigger y echo.
Adicionalmente, esta librería a ser desarrollada como una clase en C++, permite usar fácilmente varios sensores HC-SR04 o HC-SR05 a la vez. Tambien introduce mejoras en las lecturas de la distancia mediante filtros de ruido.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 |
/* * Sensor de ultrasonidos * Version de codigo usanlo libreria NewPing * * https://www.proyectoarduino.com * */ #include <NewPing.h> const int pinTrigger = 2; const int pinEcho = 3; const int distanciaMaxima = 200; NewPing sensor(pinTrigger, pinEcho, distanciaMaxima); void setup() { // Inicia la consola Serial.begin(9600); } void loop() { // Espera 50mS antes de la siguiente lectura de distancia // El valor minimo posible es 30mS delay(50); // Inicio de la lectura de distncia en centimetros // Si devuelve cero, la lectura esta fuera de rango Serial.print(sensor.ping_cm()); Serial.println("cm"); } |
Como hacer un medidor de distancias con el sensor HC-SR04
Este es un pequeño ejemplo de un uso bastante útil del sensor de ultrasonidos HC-SR04, como detector de proximidad. Se basa en el primer programa, con las siguientes variantes:
- Tiene definido un valor de distancia mínima
- Cuando la distancia mínima se alcanza, se enciende el led conectado al pin 13
- Da aviso en la consola de la alarma por proximidad
El programa toma la lectura de distancia y la compara con un valor mínimo de distancia pre definido. Cada segundo la placa Arduino UNO ordena al sensor a hacer una lectura de distancia.
Si la lectura es mayor a la distancia prefijada no hay ningún tipo de aviso. Si esta distancia es menor a la prefijada se dan los avisos de alarma mediante el led y la consola.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 |
/* * Sensor de ultrasonidos como alarma * Version de codigo sin usar librerias * * https://www.proyectoarduino.com * */ const int pinEcho = 2; const int pinTrigger = 3; const int pinLed = 13; const int distanciaAlarma = 10; // Valor en centimetros int sensor(int pinTrigger, int pinEcho) { long duracionPulso, distancia; // Iniciamos el sensor enviando un pulso alto // al pin trigger por un lapso de 10uS // Prepara el sensor enviando un pulso bajo al trigger digitalWrite(pinTrigger, LOW); delayMicroseconds(5); // Envia el pulso de trigger por 10uS digitalWrite(pinTrigger, HIGH); delayMicroseconds(10); // Finaliza el pulso de trigger digitalWrite(pinTrigger, LOW); // Tomamos medida del ancho del pulso en el pin echo duracionPulso = pulseIn(pinEcho, HIGH); // La lectura del pulso esta en microsegundos // Obtenemos lectura de distancia en centimetros distancia = duracionPulso / 58; return distancia; } void setup() { // Inicia la consola Serial.begin(9600); // Configura los pines de control del sensor pinMode(pinEcho, INPUT); pinMode(pinTrigger, OUTPUT); // Configura el pin del led pinMode(pinLed, OUTPUT); } void loop() { // Iniciamos lectura de la distancia int distancia = sensor(pinTrigger, pinEcho); if (distancia <= distanciaAlarma) { digitalWrite(pinLed, HIGH); // Presenta los resultados Serial.println("¡ALARMA! Objeto muy cercano."); } else { digitalWrite(pinLed, LOW); } // Espera un segundo y vuelta a empezar delay(1000); } |
Una mejora a este diseño de alarma seria incorporar un buzzer a alguno de los pines libres de la placa para que dé también un aviso sonoro. El diseño modificado quedaría de la siguiente manera:
En este caso, se ha colocado un buzzer conectado al pin 9 y a GND. Y el código modificado seria el siguiente:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 |
/* * Sensor de ultrasonidos como alarma con buzzer * Version de codigo sin usar librerias * * https://www.proyectoarduino.com * */ const int pinEcho = 2; const int pinTrigger = 3; const int pinLed = 13; const int distanciaPreAlarma = 25; // Valor en centimetros const int distanciaAlarma = 10; // Valor en centimetros const int buzzer = 9; //buzzer en el pin 9 int sensor(int pinTrigger, int pinEcho) { long duracionPulso, distancia; // Iniciamos el sensor enviando un pulso alto // al pin trigger por un lapso de 10uS // Prepara el sensor enviando un pulso bajo al trigger digitalWrite(pinTrigger, LOW); delayMicroseconds(5); // Envia el pulso de trigger por 10uS digitalWrite(pinTrigger, HIGH); delayMicroseconds(10); // Finaliza el pulso de trigger digitalWrite(pinTrigger, LOW); // Tomamos medida del ancho del pulso en el pin echo duracionPulso = pulseIn(pinEcho, HIGH); // La lectura del pulso esta en microsegundos // Obtenemos lectura de distancia en centimetros distancia = duracionPulso / 58; return distancia; } void setup() { // Inicia la consola Serial.begin(9600); // Configura los pines de control del sensor pinMode(pinEcho, INPUT); pinMode(pinTrigger, OUTPUT); // Configura el pin del led pinMode(pinLed, OUTPUT); } void loop() { // Iniciamos lectura de la distancia int distancia = sensor(pinTrigger, pinEcho); if (distancia < distanciaPreAlarma && distancia > distanciaAlarma) { // Tono de un 1KHz, el objeto ha entrado en el rango de distancia tone(buzzer, 1000); // Desactiva led digitalWrite(pinLed, LOW); // Avisa el estado de alarma en a consola Serial.println("¡PRE-ALARMA! Objeto en rango de distancia."); } else if (distancia <= distanciaAlarma) { // Tono de un 2KHz, el objeto ha sobrepasado el rango de distancia tone(buzzer, 2000); // Activa led de alarma cercana digitalWrite(pinLed, HIGH); // Avisa el estado de alarma en a consola Serial.println("¡ALARMA! Objeto muy cercano."); } // En este caso, el objeto esta mas alla de la // distancia de pre-alarma else { // No emite ningun sonido noTone(buzzer); // Desactiva led digitalWrite(pinLed, LOW); } // Espera un segundo y vuelta a empezar delay(1000); } |
Las aplicaciones de un sensor de proximidad son muy amplias, entre ellas, detectar presencia, cierre o apertura de puertas, detección de paso de animales domésticos, etc.
