/** \brief 设置加热PWM值
*
* \param index uint8_t 0-ex1; 1-bed; 2-ex2; 3-ex3
* \return uint16_t
*/
void setPWMHeaterValue(uint8_t index, uint8_t value)
{
TIM_OC_InitTypeDef TIM_InitStruct;
TIM_InitStruct.OCMode = TIM_OCMODE_PWM1;
TIM_InitStruct.OCPolarity = TIM_OCPOLARITY_HIGH;
TIM_InitStruct.OCFastMode = TIM_OCFAST_DISABLE;
TIM_InitStruct.Pulse = (uint32_t)value;
if (index == 0){
HAL_TIM_PWM_ConfigChannel(&TIM_PWM_HandleStruct, &TIM_InitStruct, TIM_CHANNEL_1);
}
#ifdef HEATBED_ENABLED
else if (index == 1){
HAL_TIM_PWM_ConfigChannel(&TIM_PWM_HandleStruct, &TIM_InitStruct, TIM_CHANNEL_2);
}
#endif
#ifdef EXTRUDER_2_ENABLED
else if (index == 2){
HAL_TIM_PWM_ConfigChannel(&TIM_PWM_HandleStruct, &TIM_InitStruct, TIM_CHANNEL_3);
}
#endif
#ifdef EXTRUDER_3_ENABLED
else if (index == 3){
HAL_TIM_PWM_ConfigChannel(&TIM_PWM_HandleStruct, &TIM_InitStruct, TIM_CHANNEL_4);
}
#endif
}
/**
* @brief 初始化舵机PWM.
* @param None
* @retval None
*/
void Steer_Pwm_Init(void){
//B0引脚定义
GPIO_InitTypeDef GPIO_InitStruct;
__HAL_RCC_GPIOB_CLK_ENABLE();
__HAL_RCC_TIM3_CLK_ENABLE();
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_AF2_TIM3;
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
//C7引脚定义
__HAL_RCC_GPIOC_CLK_ENABLE();
GPIO_InitStruct.Pin = GPIO_PIN_7;
GPIO_InitStruct.Alternate = GPIO_AF2_TIM3;
HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
//TIM3
TimHandleT3.Instance = TIM3;
TimHandleT3.Init.Period = 1000 - 1;;
TimHandleT3.Init.Prescaler = 1680-1;
TimHandleT3.Init.ClockDivision = 0;
TimHandleT3.Init.CounterMode = TIM_COUNTERMODE_UP;
HAL_TIM_PWM_Init(&TimHandleT3);
pwmConfig.OCMode=TIM_OCMODE_PWM1;
pwmConfig.Pulse=79;
HAL_TIM_PWM_ConfigChannel(&TimHandleT3, &pwmConfig, TIM_CHANNEL_2);
HAL_TIM_PWM_ConfigChannel(&TimHandleT3, &pwmConfig, TIM_CHANNEL_3);
HAL_TIM_PWM_Start(&TimHandleT3, TIM_CHANNEL_3);
HAL_TIM_PWM_Start(&TimHandleT3, TIM_CHANNEL_2);
}
/*******************************************************************************
* @brief : Initialise and configure PWM of a Timer
* @param : Aucun.
* @return : Rien.
******************************************************************************/
void LBF_PWM4_Ch34_Init ( void )
{
// Derived from Cube MX code and STM32L152 project example in Cube Library package
// To set Prescaler and Pulse values:
// Prescaler = (TIMxCLK / Prescaled clock) - 1
// ARR Period = (Prescaled clock / Target PWM Fqcy) - 1
// TIM2 Channely duty cycle = (TIMx_CCRy/ TIMx_ARR + 1)* 100%
TIM_OC_InitTypeDef sConfigOC; // or NEEDS TO BE GLOBAL ????
// First, confirgure the TIM (timer) peripheral
htim4.Instance = TIM4;
htim4.Init.Prescaler = (HAL_RCC_GetPCLK1Freq()/1000000) - 1; // so prescaled clock always 1MHz
// Caution: TIM4CLK is 1x PCLK2 if APB1 prescaler=1 else is 2x -- see STM32 UserMan
htim4.Init.CounterMode = TIM_COUNTERMODE_UP;
htim4.Init.Period = 0 ; // Initial Value, Target Value to be set by Application
htim4.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1; // ie no division
HAL_TIM_PWM_Init(&htim4);
// Second, configure the PWM channel
sConfigOC.OCMode = TIM_OCMODE_PWM1;
sConfigOC.Pulse = 0 ; // Initial Value, Target Value to be set by Application
sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
HAL_TIM_PWM_ConfigChannel(&htim4, &sConfigOC, TIM_CHANNEL_3);
sConfigOC.Pulse = 0 ; // Initial Value, Target Value to be set by Application
HAL_TIM_PWM_ConfigChannel(&htim4, &sConfigOC, TIM_CHANNEL_4);
}
/* 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);
}
/* TIM9 init function */
void MX_TIM9_Init(void)
{
TIM_ClockConfigTypeDef sClockSourceConfig;
TIM_OC_InitTypeDef sConfigOC;
htim9.Instance = TIM9;
htim9.Init.Prescaler = 167;
htim9.Init.CounterMode = TIM_COUNTERMODE_UP;
htim9.Init.Period = 19999;
htim9.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
HAL_TIM_Base_Init(&htim9);
sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
HAL_TIM_ConfigClockSource(&htim9, &sClockSourceConfig);
HAL_TIM_PWM_Init(&htim9);
sConfigOC.OCMode = TIM_OCMODE_PWM1;
sConfigOC.Pulse = 1500;
sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
HAL_TIM_PWM_ConfigChannel(&htim9, &sConfigOC, TIM_CHANNEL_1);
HAL_TIM_PWM_ConfigChannel(&htim9, &sConfigOC, TIM_CHANNEL_2);
}
/* TIM2 init function */
void MX_TIM2_Init(void)
{
TIM_ClockConfigTypeDef sClockSourceConfig;
TIM_MasterConfigTypeDef sMasterConfig;
TIM_OC_InitTypeDef sConfigOC;
htim2.Instance = TIM2;
htim2.Init.Prescaler = 0;
htim2.Init.CounterMode = TIM_COUNTERMODE_UP;
htim2.Init.Period = 47;
htim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
HAL_TIM_Base_Init(&htim2);
sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
HAL_TIM_ConfigClockSource(&htim2, &sClockSourceConfig);
HAL_TIM_PWM_Init(&htim2);
sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
HAL_TIMEx_MasterConfigSynchronization(&htim2, &sMasterConfig);
sConfigOC.OCMode = TIM_OCMODE_PWM1;
sConfigOC.Pulse = 0;
sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
HAL_TIM_PWM_ConfigChannel(&htim2, &sConfigOC, TIM_CHANNEL_1);
HAL_TIM_PWM_ConfigChannel(&htim2, &sConfigOC, TIM_CHANNEL_4);
HAL_TIM_MspPostInit(&htim2);
}
void pwmout_write(pwmout_t* obj, float value) {
TIM_OC_InitTypeDef sConfig;
TimHandle.Instance = (TIM_TypeDef *)(obj->pwm);
if (value < (float)0.0) {
value = 0.0;
} else if (value > (float)1.0) {
value = 1.0;
}
obj->pulse = (uint32_t)((float)obj->period * value);
sConfig.OCMode = TIM_OCMODE_PWM1;
sConfig.OCFastMode = TIM_OCFAST_DISABLE;
sConfig.OCPolarity = TIM_OCPOLARITY_HIGH;
sConfig.Pulse = obj->pulse;
if (obj->pin == PB_3) {
HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_2);
HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_2);
}
if ((obj->pin == PB_4) || (obj->pin == PB_6)) {
HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_1);
HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_1);
}
}
void Fan::setSpeed(uint8_t fanspeed)
{
if (fan_init != 1){
init();
fan_init = 1;
}
TIM_OC_InitTypeDef TIM_InitStruct;
TIM_InitStruct.OCMode = TIM_OCMODE_PWM1;
TIM_InitStruct.OCPolarity = TIM_OCPOLARITY_HIGH;
TIM_InitStruct.OCFastMode = TIM_OCFAST_DISABLE;
TIM_InitStruct.Pulse = (uint32_t)fanspeed * 257;
fan_speed = fanspeed;
if (fan_index == 0){
HAL_TIM_PWM_ConfigChannel(&TIM_PWM_HandleStruct, &TIM_InitStruct, TIM_CHANNEL_1);
HAL_TIM_PWM_Start(&TIM_PWM_HandleStruct, TIM_CHANNEL_1);
// HAL_TIM_PWM_ConfigChannel(&TIM_PWM_HandleStruct, &TIM_InitStruct, TIM_CHANNEL_3);
// HAL_TIM_PWM_Start(&TIM_PWM_HandleStruct, TIM_CHANNEL_3);
}
else if (fan_index == 1){
HAL_TIM_PWM_ConfigChannel(&TIM_PWM_HandleStruct, &TIM_InitStruct, TIM_CHANNEL_2);
HAL_TIM_PWM_Start(&TIM_PWM_HandleStruct, TIM_CHANNEL_2);
}
}
/* TIM4 init function */
void MX_TIM4_Init(void)
{
TIM_MasterConfigTypeDef sMasterConfig;
TIM_OC_InitTypeDef sConfigOC;
htim4.Instance = TIM4;
htim4.Init.Prescaler = 49;
htim4.Init.CounterMode = TIM_COUNTERMODE_UP;
htim4.Init.Period = 19999;
htim4.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
HAL_TIM_PWM_Init(&htim4);
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_PWM_ConfigChannel(&htim4, &sConfigOC, TIM_CHANNEL_2);
HAL_TIM_PWM_ConfigChannel(&htim4, &sConfigOC, TIM_CHANNEL_3);
HAL_TIM_PWM_ConfigChannel(&htim4, &sConfigOC, TIM_CHANNEL_4);
}
void motorsbsp_init(void)
{
MOTORS_CLK;
// Configura os GPIOs do drive dos motores como sa�das push/pull
GPIO_InitTypeDef GPIO_InitStructure;
for (int i = 0; i < N_PINS; i++)
{
GPIO_InitStructure.Pin = MOTORES_PIN[i];
GPIO_InitStructure.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStructure.Pull = GPIO_PULLUP;
GPIO_InitStructure.Speed = GPIO_SPEED_FAST;
HAL_GPIO_Init(MOTORES_PORT[i], &GPIO_InitStructure);
}
HAL_GPIO_WritePin(STBY_PORT, STBY_PIN, GPIO_PIN_SET);
// Configura os GPIOs de PWM como Alternate Function
GPIO_InitStructure.Pin = L_PWM_PIN;
GPIO_InitStructure.Mode = GPIO_MODE_AF_PP;
GPIO_InitStructure.Pull = GPIO_NOPULL;
GPIO_InitStructure.Speed = GPIO_SPEED_FAST;
GPIO_InitStructure.Alternate = PWM_AF_TIM;
HAL_GPIO_Init(L_PWM_PORT, &GPIO_InitStructure);
GPIO_InitStructure.Pin = R_PWM_PIN;
HAL_GPIO_Init(R_PWM_PORT, &GPIO_InitStructure);
// Time base PWM COnfig
// PWMf: f = [(168M / 2) / (PS + 1) ] / T
//TIM4 connected on APB1 and prescaller is 4 (the minimal!!) -> Pag. 67 - Reference Manual
/* (168M/4) */
// timer_tick_frequency = Timer_default_frequency / (prescaller_set + 1)
// ttf = 10500000
// PWM_frequency = (timer_tick_frequency / (TIM_Period + 1))
// PWMf = 10500
TimHandle.Instance = PWM_TIM;
TimHandle.Init.Period = PWM_PERIOD;
TimHandle.Init.Prescaler = PWM_PRESCALER;
TimHandle.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
TimHandle.Init.CounterMode = TIM_COUNTERMODE_UP;
HAL_TIM_PWM_Init(&TimHandle);
// Output Compare - PWM
// TIM_Period = timer_tick_frequency / PWM_frequency - 1
// TIM_Period = 10500000 / 10500 = 1000
TIM_OC_InitTypeDef sConfig;
sConfig.OCMode = TIM_OCMODE_PWM1;
sConfig.OCPolarity = TIM_OCPOLARITY_HIGH;
sConfig.OCFastMode = TIM_OCFAST_DISABLE;
sConfig.Pulse = 999;
HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, L_PWM_CHANNEL);
HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, R_PWM_CHANNEL);
HAL_TIM_PWM_Start(&TimHandle, L_PWM_CHANNEL);
HAL_TIM_PWM_Start(&TimHandle, R_PWM_CHANNEL);
}
void POLOLU_MOTOR_Run_InIn(DRIVER_InitTypeDef *driver, MOTOR_InitTypeDef *motor, uint32_t mode, uint32_t speed)
{
if (mode == MOTOR_IN_IN_BREAK)
{
POLOLU_MOTOR_Break_InIn(driver, motor);
return;
}
TIM_OC_InitTypeDef sConfigOC;
sConfigOC.OCMode = TIM_OCMODE_PWM1;
sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
sConfigOC.OCFastMode = TIM_OCFAST_ENABLE;
switch (mode)
{
case MOTOR_IN_IN_COAST:
HAL_TIM_PWM_Stop(motor->htimIn1, motor->ChannelIn1);
HAL_TIM_PWM_Stop(motor->htimIn2, motor->ChannelIn2);
motor->GPIOxIn1->BSRR = (uint32_t)(motor->PinIn1) << 16;
motor->GPIOxIn2->BSRR = (uint32_t)(motor->PinIn2) << 16;
break;
case MOTOR_IN_IN_REVERSE_COAST:
HAL_TIM_PWM_Stop(motor->htimIn1, motor->ChannelIn1);
motor->GPIOxIn1->BSRR = (uint32_t)(motor->PinIn1) << 16;
sConfigOC.Pulse = count_pulse(motor->htimIn2->Init.Period, speed);
HAL_TIM_PWM_ConfigChannel(motor->htimIn2, &sConfigOC, motor->ChannelIn2);
HAL_TIM_MspPostInit(motor->htimIn2);
HAL_TIM_PWM_Start(motor->htimIn2, motor->ChannelIn2);
break;
case MOTOR_IN_IN_FORWARD_COAST:
HAL_TIM_PWM_Stop(motor->htimIn2, motor->ChannelIn2);
motor->GPIOxIn2->BSRR = (uint32_t)(motor->PinIn2) << 16;
sConfigOC.Pulse = count_pulse(motor->htimIn1->Init.Period, speed);
HAL_TIM_MspPostInit(motor->htimIn1);
HAL_TIM_PWM_Start(motor->htimIn1, motor->ChannelIn2);
break;
case MOTOR_IN_IN_REVERSE:
HAL_TIM_PWM_Stop(motor->htimIn2, motor->ChannelIn2);
motor->GPIOxIn2->BSRR = motor->PinIn2;
sConfigOC.Pulse = count_pulse(motor->htimIn1->Init.Period, speed);
HAL_TIM_MspPostInit(motor->htimIn1);
HAL_TIM_PWM_Start(motor->htimIn1, motor->ChannelIn2);
break;
case MOTOR_IN_IN_FORWARD:
HAL_TIM_PWM_Stop(motor->htimIn1, motor->ChannelIn1);
motor->GPIOxIn1->BSRR = motor->PinIn1;
sConfigOC.Pulse = count_pulse(motor->htimIn2->Init.Period, speed);
HAL_TIM_PWM_ConfigChannel(motor->htimIn2, &sConfigOC, motor->ChannelIn2);
HAL_TIM_MspPostInit(motor->htimIn2);
HAL_TIM_PWM_Start(motor->htimIn2, motor->ChannelIn2);
}
}
/**********************************************************
* @brief Motors_stop
* @param Direction and speed of the motor (0 to 100)
* @retval None
**********************************************************/
void Motors_stop(void)
{
TIMER_OC_InitStruct.Pulse = 0;
HAL_TIM_PWM_ConfigChannel(&TIMER_InitStruct, &TIMER_OC_InitStruct, TIM_CHANNEL_3);
HAL_TIM_PWM_ConfigChannel(&TIMER_InitStruct, &TIMER_OC_InitStruct, TIM_CHANNEL_4);
HAL_TIM_PWM_Start(&TIMER_InitStruct,TIM_CHANNEL_3);
HAL_TIM_PWM_Start(&TIMER_InitStruct,TIM_CHANNEL_4);
s_motorRight.speed = 0;
s_motorLeft.speed = 0;
}
void pwm_set(PWM_NAME pwm, int32_T val)
{
int32_T period = 0;
/* 参数检查 */
if(pwm > PWM_MAX)
{
ERR_STR("参数错误.");
}
/* 限制val在有效值范围内 [0,period] */
period = pwm_get_period();
if(val < 0)
{
val = 0;
}
if(val > period)
{
val = period;
}
/* 修改占空比 */
s_sConfig.Pulse = val;
if (HAL_TIM_PWM_ConfigChannel(&s_tim_handle, &s_sConfig, g_pwm_ch_list[pwm].ch) != HAL_OK)
{
ERR_STR("执行失败.");
}
/* 启动PWM */
if (HAL_TIM_PWM_Start(&s_tim_handle, g_pwm_ch_list[pwm].ch) != HAL_OK)
{
ERR_STR("执行失败.");
}
}
void POLOLU_MOTOR_Run_EnablePhase(DRIVER_InitTypeDef *driver, MOTOR_InitTypeDef *motor, uint32_t mode, uint32_t speed)
{
switch (mode)
{
case MOTOR_ENABLE_PHASE_FORWARD:
motor->GPIOxIn1->BSRR = motor->PinIn1;
break;
case MOTOR_ENABLE_PHASE_REVERSE:
motor->GPIOxIn1->BSRR = (uint32_t)(motor->PinIn1) << 16;
break;
case MOTOR_ENABLE_PHASE_BREAK:
POLOLU_MOTOR_Break_EnablePhase(driver, motor);
return;
}
uint32_t pulse = count_pulse(motor->htimIn2->Init.Period, speed);
TIM_OC_InitTypeDef sConfigOC;
sConfigOC.OCMode = TIM_OCMODE_PWM1;
sConfigOC.Pulse = pulse;
sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
sConfigOC.OCFastMode = TIM_OCFAST_ENABLE;
HAL_TIM_PWM_ConfigChannel(motor->htimIn2, &sConfigOC, motor->ChannelIn2);
HAL_TIM_MspPostInit(motor->htimIn2);
HAL_TIM_PWM_Start(motor->htimIn2, motor->ChannelIn2);
}
/* TIM10 init function */
void MX_TIM10_Init(void)
{
TIM_OC_InitTypeDef sConfigOC;
htim10.Instance = TIM10;
htim10.Init.Prescaler = 0;
htim10.Init.CounterMode = TIM_COUNTERMODE_UP;
htim10.Init.Period = 0;
htim10.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
if (HAL_TIM_Base_Init(&htim10) != HAL_OK)
{
Error_Handler();
}
if (HAL_TIM_PWM_Init(&htim10) != HAL_OK)
{
Error_Handler();
}
sConfigOC.OCMode = TIM_OCMODE_PWM1;
sConfigOC.Pulse = 0;
sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
if (HAL_TIM_PWM_ConfigChannel(&htim10, &sConfigOC, TIM_CHANNEL_1) != HAL_OK)
{
Error_Handler();
}
HAL_TIM_MspPostInit(&htim10);
}
/* 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);
}
/* 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));
}
void updatePulseWidth(eTimer timer, uint32_t pulse, uint32_t channel)
{
TIM_OC_InitTypeDef outputChannelInit = {0,};
outputChannelInit.OCMode = TIM_OCMODE_PWM1;
outputChannelInit.Pulse = pulse;
outputChannelInit.OCPolarity = TIM_OCPOLARITY_HIGH;
outputChannelInit.OCFastMode = TIM_OCFAST_DISABLE;
outputChannelInit.OCIdleState = TIM_OCIDLESTATE_SET;
//HAL_TIM_PWM_Start_IT(&handleTimer4);
switch(timer)
{
case eTimer4:
HAL_TIM_PWM_ConfigChannel(&handleTimer4, &outputChannelInit, channel);
HAL_TIM_PWM_Start(&handleTimer4, channel);
break;
case eTimer1:
case eTimer2:
case eTimer3:
default:
break;
}
return;
}
/* 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);
}
void vHardwareTimerPwmSetup(
TIM_HandleTypeDef* xTimerHandle,
TIM_OC_InitTypeDef* xTimerPwmConfig,
uint8_t usChannel,
uint8_t usPolarity,
uint32_t ulPulseValue)
{
/* Configure PWM action */
xTimerPwmConfig->OCMode = TIM_OCMODE_PWM1;
xTimerPwmConfig->OCPolarity = usPolarity;
xTimerPwmConfig->OCFastMode = TIM_OCFAST_DISABLE;
xTimerPwmConfig->Pulse = ulPulseValue;
/* Configure PWM */
if(HAL_TIM_PWM_ConfigChannel(xTimerHandle, xTimerPwmConfig, usChannel) != HAL_OK)
{
/* Configuration Error */
vErrorFatal(__LINE__, __FILE__, "Unable to init PWM");
}
/* Start PWM generation */
if(HAL_TIM_PWM_Start(xTimerHandle, usChannel) != HAL_OK)
{
/* Configuration Error */
vErrorFatal(__LINE__, __FILE__, "Unable to init PWM");
}
}
/******************************************************//**
* @brief Initialises the step clock by setting
* corresponding GPIO, Timer, Pwm,...
* @param None
* @retval None
**********************************************************/
void BSP_MotorControlBoard_StepClockInit(void)
{
TIM_OC_InitTypeDef sConfigOC;
TIM_MasterConfigTypeDef sMasterConfig;
TIM_ClockConfigTypeDef sClockSourceConfig;
hTimStepClock.Instance = BSP_MOTOR_CONTROL_BOARD_TIMER_STEP_CLOCK;
hTimStepClock.Init.Prescaler = TIMER_PRESCALER -1;
hTimStepClock.Init.CounterMode = TIM_COUNTERMODE_UP;
hTimStepClock.Init.Period = 0;
hTimStepClock.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
HAL_TIM_PWM_Init(&hTimStepClock);
sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
HAL_TIM_ConfigClockSource(&hTimStepClock, &sClockSourceConfig);
sConfigOC.OCMode = TIM_OCMODE_PWM1;
sConfigOC.Pulse = 0;
sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
HAL_TIM_PWM_ConfigChannel(&hTimStepClock, &sConfigOC, BSP_MOTOR_CONTROL_BOARD_CHAN_TIMER_STEP_CLOCK);
sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
HAL_TIMEx_MasterConfigSynchronization(&hTimStepClock, &sMasterConfig);
}
void pwmout_write(pwmout_t* obj, float value)
{
TIM_OC_InitTypeDef sConfig;
int channel = 0;
TimHandle.Instance = (TIM_TypeDef *)(obj->pwm);
if (value < (float)0.0) {
value = 0.0;
} else if (value > (float)1.0) {
value = 1.0;
}
obj->pulse = (uint32_t)((float)obj->period * value);
// Configure channels
sConfig.OCMode = TIM_OCMODE_PWM1;
sConfig.Pulse = obj->pulse;
sConfig.OCPolarity = TIM_OCPOLARITY_HIGH;
sConfig.OCFastMode = TIM_OCFAST_ENABLE;
switch (obj->pin) {
// Channels 1
case PA_0:
case PA_5:
case PA_6:
case PA_15:
case PB_4:
case PC_6:
channel = TIM_CHANNEL_1;
break;
// Channels 2
case PA_1:
case PA_7:
case PB_3:
case PB_5:
case PC_7:
channel = TIM_CHANNEL_2;
break;
// Channels 3
case PA_2:
case PB_0:
case PB_10:
case PC_8:
channel = TIM_CHANNEL_3;
break;
// Channels 4
case PA_3:
case PB_1:
case PB_11:
case PC_9:
channel = TIM_CHANNEL_4;
break;
default:
return;
}
HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, channel);
HAL_TIM_PWM_Start(&TimHandle, channel);
}
void breathing_led_init()
{
TIM_OC_InitTypeDef pwmConfig;
GPIO_InitTypeDef GPIO_InitStruct;
__HAL_RCC_GPIOB_CLK_ENABLE();
__HAL_RCC_TIM2_CLK_ENABLE();
GPIO_InitStruct.Pin = GPIO_PIN_3;
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(GPIOB, &GPIO_InitStruct);
TimHandleT2.Instance = TIM2;
TimHandleT2.Init.Period = 1000 - 1;
TimHandleT2.Init.Prescaler = 168-1;
TimHandleT2.Init.ClockDivision = 0;
TimHandleT2.Init.CounterMode = TIM_COUNTERMODE_UP;
HAL_TIM_PWM_Init(&TimHandleT2);
pwmConfig.OCMode=TIM_OCMODE_PWM1;
pwmConfig.Pulse=0;
HAL_TIM_PWM_ConfigChannel(&TimHandleT2, &pwmConfig, TIM_CHANNEL_2);
HAL_TIM_PWM_Start(&TimHandleT2, TIM_CHANNEL_2);
}
extern void set_left_speed(enum TrackSpeed x){
TIM_OC_InitTypeDef PWMConfig;
PWMConfig.OCMode = TIM_OCMODE_PWM1; //Set PWM MODE (1 or 2 - NOT CHANNEL)
PWMConfig.OCPolarity = TIM_OCPOLARITY_HIGH;
PWMConfig.OCNPolarity = TIM_OCNPOLARITY_HIGH;
PWMConfig.OCFastMode = TIM_OCFAST_DISABLE;
PWMConfig.OCIdleState = TIM_OCIDLESTATE_RESET;
PWMConfig.OCNIdleState = TIM_OCNIDLESTATE_RESET;
switch(x){
case SPEED_FAST:
PWMConfig.Pulse = 10000;
break;
case SPEED_SLOW:
PWMConfig.Pulse = 5000;
break;
case SPEED_STOP:
PWMConfig.Pulse = 0;
break;
}
HAL_TIM_PWM_ConfigChannel(&TIM_Init5, &PWMConfig, TIM_CHANNEL_1);
HAL_TIM_PWM_Start(&TIM_Init5, TIM_CHANNEL_1);
}
/* TIM3 init function */
void MX_TIM3_Init(void) {
TIM_OC_InitTypeDef sConfigOC;
htim3.Instance = TIM3;
htim3.Init.Prescaler = 35;
htim3.Init.CounterMode = TIM_COUNTERMODE_UP;
htim3.Init.Period = 199;
htim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
HAL_TIM_PWM_Init(&htim3);
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);
hdma_tim3_ch1_trig.Instance = DMA1_Channel6;
hdma_tim3_ch1_trig.Init.Direction = DMA_MEMORY_TO_PERIPH;
hdma_tim3_ch1_trig.Init.PeriphInc = DMA_PINC_DISABLE;
hdma_tim3_ch1_trig.Init.MemInc = DMA_MINC_ENABLE;
hdma_tim3_ch1_trig.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD;
hdma_tim3_ch1_trig.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD;
hdma_tim3_ch1_trig.Init.Mode = DMA_CIRCULAR;
hdma_tim3_ch1_trig.Init.Priority = DMA_PRIORITY_LOW;
HAL_DMA_Init(&hdma_tim3_ch1_trig);
/* Several peripheral DMA handle pointers point to the same DMA handle.
Be aware that there is only one channel to perform all the requested DMAs. */
__HAL_LINKDMA(&htim3, hdma[TIM_DMA_ID_CC1], hdma_tim3_ch1_trig);
__HAL_LINKDMA(&htim3, hdma[TIM_DMA_ID_TRIGGER], hdma_tim3_ch1_trig);
}
void Cpwm::Timer_PWM_Init(TIM_TypeDef* TIMx, UInt32 Tim_OCMODE_PWMx)
{
/*define and init TIMx!*/
mPWM_Struct.Instance=TIMx;
mPWM_Struct.Init.Prescaler=mPrescaler;
mPWM_Struct.Init.CounterMode=TIM_COUNTERMODE_UP;
mPWM_Struct.Init.Period=mPeriod;
mPWM_Struct.Init.ClockDivision=TIM_CLOCKDIVISION_DIV1;
mPWM_Struct.Init.RepetitionCounter=0;
HAL_TIM_Base_Init(&mPWM_Struct);
HAL_TIM_PWM_Init(&mPWM_Struct);
/*define PWM output!*/
mStrOutputChannel.OCMode=Tim_OCMODE_PWMx;
mStrOutputChannel.OCIdleState=TIM_OCIDLESTATE_SET;
mStrOutputChannel.OCNIdleState=TIM_OCNIDLESTATE_RESET;
mStrOutputChannel.OCPolarity=TIM_OCPOLARITY_HIGH;
mStrOutputChannel.OCNPolarity=TIM_OCPOLARITY_HIGH;
mStrOutputChannel.OCFastMode=TIM_OCFAST_DISABLE;
mStrOutputChannel.Pulse = 0;
HAL_TIM_PWM_ConfigChannel(&mPWM_Struct,&mStrOutputChannel,mTIM_CHANNEL_x);
/*start pwm*/
HAL_TIM_PWM_Start(&mPWM_Struct,mTIM_CHANNEL_x);
}
STATIC void servo_init_channel(pyb_servo_obj_t *s) {
uint32_t pin;
uint32_t channel;
switch (s->servo_id) {
case 1: pin = GPIO_PIN_0; channel = TIM_CHANNEL_1; break;
case 2: pin = GPIO_PIN_1; channel = TIM_CHANNEL_2; break;
case 3: pin = GPIO_PIN_2; channel = TIM_CHANNEL_3; break;
case 4: pin = GPIO_PIN_3; channel = TIM_CHANNEL_4; break;
default: return;
}
// GPIO configuration
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.Pin = pin;
GPIO_InitStructure.Mode = GPIO_MODE_AF_PP;
GPIO_InitStructure.Speed = GPIO_SPEED_FAST;
GPIO_InitStructure.Pull = GPIO_NOPULL;
GPIO_InitStructure.Alternate = GPIO_AF2_TIM5;
HAL_GPIO_Init(GPIOA, &GPIO_InitStructure);
// PWM mode configuration
TIM_OC_InitTypeDef oc_init;
oc_init.OCMode = TIM_OCMODE_PWM1;
oc_init.Pulse = s->pulse_cur; // units of 10us
oc_init.OCPolarity = TIM_OCPOLARITY_HIGH;
oc_init.OCFastMode = TIM_OCFAST_DISABLE;
HAL_TIM_PWM_ConfigChannel(&TIM5_Handle, &oc_init, channel);
// start PWM
HAL_TIM_PWM_Start(&TIM5_Handle, channel);
}
/* 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 InitializePWM()
{
TimHandle.Instance = TIMx;
/* Compute the prescaler value to have TIMx counter clock equal to 1 MHz */
TimHandle.Init.Prescaler = (uint32_t) ((SystemCoreClock) / 1000000) - 1;
TimHandle.Init.Period = (1000 - 1); /* Period Value PWM frequency 1Khz */
TimHandle.Init.ClockDivision = 0;
TimHandle.Init.CounterMode = TIM_COUNTERMODE_UP;
if(HAL_TIM_PWM_Init(&TimHandle) != HAL_OK) {
/* Initialization Error */
Error_Handler();
}
/*##-2- Configure the PWM channels #########################################*/
/* Common configuration for all channels */
const uint32_t PULSE1_VALUE= 0; /* Capture Compare 1 Value */
const uint32_t PULSE2_VALUE= 1000; /* Capture Compare 2 Value */
sConfig.OCMode = TIM_OCMODE_PWM1;
sConfig.OCPolarity = TIM_OCPOLARITY_HIGH;
sConfig.OCFastMode = TIM_OCFAST_DISABLE;
/* Set the pulse value for channel 1 */
sConfig.Pulse = PULSE1_VALUE;
if(HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_1) != HAL_OK) {
/* Configuration Error */
Error_Handler();
}
/* Set the pulse value for channel 2 */
sConfig.Pulse = PULSE2_VALUE;
if(HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_2) != HAL_OK) {
/* Configuration Error */
Error_Handler();
}
/*##-3- Start PWM signals generation #######################################*/
/* Start channel 1 */
if(HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_1) != HAL_OK) {
/* PWM Generation Error */
Error_Handler();
}
/* Start channel 2 */
if(HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_2) != HAL_OK) {
/* PWM Generation Error */
Error_Handler();
}
}
int timer_init(hacs_timer_t tim, hacs_timer_mode_t mode)
{
uint32_t clock_freq;
uint32_t presc;
TIM_HandleTypeDef *htim = &tim_handles[tim];
TIM_TypeDef *inst = hacs_tim_instances[tim];
tim_overflow_cb[tim] = NULL;
// First, find the appropriate prescaler to achieve microsecond resolution
if (inst == TIM1 || inst == TIM10 || inst == TIM11) {
// For stm32f411, these 3 timers are on the APB2 bus
clock_freq = HAL_RCC_GetPCLK2Freq();
} else {
clock_freq = HAL_RCC_GetPCLK1Freq();
}
presc = clock_freq / TIMER_RESOLUTION_FREQ;
// Setup timer base
htim->Instance = inst;
htim->Init.Prescaler = presc;
htim->Init.CounterMode = TIM_COUNTERMODE_UP;
htim->Init.Period = 0;
htim->Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
htim->Init.RepetitionCounter = 0;
HAL_TIM_Base_Init(htim);
if (mode == HACS_TIMER_MODE_PWM) {
TIM_OC_InitTypeDef sConfigOC;
sConfigOC.OCMode = TIM_OCMODE_PWM1;
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;
// NOTE: Assume there are 4 PWM channels on each timer, and that all of them are used.
HAL_TIM_PWM_ConfigChannel(htim, &sConfigOC, TIM_CHANNEL_1);
HAL_TIM_PWM_ConfigChannel(htim, &sConfigOC, TIM_CHANNEL_2);
HAL_TIM_PWM_ConfigChannel(htim, &sConfigOC, TIM_CHANNEL_3);
HAL_TIM_PWM_ConfigChannel(htim, &sConfigOC, TIM_CHANNEL_4);
}
return HACS_NO_ERROR;
}
