TODOPIC

Microcontroladores PIC => Lenguaje C para microcontroladores PIC => Mensaje iniciado por: pajaro en 11 de Junio de 2012, 15:08:42

Título: :: PIC18F250 nunca entra en #INT_SSP ::
Publicado por: pajaro en 11 de Junio de 2012, 15:08:42

Hola

Tengo 3 pic conectados mediante i2c,
para la recepcion del esclavo tengo una interrupcion.

#INT_SSP

la cosa es que esta insterupcion se activa si el bus i2c tiene eventos,
lo raro es que hay eventos pero la puñetera no se entera del evento.

Si le quito la interrupcion y le pongo un bucle y printeo el bus con
i2c_read() y i2c_isr_state();

obtengo la direcion del esclavo y los datos de lectura y escritura

la obtencion es 0,1 2 3,
y 80,81,82,83

pero la interrupción del bus no se entera que hay datos como  puedo obligar a que
se active,  ¿algun metodo? ¿que hace que esto ocurra.?

#Se agradeceria una ayuda#

Un Saludo.
 

Título: Re: :: PIC18F250 nunca entra en #INT_SSP ::
Publicado por: AngelGris en 11 de Junio de 2012, 16:42:25

  ¿Podés mostrar el código? Para activar la interrupción creo que en CCS tienes que escribir algo así "enable_interrupt(xxx)" y "enable_interrupt(global)" Siendo xxx la interrupción que quieras activar.

Título: Re: :: PIC18F250 nunca entra en #INT_SSP ::
Publicado por: rivale en 11 de Junio de 2012, 19:19:54

Cita de: AngelGris en 11 de Junio de 2012, 16:42:25

  ¿Podés mostrar el código? Para activar la interrupción creo que en CCS tienes que escribir algo así "enable_interrupt(xxx)" y "enable_interrupt(global)" Siendo xxx la interrupción que quieras activar.

como menciona AngelGris, muestra como configuras tu interrupcion y como declaras el I2C para poder ayudarte

Título: Re: :: PIC18F250 nunca entra en #INT_SSP ::
Publicado por: pajaro en 12 de Junio de 2012, 21:03:39

Hola amigos

siguiendo las indicaciones pongo el codigo:
correspondiente a 1 master (M1) y 2 esclavos (S1 , S2).
esclavo uno con interrupcion del i2c y esclavo 2 sin interrupcion del i2c.
los estoy simulando en proteus con pic18F250, el IDE de pragramacion
es bajo CCS.


codigo master

Código: C++

1. /*******************************************************
2. * M1.c: libreia principal
3. *
4. ********************************************************/
5. #include "M1.h"
6.  
7.  
8. void main()
9. {
10.  
11.    setup_adc_ports(NO_ANALOGS|VSS_VDD);
12.    setup_adc(ADC_CLOCK_DIV_2);
13.    setup_wdt(WDT_OFF);
14.    setup_timer_0(RTCC_INTERNAL);
15.    setup_timer_1(T1_DISABLED);
16.    setup_timer_2(T2_DISABLED,0,1);
17.    setup_timer_3(T3_DISABLED|T3_DIV_BY_1);
18.    setup_comparator(NC_NC_NC_NC);
19.    setup_vref(FALSE);
20. //Setup_Oscillator parameter not selected from Intr Oscillator Config tab
21.  
22.    // TODO: USER CODE!!
23.    
24.    OUTPUT_HIGH(PIN_B3);
25.    
26.    printf("\n\r PIC MASTER: ");
27.    printf("\n\r     enviando.... ");
28.    
29. int8 leodato,state,dato;
30.      
31.       state = i2c_isr_state(); //lee el estado del bus
32.       dato=i2c_read();
33.       printf("\n\r dato: %X  state: %X" dato,state);
34.  
35.       delay_ms(10);
36.      
37.       escribir_i2c(S1,5);
38.      
39.       state = i2c_isr_state(); //lee el estado del bus
40.       dato=i2c_read();
41.       printf("\n\r dato: %X  state: %X" dato,state);
42.      
43.       delay_ms(1000);
44.      
45.       state = i2c_isr_state(); //lee el estado del bus
46.       dato=i2c_read();
47.       printf("\n\r dato: %X  state: %X" dato,state);
48.      
49.       leodato=leer_i2c(S1);
50.      
51.      
52.       state = i2c_isr_state(); //lee el estado del bus
53.       dato=i2c_read();
54.      
55.       printf("\n\r leodato:%X state: %X dato: %X" leodato,state,dato);
56.  
57. }

Codigo Cabecera:

Código: C++

1. /*******************************************************
2. * s1.h: libreia de cabeceras
3. *
4. ********************************************************/
5. #include <18F2550.h>
6. #device adc=8
7.  
8. #FUSES NOWDT                    //No Watch Dog Timer
9. #FUSES WDT128                   //Watch Dog Timer uses 1:128 Postscale
10. #FUSES HS                       //High speed Osc (> 4mhz for PCM/PCH) (>10mhz for PCD)
11. #FUSES NOPROTECT                //Code not protected from reading
12. #FUSES NOBROWNOUT               //No brownout reset
13. #FUSES BORV20                   //Brownout reset at 2.0V
14. #FUSES NOPUT                    //No Power Up Timer
15. #FUSES NOCPD                    //No EE protection
16. #FUSES STVREN                   //Stack full/underflow will cause reset
17. #FUSES NODEBUG                  //No Debug mode for ICD
18. #FUSES NOLVP                    //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
19. #FUSES NOWRT                    //Program memory not write protected
20. #FUSES NOWRTD                   //Data EEPROM not write protected
21. #FUSES IESO                     //Internal External Switch Over mode enabled
22. #FUSES FCMEN                    //Fail-safe clock monitor enabled
23. #FUSES NOPBADEN                   //PORTB pins are configured as digital I/O on RESET
24. #FUSES NOWRTC                   //configuration not registers write protected
25. #FUSES NOWRTB                   //Boot block not write protected
26. #FUSES NOEBTR                   //Memory not protected from table reads
27. #FUSES NOEBTRB                  //Boot block not protected from table reads
28. #FUSES NOCPB                    //No Boot Block code protection
29. #FUSES MCLR                     //Master Clear pin enabled
30. #FUSES LPT1OSC                  //Timer1 configured for low-power operation
31. #FUSES NOXINST                  //Extended set extension and Indexed Addressing mode disabled (Legacy mode)
32. #FUSES PLL12                    //Divide By 12(48MHz oscillator input)
33. #FUSES CPUDIV4                  //System Clock by 4
34. #FUSES USBDIV                   //USB clock source comes from PLL divide by 2
35. #FUSES VREGEN                   //USB voltage regulator enabled
36.  
37. #use delay(clock=20000000)
38. #use rs232(baud=9600,parity=N,xmit=PIN_C6,rcv=PIN_C7,bits=8)
39. #use i2c(Master,Slow,sda=PIN_B0,scl=PIN_B1)
40.  
41. #include "milib.c"

mis librerias

Código: C++

1. /*******************************************************
2. * milib.c: libreia de mis funciones
3. *
4. ********************************************************/
5. //direcciones de dispositivos
6.  
7. #Define M1 0xA0 //Master
8. #Define S1 0xA2 //Esclavo 1
9. #Define S2 0xA4 //Esclavo 2
10. #Define S3 0xA6 //Esclavo 3
11.  
12.  
13. // --- escribir en dispositivo ---
14.  
15. void escribir_i2c(int8 direccion, int8 dato)
16. {
17.    i2c_start();
18.    i2c_write(direccion);
19.    //i2c_write(0);//add
20.    i2c_write(dato);
21.    i2c_stop();
22.    delay_us(150);
23. }
24.  
25.  
26. // --- leer del dispositivo ---
27. int8 leer_i2c(int8 direccion)
28. {
29.    int8 dato = 0;
30.    i2c_start();
31.    i2c_write(direccion); //direccion device
32.    //i2c_write(0); //add
33.      
34.    i2c_start();
35.    i2c_write(direccion+1);
36.    dato = i2c_read();
37.    //dato = i2c_read(0);//add
38.    i2c_stop();
39.    
40.    return(dato);
41. }

Esclavo 1

Código: C++

1. /*******************************************************
2. * s1.c: libreia principal
3. *
4. ********************************************************/
5. #include "s1.h"
6.  
7. #INT_SSP
8. //void  SSP_isr(void) {}
9. void ssp_interrupt(void);
10.  
11.  
12.  
13.  
14. void main(){
15.  
16.    setup_adc_ports(NO_ANALOGS|VSS_VDD);
17.    setup_adc(ADC_CLOCK_DIV_2);
18.    setup_wdt(WDT_OFF);
19.    setup_timer_0(RTCC_INTERNAL);
20.    setup_timer_1(T1_DISABLED);
21.    setup_timer_2(T2_DISABLED,0,1);
22.    setup_timer_3(T3_DISABLED|T3_DIV_BY_1);
23.    setup_comparator(NC_NC_NC_NC);
24.    setup_vref(FALSE);
25.    
26.    enable_interrupts(INT_SSP);
27.    enable_interrupts(GLOBAL);
28. //Setup_Oscillator parameter not selected from Intr Oscillator Config tab
29.  
30.    // TODO: USER CODE!!
31.    
32.    OUTPUT_HIGH(PIN_B3);
33.    
34.    printf("\n\r PIC ESCLAVO 1: ");
35.    printf("\n\r     recibiendo.... ");
36.    while(true){
37.    
38.    }
39.  
40. }

cabecera

Código: C++

1. /*******************************************************
2. * s1.h: libreia de cabeceras
3. *
4. ********************************************************/
5. #include <18F2550.h>
6. #device adc=8
7.  
8. #FUSES NOWDT                    //No Watch Dog Timer
9. #FUSES WDT128                   //Watch Dog Timer uses 1:128 Postscale
10. #FUSES XT                       //Crystal osc <= 4mhz for PCM/PCH , 3mhz to 10 mhz for PCD
11. #FUSES NOPROTECT                //Code not protected from reading
12. #FUSES NOBROWNOUT               //No brownout reset
13. #FUSES BORV20                   //Brownout reset at 2.0V
14. #FUSES NOPUT                    //No Power Up Timer
15. #FUSES NOCPD                    //No EE protection
16. #FUSES STVREN                   //Stack full/underflow will cause reset
17. #FUSES NODEBUG                  //No Debug mode for ICD
18. #FUSES NOLVP                    //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
19. #FUSES NOWRT                    //Program memory not write protected
20. #FUSES NOWRTD                   //Data EEPROM not write protected
21. #FUSES IESO                     //Internal External Switch Over mode enabled
22. #FUSES FCMEN                    //Fail-safe clock monitor enabled
23. #FUSES NOPBADEN                 //PORTB pins are configured as digital I/O on RESET
24. #FUSES NOWRTC                   //configuration not registers write protected
25. #FUSES NOWRTB                   //Boot block not write protected
26. #FUSES NOEBTR                   //Memory not protected from table reads
27. #FUSES NOEBTRB                  //Boot block not protected from table reads
28. #FUSES NOCPB                    //No Boot Block code protection
29. #FUSES MCLR                     //Master Clear pin enabled
30. #FUSES LPT1OSC                  //Timer1 configured for low-power operation
31. #FUSES NOXINST                  //Extended set extension and Indexed Addressing mode disabled (Legacy mode)
32. #FUSES PLL12                    //Divide By 12(48MHz oscillator input)
33. #FUSES CPUDIV4                  //System Clock by 4
34. #FUSES USBDIV                   //USB clock source comes from PLL divide by 2
35. #FUSES VREGEN                   //USB voltage regulator enabled
36.  
37. #use delay(clock=20000000)
38. #use rs232(baud=9600,parity=N,xmit=PIN_C6,rcv=PIN_C7,bits=8)
39. #use i2c(Slave,Slow,sda=PIN_B0,scl=PIN_B1,address=0xA2)
40.  
41. #include "milib.c"

mi libreria

Código: C++

1. /*******************************************************
2. * milib.c: libreia de mis funciones
3. *
4. ********************************************************/
5. //direcciones de dispositivos
6.  
7. #Define M1 0xA0 //Master
8. #Define S1 0xA2 //Esclavo 1
9. #Define S2 0xA4 //Esclavo 2
10. #Define S3 0xA6 //Esclavo 3
11.  
12.  
13. // --- escribir en dispositivo ---
14.  
15. void escribir_i2c(int8 direccion, int8 dato)
16. {
17.    i2c_start();
18.    i2c_write(direccion);
19.    //i2c_write(0);//add
20.    i2c_write(dato);
21.    i2c_stop();
22.    delay_us(150);
23. }
24.  
25.  
26. // --- leer del dispositivo ---
27. int8 leer_i2c(int8 direccion)
28. {
29.    int8 dato = 0;
30.    i2c_start();
31.    i2c_write(direccion); //direccion device
32.    //i2c_write(0); //add
33.      
34.    i2c_start();
35.    i2c_write(direccion+1);
36.    dato = i2c_read();
37.    //dato = i2c_read(0);//add
38.    i2c_stop();
39.    
40.    return(dato);
41. }
42. // -- funcion interrupcion ---
43.  
44. void ssp_interrupt(void){
45.    int8 state, buffer[];
46.    int8 i2c_dato_entrada,i2c_dato_funcion;
47.  
48.    state = i2c_isr_state();
49.    if(state >= 0x80){                    //master pide un dato
50.       i2c_write(buffer[i2c_dato_entrada]);          
51.    }
52.    else if(state == 0x01){               //Master esta enviando datos
53.       i2c_dato_entrada = i2c_read();
54.       buffer[i2c_dato_funcion] = i2c_dato_entrada;
55.    }
56.  
57. }

Esclavo 2

Código: C++

1. /*******************************************************
2. * s2.c: libreia principal
3. *
4. ********************************************************/
5. #include "s2.h"
6. //#int_SSP
7. //void ssp_interrupt(void);
8.  
9.  
10.  
11. void main()
12. {
13.  
14.    setup_adc_ports(NO_ANALOGS|VSS_VDD);
15.    setup_adc(ADC_CLOCK_DIV_2);
16.    setup_wdt(WDT_OFF);
17.    setup_timer_0(RTCC_INTERNAL);
18.    setup_timer_1(T1_DISABLED);
19.    setup_timer_2(T2_DISABLED,0,1);
20.    setup_timer_3(T3_DISABLED|T3_DIV_BY_1);
21.    setup_comparator(NC_NC_NC_NC);
22.    //setup_vref(FALSE);
23.    
24.    //enable_interrupts(INT_SSP);// las deshabilito porque lee cosas raras
25.    //enable_interrupts(GLOBAL); // las deshabilito porque lee cosas raras
26. //Setup_Oscillator parameter not selected from Intr Oscillator Config tab
27.  
28.    // TODO: USER CODE!!
29.    printf("\n\r PIC ESCLAVO 2: ");
30.    printf("\n\r     recibiendo.... ");
31.    
32.    int8 state,leo;
33.    
34.    OUTPUT_HIGH(PIN_B3);
35.    
36.    while (true) {
37.        
38.      
39.    state = i2c_isr_state(); //lee el estado del bus
40.    leo=i2c_read();
41.    printf("\n\r leo: %X  state: %X  "leo,state);
42.    delay_ms(1000);
43.    state = i2c_isr_state(); //lee el estado del bus
44.    leo=i2c_read();
45.    printf("\n\r leo: %X  state: %X  "leo,state);
46.    
47.    }//fin while
48.  
49. }

cabeceras

Código: C++

