Programar SRF10 con cable USB

[exque]

Hola a todos! Estoy haciendo un proyecto sobre un UAV, y ahora estoy poniéndole un sensor SRF10 para que mida la altura a la que está volando.
Mi duda es que he encontrado ejemplos del lenguaje en C sobre el srf10 pero no me van bien. El sensro es el SRF!0 y está conectado al PC mediante el cable USBI2C (convierte el I2C a USB). Me gustaría si alguien podría facilitarme el código para poder medir con ese sensor. Gracias

[MLO__]

Hola.

Yo poseo codigo pero para el manejo del SRF02, no se si te sirva. Comentame para postearlo. listo?

El SRF02 tambien se comunica por I2C (o por serial) y posee un solo transductor (emisor-receptor), es mas pequeno y tambien mide a 6 metros. No se si en tu aplicacion sea util o no.

[exque]

Hola, me iría defábula ya que en mi proyecto tambén he comprado el SRF02 y lo tendré mañana. Muchas gracias, haber si también puedo conseguir el del srf10 si lo tiene alguien. También lo usas por USB? gracias;)
Si alguien tiene el srf10 que me lo comente pro aquí si puede

[MLO__]

Mi proyecto es simple, yo configuro y manejo el SRF02 con un PIC6F873A a travez del i2c y despliego la info a traves de una LCD, controlo la adquisicion del dato  por medio de una interrupcion CCPx y envio el dato por el serial cada vez que sea diferente, el dato por la LCD siempre se esta actualizando. Llegue a conectar 4 modulos (no habia $$$$ para mas!!!! ). Pero se me ocurre que se podria enviar la informacion por un TLP u otro modulo de RF por serial y recibirla de igual manera para luego pasarla a USB (aqui en el foro hay verdaderos monstruos de los que he aprendido mucho sobre USB).

Sin mas posteo el codigo (ojala lo haga bien, si sale mal......mil disculpas soy como tarugo con esto del post!!!!!) para el manejo de un SRF02 midiendo en cms:

main:

Código: [Seleccionar]


#include <16F873A.H>
#fuses PUT,BROWNOUT,NOWDT,NOLVP,XT,PROTECT,WRT_50%,CPD //Fusibles de programacion
#use delay(clock=4M)                                  //Frecuencia de trabajo
#use i2c (master,scl=PIN_C3,sda=PIN_C4,slow)              //Habilita funciones I2C por hardware
#use fast_io (C) //Configuracion de los puertos
#use rs232(baud=9600, xmit=PIN_C6, rcv=PIN_C7)          //Habilita las funciones RS232, velocidad a 9600 baudios

#define Tx printf
#define Rx getc
#define Tx_char putc
#define lcd_xy lcd_gotoxy
#define lcd_char lcd_putc

int I2C_Buffer [16];            //buffer de recepción de un dispositivo I2C
int1 data=0;

#include <I2C_16-18FXXX.H>            //Incluye rutinas I2C básicas de propósito general           
#include <SRF02_multidir.H>          //Incluye rutinas de control del sónar SRF02 multidireccion
#include "lcdb.c" //Incluye rutinas para el manejo de la LCD en el puerto B

#int_CCP2 //Interrupcion  para el control de la medida
void go_done_isr(void)
{
if(data)
data = false;
else
data = true;
}

