Medidor de distancias mediante Ultrasonidos SFR04

[RedPic]

   Después de participar en algun hilo de este Foro tratando sobre la medida de
distancias me he dado cuenta de que tengo unos razonables conocimientos
técnicos sobre el asunto pero pueden ponerme un cero patatero en el plano
práctico. Amigos como Radón do Dogflou son verdaderos galácticos en esto
de los sensores y la adquisición de datos ... asi que ...

   He estado bicheando (o brujuleando o navegando, como queráis llamarle) por
la página de Superrobotica.com mirando cachirulos (o aparatos o cacharros)
y tengo pensado acercarme por allí este sábado con la sana intención de
adquirir un SRF04 para experimentar (cuesta 26,65 € y entra dentro de mi
presupuesto mensual para tonterias).

   El motivo de este post es consultaros si tenéis experiencia con este módulo en
concreto o alguno similar y si véis alguna problemática que se me escape. Además
deseo ir posteando los distintos experimentos que haga con él y las experiencias
que resulten.

Abajo os pego algunas de las características de este módulo:

Tensión 5V
Consumo 30 mA Tip. 50mA Max.
Frecuencia: 40 Khz.
Distancia Mínima: 3 cm.
Distancia Máxima: 300 cm.
Sensibilidad: Detecta un palo de escoba a 3 m.
Pulso de Disparo 10 uS min. TTL
Pulso de Eco: 100 uS - 18 mS
Retardo entre pulsos: 10 mS Mínimo
Pulso de Eco: 100 uS - 18 mS
Tamaño: 43 x 20 x 17 mm
Peso: 10 gr.

SFR04 :



Rango de Uso :



Cronograma :



Viendo el cronograma de arriba no encuentro especiales dificultades en manejar
el sensor con dos pines del pic, incluso con uno solo dándole el pulso de disparo
y posteriormente cambiando a entrada dicho pin y leyendo el eco. Solo habría
que aislar ambos pines en el sensor para que no se interfieran entre ellos con
un par de diodos.

Además tengo la intención de montarlo sobre un par de servos que tengo por
aquí, colocando uno sobre el eje del otro perpendicularmente y poder de este
modo moverlo a cualquier posición de una semiesfera frontal. Desearía poder
realizar un análisis tridimensional de lo que hay dentro de esa semiesfera de
3 metros de radio. Uff, ya empiezo a complicarlo y todavía no se como funciona
pero es que mi perro y yo somos así ...

En fin, espero vuestras impresiones.

(P.D. Nocturno, creo que tú sabías o habías ido alguna vez por esta tienda y me
gustaría que me indicases cual es la mejor forma de llegar)

[RaDoN]

Nunca he trasteado con ultrasonidos, sera "que mi presupuesto mensual para tonterias" no me ha llegado Pero si que me regalaron un par de capsulas que aun siguen en el cajon esperando que les saque probecho. Por lo que escuchado la unica dificultad que entraña es los problemas con los ecos y demas, pero ya te digo estoy "pezcaito en blanco" con esto

Aver si acabo de una vez (a falta de un par de semanas) el curso!!! Y me pongo a trastear de nuevo y ahora que tengo algunas pelas alo mejor me pillo tb un modulito de estos y me pongo contigo

Lo que si creo haber visto es la rutina de este ... pero en asambler

[LordLafebre]

Hola:

En la pagina de Bruce Rainolds, trata un poco sobre navegacion de robotitos por IR, RF y ultrasonido, si les sirve pueden mirar aqui:

http://www.rentron.com/Micro-Bot/index.htm

en la parte de:  Infrared & Sonar Navigation

muestra un codigo en Basic para el SRF04, de pronto te puede servir como inicio.

Suerte...!!!

[RedPic]

Mi gozo en un pozo (temporal).

Acabo de llamar a Superrobotica para saber si tenía existencias ...
y me han dicho que sí, pero que mañana Sábado no abren y que hoy
Viernes cierran a las 18.30  (son las 18:15 en el momento de llamar)
así que tendría que hacer 12 Km en una de las autopistas mas colapsadas
del mundo mundial para llegar .....

Va ser que nó. Que habrá que esperar al Lunes ....

[RedPic]

¡Tararí, tararí, que te ví!

Ya tengo en mi poder un magnifico sensor de distancias por ultrasonido SFR04
acabado de adquirir en la sevillana tienda de Superrobotica esta misma tarde.