1. /*******************************************************
2. * s2.h: libreia de cabeceras
3. *
4. ********************************************************/
5. #include <18F2550.h>
6. #device adc=8
7.  
8. #FUSES NOWDT                    //No Watch Dog Timer
9. #FUSES WDT128                   //Watch Dog Timer uses 1:128 Postscale
10. #FUSES HS                       //High speed Osc (> 4mhz for PCM/PCH) (>10mhz for PCD)
11. #FUSES NOPROTECT                //Code not protected from reading
12. #FUSES NOBROWNOUT               //No brownout reset
13. #FUSES BORV20                   //Brownout reset at 2.0V
14. #FUSES NOPUT                    //No Power Up Timer
15. #FUSES NOCPD                    //No EE protection
16. #FUSES STVREN                   //Stack full/underflow will cause reset
17. #FUSES NODEBUG                  //No Debug mode for ICD
18. #FUSES NOLVP                    //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
19. #FUSES NOWRT                    //Program memory not write protected
20. #FUSES NOWRTD                   //Data EEPROM not write protected
21. #FUSES IESO                     //Internal External Switch Over mode enabled
22. #FUSES FCMEN                    //Fail-safe clock monitor enabled
23. #FUSES NOPBADEN                 //PORTB pins are configured as digital I/O on RESET
24. #FUSES NOWRTC                   //configuration not registers write protected
25. #FUSES NOWRTB                   //Boot block not write protected
26. #FUSES NOEBTR                   //Memory not protected from table reads
27. #FUSES NOEBTRB                  //Boot block not protected from table reads
28. #FUSES NOCPB                    //No Boot Block code protection
29. #FUSES MCLR                     //Master Clear pin enabled
30. #FUSES LPT1OSC                  //Timer1 configured for low-power operation
31. #FUSES NOXINST                  //Extended set extension and Indexed Addressing mode disabled (Legacy mode)
32. #FUSES PLL12                    //Divide By 12(48MHz oscillator input)
33. #FUSES CPUDIV4                  //System Clock by 4
34. #FUSES USBDIV                   //USB clock source comes from PLL divide by 2
35. #FUSES VREGEN                   //USB voltage regulator enabled
36.  
37. #use delay(clock=20000000)
38. #use rs232(baud=9600,parity=N,xmit=PIN_C6,rcv=PIN_C7,bits=8)
39. #use i2c(Slave,Slow,sda=PIN_B0,scl=PIN_B1,address=0xA4)
40.  
41. #include "milib.c"

mi libreria

Código: C++

1. /*******************************************************
2. * milib.c: libreia de mis funciones
3. *
4. ********************************************************/
5. //direcciones de dispositivos
6.  
7. #Define M1 0xA0 //Master
8. #Define S1 0xA2 //Esclavo 1
9. #Define S2 0xA4 //Esclavo 2
10. #Define S3 0xA6 //Esclavo 3
11.  
12.  
13. // --- escribir en dispositivo ---
14.  
15. void escribir_i2c(int8 direccion, int8 dato)
16. {
17.    i2c_start();
18.    i2c_write(direccion);
19.    //i2c_write(0);//add
20.    i2c_write(dato);
21.    i2c_stop();
22.    delay_us(150);
23. }
24.  
25.  
26. // --- leer del dispositivo ---
27. int8 leer_i2c(int8 direccion)
28. {
29.    int8 dato = 0;
30.    i2c_start();
31.    i2c_write(direccion); //direccion device
32.    //i2c_write(0); //add
33.      
34.    i2c_start();
35.    i2c_write(direccion+1);
36.    dato = i2c_read();
37.    //dato = i2c_read(0);//add
38.    i2c_stop();
39.    
40.    return(dato);
41. }
42. // -- funcion interrupcion ---
43.  
44. void ssp_interrupt(void){
45.    int8 state, buffer[];
46.    int8 i2c_dato_entrada,i2c_dato_funcion;
47.    
48.    printf("\n\r interrupcion");
49.    state = i2c_isr_state();
50.    if(state >= 0x80){                    //master pide un dato
51.       i2c_write(buffer[i2c_dato_entrada]);          
52.    }
53.    else if(state == 0x01){               //Master esta enviando datos
54.       i2c_dato_entrada = i2c_read();
55.       buffer[i2c_dato_funcion] = i2c_dato_entrada;
56.    }
57.  
58. }

debajo adjunto el archivo de proteus.

Un saludo

Título: Re: :: PIC18F250 nunca entra en #INT_SSP ::
Publicado por: AngelGris en 12 de Junio de 2012, 22:10:27

  Yo no veo ningún código que corresponda a la interrupción SSP en el esclavo 1. Está la definición, pero no la implementación.
Por lo tanto, si no hay implementación no vas a poder hacer nada.

Título: Re: :: PIC18F250 nunca entra en #INT_SSP ::
Publicado por: pajaro en 13 de Junio de 2012, 04:52:37

Cita de: AngelGris en 12 de Junio de 2012, 22:10:27

 Yo no veo ningún código que corresponda a la interrupción SSP en el esclavo 1. Está la definición, pero no la implementación.
Por lo tanto, si no hay implementación no vas a poder hacer nada.

Hola AngelGris
Lo implemeeto en la libreria "milib.c", junto con la funcion de escribir y leer el i2c.

El master es un proyecto, el esclavo 1 es otro y el esclavo 2 es otro.
Cada proyecto tiene 3 archivos, el principal o main.c su caberea el .h
y una tecera milib.c lo hago asi para que me genere 3 *.hex distintos.
Cada main tiene su milib.c y su cabecera.

No se, si con este IDE se pueden meter todos los main en un mismo proyecto,
y que te generen distintos *.hex disculpen las molestias.


Un saludo.

Título: Re: :: PIC18F250 nunca entra en #INT_SSP ::
Publicado por: MGLSOFT en 13 de Junio de 2012, 08:06:16

Te has comido una "r" en la palabra interrupt.

Citar

Void SSP_Interupt

el compilador piensa que es otra funcion mas... :mrgreen: :mrgreen:

Ademas delante de la funcion debes poner esta marca de interrupcion:

Código: C

1. #INT_SSP

Título: Re: :: PIC18F250 nunca entra en #INT_SSP ::
Publicado por: AngelGris en 13 de Junio de 2012, 09:01:33

  Más allá de lo que te comenta MGLSOFT, en tu librería existe una función declarada como

Código: C

1. void ssp_interupt(void)

y en el main existe otra declarada como

Código: C

1. void ssp_interupt();

  Creo que el compilador puede interpretar que se trata de dos funciones distintas, ya que una no recibe parámetros y la otra no se... porque no tiene nada entre los paréntesis, o sea, no se como interprete esa ausencia el compilador.
 

  No estoy seguro si en la declaración de la función es necesario que figure "interrupt", yo creería que es suficiente con el señalizador "#INT_SSP"

  Yo probaría implementando directamente la interrupción en el main.c. O como dice MGLSOFT pone el señalizador en la implementación que está en la librería.

Título: Re: :: PIC18F250 nunca entra en #INT_SSP ::
Publicado por: pajaro en 13 de Junio de 2012, 12:07:26

Hola
voya a por eso de la "r", supuestamente es una funcion mas no..?

pero predecida de  #INT_SSP

tambien he decir que el asitente al crar el proyectos si le marcas lo de
 aviso de interupcion i2c o spi te crea una funcion..

#INT_SSP
//void  SSP_isr(void) {}

pero la llama de forma diferente yo solo le cambien nombre para reconocerla,
 eso no tendra que ver ... no..

resumiendo:
- cambio lo del a r :: void ssp_interupt(); por void ssp_interrupt()
- cambio lo de la declaracion:: void ssp_interrupt(); por void ssp_interrupt(void);

y cruzaremos todos los dedos para que sea eso..

ahora nos vemos..
 ......


=========================================

ya de vuelta...

No hubo suerte coloque la función con la r y en el main, comentado la de la libreria
para que no se queje de duplicidad
al final la defini con void...(void);

pero sigue igual

al mirar el debug del i2c del proteus y los mensas me dice una cosa muy rara
en el debug me salen interrogante delante de los numeros  ? ? ? ? ? S A2 A 05 A P
y en otra linea muchos mas hay ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? S A2 A Sr A3 N FF A P
y en la ultima so hay ? ? ? ? ? ? ? ? ? ? ?


y el cuadro de mensajes me dice .. un insulto ...:

Spurious SCL Transition detected at 0.0677xxs

este mensaje lo da como unas 200 veces, las xx cambiam

Que me esta diciendo el simulador?

mis funciones de lectura y escritura implementadas son correctas?

yo pienso que si, pero ustedes... puedes ponerles un ojo..

no se ocurre otra cosa...

Título: Re: :: PIC18F250 nunca entra en #INT_SSP ::
Publicado por: AngelGris en 13 de Junio de 2012, 20:19:55

  Los signos de pregunta, se deben a que el debbuger detecta actividad del bus pero no puede interpretarla.
  ¿Que tipo de resistencia estás colocando en proteus para la simulación?

Título: Re: :: PIC18F250 nunca entra en #INT_SSP ::
Publicado por: pajaro en 13 de Junio de 2012, 20:49:19

Cita de: AngelGris en 13 de Junio de 2012, 20:19:55

  Los signos de pregunta, se deben a que el debbuger detecta actividad del bus pero no puede interpretarla.
  ¿Que tipo de resistencia estás colocando en proteus para la simulación?

 de 1K analogicas, los valores eran de 2k2, 4k7 y 10 K
 creo recordar segun la velocidad y la distancia del bus
 las cambie por las de 2k2 analogicas y las ? ? ? ? ? ? ?  siguen

a lo mejor son las funciones que uso en la lectura y la escritura
ya no se que pensar....

No se.. tu que crres que puede ser...?

Un Saludo.

Título: Re: :: PIC18F250 nunca entra en #INT_SSP ::
Publicado por: AngelGris en 13 de Junio de 2012, 22:04:23

  Generalmente para simular bien el bus I2C no hay que usar las resistencias comunes sino unas llamadas pullups que se encuentran en la categoría "Modelling primitives"

Título: :: PIC18F250 nunca entra en #INT_SSP ::
Publicado por: pajaro en 14 de Junio de 2012, 06:31:22

Cita de: AngelGris en 13 de Junio de 2012, 22:04:23

 Generalmente para simular bien el bus I2C no hay que usar las resistencias comunes sino unas llamadas pullups que se encuentran en la categoría "Modelling primitives"

Hola yo tenia entendido que las pull up eran resistencias digitales,
asi que las puse como digitales y tampo iba pero esaminado el master

vi que como tenia puesto esto:

      state = i2c_isr_state(); //lee el estado del bus
      dato=i2c_read();
      printf("\n\r dato: %X  state: %X" dato,state);

para saber como estaba el bus eso era el causante de los interrogantes
como bien dijiste habia actividad en el bus cuando los comente ya no salieron.

Pero el problema persiste no se entera de la interrupcion.

la configuracion es la de cada pic es que los tengo en los pines B0 y B1
que son los pines de SDA y SCL correspondientementte se podria decir que son los pines
del hardware pero no quiero forzar con la sentencia de fuerza harware.

Debe de haber algun problema en la libreria de ccs u algo se me esta pasando no es normal esto que me pasa.

¿Como se detectaria las fallas en ese bus?


- como provocar o forzar la interrupcion #INT_SSP

- evaluar que mis funcones implementadas (escritura y lectura del i2c) estan bien contruidas

- estados del bus (00,01,02,03..... 80,81,82,83,84,85....)

Título: Re: :: PIC18F250 nunca entra en #INT_SSP ::
Publicado por: pajaro en 19 de Junio de 2012, 09:47:20

hola

ya han pasado varios dias luchando con la dichosa interrupción
por el momento ella va ganando.

Lo unico que he conseguido por el momento es que con el debug de proteus y el teminal virtual
me saque 00 o 80 y ello depende de los tiempos de espera es decir depende del tiempo
que le pongo me muestra el bit de escritura o el de lectura del bus.

Pero la Señora interrupccion ni se inmuta. y por el bus hay eventos confirmados.

!!Necesito ayuda¡¡ ya no se lo que hacerle

ya solo me queda probar algun codigo de alguien que si que le funcione
para ver es el simulador de proteus ..o es la configuracion del pic ...o tan solo el pic18f2550

... :?

Título: Re: :: PIC18F250 nunca entra en #INT_SSP ::
Publicado por: MGLSOFT en 19 de Junio de 2012, 09:52:18

Deberias poner tu ultimo codigo (completo) para ver que puede estar causandote esto, incluso alguno podria compilarlo y ver que pasa para ayudarte.
Si pones el codigo, usa GeShi y la opcion C o C++.

Título: Re: :: PIC18F250 nunca entra en #INT_SSP ::
Publicado por: pajaro en 19 de Junio de 2012, 10:17:00

Cita de: MGLSOFT en 19 de Junio de 2012, 09:52:18

Deberias poner tu ultimo codigo (completo) para ver que puede estar causandote esto, incluso alguno podria compilarlo y ver que pasa para ayudarte.
Si pones el codigo, usa GeShi y la opcion C o C++.

hola MGLSOFT

voy a poner el code:
M1:: master
S1:: esclavo 1 con interrupcion
S2:: esclavo 2 sin  interrupcion

Código: C++

1. /*******************************************************
2. * M1.c: libreia principal
3. *
4. ********************************************************/
5. #include "M1.h"
6.  
7.  
8. void main()
9. {
10.  
11.    setup_adc_ports(NO_ANALOGS|VSS_VDD);
12.    setup_adc(ADC_CLOCK_DIV_2);
13.    setup_wdt(WDT_OFF);
14.    setup_timer_0(RTCC_INTERNAL);
15.    setup_timer_1(T1_DISABLED);
16.    setup_timer_2(T2_DISABLED,0,1);
17.    setup_timer_3(T3_DISABLED|T3_DIV_BY_1);
18.    setup_comparator(NC_NC_NC_NC);
19.    setup_vref(FALSE);
20. //Setup_Oscillator parameter not selected from Intr Oscillator Config tab
21.  
22.    // TODO: USER CODE!!
23.    int8 leodato,state;
24. int8 addr,dato;
25.  
26.    if(existe_addr(S1)){
27.    printf("\n\r Se encontro %X "addr);
28.    }
29.    OUTPUT_HIGH(PIN_B3);
30.    
31.    printf("\n\r PIC MASTER: ");
32.    printf("\n\r     enviando.... ");
33.    addr=S1;
34.    dato=5;
35.    printf("\n\r ADDR: %X  dato: %d "addr,dato);
36.    
37.  
38.  
39.      
40.       /*state = i2c_isr_state(); //lee el estado del bus
41.       dato=i2c_read();
42.       printf("\n\r dato: %X  state: %X" dato,state);
43.  
44.       delay_ms(10);
45.     */
46.       escribir_i2c(addr,dato);
47.  
48.       /*
49.       state = i2c_isr_state(); //lee el estado del bus
50.       dato=i2c_read();
51.       printf("\n\r dato: %X  state: %X" dato,state);
52.       */
53.       delay_ms(100);
54.       /*
55.       state = i2c_isr_state(); //lee el estado del bus
56.       dato=i2c_read();
57.       printf("\n\r dato: %X  state: %X" dato,state);
58.       */
59.       leodato=leer_i2c(S1);
60.      
61.       /*
62.       state = i2c_isr_state(); //lee el estado del bus
63.       dato=i2c_read();
64.      
65.       printf("\n\r leodato:%X state: %X dato: %X" leodato,state,dato);
66. */
67. if(existe_addr(S1)){
68. printf("\n\r Se encontro %X "addr);
69. }
70. }

Código: C++

1. /*******************************************************
2. * s1.h: libreia de cabeceras
3. *
4. ********************************************************/
5. #include <18F2550.h>
6. #device adc=8
7.  
8. #FUSES NOWDT                    //No Watch Dog Timer
9. #FUSES WDT128                   //Watch Dog Timer uses 1:128 Postscale
10. #FUSES HS                       //High speed Osc (> 4mhz for PCM/PCH) (>10mhz for PCD)
11. #FUSES NOPROTECT                //Code not protected from reading
12. #FUSES NOBROWNOUT               //No brownout reset
13. #FUSES BORV20                   //Brownout reset at 2.0V
14. #FUSES NOPUT                    //No Power Up Timer
15. #FUSES NOCPD                    //No EE protection
16. #FUSES STVREN                   //Stack full/underflow will cause reset
17. #FUSES NODEBUG                  //No Debug mode for ICD
18. #FUSES NOLVP                    //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
19. #FUSES NOWRT                    //Program memory not write protected
20. #FUSES NOWRTD                   //Data EEPROM not write protected
21. #FUSES IESO                     //Internal External Switch Over mode enabled
22. #FUSES FCMEN                    //Fail-safe clock monitor enabled
23. #FUSES NOPBADEN                   //PORTB pins are configured as digital I/O on RESET
24. #FUSES NOWRTC                   //configuration not registers write protected
25. #FUSES NOWRTB                   //Boot block not write protected
26. #FUSES NOEBTR                   //Memory not protected from table reads
27. #FUSES NOEBTRB                  //Boot block not protected from table reads
28. #FUSES NOCPB                    //No Boot Block code protection
29. #FUSES MCLR                     //Master Clear pin enabled
30. #FUSES LPT1OSC                  //Timer1 configured for low-power operation
31. #FUSES NOXINST                  //Extended set extension and Indexed Addressing mode disabled (Legacy mode)
32. #FUSES PLL12                    //Divide By 12(48MHz oscillator input)
33. #FUSES CPUDIV4                  //System Clock by 4
34. #FUSES USBDIV                   //USB clock source comes from PLL divide by 2
35. #FUSES VREGEN                   //USB voltage regulator enabled
36.  
37. #use delay(clock=20000000)
38. #use rs232(baud=9600,parity=N,xmit=PIN_C6,rcv=PIN_C7,bits=8)
39. #use i2c(Master,Slow,sda=PIN_B0,scl=PIN_B1)
40.  
41. #use fast_io(B)
42. #include "milib.c"

