Sensor ultrasónico de distancia.

Más sobre medir el tiempo: delayMicroseconds ().

Más funciones disponibles: PulseIn ().

Importando una librería externa.

 

 

	Arduino UNO
	Una Protoboard mas  cables.
	Sensor de distancia HC-SR04
	diodo LED y resistencia.

 

 

Hemos visto, en los documentales, que los murciélagos son capaces de volar en completa oscuridad y sin embargo, sortear obstáculos o atrapar insectos en vuelo. Sabemos que lo hacen, pero rara vez pensamos como.

Tenemos una vaga idea de que se llama ecolocalización y que más o menos tiene que ver con unos sonidos agudos que emiten y que después recogen con esas enormes orejas que Dios les ha dado, pero rara vez nos planteamos cómo es esto posible.

Delfines y ballenas utilizan un sistema similar para atrapar a sus presas, y hasta hemos visto que, en cualquier película de submarinos, en el momento álgido el capitán ordena emitir un pulso único de sonar para localizar al enemigo.

El concepto básico, es siempre el mismo, sabiendo a qué velocidad viaja el sonido, si emitimos un pulso sónico corto y escuchamos cuanto tiempo tarda en regresar el eco podemos calcular la distancia a la que se encuentra el objeto en el que ha rebotado la señal.

• El radar funciona de modo similar aunque usando ondas de radio frecuencia muy cortasy con una problemática propia descomunal. Un pulso de radiofrecuencia se emite desde la antena y se recoge el eco que vuelve a la velocidad de la luz.

Lo que haremos en esta sesión es utilizar un sensor de distancia sencillo HC-SR04 (y muy parecido a los sensores de aparcamiento de los coches modernos), que nos permite enviar estos pulsos ultrasónicos y escuchar el eco de retorno. Midiendo este tiempo, podemos calcular la distancia hasta el obstáculo.

El oído humano no percibe sonidos por encima de 20kHz. Por eso, a las ondas de mayor frecuencia las llamamos ultrasonidos ( mas allá del sonido).  Los sensores de ultrasonidos funcionan sobre los 40 kHz.

No son perfectos, les influye la temperatura ambiente, la humedad y los materiales en los que reflejan, lo que genera una cierta incertidumbre. Pero a cambio son baratos y efectivos hasta un poco más de 3 metros en condiciones normales si la precisión no es un problema determinante

 

 

Veamos como conectar uno de esto detectores a nuestros Duinos. Aquí está el esquema eléctrico y de protoboard por cortesía de Fritzing:

Y de nuevo, el diagrama de conexión de la protoboard

 

Vamos con el programa, empezamos definiendo algunos valores:

#define trigPin 13
#define echoPin 12
#define led 2

Hasta ahora habíamos visto que podíamos definir una variable como int, por ejemplo, y también como una constante (const int pin). Aquí utilizamos otro método, el #define que es una directiva para el compilador.

Esto solo significa que el compilador (en rigor el pre procesador) cambiará todas las ocurrencias de estos #define en nuestro programa por su valor antes de compilar. Esta es la forma clásica de C de hacer esto y tiene la virtud de que no ocupa memoria definiendo una variable (y con un Arduino UNO, que va muy corto de memoria, esto puede ser crítico en ocasiones).

void setup()
   {    
       Serial.begin (9600);
       pinMode(trigPin, OUTPUT);
       pinMode(echoPin, INPUT);
       pinMode(led, OUTPUT);
   }

Ya estamos más que habituados a la función delay(milis), pero el reloj interno de Arduino uno mide en microsegundos y tenemos otra función parecida delayMicroseconds(µs) que simplemente congela Arduino el número especificado de microsegundos.

Para dar un pulso ultrasónico lo que hacemos es activar el pin Trigger durante unos microsegundos y para ello lo ponemos en HIGH, antes de escuchar el eco:

digitalWrite(trigPin, LOW);     // Nos aseguramos de que el trigger está desactivado
delayMicroseconds(2);           // Para estar seguros de que el trigger ya está LOW
digitalWrite(trigPin, HIGH);    // Activamos el pulso de salida
delayMicroseconds(10);          // Esperamos 10µs. El pulso sigue active este tiempo
digitalWrite(trigPin, LOW);     // Cortamos el pulso y a esperar el echo

Para escuchar el pulso vamos a usar otra función, pulseIn() ( Oh sí, hay muchas, muchísimas). Para leer el manual de pulseIn()  buscad en google Arduino pulseIn y vereis que pronto lo encontrais.

Básicamente lo que hace es escuchar el pin que le pasamos, buscando una señal que pase de LOW a HIGH ( si le pasamos HIGH como parámetro) y cuenta el tiempo que tarda en volver a bajar desde que sube.

long duracion, distancia ;
duracion = pulseIn(echoPin, HIGH) ;

Ahora ya sabemos el tiempo que tarda en volver el eco en µs. Como la velocidad del sonido es de 343 metros / segundo, Necesitamos 1/343 = 0,00291 segundos para recorrer un metro.

Para usar una medida más cómoda podemos pasar esto  a microsegundos por centímetro:

Como nuestro eco mide el tiempo que tarda el pulso en ir y venir la distancia recorrida será la mitad:

Así que el programa queda parecido a esto ( Prog_18_1) : [highlight variation=»orange»]Descargar ejemplo 18_1[/highlight]:

     #define trigPin 13
     #define echoPin 12
     #define led 2

     void setup()
        {   Serial.begin (9600);
            pinMode(trigPin, OUTPUT);
            pinMode(echoPin, INPUT); 
            pinMode(led, OUTPUT);
        }

     void loop()
        {   long duracion, distancia ;
            digitalWrite(trigPin, LOW);        // Nos aseguramos de que el trigger está desactivado
            delayMicroseconds(2);              // Para asegurarnos de que el trigger esta LOW
            digitalWrite(trigPin, HIGH);       // Activamos el pulso de salida
            delayMicroseconds(10);             // Esperamos 10µs. El pulso sigue active este tiempo
            digitalWrite(trigPin, LOW);        // Cortamos el pulso y a esperar el echo
            duracion = pulseIn(echoPin, HIGH) ;
            distancia = duracion / 2 / 29.1  ;
            Serial.println(String(distancia) + " cm.") ;
            int Limite = 200 ;                  // Medida en vacío del sensor
            if ( distancia < Limite)
                 digitalWrite ( led , HIGH) ;
            else
                 digitalWrite( led , LOW) ;
            delay (500) ;                  // Para limitar el número de mediciones
        }

Para convertir esto en un detector de movimiento hemos creado  una variable un poco menor de la medida que el sensor recibe en vacio (en mi caso unos 200 cm). Si la distancia medida cae por debajo este valor es que algo se ha interpuesto y por tanto encendemos una alarma, en nuestro caso un humilde LED.

Después de este ejercicio de física y matemáticas, que sin duda causará furor entre los estudiantes aplicados, vamos a hacer el mismo programa pero usando una librería externa, que alguien se ha molestado en escribir, paras esas pocas personas que no disfrutan de los problemas de ciencias y que así, podamos ver la diferencia.

Podeís descargar la librería de aquí, [highlight variation=»orange»]Descargar[/highlight], o bien de la web del autor en  code.google.com/p/arduino-new-ping.

Para instalar una librería externa no incluida en el IDE de Arduino tenemos que importarla con el menú Programa \ Importar librería\Añadir librería:

En la ventana que sale, buscad el fichero NewPing_v1.5.zip que habéis descargado y seleccionadlo.

Ya está. Arduino ha importado la librería y los ejemplos que incluye. Si ahora volvéis a Programa\ImportarLibrería, veréis que al final de la lista ya está disponible como NewPing, y además el zip incluye varios ejemplos de uso. Vamos a cargar el equivalente del programa anterior. Haced :

Archivo \ Ejemplos \ NewPing \ NewPingExample

 Arduino cargara un programa de ejemplo. Las instrucciones claves son primero inicializar la librería con:

NewPing sonar(TRIGGER_PIN, ECHO_PIN, MAX_DISTANCE) ;

Y después medir la distancia:

unsigned int uS = sonar.ping() ;

Aqui os copio el ejemplo para vuestra referencia:

     #include <NewPing.h>

     #define TRIGGER_PIN 12 // Arduino pin tied to trigger pin on the ultrasonic sensor.    
     #define ECHO_PIN 11    // Arduino pin tied to echo pin on the ultrasonic sensor.
     #define MAX_DISTANCE 200 
     
     NewPing sonar(TRIGGER_PIN, ECHO_PIN, MAX_DISTANCE); // NewPing setup of pins and maximum distance
 
     void setup() 
        {   Serial.begin(115200); // Open serial monitor at 115200 baud to see ping results.
        }
 
     void loop()
       {   delay(50); 
           unsigned int uS = sonar.ping(); // Send ping, get ping time in microseconds (uS)
           Serial.print("Ping: ");
           Serial.print(uS / US_ROUNDTRIP_CM); 
           Serial.println("cm");
       }

Como veis la librería se encarga de inicializar los pines necesarios, enviar los pulsos, escuchar el eco de retorno  y de hacer los cálculos. No está mal.

• Fijaros, que el ejemplo, utiliza diferentes pines a los que nosotros hemos usado,así que tendreís que modificarlos. Igualmente, el ejemplo inicializa la puerta serie a 115.200. Es imprescindible igualar esta velocidad con la que recibe la consola o veréis muchas cosas raras en pantalla.
• Los alumnos avispados se habrán dado cuenta de que Arduino viene forrado de ejemplos que pueden cargar y usar. Os invito a que investiguéis y juguéis con estos ejemplos  cuanto queráis.

 

Hemos conocido los sensores ultrasónicos de distancia.

Sabemos que sirven para medir algo menos de 3 0 4 metros

Sabemos que no son perfectos pero son útiles y baratos.

Más sobre medir el tiempo: delayMicroseconds ().

Más funciones disponibles: PulseIn ().

Importando una librería externa, de nuevo,algo que en las próximas sesiones iremos haciendo cada vez más, a medida que los elementos a usar se vayan sofisticando.