Serial routine fails for some reason

[DPatr.2]

STM32F429ZIT6 - Nucleo

I am doing some tests with this board, it reads Encoder input in x4 mode, generates TRGO to ITR1 slave TIM1 in One pulse mode when it reaches TIM2->CCR3 value and updates Encoder counts and number of triggers every 15 seconds on serial.

I have observed when encoder count get above a certain threshold (less than 2^32 -1)

this serial routines either stop outputing on serial or get stucks in continuous output.

Is there anything wrong with this ?

counter and i are declared as global variable

volatile uint32_t counter = 0;
uint32_t i = 0;

 uint8_t data[50] ={'\0'}; 
 uint32_t startTime = HAL_GetTick();
 uint32_t waitTime = 15000;
 while (1)
 {
 
	if(HAL_GetTick()-startTime > waitTime){
		startTime = HAL_GetTick();
		sprintf(data, "Encoder count : %d Number of triggers : %d \r\n", counter,i);
		HAL_UART_Transmit(&huart3,data,sizeof(data),10);
 
	}
 
 }

[DPatr.2]

here is full main.c

#include "main.h"
 
TIM_HandleTypeDef htim1;
TIM_HandleTypeDef htim2;
 
UART_HandleTypeDef huart3;
 
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_USART3_UART_Init(void);
static void MX_TIM2_Init(void);
static void MX_TIM1_Init(void);
 
 
volatile uint32_t counter = 0;
volatile uint8_t direction = 0xFF;
 
void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim)
{
	counter = __HAL_TIM_GET_COUNTER(htim);
//	direction = (TIM2->CR1 & (1<<4))>>4;
}
 
 
#define STEP 10
#define DistToStart 10
#define FORWARD 0
#define BACKWARD 1
 
uint32_t trig_pos = 0;
uint32_t i = 0;
 
 
void HAL_TIM_OC_DelayElapsedCallback(TIM_HandleTypeDef *htim){
	//TIM2->CR1 Bit 4 = DIR // DIR = 0 Upcounting, DIR = 1 Downcounting
	i++;
	trig_pos = STEP*i +DistToStart;											// Update next encoder position
	__HAL_TIM_SET_COMPARE(&htim2,TIM_CHANNEL_3,trig_pos); 		//Write in TIM2->CCR3 (32 bits) Next encoder position compare value
	TIM1->CR1 |= (1<<0);										// Set CEN bit in TIM1->CR1 to restart TIM1 CNT
 
}
 
 
int main(void)
{
 
 HAL_Init();
  SystemClock_Config();
 MX_GPIO_Init();
 MX_USART3_UART_Init();
 MX_TIM2_Init();
 MX_TIM1_Init();
 /* USER CODE BEGIN 2 */
 uint8_t data[100] ={'\0'};
 
 HAL_TIM_OnePulse_Start(&htim1,TIM_CHANNEL_1);
 //HAL_TIM_PWM_Start(&htim1,TIM_CHANNEL_1);
 
 HAL_TIM_Encoder_Start_IT(&htim2, TIM_CHANNEL_ALL);
 HAL_TIM_OC_Start_IT(&htim2, TIM_CHANNEL_3);
 uint32_t startTime = HAL_GetTick();
 
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 uint32_t waitTime = 15000;
 while (1)
 {
 
	if(HAL_GetTick()-startTime > waitTime){
		startTime = HAL_GetTick();
		sprintf(data, "Encoder count : %d Number of triggers : %d \r\n", counter,i);
		HAL_UART_Transmit(&huart3,data,sizeof(data),10);
 
	}
 
 }
 
}
 
 
void SystemClock_Config(void)
{
 RCC_OscInitTypeDef RCC_OscInitStruct = {0};
 RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
 
 /** Configure the main internal regulator output voltage
 */
 __HAL_RCC_PWR_CLK_ENABLE();
 __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);
 /** Initializes the RCC Oscillators according to the specified parameters
 * in the RCC_OscInitTypeDef structure.
 */
 RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
 RCC_OscInitStruct.HSIState = RCC_HSI_ON;
 RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
 RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
 RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSI;
 RCC_OscInitStruct.PLL.PLLM = 8;
 RCC_OscInitStruct.PLL.PLLN = 180;
 RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
 RCC_OscInitStruct.PLL.PLLQ = 4;
 if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
 {
 Error_Handler();
 }
 
 if (HAL_PWREx_EnableOverDrive() != HAL_OK)
 {
 Error_Handler();
 }
 
 RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
 |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
 RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
 RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
 RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV4;
 RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV2;
 
 if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_5) != HAL_OK)
 {
 Error_Handler();
 }
}
 
