Прерывание таймера STM32 HAL не запускается

Question

Я пытаюсь периодически отправлять и серийную строку с моего устройства STM32F746ZG, используя прерывание. Большая часть кода автоматически генерируется stm32cubemx. У меня есть аппаратные точки останова (jlink), установленные на каждом прерывании, но я только включаю функцию elapse периода один раз, при инициализации. Когда я случайным образом приостанавливаю отладчик, я вижу значения счетчика от 0 до 1000, как ожидалось. Поэтому я знаю, что счетчик сбрасывается каждую секунду. Внутренние часы работают на частоте 16 МГц.

Опыт работы со встроенными устройствами ограничен BBB, малиной и ардуино. Я пробовал разные примеры и учебные пособия, но на данный момент я просто не знаю больше. Любая помощь или предложения очень ценится.

моя главная функция:

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(); 
    } 

} 

Моя Base_MspInit функция:

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); 
    } 
} 

Мой ТИМ IRQ функция обработчика:

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

HAL IRQ Handler, который вызывает HAL_TIM_PeriodElapsedCallback:

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); 
    } 
    } 
} 

Моя функция обратного вызова:

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

Код выше был правильным. Точками останова были «временные аппаратные» точки останова, когда я поменял их на «аппаратные» точки останова, где они попадали, когда произошло переполнение счетчика, указывающее, что период был достигнут.

Типичный случай, глядя на тот же код слишком долго ;-)