Ahora a ponerme a implementar los timmings necesarios para una perfecta
comunicación entre él y mi 16F628 ... el de la RRBOARD1 que hasta hace muy
poco estábais visitando desde Internet ... el mismo que viste y calza y que
ahora se va a poner a generar la información necesaria para realizar el Mapa
Tridimensional de mi Habitación ....

[RaDoN]

Tienen tienda fisica entonces? dirección? yo quiero uno

[RedPic]

SuperInventos / Superrobotica

C/ Ciaurriz 142, 1ºB

41927 Mairena del Aljarafe, SEVILLA

(Urbanización Simón Verde, Junto al Hotel Sevilla Suites)

Horario: de 9 a 14 y de 16 a 18.30 horas de Lunes a Viernes

Los sábados no abren.

Teléfono: (34) 902 303 180



La mejor manera de llegar desde Sevilla es subiendo a la cornisa del Aljarafe
desde la autovia de Coria, antes de llegar a Gelves, justo después de pasar la
rotonda de Arrocerías Hervas, a la derecha y hacia arriba. Entras por ahí
directamente en la calle Ciaurriz, una vez coronada la cuesta hay unos 3 Km
hasta la tienda.

Ésta se encuentra en un edifico adyacente al Hotel Sevilla Suites. En el frente
que dá a la calle Ciaurriz hay un Kiosko de prensa y una Cafetería. Entre ambos
encuentras la entrada a un patio interior desde el que se accede a la primera
planta por la escalera que hay a la izquierda, según se entra. En el pasillo superior
casi al borde mismo del edifico tienes la entrada, en el extremo opuesto por el
que has subido. Sobre dicha entrada un gran cartel luminoso LCD de color rojo
te informa que el tugurio se llama: Superinventos.

Coordenadas geográficas para GoogleEarh o GPS :  37°20"13.25"N   6° 2"15.81"W


Si quieres te llevo de la manita ... jua, jua, jua

[RaDoN]

Escrito originalmente por RedPic
Si quieres te llevo de la manita ... jua, jua, jua

Gracias jejej creo que me fiare del GPS

[RedPic]

Avance sobre el estado del experimento:

Ya he realizado las conexiones eléctricas pertinentes y comienzo a desarrollar
el programa para completar el experimento. Voy a utilizar de base el RROS de la
RRBOARD1 que ya conocéis de otros trabajos míos, y bajo petición desde el PC
vía RS232 pretendo que el SRF04 realice una única medida y me trasmita el
resultado por el mismo canal. Como véis en la imagen de abajo he montado el
SRF04 de forma que tengo un regla entre él y el obstaculo que tiene delante,
el osciloscopio, con lo que intentaré relacionar los datos que me envíe con la
distancia real a la que se encuentra de éste:

[RedPic]

Bueno, esto ha sido más rápido de lo que yo esperaba.

He aplicado exactamente los criterios expuestos mas arriba, en la hoja técnica
del SRF04 que proporciona el fabricante, y todo ha funcionado a la primera.  

Os copio el fuente marcando en rojo lo estrictamente necesario para el manejo
del SRF04. El programa queda tal como sigue:

Codigo:

/////////////////////////////////////////////////////////////////////////////////////////
//
// RROS para RRBOARD1 : SRF04 Test
//
// © 18.03.2006 By RedRaven
//
// Hardware: PIC16F628
//
//           RA0      SRF04 Input Echo
//           RA1      SRF04 Trigger
//           RA2,RA3  Leds
//           RB1      USART RX
//           RB2      USART TX
//           RB5      Buzzer Driver
//           RB6,RB7  ICSP
//
//           Xtal Ext. 4.00 Mhz
//
// Idioma: CCS PICC v.3.242
//
//
/////////////////////////////////////////////////////////////////////////////////////////

#include <16f628a.h>
#fuses XT,NOWDT,NOPROTECT,NOPUT,NOBROWNOUT,NOLVP
#use delay(clock=4000000)
#use rs232(baud=9600, xmit=PIN_B2, rcv=PIN_B1)

#include <stdlib.h>

// Constantes y definiciones ////////////////////////////////////////////////////////////

#define SRF04_PORT_TRIGGER PIN_A1                // Pin usado para el pulso de Disparo 
#define SRF04_PORT_ECHO    PIN_A0                // Pin usado para recibir el eco ultrasónico