Código: C++

1. /*******************************************************
2. * milib.c: libreia de mis funciones
3. *
4. ********************************************************/
5. //direcciones de dispositivos
6.  
7. #Define M1 0xA0 //Master
8. #Define S1 0xA2 //Esclavo 1
9. #Define S2 0xA4 //Esclavo 2
10. #Define S3 0xA6 //Esclavo 3
11.  
12.  
13. // --- escribir en dispositivo ---
14.  
15. void escribir_i2c(int8 direccion, int8 dato)
16. {
17.    i2c_start();
18.    i2c_write(direccion);
19.    //i2c_write(0);//add
20.    i2c_write(dato);
21.    i2c_stop();
22.    //delay_us(50);
23. }
24.  
25.  
26. // --- leer del dispositivo ---
27. int8 leer_i2c(int8 direccion)
28. {
29.    int8 dato = 0;
30.    i2c_start();
31.    i2c_write(direccion); //direccion device
32.    //i2c_write(0); //add
33.      
34.    i2c_start();
35.    i2c_write(direccion+1);
36.    //dato = i2c_read();
37.    dato = i2c_read(0);//add
38.    return(dato);
39.    i2c_stop();
40.    
41.    
42. }
43.  
44.  
45. //text de dispositivo
46.  
47. int8 existe_addr(int8 addr){
48.  
49.   i2c_start();
50.   if(i2c_write(addr)){
51.     return 0;
52.   }else{
53.     return 1;
54.   }
55.   i2c_stop();
56. }

========================

Código: C++

1. /*******************************************************
2. * s1.c: libreia principal
3. *
4. ********************************************************/
5. #include "s1.h"
6.  
7. #INT_SSP
8. //void SSP_isr(void){
9. void ssp_interrupt(void);
10.  
11.  
12.  
13. void main(){
14.  
15.    setup_adc_ports(NO_ANALOGS|VSS_VDD);
16.    setup_adc(ADC_CLOCK_DIV_2);
17.    setup_wdt(WDT_OFF);
18.    setup_timer_0(RTCC_INTERNAL);
19.    setup_timer_1(T1_DISABLED);
20.    setup_timer_2(T2_DISABLED,0,1);
21.    setup_timer_3(T3_DISABLED|T3_DIV_BY_1);
22.    setup_comparator(NC_NC_NC_NC);
23.    setup_vref(FALSE);
24.    
25.    enable_interrupts(INT_SSP);
26.    enable_interrupts(GLOBAL);
27. //Setup_Oscillator parameter not selected from Intr Oscillator Config tab
28.  
29.    // TODO: USER CODE!!
30.    
31.    OUTPUT_HIGH(PIN_B3);
32.    
33.    printf("\n\r PIC ESCLAVO 1: ");
34.    printf("\n\r     recibiendo.... ");
35.    while(true){
36.    
37.    }
38.  
39. }

Código: C++

1. /*******************************************************
2. * s1.h: libreia de cabeceras
3. *
4. ********************************************************/
5. #include <18F2550.h>
6. #device adc=8
7.  
8. #FUSES NOWDT                    //No Watch Dog Timer
9. #FUSES WDT128                   //Watch Dog Timer uses 1:128 Postscale
10. #FUSES XT                       //Crystal osc <= 4mhz for PCM/PCH , 3mhz to 10 mhz for PCD
11. #FUSES NOPROTECT                //Code not protected from reading
12. #FUSES NOBROWNOUT               //No brownout reset
13. #FUSES BORV20                   //Brownout reset at 2.0V
14. #FUSES NOPUT                    //No Power Up Timer
15. #FUSES NOCPD                    //No EE protection
16. #FUSES STVREN                   //Stack full/underflow will cause reset
17. #FUSES NODEBUG                  //No Debug mode for ICD
18. #FUSES NOLVP                    //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
19. #FUSES NOWRT                    //Program memory not write protected
20. #FUSES NOWRTD                   //Data EEPROM not write protected
21. #FUSES IESO                     //Internal External Switch Over mode enabled
22. #FUSES FCMEN                    //Fail-safe clock monitor enabled
23. #FUSES NOPBADEN                 //PORTB pins are configured as digital I/O on RESET
24. #FUSES NOWRTC                   //configuration not registers write protected
25. #FUSES NOWRTB                   //Boot block not write protected
26. #FUSES NOEBTR                   //Memory not protected from table reads
27. #FUSES NOEBTRB                  //Boot block not protected from table reads
28. #FUSES NOCPB                    //No Boot Block code protection
29. #FUSES MCLR                     //Master Clear pin enabled
30. #FUSES LPT1OSC                  //Timer1 configured for low-power operation
31. #FUSES NOXINST                  //Extended set extension and Indexed Addressing mode disabled (Legacy mode)
32. #FUSES PLL12                    //Divide By 12(48MHz oscillator input)
33. #FUSES CPUDIV4                  //System Clock by 4
34. #FUSES USBDIV                   //USB clock source comes from PLL divide by 2
35. #FUSES VREGEN                   //USB voltage regulator enabled
36.  
37. #use delay(clock=20000000)
38. #use rs232(baud=9600,parity=N,xmit=PIN_C6,rcv=PIN_C7,bits=8)
39. #use i2c(Slave,Slow,sda=PIN_B0,scl=PIN_B1,address=0xA2)
40.  
41. #use fast_io(B)
42. #include "milib.c"

Código: C++

1. /*******************************************************
2. * milib.c: libreia de mis funciones
3. *
4. ********************************************************/
5. //direcciones de dispositivos
6.  
7. #Define M1 0xA0 //Master
8. #Define S1 0xA2 //Esclavo 1
9. #Define S2 0xA4 //Esclavo 2
10. #Define S3 0xA6 //Esclavo 3
11.  
12.  
13. // --- escribir en dispositivo ---
14.  
15. void escribir_i2c(int8 direccion, int8 dato)
16. {
17.    i2c_start();
18.    i2c_write(direccion);
19.    //i2c_write(0);//add
20.    i2c_write(dato);
21.    i2c_stop();
22.    delay_us(150);
23. }
24.  
25.  
26. // --- leer del dispositivo ---
27. int8 leer_i2c(int8 direccion)
28. {
29.    int8 dato = 0;
30.    i2c_start();
31.    i2c_write(direccion); //direccion device
32.    //i2c_write(0); //add
33.      
34.    i2c_start();
35.    i2c_write(direccion+1);
36.    //dato = i2c_read();
37.    dato = i2c_read(0);//add
38.    i2c_stop();
39.    
40.    return(dato);
41. }
42. // -- funcion interrupcion ---
43.  
44. void ssp_interrupt(void){
45.    int8 state, buffer[];
46.    int8 i2c_dato_entrada,i2c_dato_funcion;
47.  
48.    state = i2c_isr_state();
49.    if(state >= 0x80){                    //master pide un dato
50.       i2c_write(buffer[i2c_dato_entrada]);          
51.    }
52.    else if(state == 0x01){               //Master esta enviando datos
53.       i2c_dato_entrada = i2c_read();
54.       buffer[i2c_dato_funcion] = i2c_dato_entrada;
55.    }
56.  
57. }

======================

Código: C++

1. /*******************************************************
2. * s2.c: libreia principal
3. *
4. ********************************************************/
5. #include "s2.h"
6. //#int_SSP
7. //void ssp_interrupt(void);
8.  
9.  
10.  
11. void main()
12. {
13.  
14.    setup_adc_ports(NO_ANALOGS|VSS_VDD);
15.    setup_adc(ADC_CLOCK_DIV_2);
16.    setup_wdt(WDT_OFF);
17.    setup_timer_0(RTCC_INTERNAL);
18.    setup_timer_1(T1_DISABLED);
19.    setup_timer_2(T2_DISABLED,0,1);
20.    setup_timer_3(T3_DISABLED|T3_DIV_BY_1);
21.    setup_comparator(NC_NC_NC_NC);
22.    //setup_vref(FALSE);
23.    
24.    //enable_interrupts(INT_SSP);// las deshabilito porque lee cosas raras
25.    //enable_interrupts(GLOBAL); // las deshabilito porque lee cosas raras
26. //Setup_Oscillator parameter not selected from Intr Oscillator Config tab
27.  
28.    // TODO: USER CODE!!
29.    printf("\n\r PIC ESCLAVO 2: ");
30.    printf("\n\r     recibiendo.... ");
31.    
32.    int8 state,leo,dato;
33.    
34.    //OUTPUT_HIGH(PIN_B3);
35.    
36.    //while (true) {
37.        
38.     delay_us(10);
39.    state = i2c_isr_state(); //lee el estado del bus
40.    if(state <0x80 || state >=0x80){
41.    //leo=i2c_read();
42.    dato=i2c_read(0);
43.    printf("\n\r leo: %X  state: %X  dato: %X "leo,state,dato);
44.    }
45.    //delay_ms(1000);
46.    //state = i2c_isr_state(); //lee el estado del bus
47.    //leo=i2c_read();
48.    //printf("\n\r leo: %X  state: %X  "leo,state);
49.    
50.   // }//fin while
51.  
52. }

Código: C++

1. /*******************************************************
2. * s2.h: libreia de cabeceras
3. *
4. ********************************************************/
5. #include <18F2550.h>
6. #device adc=8
7.  
8. #FUSES NOWDT                    //No Watch Dog Timer
9. #FUSES WDT128                   //Watch Dog Timer uses 1:128 Postscale
10. #FUSES HS                       //High speed Osc (> 4mhz for PCM/PCH) (>10mhz for PCD)
11. #FUSES NOPROTECT                //Code not protected from reading
12. #FUSES NOBROWNOUT               //No brownout reset
13. #FUSES BORV20                   //Brownout reset at 2.0V
14. #FUSES NOPUT                    //No Power Up Timer
15. #FUSES NOCPD                    //No EE protection
16. #FUSES STVREN                   //Stack full/underflow will cause reset
17. #FUSES NODEBUG                  //No Debug mode for ICD
18. #FUSES NOLVP                    //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
19. #FUSES NOWRT                    //Program memory not write protected
20. #FUSES NOWRTD                   //Data EEPROM not write protected
21. #FUSES IESO                     //Internal External Switch Over mode enabled
22. #FUSES FCMEN                    //Fail-safe clock monitor enabled
23. #FUSES NOPBADEN                 //PORTB pins are configured as digital I/O on RESET
24. #FUSES NOWRTC                   //configuration not registers write protected
25. #FUSES NOWRTB                   //Boot block not write protected
26. #FUSES NOEBTR                   //Memory not protected from table reads
27. #FUSES NOEBTRB                  //Boot block not protected from table reads
28. #FUSES NOCPB                    //No Boot Block code protection
29. #FUSES MCLR                     //Master Clear pin enabled
30. #FUSES LPT1OSC                  //Timer1 configured for low-power operation
31. #FUSES NOXINST                  //Extended set extension and Indexed Addressing mode disabled (Legacy mode)
32. #FUSES PLL12                    //Divide By 12(48MHz oscillator input)
33. #FUSES CPUDIV4                  //System Clock by 4
34. #FUSES USBDIV                   //USB clock source comes from PLL divide by 2
35. #FUSES VREGEN                   //USB voltage regulator enabled
36.  
37. #use delay(clock=20000000)
38. #use rs232(baud=9600,parity=N,xmit=PIN_C6,rcv=PIN_C7,bits=8)
39. #use i2c(Slave,Slow,sda=PIN_B0,scl=PIN_B1,address=0xA4)
40.  
41. #use fast_io(B)
42. #include "milib.c"

=================

Código: C++

1. /*******************************************************
2. * milib.c: libreia de mis funciones
3. *
4. ********************************************************/
5. //direcciones de dispositivos
6.  
7. #Define M1 0xA0 //Master
8. #Define S1 0xA2 //Esclavo 1
9. #Define S2 0xA4 //Esclavo 2
10. #Define S3 0xA6 //Esclavo 3
11.  
12.  
13. // --- escribir en dispositivo ---
14.  
15. void escribir_i2c(int8 direccion, int8 dato)
16. {
17.    i2c_start();
18.    i2c_write(direccion);
19.    i2c_write(dato);
20.    i2c_stop();
21.    delay_us(50);
22. }
23.  
24.  
25. // --- leer del dispositivo ---
26. int8 leer_i2c(int8 direccion)
27. {
28.    int8 dato = 0;
29.    i2c_start();
30.    i2c_write(direccion); //direccion device
31.    //i2c_write(0); //add
32.      
33.    i2c_start();
34.    i2c_write(direccion+1);
35.    //dato = i2c_read();
36.    dato = i2c_read(0);//add
37.    i2c_stop();
38.    
39.    return(dato);
40. }
41. // -- funcion interrupcion ---
42.  
43. void ssp_interrupt(void){
44.    int8 state, buffer[];
45.    int8 i2c_dato_entrada,i2c_dato_funcion;
46.    
47.    printf("\n\r interrupcion");
48.    state = i2c_isr_state();
49.    if(state >= 0x80){                    //master pide un dato
50.       i2c_write(buffer[i2c_dato_entrada]);          
51.    }
52.    else if(state == 0x01){               //Master esta enviando datos
53.       i2c_dato_entrada = i2c_read();
54.       buffer[i2c_dato_funcion] = i2c_dato_entrada;
55.    }
56.  
57. }

con fichero de proteus de pos anteriores se puede simular es el mismo
pero si quieren les dejo el fichero de nuevo su version es 7.2 sp6.

Título: Re: :: PIC18F250 nunca entra en #INT_SSP ::
Publicado por: MGLSOFT en 19 de Junio de 2012, 10:35:42

Creo que el nudo lo has creado tu mismo, queriendo hacer todo en librerias externas.
Prueba a hacer un solo programa para cada PIC, porque esta muy enredado y me parece que tienes que poner el codigo de interrupcion directamente dentro de la rutina, porque no soporta declaracion de funciones en la interrupcion.

Título: Re: :: PIC18F250 nunca entra en #INT_SSP ::
Publicado por: pajaro en 19 de Junio de 2012, 11:23:23

Cita de: MGLSOFT en 19 de Junio de 2012, 10:35:42

Creo que el nudo lo has creado tu mismo, queriendo hacer todo en librerias externas.
Prueba a hacer un solo programa para cada PIC, porque esta muy enredado y me parece que tienes que poner el codigo de interrupcion directamente dentro de la rutina, porque no soporta declaracion de funciones en la interrupcion.

Hola
eso de integrar todo en uno ya lo intente la vez anterior,
 de poner la interrupcion dentro del  main y el comportamiento era el mismo.

tiene que haber otra forma ..¿ has programado algo en i2c,... que codigo usaste?

un saludo.

Título: Re: :: PIC18F250 nunca entra en #INT_SSP ::
Publicado por: MGLSOFT en 19 de Junio de 2012, 11:51:54

La verdad es que mi experiencia con el I2C no es de las mas gandes, solo use un IC de reloj y unas memorias, y nunca lo use con interrupciones, asi que no creo ser el mejor para decirte si asi como las usas esta bien o mal, pero en mi opinion deberias arrancar con un solo esclavo y un maestro, sin interrupciones y luego ir creciendo despacio, hasta que le tomes la mano bien al tema.

Título: Re: :: PIC18F250 nunca entra en #INT_SSP ::
Publicado por: Suky en 19 de Junio de 2012, 12:05:52

No es recomendable colocar printf dentro de una interrupción, mejor utiliza leds si quieres saber si ingreso a ella. Yo en un proyecto con 16F como esclavo la interrupción por SSP  es idéntica a la que posteas.

Saludos!

Título: Re: :: PIC18F250 nunca entra en #INT_SSP ::
Publicado por: AngelGris en 19 de Junio de 2012, 12:28:02

  Viendo las dificultades de este post, hice lo propio pero con el compilador HiTech y pude comprobar que sí entra en la interrupción.
  Ahora bien, sucede algo que creo no es lo correcto, lo detallo... Cuando mandaba la dirección del esclavo1, entraba en la interrupción del mismo y por supuesto respondía con ACK. De manera inmediata le enviaba un dato, pero ahora ingresaba en la interrupción de los dos esclavos y me da la sensación que es el segundo esclavo el que está respondiendo con ACK lo cual estaría mal.

