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

/* TIM3 init function */void MX_TIM3_Init(void){  TIM_ClockConfigTypeDef sClockSourceConfig;  TIM_MasterConfigTypeDef sMasterConfig;  TIM_OC_InitTypeDef sConfigOC;  htim3.Instance = TIM3;  htim3.Init.Prescaler = 0;  htim3.Init.CounterMode = TIM_COUNTERMODE_UP;  htim3.Init.Period = 0;  htim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;  HAL_TIM_Base_Init(&htim3);  sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;  HAL_TIM_ConfigClockSource(&htim3, &sClockSourceConfig);  HAL_TIM_PWM_Init(&htim3);  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;  HAL_TIMEx_MasterConfigSynchronization(&htim3, &sMasterConfig);  sConfigOC.OCMode = TIM_OCMODE_PWM1;  sConfigOC.Pulse = 0;  sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;  sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;  HAL_TIM_PWM_ConfigChannel(&htim3, &sConfigOC, TIM_CHANNEL_3);}

void MX_TIM1_Init(void) {  TIM_ClockConfigTypeDef sClockSourceConfig;  TIM_MasterConfigTypeDef sMasterConfig;  TIM_SlaveConfigTypeDef sSlaveConfig;  htim1.Instance = TIM1;  htim1.Init.Prescaler = 47999;  htim1.Init.CounterMode = TIM_COUNTERMODE_UP;  htim1.Init.Period = 249;  htim1.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;  htim1.Init.RepetitionCounter = 0;  HAL_TIM_Base_Init(&htim1);  sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;  HAL_TIM_ConfigClockSource(&htim1, &sClockSourceConfig);  sSlaveConfig.SlaveMode = TIM_SLAVEMODE_TRIGGER;  sSlaveConfig.InputTrigger = TIM_TS_TI1FP1;  sSlaveConfig.TriggerPolarity = TIM_TRIGGERPOLARITY_RISING;  sSlaveConfig.TriggerFilter = 15;  HAL_TIM_SlaveConfigSynchronization(&htim1, &sSlaveConfig);  sMasterConfig.MasterOutputTrigger = TIM_TRGO_UPDATE;  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_ENABLE;  HAL_TIMEx_MasterConfigSynchronization(&htim1, &sMasterConfig);}

/* TIM21 init function */void MX_TIM21_Init(void){  TIM_MasterConfigTypeDef sMasterConfig;  TIM_OC_InitTypeDef sConfigOC;  htim21.Instance = TIM21;  htim21.Init.Prescaler = 0;  htim21.Init.CounterMode = TIM_COUNTERMODE_UP;  htim21.Init.Period = TIM_PERIOD;  htim21.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;  HAL_TIM_PWM_Init(&htim21);  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;  HAL_TIMEx_MasterConfigSynchronization(&htim21, &sMasterConfig);  sConfigOC.OCMode = TIM_OCMODE_PWM1;  sConfigOC.Pulse = 500;  sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;  sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;  HAL_TIM_PWM_ConfigChannel(&htim21, &sConfigOC, TIM_CHANNEL_1);  HAL_TIM_PWM_ConfigChannel(&htim21, &sConfigOC, TIM_CHANNEL_2);}

/* TIM3 init function */void MX_TIM3_Init(void){  TIM_MasterConfigTypeDef sMasterConfig;  TIM_OC_InitTypeDef sConfigOC;		uint32_t uhPrescalerValue = (uint32_t) ((SystemCoreClock /2) / 1300) - 1;  htim3.Instance = TIM3;  htim3.Init.Prescaler = uhPrescalerValue;  htim3.Init.CounterMode = TIM_COUNTERMODE_UP;  htim3.Init.Period = PERIOD_VALUE;  htim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;  HAL_TIM_PWM_Init(&htim3);  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;  HAL_TIMEx_MasterConfigSynchronization(&htim3, &sMasterConfig);  sConfigOC.OCMode = TIM_OCMODE_PWM1;  sConfigOC.Pulse = PULSE1_VALUE;  sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;  sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;  HAL_TIM_PWM_ConfigChannel(&htim3, &sConfigOC, TIM_CHANNEL_1);  HAL_TIM_MspPostInit(&htim3);}

