Electronic – Inaccurate timer interrupt STM32

embeddedinterruptsstm32timer

I wrote a simple program to toggle an LED on and off using the TIM1 interrupt on an STM32F0 discovery board.

CLK Freq = 48MHz
Prescalar = 48000
Auto Reload Register = 1000

Using the following formula to calculate the timer frequency:

Timer frequency = (CLK FREQ/ (Prescalar -1) * ARR)

In my case it is equal to 1 second. If I run this code without an interrupt, it toggles the LED on and off at 1-second intervals, which is what I want.

As soon as I use the ISR, my LED TOGGLE is really fast (approximately 500ms), if I make my Timer_Value = 60000

void TIM1_BRK_UP_TRG_COM_IRQHandler(void)
{
    Timer_Value++;

if(Timer_Value == 60000)
{
if(Timer_Change_Status == Timer_Deactive)
{
    SendBitToPortAndPin(LEDIND_Port, LEDIND_Pin,1);
    Timer_Change_Status = Timer_Active;
}
else {
    SendBitToPortAndPin(LEDIND_Port, LEDIND_Pin,0);
    Timer_Change_Status = Timer_Deactive;
}
Timer_Value = 0;
}
  // reload counter
TIM1->EGR |= 0x01;
}

In my main loop, I call the following function

void COnfig_Start_Timer(void)
    {   
    RCC->APB2ENR |= RCC_APB2ENR_TIM1EN;

    TIM1->PSC = 48000;                          ///Load Prescalar
    TIM1->ARR = 1000;                           ///Load Auto Reload value


    NVIC_EnableIRQ(TIM1_BRK_UP_TRG_COM_IRQn);   ///Enable interrupt
    NVIC_SetPriority(TIM1_BRK_UP_TRG_COM_IRQn,1);///Set interrupt priority
    TIM1->DIER |= TIM_DIER_UIE;                 ///Activate Timer Interrupt
    TIM1->CR1 |= TIM_CR1_CEN;                   ///start Timer


    while(1)
    {

    }
    }

I would like to know what is causing my ISR to fire so frequently, when it should only fire once every second. I have referred to my reference manual with no luck.

Best Answer

There are two things wrong with your code:

1) you attempt to reset and restart the counter in the interrupt handler with "TIM1->EGR |= 0x01;" . But you're using the automatic reload mode of the counter so you shouldn't do that.

2) You never clear the interrupt from the timer. The timer sets the interrupt, but you're responsible for clearing it once you've handled it. Since you don't do that, when your IRQ handler returns, the cpu immediately dispatches the same interrupt and calls it again. To clear the interrupt you need to clear bit 0 of TIM1_SR with something like

TIM1->SR &= ~0x1;

(or perhaps TIM1->SR &= ~TIM_SR_UIF; if you have that defined)

Related Solutions

Electronic – STM32: Timer interrupt works immediately

I ran into this with an STM32F105. The STM32F1xx Standard Peripheral Library functions are a bit different than what you are using, but the idea should be the same.

Issuing the TIM_TimeBaseInit() function caused the TIM_SR_UIF flag to become set. I haven't gone back yet to figure out why. Once this bit is set, the interrupt will trigger as soon as it is enabled.

To fix it, after calling TIM_TimeBaseInit(), I immediately called TIM_ClearITPendingBit(). Then I would enable the interrupt with TIM_ITConfig(). This fixed the problem.

My complete initialization routine looks like this:

// Enable the peripheral clock
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM5, ENABLE);

// Configure the timebase
TIM_TimeBaseInitStructure.TIM_Prescaler = 1;
TIM_TimeBaseInitStructure.TIM_Period = 35999;
TIM_TimeBaseInit(TIM5, &TIM_TimeBaseInitStructure);

// That last function caused the UIF flag to get set. Clear it.
TIM_ClearITPendingBit(TIM5, TIM_IT_Update);

// Configure so that the interrupt flag is only set upon overflow
TIM_UpdateRequestConfig(TIM5, TIM_UpdateSource_Regular);

// Enable the TIM5 Update Interrupt type
TIM_ITConfig(TIM5, TIM_IT_Update, ENABLE);

Electronic – STM32: Timer Modes

Introduction

It seems like you are trying to build a frequency counter. You can achieve such a device with the timer module in a microcontroller. Be aware that it will have some limitations in terms of how fast of a signal it can observe.

Analog Processing

You will need to first condition the input signal. To know what is required, I would first need to know a bit more about your signal, but I will assume you are trying to measure the frequency of something that is basically a sine/square wave perhaps with some DC offset. We need to get from this general analog signal to a digital square wave that represents the same edges. We can do that with the following comparator circuit:

schematic

^{simulate this circuit – Schematic created using CircuitLab}

Microcontroller Configuration

Configure your microcontroller to count up until it sees a rising edge on the output of the comparator. Increase the timer frequency as high as possible to achieve the frequency resolution you require. You will also want to fire an interrupt on a capture event so you can do something with the new data.

Algorithm

When the interrupt is fired grab the value in the capture register and compute the frequency of the signal as follows:

$$f_{in} = \frac{f_{timer}}{count}$$

You may then wish to average several of these readings.