Título: Re: :: PIC18F250 nunca entra en #INT_SSP ::
Publicado por: pajaro en 19 de Junio de 2012, 14:26:31

Cita de: MGLSOFT en 19 de Junio de 2012, 11:51:54

La verdad es que mi experiencia con el I2C no es de las mas gandes, solo use un IC de reloj y unas memorias, y nunca lo use con interrupciones, asi que no creo ser el mejor para decirte si asi como las usas esta bien o mal, pero en mi opinion deberias arrancar con un solo esclavo y un maestro, sin interrupciones y luego ir creciendo despacio, hasta que le tomes la mano bien al tema.

Hola AngelGris

yo anteriormente use i2c para el ds1307 y para expasores pcf8574x
pero nunca antes me puse acomunicar entre ambos pic usando i2c.

El problemilla de la interrupcion INT_SSP me esta dando mucho quebraderos de cabeza.


Hola Suky 
tomare nota de lo de los led en vez de printf.


Seguiremos insistiendo

Un Saludo.

Título: Re: :: PIC18F250 nunca entra en #INT_SSP ::
Publicado por: AngelGris en 19 de Junio de 2012, 20:20:11

  Creo que descubrí el error en mi código. Aparentemente se me está activando el bit SSPOV (overflow) que indica que llegó un nuevo dato pero seguía estando lleno el SSPBUF (registro que almacena la información que llega). El SSPBUF se llena cuando coincide el address y también cuando llega un dato.
  Aparentemente es el programa que hagamos quien se tiene que encargar de procesar dicha información y darle utilidad o desecharla.
  Imagino que tendré que leer el registro SSPBUF para limpiarlo y así no se genere el overflow para poder procesar correctamente la información.

  Voy a investigar un poco el tema, y cuando logre algo te subo el código en HiTech, para que veas como va.

Título: Re: :: PIC18F250 nunca entra en #INT_SSP ::
Publicado por: AngelGris en 19 de Junio de 2012, 21:59:56

  Hasta ahora logré, con los códigos que siguen, que trabajen bien ambos esclavos, pero creo que la rutina de interrupción para el uso del dato podría ser mejorada... Seguiré haciendo pruebas.
  Más allá de posibles errores o mejoras en la rutina, los esclavos trabajan bien y en ambos casos lo hacen a partir de la interrupción SSP.

  Los códigos están simulados con proteus para pic 16F876A a 10 MHz. La frecuencia de I2C es de 100 KHz.

Código maestro

Código: C

1. #include <htc.h>
2.  
3. __CONFIG (HS & WDTDIS & LVPDIS);
4.  
5. #define PIC_CLK     10000000
6. #define _XTAL_FREQ 10000000
7. #define I2C_BAUD    100000
8.  
9. #include "HardI2c.c"
10.  
11. void main(void)
12. {
13.  
14.   setup_i2c(I2C_MASTER);
15.   __delay_ms(250);
16.   __delay_ms(250);
17.   __delay_ms(250);
18.   __delay_ms(250);
19.  
20.  
21.   start_i2c();
22.   write_i2c(0x1E);  // direccion esclavo 1, escritura
23.   write_i2c(0xAB);  // dato para esclavo 1
24.   stop_i2c();
25.  
26.   __delay_ms(5);
27.   start_i2c();
28.   write_i2c(0x1F);  // direccion esclavo 1, lectura
29.   read_i2c(1);      // leo el dato y no respondo
30.   stop_i2c();
31.  
32.   __delay_ms(5);
33.   start_i2c();
34.   write_i2c(0xFE);  // direccion esclavo 2, escritura
35.   write_i2c(0x99);  // dato para esclavo 2
36.   stop_i2c();
37.  
38.   __delay_ms(5);
39.   start_i2c();
40.   write_i2c(0x1E);  // direccion esclavo 1, escritura
41.   write_i2c(0xCC);  // dato para esclavo 1
42.   stop_i2c();
43.  
44.   __delay_ms(5);
45.   start_i2c();
46.   write_i2c(0xFF);  // direccion esclavo 2, lectura
47.   read_i2c(1);      // leo el dato y no respondo
48.   stop_i2c();
49.  
50.   while(1);
51. }

Código esclavo 1

Código: C

1. #include <htc.h>
2.  
3. __CONFIG (HS & WDTDIS & LVPDIS);
4.  
5. #define __XTAL_FREQ 10000000
6. #define PIC_CLK     10000000
7. #define I2C_BAUD    100000
8.  
9. #include "HardI2c.c"
10.  
11. char lectura;
12.  
13. void interrupt ISR(void)
14. {
15.   if (SSPIF == 1)  // interrupcion por SSP
16.   {    
17.     if (SSPOV == 1) // si hay overflow leo el buffer y borro dicho flag
18.     {
19.       lectura = read_i2c(1);
20.       SSPOV = 0;
21.     }
22.     else             // si no hay overflow proceso el dato
23.     {
24.       if (BF == 1)  // si hay dato
25.       {
26.         if (RW == 0)  // esclavo para escritura
27.         {    
28.           lectura = read_i2c(0);
29.           if (DA == 1) PORTB = lectura; // si llego un dato, lo mando al puerto
30.         }      
31.       }
32.       if (RW == 1) write_i2c(0x77); // esclavo para lectura
33.     }
34.     SSPIF = 0;  
35.   }
36. }
37.  
38. void main(void)
39. {
40.   char nada;
41.  
42.   TRISB = 0;              // Puerto B como salida
43.   PORTB = 0;              // Puerto B todo en 0
44.   SSPADD = 0x1E;          // Direccion del esclavo 1
45.   setup_i2c (I2C_SLAVE);  // Configuro como esclavo
46.   CKP = 1;
47.   nada = SSPBUF;          // Limpio el Buffer
48.   SSPOV = 0;              // Limpio el flag de overflow
49.   SSPIE = 1;              // Habilito interrupcion por SSP
50.   PEIE = 1;               // Habilito interrupcion de perifericos
51.   GIE = 1;                // Habilito las interrupciones globales
52.   while(1)
53.   {
54.   }
55. }

Código esclavo 2

Código: C

1. #include <htc.h>
2.  
3. __CONFIG (HS & WDTDIS & LVPDIS);
4.  
5. #define _XTAL_FREQ 10000000
6. #define PIC_CLK    10000000
7. #define I2C_BAUD   100000
8.  
9. #include "HardI2c.c"
10.  
11. void interrupt isr(void)
12. {
13.   char dato;
14.  
15.   if (SSPIF == 1)  // interrupcion SSP
16.   {
17.     if (SSPOV == 1)  // si hay overflow leo el buffer y borro dicho flag
18.     {
19.       dato = read_i2c(1);
20.       SSPOV = 0;
21.     }
22.     else  // si no hay overflow proceso el dato
23.     {
24.       if (BF == 1) // si esta lleno el buffer
25.       {
26.         if (RW == 0)
27.         {
28.           dato = read_i2c(1); // leo el buffer
29.           if (DA == 1)  // si es un dato lo mando al puerto B
30.           {
31.             PORTB = dato;
32.           }
33.         }        
34.       }
35.       if (RW == 1) write_i2c(0x11);
36.     }
37.     SSPIF = 0;  // borro el flag de interrupcion
38.   }
39. }
40.  
41. void main(void)
42. {
43.   char nada;
44.  
45.   TRISB = 0;              // Puerto B como salida
46.   PORTB = 0;              // Puerto B todo en 0
47.   SSPADD = 0xFE;          // Direccion del esclavo
48.   setup_i2c(I2C_SLAVE);   // configuro como esclavo
49.   SSPIE = 1;              // Habilito la interrupcion de SSP
50.   PEIE = 1;               // Habilito las interrupciones de perifericos
51.   GIE = 1;                // Habilito las interrupciones globales
52.  
53.   while(1);
54.  
55. }

Título: Re: :: PIC18F250 nunca entra en #INT_SSP ::
Publicado por: pajaro en 22 de Junio de 2012, 09:25:33

Cita de: AngelGris en 19 de Junio de 2012, 12:28:02

 Viendo las dificultades de este post, hice lo propio pero con el compilador HiTech y pude comprobar que sí entra en la interrupción.
  Ahora bien, sucede algo que creo no es lo correcto, lo detallo... Cuando mandaba la dirección del esclavo1, entraba en la interrupción del mismo y por supuesto respondía con ACK. De manera inmediata le enviaba un dato, pero ahora ingresaba en la interrupción de los dos esclavos y me da la sensación que es el segundo esclavo el que está respondiendo con ACK lo cual estaría mal.

Hola AngelGris

En el codigo que yo puse , el master envia un dato a un esclavo
y el esclavo 1 que es el correspondinete debia de responder
pero no lo hace.

en caso contrario como el esclavo 2 tiene un bucle while y deberia de hacer algo cuando hay
eventos en el bus ya que se forzo con un bucle a la lectura perpetua.

con el esclavo 2 veo que es la direcion A2 que envio el master y que segun el retardo
me visualiza el bit 00+ o el 80+ pero no el dato.

Por ello meti al esclavo 2 en un while para que me rastreara todos los eventos del bus

con eso veo todos los eventos del bus,pero el esclavo 1 no se entera.

con esto se me plantea una nueva duda !!!

si el master indica con quien se quiere comunicar.
¿Quien es el que detecta la direcion o discrimina la direcion,..es el propio esclavo?

La funcion de ccs tiene errores..!

AngelGris como configuraste tu el master y el eclavo1 y el esclavo 2?

ambos actuan mediante interrupcion en tu codigo?

Creo que si.., me puedes confirmar..

Sigo analizando tu codigo...

Título: Re: :: PIC18F250 nunca entra en #INT_SSP ::
Publicado por: MGLSOFT en 22 de Junio de 2012, 14:57:52

Citar

si el master indica con quien se quiere comunicar.
¿Quien es el que detecta la direcion o discrimina la direcion,..es el propio esclavo?

Si fuera el bus SPI, que tiene un pin de ChipSelect o CS, que obliga al esclavo a atender, diria que no, porque el direccionamiento es por hardware.
En el caso del I2C, el maestro envia la direccion del esclavo que debe responder a los comandos (lectura o escritura) y el esclavo (en realidad todos los esclavos que estan en el bus) comparan esa direccion con la suya propia, y responde el que corresponde a esa direccion solamente.

Una cosa que nunca revisamos de tu codigo es eso, que direccion tienen tus esclavos y cuales son las que consulta el maestro !!

Título: Re: :: PIC18F250 nunca entra en #INT_SSP ::
Publicado por: pajaro en 22 de Junio de 2012, 16:22:13

Cita de: MGLSOFT en 22 de Junio de 2012, 14:57:52

Citar

si el master indica con quien se quiere comunicar.
¿Quien es el que detecta la direcion o discrimina la direcion,..es el propio esclavo?

Si fuera el bus SPI, que tiene un pin de ChipSelect o CS, que obliga al esclavo a atender, diria que no, porque el direccionamiento es por hardware.
En el caso del I2C, el maestro envia la direccion del esclavo que debe responder a los comandos (lectura o escritura) y el esclavo (en realidad todos los esclavos que estan en el bus) comparan esa direccion con la suya propia, y responde el que corresponde a esa direccion solamente.

Una cosa que nunca revisamos de tu codigo es eso, que direccion tienen tus esclavos y cuales son las que consulta el maestro !!

Hola
esa info esta en la libreria milib.c

en esta defini las funciones de escritura y de lectura del i2c y justo en su cabecera las direciones para los dispositivos
del esclavo o esclavos y la del master.

Pero si es asi como dices y creo que dices bien, ya que es lo razonable..
¿por que s2 ve el dato del bus si no va para el,
solo deberia de ver la direcion no el dato.



ahora que nombras el spi.. el cs o selecionador de chip, cada esclavo tiene 4 cables y el master otros tantos, pero como selecionan el esclavo .. un cable para cada esclavo ¿ eso es un derroche en pines?

porcierto ..mirando el code del amigo veo que lee con un 1 no con un 0 como recomiendan muchos post por ahi.
cual es la explicacion

i2c_read(1);

¿Hay alguna diferencia entre leer con 1 o leer con 0 ?¿o entre no poner nada?

AngelGris tengo una curiosidad con respectoa tu code, es por software o por hardware?

estoy intentado comparar el tuyo con el mio..

SSPIF == 1)  // interrupcion SSP

equivale a la funcion:

 i2c_isr_state(); o i2c_poll()

yo no uso i2c_poll() ya que no  fuerzo a hardware el i2c



en mi code seleciona el B0 y B1 que son pines de hardware pero en el code no fuerzo ni hardware , ni software

sigo analizando tu codigo....

Título: Re: :: PIC18F250 nunca entra en #INT_SSP ::
Publicado por: AngelGris en 22 de Junio de 2012, 16:41:12

  Yo lo hago por HardWare.
  Los dos esclavos responden por interrupción.

  "if (SSP == 1)" lo uso para testear si se activó la interrupción del SSP.
  En HiTech no se hace una función por cada interrupción, sino que hay una sola función y dentro de la misma se testea cual es la que se activó.

  Leer con 1 o con 0, "i2c_read(1)" o "i2c_read(0)" dependerá de como sea la comunicación con el esclavo. Con algunos dispositivos, si se quiere leer sólo un byte hay que responder con NOACK y luego el bit de STOP. Por lo tanto la lectura deberá realizarse con "i2c_read(1)".
  Si quieres leer 2 bytes seguidos (dentro de un mismo ciclo de START-STOP, o trama) la primer lectura indefectiblemente la tienes que hacer con "i2c_read(0)" para indicarle al dispositivo que recibiste el byte y éste te mande el siguiente byte.


  ¿Por qué no fuerzas en tu configuración a que utilice hardware? Tal vez sea la única forma que tome las interrupciones del módulo SSP.

Título: Re: :: PIC18F250 nunca entra en #INT_SSP ::
Publicado por: pajaro en 22 de Junio de 2012, 17:54:15

Hola AngelGris

La idea es muchos PIC tienen i2c y otros no tienen,
y los que tienen solo tienen un canal, asi que por eso lo intento sin forzar hardware
 aunque los pines  del i2c son los pines fisico.

Por el momento desconozco si tendra alguna diferencia entre forzar harware,
forzar software o no poner la sentencia que especifica ese estado,
 por el contrario no se si al no especificar nada al compilador este le pondra una por defecto y tal caso
cual tomara o que caso le aplicara.
 se de leer por ahi que por hardware es el hardware el que configura retardos y tiempos
miestras por software lo tienes que hacer tu de esas maneras.

Tambien desconozco si se pone en el master, o en el esclavo o se pone en ambos,
(no lo confirme o contraste con otras fuentes) tambien deconozco si se puede
combinar dispositivos forzados en harware y dispositivos forzados en sofware
dentro del mismo bus.

La logica me dice que se deberia de poder hacer esto a nivel independiente de dispositivo no de bus,
me gustaria poder probarlo pero con esto de la interrupcion me tiene aqui bien cogido.

¿Tu probaste por ambos metodos.. ¿ te dejaria?

¿que es eso de la interrupcion de dispositivo?

sigo con el codigo..


Segun el manual de ccs si no pones nada lo toma como si fuese por software,
y recuedo que con el asistente de proyectos te genera los pines i2c virtuales
en diferentes a los fisicos.

sigo con el codigo..

Título: Re: :: PIC18F250 nunca entra en #INT_SSP ::
Publicado por: AngelGris en 22 de Junio de 2012, 19:36:42

Cita de: pajaro en 22 de Junio de 2012, 17:54:15

Hola AngelGris

La idea es muchos PIC tienen i2c y otros no tienen,
y los que tienen solo tienen un canal, asi que por eso lo intento sin forzar hardware
 aunque los pines  del i2c son los pines fisico.

Por el momento desconozco si tendra alguna diferencia entre forzar harware,
forzar software o no poner la sentencia que especifica ese estado,
 por el contrario no se si al no especificar nada al compilador este le pondra una por defecto y tal caso
cual tomara o que caso le aplicara.
 se de leer por ahi que por hardware es el hardware el que configura retardos y tiempos
miestras por software lo tienes que hacer tu de esas maneras.

Tambien desconozco si se pone en el master, o en el esclavo o se pone en ambos,
(no lo confirme o contraste con otras fuentes) tambien deconozco si se puede
combinar dispositivos forzados en harware y dispositivos forzados en sofware
dentro del mismo bus.

