TODOPIC

Mecatrónica => Robótica => Mensaje iniciado por: Nabil en 03 de Diciembre de 2008, 14:27:27

Título: detectar oponente SUMO
Publicado por: Nabil en 03 de Diciembre de 2008, 14:27:27
saludos; esty realizando un robot de SUMO; y utilizo SRF08 para detectar al oponente; con el siguiente codigo
y no consigo hacerlo funcionar ... he leido este foro de arriba a abajo y no encuentro solucion; x favor ayudenme.
_____________________________________________
#include <16f876.h>
#fuses XT, PUT, NOWDT, NOPROTECT
#use delay(clock=4000000)
#use fast_IO(B)
#use fast_IO(C)
#use i2c(Master,sda=PIN_B4,scl=PIN_B3)

void main()
{
   char distancia_L, distancia_H, luz;

   set_tris_B(0x00);
   set_tris_C(0x00);

   output_high(pin_B0);      //asi veo que el pic funciona
   do
   {
      i2c_start();                                                               // Bit de Start.
      i2c_write(0xE0);                                                           // Dirección del SRF08 en escritura.
      i2c_write(0x00);                                                           // El registro de comando está en la ubicación 0.
      i2c_write(0x51);                                                           // 0x51 es el comando de cálculo de distancia en cm.
      i2c_stop();                                                                // Bit de Stop.

      delay_ms(100);                                                              // Espera  65 ms hasta la lectura.

      i2c_start();                                                               // Bit de Start.
      i2c_write(0xE0);                                                           // Dirección del SRF08 en escritura.
      i2c_write(0x01);                                                           // Apunta a la ubicación 0x01 que es a partir donde se

      i2c_start();
      i2c_write(0xE1);                                                           // Dirección del SRF08 en lectura.
      luz = i2c_read(1);                                                         // Lee la luminosidad.

      delay_ms(100);
      distancia_H = i2c_read(1);                                                 // Lee el byte alto de la distancia.

      delay_ms(100);
      distancia_L = i2c_read(0);                                                 // Lee el byte bajo de la distancia.
      i2c_stop();

      output_C(luz);

   }while ( distancia_L);   //AKI VEO QUE HAY ALGO DELANTE Y AVANZO CON EL ROBOT.
}
Título: Re: detectar oponente SUMO
Publicado por: Nabil en 03 de Diciembre de 2008, 14:29:13
este codigo lo he repasado MIL veces y no consigo leer nada del sensor.

ayudenme con alguna idea para solucionarlo pls.

GRACIAS DE ANTEMANO.
Título: Re: detectar oponente SUMO
Publicado por: Nabil en 03 de Diciembre de 2008, 15:00:06
añado:

siempre leo FF; sea luz o byte alto o bajo de distancia...

ayuda por favor
Título: Re: detectar oponente SUMO
Publicado por: MLO__ en 03 de Diciembre de 2008, 16:05:30
Hola.

