:: envio / recepcion i2c con buffer, multidato, o vector :: Buscando solución ::

[pajaro]

Hola

Hace unas semanas logre comunicar un pic maestro con dos esclavos,
a los cuales les enviaba solo un dato.

ahora estoy modificando el programa para enviar mas datos,
bien dato a dato o bien por un vector o buffer. y en la recepcion con uno de un vector,
o buffer de recepción.


la idea era enviarlos mediante un vector, pero si no dejo un retardo de 50ms
entre envio y envio como que no trabaja.la simulacion de proteus..

...
i2c_wr_bus(addr, dato1);
delay_ms(50)
i2c_wr_bus(addr, dato2);
...


 esa parte la tengo + o menos apañada, no a mi gusto ya lo que pretendia era enviarle un vector
a la funcion.. como si fuera un puntero ... pero bueno..

ahora si, el verdadero problema:
 en la recepcion del dato le puse un contador
 para que me almacene en un vector segun llega el dato
no me gusta como resolvi el problema, pero bueno ... ya lo peinare despues..

la primera vez lo hace bien,
desde la posición  cero a la 3 , el 99 es una marca como lo fuera "\"
..pero la segunda hace cosas raras me carga todos lo valores en su pos 0 del vector

y otra cosa si acedo a los datos desde el bucle while , el pulsador no me funciona


que cosas..

master envia:

puldador on:

Código: C++

1. void main()
2. {
3.  
4.  
5.    setup_adc_ports(NO_ANALOGS|VSS_VDD);
6.    setup_adc(ADC_CLOCK_DIV_2);
7.    setup_wdt(WDT_OFF);
8.    setup_timer_0(RTCC_INTERNAL);
9.    setup_timer_1(T1_DISABLED);
10.    setup_timer_2(T2_DISABLED,0,1);
11.    setup_timer_3(T3_DISABLED|T3_DIV_BY_1);
12.    setup_comparator(NC_NC_NC_NC);
13.    setup_vref(FALSE);
14.    
15.    enable_interrupts(INT_SSP);
16.    enable_interrupts(GLOBAL);
17. //Setup_Oscillator parameter not selected from Intr Oscillator Config tab
18.  
19.    // TODO: USER CODE!!
20.    int8 dato,dato1,e;
21.    int8 envio[]={30,45,1,99};
22.    
23.    dato=30;
24.    dato1=40;
25.    
26. while(true){
27.    //delay_ms(1000);
28.      if(input(P1)==1){
29.        for(e=0;e<4;e++){
30.          printf("\n\r dato envio: %d"envio[e]);
31.          escribe_i2c_01(S1, envio[e]);
32.          delay_ms(50);
33.        }//fin for
34.        delay_ms(1000);
35.     }//fin if
36.  
37.    /*
38.    if(input(P1)==1){
39.      printf("\n\r dato envio: %d"dato);
40.      escribe_i2c_01(S1, dato);
41.      delay_ms(50);
42.      printf("\n\r dato envio: %d"dato1);
43.      escribe_i2c_01(S1, dato1);
44.  
45.      //delay_ms(300);
46.      //Dato_rcv_1=lee_i2c(S1);
47.      //printf("\n\r data_rcv_1: %X"Dato_rcv_1);
48.      delay_ms(1000);
49.    }
50.    
51.    */
52.  
53.   if(input(P2)==1){
54.      escribe_i2c_01(S2, Pide_Dato1);
55.      //delay_ms(300);
56.      //Dato_rcv_1=lee_i2c(S2);
57.      printf("\n\r data: %X"Dato_rcv_1);
58.      
59.   }
60. }//fin while
61.  
62.  
63. }

para la recepcion:

Código: C++

