¡Bienvenido a una nueva entrada del curso de programación con Arduino!
En esta entrada del curso vamos a utilizar dos sensores de ultrasonido BAT para calcular la distancia a la que colocamos la mano, y después con un pequeño zumbador, o buzzer, reproduciremos un sonido.
Lista de materiales
- ZUM BT-328, placa Arduino o compatible.
- Sensor ultrasonidos Bat x2
- Módulo Zumbador
Conceptos que aprenderemos
En esta entrada vamos a aprender a utilizar el sensor de ultrasonidos para calcular la distancia en centímetros y utilizaremos la función Tone de Arduino para emitir sonidos por el zumbador.
Para conectar los sensores de ultrasonidos BAT, seguiremos las indicaciones de la tabla:
| Módulo Bat 1 | Módulo Bat 2 | |
| VCC | VCC | VCC |
| GND | GND | GND |
| ECHO | Pin 8 | Pin 9 |
| TRIGGER | Pin 10 | Pin 11 |
En la siguiente imagen puedes ver como se conectan los módulos a la placa.
El código
En el código de Arduino, comenzamos añadiendo la librería que usaremos para los ultrasonidos que te podrás bajar a través del siguiente enlace y tendrás que incluir en la carpeta de librerías dentro de Arduino:
|
1 |
#include "BitbloqUS.h" |
Posteriormente, declaramos las variables globales, que en este caso, serán solo las relativas a las conexiones de los pines.
|
1 2 3 4 |
int TP1 = 9, EP1 = 8; // Trigger Pin 1, Echo Pin 1 int TP2 = 11, EP2 = 10; // Trigger Pin 2, Echo Pin 2 int pinBuzzer = 5; |
Creamos dos objetos de tipo US que serán a través de los que controlaremos los ultrasonidos.
|
1 |
US bat1, bat2; |
Después, inicializamos el programa con la función setup:
|
1 2 3 4 5 |
void setup() { bat1.init(TP1,EP1); bat2.init(TP2,EP2); pinMode(pinBuzzer, OUTPUT); } |
En esta función, indicamos los pines que funcionarán como entrada, INPUT, y cuales lo harán como salida, OUTPUT.
El código de la función loop es:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
void loop() { int frec_maxima = 4000; //frecuencia maxima int distancia_frecuencia = bat1.read(); int distancia_tiempo = bat2.read(); distancia_frecuencia = constrain(distancia_frecuencia, 1, 20); distancia_tiempo = constrain(distancia_tiempo, 1, 10); // 1 equivale a 10 ms y 10 a 100ms distancia_frecuencia = map(distancia_frecuencia, 1, 20, 1, frec_maxima); distancia_tiempo = map(distancia_tiempo, 1, 10, 10, 100); // de (1,10) cm a (10,100)ms tone(pinBuzzer, distancia_frecuencia, distancia_tiempo); delay(distancia_tiempo); } |
Donde en primer lugar declaramos la variable local frec_maxima, que indica a Arduino cual será la frecuencia máxima a la que sonará el zumbador. Después declaramos las variables distancia_frecuencia y distancia_tiempo que almacenarán los datos de la distancia leída en los sensores de ultrasonidos, siendo las distancias que se utilizarán para modificar la frecuencia del sonido y el tiempo que se reproduce cada “nota”, respectivamente.
Para leer la distancia, utilizamos la función read. El código de esta librería se puede encontrar en la carpeta libraries/BitbloqUS/BitbloqUS.cpp dentro de Arduino. Si la abrimos, encontramos:
|
1 2 3 4 5 6 7 8 9 |
float US::read(){ long microseconds = US::TP_init(); long distance; distance = microseconds/29/2; if (distance == 0){ distance = _timeOut/29/2; } return distance; } |
Podéis ver como esta función llama a la función TP_init, la cual no tiene argumentos puesto que la función utiliza la variables _pinTrigger y _pinEcho que se han establecido al crear el objeto de esta clase. La función TP_init tiene el siguiente código:
|
1 2 3 4 5 6 7 8 9 10 11 |
long US::TP_init() { digitalWrite(_pinTrigger, LOW); delayMicroseconds(2); digitalWrite(_pinTrigger, HIGH); delayMicroseconds(10); digitalWrite(_pinTrigger, LOW); long microseconds = pulseIn(_pinEcho,HIGH,_timeOut); delay(29); return microseconds; } |
Dentro de esta función, cambiamos de estado los pines, y enviamos varias señales, de 2 y 10 microsegundos, a través del pin Trigger del sensor de ultrasonidos, y después utilizamos la función pulseIn en el pin Echo para calcular el tiempo que tarda el pin en cambiar su valor de alto a bajo. Dicho tiempo corresponde con el tiempo que ha tardado el pulso en recibirse desde que se ha enviado. Si quieres conocer más sobre esta función, puedes acceder a la página de referencia de Arduino para la función pulseIn.
La función TP_init retorna como dato el valor en microsegundos que da la función pulseIn y dentro de la función read utilizamos el valor en microsegundos que hemos recibido para calcular la distancia a la que se encuentra el objeto.
Una vez que hemos calculado las distancias para los dos sensores de ultrasonidos, utilizamos la función constrain, que vimos en el tutorial anterior, para obligar a que las lecturas que hemos realizado se encuentren dentro de ciertos margenes. Recuerda modificar los valores para practicar y aprender más.
Una vez que hemos utilizado la función constrain, utilizamos la función map, que vimos también en el tutorial anterior, para modificar el rango de los valores. En el caso de la variable distancia_tiempo, podría haberse multiplicado por 10 el valor, por lo que no era completamente necesario utilizar la función map.
Por último, hacemos sonar el zumbador con la orden tone:
|
1 2 |
tone(pinBuzzer, distancia_frecuencia, distancia_tiempo); delay(distancia_tiempo); |
La función tone es la encargada de reproducir el tono que sonará por el zumbador y tiene como parámetros, el pin al que esta conectado el zumbador, la frecuencia y el tiempo que sonará el tono. A continuación realizamos un delay del mismo tiempo del tono para que el tono se reproduzca completamente.
Como ejercicio puedes probar a modificar los valores de frecuencia mínima y máxima, las distancias, modificar la escala a la que se mapean los valores y ver el efecto que tiene sobre el zumbador.
En el siguiente vídeo se programa el mismo ejemplo de forma que no necesites utilizar la librería externa, puesto que programas en el mismo archivo las funciones que necesitas y que antes estaban incluidas en la librería, escribiendo más código.
¡Hasta la próxima!
