Electrical – PIC24 Timer 2/3 Interrupt Flag does not gets set

microchippictimer

I am working with a PIC24FJ1024.

I want to test Timer 2/3 (32 bit timer), by writing a C code, where I toggle a pin (PORTAbits.RA7) every second.

That is part of the code:

while(!IFS0bits.T2IF);
LATAbits.LATA7 = ~LATAbits.LATA7;
IFS0bits.T2IF = 0;

When I compile and download it onto my Development Tool (Explorer 16/32), I don't see my Pin (which is connected to an LED) Toggle.

I debug program, and it turns out that IFS0bits.T2IF doesn't get set, the program just sits on while(!IFS0bits.T2IF)

Can someone explain to me why this happens?

Thank you in advance.

EDIT:
The Code

#include <xc.h>

#pragma config FWDTEN = OFF
#pragma config FNOSC = FRC //8MHz 
#pragma config ICS = PGD2

void Timer23_Init (void)
{
    /*
     Initialize T2 & 3
     from FRC
     * 1 second
     * on and off

     */

    T2CONbits.T32 = 1;//32 bit timer

    T2CONbits.TSIDL = 0;//continues through Idle Mode
    T2CONbits.TGATE = 0;//no TGATE Operationss
    T2CONbits.TCS = 0;//internal CLK SRC
    T2CONbits.TECS = 0x00;

    T2CONbits.TCKPS = 3;//1:256
    /*
      PRESCALAR = 256
     * t = 1 sec = 1000 ms = 1,000,000 us
     * Fosc = 8MHz Fosc/2 = 4MHz Tcy = 0.25 us
     * 
     * t = N*PRE*Tcy
     * N = t/(PRE*Tcy) = 1,000,000/(256*0.25) = 15,625
     * PR2 = 15625 (0x3D09)    
     */

    TMR2 = 0x00000000;
    PR2 = 15625;   

    TRISAbits.TRISA7 = 0;//output
    ANSAbits.ANSA7 = 0;//Digital
    LATAbits.LATA7 = 0;

    T2CONbits.TON = 1;
}

int main (void)
{   


    Timer23_Init ();

    while(1)
    {
        IFS0bits.T2IF = 0;

        while(!IFS0bits.T2IF);
        LATAbits.LATA7 = ~LATAbits.LATA7;
        IFS0bits.T2IF = 0;  
    }

    return 0;
}

Best Answer

Can someone explain to me why this happens?

The flag is almost surely firing and your led pin flipping. Except that the pin is not in GPIO mode.

Related Solutions

Timer on PIC18 not getting close to desired interrupt period time

Stop and think about what it means to set timer 0 to FFh. That means it will overflow and set the interrupt condition on the very next clock. The clock is stopped for a couple of cycles when TMR0 is written, so this will occur 3 cycles (if I remember right) after the write. How can you possibly expect the interrupt mechanism to repond that fast. The return from interrupt (RETFIE) takes 2 cycles alone, and the entry into the interrupt routine at least another 2 cycles (it's essentially a call), then there is the code to save and restore context. This is all overhead even if your application code does nothing.

Expecting a PIC 18 to interrupt every 3 cycles is rediculous, as even a cursory look at the datasheet should have made obvious. Using a compiler on top of that only makes the minimum interrupt frequency that can actually be handled worse.

If you want to set up a periodic interrupt, start with timer 2, not timer 0. That timer has a period register for exactly this purpose.

Even if you are stuck with timer 0 to create a periodic interrupt, you should be adding a value into TMR0, not setting it to a fixed value. That way there is no accumulating error and the number of cycles from the timer 0 overflow to the instruction that writes it to a new value doesn't matter.

Electronic – Why does DSPIC33F restarts when timer interrupt flag is addressed

Page 2 in the PIC33f Interrupts family reference illustrates how interrupt process works for the dsPIC33f:

http://ww1.microchip.com/downloads/en/DeviceDoc/70300C.pdf

When you enable an interrupt (e.g. T2IE) and the interrupt fires it goes to the address location found at the peripheral interrupt vector. if you did not define a legal address for the peripheral the peripheral interrupt vector will have an unknown address (perhaps 0) and when the interrupt will fire it will go to that address and unpredictable things can happen

in your case, assuming the ALTIVT bit (INTCON2<15>) is cleared, when the the TMR2 interrupt fires it will go to the address location found in 0x000022.

when you write:

void __attribute__((__interrupt__, auto_psv)) _T2Interrupt (void)
{

}

you actually telling your compiler that you would like to place the address of the start of this code at address 0x000022 (TMR2 IVT Address)

and when you write:

void __attribute__((__interrupt__, auto_psv)) _AltT2Interrupt (void)
{

}

you are telling your compiler to place the address of the start of this code at address 0x000122 (TMR2 AIVT Address)

Related Topic