La logica me dice que se deberia de poder hacer esto a nivel independiente de dispositivo no de bus,
me gustaria poder probarlo pero con esto de la interrupcion me tiene aqui bien cogido.

  Se pueden mezclar PICs que tengas I2C por SoftWare y otros con HardWare y otros dispositivos como memorias sin ningún problema. Yo comuniqué un 16F876A utilizando I2C por HardWare con un 16F628A utilizando I2C por SoftWare.


¿Tu probaste por ambos metodos.. ¿ te dejaria?

Cita de: pajaro en 22 de Junio de 2012, 17:54:15

¿que es eso de la interrupcion de dispositivo?

  ¿A que te referís con ello?

Título: Re: :: PIC18F250 nunca entra en #INT_SSP ::
Publicado por: pajaro en 22 de Junio de 2012, 21:06:55

Hola

En el codigo de esclavo 1

Código: C++

1. ...
2. nada = SSPBUF;          // Limpio el Buffer
3.  SSPOV = 0;              // Limpio el flag de overflow
4.  SSPIE = 1;              // Habilito interrupcion por SSP
5.  PEIE = 1;               // Habilito interrupcion de perifericos
6.  GIE = 1;                // Habilito las interrupciones globales
7. ..

Me referia  a lo de interrupcion de periferico

te pregunto porque intento comprender el codigo de tu compilador
para ver si consigo que funcione en el mio que es con ccs..

***Ya probe lo de forzar hardware,
no funciona estamos en las mismas..

¿Que version de proteus usas?
¿Que retardos usas para la inicializacion?

 hace un rato lei algo  de un enlace y por lo visto el INT_SSP a mas de uno
le dio dolores de cabeza..

encontre unos enlaces:

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

http://www.ucontrol.com.ar/forosmf/problemas-con-mis-proyectos/problema-con-pic16f877a-y-pic16f876a-como-esclavos-i2c/?PHPSESSID=lo7u704ntfc07udqs8p0fivpp7


en estos codigos encontre una similitud con el tuyo ambos usais el BF y otras variables
de donde las has obtenido, porque las declaras con esos nombres tan especiales..
en ccs estaran declarados u las tendre que declar para usarlas..



Continuo con el code..

Título: Re: :: PIC18F250 nunca entra en #INT_SSP ::
Publicado por: AngelGris en 23 de Junio de 2012, 01:23:01

Cita de: pajaro en 22 de Junio de 2012, 21:06:55

Hola

En el codigo de esclavo 1


...
nada = SSPBUF;          // Limpio el Buffer
 SSPOV = 0;              // Limpio el flag de overflow
 SSPIE = 1;              // Habilito interrupcion por SSP
 PEIE = 1;               // Habilito interrupcion de perifericos
 GIE = 1;                // Habilito las interrupciones globales
..


Me referia  a lo de interrupcion de periferico

  PEIE es el bit que habilita las interrupciones de los periféricos en general (ADC, SSP, UART). Dicho bit tiene que estar en 1 si o si para que funcionen dichas interrupciones. Pero además hay que habilitar la interrupción particular que se quiera utilizar. Y, por supuesto, habilitarlas globalmente.

  Todo lo mencionado anteriormente está explicado en el datasheet del PIC.

Cita de: pajaro en 22 de Junio de 2012, 21:06:55

te pregunto porque intento comprender el codigo de tu compilador
para ver si consigo que funcione en el mio que es con ccs..

***Ya probe lo de forzar hardware,
no funciona estamos en las mismas..

¿Que version de proteus usas?
¿Que retardos usas para la inicializacion?

 hace un rato lei algo  de un enlace y por lo visto el INT_SSP a mas de uno
le dio dolores de cabeza..

encontre unos enlaces:

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

http://www.ucontrol.com.ar/forosmf/problemas-con-mis-proyectos/problema-con-pic16f877a-y-pic16f876a-como-esclavos-i2c/?PHPSESSID=lo7u704ntfc07udqs8p0fivpp7


en estos codigos encontre una similitud con el tuyo ambos usais el BF y otras variables
de donde las has obtenido, porque las declaras con esos nombres tan especiales..
en ccs estaran declarados u las tendre que declar para usarlas..



Continuo con el code..

  La versión de Proteus es la 7.8 SP2
  En el único código que puse retardos es en el del master, y es sólo para asegurarme de que los esclavos estén bien configurados antes que el master empiece a mandar información. Puse cuatro delays de 250ms cada uno así que hay 1 segundo aproximadamente antes de querer comunicarme con algún esclavo.

  BF y las otras variables son algunos bits de los registros que forman parte del módulo SSP. Dicha información la encontrarás en el datasheet del PIC

Título: Re: :: PIC18F250 nunca entra en #INT_SSP ::
Publicado por: pajaro en 23 de Junio de 2012, 13:38:01

Hola AngelGris

en tu codigo del esclavo,
vi que asignas el dato recibido a una variable
y esa variable la asignas a un puerto,
con ello ¿equivaldria a enceder y apagar los bit de un puerto?

Código: C++

1. ....
2. else             // si no hay overflow proceso el dato
3.    {
4.      if (BF == 1)  // si hay dato
5.      {
6.        if (RW == 0)  // esclavo para escritura
7.        {    
8.          lectura = read_i2c(0);
9.          if (DA == 1) PORTB = lectura; // si llego un dato, lo mando al puerto
10.        }      
11.      }
12.      if (RW == 1) write_i2c(0x77); // esclavo para lectura
13.    }
14.    SSPIF = 0;  
15. ....

ahora me surgen 4 preguntas...
 ¿ese dato lo puedes asignar a cualquier "cosa" (variable)?

- igual que lo asignas un puerto lo podrias asignar al comando de definicion del puerto (TRISB)
me esplico:
 en principio lo declaras como entradas y mediante ese dato lo redeclaras como salida o al reves.

- otra cosa en tu ejemplo cuando escribes en el esclavo le pasas la direccion del esclavo y el dato.
en algunas otras funciones que consulte por ahi le pasan una direcion donde escribir. ¿exite diferencia?


- si le pasaramos la direcion del esclavo ,la direccion del puertox , y el dato ¿esto funcionaria ..verdad?


sigo con el codigo...
a mi no me funciona ni con retardos despues de la escritura...
malico me toy poniendo

 :?

Título: Re: :: PIC18F250 nunca entra en #INT_SSP ::
Publicado por: AngelGris en 23 de Junio de 2012, 16:06:44

Cita de: pajaro en 23 de Junio de 2012, 13:38:01

Hola AngelGris

en tu codigo del esclavo,
vi que asignas el dato recibido a una variable
y esa variable la asignas a un puerto,
con ello ¿equivaldria a enceder y apagar los bit de un puerto?

  Exacto!!!
  Creo recordar que para setear el valor de un puerto completamente en CCS hay algo parecido a setport_b() o algo así.

Cita de: pajaro en 23 de Junio de 2012, 13:38:01

....
else             // si no hay overflow proceso el dato
   {
     if (BF == 1)  // si hay dato
     {
       if (RW == 0)  // esclavo para escritura
       {    
         lectura = read_i2c(0);
         if (DA == 1) PORTB = lectura; // si llego un dato, lo mando al puerto
       }      
     }
     if (RW == 1) write_i2c(0x77); // esclavo para lectura
   }
   SSPIF = 0;  
....



ahora me surgen 4 preguntas...
 ¿ese dato lo puedes asignar a cualquier "cosa" (variable)?

- igual que lo asignas un puerto lo podrias asignar al comando de definicion del puerto (TRISB)
me esplico:
 en principio lo declaras como entradas y mediante ese dato lo redeclaras como salia o al reves.

  Sí, se lo puede asignar a cualquier cosa. Ten en cuenta que, asignarlo a una variable, a un puerto o a cualquier registro (a excepción, obviamente, de los que son solo de lectura), sería lo mismo. En definitiva, lo que se está haciendo es copiar el dato en tal o cual dirección.

Cita de: pajaro en 23 de Junio de 2012, 13:38:01

- otra cosa en tu ejemplo cuando escribes le pasas la direccion del esclavo y el dato.
en algunas otras funciones le pasan una direcion donde escribir


- si le pasaramos la direcion del esclavo ,la direccion del puertox , y el dato funcionaria verdad?


sigo con el codigo...

  Imagino que sí funcionaría, sería cuestión de ver como implementar el código pero debería funcionar.

Título: Re: :: PIC18F250 nunca entra en #INT_SSP ::
Publicado por: pajaro en 23 de Junio de 2012, 18:17:25

Hola

despues de probar de mil y una con lo de los retardos y no funcionar de nada
a pesar de que en el post dice que le funciona:

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

voy a intentar implementar las variables para controlar lo del llenado del esclavo

como hace este enlace :

http://www.ucontrol.com.ar/forosmf/problemas-con-mis-proyectos/problema-con-pic16f877a-y-pic16f876a-como-esclavos-i2c/?PHPSESSID=lo7u704ntfc07udqs8p0fivpp7

y el amigo AngelGris.


Angelgris cuando usas BF , RW

lo declaras de alguna forma ?

en el fichero de cabecera lo deberas de tener definido en alguna direcion?

por eso no lo declaras en el programa..!

¿Estoy en lo cierto?

Título: Re: :: PIC18F250 nunca entra en #INT_SSP ::
Publicado por: AngelGris en 23 de Junio de 2012, 18:29:35

Cita de: pajaro en 23 de Junio de 2012, 18:17:25

Angelgris cuando usas BF , RW

lo declaras de alguna forma ?

en el fichero de cabecera lo deberas de tener definido en alguna direcion?

por eso no lo declaras en el programa..!

¿Estoy en lo cierto?

  Exactamente, HiTech tiene definido dichos bits en el archivo de cabecera.

  Desconozco si CCS los tiene definidos.
  Sé que CCS tiene la función bit_test, así que podrías hacer uso de ella y testear los bits correspondientes a BF y RW.. Para ello vas a necesitar el datasheet a mano para saber a qué registros pertenecen y qué bits son.

Título: Re: :: PIC18F250 nunca entra en #INT_SSP ::
Publicado por: pajaro en 23 de Junio de 2012, 20:46:32

Hola AngelGris

En mi ccs busque el fichero de cabecera
del PIC es un PIC18F2550 y tine definidas
dentro de su *.h muchas cosas pero no estab esos registros imagino
que tendre que impremetarlos yo.

He mirado el Data de este pic en su sección de MSSP y la verdad
no se por donde cogerlo.

He leido que tiene 6 registros:

SSPCON1:
SSPCON2:
SSPSTAT:

son para el control y registro de estado en i2c,

SSPBUF: registro del buffer
SSPBSR: registro de desplazamineto.
SSPADD:registro de direciones

leyendo mas por debajo entiendo lo que hace cada bit pero no
se por donde coger esto.

¿alguna idea de como se declara?
 viendo tu codigo y el de los enlaces que puse parece tan facil..
pero cuando estas delante del data del chip da miedo..

Título: Re: :: PIC18F250 nunca entra en #INT_SSP ::
Publicado por: AngelGris en 23 de Junio de 2012, 20:59:09

  Si mal no recuerdo en CCS podías declarar de la siguiente manera

Código: C

1. #byte SSPSTAT 0xFC7

  Siendo 0xFC7 la dirección del registro, esa información está en el datasheet

  Luego, en tu programa, podrías hacer algo así para testear el bit 0 que corresponde a BF

Código: C

1. bit_test(SSPSTAT,0)

  Creo que era así como se utilizaba la función bit_test

Título: Re: :: PIC18F250 nunca entra en #INT_SSP ::
Publicado por: pajaro en 23 de Junio de 2012, 22:11:13

Hola AngelGris

SSPSTAT:
bit 7-6 se pueden escribir (W), leer(R), limpiar(0)
bit 5-0 se puden solo leer(R),  limpiar(0)


bit 7:SMP
bit 6:CKE


bit 5:D/A
bit 4:P
bit 3:S
bit 2:R/W
bit 1:UA
bit 0:BF


//Configuracion de los registros
#BYTE SSPADD = ....0xFC8
#BYTE SSPCON1 = ....0xFC6
#BYTE SSPCON2 = ....0xFC5



AngelGris, ¿puedes pasarme el fichero de cabecera del pic18f250 y pic18F4550?
de tu compilador. donde define los pines..

seguire mañana ... :ni)  necesito descansar..

Título: Re: :: PIC18F250 nunca entra en #INT_SSP ::
Publicado por: AngelGris en 25 de Junio de 2012, 10:07:55

  Te dejo el archivo de encabezado...

Título: Re: :: PIC18F250 nunca entra en #INT_SSP ::
Publicado por: pajaro en 25 de Junio de 2012, 16:38:06

Cita de: AngelGris en 25 de Junio de 2012, 10:07:55

 Te dejo el archivo de encabezado...

Gracias por el fichero pero necesitaria el del pic18F2550
me equivoque y puse pic18F250, en realidad es pic18F2550  es sobre este ultimo sobre
quien implemento todo esto, ...

0xFxx

las direciones son en hexadecimal,
en el data mire los registros
#BYTE SSPADD = ....0xFC8
#BYTE SSPCON1 = ....0xFC6
#BYTE SSPCON2 = ....0xFC5

todos son de 8 bit, asi pues que significa la F
En CCS para Hexadecimal con 0xa5 ya se entiende que es hexadecimal
pero no entiendo lo de la F en otro ejemplo tambien aparece.

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


¿Tiene que ver con algo lo de la F cuando se define?

sigo investigando..

Título: Re: :: PIC18F250 nunca entra en #INT_SSP ::
Publicado por: AngelGris en 25 de Junio de 2012, 16:59:38

  El número indica la dirección que tiene el registro en el mapa de memoria del pic, no tiene nada que ver que un registro sea de 8 bits.

  Si tuviese un registro en última dirección de un mapa de 0xFFFF posiciones, la dirección de dicho registro sería 0xFFFE sin importar que el resto de los registros sea de 8 bits.

  No encuentro ningún archivo de cabecera para 18F250

Título: Re: :: PIC18F250 nunca entra en #INT_SSP ::
Publicado por: pajaro en 25 de Junio de 2012, 19:49:25

Cita de: AngelGris en 25 de Junio de 2012, 16:59:38

 El número indica la dirección que tiene el registro en el mapa de memoria del pic, no tiene nada que ver que un registro sea de 8 bits.

  Si tuviese un registro en última dirección de un mapa de 0xFFFF posiciones, la dirección de dicho registro sería 0xFFFE sin importar que el resto de los registros sea de 8 bits.

  No encuentro ningún archivo de cabecera para 18F250

Llevas razon compañero.
 Se corresponde con el mapeo de la memoria ahora en el data
al buscar la organizacion de la memoria, he dado con lo que buscaba,
en otros pic  al principio del data te muestra una tabla con las direciones de los puertos
y otras cosas, si... en este pic pic18F2550 se situa en la hoja 68 de 430 hay un apartado que dice:

SPECIAL FUNCTION REGISTER MAP FOR PIC18F2455/2550/4455/4550 DEVICES

hay se define las direciones del :

#BYTE SSPADD = 0xFC8
#BYTE SSPCON1 = 0xFC6
#BYTE SSPCON2 = 0xFC5
#BYTE SSPBUF = 0xFC9          //FC9h SSPBUF

como bien ponia en el enlace que pegue anteriormente.

con respecto ala libreria dentro de esta pone:

Código: C++

1. /* header file for the MICROCHIP PIC18 microcontrollers
2.   PIC18F2455
3.   PIC18F2550
4.   PIC18F4455
5.   PIC18F4550
6.   PIC18F2458
7.   PIC18F2553
8.   PIC18F4458
9.   PIC18F4553
10.  */

podria valer la misma libreria pero con algunos cambios imagino...
la idea era como tenia definicas las cosas.

cosas conseguidas:
- se de donde sale lo de los registros del control y su famoso numerito:
- se que valen para mi pic eas definiciones
- se que :


#BYTE SSPADD = 0xFC8
#BYTE SSPCON1 = 0xFC6
#BYTE SSPCON2 = 0xFC5
#BYTE SSPBUF = 0xFC9



coasas que me faltan:


me puedes confirma estas cosillas...?







cosas que dudo si se corresponderan:

- SSPIF == 1)  // interrupcion SSP


bit 3 del PIR1 y PIR1 es

PIR1: PERIPHERAL INTERRUPT REQUEST (FLAG) REGISTER 1

- SSPOV == 1)  // si hay overflow leo el buffer y borro dicho flag

bit 6 del registro del
SSPCON1: MSSP CONTROL REGISTER 1 (I2C™ MODE)

- BF == 1) // si esta lleno el buffer

BF

se corresponde con el bit 0 del registro
SSPSTAT: MSSP STATUS REGISTER (I2C™ MODE)