1. #include "esclavo_fe_1.h"
2.  
3. int8 state, Direc_master, iic_dato, comando;
4. int8 dato[5];
5. int8 cnt=0;
6.  
7. #int_SSP
8. void  SSP_isr(void){
9. disable_interrupts(INT_SSP);
10. //int8 comando;
11.  
12.  
13. state = i2c_isr_state();
14.    if(state==0)
15.    {
16.       Direc_Master=i2c_read();
17.      
18.       printf("\n\r direc_master: %X "Direc_Master);
19.       //if(SSPADD==S1){
20.       //printf("\n\r state==0 soy S1: %X "SSPADD);
21.       //}
22.      
23.    }
24.    
25.    if(state < 0x80)
26.    {
27.      
28.       //iic_dato=i2c_read();
29.       //comando=iic_dato;
30.       dato[cnt]=i2c_read();
31.      
32.       printf("\n\r dato[%u]:%u"cnt,dato[cnt]);
33.      
34.       if(dato[3]==99){
35.          cnt=0;
36.       }
37.       else{
38.          cnt=cnt+1;
39.       }
40.      
41.       //Aqui colocas lo que necesites hacer con el dato enviado por el maestro
42.       //printf("\n\r comando recibo <80: %u"comando);
43.      
44.    }
45.    if(state == 0x80)
46.    {
47.    
48.       switch(comando)
49.       {
50.          Case Pide_Dato1:
51.             i2c_write(Dato1);
52.             output_high(PIN_B7);
53.             delay_ms(300);
54.             output_low(PIN_B7);
55.             delay_ms(300);
56.             output_high(PIN_B7);
57.             delay_ms(300);
58.             output_low(PIN_B7);
59.             delay_ms(300);
60.             output_high(PIN_B7);
61.             delay_ms(300);
62.             output_low(PIN_B7);
63.             printf("\n\r Llego dato.");
64.             break;
65.          Case Pide_Dato2:
66.             i2c_write(Dato2);
67.             output_high(PIN_B2);
68.             break;
69.       }
70.    }
71. }
72.  
73.  
74.  
75. void main()
76. {
77.  
78.    setup_adc_ports(NO_ANALOGS|VSS_VDD);
79.    setup_adc(ADC_CLOCK_DIV_2);
80.    setup_wdt(WDT_OFF);
81.    setup_timer_0(RTCC_INTERNAL);
82.    setup_timer_1(T1_DISABLED);
83.    setup_timer_2(T2_DISABLED,0,1);
84.    setup_comparator(NC_NC_NC_NC);
85.    setup_vref(FALSE);
86.    enable_interrupts(INT_SSP);
87.    enable_interrupts(GLOBAL);
88. //Setup_Oscillator parameter not selected from Intr Oscillator Config tab
89.  
90.    // TODO: USER CODE!!
91.    printf("\n\r Preparado S1: ");
92.    int8 dat;
93. while(true){
94.  
95.    if(P1==1){
96.       for(dat=0;dat<5;dat++){
97.          printf("\n\r dato[%u]:%u"dat,dato[dat]);
98.    
99.       }//fin for
100.       //printf("\n\r comando en p1: %X"comando);
101.       //enable_interrupts(INT_SSP);
102.    }//fin if
103.    //printf("\n\r comando en while: %d"comando);
104. enable_interrupts(INT_SSP);
105.  }//fin while
106.  
107. }

sigo dandole vueltas a esto

si alguien conoce alguna otra forma de resolver el problema y le funciona
le agradeceria de todo corazon que la expusiara..

si algien conoce porque me hace estas cosas tan raras puede opinar


sigo a la faena...rolando..

[pajaro]

hola
sigo aca solucione algunas otras cosas pero la recepción,
en el esclavo me la hace a media, desde el master envio un vector
de 4 posiciones y cuando recive en el esclavo dentro de la interrupcion
recibe el dato en el orden enviado y da la sensacion que lo guardo bien....
sineembargo es una mera ilusion..

si sales de la interrupcion y pruebas a imprimir, desde el main no es correcto.

envio: 2,6,0,99  (desde master)

desde la int del i2c recivo 2,6,0,99
si imprimo el vector que se relleno des dela interupcion me da

99,6,0,99

no se porque se me come el primer numero;

ademas veo las direciones del esclavo y eso si parece que lo hace bien:

state = i2c_isr_state();
si estate es 00 saco la direcion del esclavo

si estate es menor de 80 guardo dato en vector de 4 el que veo que hace bien

si estate es mayor de 80 estoy parpadeando led

en el main imprimo el vector para segurarme que es eso, pero no es lo que le envie.