Si es por I2C, de pronto te sirva este LINK (http://www.todopic.com.ar/foros/index.php?topic=21136.0).

Saludos
Título: Re: detectar oponente SUMO
Publicado por: Nabil en 04 de Diciembre de 2008, 12:21:21
gracias MLO; le exare un vistazo ahorita mismo.
Título: Re: detectar oponente SUMO
Publicado por: Nabil en 04 de Diciembre de 2008, 13:05:54
el LINK de arriba que contiene unos codigos para el SRF02 sirven igual para el SRF08 ???
gracias MLO
Título: Re: detectar oponente SUMO
Publicado por: MLO__ en 04 de Diciembre de 2008, 13:23:24
Hola.

El modo de comunicacion es el mismo: I2C. Habria que revisar los datasheets de los dos sensores, me imagino que deben o pueden tener valores diferentes los comando para acceder a las variables, pero el proceso es exactamente el mismo.

Saludos
Título: Re: detectar oponente SUMO
Publicado por: Nabil en 04 de Diciembre de 2008, 13:56:42
que es lo que falla en este codigo ??? no lo hago funcionar MLO ¡¡¡

gracias:

_________________________________________________________

#include <16f876.h>
#fuses XT, PUT, NOWDT, NOPROTECT
#use delay(clock=4000000)
#use fast_IO(B)
#use fast_IO(C)
#use i2c(Master,sda=PIN_B4,scl=PIN_B3)

void main()
{
   char distancia_L, distancia_H;

   set_tris_B(0x00);
   set_tris_C(0x00);
   output_float(PIN_b3);
   output_float(PIN_b4);

   do
   {
      i2c_start();                                                               // Bit de Start.
      i2c_write(0xE0);                                                           // Dirección del SRF08 en escritura.
      i2c_write(0x00);                                                           // El registro de comando está en la ubicación 0.
      i2c_write(0x51);                                                           // 0x51 es el comando de cálculo de distancia en cm.
      i2c_stop();                                                                // Bit de Stop.

      delay_ms(80);                                                              // Espera más de 65 ms hasta la lectura.

      i2c_start();                                                               // Bit de Start.
      i2c_write(0xE0);                                                           // Dirección del SRF08 en escritura.
      i2c_write(0x02);                                                           // Apunta a la ubicación 0x01 que es a partir donde se
      i2c_stop();
      i2c_start();
      i2c_write(0xE0|0x01);                                                      // Dirección del SRF08 en lectura.
      distancia_H = i2c_read(0);                                                 // Lee el byte alto de la distancia.
      distancia_L = i2c_read(1);                                                 // Lee el byte bajo de la distancia.
      i2c_stop();

      delay_ms(80);

      output_C(distancia_L);

   }while (true);
}
Título: Re: detectar oponente SUMO
Publicado por: Nabil en 04 de Diciembre de 2008, 13:58:45
b3 y b4 para el BUS i2c; y la puerta C, son unos LEDS que muestra el valor en binario de la parte baja de los dos bytes de la distancia.

pido humildemente su ayuda MLO__ ¡¡
muchas gracias
Título: Re: detectar oponente SUMO
Publicado por: MLO__ en 04 de Diciembre de 2008, 14:05:28
Hola.

Coloca en la configuracion del I2C:
Código: [Seleccionar]
#use i2c (master,scl=PIN_b3,sda=PIN_b4,slow)
Quita el set_tris_B(0x00);

Recuerda que debe haber unas resistencias de pull up en las lineas de SDA y SCL, de unos 1.7k.

Las librerias que te pase deberian funcionar tambien para el SRF08, ya que tienen los mismos valores para los comandos.

Saludos
Título: Re: detectar oponente SUMO
Publicado por: Nabil en 04 de Diciembre de 2008, 17:28:22
 :(;

#include <16f876.h>
#fuses XT, PUT, NOWDT, NOPROTECT
#use delay(clock=4000000)
#use fast_IO(B)
#use fast_IO(C)
#use i2c (master,scl=PIN_b3,sda=PIN_b4,slow)

void main()
{
   char distancia_L, distancia_H;

   set_tris_C(0x00);
   do
   {
      i2c_start();                                                               // Bit de Start.
      i2c_write(0xE0);                                                           // Dirección del SRF08 en escritura.
      i2c_write(0x00);                                                           // El registro de comando está en la ubicación 0.
      i2c_write(0x51);                                                           // 0x51 es el comando de cálculo de distancia en cm.
      i2c_stop();                                                                // Bit de Stop.

      delay_ms(80);                                                              // Espera más de 65 ms hasta la lectura.

      i2c_start();                                                               // Bit de Start.
      i2c_write(0xE0);                                                           // Dirección del SRF08 en escritura.
      i2c_write(0x01);                                                           // Apunta a la ubicación 0x01 que es a partir donde se
      i2c_stop();
      i2c_start();
      i2c_write(0xE0|0x01);                                                      // Dirección del SRF08 en lectura.
      distancia_H = i2c_read(1);                                                 // Lee el byte alto de la distancia.
      distancia_L = i2c_read(0);                                                 // Lee el byte bajo de la distancia.
      i2c_stop();

      delay_ms(80);

      output_C(distancia_L);

   }while (true);
}
___________________________________

he hecho los cambios que me has comentado; pero me sale por la puerta C (FF);
esty desesperado MLO__ :S
_____
unicamente necesito una rutina que al llamarla calcule si hay objetos cerca o no; (si no hay dara todo 0x00, si hay algo otros valores);
asi el robot sabrá si tiene al enemigo en el lado del sensor.

pero no consigo hacerlo funcionar; siempre lee 0xff..
q puede fallar ??
Título: Re: detectar oponente SUMO
Publicado por: Nabil en 04 de Diciembre de 2008, 18:00:28
parece que ha habido un cambio; ahora me lee 0x27,o sea me saca (00100111) por los leds;

pero no envia otra cosa...
Título: Re: detectar oponente SUMO
Publicado por: MLO__ en 04 de Diciembre de 2008, 19:18:45
Hola.

Mira bien si es el registro que debes acceder, creo que el SRF08 tiene tambien una LDR para medir la luminosidad.

La secuencia creo que esta bien, de hecho se asemeja mucho a la que yo uso con el SRF02.

Saludos
Título: Re: detectar oponente SUMO
Publicado por: Nabil en 05 de Diciembre de 2008, 14:23:49
saludos MLO__

pero el codigo esta bien ??, me refiero los pasos de start, write, read, estan en el orden en el que deben estar, con los delays en dnd deben estar ??

no esty del todo seguro de que sea esa la secuencia...

Muchas gracias de verdad MLO__.

un saludo desde españa.
Título: Re: detectar oponente SUMO
Publicado por: MLO__ en 05 de Diciembre de 2008, 14:56:36
La secuencia tuya hace exactamente lo mismo que la mia ....

Revisa si es la direccion 0x01 la que debes leer o no. En el caso del SRF02, esta en la direccion 0x02. Puedes estar leyendo un valor que no es, revisa eso en la datasheet del SRF08, ahi estan las direcciones de los registros y que guarda en cada una de ellas.

Saludos
Título: Re: detectar oponente SUMO
Publicado por: jfh900 en 05 de Diciembre de 2008, 17:11:34
Estas son las funciones que en su día utilice para leer y escribir en un SRF08. Por otra parte te comento que no es muy buena idea utilizar un medidor de distancias por ultrasonidos para detectar la proximidad de los enemigos. Es preferible utilizar un detector por infrarrojos.

Código: C
  1. /* ************************************************* */
  2. /* Función : SRF08_GetMeasurement */
  3. /* Parámetros : Address => Di r e c c i ón de l d i s p o s i t i v o */
  4. /* a l e e r */
  5. /* ModeMeasure => Modo de l e c t u r a */
  6. /* en pulgadas , */
  7. /* c ent ime t r o s o en */
  8. /* mi c rosegundos */
  9. /* Devuelve : La l e c t u r a de l a d i s t a n c i a como un */
  10. /* ent e r o l a r g o */
  11. /* Obj e t ivo : Re a l i z a r medidas de d i s t a n c i a en di spo&#8722; */
  12. /* s i t i v o s SRF08 */
  13. /* ************************************************* */
  14. long SRF08_GetMeasurement ( int Address ,MODE_MEASURE ModeMeasure )
  15. {
  16. // Lanzamos l a l e c t u r a de l a d i s t a n c i a
  17. // p r i n t f (" Di s p o s i t i v o : [%02X] Modo : <%u>\n\ r " , Address ,ModeMeasure ) ;
  18. nValue = 0 ;
  19. i 2 c_s t a r t ( ) ;
  20. i2c_wr i t e ( Address ) ;
  21. i2c_wr i t e (0 x00 ) ;
  22. switch(ModeMeasure )
  23. {
  24. case ModeInches : i2c_wr i t e (0 x50 ) ; break ;
  25. case ModeCentimeter : i2c_wr i t e (0 x51 ) ; break ;
  26. case ModeTimer : i2c_wr i t e (0 x52 ) ; break ;
  27. default : p r i n t f ( "Er ror en Mode Measure\n\ r " ) ;
  28. }
  29. // Esperamos a t e rminar l a l e c t u r a
  30. /* y = 2 5 5 ;
  31. whi l e ( y==255)
  32. {
  33. i 2 c_s t a r t ( ) ;
  34. i 2 c_wr i t e ( Address ) ;
  35. i 2 c_wr i t e (0 x00 ) ; // Le c tura en e l r e g i s t r o de medida
  36. i 2 c_s t a r t ( ) ;
  37. i 2 c_wr i t e ( Address +1) ;
  38. y = i2c_read ( 1 ) ;
  39. i2c_s top ( ) ;
  40. }
  41. */
  42. delay_ms ( 1 0 5 ) ; // Esperamos timepo de vue lo ( ¾65ms ? )
  43. // Leemos e l v a l o r en c u e s t i ó n
  44. i 2 c_s t a r t ( ) ;
  45. i2c_wr i t e ( Address ) ;
  46. i2c_wr i t e (0 x02 ) ;
  47. i 2 c_s t a r t ( ) ;
  48. i2c_wr i t e ( Address+1);
  49. nValHigh = i2c_read ( 1 ) ;
  50. nValLow = i2c_read ( 0 ) ;
  51. /*
  52. f o r ( y=1;y<=15;y++)
  53. {
  54. i2c_read ( 1 ) ;
  55. i2c_read ( 1 ) ;
  56. }
  57. */
  58. i2c_s top ( ) ;
  59. // p r i n t f (" nValHigh : %u &#8722; nValLow : %u Medida : %f \n\ r " ,
  60. // nValHigh , nValLow , ( nValHigh*256+nValLow ) * 0 . 0 3 4 6 4 / 2 ) ;
  61. return ( nValHigh*256+nValLow ) ;
  62. }
  63. int SRF08_SetGain ( int Address , int Gain )
  64. {
  65. nValue = 0 ;
  66. i 2 c_s t a r t ( ) ;
  67. i2c_wr i t e ( Address ) ; nValue =1;
  68. i2c_wr i t e (0 x01 ) ; nValue +=2;
  69. i 2 c_s t a r t ( ) ;
  70. i2c_wr i t e ( Address ) ; nValue +=4;
  71. i2c_wr i t e (Gain ) ; nValue +=8;
  72. i2c_s top ( ) ;
  73. return nValue ;
  74. }
  75.  
  76. /* ************************************************* */
  77. /* Función : i2c_Ge tRegi s t e r */
  78. /* Parámetros : Address => Di r e c c i ón de l d i s p o s i t i v o */
  79. /* nAddrReg => No de l r e g i s t r o a l e e r */
  80. /* Devuelve : El v a l o r de l r e g i s t r o l e i d o */
  81. /* Obj e t ivo : Lee c u a l q u i e r r e g i s t r o de l d i s p o s i t i v o */
  82. /* ************************************************* */
  83. int i2c_Ge tRegi s t e r ( int Address , int nAddrReg )
  84. {
  85. nValue = 0 ;
  86. i 2 c_s t a r t ( ) ;
  87. i f ( i2c_wr i t e ( Address )==1) nValue =1;
  88. i f ( i2c_wr i t e ( nAddrReg)==1) nValue+=2;
  89. i 2 c_s t a r t ( ) ;
  90. i f ( i2c_wr i t e ( Address+1)==1) nValue+=4;
  91. nValLow = i2c_read ( 1 ) ;
  92. i2c_s top ( ) ;
  93. return nValLow ;
  94. }
  95. /* ************************************************* */
  96. /* Función : i2c_Wr iRegi s t e r */
  97. /* Parámetros : Address => Di r e c c i ón de l d i s p o s i t i v o */
  98. /* nAddrReg => No de l r e g i s t r o a l e e r */
  99. /* Value => Valor a e s c r i b i r en e l */
  100. /* r e g i s t r o */
  101. /* Devuelve : Nada */
  102. /* Obj e t ivo : La e s c r i t u r a en e l r e g i s t r o de */
  103. /* c u a l q u i e r d i s p o s i t i v o cone c tado a l bus */
  104. /* I2C */
  105. /* ************************************************* */
  106. int i2c_WriRegister ( int Address , int nAddrReg , int Value )
  107. {
  108. nValue = 0 ;
  109. i 2 c_start( ) ;
  110. i f ( i2c_write( Address )==1)
  111. nValue=1;
  112. i f ( i2c_write( nAddrReg)==1) // Se pasa l a d i r e c c i ó n de l
  113. nValue+=2;                          // r e g i s t r o a e s c r i b r i r
  114. i f ( i2c_write(Value)==1)
  115. nValue+=4;
  116. i2c_stop ( ) ;
  117. return nValue ;
  118. }

Siento que al pegar el código ha perdido la indentación y no se que me ha echo con el texto.

Un saludo
Título: Re: detectar oponente SUMO
Publicado por: Nabil en 05 de Diciembre de 2008, 17:34:44
gracias, echaré un vistazo ahoramismo a tu codigo.

de todos modos xq dices que no es recomendable usar ultrasonidos ???

los infrarojos no son sensibles al negro..

has tenido experiencia con ellos ?? los has usado y dan buen resultado ??
que estrategia has seguido ??
Título: Re: detectar oponente SUMO
Publicado por: jfh900 en 05 de Diciembre de 2008, 22:07:17
Hola

He probado el SRF08 y da muchos problemas de rebote y falsas medidas, sin embargo los infrarrojos son mucho más precisos y no dan tantos problemas ademas de ser más baratos.

Un saludo
Título: Re: detectar oponente SUMO
Publicado por: Nabil en 06 de Diciembre de 2008, 11:25:19
pero no es verdad que los infrarojos son inútiles ante color negro ??

crees que darán buen resultado ?? aunque sean enemigos pintados con coberturas negras ??

en ese caso que sensores de infrarojos me recomiendas ??

PD: xq crees q son tan efectivos ??, has utilizado otras tecnicas de deteccion ??
Título: Re: detectar oponente SUMO
Publicado por: jfh900 en 06 de Diciembre de 2008, 17:19:11
Este es el tipo de detector más utilizado y no suele dar problemas:

http://www.superrobotica.com/S300486.htm

Un saludo
Título: Re: detectar oponente SUMO
Publicado por: Nabil en 07 de Diciembre de 2008, 10:48:50
parece una buena solución jfh900

pero el sensor tiene 3 pines: +5, tierra, y la Vout del sensor.
esa Vout da mas tensión cuanto mas cerca este el objeto.

pero para eso hace falta usar el conversor-analogico digital del PIC no ?

la idea es dar vueltas por el tatami y cuando el sensor de un lado detecte cualquier cosa (obstaculo por ese lado), la parte frontal gire hacia ese lado.
por eso no es importante la distancia exacta, ni utilizando el SRF08 ni los infrarojos.simplemente que me digan: AHI HAY ALGO
y entonces girar a ese lado.

cuantos sensores de infrarojos como ese podría utilizar ?; tantos como pines tenga el PIC ??
teneis un ejemplo de programa que utilice estos sensores, para que me digan solamente si hay algun objeto ?

podía ser unaidea, guardar el valor en un registro inicializado a '0'; y cuando el infrarojo detecte algo,cmbiar el valor de ese registro, y asi que el PIC sepa que hay que girar a ese lado.

con que codigo en Css puedo empezar a investigar ?
__________________________________________________
GRACIAS, este foro es lo mejor ¡¡¡
saludos.
Título: Re: detectar oponente SUMO
Publicado por: jfh900 en 08 de Diciembre de 2008, 08:42:33
Ahora mismo me encuentro trabajando en un mini luchador de Sumo que utiliza precisamente los infrarrojos para detectar al contrario, en concreto utilizaremos 4 detectores, uno por cada cara. La tensión suministrada por el detector es inversamente proporcional a la distancia y su lectura es tan simple como leer en el ADC su valor. Puedes poner por software un límite de distancia y con ello activar una variable que sea detectada por el programa principal y actuar en consecuencia, como por ejemplo (seudocódigo):

Var = read_ADC;

if (Var >= Limite)
   Detectado = Cierto;
sino
   Detectado = Falso;


Un saludo