- RW == 0

rw :  RD or WR

de este no encontre nada ....  :(

 no ser que se coresponda con el bit 2 del
SSPSTAT: MSSP STATUS REGISTER



- DA == 1

da :    SPP data write

de este no encontre nada ....  :(

- SSPIF = 0;  // borro el flag de interrupcion

PIR1: PERIPHERAL INTERRUPT REQUEST (FLAG) REGISTER 1

el bit 3 de este registro es el SSPIF (segun data)

SSPIF: Master Synchronous Serial Port Interrupt Flag bit
1 = The transmission/reception is complete (must be cleared in software)
0 = Waiting to transmit/receive




- SSPIE = 1;              // Habilito interrupcion por SSP

enable_interrupts(INT_SSP);

- PEIE = 1;               // Habilito interrupcion de perifericos

enable_interrupts(....); // no se con cual se correspondera o su hara falta
lo mas parecido que encontre en le data es el regidstro de control de interrupciones
PIE1,PIE2 estas partenecen a una lista de 10 , las cuales se usan para el control de inerrupciones (pag 99)

pero mas abajo encontre el PEIE:

INTCON: INTERRUPT CONTROL REGISTER(pag_101):

PEIE es el bit 6 del INTCON

pero en el fichero de cabecera de mi pic donde estan definidas los tipos de interrupciones no aparece
o no la reconozco y aparece con otro nombre


- GIE = 1;                // Habilito las interrupciones globales

enable_interrupts(GLOBAL);


volvemos al codigo ...

Título: Re: :: PIC18F250 nunca entra en #INT_SSP ::
Publicado por: pajaro en 25 de Junio de 2012, 20:25:08

Cita de: AngelGris en 25 de Junio de 2012, 16:59:38

 El número indica la dirección que tiene el registro en el mapa de memoria del pic, no tiene nada que ver que un registro sea de 8 bits.

  Si tuviese un registro en última dirección de un mapa de 0xFFFF posiciones, la dirección de dicho registro sería 0xFFFE sin importar que el resto de los registros sea de 8 bits.

  No encuentro ningún archivo de cabecera para 18F250

Perdona,
 me equivoque en realidad es el pic18F2550, me comi un 5.

Gracias.

Título: Re: :: PIC18F250 nunca entra en #INT_SSP ::
Publicado por: AngelGris en 25 de Junio de 2012, 21:29:05

Cita de: pajaro en 25 de Junio de 2012, 19:49:25

............

coasas que me faltan:
me puedes confirma estas cosillas...?
cosas que dudo si se corresponderan:

- SSPIF == 1)  // interrupcion SSP


bit 3 del PIR1 y PIR1 es

PIR1: PERIPHERAL INTERRUPT REQUEST (FLAG) REGISTER 1

- SSPOV == 1)  // si hay overflow leo el buffer y borro dicho flag

bit 6 del registro del
SSPCON1: MSSP CONTROL REGISTER 1 (I2C™ MODE)

- BF == 1) // si esta lleno el buffer

BF

se corresponde con el bit 0 del registro
SSPSTAT: MSSP STATUS REGISTER (I2C™ MODE)

  Exacto!

Cita de: pajaro en 25 de Junio de 2012, 19:49:25

- RW == 0

rw :  RD or WR

de este no encontre nada ....  :(

 no ser que se coresponda con el bit 2 del
SSPSTAT: MSSP STATUS REGISTER


- DA == 1

da :    SPP data write

de este no encontre nada ....  :(

  RW corresponde al bit 2 del registro SSPSTAT
  DA corresponde al bit 5 del registro SSPSTAT

Cita de: pajaro en 25 de Junio de 2012, 19:49:25

- SSPIF = 0;  // borro el flag de interrupcion

PIR1: PERIPHERAL INTERRUPT REQUEST (FLAG) REGISTER 1

el bit 3 de este registro es el SSPIF (segun data)

SSPIF: Master Synchronous Serial Port Interrupt Flag bit
1 = The transmission/reception is complete (must be cleared in software)
0 = Waiting to transmit/receive




- SSPIE = 1;              // Habilito interrupcion por SSP

enable_interrupts(INT_SSP);

- PEIE = 1;               // Habilito interrupcion de perifericos

enable_interrupts(....); // no se con cual se correspondera o su hara falta
lo mas parecido que encontre en le data es el regidstro de control de interrupciones
PIE1,PIE2 estas partenecen a una lista de 10 , las cuales se usan para el control de inerrupciones (pag 99)

pero mas abajo encontre el PEIE:

INTCON: INTERRUPT CONTROL REGISTER(pag_101):

PEIE es el bit 6 del INTCON

pero en el fichero de cabecera de mi pic donde estan definidas los tipos de interrupciones no aparece
o no la reconozco y aparece con otro nombre


- GIE = 1;                // Habilito las interrupciones globales

enable_interrupts(GLOBAL);


volvemos al codigo ...

  Tal vez en CCS se active automáticamente el bit PEIE, al habilitar las interrupciones globales.

Título: Re: :: PIC18F250 nunca entra en #INT_SSP ::
Publicado por: pajaro en 28 de Junio de 2012, 05:22:41

Hola AngelGris
con el proteus hay forma de ver esos registros,
para verifocar eso que dices,
por si solo no los muestra imagino que si los declaro dentro del programa los mostrara
como si se tratase de una variable mas..

sigo con el problema...

en ningun mumento cambiam los valores:

yo declare asi:
#BYTE SSPADD = 0xFC8
#BYTE SSPCON1 = 0xFC6
#BYTE SSPCON2 = 0xFC5
#BYTE SSPBUF = 0xFC9

al arrancar el proteus muestra: su valor en 0xFF

y en ningun momento cambian esos valores

pero investigando mas en el watch windows de proteus en la pestaña debug
 encontre la forma de anadir registros y
te deja añadir por nombre de variable

ahora necesitaria saber que registros son los que cambian
para saber que esta trabajando bien, y poder fijarme en ellos.


sigo investigando....

creo que esta haciendo cosas raras
analizo ,  sistetizo y cuento

...

Título: Re: :: PIC18F250 nunca entra en #INT_SSP ::
Publicado por: AngelGris en 28 de Junio de 2012, 09:16:22

  Efectivamente la forma de visualizar los registros es utilizando el watch window.

  Corrobora que la forma en que estás utilizando la sentencia "#byte" sea la correcta. Como no utilizo CCS no sé si lleva el "=" o no.

Título: Re: :: PIC18F250 nunca entra en #INT_SSP ::
Publicado por: pajaro en 28 de Junio de 2012, 13:46:01

Cita de: AngelGris en 28 de Junio de 2012, 09:16:22

 Efectivamente la forma de visualizar los registros es utilizando el watch window.

  Corrobora que la forma en que estás utilizando la sentencia "#byte" sea la correcta. Como no utilizo CCS no sé si lleva el "=" o no.

Hola AngelGris

es correcto como lo defino:
En el manual de referencia lo dice asi:

Citar

#BYTE id = x

Elements:
id is a valid C identifier, x is a C variable or a constant

Purpose:
If the id is already known as a C variable then this will locate the variable at address x. In this case the variable type does not change from the original definition. If the id is not known a new C variable is created and placed at address x with the type int (8 bit)

Warning:
In both cases memory at x is not exclusive to this variable. Other variables may be located at the same location. In fact when x is a variable, then id and x share the same memory location.

seguire indagando..

Título: Re: :: PIC18F250 nunca entra en #INT_SSP ::
Publicado por: pajaro en 28 de Junio de 2012, 19:25:19

hola
pase casi todo tu codigo a ccs cuasitodo..

AngelGris espero que no te importe
pero pienso que si a ti te funciona a mi tambien  me deberia.... esto solo en teoria
cuando lo ponga en practica lo podre afirmar.

Tengo dos preguntas:

en el codigo del esclavo declaras algo
que no comprendo:

Código: C++

1. ...
2. ..
3.         lectura=i2c_read(0);
4.          //if (DA == 1)
5.          if(bit_test (SSPSTAT, 5))
6.           {
7.              PORTB = lectura;  // si llego un dato, lo mando al puerto
8.           }  
9.        }      
10.      }
11.      //if (RW == 1)
12.      if(bit_test (SSPSTAT, 2))
13.       {
14.          //write_i2c(0x77); // esclavo para lectura
15.          i2c_write(0x77); // esclavo para lectura
16.       }
17.    }
18.  
19. ...

PORTB = lectura;  // si llego un dato, lo mando al puerto

esto que es un configura puerto
set_tris_b(lectura);

u  es otra cosa..

... me huelo que es otra cosa...



- Segunda pregunta?

write_i2c(0x77); // esclavo para lectura

esta direcion no coincide con la ningun esclavo ...

si miramos en las funciones del master no hay ninguna direcion llamada 0x77
de donde sale esto..

sigo con el codigo...

Título: Re: :: PIC18F250 nunca entra en #INT_SSP ::
Publicado por: AngelGris en 28 de Junio de 2012, 20:07:20

  En respuesta a la primer pregunta, PORTB = lectura es para que salga por el puerto B el dato que me llego vía I2C. Simplemente es para corroborar que llegó bien el dato.

  En cuanto a la segunda pregunta... i2c_write(0x77).... me refiero a que llega a ésa línea cuando el esclavo es accedido para lectura (es decir que el master quiere leer un dato desde el esclavo) y 0x77 es el dato que el esclavo le envía al master.

Título: Re: :: PIC18F250 nunca entra en #INT_SSP ::
Publicado por: pajaro en 29 de Junio de 2012, 03:57:39

Cita de: AngelGris en 28 de Junio de 2012, 20:07:20

 En respuesta a la primer pregunta, PORTB = lectura es para que salga por el puerto B el dato que me llego vía I2C. Simplemente es para corroborar que llegó bien el dato.

  En cuanto a la segunda pregunta... i2c_write(0x77).... me refiero a que llega a ésa línea cuando el esclavo es accedido para lectura (es decir que el master quiere leer un dato desde el esclavo) y 0x77 es el dato que el esclavo le envía al master.

Hola AngelGris
pregunta 1:
¿entonces seria como encender los led del puerto b con el dato que llegue?

en caso de ser asi seria como set_tris_b(lectura);

continuo con el codigo..

Título: Re: :: PIC18F250 nunca entra en #INT_SSP ::
Publicado por: pajaro en 29 de Junio de 2012, 05:54:59

Hola

DESEPERACION es la palabra  ...  :5]

pongo el codigo del master

Código: C++

1. /***************************************************
2. *
3. * master_ag_1.c
4. *
5. ***************************************************/
6. #include "Master_ag.h"
7.  
8.  
9.  
10. void main()
11. {
12.  
13.    setup_adc_ports(NO_ANALOGS|VSS_VDD);
14.    setup_adc(ADC_CLOCK_DIV_2);
15.    setup_wdt(WDT_OFF);
16.    setup_timer_0(RTCC_INTERNAL);
17.    setup_timer_1(T1_DISABLED);
18.    setup_timer_2(T2_DISABLED,0,1);
19.    setup_timer_3(T3_DISABLED|T3_DIV_BY_1);
20.    setup_comparator(NC_NC_NC_NC);
21.    setup_vref(FALSE);
22.    
23.    enable_interrupts(INT_SSP);
24.    enable_interrupts(GLOBAL);
25. //Setup_Oscillator parameter not selected from Intr Oscillator Config tab
26.  
27.    // TODO: USER CODE!!
28. int8 midato;
29.  
30. printf("\n\r MASTER: ");
31.  delay_ms(1000);
32.  
33.  printf("\n\r escribo en esclavo");
34.  
35.  i2c_master_escribe(s1,5);
36.  
37.   printf("\n\r fin de escritura");
38.  
39.  
40.  printf("\n\r leo de esclavo");
41.  
42.  midato=i2c_master_lee(S1);
43.  
44.  printf("\r\n %d"midato);
45.  
46.  
47. }

cabecera:

Código: C++

1. /***************************************************
2. *
3. * master_ag_1.h
4. *
5. ***************************************************/
6. #include <18F2550.h>
7.  
8. #device adc=8
9.  
10. #FUSES NOWDT                    //No Watch Dog Timer
11. #FUSES WDT128                   //Watch Dog Timer uses 1:128 Postscale
12. #FUSES HS                       //High speed Osc (> 4mhz for PCM/PCH) (>10mhz for PCD)
13. #FUSES NOPROTECT                //Code not protected from reading
14. #FUSES NOBROWNOUT               //No brownout reset
15. #FUSES BORV20                   //Brownout reset at 2.0V
16. #FUSES NOPUT                    //No Power Up Timer
17. #FUSES NOCPD                    //No EE protection
18. #FUSES STVREN                   //Stack full/underflow will cause reset
19. #FUSES NODEBUG                  //No Debug mode for ICD
20. #FUSES NOLVP                    //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
21. #FUSES NOWRT                    //Program memory not write protected
22. #FUSES NOWRTD                   //Data EEPROM not write protected
23. #FUSES IESO                     //Internal External Switch Over mode enabled
24. #FUSES FCMEN                    //Fail-safe clock monitor enabled
25. #FUSES NOPBADEN                 //PORTB pins are configured as digital I/O on RESET
26. #FUSES NOWRTC                   //configuration not registers write protected
27. #FUSES NOWRTB                   //Boot block not write protected
28. #FUSES NOEBTR                   //Memory not protected from table reads
29. #FUSES NOEBTRB                  //Boot block not protected from table reads
30. #FUSES NOCPB                    //No Boot Block code protection
31. #FUSES MCLR                     //Master Clear pin enabled
32. #FUSES LPT1OSC                  //Timer1 configured for low-power operation
33. #FUSES NOXINST                  //Extended set extension and Indexed Addressing mode disabled (Legacy mode)
34. #FUSES PLL12                    //Divide By 12(48MHz oscillator input)
35. #FUSES CPUDIV4                  //System Clock by 4
36. #FUSES USBDIV                   //USB clock source comes from PLL divide by 2
37. #FUSES VREGEN                   //USB voltage regulator enabled
38.  
39. #use delay(clock=20000000)
40. #use rs232(baud=9600,parity=N,xmit=PIN_C6,rcv=PIN_C7,bits=8)
41. #use i2c(Master,Slow,sda=PIN_B0,scl=PIN_B1,force_hw)
42. //#include "milib.c"
43.  
44. #DEFINE MODO_LECTURA 00000001
45. #DEFINE MODO_ESCRITURA 00000000
46. #DEFINE S1 0xB0
47.  
48.  
49. void i2c_master_escribe(int8 direccion,int8 dato){
50.    i2c_start();            // Comienzo comunicación
51.    i2c_write(direccion);   // Dirección del esclavo en el bus I2C modo rw
52.    //i2c_write(posicion);    // Posición donde se guardara el dato transmitido
53.    i2c_write(dato);        // Dato a transmitir
54.    i2c_stop();             // Fin comunicación
55.    delay_ms(1000);
56.  }
57.  
58.  
59.  
60. int8 i2c_master_lee(int8 direccion){
61. int8 dato_leido;
62.    i2c_start();            // Comienzo de la comunicación
63.    i2c_write(direccion);   // Dirección del esclavo en el bus I2C modo RW
64.    //i2c_write(posicion);    // Posición de donde se leerá el dato en el esclavo
65.    i2c_start();            // Reinicio
66.    i2c_write(direccion +1); // Dirección del esclavo en modo lectura (modo r)
67.    dato_leido=i2c_read(1); // Lectura del dato
68.    i2c_stop();             // Fin comunicación
69.    delay_ms(50);
70. return dato_leido;
71. }

pongo el codigo del esclavo

Código: C++

