Mini curso "Programación en XC8"

[Picuino]

Gracias jukinch
Al final he puesto esto:

Código: [Seleccionar]

void isr(void) {
   // Rutina de atención a interrupciones
   ...

}

void interrupt high_isr(void) {
   #asm
   GOTO _isr
   #endasm
}

void interrupt low_priority low_isr(void) {
   #asm
   GOTO _isr
   #endasm
}

El programa no funciona todavía, pero el error ahora no parece estar en las interrupciones.

Saludos.

[Rseliman]

Hola a todos ....
estoy intentando compilar en xc8 esto



const rom unsigned char OSS_conversion_time[] = {5, 8, 14, 26};


o sea intento almacenar cadena en la rom



lo saque de un sub de xc18 ... me da el siguiente error

 ";" expected

 missing basic type; int assumed

Surround with ...

Porque no lo entiende el xc8 ?? alguien me da una mano por favor ?? Gracias
como hago lo mismo en xc8 ??Gracias


lo mismo me pasa aca



printf((const far rom char*) "%ld\r\n%ld\r\n%ld\r\n%ld\r\n%ld\r\n%ld\r\n%ld\r\n%ld\r\n%ld\r\n%ld\r\n%ld\r\n,",\
   ac1, ac2, ac3, ac4, ac5, ac6, b1, b2, mb, mc, md);

[AngelGris]

Prueba con definirla de esta manera

Código: C

1. const unsigned char OSS_conversion_time[]={5,8,14,26};

es decir, sin la palabra "rom"

[jukinch]

Interrupciones de alta y baja prioridad.

 En este programa vamos a utilizar las interrupciones externas del pic18F4550 en los pines RB0, RB1 y RB2
   configurando lso flancos de subida para INT0, INT1, e INT2.

  En el 4550 la INT0 es siempre de alta prioridad. No se puede setear como de baja prioridad
   Las INT1 e INT2 las configuramos en baja prioridad.

   Cada vez que se produzca una interrupción en INT0 cambiará el estado del pin RA0
   Cada vez que se produzca una interrupción en INT1 cambiará el estado del pin RA1
   Cada vez que se produzca una interrupción en INT2 cambiará el estado del pin RA2

        Saludos.
              Jukinch

Código: C