static void MX_TIM1_Init(void)
{
  
 TIM_ClockConfigTypeDef sClockSourceConfig = {0};
 TIM_SlaveConfigTypeDef sSlaveConfig = {0};
 TIM_MasterConfigTypeDef sMasterConfig = {0};
 TIM_OC_InitTypeDef sConfigOC = {0};
 TIM_BreakDeadTimeConfigTypeDef sBreakDeadTimeConfig = {0};
 
 htim1.Instance = TIM1;
 htim1.Init.Prescaler = 0;
 htim1.Init.CounterMode = TIM_COUNTERMODE_UP;
 htim1.Init.Period = 451;
 htim1.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
 htim1.Init.RepetitionCounter = 0;
 htim1.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
 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();
 }
 if (HAL_TIM_PWM_Init(&htim1) != HAL_OK)
 {
 Error_Handler();
 }
 if (HAL_TIM_OnePulse_Init(&htim1, TIM_OPMODE_SINGLE) != HAL_OK)
 {
 Error_Handler();
 }
 sSlaveConfig.SlaveMode = TIM_SLAVEMODE_TRIGGER;
 sSlaveConfig.InputTrigger = TIM_TS_ITR1;
 if (HAL_TIM_SlaveConfigSynchro(&htim1, &sSlaveConfig) != HAL_OK)
 {
 Error_Handler();
 }
 sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
 sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
 if (HAL_TIMEx_MasterConfigSynchronization(&htim1, &sMasterConfig) != HAL_OK)
 {
 Error_Handler();
 }
 sConfigOC.OCMode = TIM_OCMODE_PWM2;
 sConfigOC.Pulse = 1;
 sConfigOC.OCPolarity = TIM_OCPOLARITY_LOW;
 sConfigOC.OCNPolarity = TIM_OCNPOLARITY_LOW;
 sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
 sConfigOC.OCIdleState = TIM_OCIDLESTATE_SET;
 sConfigOC.OCNIdleState = TIM_OCNIDLESTATE_SET;
 if (HAL_TIM_PWM_ConfigChannel(&htim1, &sConfigOC, TIM_CHANNEL_1) != HAL_OK)
 {
 Error_Handler();
 }
 sBreakDeadTimeConfig.OffStateRunMode = TIM_OSSR_DISABLE;
 sBreakDeadTimeConfig.OffStateIDLEMode = TIM_OSSI_DISABLE;
 sBreakDeadTimeConfig.LockLevel = TIM_LOCKLEVEL_OFF;
 sBreakDeadTimeConfig.DeadTime = 0;
 sBreakDeadTimeConfig.BreakState = TIM_BREAK_DISABLE;
 sBreakDeadTimeConfig.BreakPolarity = TIM_BREAKPOLARITY_HIGH;
 sBreakDeadTimeConfig.AutomaticOutput = TIM_AUTOMATICOUTPUT_DISABLE;
 if (HAL_TIMEx_ConfigBreakDeadTime(&htim1, &sBreakDeadTimeConfig) != HAL_OK)
 {
 Error_Handler();
 }
 /* USER CODE BEGIN TIM1_Init 2 */
 //	sConfigOC.OCMode = TIM_OCMODE_PWM1;	//Actice High trigger pulse
 //	sConfigOC.OCMode = TIM_OCMODE_PWM2;	//Actice Low trigger pulse
 //	TIM1 Clock input is 180 MHz, period = 5.555 ns
 //	TIM1_CCR1 = 1 	(sConfigOC.Pulse = 1;)
 //	TIM1_ARR = 451	(htim1.Init.Period = 451;)
 //	Delay to generate pulse = 1 * 5.555 ns = 5.555ns
 //	Pulse width = (451-1)*5.555ns = 2.5 us
 /* USER CODE END TIM1_Init 2 */
 HAL_TIM_MspPostInit(&htim1);
 
}
 