1. /***************************************************
2. *
3. * esclavo_ag_1.c
4. *
5. ***************************************************/
6.  
7. #include "esclavo_ag_1.h"
8. char lectura;
9. #int_SSP
10. void  SSP_isr(void)
11. {
12.  
13. //if (SSPIF == 1)  // interrupcion por SSP
14. if(bit_test (PIR1, 3))
15.  {    
16.    //if (SSPOV == 1) // si hay overflow leo el buffer y borro dicho flag
17.    if(bit_test (SSPCON1, 6)) // return 0 o 1
18.    {
19.      //lectura = read_i2c(1);
20.      lectura=i2c_read(1);
21.      //SSPOV = 0;
22.      bit_clear(SSPCON1,6); //limpio bit 6 del SSPCON1
23.    }
24.    else             // si no hay overflow proceso el dato
25.    {
26.      //if (BF == 1)  // si hay dato
27.      if(bit_test (SSPSTAT, 0))
28.      {
29.        //if (RW == 0)  // esclavo para escritura
30.        if(bit_test (SSPSTAT, 2)==0)
31.        {    
32.          //lectura = read_i2c(0);
33.          lectura=i2c_read(0);
34.          //if (DA == 1)
35.          if(bit_test (SSPSTAT, 5))
36.           {
37.              PORTB = lectura;  // si llego un dato, lo mando al puerto
38.              printf("\n\n lectura: %d"lectura);
39.           }  
40.        }      
41.      }
42.      //if (RW == 1)
43.      if(bit_test (SSPSTAT, 2))
44.       {
45.          //write_i2c(0x77); // esclavo para lectura
46.          i2c_write(0x77); // esclavo para lectura
47.          output_High(PIN_B3);// anado para vericar entro
48.       }
49.    }
50.    //SSPIF = 0;
51.    bit_clear(PIR1, 3);
52.  }
53. }
54.  
55.  
56.  
57. void main()
58. {
59.  
60.    setup_adc_ports(NO_ANALOGS|VSS_VDD);
61.    setup_adc(ADC_CLOCK_DIV_2);
62.    setup_wdt(WDT_OFF);
63.    setup_timer_0(RTCC_INTERNAL);
64.    setup_timer_1(T1_DISABLED);
65.    setup_timer_2(T2_DISABLED,0,1);
66.    setup_timer_3(T3_DISABLED|T3_DIV_BY_1);
67.    setup_comparator(NC_NC_NC_NC);
68.    setup_vref(FALSE);
69.    set_tris_b(0x00);
70.    
71.    
72.    enable_interrupts(INT_SSP);
73.    enable_interrupts(GLOBAL);
74. //Setup_Oscillator parameter not selected from Intr Oscillator Config tab
75.  
76.    // TODO: USER CODE!!
77.  
78. printf("\n\r ESCLAVO: ");
79.  
80. }

Código: C++

1. /***************************************************
2. *
3. * esclavo_ag_1.h
4. *
5. ***************************************************/
6.  
7. #include <18F2550.h>
8. #device adc=8
9.  
10. #FUSES NOWDT                    //No Watch Dog Timer
11. #FUSES WDT128                   //Watch Dog Timer uses 1:128 Postscale
12. #FUSES HS                       //High speed Osc (> 4mhz for PCM/PCH) (>10mhz for PCD)
13. #FUSES NOPROTECT                //Code not protected from reading
14. #FUSES NOBROWNOUT               //No brownout reset
15. #FUSES BORV20                   //Brownout reset at 2.0V
16. #FUSES NOPUT                    //No Power Up Timer
17. #FUSES NOCPD                    //No EE protection
18. #FUSES STVREN                   //Stack full/underflow will cause reset
19. #FUSES NODEBUG                  //No Debug mode for ICD
20. #FUSES NOLVP                    //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
21. #FUSES NOWRT                    //Program memory not write protected
22. #FUSES NOWRTD                   //Data EEPROM not write protected
23. #FUSES IESO                     //Internal External Switch Over mode enabled
24. #FUSES FCMEN                    //Fail-safe clock monitor enabled
25. #FUSES NOPBADEN                 //PORTB pins are configured as digital I/O on RESET
26. #FUSES NOWRTC                   //configuration not registers write protected
27. #FUSES NOWRTB                   //Boot block not write protected
28. #FUSES NOEBTR                   //Memory not protected from table reads
29. #FUSES NOEBTRB                  //Boot block not protected from table reads
30. #FUSES NOCPB                    //No Boot Block code protection
31. #FUSES MCLR                     //Master Clear pin enabled
32. #FUSES LPT1OSC                  //Timer1 configured for low-power operation
33. #FUSES NOXINST                  //Extended set extension and Indexed Addressing mode disabled (Legacy mode)
34. #FUSES PLL12                    //Divide By 12(48MHz oscillator input)
35. #FUSES CPUDIV4                  //System Clock by 4
36. #FUSES USBDIV                   //USB clock source comes from PLL divide by 2
37. #FUSES VREGEN                   //USB voltage regulator enabled
38.  
39. #use delay(clock=20000000)
40. #define I2C_SDA   PIN_B0
41. #define I2C_SCL   PIN_B1
42. #define S1 0xB0
43.  
44. #use rs232(baud=9600,parity=N,xmit=PIN_C6,rcv=PIN_C7,bits=8)
45. #use i2c(Slave,Slow,sda=PIN_B0,scl=PIN_B1,force_hw,address=0xB0)
46.  
47. //#include "milib.c"
48.  
49. //Define pines
50. #BYTE SSPADD = 0xFC8
51. #BYTE SSPCON1 = 0xFC6
52. #BYTE SSPCON2 = 0xFC5
53. #BYTE SSPBUF = 0xFC9
54. #BYTE SSPSTAT = 0xFC7
55. #BYTE PIR1 = 0xF9E
56. #BYTE PORTB = 0xF81
57.  
58. void i2c_master_escribe(int8 direccion,int8 dato){
59.    i2c_start();            // Comienzo comunicación
60.    i2c_write(direccion);   // Dirección del esclavo en el bus I2C modo rw
61.    //i2c_write(posicion);    // Posición donde se guardara el dato transmitido
62.    i2c_write(dato);        // Dato a transmitir
63.    i2c_stop();             // Fin comunicación
64.    delay_ms(1000);
65.  }
66.  
67.  
68.  
69. int8 i2c_master_lee(int8 direccion){
70. int8 dato_leido;
71.    i2c_start();            // Comienzo de la comunicación
72.    i2c_write(direccion);   // Dirección del esclavo en el bus I2C modo RW
73.    //i2c_write(posicion);    // Posición de donde se leerá el dato en el esclavo
74.    i2c_start();            // Reinicio
75.    i2c_write(direccion+1); // Dirección del esclavo en modo lectura (modo r)
76.    dato_leido=i2c_read(1); // Lectura del dato
77.    i2c_stop();             // Fin comunicación
78.    delay_ms(50);
79. return dato_leido;
80. }

No funciona nada...

Título: Re: :: PIC18F250 nunca entra en #INT_SSP ::
Publicado por: MGLSOFT en 29 de Junio de 2012, 09:02:25

Me llama bastante la atencion como usas las instrucciones I2C, por eso refresque un poco lo que habia usado, mirando las librerias actuales de CCS, en este caso para una memoria.
Pongo el codigo que usan para escritura, mira bien como separan las instrucciones, y prueba hacerlo en tus programas a ver como te va...

Código: C++

1. int1 ext_eeprom_ready() {
2.    int1 ack;
3.    i2c_start();            // If the write command is acknowledged,
4.    ack = i2c_write(0xa0);  // then the device is ready.
5.    i2c_stop();
6.    return !ack;
7. }
8.  
9. void write_ext_eeprom(EEPROM_ADDRESS address, BYTE data) {
10.    while(!ext_eeprom_ready());
11.    i2c_start();
12.    i2c_write((0xa0|(BYTE)(address>>7))&0xfe);
13.    i2c_write(address);
14.    i2c_write(data);
15.    i2c_stop();
16. }

Título: Re: :: PIC18F250 nunca entra en #INT_SSP ::
Publicado por: pajaro en 29 de Junio de 2012, 10:36:21

Cita de: MGLSOFT en 29 de Junio de 2012, 09:02:25

Me llama bastante la atencion como usas las instrucciones I2C, por eso refresque un poco lo que habia usado, mirando las librerias actuales de CCS, en este caso para una memoria.
Pongo el codigo que usan para escritura, mira bien como separan las instrucciones, y prueba hacerlo en tus programas a ver como te va...

Código: C++

1. int1 ext_eeprom_ready() {
2.    int1 ack;
3.    i2c_start();            // If the write command is acknowledged,
4.    ack = i2c_write(0xa0);  // then the device is ready.
5.    i2c_stop();
6.    return !ack;
7. }
8.  
9. void write_ext_eeprom(EEPROM_ADDRESS address, BYTE data) {
10.    while(!ext_eeprom_ready());
11.    i2c_start();
12.    i2c_write((0xa0|(BYTE)(address>>7))&0xfe);
13.    i2c_write(address);
14.    i2c_write(data);
15.    i2c_stop();
16. }

Hola
 ojeando tu codigo vi INT1
si INT8 es byte supongo que int1 es un bit ... ¿es correcta mi suposicion?

0xa0 -> sera la direccion por lo tanto
esa funcion verifica si un dispositivo con esa direcion esta dispoinible
si es asi , esta disponoble responde con ack

¿ack es un 1 o un 0?

para la segunda funcion..

te reformatea a BYTE la address desde ...

aca la pregunta: ¿te desplaza todo 7 posiciones ?
¿te rota 7 veces?
intentas darle la vuelta a la direcion un algo

luego  le haces una or si son 0 y 0 son 0 sino 1
y luego la and si son 1 y 1 sera 1 si no cero

para que esa converison no le termino de ver..

¿Puedes contarme, ...?

Título: Re: :: PIC18F250 nunca entra en #INT_SSP ::
Publicado por: pajaro en 01 de Julio de 2012, 13:04:18

AngelGris

aun estoy aca tu ejemplo no paro de mirarlo
si ati te funciono como es posible que a mi
no me funcione.

tu lo hiciste con un pic distinto al mio, pero el codigo es clavado

Seria abusar de tu buena fe que probaras tu codigo en un pic18F2550
con el simulador de protesus.a ver si es el pic el que hace cosa raras.

De esa forma podria testear entre tu code y el mio, aun mas cerca.

ayer noche pense en implementar el code de otra forma en vez de usar
las funciones propias de ccs podia declarar a nivel de bit

#BIT BF=0xFC8.0

no se si funcionara
pero si para el manejo de los bit de un puerto funciona
deberia de hacerlo tambien aca.

No se si podras ayudarme, pero de todas formas te agradezco toda tu ayuda
que me has ofrecido con esta pesadilla...

sigo indagando...

Título: Re: :: PIC18F250 nunca entra en #INT_SSP ::
Publicado por: AngelGris en 01 de Julio de 2012, 14:19:10

  Hago los cambios necesarios, seguramente será sólo en lo que respecta a los bits de configuración y te comento.

  Tal vez en tu caso no entra en la interrupción porque no está utilizando el módulo SSP.... sino no le encuentro otra explicación... o tal vez la versión de Preoteus. Yo estoy utilizando la 7.8 SP2

Título: Re: :: PIC18F250 nunca entra en #INT_SSP ::
Publicado por: pajaro en 02 de Julio de 2012, 07:42:35

Cita de: AngelGris en 01 de Julio de 2012, 14:19:10

  Hago los cambios necesarios, seguramente será sólo en lo que respecta a los bits de configuración y te comento.

  Tal vez en tu caso no entra en la interrupción porque no está utilizando el módulo SSP.... sino no le encuentro otra explicación... o tal vez la versión de Preoteus. Yo estoy utilizando la 7.8 SP2

Hola AngelGris

La version de mi proteus con la que implemento o diseño es la 7.2 sp6 pero
dispongo de una portable mas avanzada 7.8 sp2 para pasar los diseños de versiones posteriores
a esta.

que esquema electrico usas tu.

te cuelgo el mio.

Sigo con el codigo

Título: Re: :: PIC18F250 nunca entra en #INT_SSP ::
Publicado por: AngelGris en 02 de Julio de 2012, 09:36:39

  Después de tener que cambiar de versión del compilador para PIC18 pude compilar bien el programa y lo pude simular constatando que sí responde bien el esclavo por interrupciones en el PIC18F2550.

  De dejo el circuito que estoy utilizando.

Título: Re: :: PIC18F250 nunca entra en #INT_SSP ::
Publicado por: pajaro en 02 de Julio de 2012, 11:28:15

Cita de: AngelGris en 02 de Julio de 2012, 09:36:39

 Después de tener que cambiar de versión del compilador para PIC18 pude compilar bien el programa y lo pude simular constatando que sí responde bien el esclavo por interrupciones en el PIC18F2550.

  De dejo el circuito que estoy utilizando.

El codigo usado es el mismo que publicaste
en la vez pasada?

¿y lo de cambiar del compilador a que se debe..?
El anterior no te dejaba...

ya modificando mi codigo tal como dije..

quedo como tu codigo...pero al simularlo
hace cosas raras..

si quito el esclavo de la simulacion en lo de propiedades excluir el master se mete en un bucle infinito
pero si lo pongo ..
enciende el led del esclavo


pongo el code:

Código: C++

1. /***************************************************
2. *
3. * master_ag_1.c
4. *
5. ***************************************************/
6. #include "Master_ag.h"
7.  
8.  
9.  
10. void main()
11. {
12.  
13.    setup_adc_ports(NO_ANALOGS|VSS_VDD);
14.    setup_adc(ADC_CLOCK_DIV_2);
15.    setup_wdt(WDT_OFF);
16.    setup_timer_0(RTCC_INTERNAL);
17.    setup_timer_1(T1_DISABLED);
18.    setup_timer_2(T2_DISABLED,0,1);
19.    setup_timer_3(T3_DISABLED|T3_DIV_BY_1);
20.    setup_comparator(NC_NC_NC_NC);
21.    setup_vref(FALSE);
22.    
23.    enable_interrupts(INT_SSP);
24.    enable_interrupts(GLOBAL);
25. //Setup_Oscillator parameter not selected from Intr Oscillator Config tab
26.  
27.    // TODO: USER CODE!!
28. int8 midato;
29.  
30. printf("\n\r MASTER: ");
31.  delay_ms(1000);
32.  
33.  printf("\n\r escribo en esclavo");
34.  
35.  i2c_master_escribe(s1,5);
36.  
37.   printf("\n\r fin de escritura");
38.  
39.  
40.  printf("\n\r leo de esclavo");
41.  
42.  midato=i2c_master_lee(S1);
43.  
44.  printf("\r\n %X : "midato);
45.  
46.  
47. }

cabcera:

Código: C++

1. /***************************************************
2. *
3. * master_ag_1.h
4. *
5. ***************************************************/
6. #include <18F2550.h>
7.  
8. #device adc=8
9.  
10. #FUSES NOWDT                    //No Watch Dog Timer
11. #FUSES WDT128                   //Watch Dog Timer uses 1:128 Postscale
12. #FUSES HS                       //High speed Osc (> 4mhz for PCM/PCH) (>10mhz for PCD)
13. #FUSES NOPROTECT                //Code not protected from reading
14. #FUSES NOBROWNOUT               //No brownout reset
15. #FUSES BORV20                   //Brownout reset at 2.0V
16. #FUSES NOPUT                    //No Power Up Timer
17. #FUSES NOCPD                    //No EE protection
18. #FUSES STVREN                   //Stack full/underflow will cause reset
19. #FUSES NODEBUG                  //No Debug mode for ICD
20. #FUSES NOLVP                    //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
21. #FUSES NOWRT                    //Program memory not write protected
22. #FUSES NOWRTD                   //Data EEPROM not write protected
23. #FUSES IESO                     //Internal External Switch Over mode enabled
24. #FUSES FCMEN                    //Fail-safe clock monitor enabled
25. #FUSES NOPBADEN                 //PORTB pins are configured as digital I/O on RESET
26. #FUSES NOWRTC                   //configuration not registers write protected
27. #FUSES NOWRTB                   //Boot block not write protected
28. #FUSES NOEBTR                   //Memory not protected from table reads
29. #FUSES NOEBTRB                  //Boot block not protected from table reads
30. #FUSES NOCPB                    //No Boot Block code protection
31. #FUSES MCLR                     //Master Clear pin enabled
32. #FUSES LPT1OSC                  //Timer1 configured for low-power operation
33. #FUSES NOXINST                  //Extended set extension and Indexed Addressing mode disabled (Legacy mode)
34. #FUSES PLL12                    //Divide By 12(48MHz oscillator input)
35. #FUSES CPUDIV4                  //System Clock by 4
36. #FUSES USBDIV                   //USB clock source comes from PLL divide by 2
37. #FUSES VREGEN                   //USB voltage regulator enabled
38.  
39. #use delay(clock=20000000)
40. #use rs232(baud=9600,parity=N,xmit=PIN_C6,rcv=PIN_C7,bits=8)
41. #use i2c(Master,Slow,sda=PIN_B0,scl=PIN_B1,force_hw)
42. //#include "milib.c"
43.  
44. #DEFINE MODO_LECTURA 00000001
45. #DEFINE MODO_ESCRITURA 00000000
46. #DEFINE S1 0xB0
47.  
48.  
49. void i2c_master_escribe(int8 direccion,int8 dato){
50.    i2c_start();            // Comienzo comunicación
51.    delay_us(100);
52.    i2c_write(direccion);   // Dirección del esclavo en el bus I2C modo rw
53.    delay_us(100);
54.    //i2c_write(posicion);    // Posición donde se guardara el dato transmitido
55.    i2c_write(dato);        // Dato a transmitir
56.    delay_us(100);
57.    i2c_stop();             // Fin comunicación
58.    delay_ms(1000);
59.  }
60.  
61.  
62.  
63. int8 i2c_master_lee(int8 direccion){
64. int8 dato_leido;
65.    i2c_start();            // Comienzo de la comunicación
66.    delay_us(100);
67.    i2c_write(direccion);   // Dirección del esclavo en el bus I2C modo RW
68.    delay_us(100);
69.    //i2c_write(posicion);    // Posición de donde se leerá el dato en el esclavo
70.    i2c_start();            // Reinicio
71.    delay_us(100);
72.    i2c_write(direccion+1); // Dirección del esclavo en modo lectura (modo r)
73.    delay_us(100);
74.    dato_leido=i2c_read(1); // Lectura del dato
75.    delay_us(100);
76.    i2c_stop();             // Fin comunicación
77.    delay_ms(50);
78. return dato_leido;
79. }