alguna idea de este error?


Un saludo sigo luchando..




enlaces:

http://www.todopic.com.ar/foros/index.php?topic=12946.0

http://www.todopic.com.ar/foros/index.php?topic=36248.0

http://solocodigo.com/45062/comunicacion-i2c-multi_master-entre-pics/

http://www.forosdeelectronica.com/f24/comunicacion-entre-2-pics-i2c-39673/

http://www.forosdeelectronica.com/f24/pic16f873a-esclavo-i2c-37748/

[pajaro]

Hola
 sigue ahciendo cosas raras al cambiar envio de datos
si envio:

2,3,0,99

99 es distintivo de reset del contador de interrupcion
para que me ponga el dato recibido donde yo quiero, en la posicion del vector que yo quiero

recivo[cnt]=2
....

recivo[0]=2
recivo[1]=3
recivo[2]=0
recivo[3]=99

esto lo hace bien
pero si le envio

2,3,1,99

me recoge:

recivo[0]=2
recivo[1]=3
recivo[2]=0
recivo[3]=176 // que se corresponde con B2 que es la direcion del esclavo

en ese momento se jode la trasmision

si envio un paquete a S1 y otro a S2
si esto lo hago con s2 S1 llega bien
pero si lo hago con S1 a s2 no llega nada.

con : 0 en el tercer bit no pasa nada:
es decir si envio esto:

2,3,0,99

pero si envio esto 2,3,1,99

ya se a liado. el master no envia mas y el esclavo me escribe 2,3,1,176

funciones que uso en i2c

Código: C++

1. void escribe_i2c_01(int8 pic, int8 dato ){
2.      i2c_start();    // Condicion Inicio
3.      i2c_write(pic);// Direccion dispositivo
4.      //delay_ms(3);    // *** Necesario ***
5.      i2c_write(dato);// dato
6.      //delay_ms(3);    // *** Necesario ***
7.      //i2c_write(++dato);// dato
8.      i2c_stop();     // Stop
9.      //delay_us(20);
10.  }  
11.  
12.  //traspado giro
13.  //angulo, inclinacion, envio, posicion de v1,v2 estdo de motor
14. void pasa_giro(int8 *v1[], int8 *v2[],int8 *v3[], int8 pos_v, int8 m_on){
15.    v3[0]=v1[pos_v];
16.    v3[1]=v2[pos_v];
17.    v3[2]=m_on;
18.    v3[3]=99;
19.    
20. }
21.  
22. //funcion de envio de vector por i2c
23. //S1, envio,rango
24. void envia_sv(int8 PIC, int8 *v[]){
25. int8 e;
26.        for(e=0;e<4;e++){
27.          printf("\n\r dato envio: %d" v[e]);
28.          escribe_i2c_01(PIC, v[e]);
29.          delay_ms(50);
30.        }//fin for
31.        delay_ms(1000);
32.  
33. }

desde el main en el master lo llamo asi:

Código: C++

1. ..
2. ..
3.  printf("\n\r\n\r angulos S1: "); //--- debug
4.    pasa_giro(angulo, inclina, envio, 0, 1);
5.    envia_sv(S1, envio);
6.  
7.    printf("\n\r\n\r angulos: S2 ");   //---debug
8.    pasa_giro(angulo, inclina, envio, 0, 1);
9.    envia_sv(S2, envio);
10.    //envia_g(angulo, inclina, envio, 1);
11.  
12. ..
13. ..

en el esclavo recivo asi:

Código: C++

