STM32 HAL-Timer-Interrupt wird nicht ausgelöst

Question

Ich versuche in regelmäßigen Abständen zu senden und Serial String von meinem STM32F746ZG-Gerät mit einem Interrupt. Der meiste Code wird automatisch von stm32cubemx generiert. Ich habe Hardware Breakpoints (jlink) bei jedem Interrupt eingestellt, aber ich gebe die Periodendauerfunktion nur einmal bei der Initialisierung ein. Wenn ich den Debugger zufällig pausiere, sehe ich die Zählerwerte zwischen 0 und 1000 wie erwartet. Also weiß ich, dass der Zähler jede Sekunde zurückgesetzt wird. Die interne Uhr läuft mit 16 MHz.

Meine Erfahrung mit eingebetteten Geräten ist auf BBB, Raspberry und Arduino beschränkt. Ich habe verschiedene Beispiele und Tutorials ausprobiert, aber im Moment weiß ich es einfach nicht mehr. Jede Hilfe oder Vorschläge wird sehr geschätzt.

meine Hauptfunktion:

int main(void) { 

    HAL_Init(); 
    SystemClock_Config(); 
    MX_GPIO_Init(); 
    MX_RTC_Init(); 
    MX_TIM1_Init(); 

    if (HAL_TIM_Base_Start(&htim1) != HAL_OK) { 
     Error_Handler(); 
    } 

    if (HAL_TIM_Base_Start_IT(&htim1) != HAL_OK) { 
     Error_Handler(); 
    } 

    while (1) { 
     cnt = __HAL_TIM_GetCounter(&htim1); 
    } 
} 

TIM1 init:

static void MX_TIM1_Init(void) { 

    TIM_ClockConfigTypeDef sClockSourceConfig; 
    TIM_MasterConfigTypeDef sMasterConfig; 

    htim1.Instance = TIM1; 
    htim1.Init.Prescaler = 16000; 
    htim1.Init.CounterMode = TIM_COUNTERMODE_UP; 
    htim1.Init.Period = 1000; 
    htim1.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1; 
    htim1.Init.RepetitionCounter = 0x0; 
    if (HAL_TIM_Base_Init(&htim1) != HAL_OK) { 
     Error_Handler(); 
    } 

    sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL; 
    if (HAL_TIM_ConfigClockSource(&htim1, &sClockSourceConfig) != HAL_OK) { 
     Error_Handler(); 
    } 

    sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET; 
    sMasterConfig.MasterOutputTrigger2 = TIM_TRGO2_RESET; 
    sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE; 
    if (HAL_TIMEx_MasterConfigSynchronization(&htim1, &sMasterConfig) 
      != HAL_OK) { 
     Error_Handler(); 
    } 

} 

Meine Base_MspInit Funktion:

void HAL_TIM_Base_MspInit(TIM_HandleTypeDef* htim_base) 
{ 

    GPIO_InitTypeDef GPIO_InitStruct; 
    if(htim_base->Instance==TIM1) 
    { 
    /* Peripheral clock enable */ 
    __HAL_RCC_TIM1_CLK_ENABLE(); 
    /* Peripheral interrupt init */ 
    HAL_NVIC_SetPriority(TIM1_BRK_TIM9_IRQn, 0, 0); 
    HAL_NVIC_EnableIRQ(TIM1_BRK_TIM9_IRQn); 
    HAL_NVIC_SetPriority(TIM1_UP_TIM10_IRQn, 0, 0); 
    HAL_NVIC_EnableIRQ(TIM1_UP_TIM10_IRQn); 
    HAL_NVIC_SetPriority(TIM1_TRG_COM_TIM11_IRQn, 0, 0); 
    HAL_NVIC_EnableIRQ(TIM1_TRG_COM_TIM11_IRQn); 
    HAL_NVIC_SetPriority(TIM1_CC_IRQn, 0, 0); 
    HAL_NVIC_EnableIRQ(TIM1_CC_IRQn); 
    } 
} 

Meine TIM IRQ-Handler-Funktion:

void TIM1_UP_TIM10_IRQHandler(void) 
{ 
    HAL_TIM_IRQHandler(&htim1); 
} 

HAL IRQ-Handler, die die HAL_TIM_PeriodElapsedCallback ruft:

void HAL_TIM_IRQHandler(TIM_HandleTypeDef *htim) 
{ 
    /* Capture compare 1 event */ 
    if(__HAL_TIM_GET_FLAG(htim, TIM_FLAG_CC1) != RESET) 
    { 
    if(__HAL_TIM_GET_IT_SOURCE(htim, TIM_IT_CC1) !=RESET) 
    { 
     { 
     __HAL_TIM_CLEAR_IT(htim, TIM_IT_CC1); 
     htim->Channel = HAL_TIM_ACTIVE_CHANNEL_1; 

     /* Input capture event */ 
     if((htim->Instance->CCMR1 & TIM_CCMR1_CC1S) != 0x00) 
     { 
      HAL_TIM_IC_CaptureCallback(htim); 
     } 
     /* Output compare event */ 
     else 
     { 
      HAL_TIM_OC_DelayElapsedCallback(htim); 
      HAL_TIM_PWM_PulseFinishedCallback(htim); 
     } 
     htim->Channel = HAL_TIM_ACTIVE_CHANNEL_CLEARED; 
     } 
    } 
    } 
    /* Capture compare 2 event */ 
    if(__HAL_TIM_GET_FLAG(htim, TIM_FLAG_CC2) != RESET) 
    { 
    if(__HAL_TIM_GET_IT_SOURCE(htim, TIM_IT_CC2) !=RESET) 
    { 
     __HAL_TIM_CLEAR_IT(htim, TIM_IT_CC2); 
     htim->Channel = HAL_TIM_ACTIVE_CHANNEL_2; 
     /* Input capture event */ 
     if((htim->Instance->CCMR1 & TIM_CCMR1_CC2S) != 0x00) 
     {   
     HAL_TIM_IC_CaptureCallback(htim); 
     } 
     /* Output compare event */ 
     else 
     { 
     HAL_TIM_OC_DelayElapsedCallback(htim); 
     HAL_TIM_PWM_PulseFinishedCallback(htim); 
     } 
     htim->Channel = HAL_TIM_ACTIVE_CHANNEL_CLEARED; 
    } 
    } 
    /* Capture compare 3 event */ 
    if(__HAL_TIM_GET_FLAG(htim, TIM_FLAG_CC3) != RESET) 
    { 
    if(__HAL_TIM_GET_IT_SOURCE(htim, TIM_IT_CC3) !=RESET) 
    { 
     __HAL_TIM_CLEAR_IT(htim, TIM_IT_CC3); 
     htim->Channel = HAL_TIM_ACTIVE_CHANNEL_3; 
     /* Input capture event */ 
     if((htim->Instance->CCMR2 & TIM_CCMR2_CC3S) != 0x00) 
     {   
     HAL_TIM_IC_CaptureCallback(htim); 
     } 
     /* Output compare event */ 
     else 
     { 
     HAL_TIM_OC_DelayElapsedCallback(htim); 
     HAL_TIM_PWM_PulseFinishedCallback(htim); 
     } 
     htim->Channel = HAL_TIM_ACTIVE_CHANNEL_CLEARED; 
    } 
    } 
    /* Capture compare 4 event */ 
    if(__HAL_TIM_GET_FLAG(htim, TIM_FLAG_CC4) != RESET) 
    { 
    if(__HAL_TIM_GET_IT_SOURCE(htim, TIM_IT_CC4) !=RESET) 
    { 
     __HAL_TIM_CLEAR_IT(htim, TIM_IT_CC4); 
     htim->Channel = HAL_TIM_ACTIVE_CHANNEL_4; 
     /* Input capture event */ 
     if((htim->Instance->CCMR2 & TIM_CCMR2_CC4S) != 0x00) 
     {   
     HAL_TIM_IC_CaptureCallback(htim); 
     } 
     /* Output compare event */ 
     else 
     { 
     HAL_TIM_OC_DelayElapsedCallback(htim); 
     HAL_TIM_PWM_PulseFinishedCallback(htim); 
     } 
     htim->Channel = HAL_TIM_ACTIVE_CHANNEL_CLEARED; 
    } 
    } 
    /* TIM Update event */ 
    if(__HAL_TIM_GET_FLAG(htim, TIM_FLAG_UPDATE) != RESET) 
    { 
    if(__HAL_TIM_GET_IT_SOURCE(htim, TIM_IT_UPDATE) !=RESET) 
    { 
     __HAL_TIM_CLEAR_IT(htim, TIM_IT_UPDATE); 
     HAL_TIM_PeriodElapsedCallback(htim); 
    } 
    } 
    /* TIM Break input event */ 
    if(__HAL_TIM_GET_FLAG(htim, TIM_FLAG_BREAK) != RESET) 
    { 
    if(__HAL_TIM_GET_IT_SOURCE(htim, TIM_IT_BREAK) !=RESET) 
    { 
     __HAL_TIM_CLEAR_IT(htim, TIM_IT_BREAK); 
     HAL_TIMEx_BreakCallback(htim); 
    } 
    } 

    /* TIM Break input event */ 
    if(__HAL_TIM_GET_FLAG(htim, TIM_FLAG_BREAK2) != RESET) 
    { 
    if(__HAL_TIM_GET_IT_SOURCE(htim, TIM_IT_BREAK) !=RESET) 
    { 
     __HAL_TIM_CLEAR_IT(htim, TIM_IT_BREAK); 
     HAL_TIMEx_BreakCallback(htim); 
    } 
    } 

    /* TIM Trigger detection event */ 
    if(__HAL_TIM_GET_FLAG(htim, TIM_FLAG_TRIGGER) != RESET) 
    { 
    if(__HAL_TIM_GET_IT_SOURCE(htim, TIM_IT_TRIGGER) !=RESET) 
    { 
     __HAL_TIM_CLEAR_IT(htim, TIM_IT_TRIGGER); 
     HAL_TIM_TriggerCallback(htim); 
    } 
    } 
    /* TIM commutation event */ 
    if(__HAL_TIM_GET_FLAG(htim, TIM_FLAG_COM) != RESET) 
    { 
    if(__HAL_TIM_GET_IT_SOURCE(htim, TIM_IT_COM) !=RESET) 
    { 
     __HAL_TIM_CLEAR_IT(htim, TIM_FLAG_COM); 
     HAL_TIMEx_CommutationCallback(htim); 
    } 
    } 
} 

Meine Callback-Funktion:

void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim) { 
    if (htim->Instance == TIM1) { 
     char frame[20] = "123456789\r\n"; 
     HAL_UART_Transmit(&huart1, frame, 20, 10); 
    } 
} 

Answer 1

Der obige Code richtig war. Die Breakpoints waren "temporäre Hardware" Breakpoints, als ich sie zu "Hardware" Breakpoints änderte, wo sie getroffen wurden, als ein Zählerüberlauf auftrat, der darauf hinwies, dass der Zeitraum erreicht war.

Typischer Fall von viel zu langen ;-)