I have the following code:

#include "stm32f407xx.h" 
#define TIM2_IRQNO 28  

void TIM2_IRQHandler(void) {     
    printf("tick\n"); 
}  

int main() {
    TIM_PeriClockControl(TIM2, ENABLE);	        //enable system clock on timer

    TIM2->PSC = 168;                            //set prescaler
    TIM2->ARR = 1000;                           //set frequency to 1kHz

    TIM2->CR1 |= (1 << TIM_CR1_URS);            //update enable (after overflow)
    TIM2->EGR |= (1 << 0);                      //update generation
    TIM2->DIER |= (1 << 0);                     //update interrupt enabled

    TIM2->CR1 |= 1 << TIM_CR1_CEN;              //enable timer

    uint32_t *pISER1 = (uint32_t *)0xE000E100;  //NVIC_ISER base addr (or ..104?)
    *pISER1 |= ( 1 << (TIM2_IRQNO % 32) );      //enable NVIC for TIM2

    for(;;);                                    //main loop
}

I have an STM32F407VG microcontroller. It features a 168MHz clock. Whith the prescaler I bring down it's speed to 1MHz on the peripherals and I further decrease the timers speed to 1kHz with the help of the ARR Auto Reload register.

Not sure about EGR and DIER registers, but have seen others use them in their implementations.

After enabling the timer I try to enable the interrupt on the timer using the base address of the ISER register of the NVIC. It should probably end in 104, not 100, but with 104 I managed to print nothing, while using 100 I could print the "tick" text, but uncontrollably fast.

What I would expect form this code is to call the TIM2_IRQHandler after every millisecond (1 tick of the timer with the given PSC and ARR configuration). What am I doing wrong?

OK... I have an STM32L452 MCU running at 80MHz

I have a UART4 RX interrupt that is working. That ISR sets a pin high, and kick off a timer3 interrupt after 500 us.

The HAL generated code for setting up TIM3 is

static void MX_TIM3_Init(void)
{
  /* USER CODE BEGIN TIM3_Init 0 */
  /* USER CODE END TIM3_Init 0 */

  TIM_ClockConfigTypeDef sClockSourceConfig = {0};
  TIM_MasterConfigTypeDef sMasterConfig = {0};

  /* USER CODE BEGIN TIM3_Init 1 */
  /* USER CODE END TIM3_Init 1 */
  htim3.Instance = TIM3;
  htim3.Init.Prescaler = 79;
  htim3.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim3.Init.Period = 499;
  htim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  htim3.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  if (HAL_TIM_Base_Init(&htim3) != HAL_OK)
  {
    Error_Handler();
  }
  sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
  if (HAL_TIM_ConfigClockSource(&htim3, &sClockSourceConfig) != HAL_OK)
  {
    Error_Handler();
  }
  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  if (HAL_TIMEx_MasterConfigSynchronization(&htim3, &sMasterConfig) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN TIM3_Init 2 */
  /* USER CODE END TIM3_Init 2 */
}

When the UART4 interrupt is triggered, I call

void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart){
	if(huart->Instance==UART4){
		newMasterMessage = 1;
		HAL_GPIO_WritePin(UART4_DE_GPIO_Port, UART4_DE_Pin, GPIO_PIN_SET);	
		HAL_TIM_Base_Start_IT(&htim3);
	}
}

...the ISR for the timer3 interrupt just sets that pin low.

void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
  // Check which version of the timer triggered this callback and toggle LED
  if (htim == &htim3)
  {
	  HAL_GPIO_WritePin(UART4_DE_GPIO_Port, UART4_DE_Pin, GPIO_PIN_RESET);	
  }
}

My goal is to have the timer fire an interrupt after 500us. With an 80 MHz clock, I use a pre-scalar of 79, and counter of 499, which should do the trick.

However, the interrupt always fires after just ~5us, no matter what parameters I use. I have also tried using tim16, but it does the same thing. I feel like I'm missing something fundamental, but I don't know what.

Can anyone help?