#define TIME_TRIGGER_uS  10                      // Longitud del pulso de disparo 10 uS (microsegundos)
#define TIME_NEXT_TRIGGER_mS 10                  // Espacio entre echo y siguiente disparo 10 mS (milisegundos)
#define MAX_ECHO_RESPONSE_Ticks 35000            // Maximo tiempo de espera del eco en Ticks de Timer1 (35 ms)
#define CALC_DISTANCE(t) (t / 58)                // Convierte de Ticks a distancia
#define DISTANCE_INFINITE (0xffff)               // Distancia infinita, no hay obstaculo en el rango de medida

// De RROS

int const MAXLENBUFF=24;                         // Maxima longitud de los bufferes
int const MAXLENCOMMAND=12;                      // Maxima longitud de un comando (sin argumentos)
int const NUMPAGSEEPROM=7;                       // Numero de paginas (de 16 bytes) de la EEPROM interna

// Variables Globales ///////////////////////////////////////////////////////////////////

long echo_delay;
long distance = DISTANCE_INFINITE;

// De RROS

char buffrec[MAXLENBUFF];                        // Buffer de Recepcion
int  xbuffrec=0x00;                              // índice del Buffer de Recepcion
int1 new_command=0;                              // Flag para indicar comando disponible
int1 pdte_send_prompt=0;                         // Flags para enviar echo fuera de la int_rda
int1 pdte_send_tmp_prompt=0;
char xcommand[MAXLENCOMMAND];                    // Comprobador de comando recibido

// Declaracion de Funciones /////////////////////////////////////////////////////////////

void On_reset(void);                             // Tras RESET del Micro
void Send_listen(void);                          // Monitoriza RS232 : Comienzo
void Send_opts(void);                            // Monitoriza RS232 : Presenta opciones
void Send_prompt(void);                          // Monitoriza RS232 : Presenta el Cursor
void Send_tmp_prompt(void);                      // Monitoriza RS232 : Presenta el Cursor y el comando actual
void Ini_buffrec(void);                          // Borra el buffer de recepción
void Add_buffrec(char c);                        // Añade un caracter al buffer de recepción
void Procesa_comando(void);                      // Procesado de comandos

void realiza_medida(void);                       // Realiza una medida completa

// INTERRUPCIONES ///////////////////////////////////////////////////////////////////////

// INTERRUPCION RDA - Recepción USART -

#int_rda
void serial_isr() {
   if(kbhit()){                                  // Si hay algo pendiente de recibir ...
      Add_buffrec(getc());                       // lo recibo y lo añado al Buffer de Recepcion
   }
}

// Control del Buffer de recepcion ---------------------------------------

void Ini_buff_rec(void){                         // Inicia a "" el Buffer de Recepcion

   int i;
   for(i=0;i<MAXLENBUFF;i++){                    // Bucle que pone a 0 todos los
      buffrec[ i ]=0x00;                           // caracteres en el Buffer de Recepcion
   }
   xbuffrec=0x00;                                // Inicializo el indice de siguiente caracter recibido
}

void Add_buffrec(char c){                         // Añade caracter al Buffer de Recepcion

      switch(c){
         case 0x0D:                              // [Enter] -> Habilita Flag para procesar comando en Main
            new_command=1;
            break;
         case 0x08:                              // [Del]   -> Borra último caracter del Buffer
            if(xbuffrec>0){                      //            Si hay algo en el buffer
               buffrec[--xbuffrec]=0x00;         //            decremento el índice, escribo un cero y ...
               pdte_send_tmp_prompt=1;           //            habilito flag para refrescar el prompt
            }
            break;
         case 0x01B:                             // [Esc]   -> Borra el Buffer completamente y ...
            Ini_buff_rec();                      //            habilito flag para refrescar el prompt
            pdte_send_prompt=1;
            break;
         case 0x009:                             // [Tab]   -> Refresca el prompt y el comando tal como esté
            pdte_send_tmp_prompt=1;
            break;
         default:
            buffrec[xbuffrec++]=c;               // Añade caracter recibido al Buffer
            putc(c);                             // y lo monitorizo
      }
}

// Rutinas y Funciones de RROS ///////////////////////////////////////////