1. File:   main.c
2.    Author: JUKINCH
3.  
4.    Created on 31 de mayo de 2013, 14:49
5.  
6.    PRUEBA DE INTERRUPCIONES en baja y alta prioridad
7.    EN INT0 (RB0) INT1 (RB1) E INT2 (RB2)
8.  
9.  
10.    pic: 18f4550
11.    crystal: NO
12.    CPU: 8Mhz (valor establecido dentro de main cambiando los bits IRCF2, IRCF1 e IRCF0 del registro OSCCON)
13.         en RA6 sale la frecuencia de Fosc/4   ------->   8Mhz/4 = 2Mhz
14.  
15.    FUSES: los bits de configuración se establecen en el archivo "configuracion_de_fuses.c"
16.  
17.    CONEXIONES entrenadora FELIXLS:
18.     1 módulo conectado en IDC(RB0) en modo botón
19.     1 módulo conectado en IDC(RA0) en modo leds
20.     los cambios se pueden hacer en el archivo configuracion_hard.c
21.  
22.  */
23.  
24.  
25.  
26. /*Includes globales*/
27. #include <xc.h>
28. #include <delays.h> /* Para utilizar demoras en nuestro código*/
29.  
30. /*Includes locales*/
31. #include "configuracion_de_fuses.c"
32. #include "configuracion_hard.c"
33.  
34.  
35.  
36.  
37.  
38. volatile int myVolatileVariable=0;//variable para utilizar con las interrupciones
39.  
40.  
41. //******************************************************//
42. // Rutina de Interrupcion de Alta Prioridad
43. //******************************************************//
44. //
45.  
46. void interrupt interrupcionDeAlta(void)//prototipo de la interrupción de alta prioridad
47.         {
48.             if(INTCONbits.INT0IF)          //pregunta por bandera de interrupción en rb0
49.                     {
50.                     LED0 = ~LED0;          // invierto estado del led
51.                     myVolatileVariable++;
52.                     INTCONbits.INT0IF = 0; //limpia bandera y salimos
53.                     }
54.         }
55.  
56.  
57. //
58. //******************************************************//
59. // Rutina de Interrupcion de baja prioridad
60. //******************************************************//
61. //
62. void interrupt low_priority   interrupcionDeBaja(void)//prototipo de la interrupción de baja prioridad
63.         {
64.             if(INTCON3bits.INT1IF)       //pregunta por bandera de interrupción
65.                 {
66.                 LED1 = ~LED1;            // invierto estado del led
67.                 myVolatileVariable++;
68.                 INTCON3bits.INT1IF = 0;  //limpia bandera y salimos
69.                 }
70.  
71.  
72.             if(INTCON3bits.INT2IF)       //pregunta por bandera de interrupción
73.                 {
74.                 LED2 = ~LED2;            // invierto estado del led
75.                 myVolatileVariable++;
76.                 INTCON3bits.INT2IF = 0;  //limpia bandera y salimos
77.                 }
78.         }
79.  
80.  
81.  
82.  
83.  
84. //******************************************************//
85. // Programa Principal
86. //******************************************************//
87. void main(void)
88. {
89. ADCON0 = 0X00,ADCON1 = 0X0F,CMCON = 0X07; //puerto A con todos los pines digitales
90.  
91. PINLED0=0; // Configuración de pines como salida para los leds
92. PINLED1=0;
93. PINLED2=0;
94. PINBOTON0=1; // Configuración de pines como entrada para los botones
95. PINBOTON1=1;
96. PINBOTON2=1;
97.  
98. LATA = 0X00; // todo el puerto A a cero.
99.  
100.  
101. RCONbits.IPEN = 1; // Activa modo alta y baja prioridad
102. INTCONbits.GIEL = 1;// permitimos interrupciones de baja prioridad (Global Interrupt Enable Low)
103. INTCONbits.GIEH = 1;// permitimos interrupciones de alta prioridad (Global Interrupt Enable High)
104. INTCON2bits.INTEDG0 = 1;//configura interrupcion por flanco de subida para la interrupcion en RB0
105. INTCON2bits.INTEDG1 = 1;//configura interrupcion por flanco de subida para la interrupcion en RB1
106. INTCON2bits.INTEDG2 = 1;//configura interrupcion por flanco de subida para la interrupcion en RB2
107.  
108. INTCONbits.INT0IE=1; // activa la interrupción externa por flanco del pin RB0
109.                      // La Int0 es siempre de alta prioridad. No se puede setear como de baja prioridad
110.  
111. INTCON3bits.INT1IE=1; // activa la interrupción externa por flanco del pin RB1
112. INTCON3bits.INT1IP=0; // selecciona la interrupción de baja prioridad del pin RB1
113.  
114. INTCON3bits.INT2IE=1; // activa la interrupción externa por flanco del pin RB2
115. INTCON3bits.INT2IP=0; // selecciona la interrupción de baja prioridad del pin  RB2
116.  
117. //*******************************************************
118. //*******************************************************
119.  
120.  
121. while (1);
122.  
123.  
124.  
125. }
126. //*******************************************************
127. //*******************************************************

[Picuino]

A mi me han dado muchos problemas las interrupciones hasta que las he activado antes de finalizar la rutina de interrupción:

Código: C

1. void interrupt low_priority low_isr(void) {
2.    // Timer0 interrupt counter
3.    if (INTCONbits.TMR0IF == 1) {
4.       INTCONbits.TMR0IF = 0;
5.       timer0.dword++;
6.    }
7.  
8.    INTCONbits.GIEL = 1;    // Sin esta instrucción, las interrupciones se deshabilitan después de cada interrupción
9. }