static void MX_TIM2_Init(void)
{
  
 TIM_Encoder_InitTypeDef sConfig = {0};
 TIM_MasterConfigTypeDef sMasterConfig = {0};
 TIM_OC_InitTypeDef sConfigOC = {0};
 
 htim2.Instance = TIM2;
 htim2.Init.Prescaler = 0;
 htim2.Init.CounterMode = TIM_COUNTERMODE_UP; //TIM_COUNTERMODE_UP
 htim2.Init.Period = 4294967295;
 htim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
 htim2.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE; //was enable
 if (HAL_TIM_OC_Init(&htim2) != HAL_OK)
 {
 Error_Handler();
 }
 sConfig.EncoderMode = TIM_ENCODERMODE_TI12;
 sConfig.IC1Polarity = TIM_ICPOLARITY_FALLING;
 sConfig.IC1Selection = TIM_ICSELECTION_DIRECTTI;
 sConfig.IC1Prescaler = TIM_ICPSC_DIV1;
 sConfig.IC1Filter = 10;
 sConfig.IC2Polarity = TIM_ICPOLARITY_FALLING;
 sConfig.IC2Selection = TIM_ICSELECTION_DIRECTTI;
 sConfig.IC2Prescaler = TIM_ICPSC_DIV1;
 sConfig.IC2Filter = 10;
 if (HAL_TIM_Encoder_Init(&htim2, &sConfig) != HAL_OK)
 {
 Error_Handler();
 }
 sMasterConfig.MasterOutputTrigger = TIM_TRGO_OC3REF;
 sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_ENABLE;
 if (HAL_TIMEx_MasterConfigSynchronization(&htim2, &sMasterConfig) != HAL_OK)
 {
 Error_Handler();
 }
 sConfigOC.OCMode = TIM_OCMODE_ACTIVE;
 sConfigOC.Pulse = DistToStart;
 sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
 sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
 if (HAL_TIM_OC_ConfigChannel(&htim2, &sConfigOC, TIM_CHANNEL_3) != HAL_OK)
 {
 Error_Handler();
 }
 __HAL_TIM_DISABLE_OCxPRELOAD(&htim2, TIM_CHANNEL_3);
 }
 
static void MX_USART3_UART_Init(void)
{
 
 huart3.Instance = USART3;
 huart3.Init.BaudRate = 115200;
 huart3.Init.WordLength = UART_WORDLENGTH_8B;
 huart3.Init.StopBits = UART_STOPBITS_1;
 huart3.Init.Parity = UART_PARITY_NONE;
 huart3.Init.Mode = UART_MODE_TX_RX;
 huart3.Init.HwFlowCtl = UART_HWCONTROL_NONE;
 huart3.Init.OverSampling = UART_OVERSAMPLING_16;
 if (HAL_UART_Init(&huart3) != HAL_OK)
 {
 Error_Handler();
 }
 
}
 
 
static void MX_GPIO_Init(void)
{
 GPIO_InitTypeDef GPIO_InitStruct = {0};
 
 __HAL_RCC_GPIOA_CLK_ENABLE();
 __HAL_RCC_GPIOB_CLK_ENABLE();
 __HAL_RCC_GPIOE_CLK_ENABLE();
 __HAL_RCC_GPIOD_CLK_ENABLE();
 
 HAL_GPIO_WritePin(LED_PIN_GPIO_Port, LED_PIN_Pin, GPIO_PIN_RESET);
 
 /*Configure GPIO pin : LED_PIN_Pin */
 GPIO_InitStruct.Pin = LED_PIN_Pin;
 GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
 GPIO_InitStruct.Pull = GPIO_NOPULL;
 GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
 HAL_GPIO_Init(LED_PIN_GPIO_Port, &GPIO_InitStruct);
 
}
 
void Error_Handler(void)
{
 __disable_irq();
 while (1)
 {
 }
 
}
 
#ifdef USE_FULL_ASSERT
 
void assert_failed(uint8_t *file, uint32_t line)
{
 /* USER CODE BEGIN 6 */
 /* User can add his own implementation to report the file name and line number,
 ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
 /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */

[Tesla DeLorean]

The two shouldn't interact at a peripheral level.

I'd suggest qualifying the interrupt source.

Have Error_Handler() and HardFault_Handler() output info if they get stuck there.

Use the debugger to understand what's happening in the failure cases, perhaps add code yourself to identify why continuous/repeated output is occurring, etc.

Note sprintf() should return the output string length, use that rather than blindly sending the whole array, make sure that's not overrunning.