void On_reset(void){                             // Inicializacion del Micro tras RESET

   disable_interrupts(GLOBAL);                   // todas las interrupciones desactivadas

   delay_ms(100);

   output_low(SRF04_PORT_TRIGGER);               // A bajo el pin del disparador
   setup_timer_1(T1_INTERNAL | T1_DIV_BY_1);     // Timer1 con preescaler 1:1

   Ini_buff_rec();                               // Inicializo Buffer de recepcion
   new_command=0;                                // Desactivo flag de comando pendiente.
   pdte_send_prompt=0;                           // Desactivo Flags para enviar echo fuera de la int_rda
   pdte_send_tmp_prompt=0;

   enable_interrupts(int_rda);                   // interrupcion RDA habilitada
   enable_interrupts(global);                      // todas las interrupciones activadas

   Send_opts();                                  // Presenta Comienzo
   Send_prompt();                                // Presenta el Cursor

}

void Send_listen(void){                          // Presenta Comienzo

   printf("SRF04 Ultrasonic Ranger Test

" );
}

void Send_opts(void){                            // Relación de comandos válidos

   printf("

" );
   Send_listen();
   printf("
" );
   printf("[?] comandos válidos
" );
   printf("[r] realiza una medición

" );
}

void Send_prompt(void){                          // Presenta el cursor

   printf("
>" );
}

void Send_tmp_prompt(void){                      // Presenta el cursor con el comando actual

   printf(">%s",buffrec);
}

// MAIN Programa Principal ///////////////////////////////////////////////

void main(void)
{
   On_reset();

   do {

      // Deteccion de la necesidad de procesar comandos pendientes ///////
      if(new_command==1){                        // Si hay un nuevo comando ...
         new_command=0;                          // deshabilito el aviso y ...
         Procesa_comando();                      // Procesado de comandos
         Ini_buff_rec();                         // inicializo todo para nuevo comando y ...
         pdte_send_prompt=1;                     // mando prompt.
      }

      // Deteccion de la necesidad de enviar echos ///////////////////////
      if(pdte_send_prompt==1){
         pdte_send_prompt=0;
         Send_prompt();
      }
      if(pdte_send_tmp_prompt==1){
         pdte_send_tmp_prompt=0;
         Send_tmp_prompt();
      }

     } while(TRUE);
}

// Funciones de Comando //////////////////////////////////////////////////

void realiza_medida(void){

  delay_ms(TIME_NEXT_TRIGGER_mS);                // Espero para asegurarme que hay espacio entre eco y disparo
  output_high(SRF04_PORT_TRIGGER);               // Envío el pulso de disparo
  delay_us(TIME_TRIGGER_uS);                     // espero el ancho de pulso requerido
  output_low(SRF04_PORT_TRIGGER);                // termino el pulso
  for ( ; !input(SRF04_PORT_ECHO); );            // Espero el inicio del pulso del eco (flanco de subida) 
  set_timer1(0);                                 // Cuando llegue pon a cero el Timer1
  for ( ; input(SRF04_PORT_ECHO); );              // Espero al final del pulso del eco (flanco de bajada) 
  echo_delay = get_timer1();
  if (echo_delay >= MAX_ECHO_RESPONSE_Ticks){
    distance = DISTANCE_INFINITE;
  }
  else {
    distance = CALC_DISTANCE(echo_delay);
  }
}

// Procesa_comando: Hace cosas o manda hacerlas ... //////////////////////

void Procesa_comando(void){

   int1 procesado_ok=0;
   int waddress, wbyte;

   // COMANDO = "" intro en blanco ---------------------------------------
   strcpy(xcommand,"" );
   if(!strcmp(buffrec,xcommand)){
      procesado_ok=1;
      goto fin_procesa;
   }
   // COMANDO = "?" ------------------------------------------------------
   strcpy(xcommand,"?" );
   if(!strncmp(buffrec,xcommand,strlen(xcommand))){
      Send_opts();
      procesado_ok=1;
      goto fin_procesa;
   }
   // COMANDO = "r" ------------------------------------------------------
   strcpy(xcommand,"r" );
   if(!strncmp(buffrec,xcommand,strlen(xcommand))){
      realiza_medida();
      printf(" -> %lu cm (%lu) 
",distance,echo_delay);
      procesado_ok=1;
      goto fin_procesa;
   }

fin_procesa:

   // COMANDO ERRÓNEO - ¿ezo qué é lo que é ?-----------------------------
   if(procesado_ok==0){
      printf("
?%s",buffrec);
   }

}

Si queréis descargar el fuente lo tenéis aqui



En cuanto a los resultados me he dedicado a acercarlo y alejarlo del obstaculo
que le puse delante, comparando lo que me enviaba con lo medido con la regla
y es bastante exacto, +-1cm, entre 3 cm y entre 3 y 4 metros.







Ahora creo que debo probar la resolución lateral del SRF04, o sea la directividad
de la medida, haciendo mas o menos ancho el objeto a detectar, para saber qué
tipo de medida es la que estoy realizando.

 

[RaDoN]

Como te lo curras redpic!!! Voi a tener que pegarme un viajecito a mairena ya!!

Por cierto, ya estas tardando en montarlo en un servo y montarte un radar

[dogflu66]

Todo a supervelocidad, se ve muy bien el proyecto…

[RedPic]

Gracias al trabajo realizado en este foro, acabo de concluir la publicación en mi Web
el artículo dedicado al Circuito auxiliar de medición de distancias por ultrasonidos SRF04

En éste he comenzado con una breve descripción de los fundamentos de la medición
y desearía hacer el viaje de vuelta y publicar aquí dicha introducción. Así este hilo
quedaría mas completo y redondo: Peinado y con su colonia puesta.

Cita:
   El objetivo de este circuito auxiliar es el de medir distancias, utilizando para ello dos transceptores de ultrasonidos, uno emisor y otro receptor, basándonos en el tiempo que tarda la señal en ir desde el emisor hasta el objeto obstáculo y volver rebotada desde éste hasta el receptor. Midiendo dicho tiempo podemos calcular con suficiente precisión y exactitud la distancia entre el objeto y nuestros transceptores.

   Primero unos pocos datos e ideas de teoría física básica y la descripción de los cálculos que necesitamos hacer para implementarlos en nuestro programa:

Los ultrasonidos son antes que nada sonido, exactamente igual que los que oímos normalmente, salvo que tienen una frecuencia mayor que la máxima audible por el oído humano. Ésta comienza desde unos 16 Hz y tiene un límite superior de aproximadamente 20 KHz, mientras que nosotros vamos a utilizar sonido con una frecuencia de 40 KHz. A este tipo de sonidos es a lo que llamamos Ultrasonidos.

(1) El sonido se desplaza en el aire a una velocidad de 340 m/s a una temperatura de 20º C, con una variación térmica de 0.6 m/s por cada grado centígrado. Así, por ejemplo, a 30º C de temperatura del aire, la velocidad del sonido es de 340 m/s + (0.6 m/s/º C * 10º C) = 346 m/s (Intervienen otros parámetros pero que vamos a dejar de lado en este trabajo por complicarnos excesivamente sin aportarnos mayor resolución)

(2) La distancia d recorrida por un móvil es directamente proporcional a la velocidad v de éste y al tiempo t empleado en ello. Podemos escribirlo como una fórmula en la sencilla forma:

d = v * t

dónde d es la distancia recorrida en metros, v la velocidad en metros por segundo y t el tiempo en segundos.

esta misma relación la podemos escribir de otra forma que nos relacione el tiempo con las otras dos variables, estableciendo que el tiempo t que tarda un móvil en recorrer una distancia d es inversamente proporcional a la velocidad v del mismo y directamente proporcional a la distancia d a recorrer:

t = d / v

dónde t el tiempo en segundos, d es la distancia en metros y v la velocidad en metros por segundo.

Si deseamos medir una distancia usando los ultrasonidos tenemos que emitir un pulso ultrasónico breve, esperar que llegue hasta el obstáculo a sensar, se refleje en éste y vuelva hasta nuestro dispositivo sensor, midiendo entonces el tiempo t que ha tardado en hacer todo el trayecto de ida y vuelta mediante nuestro microcontrolador PIC. Conociendo la velocidad v a que se ha desplazado nuestra onda tal como hemos visto en (1), podemos fácilmente calcular según lo xpresado en (2) la distancia d entre el sensor y el objeto.

Por ejemplo:

Un objeto situado a 15 cm. de nuestro sensor, con una temperatura del aire de 20º C, debe emitir un eco tras nuestro pulso que debe tardar en llegar  t = (0.15 m / 340 m/s) * 2 = 0.000882 segundos (o escrito de otra forma 882 uS, microsegundos)

Date cuenta del detalle de que multiplicamos por 2 el tiempo empleado debido a que el sonido debe ir y volver reflejado desde el objeto, por lo que recorre dos veces la distancia que separa al sensor del objeto.

[RaDoN]

Buen trabajo RedPic, muy agradecido por compartirlo

[RedPic]

De nada, amigo Radón, a mandar que para eso estamos ...