自学教程：C++ HAL_TIM_Base_Start_IT函数代码示例

void SERVO_CONTROLLER_Start (void){    //Start timers    HAL_TIM_Base_Start_IT(&htim1);    HAL_TIM_Base_Start_IT(&htim2);    HAL_TIM_Base_Start_IT(&htim3);    HAL_TIM_Base_Start_IT(&htim4);        //Start PWMs    for (int i = 0; i < SERVO_TotalChannelsNum; i++)    {        TIM_HandleTypeDef *htim = tim_handlers_table[i];        int32_t channel = tim_channels_table[i];                if (!htim || channel < 0)        {            continue;        }                HAL_TIM_PWM_Start(htim, (uint32_t)channel);                SERVO_Channel *ch = &servo_channels[i];        SERVO_CONTROLLER_SetChannel((SERVO_ChannelId)i, ch->pulseCycles);    }}

/* TIM2 init function */void MX_TIM2_Init(void){  TIM_ClockConfigTypeDef sClockSourceConfig;  TIM_MasterConfigTypeDef sMasterConfig;  htim2.Instance = TIM2;  htim2.Init.Prescaler = 1;  htim2.Init.CounterMode = TIM_COUNTERMODE_UP;  htim2.Init.Period = 875;  htim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;  htim2.Init.RepetitionCounter = 0;  HAL_TIM_Base_Init(&htim2);  // Initialize interrupt triggering//  HAL_NVIC_EnableIRQ(TIM2_IRQn);  sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;  HAL_TIM_ConfigClockSource(&htim2, &sClockSourceConfig);  sMasterConfig.MasterOutputTrigger = TIM_TRGO_UPDATE;  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;  HAL_TIMEx_MasterConfigSynchronization(&htim2, &sMasterConfig);  if (HAL_TIM_Base_Start_IT(&htim2) != HAL_OK) {      while(1);  }}

/*** @brief This function handles EXTI line0 interrupt.*/void EXTI0_IRQHandler(void){  /* USER CODE BEGIN EXTI0_IRQn 0 */  // Checks if the interrupt has been triggered by a rising edge( first   // pressing of button), starts a 2secs timer and make the line falling  // edge sensitive.  if ((EXTI-> RTSR) & (GPIO_PIN_0))  {    HAL_TIM_Base_Start_IT(&htim6);    EXTI-> RTSR &= (~GPIO_PIN_0);    EXTI-> FTSR |= GPIO_PIN_0;  }  else  {    // If a falling edge is detected( button is released) before the countdown    // ends, we stop the countdown, reset it and make the line rising    // edge sensitive again.    HAL_TIM_Base_Stop_IT(&htim6);    __HAL_TIM_SET_COUNTER(&htim6,0);    EXTI-> FTSR &= (~GPIO_PIN_0);    EXTI-> RTSR |= GPIO_PIN_0;  }  /* USER CODE END EXTI0_IRQn 0 */  HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_0);  /* USER CODE BEGIN EXTI0_IRQn 1 */  /* USER CODE END EXTI0_IRQn 1 */}

/**  * @brief  Initializes the CDC media low layer        * @param  None  * @retval Result of the operation: USBD_OK if all operations are OK else USBD_FAIL  */static int8_t CDC_Itf_Init(void){  /*##-6- Enable TIM peripherals Clock #######################################*/  USBCDCTIMx_CLK_ENABLE();  /*##-7- Configure the NVIC for TIMx ########################################*/  /* Set Interrupt Group Priority */  HAL_NVIC_SetPriority(USBCDCTIMx_IRQn, 6, 0);  /* Enable the TIMx global Interrupt */  HAL_NVIC_EnableIRQ(USBCDCTIMx_IRQn);  /*##-3- Configure the TIM Base generation  #################################*/  TIM_Config();    /*##-4- Start the TIM Base generation in interrupt mode ####################*/  /* Start Channel1 */  if(HAL_TIM_Base_Start_IT(&USBCDCTimHandle) != HAL_OK)  {    /* Starting Error */    Error_Handler();  }    /*##-5- Set Application Buffers ############################################*/  USBD_CDC_SetTxBuffer(&usb_cdc_dev_param, UserTxBuffer, 0);  USBD_CDC_SetRxBuffer(&usb_cdc_dev_param, UserRxBuffer);    return (USBD_OK);}

/**  * @brief  Initialize the hardware timer 4.  * @param  None  * @retval None  */void HardwareTimer4_Init(void){	__TIM4_CLK_ENABLE();	/* Enable TIM4 interface clock */			/* Desired_timer_frequency = Timer_input_frequency / (prescaler * period)		 Timer_input_frequency = 84 MHz (same as TIM3, TIM4 is also on APB1)		 Desired_timer_frequency = 8 Hz (Rotate the LEDs at that frequency for the visuals)		 ---> prescaler * period = 84 MHz / 8 Hz = 10500000 = 2100 * 5000		 ---> prescaler = 5000, period = 2100 */		timmy4.Instance = TIM4;																/* Use TIM4 */	timmy4.Init.Prescaler = 2100;													/* Set prescaler to 2100 */	timmy4.Init.CounterMode = TIM_COUNTERMODE_DOWN;				/* Count down */	timmy4.Init.Period = 5000;														/* Set period count register to 5000 */	timmy4.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;		/* Set clock division to 1 */	timmy4.Init.RepetitionCounter = 0;										/* Not valid for TIM4 */	timmy4.Channel = HAL_TIM_ACTIVE_CHANNEL_CLEARED;			/* Not using channels */		/* Initialize the TIM Time Base Unit */	HAL_TIM_Base_Init(&timmy4);		/* Start TIM3 in interrupt mode */	HAL_TIM_Base_Start_IT(&timmy4);		/* Set priority for TIM3 IRQ */	HAL_NVIC_SetPriority(TIM4_IRQn, 0, 0);		/* Enable IRQ for the TIM3 Timer*/	HAL_NVIC_EnableIRQ(TIM4_IRQn);}

/* --- Load and start periodic event counter --- */void startPerEvent(uint32_t rateFactor){	htim2.Init.Period = rateFactor;	HAL_TIM_Base_Init(&htim2);	HAL_TIM_Base_Start_IT(&htim2);		}

void Timer_For_Main_Loop_Init(){	__TIM6_CLK_ENABLE();  /* Compute the prescaler value to have TIMx counter clock equal to 1 KHz */  uwPrescalerValue = (uint32_t) ((SystemCoreClock / 1000) - 1);    /*##-1- Configure the TIM peripheral #######################################*/   /* Set TIMx instance */  TimHandle.Instance = TIM6;      /* Initialize TIMx peripheral as follow:       + Period = 10000 - 1       + Prescaler = SystemCoreClock/10000 Note that APB clock = TIMx clock if                     APB prescaler = 1.       + ClockDivision = 0       + Counter direction = Up  */  TimHandle.Init.Period = 10000 - 1;  TimHandle.Init.Prescaler = uwPrescalerValue;  TimHandle.Init.ClockDivision = 0;  TimHandle.Init.CounterMode = TIM_COUNTERMODE_UP;  HAL_TIM_Base_Init(&TimHandle);  /*##-2- Start the TIM Base generation in interrupt mode ####################*/  /* Start Channel1 */  HAL_TIM_Base_Start_IT(&TimHandle);	HAL_NVIC_EnableIRQ(TIM6_IRQn);}

int main(void){  /* USER CODE BEGIN 1 */  /* USER CODE END 1 */  /* MCU Configuration----------------------------------------------------------*/  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */  HAL_Init();  /* Configure the system clock */  SystemClock_Config();  /* Initialize all configured peripherals */  MX_GPIO_Init();  MX_DMA_Init();  MX_ADC1_Init();  MX_ADC2_Init();  MX_TIM1_Init();  MX_TIM2_Init();  MX_USART1_UART_Init();  /* USER CODE BEGIN 2 */  /* USER CODE END 2 */  /* Infinite loop */  /* USER CODE BEGIN WHILE */  HAL_TIM_Base_Start_IT(&htim1);  HAL_TIM_PWM_Start(&htim1,TIM_CHANNEL_1);  HAL_TIMEx_PWMN_Start(&htim1,TIM_CHANNEL_1);  HAL_TIM_PWM_Start(&htim1,TIM_CHANNEL_2);  HAL_TIMEx_PWMN_Start(&htim1,TIM_CHANNEL_2);  HAL_TIM_PWM_Start(&htim1,TIM_CHANNEL_3);  HAL_TIMEx_PWMN_Start(&htim1,TIM_CHANNEL_3);  HAL_TIM_Base_Start_IT(&htim2);  while (1)  {  /* USER CODE END WHILE */  /* USER CODE BEGIN 3 */  }  /* USER CODE END 3 */}

int main(void){  /* USER CODE BEGIN 1 */  /* USER CODE END 1 */  /* MCU Configuration----------------------------------------------------------*/  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */  HAL_Init();  /* Configure the system clock */  SystemClock_Config();  /* Initialize all configured peripherals */  MX_GPIO_Init();  MX_TIM1_Init();  HAL_TIM_Base_Start_IT(&htim1);  /* USER CODE BEGIN 2 */  /* USER CODE END 2 */  /* Infinite loop */  /* USER CODE BEGIN WHILE */  while (1)  {//	  uint32_t ticksPassed = 0;//	  if (GPIOA->IDR & 0x01) {//		  uint32_t ticksPassed = 0;//		  while (GPIOA->IDR & 0x01) {//			  ticksPassed++;//		  }//		  SysTick_Config(ticksPassed);//	  }//	  if (GPIOA->IDR & 0x01) {////	  }  /* USER CODE END WHILE *///	  GPIOE->ODR ^= 0x0000FF00;//	  int i = 0;//	  while (i < 1000000) {//		  i++;//	  }//	  HAL_GPIO_TogglePin(GPIOE, 0xFF00);//	  HAL_Delay(1000);  /* USER CODE BEGIN 3 */  }  /* USER CODE END 3 */}

static void acquisition_start(void){	HAL_DAC_Start_DMA(&hdac, DAC_CHANNEL_1, (uint32_t*)&wave_buff, WAVE_BUFF_LEN, DAC_ALIGN_12B_R);	HAL_ADC_Start_IT(&hadc2);	HAL_ADC_Start_DMA(&hadc1, (uint32_t*)&mic_buff, WAVE_BUFF_LEN);	HAL_TIM_Base_Start(&htim2);	HAL_TIM_Base_Start_IT(&htim3);}

/**  * @brief  This function configures the TIM6 as a time base source.   *         The time source is configured  to have 1ms time base with a dedicated   *         Tick interrupt priority.   * @note   This function is called  automatically at the beginning of program after  *         reset by HAL_Init() or at any time when clock is configured, by HAL_RCC_ClockConfig().   * @param  TickPriority: Tick interrupt priority.  * @retval HAL status  */HAL_StatusTypeDef HAL_InitTick (uint32_t TickPriority){  RCC_ClkInitTypeDef    sClokConfig;  uint32_t              uwTimclock, uwAPB1Prescaler = 0;  uint32_t              uwPrescalerValue = 0;  uint32_t              pFLatency;      /*Configure the TIM6 IRQ priority */  HAL_NVIC_SetPriority(TIM6_DAC_IRQn, TickPriority ,0);     /* Get clock configuration */  HAL_RCC_GetClockConfig(&sClokConfig, &pFLatency);    /* Get APB1 prescaler */  uwAPB1Prescaler = sClokConfig.APB1CLKDivider;    /* Compute TIM6 clock */  if (uwAPB1Prescaler == 0)   {    uwTimclock = HAL_RCC_GetPCLK1Freq();  }  else  {    uwTimclock = 2*HAL_RCC_GetPCLK1Freq();  }  /* Compute the prescaler value to have TIM6 counter clock equal to 1MHz */  uwPrescalerValue = (uint32_t) ((uwTimclock / 1000000) - 1);    /* Initialize TIM6 */  TimHandle.Instance = TIM6;      /* Initialize TIMx peripheral as follow:       + Period = [(TIM6CLK/1000) - 1]. to have a (1/1000) s time base.       + Prescaler = (uwTimclock/1000000 - 1) to have a 1MHz counter clock.       + ClockDivision = 0       + Counter direction = Up  */  TimHandle.Init.Period = (1000000 / 1000) - 1;  TimHandle.Init.Prescaler = uwPrescalerValue;  TimHandle.Init.ClockDivision = 0;  TimHandle.Init.CounterMode = TIM_COUNTERMODE_UP;  if(HAL_TIM_Base_Init(&TimHandle) != HAL_OK)  {    /* Initialization Error */    ErrorHandler();  }    /* Start the TIM time Base generation in interrupt mode */  if(HAL_TIM_Base_Start_IT(&TimHandle) != HAL_OK)  {    /* Starting Error */    ErrorHandler();  }     /* Return function status */  return HAL_OK;}

/**  * @brief  This function configures the TIM6 as a time base source.  *         The time source is configured  to have 1ms time base with a dedicated  *         Tick interrupt priority.  * @note   This function is called  automatically at the beginning of program after  *         reset by HAL_Init() or at any time when clock is configured, by HAL_RCC_ClockConfig().  * @param  TickPriority Tick interrupt priority.  * @retval HAL status  */HAL_StatusTypeDef HAL_InitTick (uint32_t TickPriority){  RCC_ClkInitTypeDef    clkconfig;  uint32_t              uwTimclock, uwAPB1Prescaler = 0U;  uint32_t              uwPrescalerValue = 0U;  uint32_t              pFLatency;  /*Configure the TIM6 IRQ priority */  HAL_NVIC_SetPriority(TIM6_DAC_IRQn, TickPriority ,0U);  /* Enable the TIM6 global Interrupt */  HAL_NVIC_EnableIRQ(TIM6_DAC_IRQn);  /* Enable TIM6 clock */  __HAL_RCC_TIM6_CLK_ENABLE();  /* Get clock configuration */  HAL_RCC_GetClockConfig(&clkconfig, &pFLatency);  /* Get APB1 prescaler */  uwAPB1Prescaler = clkconfig.APB1CLKDivider;  /* Compute TIM6 clock */  if (uwAPB1Prescaler == RCC_HCLK_DIV1)  {    uwTimclock = HAL_RCC_GetPCLK1Freq();  }  else  {    uwTimclock = 2*HAL_RCC_GetPCLK1Freq();  }  /* Compute the prescaler value to have TIM6 counter clock equal to 1MHz */  uwPrescalerValue = (uint32_t) ((uwTimclock / 1000000U) - 1U);  /* Initialize TIM6 */  TimHandle.Instance = TIM6;  /* Initialize TIMx peripheral as follow:   + Period = [(TIM6CLK/1000) - 1]. to have a (1/1000) s time base.   + Prescaler = (uwTimclock/1000000 - 1) to have a 1MHz counter clock.   + ClockDivision = 0   + Counter direction = Up   */  TimHandle.Init.Period = (1000000U / 1000U) - 1U;  TimHandle.Init.Prescaler = uwPrescalerValue;  TimHandle.Init.ClockDivision = 0;  TimHandle.Init.CounterMode = TIM_COUNTERMODE_UP;  TimHandle.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;  if(HAL_TIM_Base_Init(&TimHandle) == HAL_OK)  {    /* Start the TIM time Base generation in interrupt mode */    return HAL_TIM_Base_Start_IT(&TimHandle);  }  /* Return function status */  return HAL_ERROR;}

int main(void){	/* USER CODE BEGIN 1 */	/* USER CODE END 1 */	/* MCU Configuration----------------------------------------------------------*/	/* Reset of all peripherals, Initializes the Flash interface and the Systick. */	HAL_Init();	/* Configure the system clock */	SystemClock_Config();	/* Initialize all configured peripherals */	MX_GPIO_Init();	MX_DMA_Init();	MX_I2C3_Init();	MX_TIM1_Init();	MX_TIM2_Init();	MX_TIM3_Init();	MX_TIM4_Init();	MX_TIM5_Init();	MX_USART1_UART_Init();	MX_USART2_UART_Init();	MX_TIM11_Init();	/* USER CODE BEGIN 2 */	HAL_TIM_Base_Start_IT(&htim11); // 100 msec timer	initSonar( MAX_SONAR);	initSerOutput();	/* USER CODE END 2 */	/* Infinite loop */	/* USER CODE BEGIN WHILE */	while (1)	{		/* USER CODE END WHILE */		/* USER CODE BEGIN 3 */		// >>>>> Sonar reading		triggerSonar( COUPLE_0_2);		HAL_Delay(49);		triggerSonar( COUPLE_1_3);		HAL_Delay(49);		// <<<<< Sonar reading		// >>>>> Serial Output		convertMeasures();		sendMeasures();		// <<<<< Serial Output	}	/* USER CODE END 3 */}

void Timer2_Cmd( uint32_t cmd ){  if (cmd == ENABLE) {    HAL_TIM_Base_Start_IT(hTimer2.handle);  }  else {    HAL_TIM_Base_Stop_IT(hTimer2.handle);  }}

/**  * @brief  定时器初始化函数  * @param  None  * @retval None  */BOOLxMBPortTimersInit( USHORT usTim1Timerout50us ){    /*##-1- Configure the TIM peripheral #######################################*/    /* -----------------------------------------------------------------------      In this example TIM3 input clock (TIM3CLK)  is set to APB1 clock (PCLK1),      since APB1 prescaler is equal to 1.        TIM3CLK = PCLK1        PCLK1 = HCLK        => TIM3CLK = HCLK = SystemCoreClock      To get TIM3 counter clock at 10 KHz, the Prescaler is computed as following:      Prescaler = (TIM3CLK / TIM3 counter clock) - 1      Prescaler = (SystemCoreClock /10 KHz) - 1      Note:       SystemCoreClock variable holds HCLK frequency and is defined in system_stm32l1xx.c file.       Each time the core clock (HCLK) changes, user had to update SystemCoreClock       variable value. Otherwise, any configuration based on this variable will be incorrect.       This variable is updated in three ways:        1) by calling CMSIS function SystemCoreClockUpdate()        2) by calling HAL API function HAL_RCC_GetSysClockFreq()        3) each time HAL_RCC_ClockConfig() is called to configure the system clock frequency    ----------------------------------------------------------------------- */    /* Compute the prescaler value to have TIMx counter clock equal to 10000 Hz */    uwPrescalerValue = (uint32_t)(SystemCoreClock / 20000) - 1;    /* Set TIMx instance */    TimHandle.Instance = TIMx;    /* Initialize TIMx peripheral as follows:         + Period = 10000 - 1         + Prescaler = (SystemCoreClock/10000) - 1         + ClockDivision = 0         + Counter direction = Up    */    TimHandle.Init.Period            = (usTim1Timerout50us * 20) - 1;    TimHandle.Init.Prescaler         = uwPrescalerValue;    TimHandle.Init.ClockDivision     = 0;    TimHandle.Init.CounterMode       = TIM_COUNTERMODE_UP;    if (HAL_TIM_Base_Init(&TimHandle) != HAL_OK)    {        /* Initialization Error */        Error_Handler();    }    /*##-2- Start the TIM Base generation in interrupt mode ####################*/    /* Start Channel1 */    if (HAL_TIM_Base_Start_IT(&TimHandle) != HAL_OK)    {        /* Starting Error */        Error_Handler();    }		return TRUE;}

int main(void) {  HAL_Init();  Nucleo_BSP_Init();  MX_TIM3_Init();  HAL_TIM_Base_Start_IT(&htim3);  while (1);}

void hubInit(void) {	initIO();	calculatePeriod();	hubLUTInit();	initRows();	hubOrientation = HUB_ROTATE_0;	hubSetOrient(hubOrientation);	clearScreen();	//fillScreen(COLOR_RGB(255, 255, 255));	hubTestBmp();	screenRedraw();		// 100 Hz * 16 Phases  HUB_TIMER_CLK_ENABLE();  TIM_ClockConfigTypeDef sClockSourceConfig;  hubtim.Instance = HUB_TIMER;  hubtim.Init.Prescaler = HUB_PRESCALER - 1;  hubtim.Init.CounterMode = TIM_COUNTERMODE_UP;  hubtim.Init.Period = period0 - 1;  hubtim.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;  HAL_TIM_Base_Init(&hubtim);  sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;  HAL_TIM_ConfigClockSource(&hubtim, &sClockSourceConfig);	HAL_NVIC_SetPriorityGrouping(NVIC_PRIORITYGROUP_4);  HAL_NVIC_SetPriority(TIM1_BRK_TIM9_IRQn, 0, 0);  HAL_NVIC_EnableIRQ(TIM1_BRK_TIM9_IRQn);		HAL_TIM_Base_Start_IT(&hubtim);		// Timer 2 for NOE	HUB_TIMER2_CLK_ENABLE();  TIM_OC_InitTypeDef sConfigOC;  hubtim2.Instance = HUB_TIMER2;  hubtim2.Init.Prescaler = 0;  hubtim2.Init.CounterMode = TIM_COUNTERMODE_UP;  hubtim2.Init.Period = 0xffff;  hubtim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;  HAL_TIM_Base_Init(&hubtim2);  HAL_TIM_OC_Init(&hubtim2);  sConfigOC.OCMode = TIM_OCMODE_PWM1;  sConfigOC.Pulse = period2Min;  sConfigOC.OCPolarity = TIM_OCPOLARITY_LOW;  sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;  HAL_TIM_OC_ConfigChannel(&hubtim2, &sConfigOC, NOE_TIM_CHANNEL);	HAL_TIM_PWM_Start(&hubtim2, NOE_TIM_CHANNEL); }

/**  * @brief  Period elapsed callback in non blocking mode  * @param  htim : TIM handle  * @retval None  */void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim) {    __HAL_TIM_SET_COUNTER(htim, 0);    switch (KB_state) {    case BTN_Down:        if ((len_KB_str == 0) || (pKB_str == NULL)) {            HAL_TIM_Base_Stop_IT(htim);            return;        }        KB_state = BTN_Up;        char2KBID(*pKB_str);        SEGGER_RTT_printf(0, "USB send char %c /r/n" , *pKB_str);        pKB_str++;        len_KB_str--;        USBD_HID_SendReport(&USBD_Device, KB_USBBuf, HID_KB_SIZE);        __HAL_TIM_SET_COUNTER(&TimHandle, 0);        __HAL_TIM_SET_AUTORELOAD(&TimHandle, 200-1); // 200ms        HAL_TIM_Base_Start_IT(&TimHandle);        break;    case BTN_Up:        memset(KB_USBBuf, 0, 9);        KB_USBBuf[0] = 1;        USBD_HID_SendReport(&USBD_Device, KB_USBBuf, HID_KB_SIZE);        if (len_KB_str == 0) {            pKB_str = NULL;            HAL_TIM_Base_Stop_IT(htim);        } else {            KB_state = BTN_Down;            __HAL_TIM_SET_COUNTER(&TimHandle, 0);            __HAL_TIM_SET_AUTORELOAD(&TimHandle, 200-1); // 200ms            HAL_TIM_Base_Start_IT(&TimHandle);        }        break;    default:        pKB_str = NULL;        HAL_TIM_Base_Stop_IT(htim);        break;    }}

void CAM_init(){	/*	 * Initialize hardware	 */	CAM_GPIO_init();	CAM_TIM_init(SLOW);	CAM_ADC_init();	/*	 * Initial GPIO pins status	 */	RESET_high();	START_low();	LOAD_low();	SIN_low();	/*	 * Configure NVIC (interrupts)	 */	HAL_NVIC_SetPriority(ADC_IRQn, 0, 0);	HAL_NVIC_EnableIRQ(ADC_IRQn);	HAL_NVIC_SetPriority(TIM2_IRQn, 0, 1);	HAL_NVIC_EnableIRQ(TIM2_IRQn);	HAL_NVIC_SetPriority(EXTI1_IRQn, 3, 0);	HAL_NVIC_EnableIRQ(EXTI1_IRQn);	/*	 * Initialize library global variables	 */	imageCursor = 0;	flag_captureGoing = 0;	flag_captureEnd = 0;	clockPhase = 0;	acquiring = 0;	skip = PIXSKIP;	/*	 * Start ADC	 */	HAL_ADC_Start_IT(&AdcHandle);					// Providing ConvCplt Callback	/*	 * Start TIM Base and TIM PWM	 */	HAL_TIM_Base_Start_IT(&htim);					// Providing PeriodElapsed Callback	HAL_TIM_PWM_Start_IT(&htim, TIM_CHANNEL_2);	// Providing PulseFinished Callback}

void TimInit (void){  uint32_t __prescaler = (uint32_t) ((SystemCoreClock /2) / 1000) - 1;    TimHandle.Instance = TIM1;   TimHandle.Init.Period = 50 - 1;  TimHandle.Init.Prescaler = __prescaler;  TimHandle.Init.ClockDivision = 0;  TimHandle.Init.CounterMode = TIM_COUNTERMODE_UP;  if(HAL_TIM_Base_Init(&TimHandle) != HAL_OK)  {    Error_Handler();  }  	  if(HAL_TIM_Base_Start_IT(&TimHandle) != HAL_OK)  {    Error_Handler();  }		__prescaler = (uint32_t) ((SystemCoreClock /2) / 1000) - 1;    Tim2_Handle.Instance = TIM2;  Tim2_Handle.Init.Period = 1000 - 1;  Tim2_Handle.Init.Prescaler = __prescaler;  Tim2_Handle.Init.ClockDivision = 10;  Tim2_Handle.Init.CounterMode = TIM_COUNTERMODE_UP;  if(HAL_TIM_Base_Init(&Tim2_Handle) != HAL_OK)  {    Error_Handler();  }  if(HAL_TIM_Base_Start_IT(&Tim2_Handle) != HAL_OK)  {    Error_Handler();  }	HAL_NVIC_SetPriority(TIM1_UP_TIM10_IRQn, 0 ,1);  HAL_NVIC_EnableIRQ(TIM1_UP_TIM10_IRQn);	HAL_NVIC_SetPriority(TIM2_IRQn, 0 ,1);  HAL_NVIC_EnableIRQ(TIM2_IRQn);}

void vInitialiseTimerForIntQueueTest( void ){TIM_HandleTypeDef    xTimHandle;const uint32_t ulPrescale = 0; /* No prescale. */	/* Clock the utilised timers. */	__TIM2_CLK_ENABLE();	__TIM3_CLK_ENABLE();	__TIM4_CLK_ENABLE();	/* Configure TIM2 to generate an interrupt at the required frequency. */	xTimHandle.Instance = TIM2;	xTimHandle.Init.Period = ( SystemCoreClock / 2UL ) / ( tmrTIMER_2_FREQUENCY - 1 );	xTimHandle.Init.Prescaler = ulPrescale;	xTimHandle.Init.ClockDivision = 0;	xTimHandle.Init.CounterMode = TIM_COUNTERMODE_UP;	HAL_TIM_Base_Init( &xTimHandle );	HAL_TIM_Base_Start_IT( &xTimHandle );    /* Configure and enable TIM2 interrupt. */	NVIC_SetPriority( TIM2_IRQn, tmrLOWER_PRIORITY );    NVIC_ClearPendingIRQ( TIM2_IRQn );    NVIC_EnableIRQ( TIM2_IRQn );	/* Repeat for TIM3 and TIM4. */	xTimHandle.Instance = TIM3;	xTimHandle.Init.Period = ( SystemCoreClock / 2UL ) / ( tmrTIMER_3_FREQUENCY - 1 );	HAL_TIM_Base_Init( &xTimHandle );	HAL_TIM_Base_Start_IT( &xTimHandle );	NVIC_SetPriority( TIM3_IRQn, tmrMEDIUM_PRIORITY );    NVIC_ClearPendingIRQ( TIM3_IRQn );    NVIC_EnableIRQ( TIM3_IRQn );	xTimHandle.Instance = TIM4;	xTimHandle.Init.Period = ( SystemCoreClock / 2UL ) / ( tmrTIMER_4_FREQUENCY - 1 );	HAL_TIM_Base_Init( &xTimHandle );	HAL_TIM_Base_Start_IT( &xTimHandle );	NVIC_SetPriority( TIM4_IRQn, tmrHIGHER_PRIORITY );    NVIC_ClearPendingIRQ( TIM4_IRQn );    NVIC_EnableIRQ( TIM4_IRQn );}

void TIM3_Init(void){  /*##-1- Configure the TIM peripheral #######################################*/  /* -----------------------------------------------------------------------    In this example TIM3 input clock (TIM3CLK) is set to 2 * APB1 clock (PCLK1),    since APB1 prescaler is different from 1.      TIM3CLK = 2 * PCLK1      PCLK1 = HCLK / 4      => TIM3CLK = HCLK / 2 = SystemCoreClock /2    To get TIM3 counter clock at 10 KHz, the Prescaler is computed as following:    Prescaler = (TIM3CLK / TIM3 counter clock) - 1    Prescaler = ((SystemCoreClock /2) /10 KHz) - 1    Note:     SystemCoreClock variable holds HCLK frequency and is defined in system_stm32f4xx.c file.     Each time the core clock (HCLK) changes, user had to update SystemCoreClock     variable value. Otherwise, any configuration based on this variable will be incorrect.     This variable is updated in three ways:      1) by calling CMSIS function SystemCoreClockUpdate()      2) by calling HAL API function HAL_RCC_GetSysClockFreq()      3) each time HAL_RCC_ClockConfig() is called to configure the system clock frequency  ----------------------------------------------------------------------- */  /* Compute the prescaler value to have TIM3 counter clock equal to 10 KHz */  uwPrescalerValue = (uint32_t) ((SystemCoreClock /2) / 10000) - 1;  /* Set TIMx instance */  TimHandle3.Instance = TIM3;  /* Initialize TIM3 peripheral as follows:       + Period = 10000 - 1       + Prescaler = ((SystemCoreClock/2)/10000) - 1       + ClockDivision = 0       + Counter direction = Up  */  TimHandle3.Init.Period = 10000 - 1;  TimHandle3.Init.Prescaler = uwPrescalerValue;  TimHandle3.Init.ClockDivision = 0;  TimHandle3.Init.CounterMode = TIM_COUNTERMODE_UP;  TimHandle3.State = HAL_TIM_STATE_RESET;  if(HAL_TIM_Base_Init(&TimHandle3) != HAL_OK)  {    /* Initialization Error */  }  /*##-2- Start the TIM Base generation in interrupt mode ####################*/  /* Start Channel1 */  if(HAL_TIM_Base_Start_IT(&TimHandle3) != HAL_OK)  {    /* Starting Error */  }}

/**  * @brief  CDC_Itf_Init  *         Initializes the CDC media low layer  * @param  None  * @retval Result of the operation: USBD_OK if all operations are OK else USBD_FAIL  */static int8_t CDC_Itf_Init(void){#if 0  /*##-1- Configure the UART peripheral ######################################*/  /* Put the USART peripheral in the Asynchronous mode (UART Mode) */  /* USART configured as follow:      - Word Length = 8 Bits      - Stop Bit    = One Stop bit      - Parity      = No parity      - BaudRate    = 115200 baud      - Hardware flow control disabled (RTS and CTS signals) */  UartHandle.Instance          = USARTx;  UartHandle.Init.BaudRate     = 115200;  UartHandle.Init.WordLength   = UART_WORDLENGTH_8B;  UartHandle.Init.StopBits     = UART_STOPBITS_1;  UartHandle.Init.Parity       = UART_PARITY_NONE;  UartHandle.Init.HwFlowCtl    = UART_HWCONTROL_NONE;  UartHandle.Init.Mode         = UART_MODE_TX_RX;  UartHandle.Init.OverSampling = UART_OVERSAMPLING_16;      if(HAL_UART_Init(&UartHandle) != HAL_OK)  {    /* Initialization Error */    Error_Handler();  }    /*##-2- Put UART peripheral in IT reception process ########################*/  /* Any data received will be stored in "UserTxBuffer" buffer  */  if(HAL_UART_Receive_IT(&UartHandle, (uint8_t *)UserTxBuffer, 1) != HAL_OK)  {    /* Transfer error in reception process */    Error_Handler();  }  #endif  /*##-3- Configure the TIM Base generation  #################################*/  TIM_Config();    /*##-4- Start the TIM Base generation in interrupt mode ####################*/  /* Start Channel1 */  if(HAL_TIM_Base_Start_IT(&TimHandle) != HAL_OK)  {    /* Starting Error */    Error_Handler();  }    /*##-5- Set Application Buffers ############################################*/  USBD_CDC_SetTxBuffer(&USBD_Device, UserTxBuffer, 0);  USBD_CDC_SetRxBuffer(&USBD_Device, UserRxBuffer);    return (USBD_OK);}

void TIM4_init(void){__TIM4_CLK_ENABLE();		TIM_Handle2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV4; // 168 MHz / 4 = 42 MHz    TIM_Handle2.Init.Prescaler = 419; // 42 MHz / (419 + 1) = 100 KHz    TIM_Handle2.Init.Period = 999; // 100 KHz / (999 + 1) = 100 Hz    TIM_Handle2.Init.CounterMode = TIM_COUNTERMODE_UP;    TIM_Handle2.Instance = TIM4;   //Same timer whose clocks we enabled    HAL_TIM_Base_Init(&TIM_Handle2);     // Init timer    HAL_TIM_Base_Start_IT(&TIM_Handle2); // start timer interrupts    HAL_NVIC_SetPriority(TIM4_IRQn, 0, 1);    HAL_NVIC_EnableIRQ(TIM4_IRQn);}

/* Exported function, to start ExtCtrl */void vTaskExtCtrlStart(void){    GPIO_InitTypeDef  xGpioInitStruct;    /* Enable GPIO E */    __GPIOD_CLK_ENABLE();        /* Configure TIMX as a time source for external controls measurements      * Set prescaler to achieve clock equal to 100kHz (to measure time within     * 0.01ms range) */    __TIMX_CLK_ENABLE();    vHardwareTimerSetup(&xTimeBaseHandle, TIMX, 1000000, 100000);    /* Start timer */    if(HAL_TIM_Base_Init(&xTimeBaseHandle) != HAL_OK)    {        vErrorFatal(__LINE__, __FILE__, "prvTaskExtCtrl: Unable to init TIM1");    }    if(HAL_TIM_Base_Start_IT(&xTimeBaseHandle) != HAL_OK)    {        vErrorFatal(__LINE__, __FILE__, "prvTaskExtCtrl: Unable to start TIM1");    }        /* Configure GPIO E 0-2 as inputs with pulldown */    xGpioInitStruct.Pin = (GPIO_PIN_0 |GPIO_PIN_1 |GPIO_PIN_3);    xGpioInitStruct.Mode = GPIO_MODE_IT_RISING_FALLING;    xGpioInitStruct.Pull = GPIO_PULLDOWN;    xGpioInitStruct.Speed = GPIO_SPEED_HIGH;    HAL_GPIO_Init(GPIOD, &xGpioInitStruct);    /* Configure line interrupts */    HAL_NVIC_SetPriority(EXTI0_IRQn, 10, 10);    HAL_NVIC_EnableIRQ(EXTI0_IRQn);    HAL_NVIC_SetPriority(EXTI1_IRQn, 10, 10);    HAL_NVIC_EnableIRQ(EXTI1_IRQn);    HAL_NVIC_SetPriority(EXTI3_IRQn, 10, 10);    HAL_NVIC_EnableIRQ(EXTI3_IRQn);        /* Create data container and semaphore */    xExtCtrlSem = xSemaphoreCreateBinary();    xSemaphoreTake(xExtCtrlSem, 0);    xExtCtrl.pitch  = 0;    xExtCtrl.roll   = 0;    xExtCtrl.yaw    = 0;    xSemaphoreGive(xExtCtrlSem);    /* Create task and register CLI command */    if(xTaskCreate(prvTaskExtCtrl, "EXTCTRL", configMINIMAL_STACK_SIZE, NULL, 1, NULL) != pdPASS)        vErrorFatal(__LINE__, __FILE__, "prvTaskExtCtrl: Unable to start");    FreeRTOS_CLIRegisterCommand(&xTaskExtCtrlDebugCommand);}

/* initializes the CDC media low level layer */static int8_t CDC_Itf_Init(void){	TIM_Config();	if (HAL_TIM_Base_Start_IT(&TimHandle) != HAL_OK) {		Error_Handler();	}	USBD_CDC_SetTxBuffer(&USBD_Device, UserTxBuffer, 0);	USBD_CDC_SetRxBuffer(&USBD_Device, UserRxBuffer);	return USBD_OK;}

/* * this function initializes the timer for the encoder pins for both motors*/void MotionTimInit(TIM_HandleTypeDef *htim){	uint16_t psc				= MOTION_PSC,	 //freq = 1MHz			period				= MOTION_PERIOD; //freq = 1kHz -> every 1ms  change period to inc/dec the freq of motion												 //!!!!!!period max = 65500	htim->Instance				 = TIM5;	htim->Init.Period			 = period;	htim->Init.Prescaler		 = psc;	htim->Init.ClockDivision	 = TIM_CLOCKDIVISION_DIV1;	htim->Init.CounterMode		 = TIM_COUNTERMODE_UP;	htim->Init.RepetitionCounter = 0;	HAL_TIM_Base_Init(htim);	HAL_TIM_Base_Start_IT(htim);}

//------------------------------------------------------------------------------void timer_init(void){    __TIM2_CLK_ENABLE();    timer2Handle.Instance = TIM2;     timer2Handle.Init.Prescaler = 271;    timer2Handle.Init.CounterMode = TIM_COUNTERMODE_UP;    timer2Handle.Init.Period = 62499;    timer2Handle.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;    HAL_TIM_Base_Init(&timer2Handle);     // Init timer        HAL_TIM_Base_Start_IT(&timer2Handle); // start timer interrupts    HAL_NVIC_SetPriority(TIM2_IRQn, 0, 1);     HAL_NVIC_EnableIRQ(TIM2_IRQn);}

/**  * @brief  The application entry point.  * @retval int  */int main(void){  /* USER CODE BEGIN 1 */  /* USER CODE END 1 */  /* MCU Configuration--------------------------------------------------------*/  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */  HAL_Init();  /* USER CODE BEGIN Init */  /* USER CODE END Init */  /* Configure the system clock */  SystemClock_Config();  /* USER CODE BEGIN SysInit */  /* USER CODE END SysInit */  /* Initialize all configured peripherals */  MX_GPIO_Init();  MX_USART2_UART_Init();  MX_I2C1_Init();  MX_TIM2_Init();  /* USER CODE BEGIN 2 */  Display_Init();  CircularBuff_Init();  DisplayUpdater_Init();  HAL_TIM_Base_Start_IT(&htim2);      //start timer2 in interrupt mode.  /* USER CODE END 2 */  /* Infinite loop */  /* USER CODE BEGIN WHILE */  while (1)  {    /* USER CODE END WHILE */    /* USER CODE BEGIN 3 */	__WFI(); // CPU sleep  }  /* USER CODE END 3 */}