void TIM4_init() {
TIM_TimeBaseInitTypeDef TIM3_TimeBase;
NVIC_InitTypeDef NVIC_InitStructure;
//RCC_AHB1PeriphClockCmd(RCC_APB1Periph_TIM3,ENABLE);
__TIM4_CLK_ENABLE();
TIM_TimeBaseStructInit(&TIM3_TimeBase);
TIM3_TimeBase.TIM_Period = 65535;
TIM3_TimeBase.TIM_Prescaler = 2;
TIM3_TimeBase.TIM_ClockDivision = 0;
TIM3_TimeBase.TIM_CounterMode = TIM_CounterMode_Up;
TIM_TimeBaseInit(TIM4, &TIM3_TimeBase);
TIM_ITConfig(TIM4, TIM_IT_Update, ENABLE);
TIM_Cmd(TIM4, ENABLE);
NVIC_InitStructure.NVIC_IRQChannel = TIM4_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
//HAL_NVIC_SetPriority(TIM3_IRQn, 1, 1);
//HAL_NVIC_EnableIRQ(TIM3_IRQn);
}
/**
* @brief TIM MSP Initialization
* This function configures the hardware resources used in this example:
* - Peripheral's clock enable
* - Peripheral's GPIO Configuration
* @param htim: TIM handle pointer
* @retval None
*/
void HAL_TIM_PWM_MspInit(TIM_HandleTypeDef *htim)
{
GPIO_InitTypeDef GPIO_InitStruct;
/* Enable TIM1, TIM3 & TIM4 clocks */
__TIM2_CLK_ENABLE();
__TIM3_CLK_ENABLE();
__TIM4_CLK_ENABLE();
/* Enable GPIOA, GPIOB & GPIOC Clocks */
__GPIOA_CLK_ENABLE();
__GPIOB_CLK_ENABLE();
/* Configure PA.8 (TIM1_Channel1), PC.6 (TIM3_Channel1) and PB.6 (TIM4_Channel1),
in push-pull, alternate function mode */
GPIO_InitStruct.Pin = GPIO_PIN_0;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;
GPIO_InitStruct.Alternate = GPIO_AF1_TIM2;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
GPIO_InitStruct.Alternate = GPIO_AF2_TIM3;
GPIO_InitStruct.Pin = GPIO_PIN_4;
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
GPIO_InitStruct.Alternate = GPIO_AF2_TIM4;
GPIO_InitStruct.Pin = GPIO_PIN_6;
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
}
void pwmout_init(pwmout_t* obj, PinName pin) {
// Get the peripheral name from the pin and assign it to the object
obj->pwm = (PWMName)pinmap_peripheral(pin, PinMap_PWM);
if (obj->pwm == (PWMName)NC) {
error("PWM error: pinout mapping failed.");
}
// Enable TIM clock
if (obj->pwm == PWM_1) __TIM1_CLK_ENABLE();
if (obj->pwm == PWM_2) __TIM2_CLK_ENABLE();
if (obj->pwm == PWM_3) __TIM3_CLK_ENABLE();
if (obj->pwm == PWM_4) __TIM4_CLK_ENABLE();
if (obj->pwm == PWM_9) __TIM9_CLK_ENABLE();
if (obj->pwm == PWM_10) __TIM10_CLK_ENABLE();
if (obj->pwm == PWM_11) __TIM11_CLK_ENABLE();
// Configure GPIO
pinmap_pinout(pin, PinMap_PWM);
obj->pin = pin;
obj->period = 0;
obj->pulse = 0;
pwmout_period_us(obj, 20000); // 20 ms per default
}
void HAL_TIM_PWM_MspInit(TIM_HandleTypeDef* htim_pwm)
{
GPIO_InitTypeDef GPIO_InitStruct;
if(htim_pwm->Instance==TIM4)
{
/* USER CODE BEGIN TIM4_MspInit 0 */
/* USER CODE END TIM4_MspInit 0 */
/* Peripheral clock enable */
__TIM4_CLK_ENABLE();
/**TIM4 GPIO Configuration
PB8 ------> TIM4_CH3
PB9 ------> TIM4_CH4
*/
GPIO_InitStruct.Pin = GPIO_PIN_8|GPIO_PIN_9;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Speed = GPIO_SPEED_LOW;
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
/* USER CODE BEGIN TIM4_MspInit 1 */
/* USER CODE END TIM4_MspInit 1 */
}
}
void HAL_TIM_PWM_MspInit(TIM_HandleTypeDef* htim_pwm)
{
if(htim_pwm->Instance==TIM3)
{
/* USER CODE BEGIN TIM3_MspInit 0 */
/* USER CODE END TIM3_MspInit 0 */
/* Peripheral clock enable */
__TIM3_CLK_ENABLE();
/* USER CODE BEGIN TIM3_MspInit 1 */
/* USER CODE END TIM3_MspInit 1 */
}
else if(htim_pwm->Instance==TIM4)
{
/* USER CODE BEGIN TIM4_MspInit 0 */
/* USER CODE END TIM4_MspInit 0 */
/* Peripheral clock enable */
__TIM4_CLK_ENABLE();
/* USER CODE BEGIN TIM4_MspInit 1 */
/* USER CODE END TIM4_MspInit 1 */
}
}
/**
* @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);
}
void HAL_TIM_IC_MspInit(TIM_HandleTypeDef* htim_ic)
{
GPIO_InitTypeDef GPIO_InitStruct;
if(htim_ic->Instance==TIM3)
{
/* USER CODE BEGIN TIM3_MspInit 0 */
/* USER CODE END TIM3_MspInit 0 */
/* Peripheral clock enable */
__TIM3_CLK_ENABLE();
/**TIM3 GPIO Configuration
PA6 ------> TIM3_CH1
PA7 ------> TIM3_CH2
PB0 ------> TIM3_CH3
*/
GPIO_InitStruct.Pin = GPIO_PIN_6|GPIO_PIN_7;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_LOW;
GPIO_InitStruct.Alternate = GPIO_AF2_TIM3;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
GPIO_InitStruct.Pin = GPIO_PIN_0;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_LOW;
GPIO_InitStruct.Alternate = GPIO_AF2_TIM3;
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
/* USER CODE BEGIN TIM3_MspInit 1 */
/* USER CODE END TIM3_MspInit 1 */
}
else if(htim_ic->Instance==TIM4)
{
/* USER CODE BEGIN TIM4_MspInit 0 */
/* USER CODE END TIM4_MspInit 0 */
/* Peripheral clock enable */
__TIM4_CLK_ENABLE();
/**TIM4 GPIO Configuration
PD12 ------> TIM4_CH1
PD13 ------> TIM4_CH2
PD14 ------> TIM4_CH3
*/
GPIO_InitStruct.Pin = GPIO_PIN_12|GPIO_PIN_13|GPIO_PIN_14;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_LOW;
GPIO_InitStruct.Alternate = GPIO_AF2_TIM4;
HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
/* USER CODE BEGIN TIM4_MspInit 1 */
/* USER CODE END TIM4_MspInit 1 */
}
}
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);
}
void HAL_TIM_Base_MspInit(TIM_HandleTypeDef* htim_base)
{
GPIO_InitTypeDef GPIO_InitStruct;
if(htim_base->Instance==TIM3)
{
/* USER CODE BEGIN TIM3_MspInit 0 */
/* USER CODE END TIM3_MspInit 0 */
/* Peripheral clock enable */
__TIM3_CLK_ENABLE();
/**TIM3 GPIO Configuration
PB0 ------> TIM3_CH3
PB1 ------> TIM3_CH4
*/
GPIO_InitStruct.Pin = GPIO_PIN_0|GPIO_PIN_1;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_LOW;
GPIO_InitStruct.Alternate = GPIO_AF2_TIM3;
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
/* USER CODE BEGIN TIM3_MspInit 1 */
/* USER CODE END TIM3_MspInit 1 */
}
else if(htim_base->Instance==TIM4)
{
/* USER CODE BEGIN TIM4_MspInit 0 */
/* USER CODE END TIM4_MspInit 0 */
/* Peripheral clock enable */
__TIM4_CLK_ENABLE();
/**TIM4 GPIO Configuration
PB7 ------> TIM4_CH2
*/
GPIO_InitStruct.Pin = GPIO_PIN_7;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_LOW;
GPIO_InitStruct.Alternate = GPIO_AF2_TIM4;
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
/* USER CODE BEGIN TIM4_MspInit 1 */
/* USER CODE END TIM4_MspInit 1 */
}
}
void Tim4Init()
{
__TIM4_CLK_ENABLE();
Tim4Handle.Instance = TIM4;
Tim4Handle.Init.ClockDivision=TIM_CLOCKDIVISION_DIV1;
Tim4Handle.Init.CounterMode=TIM_COUNTERMODE_UP;
Tim4Handle.Init.Prescaler=41999;
//Tim4Handle.Init.Period=999;
Tim4Handle.Init.Period=1998;
HAL_NVIC_SetPriority(TIM4_IRQn,4,0);
HAL_NVIC_EnableIRQ(TIM4_IRQn);
HAL_TIM_Base_Init(&Tim4Handle);
HAL_TIM_Base_Start_IT(&Tim4Handle);
}
void threewire_tim_init(t_hydra_console *con)
{
mode_config_proto_t* proto = &con->mode->proto;
htim.Instance = TIM4;
htim.Init.Period = 42 - 1;
htim.Init.Prescaler = (THREEWIRE_MAX_FREQ/proto->config.rawwire.dev_speed) - 1;
htim.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
htim.Init.CounterMode = TIM_COUNTERMODE_UP;
HAL_TIM_Base_MspInit(&htim);
__TIM4_CLK_ENABLE();
HAL_TIM_Base_Init(&htim);
TIM4->SR &= ~TIM_SR_UIF; //clear overflow flag
HAL_TIM_Base_Start(&htim);
}
void HAL_TIM_PWM_MspInit(TIM_HandleTypeDef* htim_pwm)
{
GPIO_InitTypeDef GPIO_InitStruct;
if(htim_pwm->Instance==TIM3)
{
/* USER CODE BEGIN TIM3_MspInit 0 */
/* USER CODE END TIM3_MspInit 0 */
/* Peripheral clock enable */
__TIM3_CLK_ENABLE();
/**TIM3 GPIO Configuration
PB4 ------> TIM3_CH1
*/
GPIO_InitStruct.Pin = PWM_1_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Speed = GPIO_SPEED_LOW;
HAL_GPIO_Init(PWM_1_GPIO_Port, &GPIO_InitStruct);
__HAL_AFIO_REMAP_TIM3_PARTIAL();
/* USER CODE BEGIN TIM3_MspInit 1 */
/* USER CODE END TIM3_MspInit 1 */
}
else if(htim_pwm->Instance==TIM4)
{
/* USER CODE BEGIN TIM4_MspInit 0 */
/* USER CODE END TIM4_MspInit 0 */
/* Peripheral clock enable */
__TIM4_CLK_ENABLE();
/**TIM4 GPIO Configuration
PB9 ------> TIM4_CH4
*/
GPIO_InitStruct.Pin = PWM_2_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Speed = GPIO_SPEED_LOW;
HAL_GPIO_Init(PWM_2_GPIO_Port, &GPIO_InitStruct);
/* USER CODE BEGIN TIM4_MspInit 1 */
/* USER CODE END TIM4_MspInit 1 */
}
}
void initTimers()
{
TIM_HandleTypeDef TIM_Handle;
// 10 kHz timer.
#if defined STM32F1
__TIM8_CLK_ENABLE();
TIM_Handle.Instance = TIM8;
TIM_Handle.Init.Prescaler = (uint16_t)(HAL_RCC_GetPCLK2Freq() / 10000) - 1;
#elif defined STM32F2
__TIM4_CLK_ENABLE();
TIM_Handle.Instance = TIM4;
TIM_Handle.Init.Prescaler = (uint16_t)(HAL_RCC_GetPCLK2Freq() / 100000) - 1;
#elif defined STM32F4
__TIM3_CLK_ENABLE();
TIM_Handle.Instance = TIM3;
// TIM3 Clocked from SYSCLK = 168 MHz
TIM_Handle.Init.Prescaler = (uint16_t)(HAL_RCC_GetSysClockFreq() / 10000) - 1;
#endif
// 1 Hz blinking
TIM_Handle.Init.Period = 10000;
TIM_Handle.Init.ClockDivision = 0;
TIM_Handle.Init.CounterMode = TIM_COUNTERMODE_UP;
HAL_TIM_Base_Init(&TIM_Handle);
HAL_TIM_PWM_Init(&TIM_Handle);
TIM_OC_InitTypeDef TIM_OCConfig;
TIM_OCConfig.OCMode = TIM_OCMODE_PWM1;
// 5000 / 10000 = 50% duty cycle.
TIM_OCConfig.Pulse = 4999;
TIM_OCConfig.OCPolarity = TIM_OCPOLARITY_HIGH;
TIM_OCConfig.OCFastMode = TIM_OCFAST_DISABLE;
#if defined STM32F1
HAL_TIM_PWM_ConfigChannel(&TIM_Handle, &TIM_OCConfig, TIM_CHANNEL_3);
HAL_TIM_PWM_Start(&TIM_Handle, TIM_CHANNEL_3);
#elif defined STM32F2
HAL_TIM_PWM_ConfigChannel(&TIM_Handle, &TIM_OCConfig, TIM_CHANNEL_1);
HAL_TIM_PWM_Start(&TIM_Handle, TIM_CHANNEL_1);
#elif defined STM32F4
HAL_TIM_PWM_ConfigChannel(&TIM_Handle, &TIM_OCConfig, TIM_CHANNEL_1);
HAL_TIM_PWM_Start(&TIM_Handle, TIM_CHANNEL_1);
#endif
}
void encoder2_init(void) {
GPIO_InitTypeDef gpio_init;
gpio_init.Pin = GPIO_PIN_12;
gpio_init.Pull = GPIO_PULLUP;
gpio_init.Speed = GPIO_SPEED_HIGH;
gpio_init.Mode = GPIO_MODE_AF_PP;
gpio_init.Alternate = GPIO_AF2_TIM4;
__GPIOD_CLK_ENABLE();
HAL_GPIO_Init(GPIOD, &gpio_init);
gpio_init.Pin = GPIO_PIN_13;
HAL_GPIO_Init(GPIOD, &gpio_init);
__TIM4_CLK_ENABLE();
hTIM4.Instance = TIM4;
// hTIM4.Init.Prescaler = (SystemCoreClock/65535) - 1; // 1s
// hTIM4.Init.CounterMode = TIM_COUNTERMODE_UP;
// hTIM4.Init.ClockDivision = 0;
hTIM4.Init.Period = 65535;
//hTIM4.Channel = HAL_TIM_ACTIVE_CHANNEL_1 | HAL_TIM_ACTIVE_CHANNEL_2;
//HAL_TIM_Base_Init(&hTIM4);
TIM_Encoder_InitTypeDef enc_init;
enc_init.EncoderMode = TIM_ENCODERMODE_TI12;
enc_init.IC1Polarity = TIM_INPUTCHANNELPOLARITY_RISING;
enc_init.IC2Polarity = TIM_INPUTCHANNELPOLARITY_RISING;
enc_init.IC1Selection = TIM_ICSELECTION_DIRECTTI;
enc_init.IC2Selection = TIM_ICSELECTION_DIRECTTI;
enc_init.IC1Prescaler = TIM_ICPSC_DIV1;
enc_init.IC2Prescaler = TIM_ICPSC_DIV1;
enc_init.IC1Filter = 0;
enc_init.IC2Filter = 0;
HAL_TIM_Encoder_Init(&hTIM4, &enc_init);
__HAL_TIM_SetCounter(&hTIM4,0);
HAL_TIM_Encoder_Start(&hTIM4, TIM_CHANNEL_1 | TIM_CHANNEL_2);
}
void HAL_TIM_Base_MspInit(TIM_HandleTypeDef* htim_base)
{
if(htim_base->Instance==TIM4)
{
/* USER CODE BEGIN TIM4_MspInit 0 */
/* USER CODE END TIM4_MspInit 0 */
/* Peripheral clock enable */
__TIM4_CLK_ENABLE();
/* Peripheral interrupt init*/
HAL_NVIC_SetPriority(TIM4_IRQn, 0, 0);
HAL_NVIC_EnableIRQ(TIM4_IRQn);
/* USER CODE BEGIN TIM4_MspInit 1 */
/* USER CODE END TIM4_MspInit 1 */
}
}
/**
* @brief Initializes the TIM PWM MSP.
* @param htim: TIM handle
* @retval None
*/
void HAL_TIM_PWM_MspInit(TIM_HandleTypeDef *htim)
{
GPIO_InitTypeDef GPIO_InitStructure;
/* --------------------------- System Clocks Configuration -----------------*/
/* TIM4 clock enable */
__TIM4_CLK_ENABLE();
/* GPIOD clock enable */
__GPIOD_CLK_ENABLE();
/*-------------------------- GPIO Configuration ----------------------------*/
/* GPIOD Configuration: Pins 12, 13, 14 and 15 in output push-pull */
GPIO_InitStructure.Pin = GPIO_PIN_12 | GPIO_PIN_13 | GPIO_PIN_14 | GPIO_PIN_15;
GPIO_InitStructure.Mode = GPIO_MODE_AF_PP;
GPIO_InitStructure.Pull = GPIO_NOPULL;
GPIO_InitStructure.Speed = GPIO_SPEED_HIGH;
GPIO_InitStructure.Alternate = GPIO_AF2_TIM4;
HAL_GPIO_Init(GPIOD, &GPIO_InitStructure);
}
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 TIM_Timer4_Init()
{
__TIM4_CLK_ENABLE();
handleTimer4.Instance = TIM4; //Select timer
handleTimer4.Init.Prescaler = 100; //
handleTimer4.Init.CounterMode = TIM_COUNTERMODE_UP;
handleTimer4.Init.Period = 16800;
handleTimer4.Init.RepetitionCounter = 0;
handleTimer4.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
HAL_TIM_PWM_Init(&handleTimer4);
//HAL_TIM_PWM_Start_IT(&handleTimer4);
//HAL_TIM_Base_Init(&handleTimer4); // Init timer
//HAL_TIM_Base_Start_IT(&handleTimer4); // start timer interrupts
HAL_NVIC_SetPriority(TIM4_IRQn, 0, 1);
//HAL_NVIC_EnableIRQ(TIM4_IRQn);
/*
//handleTimer4.Channel = 1;
HAL_TIM_PWM_Init(&handleTimer4);
*/
//HAL_TIM_Base_Init(&handleTimer4); // Init timer
//HAL_TIM_Base_Start_IT(&handleTimer4); // start timer interrupts
/*
HAL_TIM_ConfigClockSource(&handleTimer4, &sClockSourceConfig);
TIM_ClockConfigTypeDef sClockSourceConfig;
sClockSourceConfig.ClockFilter = 0x0;
sClockSourceConfig.ClockPolarity = TIM_CLOCKPOLARITY_RISING;
sClockSourceConfig.ClockPrescaler = TIM_CLOCKPRESCALER_DIV8;
sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
TIM_MasterConfigTypeDef sMasterConfig;
TIM_IC_InitTypeDef sConfigOC;
*/
}
void HAL_TIM_Encoder_MspInit(TIM_HandleTypeDef* htim_encoder)
{
GPIO_InitTypeDef GPIO_InitStruct;
if(htim_encoder->Instance==TIM2)
{
/* USER CODE BEGIN TIM2_MspInit 0 */
/* USER CODE END TIM2_MspInit 0 */
/* Peripheral clock enable */
__TIM2_CLK_ENABLE();
/**TIM2 GPIO Configuration
PA15 ------> TIM2_CH1
PB3 ------> TIM2_CH2
*/
GPIO_InitStruct.Pin = GPIO_PIN_15;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Speed = GPIO_SPEED_MEDIUM;
GPIO_InitStruct.Alternate = GPIO_AF1_TIM2;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
GPIO_InitStruct.Pin = GPIO_PIN_3;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Speed = GPIO_SPEED_MEDIUM;
GPIO_InitStruct.Alternate = GPIO_AF1_TIM2;
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
/* Peripheral interrupt init*/
HAL_NVIC_SetPriority(TIM2_IRQn, 5, 0);
HAL_NVIC_EnableIRQ(TIM2_IRQn);
/* USER CODE BEGIN TIM2_MspInit 1 */
/* USER CODE END TIM2_MspInit 1 */
}
else if(htim_encoder->Instance==TIM4)
{
/* USER CODE BEGIN TIM4_MspInit 0 */
/* USER CODE END TIM4_MspInit 0 */
/* Peripheral clock enable */
__TIM4_CLK_ENABLE();
/**TIM4 GPIO Configuration
PB6 ------> TIM4_CH1
PB7 ------> TIM4_CH2
*/
GPIO_InitStruct.Pin = GPIO_PIN_6|GPIO_PIN_7;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Speed = GPIO_SPEED_MEDIUM;
GPIO_InitStruct.Alternate = GPIO_AF2_TIM4;
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
/* Peripheral interrupt init*/
HAL_NVIC_SetPriority(TIM4_IRQn, 5, 0);
HAL_NVIC_EnableIRQ(TIM4_IRQn);
/* USER CODE BEGIN TIM4_MspInit 1 */
/* USER CODE END TIM4_MspInit 1 */
}
}
void HAL_TIM_PWM_MspInit(TIM_HandleTypeDef* htim_pwm)
{
GPIO_InitTypeDef GPIO_InitStruct;
if(htim_pwm->Instance==TIM2)
{
/* Peripheral clock enable */
__TIM2_CLK_ENABLE();
/**TIM2 GPIO Configuration
PB10 ------> TIM2_CH3
PA15 ------> TIM2_CH1
*/
GPIO_InitStruct.Pin = GPIO_PIN_10;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_LOW;
GPIO_InitStruct.Alternate = GPIO_AF1_TIM2;
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
GPIO_InitStruct.Pin = GPIO_PIN_15;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_LOW;
GPIO_InitStruct.Alternate = GPIO_AF1_TIM2;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
}
else if(htim_pwm->Instance==TIM3)
{
/* Peripheral clock enable */
__TIM3_CLK_ENABLE();
/**TIM3 GPIO Configuration
PC6 ------> TIM3_CH1
PB5 ------> TIM3_CH2
*/
GPIO_InitStruct.Pin = GPIO_PIN_6;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_LOW;
GPIO_InitStruct.Alternate = GPIO_AF2_TIM3;
HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
GPIO_InitStruct.Pin = GPIO_PIN_5;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_LOW;
GPIO_InitStruct.Alternate = GPIO_AF2_TIM3;
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
}
else if(htim_pwm->Instance==TIM4)
{
/* Peripheral clock enable */
__TIM4_CLK_ENABLE();
/**TIM4 GPIO Configuration
PB7 ------> TIM4_CH2
*/
GPIO_InitStruct.Pin = GPIO_PIN_7;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_LOW;
GPIO_InitStruct.Alternate = GPIO_AF2_TIM4;
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
}
}
void HAL_TIM_Base_MspInit(TIM_HandleTypeDef* htim_base)
{
if(htim_base->Instance==TIM1)
{
/* USER CODE BEGIN TIM1_MspInit 0 */
/* USER CODE END TIM1_MspInit 0 */
/* Peripheral clock enable */
__TIM1_CLK_ENABLE();
/* Peripheral interrupt init*/
HAL_NVIC_SetPriority(TIM1_BRK_TIM9_IRQn, 5, 0);
HAL_NVIC_EnableIRQ(TIM1_BRK_TIM9_IRQn);
HAL_NVIC_SetPriority(TIM1_UP_TIM10_IRQn, 5, 0);
HAL_NVIC_EnableIRQ(TIM1_UP_TIM10_IRQn);
HAL_NVIC_SetPriority(TIM1_CC_IRQn, 5, 0);
HAL_NVIC_EnableIRQ(TIM1_CC_IRQn);
/* USER CODE BEGIN TIM1_MspInit 1 */
/* USER CODE END TIM1_MspInit 1 */
}
else if(htim_base->Instance==TIM4)
{
/* USER CODE BEGIN TIM4_MspInit 0 */
/* USER CODE END TIM4_MspInit 0 */
/* Peripheral clock enable */
__TIM4_CLK_ENABLE();
/* Peripheral interrupt init*/
HAL_NVIC_SetPriority(TIM4_IRQn, 5, 0);
HAL_NVIC_EnableIRQ(TIM4_IRQn);
/* USER CODE BEGIN TIM4_MspInit 1 */
/* USER CODE END TIM4_MspInit 1 */
}
else if(htim_base->Instance==TIM6)
{
/* USER CODE BEGIN TIM6_MspInit 0 */
/* USER CODE END TIM6_MspInit 0 */
/* Peripheral clock enable */
__TIM6_CLK_ENABLE();
/* Peripheral interrupt init*/
HAL_NVIC_SetPriority(TIM6_DAC_IRQn, 5, 0);
HAL_NVIC_EnableIRQ(TIM6_DAC_IRQn);
/* USER CODE BEGIN TIM6_MspInit 1 */
/* USER CODE END TIM6_MspInit 1 */
}
else if(htim_base->Instance==TIM7)
{
/* USER CODE BEGIN TIM7_MspInit 0 */
/* USER CODE END TIM7_MspInit 0 */
/* Peripheral clock enable */
__TIM7_CLK_ENABLE();
/* USER CODE BEGIN TIM7_MspInit 1 */
/* USER CODE END TIM7_MspInit 1 */
}
else if(htim_base->Instance==TIM9)
{
/* USER CODE BEGIN TIM9_MspInit 0 */
/* USER CODE END TIM9_MspInit 0 */
/* Peripheral clock enable */
__TIM9_CLK_ENABLE();
/* Peripheral interrupt init*/
HAL_NVIC_SetPriority(TIM1_BRK_TIM9_IRQn, 5, 0);
HAL_NVIC_EnableIRQ(TIM1_BRK_TIM9_IRQn);
/* USER CODE BEGIN TIM9_MspInit 1 */
/* USER CODE END TIM9_MspInit 1 */
}
else if(htim_base->Instance==TIM10)
{
/* USER CODE BEGIN TIM10_MspInit 0 */
/* USER CODE END TIM10_MspInit 0 */
/* Peripheral clock enable */
__TIM10_CLK_ENABLE();
/* Peripheral interrupt init*/
HAL_NVIC_SetPriority(TIM1_UP_TIM10_IRQn, 5, 0);
HAL_NVIC_EnableIRQ(TIM1_UP_TIM10_IRQn);
/* USER CODE BEGIN TIM10_MspInit 1 */
/* USER CODE END TIM10_MspInit 1 */
}
else if(htim_base->Instance==TIM11)
{
/* USER CODE BEGIN TIM11_MspInit 0 */
/* USER CODE END TIM11_MspInit 0 */
/* Peripheral clock enable */
__TIM11_CLK_ENABLE();
/* USER CODE BEGIN TIM11_MspInit 1 */
/* USER CODE END TIM11_MspInit 1 */
}
else if(htim_base->Instance==TIM13)
{
/* USER CODE BEGIN TIM13_MspInit 0 */
/* USER CODE END TIM13_MspInit 0 */
/* Peripheral clock enable */
__TIM13_CLK_ENABLE();
/* Peripheral interrupt init*/
HAL_NVIC_SetPriority(TIM8_UP_TIM13_IRQn, 5, 0);
HAL_NVIC_EnableIRQ(TIM8_UP_TIM13_IRQn);
/* USER CODE BEGIN TIM13_MspInit 1 */
/* USER CODE END TIM13_MspInit 1 */
}
}
void cHAL::Init(void) {
__HAL_RCC_GPIOA_CLK_ENABLE();
__HAL_RCC_GPIOB_CLK_ENABLE();
__HAL_RCC_GPIOC_CLK_ENABLE();
__HAL_RCC_CAN2_CLK_ENABLE();
__HAL_RCC_CAN1_CLK_ENABLE();
__HAL_RCC_USART3_CLK_ENABLE();
__HAL_RCC_UART4_CLK_ENABLE();
GPIO_InitTypeDef gi;
HAL_StatusTypeDef status;
//Enable UART
gi.Pin = GPIO_PIN_10 | GPIO_PIN_11; //C10=TX, C11=RX
gi.Mode = GPIO_MODE_AF_PP;
gi.Pull = GPIO_PULLUP;
gi.Speed = GPIO_SPEED_LOW;
gi.Alternate = GPIO_AF7_USART3;
HAL_GPIO_Init(GPIOC, &gi);
InitAndTestUSART();
//Onboard LEDs
gi.Mode = GPIO_MODE_OUTPUT_PP;
gi.Alternate = 0;
gi.Pull = GPIO_NOPULL;
gi.Speed = GPIO_SPEED_LOW;
gi.Pin = GPIO_PIN_7;
HAL_GPIO_Init(GPIOB, &gi);
LOGI(BSP::SUCCESSFUL_STRING, "GPIO for LED");
if(InitDWTCounter())
{
LOGI(BSP::SUCCESSFUL_STRING, "DWTCounter");
}
else
{
LOGE(NOT_SUCCESSFUL_STRING, "DWTCounter");
}
//MP3-Player
gi.Pin = GPIO_PIN_0 | GPIO_PIN_1; //A0=USART4_TX, A1=USART4_RX, Kerbe nach oben; ansicht von Pinseite, rechts von oben
//VCC, RX, TX, DACR, DACL, SPK1, GND, SPK2
//Also: PA0 --> RX
gi.Mode = GPIO_MODE_AF_PP;
gi.Pull = GPIO_PULLUP;
gi.Speed = GPIO_SPEED_LOW;
gi.Alternate = GPIO_AF8_UART4;
HAL_GPIO_Init(GPIOA, &gi);
BELL.Instance = UART4;
BELL.Init.BaudRate = 9600;
BELL.Init.WordLength = UART_WORDLENGTH_8B;
BELL.Init.StopBits = UART_STOPBITS_1;
BELL.Init.Parity = UART_PARITY_NONE;
BELL.Init.Mode = UART_MODE_TX_RX;
BELL.Init.HwFlowCtl = UART_HWCONTROL_NONE;
BELL.Init.OverSampling = UART_OVERSAMPLING_16;
HAL_UART_Init(&BSP::BELL);
LOGI(SUCCESSFUL_STRING, "UART4 for MP3-Module");
__I2C1_CLK_ENABLE();
__I2C2_CLK_ENABLE();
/*
PB08 ------> I2C1_SCL
PB09 ------> I2C1_SDA
*/
gi.Pin = GPIO_PIN_8 | GPIO_PIN_9;
gi.Mode = GPIO_MODE_AF_OD;
gi.Pull = GPIO_PULLUP;
gi.Speed = GPIO_SPEED_MEDIUM;
gi.Alternate = GPIO_AF4_I2C1;
HAL_GPIO_Init(GPIOB, &gi);
/*
PB10 ------> I2C2_SCL
PB11 ------> I2C2_SDA
*/
gi.Pin = GPIO_PIN_10 | GPIO_PIN_11;
gi.Mode = GPIO_MODE_AF_OD;
gi.Pull = GPIO_PULLUP;
gi.Speed = GPIO_SPEED_MEDIUM;
gi.Alternate = GPIO_AF4_I2C2;
HAL_GPIO_Init(GPIOB, &gi);
i2cbus[0].Instance = I2C1;
i2cbus[0].Init.ClockSpeed = 100000;
i2cbus[0].Init.DutyCycle = I2C_DUTYCYCLE_2;
i2cbus[0].Init.OwnAddress1 = 0;
i2cbus[0].Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;
i2cbus[0].Init.DualAddressMode = I2C_DUALADDRESS_DISABLED;
i2cbus[0].Init.OwnAddress2 = 0;
i2cbus[0].Init.GeneralCallMode = I2C_GENERALCALL_DISABLED;
i2cbus[0].Init.NoStretchMode = I2C_NOSTRETCH_DISABLED;
HAL_I2C_Init(&i2cbus[0]);
LOGI("I2C1 configured for onboard digital io");
i2cbus[1].Instance = I2C2;
i2cbus[1].Init.ClockSpeed = 100000;
i2cbus[1].Init.DutyCycle = I2C_DUTYCYCLE_2;
i2cbus[1].Init.OwnAddress1 = 0;
i2cbus[1].Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;
i2cbus[1].Init.DualAddressMode = I2C_DUALADDRESS_DISABLED;
i2cbus[1].Init.OwnAddress2 = 0;
i2cbus[1].Init.GeneralCallMode = I2C_GENERALCALL_DISABLED;
i2cbus[1].Init.NoStretchMode = I2C_NOSTRETCH_DISABLED;
HAL_I2C_Init(&BSP::i2c2);
LOGI(BSP::SUCCESSFUL_STRING, "I2C2 for 1wire and external");
if(drivers::cPCA9685::SoftwareReset(&BSP::i2c1))
{
LOGI(SUCCESSFUL_STRING, "i2c1 reset");
}
else
{
LOGE(NOT_SUCCESSFUL_STRING, "i2c1 reset");
}
if(pca9685_U7.Setup())//next to CPU, all A-Pins @ GND b01
{
LOGI(SUCCESSFUL_STRING, "pca9685_U7");
}
else
{
LOGE(NOT_SUCCESSFUL_STRING, "pca9685_U7");
}
if(pca9685_U9.Setup())
{
LOGI(SUCCESSFUL_STRING, "pca9685_U9");
}
else
{
LOGE(NOT_SUCCESSFUL_STRING, "pca9685_U9");
}
//Interrupt-Pins for PCA9555
gi.Pin = GPIO_PIN_0|GPIO_PIN_1;
gi.Mode = GPIO_MODE_INPUT;
gi.Pull = GPIO_PULLUP;
HAL_GPIO_Init(GPIOC, &gi);
if(pca9555_U19.Setup())
{
LOGI(BSP::SUCCESSFUL_STRING, "pca9555_U19");
}
else
{
LOGE(BSP::NOT_SUCCESSFUL_STRING, "pca9555_U19");
}
if(pca9555_U18.Setup())
{
LOGI(BSP::SUCCESSFUL_STRING, "pca9555_U18");
}
else
{
LOGE(BSP::NOT_SUCCESSFUL_STRING, "pca9555_U18");
}
uint16_t tmp = pca9555_U18.GetInput();
inputState[WORD_I2C] = (inputState[WORD_I2C] & 0xFFFF0000) + tmp;
tmp = pca9555_U19.GetInput();
inputState[WORD_I2C] = (inputState[WORD_I2C] & 0x0000FFFF) + (tmp << 16);
rcSwitch.enableReceive();
if(drivers::cPCA9685::SoftwareReset(&BSP::i2c2))
{
LOGI(SUCCESSFUL_STRING, "i2c2 reset");
}
else
{
LOGE(NOT_SUCCESSFUL_STRING, "i2c2 reset");
}
SearchI2C("I2C2", &i2c2);
Init1wire();
//Enable Rotary Encoder Switch Input
gi.Mode = GPIO_MODE_INPUT;
gi.Alternate = 0;
gi.Pull = GPIO_PULLUP;
gi.Speed = GPIO_SPEED_LOW;
gi.Pin = GPIO_PIN_13;
HAL_GPIO_Init(GPIOC, &gi);
LOGI(SUCCESSFUL_STRING, "GPIO for Rotary Encoder");
#ifdef DCF77
//DCF77
gi.Mode = GPIO_MODE_INPUT;
gi.Alternate=0;
gi.Pull=GPIO_PULLUP;
gi.Speed=GPIO_SPEED_FREQ_LOW;
gi.Pin=DCF77_PIN;
HAL_GPIO_Init(DCF77_PORT, &gi);
#endif
#endif
//=====PWM-Timers
//===============
//Overall GPIO-Settings
//All gpios enabled!
gi.Mode = GPIO_MODE_AF_PP;
gi.Pull = GPIO_NOPULL;
gi.Speed = GPIO_SPEED_HIGH;
//Overall base timer settings
TIM_HandleTypeDef TimHandle;
TimHandle.Init.Prescaler = 0;
TimHandle.Init.Period = UINT16_MAX;
TimHandle.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
TimHandle.Init.CounterMode = TIM_COUNTERMODE_UP;
//Overall OC-settings
TIM_OC_InitTypeDef sConfig;
sConfig.OCMode = TIM_OCMODE_PWM1;
sConfig.OCPolarity = TIM_OCPOLARITY_HIGH;
sConfig.OCNPolarity = TIM_OCNPOLARITY_HIGH;
sConfig.OCFastMode = TIM_OCFAST_DISABLE;
sConfig.OCIdleState = TIM_OCIDLESTATE_RESET;
sConfig.OCNIdleState = TIM_OCNIDLESTATE_RESET;
sConfig.Pulse = 0;
//===Slow Timers (84MHz) TIM4 and TIM12
//TIM1, TIM8 SystemCoreClock/1
//Others SystemCoreClock/2
//Prescaler (uint16_t) ((SystemCoreClock / 1 bzw 2) / TimerTickFrq) - 1;
//Einstellungen führen zu PWM-Frequenz von 116,5Hz (rechnerisch ermittelt, per LogicAnalyzer bestätigt)
#ifdef SENSACTHS07
TimHandle.Init.Prescaler = 10; //for 84MHz-Timers
__TIM12_CLK_ENABLE()
;
gi.Pin = GPIO_PIN_14 | GPIO_PIN_15;
gi.Alternate = GPIO_AF9_TIM12;
HAL_GPIO_Init(GPIOB, &gi);
TimHandle.Instance = TIM12;
HAL_TIM_PWM_Init(&TimHandle);
HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_1);
HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_2);
HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_1); //PB14 O1.1
HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_2); ///PB15 O1.2
CLEAR_BIT(TIM12->CCMR1, TIM_CCMR1_OC1PE);
CLEAR_BIT(TIM12->CCMR1, TIM_CCMR1_OC2PE);
LOGI(BSP::SUCCESSFUL_STRING, "TIM12");
//===Fast Timers (168MHz) TIM1 and TIM8
TimHandle.Init.Prescaler = 20;
__TIM8_CLK_ENABLE()
;
gi.Pin = GPIO_PIN_6 | GPIO_PIN_7 | GPIO_PIN_9;
gi.Alternate = GPIO_AF3_TIM8;
HAL_GPIO_Init(GPIOC, &gi);
TimHandle.Instance = TIM8;
HAL_TIM_PWM_Init(&TimHandle);
HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_1);
HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_2);
HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_4);
HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_1); //C6 O1.3
HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_2); //C7 O1.4
HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_4); //C9 O1.5
CLEAR_BIT(TIM8->CCMR1, TIM_CCMR1_OC1PE);
CLEAR_BIT(TIM8->CCMR1, TIM_CCMR1_OC2PE);
CLEAR_BIT(TIM8->CCMR2, TIM_CCMR2_OC4PE);
LOGI(SUCCESSFUL_STRING, "TIM8");
__TIM1_CLK_ENABLE()
;
gi.Pin = GPIO_PIN_8|GPIO_PIN_9|GPIO_PIN_10;
gi.Alternate = GPIO_AF1_TIM1;
HAL_GPIO_Init(GPIOA, &gi);
TimHandle.Instance = TIM1;
TIM_ClockConfigTypeDef sClockSourceConfig;
TIM_MasterConfigTypeDef sMasterConfig;
TIM_BreakDeadTimeConfigTypeDef sBreakDeadTimeConfig;
HAL_TIM_Base_Init(&TimHandle);
sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
HAL_TIM_ConfigClockSource(&TimHandle, &sClockSourceConfig);
HAL_TIM_PWM_Init(&TimHandle);
sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
HAL_TIMEx_MasterConfigSynchronization(&TimHandle, &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(&TimHandle, &sBreakDeadTimeConfig);
HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_1);
HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_2);
HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_3);
HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_1); //A8 O1.6
HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_2); //A9 O1.7
HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_3); //A10 O1.8
CLEAR_BIT(TIM1->CCMR1, TIM_CCMR1_OC1PE);
CLEAR_BIT(TIM1->CCMR1, TIM_CCMR1_OC2PE);
CLEAR_BIT(TIM1->CCMR2, TIM_CCMR2_OC3PE);
LOGI(SUCCESSFUL_STRING, "TIM1");
#endif
#ifdef SENSACTHS04
TimHandle.Init.Prescaler = 10; //for 84MHz-Timers
__TIM4_CLK_ENABLE();
gi.Pin = GPIO_PIN_6 | GPIO_PIN_7 | GPIO_PIN_8 | GPIO_PIN_9;
gi.Alternate = GPIO_AF2_TIM4;
HAL_GPIO_Init(GPIOB, &gi);
TimHandle.Instance = TIM4;
HAL_TIM_PWM_Init(&TimHandle);
HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_1);
HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_2);
HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_3);
HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_4);
HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_1); //PB6 o2.1
HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_2); //PB7 o2.2
HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_3); //PB8 o1.1
HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_4); //PB9 o1.2
TIM4->CCMR1 &= ~TIM_CCMR1_OC1PE;
TIM4->CCMR1 &= ~TIM_CCMR1_OC2PE;
TIM4->CCMR2 &= ~TIM_CCMR2_OC3PE;
TIM4->CCMR2 &= ~TIM_CCMR2_OC4PE;
LOGI(SUCCESSFUL_STRING, "TIM4");
__TIM12_CLK_ENABLE();
gi.Pin = GPIO_PIN_14 | GPIO_PIN_15;
gi.Alternate = GPIO_AF9_TIM12;
HAL_GPIO_Init(GPIOB, &gi);
TimHandle.Instance = TIM12;
HAL_TIM_PWM_Init(&TimHandle);
HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_1);
HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_2);
HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_1); //PB14 O7.2
HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_2); ///PB15 O4.1
TIM12->CCMR1 &= ~TIM_CCMR1_OC1PE;
TIM12->CCMR1 &= ~TIM_CCMR1_OC2PE;
LOGI(SUCCESSFUL_STRING, "TIM12");
//===Fast Timers (168MHz) TIM1 and TIM8
TimHandle.Init.Prescaler = 20;
__TIM1_CLK_ENABLE();
gi.Pin = GPIO_PIN_8;
gi.Alternate = GPIO_AF1_TIM1;
HAL_GPIO_Init(GPIOA, &gi);
TimHandle.Instance = TIM1;
HAL_TIM_PWM_Init(&TimHandle);
HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_1);
HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_3);
HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_1);
HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_3);
TIM1->CCMR1 &= ~TIM_CCMR1_OC1PE;
TIM1->CCMR2 &= ~TIM_CCMR2_OC3PE;
LOGI(SUCCESSFUL_STRING, "TIM1");
__TIM8_CLK_ENABLE();
gi.Pin = GPIO_PIN_6 | GPIO_PIN_7 | GPIO_PIN_9;
gi.Alternate = GPIO_AF3_TIM8;
HAL_GPIO_Init(GPIOC, &gi);
TimHandle.Instance = TIM8;
HAL_TIM_PWM_Init(&TimHandle);
HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_1);
HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_2);
HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_4);
HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_1);
HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_2);
HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_4);
TIM8->CCMR1 &= ~TIM_CCMR1_OC1PE;
TIM8->CCMR1 &= ~TIM_CCMR1_OC2PE;
TIM8->CCMR2 &= ~TIM_CCMR2_OC4PE;
LOGI(SUCCESSFUL_STRING, "TIM8");
#endif
//===SPI for Relais
//PA15=LATCH,PB3=CLK PB4=MISO, PB5=MOSI
//DRV8066 DIN=2, CLK(low@inak)=3, Latch@pos edge=4
__SPI3_CLK_ENABLE()
;
gi.Pin = GPIO_PIN_3 | GPIO_PIN_4 | GPIO_PIN_5;
gi.Mode = GPIO_MODE_AF_PP;
gi.Pull = GPIO_NOPULL;
gi.Speed = GPIO_SPEED_HIGH;
gi.Alternate = GPIO_AF6_SPI3;
HAL_GPIO_Init(GPIOB, &gi);
#ifdef SENSACTHS07
BSP::spi.Init.DataSize = SPI_DATASIZE_8BIT;
HAL_GPIO_WritePin(GPIOC, GPIO_PIN_14, GPIO_PIN_SET);
gi.Pin = GPIO_PIN_14;
gi.Mode = GPIO_MODE_OUTPUT_PP;
gi.Pull = GPIO_NOPULL;
gi.Speed = GPIO_SPEED_MEDIUM;
HAL_GPIO_Init(GPIOC, &gi);
#endif
#ifdef SENSACTHS04
BSP::spi.Init.DataSize = SPI_DATASIZE_16BIT;
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_15, GPIO_PIN_SET);
gi.Pin = GPIO_PIN_15;
gi.Mode = GPIO_MODE_OUTPUT_PP;
gi.Pull = GPIO_NOPULL;
gi.Speed = GPIO_SPEED_MEDIUM;
HAL_GPIO_Init(GPIOA, &gi);
#endif
BSP::spi.Instance = SPI3;
BSP::spi.Init.Mode = SPI_MODE_MASTER;
BSP::spi.Init.Direction = SPI_DIRECTION_2LINES;
BSP::spi.Init.CLKPolarity = SPI_POLARITY_LOW;
BSP::spi.Init.CLKPhase = SPI_PHASE_1EDGE;
BSP::spi.Init.NSS = SPI_NSS_SOFT;
BSP::spi.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_128;
BSP::spi.Init.FirstBit = SPI_FIRSTBIT_MSB;
BSP::spi.Init.TIMode = SPI_TIMODE_DISABLED;
BSP::spi.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLED;
BSP::spi.Init.CRCPolynomial = 1;
status = HAL_SPI_Init(&BSP::spi);
if (status != HAL_OK) {
LOGE("Unable to configure SPI for Relays");
while(1) {};
}
uint8_t tx[] = {0, 0, 0};
#ifdef SENSACTHS07
HAL_GPIO_WritePin(GPIOC, GPIO_PIN_14, GPIO_PIN_RESET);
HAL_SPI_Transmit(&BSP::spi, tx, 3, 100);
HAL_GPIO_WritePin(GPIOC, GPIO_PIN_14, GPIO_PIN_SET);
LOGI(SUCCESSFUL_STRING, "SPI for DRV8860");
#endif
#ifdef SENSACTHS04
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_15, GPIO_PIN_RESET);
if (HAL_SPI_Transmit(&BSP::spi, tx, 1, 100) == HAL_OK) {
LOGI(SUCCESSFUL_STRING, "SPI for DRV8860");
}
else
{
LOGE(NOT_SUCCESSFUL_STRING, "SPI for DRV8860");
}
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_15, GPIO_PIN_SET);
#endif
/**CAN2 GPIO Configuration
PB12 ------> CAN2_RX
PB13 ------> CAN2_TX
*/
gi.Pin = GPIO_PIN_12 | GPIO_PIN_13;
gi.Mode = GPIO_MODE_AF_PP;
gi.Pull = GPIO_NOPULL;
gi.Speed = GPIO_SPEED_LOW;
gi.Alternate = GPIO_AF9_CAN2;
HAL_GPIO_Init(GPIOB, &gi);
InitCAN();
return;
}
