Electronic – Error setting up timer HAL PeriodElapsed Callback STM32F334R8T

errorstm32timer

I'm trying to create a microsecond delay function using the STMs regular timer. I wanted to set a timer to fire an interrupt every microsecond and then increment a variable in the call back function which gets called at the end of the interrupt and if that variable has reached the desired value stop the counter with HAL_TIM_BASE_STOP_IT().

Normally when using the HAL library for STM32 at the end of an the interrupt, the interrupt handler calls a callback function. The callback functions are already declared but are left blank. The driver makes use of a nonstandard keyword weak which allows you to overload the callback function, by simply writing your own definition. I've successfully done this with the callback functions for the interrupts for I2C, UART, and SPI communication, but for the timer I get the following 3 errors.

Error[Pe079]: expected a type specifier C:\projects\automated_testing\voltage measurement node\Src\main.c 610 

Error[Pe147]: declaration is incompatible with "__interwork __softfp void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *)" (declared at line 1558 of "C:\projects\automated_testing\voltage measurement node\Drivers\ C:\projects\automated_testing\voltage measurement node\Src\main.c 610 

Error[Pe141]: unnamed prototyped parameters not allowed when body is present C:\projects\automated_testing\voltage measurement node\Src\main.c 610

My function at the moment is literally just toggling a pin to see if it works. If I comment it out, it compiles fine.

void HAL_TIM_PeriodElapsedCallback(&htim3)
{
  HAL_GPIO_TogglePin(N_CS_GPIO_Port, N_CS_Pin);
}

Here's the configuration code for my timer created by STMCube to be in "Output Compare No Output" mode. I'm using HAL_TIM_Base_Start_IT(&htim3) to start the timer and does call the interrupt routine and get to the correct blank callback function when I don't create my own definition of the function.

* TIM3 init function */
static void MX_TIM3_Init(void)
{

  TIM_ClockConfigTypeDef sClockSourceConfig;
  TIM_MasterConfigTypeDef sMasterConfig;
  TIM_OC_InitTypeDef sConfigOC;

  htim3.Instance = TIM3;
  htim3.Init.Prescaler = 0;
  htim3.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim3.Init.Period = 72;
  htim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  htim3.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
  if (HAL_TIM_Base_Init(&htim3) != HAL_OK)
  {
    _Error_Handler(__FILE__, __LINE__);
  }

  sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
  if (HAL_TIM_ConfigClockSource(&htim3, &sClockSourceConfig) != HAL_OK)
  {
    _Error_Handler(__FILE__, __LINE__);
  }

  if (HAL_TIM_OC_Init(&htim3) != HAL_OK)
  {
    _Error_Handler(__FILE__, __LINE__);
  }

  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  if (HAL_TIMEx_MasterConfigSynchronization(&htim3, &sMasterConfig) != HAL_OK)
  {
    _Error_Handler(__FILE__, __LINE__);
  }

  sConfigOC.OCMode = TIM_OCMODE_TIMING;
  sConfigOC.Pulse = 0;
  sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
  sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
  if (HAL_TIM_OC_ConfigChannel(&htim3, &sConfigOC, TIM_CHANNEL_1) != HAL_OK)
  {
    _Error_Handler(__FILE__, __LINE__);
  }

}

Any ideas as to what I've done wrong would be very helpful.

Best Answer

You should add the type of htim in the function declaration which is missing in:

void HAL_TIM_PeriodElapsedCallback(&htim3)
{
  HAL_GPIO_TogglePin(N_CS_GPIO_Port, N_CS_Pin);
}

By adding it you will get:

void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
  HAL_GPIO_TogglePin(N_CS_GPIO_Port, N_CS_Pin);
}

To check if the function is called for timer 3, check for the correct timer:

void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
   if (htim == &htim3)
   {
      HAL_GPIO_TogglePin(N_CS_GPIO_Port, N_CS_Pin);
   }
}

(I do not have a compiler at hand, so I cannot check the code).

Related Solutions

Deferred callback manager / software timer library for PIC32

The Microchip’s TCP/IP stack has an implementation of such a timer library called the Tick Module. It's written for portability and supports the PIC18, PIC24, dsPIC & PIC32 devices.

From the Microchip TCP/IP Stack Help:

The Tick module provides accurate time-keeping capabilities based on the hardware clock. By default, it uses Timer 0 on 8-bit parts and Timer 1 on 16- and 32-bit families. The module is interrupt driven, which makes the timing stable and accurate. As such, it is also suitable for a real-time clock.

The Tick module exists to assist with the implementation of non-blocking delays and timeouts. Rather than using a loop to count to a specific number, use the Tick module and compare a previous time with the current time. In this fashion applications can return its unused cycles to the stack during long delays, which increases the overall efficiency of the system.

You'll just need to find the Tick.h and Tick.c files in the TCP/IP stack (download link, it's free) and modify them a bit to make them work independent of the stack.

How to detect which timer interrupt called callback when using ASF

The Atmel Studio Framework doesn't clear any of the flags and the underlying code is quite straightforward in that area. The callback routines get setup as follows:

void tc_set_overflow_interrupt_callback(volatile void *tc,
        tc_callback_t callback)
{
#ifdef TCC0
    if ((uintptr_t) tc == (uintptr_t) & TCC0) {
        tc_tcc0_ovf_callback = callback;
    } else
#endif
#ifdef TCC1
    if ((uintptr_t) tc == (uintptr_t) & TCC1) {
        tc_tcc1_ovf_callback = callback;
    } else
#endif
... etc for other timers

And the actual interrupt code is:

ISR(TCC0_OVF_vect)
{
    if (tc_tcc0_ovf_callback) {
        tc_tcc0_ovf_callback();
    }
}
... etc for other timers

The XMEGA is a little different to some processors in that some of the flags get cleared before the interrupt code is called rather than on return. For example the following is the description of the OVFIF flag:

This flag is set either on a TOP (overflow) or BOTTOM (underflow) condition, depending on the WGMODE setting. OVFIF is automatically cleared when the corresponding interrupt vector is executed. The flag can also be cleared by writing a one to its bit location.

One implication of using ASF is that the #ifdef directives above cause all interrupt vectors applicable to a device to be included once you include the timer/counter driver in the project.

But back to your original question as you've found those flags get cleared before the interrupt routine is called. After re-checking the documentation and taking a look at the various timer / interrupt flags before and after an interrupt in a debugger I can't see any way to achieve exactly what you're after. You might have to stick with a seperate callback for each timer that calls the main handler with a parameter. At least the code overhead shouldn't be too great because all the vectors are already included.

Best Answer

Related Solutions

Deferred callback manager / software timer library for PIC32

How to detect which timer interrupt called callback when using ASF

Related Topic