[AngelGris]

  Que raro lo que te ocurre Picuino!!! Todavía no lo he probado en XC8, pero en HiTech no tenía problemas al hacer uso de ambos tipos de interrupción.

  Creo que tengo instalada la versión 1.12.... voy a probarlo y te comento.

[AngelGris]

  El siguiente código está compilado con la versión 1.12 de XC8 en MPLABX 1.60. Simulándolo en ISIS funciona bien.

  No lo probé en real, así que no sabría decirte si sólo funciona en la simulación o es que funciona por lo simple del programa.

Código: C

1. #include <xc.h>
2.  
3. #pragma config IESO=OFF, FOSC=HS, FCMEN=OFF, CPUDIV=OSC1_PLL2, PLLDIV=1
4. #pragma config VREGEN=OFF, BOR=OFF, BORV=0, PWRT=OFF, WDT=OFF, WDTPS=4
5. #pragma config PBADEN=OFF, LPT1OSC=OFF, MCLRE=OFF, DEBUG=OFF, STVREN=OFF
6. #pragma config LVP=OFF, CPD=OFF, CPB=OFF, USBDIV=1
7.  
8. #define _XTAL_FREQ 20000000
9.  
10. unsigned char contador;
11.  
12. void interrupt alta_prioridad()
13. {
14.     if (PIR1bits.TMR1IF == 1)
15.     {
16.         contador++;
17.         if (contador >= 10)
18.         {
19.             LATBbits.LB1 = ~LATBbits.LB1;
20.             contador = 0;
21.         }
22.         PIR1bits.TMR1IF = 0;
23.     }
24.  
25. }
26.  
27. void interrupt low_priority baja_prioridad()
28. {
29.     if (INTCONbits.T0IF == 1)
30.     {
31.         LATBbits.LB0 = ~LATBbits.LB0;
32.         INTCONbits.T0IF = 0;
33.     }
34. }
35.  
36. void main(void)
37. {
38.     const unsigned char palabra[]={5,4,8,6,};
39.  
40.     TRISB = 0;
41.  
42.     T0CON = 0b00000111;    //configuro timer0
43.     T1CON = 0b10110000;    //configuro timer1
44.  
45.     INTCON2bits.T0IP = 0;  //timer0 baja prioridad
46.     IPR1bits.TMR1IP = 1;   //timer1 alta prioridad
47.  
48.     RCONbits.IPEN = 1;     //habilito interrupcion de alta y baja prioridad
49.     INTCON = 0b00100000;     //habilito interrupciones y borro flags
50.     PIR1bits.TMR1IF = 0;   //borro flag timer1
51.     PIE1bits.TMR1IE = 1;   //habilito interrupcion timer1
52.  
53.     T0CONbits.TMR0ON = 1;  //enciendo el timer0
54.     T1CONbits.TMR1ON = 1;  //enciendo el timer1
55.     INTCONbits.GIEL = 1;
56.     INTCONbits.GIEH = 1;
57.  
58.     while(1);
59. }

[Picuino]

Puede ser un problema de mi programa, pero no me cuadra.
Estoy pasando un programa de C18 a XC8. En C18 funciona bien, y en XC8 no para de darme problemas.
Por ahora lo voy a seguir desarrollando en C18 y cuando tenga una versión estable preguntaré en el foro las dudas sobre cómo pasarlo a XC8.

Saludos.

[jukinch]

Hola Picuino. Podrías subir el código o una versión reducida del mismo?

[Picuino]

Hola jukinch,
Cuando lo tenga terminado en C18 lo subo.

Saludos.

[jukinch]

La idea era que subas lo que habías echo en xc8 para que podamos ayudarte. 

[Picuino]