para el esclavo:

Código: C++

1. /***************************************************
2. *
3. * esclavo_ag_1.c
4. *
5. ***************************************************/
6.  
7. #include "esclavo_ag_1.h"
8.  
9. //define bit a bit
10.  
11. #BIT SSPIF = 0xF9E.3         //PIR1 bit 3
12. #BIT SSPOV = 0xFC6.6         //SSPCON1 bit 6
13. #BIT BF = 0xFC8.0            //SSPSTAT bit 0
14. #BIT RW = 0xFC7.2            //SSPSTAT bit 2
15. #BIT DA = 0xFC7.5            //SSPSTAT bit 5
16.  
17. char lectura;
18. #int_SSP
19. void  SSP_isr(void)
20. {
21.  
22. if (SSPIF == 1)  // interrupcion por SSP
23. //if(bit_test (PIR1, 3))
24.  {    
25.    if (SSPOV == 1) // si hay overflow leo el buffer y borro dicho flag
26.    //if(bit_test (SSPCON1, 6)) // return 0 o 1
27.    {
28.      //lectura = read_i2c(1);
29.      lectura=i2c_read(1);
30.      output_High(PIN_B6);// añado para vericar entro
31.      SSPOV = 0;
32.      //bit_clear(SSPCON1,6); //limpio bit 6 del SSPCON1
33.    }
34.    else             // si no hay overflow proceso el dato
35.    {
36.      if (BF == 1)  // si hay dato
37.      //if(bit_test (SSPSTAT, 0))
38.      {
39.        if (RW == 0)  // esclavo para escritura
40.        //if(bit_test (SSPSTAT, 2))
41.        {    
42.          //lectura = read_i2c(0);
43.          lectura=i2c_read(0);
44.          if (DA == 1)
45.          //if(bit_test (SSPSTAT, 5))
46.           {
47.              PORTB = lectura;  // si llego un dato, lo mando al puerto
48.              printf("\n\n lectura: %d"lectura);
49.           }  
50.        }      
51.      }
52.      if (RW == 1)
53.      //if(bit_test (SSPSTAT, 2))
54.       {
55.          //write_i2c(0x77); // esclavo para lectura
56.          i2c_write(0x77); // esclavo para lectura
57.          output_High(PIN_B7);// añado para vericar entro
58.       }
59.    }
60.    SSPIF = 0;
61.    //bit_clear(PIR1, 3);
62.  }
63. }
64.  
65.  
66.  
67. void main()
68. {
69.  
70.    setup_adc_ports(NO_ANALOGS|VSS_VDD);
71.    setup_adc(ADC_CLOCK_DIV_2);
72.    setup_wdt(WDT_OFF);
73.    setup_timer_0(RTCC_INTERNAL);
74.    setup_timer_1(T1_DISABLED);
75.    setup_timer_2(T2_DISABLED,0,1);
76.    setup_timer_3(T3_DISABLED|T3_DIV_BY_1);
77.    setup_comparator(NC_NC_NC_NC);
78.    setup_vref(FALSE);
79.    set_tris_b(0x00);
80.    
81.    
82.    enable_interrupts(INT_SSP);
83.    enable_interrupts(GLOBAL);
84. //Setup_Oscillator parameter not selected from Intr Oscillator Config tab
85.  
86.    // TODO: USER CODE!!
87.  
88. printf("\n\r ESCLAVO: ");
89.  
90. }

cabecera de esclavo:

Código: C++

1. /***************************************************
2. *
3. * esclavo_ag_1.h
4. *
5. ***************************************************/
6.  
7. #include <18F2550.h>
8. #device adc=8
9.  
10. #FUSES NOWDT                    //No Watch Dog Timer
11. #FUSES WDT128                   //Watch Dog Timer uses 1:128 Postscale
12. #FUSES HS                       //High speed Osc (> 4mhz for PCM/PCH) (>10mhz for PCD)
13. #FUSES NOPROTECT                //Code not protected from reading
14. #FUSES NOBROWNOUT               //No brownout reset
15. #FUSES BORV20                   //Brownout reset at 2.0V
16. #FUSES NOPUT                    //No Power Up Timer
17. #FUSES NOCPD                    //No EE protection
18. #FUSES STVREN                   //Stack full/underflow will cause reset
19. #FUSES NODEBUG                  //No Debug mode for ICD
20. #FUSES NOLVP                    //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
21. #FUSES NOWRT                    //Program memory not write protected
22. #FUSES NOWRTD                   //Data EEPROM not write protected
23. #FUSES IESO                     //Internal External Switch Over mode enabled
24. #FUSES FCMEN                    //Fail-safe clock monitor enabled
25. #FUSES NOPBADEN                 //PORTB pins are configured as digital I/O on RESET
26. #FUSES NOWRTC                   //configuration not registers write protected
27. #FUSES NOWRTB                   //Boot block not write protected
28. #FUSES NOEBTR                   //Memory not protected from table reads
29. #FUSES NOEBTRB                  //Boot block not protected from table reads
30. #FUSES NOCPB                    //No Boot Block code protection
31. #FUSES MCLR                     //Master Clear pin enabled
32. #FUSES LPT1OSC                  //Timer1 configured for low-power operation
33. #FUSES NOXINST                  //Extended set extension and Indexed Addressing mode disabled (Legacy mode)
34. #FUSES PLL12                    //Divide By 12(48MHz oscillator input)
35. #FUSES CPUDIV4                  //System Clock by 4
36. #FUSES USBDIV                   //USB clock source comes from PLL divide by 2
37. #FUSES VREGEN                   //USB voltage regulator enabled
38.  
39. #use delay(clock=20000000)
40. #define I2C_SDA   PIN_B0
41. #define I2C_SCL   PIN_B1
42. #define S1 0xB0
43.  
44. #use rs232(baud=9600,parity=N,xmit=PIN_C6,rcv=PIN_C7,bits=8)
45. #use i2c(Slave,Slow,sda=PIN_B0,scl=PIN_B1,force_hw,address=0xB0)
46.  
47. //#include "milib.c"
48.  
49. //Define pines
50. #BYTE SSPADD = 0xFC8
51. #BYTE SSPCON1 = 0xFC6
52. #BYTE SSPCON2 = 0xFC5
53. #BYTE SSPBUF = 0xFC9
54. #BYTE SSPSTAT = 0xFC7
55. #BYTE PIR1 = 0xF9E
56. #BYTE PORTB = 0xF81
57.  
58. //define bit a bit
59.  
60. #BIT SSPIF = 0xF9E.3         //PIR1 bit 3
61. #BIT SSPOV = 0xFC6.6         //SSPCON1 bit 6
62. #BIT BF = 0xFC8.0            //SSPSTAT bit 0
63. #BIT RW = 0xFC7.2            //SSPSTAT bit 2
64. #BIT DA = 0xFC7.5            //SSPSTAT bit 5
65.  
66.  
67.  
68. void i2c_master_escribe(int8 direccion,int8 dato){
69.    i2c_start();            // Comienzo comunicación
70.    i2c_write(direccion);   // Dirección del esclavo en el bus I2C modo rw
71.    //i2c_write(posicion);    // Posición donde se guardara el dato transmitido
72.    i2c_write(dato);        // Dato a transmitir
73.    i2c_stop();             // Fin comunicación
74.    delay_ms(1000);
75.  }
76.  
77.  
78.  
79. int8 i2c_master_lee(int8 direccion){
80. int8 dato_leido;
81.    i2c_start();            // Comienzo de la comunicación
82.    i2c_write(direccion);   // Dirección del esclavo en el bus I2C modo RW
83.    //i2c_write(posicion);    // Posición de donde se leerá el dato en el esclavo
84.    i2c_start();            // Reinicio
85.    i2c_write(direccion+1); // Dirección del esclavo en modo lectura (modo r)
86.    dato_leido=i2c_read(1); // Lectura del dato
87.    i2c_stop();             // Fin comunicación
88.    delay_ms(50);
89. return dato_leido;
90. }

voy a introducir led de forma que cuando escriba en el esclavo
en el master se encianda un led y en el master tambine se enciednda ese led
y cuando lea se apague ese led en el esclavo y se encida otro led y en el master haga lo mismo,

asi vere por donde va el programa...

sabes que le puede ocurrir..

te paso los cof. para que si eso lo simules y lo puedas ver como yo lo veo..


sigo con esto..

Título: Re: :: PIC18F250 nunca entra en #INT_SSP ::
Publicado por: AngelGris en 02 de Julio de 2012, 12:19:42

  Tuve que cambiar de versión de compilador porque la anterior (versión 9.65) me daba error interno cada vez que quería hacer algo con interrupciones. Ahora pasé a la 9.80.

  Sí, el código es el mismo que te mostré la vez pasada.

  No sé si soy yo o no está, pero no veo que termines tus programas con

Código: C

1. while(TRUE);

  en el caso de HiTech yo uso

Código: C

1. while(1);

  Eso hay que usarlo para que el contador de programa no siga avanzando hacia un posición que no se sabe que habrá.

Título: Re: :: PIC18F250 nunca entra en #INT_SSP ::
Publicado por: pajaro en 02 de Julio de 2012, 12:43:25

Hola

En ccs el while (1) da error algunas veces, yo lo que hago
es sustutuirlo por true
ya que en la libreria tiene sustituido true por 1 y false por 0.

no se si te entendi bien,
¿falta un bucle while por algun lado?,
o es el while del main?

En el master no hay instruccion de while(){..} ni de do{}while()
 y en el esclavo tampoco.

Título: Re: :: PIC18F250 nunca entra en #INT_SSP ::
Publicado por: AngelGris en 02 de Julio de 2012, 12:58:16

Cita de: pajaro en 02 de Julio de 2012, 12:43:25

Hola

En ccs el while (1) da error algunas veces, yo lo que hago
es sustutuirlo por true
ya que en la libreria tiene sustituido true por 1 y false por 0.

no se si te entendi bien,
¿falta un bucle while por algun lado?,
o es el while del main?

En el master no hay instruccion de while(){..} ni de do{}while()
 y en el esclavo tampoco.

  Justamente me refiero a eso que no hay tal instrucción.  Si un programa hace algo indefinidamente tiene que estar dentro de un ciclo while. Ahora, si sólo ejecutas algo por única vez -como en tu caso- luego de ello tenés que colocar un while(true) para que el programa se quede allí y no prosiga hacia un lugar incierto.

Código: C

1. void main(void)
2. {
3.   instruccion;
4.  ....
5. ....
6. ....
7.   instruccion;
8. ...
9. ....
10.  
11. // todo lo anterior sería el codigo que se va a ejecutar
12.  
13.   while(true);
14. }

Título: Re: :: PIC18F250 nunca entra en #INT_SSP ::
Publicado por: pajaro en 02 de Julio de 2012, 16:52:20

Hola

coloque un while(true){}

al final del main del esclavo y sigue igual
en el debug del i2c veo que solo muestra S.
el master se queda clavao en el escribir..



el code queda asi:

solo coloco la parte modificada:

Código: C++

1. /***************************************************
2. *
3. * esclavo_ag_1.c
4. *
5. ***************************************************/
6.  
7. #include "esclavo_ag_1.h"
8.  
9. //define bit a bit
10.  
11. #BIT SSPIF = 0xF9E.3         //PIR1 bit 3
12. #BIT SSPOV = 0xFC6.6         //SSPCON1 bit 6
13. #BIT BF = 0xFC8.0            //SSPSTAT bit 0
14. #BIT RW = 0xFC7.2            //SSPSTAT bit 2
15. #BIT DA = 0xFC7.5            //SSPSTAT bit 5
16.  
17. char lectura;
18. #int_SSP
19. void  SSP_isr(void)
20. {
21.  
22. if (SSPIF == 1)  // interrupcion por SSP
23. //if(bit_test (PIR1, 3))
24.  {    
25.    if (SSPOV == 1) // si hay overflow leo el buffer y borro dicho flag
26.    //if(bit_test (SSPCON1, 6)) // return 0 o 1
27.    {
28.      //lectura = read_i2c(1);
29.      lectura=i2c_read(1);
30.      output_High(PIN_B6);// añado para vericar entro
31.      SSPOV = 0;
32.      //bit_clear(SSPCON1,6); //limpio bit 6 del SSPCON1
33.    }
34.    else             // si no hay overflow proceso el dato
35.    {
36.      if (BF == 1)  // si hay dato
37.      //if(bit_test (SSPSTAT, 0))
38.      {
39.        if (RW == 0)  // esclavo para escritura
40.        //if(bit_test (SSPSTAT, 2))
41.        {    
42.          //lectura = read_i2c(0);
43.          lectura=i2c_read(0);
44.          if (DA == 1)
45.          //if(bit_test (SSPSTAT, 5))
46.           {
47.              PORTB = lectura;  // si llego un dato, lo mando al puerto
48.              printf("\n\n lectura: %d"lectura);
49.           }  
50.        }      
51.      }
52.      if (RW == 1)
53.      //if(bit_test (SSPSTAT, 2))
54.       {
55.          //write_i2c(0x77); // esclavo para lectura
56.          i2c_write(0x77); // esclavo para lectura
57.          output_High(PIN_B7);// añado para vericar entro
58.       }
59.    }
60.    SSPIF = 0;
61.    //bit_clear(PIR1, 3);
62.  }
63. }
64.  
65.  
66.  
67. void main()
68. {
69.  
70.    setup_adc_ports(NO_ANALOGS|VSS_VDD);
71.    setup_adc(ADC_CLOCK_DIV_2);
72.    setup_wdt(WDT_OFF);
73.    setup_timer_0(RTCC_INTERNAL);
74.    setup_timer_1(T1_DISABLED);
75.    setup_timer_2(T2_DISABLED,0,1);
76.    setup_timer_3(T3_DISABLED|T3_DIV_BY_1);
77.    setup_comparator(NC_NC_NC_NC);
78.    setup_vref(FALSE);
79.    set_tris_b(0x00);
80.    
81.    
82.    enable_interrupts(INT_SSP);
83.    enable_interrupts(GLOBAL);
84. //Setup_Oscillator parameter not selected from Intr Oscillator Config tab
85.  
86.    // TODO: USER CODE!!
87.  
88. printf("\n\r ESCLAVO: ");
89.  
90. while(true){
91. }
92.  
93. }

No se lo que le pasa al dichoso programa
pero esto es una pesadilla ....y de las peores

 :5]

Título: Re: :: PIC18F250 nunca entra en #INT_SSP ::
Publicado por: AngelGris en 02 de Julio de 2012, 18:48:34

  Elimina la instrucción de configuración del puerto "set_tris_b(0x00)" porque así lo estás configurando como salida y sin embargo para que trabaje el I2C el puerto debe quedar configurado como entrada. Desconozco si una vez configurado por el "#use i2c.." ya no puede ser cambiado por "set_tris..." pero por las dudas, eliminala.

Título: Re: :: PIC18F250 nunca entra en #INT_SSP ::
Publicado por: pajaro en 03 de Julio de 2012, 06:23:53

Hola AngelGris

Comente esa linea y sigue igual
en el esclavo hay algo que hace que cuelgue al master..
no se lo que es, pero lo bloquea de tal forma que solo le deja haceR un start
ya que en el debug del i2c solo aparece S.

si le quito el sclavo el esclavo no se enclava...

http://es.scribd.com/doc/47987479/MODO-I2C

http://es.scribd.com/doc/3023813/Curso-PIC16F87X-10