void main()
{ 
    int16   resultado1,resultado_old=0;

    SETUP_ADC_PORTS(NO_ANALOGS);
SETUP_CCP2(CCP_CAPTURE_FE);
enable_interrupts(INT_CCP2);
enable_interrupts(GLOBAL);
    lcd_init();
   
    lcd_char("\fSRF02 - M.L.O"); 
    putc(0x0c);
    Tx("SRF02 - M.L.O\r\n");
    delay_ms(1000);

    lcd_char("\f");
    while(true)
    {
if(data)
{
SRF02_cm(SRF02_1);//SRF02_1 : 0xE0
resultado1=make16(I2C_Buffer[0],I2C_Buffer[1]);
lcd_xy(1,1);
Tx(lcd_char,"dx:%lu cm             ",resultado1);
if(resultado1 != resultado_old)
{
Tx("dx: %lu cm \r\n", resultado1);
resultado_old = resultado1;
}
}
else
{
lcd_xy(1,1);
lcd_char("ESPERANDO ACTIVACION");
}
}


Y aqui van las librerias:

I2C_16-18FXXX.H:

Código: [Seleccionar]


VOID Leer_I2C(Dir_I2C,I2C_Dir_Ini,I2C_N_Bytes)
{
   int   indice=0;
   int   contador;
   i2c_start();                //Secuencia de inicio
   i2c_write(Dir_I2C);            //Dirección I2C del dispositivo modo escritura
   i2c_write(I2C_Dir_Ini);          //Envia dirección interna del dispositivo
   i2c_stop();                  //Envía secuencia de stop
   i2c_start();                //Envía secuencia de inicio
   i2c_write(Dir_I2C|0b00000001);    //Envía dirección I2C del dispositivo en modo lectura

   For(contador=I2C_N_Bytes-1;contador>=1;contador--)    //Ultimo byte a leer ??
      {
      I2C_Buffer[indice]=i2c_read();    //No, leer el byte, envíar ACK y almacenar en el buffer
      indice++;                  //Siguiente posición en el buffer
      }
   I2C_Buffer[indice]=i2c_read(0);      //Si, lee último byte, envía NACK y almacena en el buffer
   i2c_stop();                      //Secuencia de stop   
}


VOID Escr_I2C(Dir_I2C,I2C_Dir_Ini,I2C_N_Bytes)
{
   int   indice=0;
   int   contador;
   i2c_start();                //Secuencia de inicio
   i2c_write(Dir_I2C);            //Dirección I2C del dispositivo modo escritura
   i2c_write(I2C_Dir_Ini);          //Envia dirección interna del dispositivo

   For(contador=I2C_N_Bytes;contador>=1;contador--)    //Ultimo byte a escribir ??
      {
      i2c_write(I2C_Buffer[indice]); //No, leer byte del buffer y enciarlo al dispositivo I2C
      indice++;                  //Siguiente posición del buffer
      }
   i2c_stop();                    //Secuencia de stop
}


SRF02_multidir.H:

Código: [Seleccionar]


#define   SRF02_1   0xE0            //Dirección I2C del SRF02_1
#define   SRF02_2 0XE2 //Direccion I2C del SRF02_2

/*************************************************************************************************
SRF02_Ejec():El SRF02 ejecuta un determinado comando.
dir es la direccion correspondiente del SRF02*/

void SRF02_Ejec(int SRF02_Comando,int dir)
{
   i2c_start();               //Secuencia de inicio
   i2c_write(dir);            //Dirección I2C del SRF02 modo escritura
   i2c_write(0x00);            //Dirección interna 0x00 (registro de comandos)
   i2c_write(SRF02_Comando);      //Enviar comando a ejecutar
   i2c_stop();                  //Secuencia de stop
   delay_ms(80);               //Temporización de 80mS necesaria para realizar la ejecución

/*Secuencia para la lectura del resultado medido por el SRF02 */

   Leer_I2C(dir,0x2,0x02);      //Realiza la medida del resultado
}

/**********************************************************************************************
SRF02_in(): Realiza una medida en pulgadas.El resultado se almacen en I2C_Buffer */

void SRF02_in(int dir)
{
   SRF02_Ejec(0x50,dir);            //Ejecuta el comando
}

/**********************************************************************************************
SRF02_cm(): Realiza una medida en centímetros.El resultado se almacen en I2C_Buffer */

void SRF02_cm(int dir)
{
   SRF02_Ejec(0x51,dir);            //Ejecuta el comando
}

/**********************************************************************************************
SRF02_us(): Realiza una medida en microsegundos.El resultado se almacen en I2C_Buffer */

void SRF02_us(int dir)
{
   SRF02_Ejec(0x52,dir);            //Ejecuta el comando
}


/***********************************************************************************************************
SRF02_Reset(): Fuerza un reinicio del SRF02, realizando un ciclo de autoajuste. Es similar al Power Up */

void SRF02_Reset(int dir)
{
   i2c_start();               //Secuencia de inicio
   i2c_write(dir);            //Dirección I2C del SRF02 modo escritura
   i2c_write(0x00);            //Dirección interna 0x00 (registro de comandos)
   i2c_write(0x60);            //Enviar comando para la transmisión de una ráfaga
   i2c_stop();                  //Secuencia de stop
   delay_ms(80);               //Temporización de 80mS necesaria para realizar la ejecución
}

/***********************************************************************************************************
SRF02_I2C_Dir(): Cambia la dirección I2C del SRF02. SRF02_New_Dir debe expresar la nueva dirección I2C */

void SRF02_I2C_Dir(int SRF02_New_Dir, int SRF02_Last_Dir)

{
   i2c_start();               //Secuencia de inicio
   i2c_write(SRF02_Last_Dir);  //Dirección I2C del SRF02 modo escritura
   i2c_write(0x00);            //Dirección interna 0x00 (registro de comandos)
   i2c_write(0xA0);            //1ª secuencia para el cambio de dirección
   i2c_stop();                  //Secuencia de stop

   i2c_start();               //Secuencia de inicio
   i2c_write(SRF02_Last_Dir); //Dirección I2C del SRF02 modo escritura
   i2c_write(0x00);            //Dirección interna 0x00 (registro de comandos)
   i2c_write(0xAA);            //2ª secuencia para el cambio de dirección
   i2c_stop();                  //Secuencia de stop
   
   i2c_start();               //Secuencia de inicio
   i2c_write(SRF02_Last_Dir); //Dirección I2C del SRF02 modo escritura
   i2c_write(0x00);            //Dirección interna 0x00 (registro de comandos)
   i2c_write(0xA5);            //3ª secuencia para el cambio de dirección
   i2c_stop();                  //Secuencia de stop

   i2c_start();               //Secuencia de inicio
   i2c_write(SRF02_Last_Dir);//Dirección I2C del SRF02 modo escritura
   i2c_write(0x00);            //Dirección interna 0x00 (registro de comandos)
   i2c_write(SRF02_New_Dir);      //Nueva dirección I2C
   i2c_stop();                  //Secuencia de stop
}


Yo uso el compilador CCS v4.057 (fue justamente en este foro donde me inicie..........gracias).

La libreria de la LCD es la estandar del CCS, solo que le cambie los pines para poder trabajar con mi tarjeta entrenadora (tiene la configuracion del C18 de Microchip), asi que no creo que halla problema con esa libreria.

Espero te sirva.......

Chao

[exque]

Muchas gracias MLO! está de lujo. Lo malo que no uso el Proteus porque no estoy familiarizado con él. Lo que me gustaría es que me salieran los datos que va recogiendo el sensor por pantalla (tipo printf) a ver si me puedes ayudar. merci! o sino como se hace el circuito del srf02 con el proteus para poderlo simular

[MLO__]

Ok!

El programa tambien envia el dato por el serial (RS232), tipo printf, solo que envia el dato cada vez que es diferente, la variable de distancia esta en resultado1, asi que la puedes trabajar directamente con ese nombre para calcular lo que tu quieras. El SRF02 no lo he podido simular en proteus, pero coloco el i2c debugger y miro si envia los datos correspondientes, obviamente el dato mostrado de distancia es el maximo a 16 bits, es decir 0xFF 0xFF lo que equivale a 65535cm (aun no he podido hacer que el i2c envie datos como yo quiero para simular las distancias). Si quieres que el dato por el serial se actualice siempre, solo hay que comentar el condicional if(resultado != resultado_old) y ya, el serial se inundara de datos!!!!!!

El esquematico en proteus es el siguiente:


En la imagen, el modulo debugger del i2c corresponde al SRF02, las resistencias de pull-up son de 2k7 y el terminal virtual muestra lo que saldria por el puerto COM de un PC.

Si lo vas a conectar a un PC debes agregar el MAX232 entre el pic y el PC, ya que el uC trabaja con logica TTL y hay que adecuar el tipo de senal. Una vez conectado, abres el hyperterminal de Windows y ya a ver distancias!!!!.

[MLO__]

Mil disculpas por la imagen!!!! ni yo veo bien!!!
Voy a enviarla mas grande ok? adjunto tambien el archivo de simulacion (uso el Proteus v6.7 SP3)

[exque]

gracias! mañana mismo lo pruebo allí donde estoy haciendo el proyectoy te comento! gracias de nuevo portu aportación!

[MLO__]

Ok

quedo en espera de tus comentarios.....muchos exitos

[exque]

Pues en el Proteus salen muy bien lso resultados! gracias! ahora a ver si puedo encontrar el código en C o C++ para que algún compilador me lo compile y pueda ejecutarlo y que el sensor mida las distancias y me vayan saliendo por pantalla por ejemplo con printf. Merci!

[MLO__]

Hola.

Hay algo que no entiendo bien. Tu conectas el sensor directamente al PC? No estas utilizando un PIC para el sensor? Porque si necesitas el dato de altura pordrias colocar un transmisor inalambrico y recibir la senal de distancia y procesarla en el PC. Segun entiendo, el sensor esta en tierra conectado al PC por medio del USB cierto?.

[exque]

Tengo el sensor SRF10 o el SRF02 conectado al USBI2C, el cual está conectado por cable USB al PC (puerto COM2). Los pillé de www.superrobotica.com

[MLO__]

Hola.

Te envio el ejecutable para leer el dato desde el computador, es una aplicacion que permite configurar el SRF02 o SRF10 desde el PC con la tarjeta USBI2C, espero te sirva.

chao.

[MLO__]

Hola harold

El esquematico en proteus es el siguiente:



El SRF02 se puede manejar por serial o por i2c, yo lo manejo por i2c asi que hay que dejar el pin4 al aire, las resistencias son de 2k7.

Saludos

[hard8507]

como hago para ke en las salidas de la distancia me genere un tono el cual valla aumentando o disminuyendo deacuerdo a la distancia si es muy cerca es mas fuerte y si es mas lejos es mas devil el tono muchas gracias por tu ayuda