1. int8 state, Direc_master, iic_dato, comando;
2. int8 direc_Mas_esc, recivo=0;
3. int8 dato[4];
4. int8 cnt=0;
5.  
6.  
7. #int_SSP
8. void  SSP_isr(void){
9. disable_interrupts(INT_SSP);
10. //int8 comando;
11. //master escribe de esclavo  menor de <80
12. //master lee de esclavo      mayor de >80
13.  
14. state = i2c_isr_state();
15.    if(state==0)
16.    {
17.       direc_Mas_esc=i2c_read();
18.       if(direc_Mas_esc==S1){
19.       printf("\n\r --> Direccion: %X "direc_Mas_esc);
20.          recivo=1;
21.       }
22.      
23.       //printf("\n\r Direccion : %X "direc_Mas_esc); //para solo imprime s1
24.       //if(SSPADD==S1){
25.       //printf("\n\r state==0 soy S1: %X "SSPADD);
26.       //}
27.      
28.    }
29.    
30.    if(state < 0x80)
31.    {
32.      
33.       //iic_dato=i2c_read();
34.       //comando=iic_dato;
35.       if(recivo==1){
36.          
37.             dato[cnt]=i2c_read();
38.          
39.             printf("\n\r dato[%u]:%u"cnt,dato[cnt]);
40.             recivo=0;
41.          
42.          
43.             if(dato[3]==99){
44.                cnt=0;
45.             }
46.             else{
47.                cnt=cnt+1;
48.             }        
49.       }
50.      
51.      
52.      
53.  
54.      
55.  
56.      
57.       //Aqui colocas lo que necesites hacer con el dato enviado por el maestro
58.       //printf("\n\r comando recibo <80: %u"comando);
59.      
60.    }
61.    if(state == 0x80)
62.    {
63.    
64.     switch(comando)
65.       {
66.          Case Pide_Dato1:
67.             i2c_write(Dato1);
68.             output_high(PIN_B7);
69.             delay_ms(300);
70.             output_low(PIN_B7);
71.             delay_ms(300);
72.             output_high(PIN_B7);
73.             delay_ms(300);
74.             output_low(PIN_B7);
75.             delay_ms(300);
76.             output_high(PIN_B7);
77.             delay_ms(300);
78.             output_low(PIN_B7);
79.             printf("\n\r Llego dato.");
80.             break;
81.          Case Pide_Dato2:
82.             i2c_write(Dato2);
83.             output_high(PIN_B2);
84.             break;
85.       }
86.    }
87. }
88.  
89. ....
90. ...

se bloquea la trasmision cuando pongo 1 en el vector pos 3 contado desde 0
 y no me muestra 99 sino 176 en la recepcion del esclavo que se coresponde con su direcion de esclavo.


no se lo que le ocurre, pero no logro ver lo que le esta pasando lo depure con proteus y nada
gradeceria que alguienm e dira alguna idea del problema.


si le envio 0, funciona
si envio 1 no funciona
si le envio 2 tambien funciona que
le pasara con el uno?


si asi es no le puedo mandar dato que sea un 1 por que termina la comunicacion o se bloquea
a que es debido eso.

sigo rulando.

me refiero

pasa_giro(angulo, inclina, envio, a, b);

a deberia de ser cualquier valor de 1 a 7

b deberia de ser 1 o 0

el envio lo hace bien el master si no tiene 1, pero al recibir dato si dato es 1
se termina comunicacion o se bloquea y el sigueinte dato
lo asigna a la direccion.

sigo con esto..

http://www.todopic.com.ar/foros/index.php?topic=36248.0

http://www.todopic.com.ar/foros/index.php?e;topic=34581.0

esto continua..

si envio a,b,c,d

por i2c desde el master al esclavo
y despues vuelvoa volver a repetir

como alguno de los datos a enviar sea un 1
el eclavo al llegar al 1 no recibe nada y termina la recepcion
del esclavo

puede alguien decirme que esta pasando?

...

[pajaro]

Hola a todos ustedes

me gustaria saber porque mi recepcion de i2c
posee poltergeist cuando le envio 1 del master al esclavo.

Tambien me gustraria conocer el nombre del p. duende que hace
las otras cosas raras en la recepcion

como no me detecta los unos que le envio desde el master pues me cree una cutre funcion para sumar
a mi vector una unidad de forma que antes tenia valores de 1 hasta 7
ahora tengo valores de 2 hasta 8 y cuando reciba en el esclavo volvera a realizar la
operacion inversa ...

pero cual es mi sorpresa cuando descubro que se comporta de la mis forma rara que cuando le envio un 1
si ya se que eso no deberia de ser asi,... pero estoy mas quemao que la pipa un INDIO
que me disculpen los indios, 

Pediria que me dijeran que puedo hacer con este mal... i2c
esto no tiene ninguna logica