Aquí dejo una parte del programa que me da problemas en XC8.
En C18 funciona perfectamente. El programa envía por la UART cada segundo el valor contado por el timer1 y sus desbordamientos.
En total es una cuenta de 48bits de longitud. Esa cuenta se pasa a ASCII y se envía.

En XC8, después de unos segundos, el programa se bloquea o se resetea. En otras versiones el micro se resetea. Sospecho que se debe a los punteros, pero no se que puede pasar.

El micro funciona con un xtal externo de 20Mhz. La frecuencia interna a partir del PLL es de 48Mhz.


Saludos.

[yamilongiano]

hola a todos como puedo hacer unos retardos  de uS
e encontrado puros retardos en milisegundos. y me gustaria tener los dos tipos de retardos tanto de milisegundos como microsegundos.

Código: [Seleccionar]

#include <xc.h>

#define _XTAL_FREQ 4000000
#define __delay_ms(x) _delay((unsigned long)((x)*(_XTAL_FREQ/4000.0)))

#pragma config FOSC = XT, WDTE = ON, PWRTE = OFF, CP = OFF

void main(void){
    PORTB = 0;
    TRISB = 0;

    while(1){

        PORTBbits.RB1 = 0b1;
        __delay_ms(1);
        PORTBbits.RB1 = 0b0;
        __delay_ms(1);
    }
} 

muchas gracias.

[AngelGris]

hola a todos como puedo hacer unos retardos  de uS
e encontrado puros retardos en milisegundos. y me gustaria tener los dos tipos de retardos tanto de milisegundos como microsegundos.

Código: [Seleccionar]

#include <xc.h>

#define _XTAL_FREQ 4000000
#define __delay_ms(x) _delay((unsigned long)((x)*(_XTAL_FREQ/4000.0)))

#pragma config FOSC = XT, WDTE = ON, PWRTE = OFF, CP = OFF

void main(void){
    PORTB = 0;
    TRISB = 0;

    while(1){

        PORTBbits.RB1 = 0b1;
        __delay_ms(1);
        PORTBbits.RB1 = 0b0;
        __delay_ms(1);
    }
} 

muchas gracias.

  Yo suelo utilizar __delay_us() y funciona bien

[sander]

Aquí dejo una parte del programa que me da problemas en XC8.
En C18 funciona perfectamente. El programa envía por la UART cada segundo el valor contado por el timer1 y sus desbordamientos.
En total es una cuenta de 48bits de longitud. Esa cuenta se pasa a ASCII y se envía.

En XC8, después de unos segundos, el programa se bloquea o se resetea. En otras versiones el micro se resetea. Sospecho que se debe a los punteros, pero no se que puede pasar.

El micro funciona con un xtal externo de 20Mhz. La frecuencia interna a partir del PLL es de 48Mhz.


Saludos.

Estuve revisando el código que subió y note que usa goto dentro de la rutina de interrupción. En XC8 no es necesario usar goto para ir a atender la interrupción el codigo para atender la interrupcion se pone directamente en la funcion void interrupt high_isr(void) o en la funcion void interrupt low_priority low_isr(void)

Yo utilizo las interrupciones en xc8 de la siguiente forma:

Código: [Seleccionar]

void interrupt ISR_HIGH(void)
{
    NOP();

}

void interrupt low_priority ISR_LOW(void)
{
       if(PIR1bits.RC1IF)
        IntRx1();
}


void IntRx1(void)
{
    unsigned char dato;
    if(RCSTA1bits.FERR && !PORTCbits.RC7)
        RESET(); //Si se recibio BREAK reiniciamos para entrar
//al bootloader
    else
        dato = RCREG; //Para procesar otro dato recibido
}


Lo que creo que esta pasando es que usted retorna a su programa desde la funcion void isr(void), entonces el xc8 en lugar de colocar RETFIE coloca RETURN, por eso no se habilitan de nuevo las interrupciones, y como no se  recupera los registros que guardo al ingresar a la interrupcion entoces puede ser que el programa no funcione bien.

Saludos