/* TIM5 init function */void MX_TIM5_Init(void){  TIM_MasterConfigTypeDef sMasterConfig;  TIM_IC_InitTypeDef sConfigIC;  TIM_OC_InitTypeDef sConfigOC;  htim5.Instance = TIM5;  htim5.Init.Prescaler = 0;  htim5.Init.CounterMode = TIM_COUNTERMODE_UP;  htim5.Init.Period = 8400000 * 5; // 500 ms  htim5.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;  HAL_TIM_IC_Init(&htim5);  HAL_TIM_PWM_Init(&htim5);  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;  HAL_TIMEx_MasterConfigSynchronization(&htim5, &sMasterConfig);  sConfigIC.ICPolarity = TIM_INPUTCHANNELPOLARITY_BOTHEDGE;  sConfigIC.ICSelection = TIM_ICSELECTION_DIRECTTI;  sConfigIC.ICPrescaler = TIM_ICPSC_DIV1;  sConfigIC.ICFilter = 0;  HAL_TIM_IC_ConfigChannel(&htim5, &sConfigIC, TIM_CHANNEL_1);  sConfigOC.OCMode = TIM_OCMODE_PWM1;  sConfigOC.Pulse = 840;  sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;  sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;  HAL_TIM_PWM_ConfigChannel(&htim5, &sConfigOC, TIM_CHANNEL_2);  HAL_TIM_MspPostInit(&htim5);}

/* TIM4 init function */void MX_TIM4_Init(void){  TIM_SlaveConfigTypeDef sSlaveConfig;  TIM_MasterConfigTypeDef sMasterConfig;  TIM_OC_InitTypeDef sConfigOC;  htim4.Instance = TIM4;  htim4.Init.Prescaler = 0;  htim4.Init.CounterMode = TIM_COUNTERMODE_UP;  htim4.Init.Period = 0;  htim4.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;  HAL_TIM_Base_Init(&htim4);  HAL_TIM_PWM_Init(&htim4);  HAL_TIM_OnePulse_Init(&htim4, TIM_OPMODE_SINGLE);  sSlaveConfig.SlaveMode = TIM_SLAVEMODE_EXTERNAL1;  sSlaveConfig.InputTrigger = TIM_TS_ITR0;  HAL_TIM_SlaveConfigSynchronization(&htim4, &sSlaveConfig);  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;  HAL_TIMEx_MasterConfigSynchronization(&htim4, &sMasterConfig);  sConfigOC.OCMode = TIM_OCMODE_PWM1;  sConfigOC.Pulse = 0;  sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;  sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;  HAL_TIM_PWM_ConfigChannel(&htim4, &sConfigOC, TIM_CHANNEL_1);  HAL_TIM_MspPostInit(&htim4);}

/**  * @brief  Start audio recording  * @param  pbuf Main buffer pointer for the recorded data storing    * @param  size Current size of the recorded buffer  * @retval AUDIO_OK if correct communication, else wrong communication  */uint8_t BSP_AUDIO_IN_Record(uint16_t* pbuf, uint32_t size){  uint32_t                ret = AUDIO_OK;  TIM_MasterConfigTypeDef master_config = {0};  if (HAL_ADC_Start_DMA(&hAudioInAdc, (uint32_t*)pbuf, size) == HAL_OK)  {    master_config.MasterOutputTrigger = TIM_TRGO_UPDATE;    master_config.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;        HAL_TIMEx_MasterConfigSynchronization(&hAudioInTim3, &master_config);        /* Start the time base triggering the ADC */    if (HAL_TIM_Base_Start(&hAudioInTim3) != HAL_OK)    {      ret = AUDIO_ERROR;    }  }  else  {    ret = AUDIO_ERROR;  }    return ret;}

/* TIM4 init function */void MX_TIM4_Init(void){  TIM_ClockConfigTypeDef sClockSourceConfig;  TIM_MasterConfigTypeDef sMasterConfig;  htim4.Instance = TIM4;  htim4.Init.Prescaler = 32000;  htim4.Init.CounterMode = TIM_COUNTERMODE_UP;  htim4.Init.Period = 1000;  htim4.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;  if (HAL_TIM_Base_Init(&htim4) != HAL_OK)  {    Error_Handler();  }  sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;  if (HAL_TIM_ConfigClockSource(&htim4, &sClockSourceConfig) != HAL_OK)  {    Error_Handler();  }  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;  if (HAL_TIMEx_MasterConfigSynchronization(&htim4, &sMasterConfig) != HAL_OK)  {    Error_Handler();  }}

/**  * @brief  TIM6 Configuration  * @note   TIM6 configuration is based on APB1 frequency  * @note   TIM6 Update event occurs each TIM6CLK/256  * @param  None  * @retval None  */void TIM6_Config(void){  static TIM_HandleTypeDef  htim;  TIM_MasterConfigTypeDef sMasterConfig;  /*##-1- Configure the TIM peripheral #######################################*/  /* Time base configuration */  htim.Instance = TIM6;  htim.Init.Period            = 0x7FF;  htim.Init.Prescaler         = 0;  htim.Init.ClockDivision     = 0;  htim.Init.CounterMode       = TIM_COUNTERMODE_UP;  htim.Init.RepetitionCounter = 0;  HAL_TIM_Base_Init(&htim);  /* TIM6 TRGO selection */  sMasterConfig.MasterOutputTrigger = TIM_TRGO_UPDATE;  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;  HAL_TIMEx_MasterConfigSynchronization(&htim, &sMasterConfig);  /*##-2- Enable TIM peripheral counter ######################################*/  HAL_TIM_Base_Start(&htim);}

/**  * @brief  TIM configuration  * @param  None  * @retval None  */static void TIM_Config(void){  TIM_MasterConfigTypeDef sMasterConfig;      /* Time Base configuration */  htim.Instance = TIMx;    htim.Init.Period = 0x3C;            htim.Init.Prescaler = 0;         htim.Init.ClockDivision = 0;      htim.Init.CounterMode = TIM_COUNTERMODE_UP;  htim.Init.RepetitionCounter = 0x0;    if(HAL_TIM_Base_Init(&htim) != HAL_OK)  {    /* TIM8 Initialization Error */    Error_Handler();  }     /* TIM8 TRGO selection */  sMasterConfig.MasterOutputTrigger = TIM_TRGO_UPDATE;  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;      if(HAL_TIMEx_MasterConfigSynchronization(&htim, &sMasterConfig) != HAL_OK)  {    /* TIM8 TRGO selection Error */    Error_Handler();  }}

/* TIM3 init function */void SC_TIM3_Init(SERVO_CONTROLLER_Frequency frequency){  TIM_ClockConfigTypeDef sClockSourceConfig;  TIM_MasterConfigTypeDef sMasterConfig;  TIM_OC_InitTypeDef sConfigOC;  htim3.Instance = TIM3;  htim3.Init.Prescaler = CORE_FCLK / TIM_FCLK - 1;  htim3.Init.CounterMode = TIM_COUNTERMODE_UP;  htim3.Init.Period = (uint16_t)(TIM_FCLK / frequency);   //should not exceed 0xFFFF  htim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;  HAL_TIM_Base_Init(&htim3);  sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;  HAL_TIM_ConfigClockSource(&htim3, &sClockSourceConfig);  HAL_TIM_PWM_Init(&htim3);  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;  HAL_TIMEx_MasterConfigSynchronization(&htim3, &sMasterConfig);  sConfigOC.OCMode = TIM_OCMODE_PWM1;  sConfigOC.Pulse = 0;  sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;  sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;  HAL_TIM_PWM_ConfigChannel(&htim3, &sConfigOC, TIM_CHANNEL_1);  HAL_TIM_PWM_ConfigChannel(&htim3, &sConfigOC, TIM_CHANNEL_2);  HAL_TIM_PWM_ConfigChannel(&htim3, &sConfigOC, TIM_CHANNEL_3);}

/* TIM1 init function */void MX_TIM1_Init(void){  TIM_Encoder_InitTypeDef sConfig;  TIM_MasterConfigTypeDef sMasterConfig;  htim1.Instance = TIM1;  htim1.Init.Prescaler = 0;  htim1.Init.CounterMode = TIM_COUNTERMODE_UP;  htim1.Init.Period = 0;  htim1.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;  htim1.Init.RepetitionCounter = 0;  sConfig.EncoderMode = TIM_ENCODERMODE_TI1;  sConfig.IC1Polarity = TIM_ICPOLARITY_RISING;  sConfig.IC1Selection = TIM_ICSELECTION_DIRECTTI;  sConfig.IC1Prescaler = TIM_ICPSC_DIV1;  sConfig.IC1Filter = 0;  sConfig.IC2Polarity = TIM_ICPOLARITY_RISING;  sConfig.IC2Selection = TIM_ICSELECTION_DIRECTTI;  sConfig.IC2Prescaler = TIM_ICPSC_DIV1;  sConfig.IC2Filter = 0;  HAL_TIM_Encoder_Init(&htim1, &sConfig);  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;  HAL_TIMEx_MasterConfigSynchronization(&htim1, &sMasterConfig);}

STATIC uint32_t TIMx_Config(mp_obj_t timer) {    // TRGO selection to trigger DAC    TIM_HandleTypeDef *tim = pyb_timer_get_handle(timer);    TIM_MasterConfigTypeDef config;    config.MasterOutputTrigger = TIM_TRGO_UPDATE;    config.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;    HAL_TIMEx_MasterConfigSynchronization(tim, &config);    // work out the trigger channel (only certain ones are supported)    if (tim->Instance == TIM2) {        return DAC_TRIGGER_T2_TRGO;    } else if (tim->Instance == TIM4) {        return DAC_TRIGGER_T4_TRGO;    } else if (tim->Instance == TIM5) {        return DAC_TRIGGER_T5_TRGO;    #if defined(TIM6)    } else if (tim->Instance == TIM6) {        return DAC_TRIGGER_T6_TRGO;    #endif    #if defined(TIM7)    } else if (tim->Instance == TIM7) {        return DAC_TRIGGER_T7_TRGO;    #endif    #if defined(TIM8)    } else if (tim->Instance == TIM8) {        return DAC_TRIGGER_T8_TRGO;    #endif    } else {        nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, "Timer does not support DAC triggering"));    }}

/**  * @brief  TIM configuration  * @param  None  * @retval None  */static void TIM_Config(void){  TIM_MasterConfigTypeDef master_timer_config;  RCC_ClkInitTypeDef clk_init_struct = {0};       /* Temporary variable to retrieve RCC clock configuration */  uint32_t latency;                               /* Temporary variable to retrieve Flash Latency */    uint32_t timer_clock_frequency = 0;             /* Timer clock frequency */  uint32_t timer_prescaler = 0;                   /* Time base prescaler to have timebase aligned on minimum frequency possible */    /* Configuration of timer as time base:                                     */   /* Caution: Computation of frequency is done for a timer instance on APB1   */  /*          (clocked by PCLK1)                                              */  /* Timer period can be adjusted by modifying the following constants:       */  /* - TIMER_FREQUENCY: timer frequency (unit: Hz).                           */  /* - TIMER_FREQUENCY_RANGE_MIN: timer minimum frequency (unit: Hz).         */    /* Retrieve timer clock source frequency */  HAL_RCC_GetClockConfig(&clk_init_struct, &latency);  /* If APB1 prescaler is different of 1, timers have a factor x2 on their    */  /* clock source.                                                            */  if (clk_init_struct.APB1CLKDivider == RCC_HCLK_DIV1)  {    timer_clock_frequency = HAL_RCC_GetPCLK1Freq();  }  else  {    timer_clock_frequency = HAL_RCC_GetPCLK1Freq() *2;  }    /* Timer prescaler calculation */  /* (computation for timer 16 bits, additional + 1 to round the prescaler up) */  timer_prescaler = (timer_clock_frequency / (TIMER_PRESCALER_MAX_VALUE * TIMER_FREQUENCY_RANGE_MIN)) +1;    /* Set timer instance */  TimHandle.Instance = TIMx;    /* Configure timer parameters */  TimHandle.Init.Period            = ((timer_clock_frequency / (timer_prescaler * TIMER_FREQUENCY)) - 1);  TimHandle.Init.Prescaler         = (timer_prescaler - 1);  TimHandle.Init.ClockDivision     = TIM_CLOCKDIVISION_DIV1;  TimHandle.Init.CounterMode       = TIM_COUNTERMODE_UP;  TimHandle.Init.RepetitionCounter = 0x0;    if (HAL_TIM_Base_Init(&TimHandle) != HAL_OK)  {    /* Timer initialization Error */    Error_Handler();  }  /* Timer TRGO selection */  master_timer_config.MasterOutputTrigger = TIM_TRGO_UPDATE;  master_timer_config.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;  if (HAL_TIMEx_MasterConfigSynchronization(&TimHandle, &master_timer_config) != HAL_OK)  {    /* Timer TRGO selection Error */    Error_Handler();  }  }

/* TIM3 init function */void MX_TIM3_Init(void){  TIM_Encoder_InitTypeDef sConfig;  TIM_MasterConfigTypeDef sMasterConfig;  htim3.Instance = TIM3;  htim3.Init.Prescaler = 0;  htim3.Init.CounterMode = TIM_COUNTERMODE_UP;  htim3.Init.Period = 4*ENCODER_GAP-1;  htim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;  sConfig.EncoderMode = TIM_ENCODERMODE_TI12;  sConfig.IC1Polarity = TIM_ICPOLARITY_RISING;  sConfig.IC1Selection = TIM_ICSELECTION_DIRECTTI;  sConfig.IC1Prescaler = TIM_ICPSC_DIV1;  sConfig.IC1Filter = 8;  sConfig.IC2Polarity = TIM_ICPOLARITY_RISING;  sConfig.IC2Selection = TIM_ICSELECTION_DIRECTTI;  sConfig.IC2Prescaler = TIM_ICPSC_DIV1;  sConfig.IC2Filter = 8;  if (HAL_TIM_Encoder_Init(&htim3, &sConfig) != HAL_OK)  {    Error_Handler();  }  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;  if (HAL_TIMEx_MasterConfigSynchronization(&htim3, &sMasterConfig) != HAL_OK)  {    Error_Handler();  }}

/* TIM4 init function */void MX_TIM4_Init(void){  TIM_MasterConfigTypeDef sMasterConfig;  TIM_IC_InitTypeDef sConfigIC;  htim4.Instance = TIM4;  htim4.Init.Prescaler = 0;  htim4.Init.CounterMode = TIM_COUNTERMODE_UP;  htim4.Init.Period = 0;  htim4.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;  HAL_TIM_IC_Init(&htim4);  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;  HAL_TIMEx_MasterConfigSynchronization(&htim4, &sMasterConfig);  sConfigIC.ICPolarity = TIM_INPUTCHANNELPOLARITY_RISING;  sConfigIC.ICSelection = TIM_ICSELECTION_DIRECTTI;  sConfigIC.ICPrescaler = TIM_ICPSC_DIV1;  sConfigIC.ICFilter = 0;  HAL_TIM_IC_ConfigChannel(&htim4, &sConfigIC, TIM_CHANNEL_1);  HAL_TIM_IC_ConfigChannel(&htim4, &sConfigIC, TIM_CHANNEL_2);}

void CAM_TIM_init(CLOCKSPEED speed){	/*	 * Enable TIM2 clock	 */	__TIM2_CLK_ENABLE();	/* Variables */	uint32_t prescaler, period;	TIM_MasterConfigTypeDef sMasterConfig;	/*	 * Workout TIM parameters based on given clock speed	 */	if (speed == FAST) {		prescaler = 84;		period = 8;	} else {		prescaler = 84;		period = 12;	}	/*	 * Time Base configuration and initialization	 */	htim.Instance = TIM2;	htim.Init.Period = period - 1;	htim.Init.Prescaler = prescaler - 1;	htim.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;	htim.Init.CounterMode = TIM_COUNTERMODE_UP;	htim.Init.RepetitionCounter = 0x0;	HAL_TIM_Base_Init(&htim);	/*	 * Configure TIM2 to trig ADC using the TRG0 internal trigger	 */	sMasterConfig.MasterOutputTrigger = TIM_TRGO_UPDATE;	sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;	HAL_TIMEx_MasterConfigSynchronization(&htim, &sMasterConfig);	/*	 * Initialize PWM	 */	HAL_TIM_PWM_Init(&htim);	/*	 * Configure PWM channel	 */	TIM_OC_InitTypeDef sPWMConfig;	sPWMConfig.OCMode     = TIM_OCMODE_PWM1;	sPWMConfig.Pulse      = period / 2;	sPWMConfig.OCPolarity = TIM_OCPOLARITY_LOW;	sPWMConfig.OCFastMode = TIM_OCFAST_DISABLE;	HAL_TIM_PWM_ConfigChannel(&htim, &sPWMConfig, TIM_CHANNEL_2);}

/* TIM3 init function */void BSP_TIM3_Init(void){  TIM_MasterConfigTypeDef sMasterConfig;  TIM_OC_InitTypeDef sConfigOC;	__GPIOA_CLK_ENABLE();	__GPIOB_CLK_ENABLE();	  htim3.Instance = TIM3;  htim3.Init.Prescaler = 5-1;  htim3.Init.CounterMode = TIM_COUNTERMODE_DOWN;  htim3.Init.Period = 144*250-1;  htim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;  HAL_TIM_PWM_Init(&htim3);  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;  HAL_TIMEx_MasterConfigSynchronization(&htim3, &sMasterConfig);  HAL_TIMEx_MasterConfigSynchronization(&htim3, &sMasterConfig);  HAL_TIMEx_MasterConfigSynchronization(&htim3, &sMasterConfig);  HAL_TIMEx_MasterConfigSynchronization(&htim3, &sMasterConfig);  sConfigOC.OCMode = TIM_OCMODE_PWM1;  sConfigOC.Pulse = 10000;  sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;  sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;  HAL_TIM_PWM_ConfigChannel(&htim3, &sConfigOC, TIM_CHANNEL_1);  sConfigOC.Pulse = 10000;  HAL_TIM_PWM_ConfigChannel(&htim3, &sConfigOC, TIM_CHANNEL_2);  sConfigOC.Pulse = 10000;  HAL_TIM_PWM_ConfigChannel(&htim3, &sConfigOC, TIM_CHANNEL_3);  sConfigOC.Pulse = 10000;  HAL_TIM_PWM_ConfigChannel(&htim3, &sConfigOC, TIM_CHANNEL_4);		HAL_TIM_PWM_Start(&htim3,TIM_CHANNEL_1);	HAL_TIM_PWM_Start(&htim3,TIM_CHANNEL_2);	HAL_TIM_PWM_Start(&htim3,TIM_CHANNEL_3);	HAL_TIM_PWM_Start(&htim3,TIM_CHANNEL_4);}

/* TIM1 init function */void MX_TIM1_Init(void){  TIM_ClockConfigTypeDef sClockSourceConfig;  TIM_MasterConfigTypeDef sMasterConfig;  TIM_BreakDeadTimeConfigTypeDef sBreakDeadTimeConfig;  TIM_OC_InitTypeDef sConfigOC;  htim1.Instance = TIM1;  htim1.Init.Prescaler = 0;  htim1.Init.CounterMode = TIM_COUNTERMODE_UP;  htim1.Init.Period = 0;  htim1.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;  htim1.Init.RepetitionCounter = 0;  HAL_TIM_Base_Init(&htim1);  sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;  HAL_TIM_ConfigClockSource(&htim1, &sClockSourceConfig);  HAL_TIM_OC_Init(&htim1);  HAL_TIM_PWM_Init(&htim1);  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;  HAL_TIMEx_MasterConfigSynchronization(&htim1, &sMasterConfig);  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;  HAL_TIMEx_ConfigBreakDeadTime(&htim1, &sBreakDeadTimeConfig);  sConfigOC.OCMode = TIM_OCMODE_TIMING;  sConfigOC.Pulse = 0;  sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;  sConfigOC.OCNPolarity = TIM_OCNPOLARITY_HIGH;  sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;  sConfigOC.OCIdleState = TIM_OCIDLESTATE_RESET;  sConfigOC.OCNIdleState = TIM_OCNIDLESTATE_RESET;  HAL_TIM_OC_ConfigChannel(&htim1, &sConfigOC, TIM_CHANNEL_1);  HAL_TIM_OC_ConfigChannel(&htim1, &sConfigOC, TIM_CHANNEL_2);  HAL_TIM_OC_ConfigChannel(&htim1, &sConfigOC, TIM_CHANNEL_3);  sConfigOC.OCMode = TIM_OCMODE_PWM1;  HAL_TIM_PWM_ConfigChannel(&htim1, &sConfigOC, TIM_CHANNEL_4);  HAL_TIM_MspPostInit(&htim1);}

STATIC void TIM6_Config(uint freq) {    // Init TIM6 at the required frequency (in Hz)    timer_tim6_init(freq);    // TIM6 TRGO selection    TIM_MasterConfigTypeDef config;    config.MasterOutputTrigger = TIM_TRGO_UPDATE;    config.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;    HAL_TIMEx_MasterConfigSynchronization(&TIM6_Handle, &config);    // TIM6 start counter    HAL_TIM_Base_Start(&TIM6_Handle);}

/* TIM1 init function */void MX_TIM1_Init(void){  TIM_MasterConfigTypeDef sMasterConfig;  TIM_BreakDeadTimeConfigTypeDef sBreakDeadTimeConfig;  TIM_OC_InitTypeDef sConfigOC;  htim1.Instance = TIM1;  htim1.Init.Prescaler = 84;  htim1.Init.CounterMode = TIM_COUNTERMODE_UP;  htim1.Init.Period = 64535;  htim1.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;  htim1.Init.RepetitionCounter = 0;  if (HAL_TIM_PWM_Init(&htim1) != HAL_OK)  {    Error_Handler();  }  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;  if (HAL_TIMEx_MasterConfigSynchronization(&htim1, &sMasterConfig) != 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();  }  sConfigOC.OCMode = TIM_OCMODE_PWM2;  sConfigOC.Pulse = 37767;  sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;  sConfigOC.OCNPolarity = TIM_OCNPOLARITY_HIGH;  sConfigOC.OCFastMode = TIM_OCFAST_ENABLE;  sConfigOC.OCIdleState = TIM_OCIDLESTATE_RESET;  sConfigOC.OCNIdleState = TIM_OCNIDLESTATE_RESET;  if (HAL_TIM_PWM_ConfigChannel(&htim1, &sConfigOC, TIM_CHANNEL_1) != HAL_OK)  {    Error_Handler();  }  HAL_TIM_MspPostInit(&htim1);}

/**               * @brief  TIM3 Configuration  * @note   TIM3 configuration is based on APB1 frequency  * @note   TIM3 Update event occurs each SystemCoreClock/FREQ     * @param  None  * @retval None  */void TIM3_Config(void){  TIM_OC_InitTypeDef    TIMPWM_Config;  uint16_t PeriodValue = 0;  TIM_MasterConfigTypeDef sMasterConfig;    /*##-1- Configure the TIM peripheral #######################################*/  /* PWM configuration */  PWM_Handle.Instance = TIM3;    /* Calculate the period value */  PeriodValue = (uint16_t) ((SystemCoreClock) / FREQ);    PWM_Handle.Init.Period = PeriodValue;            PWM_Handle.Init.Prescaler = 0;         PWM_Handle.Init.ClockDivision = 0;      PWM_Handle.Init.CounterMode = TIM_COUNTERMODE_UP;   PWM_Handle.Init.RepetitionCounter = 0;  HAL_TIM_PWM_Init(&PWM_Handle);  /*##-2- Configure the PWM Output Capture ########################################*/    /* PWM Output Capture configuration of channel 3 */  TIMPWM_Config.OCMode  = TIM_OCMODE_PWM2;  TIMPWM_Config.Pulse = PeriodValue/2;  TIMPWM_Config.OCPolarity = TIM_OCPOLARITY_LOW;  TIMPWM_Config.OCFastMode = TIM_OCFAST_DISABLE;  TIMPWM_Config.OCIdleState = TIM_OCIDLESTATE_SET;  if(HAL_TIM_PWM_ConfigChannel(&PWM_Handle, &TIMPWM_Config, TIM_CHANNEL_3) != HAL_OK)  {    /* Initialization Error */    Error_Handler();  }  /*##-3- Configure the Trigger Output #######################################*/    /* TIM3 TRGO selection */  sMasterConfig.MasterOutputTrigger = TIM_TRGO_ENABLE;  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_ENABLE;  HAL_TIMEx_MasterConfigSynchronization(&PWM_Handle, &sMasterConfig);  /* Reset the flags */  PWM_Handle.Instance->SR = 0;  /*##-4- Enable TIM peripheral counter ######################################*/  /* Start the TIM Output Capture measurement in interrupt mode */  if(HAL_TIM_PWM_Start(&PWM_Handle, TIM_CHANNEL_3) != HAL_OK)  {    Error_Handler();  }}

/* TIM6 init function */void MX_TIM6_Init(void){  TIM_MasterConfigTypeDef sMasterConfig;  htim6.Instance = TIM6;  htim6.Init.Prescaler = 0;  htim6.Init.CounterMode = TIM_COUNTERMODE_UP;  htim6.Init.Period = 0;  HAL_TIM_Base_Init(&htim6);  sMasterConfig.MasterOutputTrigger = TIM_TRGO_UPDATE;  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;  HAL_TIMEx_MasterConfigSynchronization(&htim6, &sMasterConfig);}

/* TIM7 init function */void MX_TIM7_Init(void){  TIM_MasterConfigTypeDef sMasterConfig;  htim7.Instance = TIM7;  htim7.Init.Prescaler = 6000;  htim7.Init.CounterMode = TIM_COUNTERMODE_UP;  htim7.Init.Period = 10;  HAL_TIM_Base_Init(&htim7);  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;  HAL_TIMEx_MasterConfigSynchronization(&htim7, &sMasterConfig);}

/* TIM3 init function */void MX_TIM3_Init(void){  TIM_MasterConfigTypeDef sMasterConfig;  htim_scope.Instance = TIM3;  htim_scope.Init.Prescaler = 0;  htim_scope.Init.CounterMode = TIM_COUNTERMODE_UP;  htim_scope.Init.Period = 2048;  htim_scope.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;  HAL_TIM_Base_Init(&htim_scope);  sMasterConfig.MasterOutputTrigger = TIM_TRGO_UPDATE;  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;  HAL_TIMEx_MasterConfigSynchronization(&htim_scope, &sMasterConfig);}

/* TIM6 init function */void MX_TIM6_Init(void){  TIM_MasterConfigTypeDef sMasterConfig;  htim6.Instance = TIM6;  htim6.Init.Prescaler = 0;  htim6.Init.CounterMode = TIM_COUNTERMODE_UP;  htim6.Init.ClockDivision = TIM_CLOCKDIVISION_DIV2;  // wurde vergessen???  htim6.Init.Period = 100;  HAL_TIM_Base_Init(&htim6);  sMasterConfig.MasterOutputTrigger = TIM_TRGO_UPDATE;  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;  HAL_TIMEx_MasterConfigSynchronization(&htim6, &sMasterConfig);}

/* TIM4 init function */void MX_TIM4_Init(DeviceConfig *x){  HAL_TIM_PWM_Init(&(x->htim4));  HAL_TIM_OC_Init(&(x->htim4));  HAL_TIMEx_MasterConfigSynchronization(&(x->htim4),&(x->sTIMMasterConfig));  HAL_TIM_PWM_ConfigChannel(&(x->htim4), &(x->TIMConfigOC1), TIM_CHANNEL_1);  HAL_TIM_PWM_ConfigChannel(&(x->htim4), &(x->TIMConfigOC2), TIM_CHANNEL_2);  HAL_TIM_PWM_ConfigChannel(&(x->htim4), &(x->TIMConfigOC3), TIM_CHANNEL_3);  HAL_TIM_PWM_ConfigChannel(&(x->htim4), &(x->TIMConfigOC4), TIM_CHANNEL_4);  HAL_TIM_MspPostInit(&(x->htim4));}

/* TIM3 init function */void MX_TIM3_Init(void){  TIM_ClockConfigTypeDef sClockSourceConfig;  TIM_MasterConfigTypeDef sMasterConfig;/*  htim3.Instance = TIM3;  htim3.Init.Prescaler =10; //( SystemCoreClock /1000000) - 1;;  htim3.Init.CounterMode = TIM_COUNTERMODE_UP;  htim3.Init.Period = 10;  htim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;  HAL_TIM_Base_Init(&htim3);*/	//benceküdte:	// 12.5MHz period	htim3.Instance = TIM3;	htim3.Init.Prescaler = 1;// ( (32000000) / 60000 ) - 1;	// 1 us - 1 MHz	htim3.Init.CounterMode = TIM_COUNTERMODE_UP;	htim3.Init.Period = 200;	htim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;	HAL_TIM_Base_Init(&htim3);			/////////////////////////////////////////////////  sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;  HAL_TIM_ConfigClockSource(&htim3, &sClockSourceConfig);  HAL_TIM_PWM_Init(&htim3);  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;  HAL_TIMEx_MasterConfigSynchronization(&htim3, &sMasterConfig);  sConfigOC.OCMode = TIM_OCMODE_PWM1;  sConfigOC.Pulse = 0;  sConfigOC.OCPolarity = TIM_OCPOLARITY_LOW;  sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;  HAL_TIM_PWM_ConfigChannel(&htim3, &sConfigOC, TIM_CHANNEL_1);  HAL_TIM_PWM_ConfigChannel(&htim3, &sConfigOC, TIM_CHANNEL_3);  HAL_TIM_PWM_ConfigChannel(&htim3, &sConfigOC, TIM_CHANNEL_4);		  sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;	  HAL_TIM_PWM_ConfigChannel(&htim3, &sConfigOC, TIM_CHANNEL_2);}

void initializesync(void){		//Sets up TIM8 for sync pulse generation	/* TIM8 init function */  TIM_ClockConfigTypeDef sClockSourceConfig;  TIM_MasterConfigTypeDef sMasterConfig;  TIM_BreakDeadTimeConfigTypeDef sBreakDeadTimeConfig;  TIM_OC_InitTypeDef sConfigOC;  htim8.Instance = TIM8;  htim8.Init.Prescaler = 65535;  htim8.Init.CounterMode = TIM_COUNTERMODE_UP;  htim8.Init.Period = 160; //Sets the 30Hz pulse ~31.27Hz when = 80 //Right now ~16Hz  htim8.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;  htim8.Init.RepetitionCounter = 0;  HAL_TIM_Base_Init(&htim8);  sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;  HAL_TIM_ConfigClockSource(&htim8, &sClockSourceConfig);  HAL_TIM_OC_Init(&htim8);  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;  HAL_TIMEx_MasterConfigSynchronization(&htim8, &sMasterConfig);  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;  HAL_TIMEx_ConfigBreakDeadTime(&htim8, &sBreakDeadTimeConfig);  sConfigOC.OCMode = TIM_OCMODE_PWM1;  sConfigOC.Pulse = 10;   sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;  sConfigOC.OCNPolarity = TIM_OCNPOLARITY_LOW;  sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;  sConfigOC.OCIdleState = TIM_OCIDLESTATE_RESET;  sConfigOC.OCNIdleState = TIM_OCNIDLESTATE_RESET;  HAL_TIM_OC_ConfigChannel(&htim8, &sConfigOC, TIM_CHANNEL_1);  }

/* TIM7 init function */void kick_TIM7_timed_interrupt(uint32_t control_loop) {  TIM_MasterConfigTypeDef sMasterConfig;  htim7.Instance = TIM7;  htim7.Init.Prescaler = 32;  htim7.Init.CounterMode = TIM_COUNTERMODE_UP;  htim7.Init.Period = control_loop;  HAL_TIM_Base_Init(&htim7);  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;  HAL_TIMEx_MasterConfigSynchronization(&htim7, &sMasterConfig);  /* Kick timer interrupt for timed threads */  HAL_TIM_Base_Start_IT(&htim7);}