电机应用-直流有刷电机多环控制实现

目录

直流有刷电机多环控制实现

硬件设计

直流电机三环（速度环、电流环、位置环）串级PID控制-位置式PID

编程要点

配置ADC可读取电流值

配置基本定时器6产生定时中断读取当前电路中驱动电机的电流值并执行PID运算

配置定时器1输出PWM控制电机

配置定时器3读取编码器的计数值

ADC数据处理

编写位置式PID算法

直流有刷电机多环控制实现

外环的输出会作为内环的输入。外环一般是最终要控制的效果， 

硬件设计

可选：L298N电机驱动板、野火MOS搭建的驱动板。

直流电机三环（速度环、电流环、位置环）串级PID控制-位置式PID

编程要点

配置ADC可读取电流值。

配置基本定时器TIM6产生定时中断执行PID运算。

配置高级定时器TIM1输出PWM控制电机。

配置通用定时器TIM3读取编码器的计数值。

ADC数据处理。

编写位置式PID算法。

编写位置环、速度环、电流环控制函数。

增加上位机曲线观察相关代码。

编写按键控制代码。

配置ADC可读取电流值
#define VBUS_MAX      		14    // 电压最大值
#define VBUS_MIN      		10    // 电压最小值
			
#define VBUS_HEX_MAX  		((VBUS_MAX/37.0+1.24)/VREF*65536)    // 电压最大值（测量电压是电源电压的1/37）
#define VBUS_HEX_MIN  		((VBUS_MIN/37.0+1.24)/VREF*65536)    // 电压最小值（测量电压是电源电压的1/37）
 
__IO uint16_t ADC_ConvertedValue;
DMA_HandleTypeDef DMA_Init_Handle;
ADC_HandleTypeDef ADC_Handle;
 
static uint16_t adc_buff[1024];
static uint16_t vbus_adc_mean = 0;  	// 电源电压 ADC 采样结果平均值
static uint32_t adc_mean_sum = 0;   	// 平均值累加
static uint32_t adc_mean_count = 0; 	// 累加计数
 
/**
  * @brief  电流采集初始化
  * @param  无
  * @retval 无
  */
void ADC_Init(void)
{
	GPIO_InitTypeDef GPIO_InitStructure;
	
    __GPIOB_CLK_ENABLE();
	__DMA2_CLK_ENABLE();
	__ADC1_CLK_ENABLE();
 
	// PB1--电流
    GPIO_InitStructure.Pin = GPIO_PIN_1;
    GPIO_InitStructure.Mode = GPIO_MODE_ANALOG;
    GPIO_InitStructure.Pull = GPIO_NOPULL;
    HAL_GPIO_Init(GPIOB, &GPIO_InitStructure);
 
	// PB0--电压
    GPIO_InitStructure.Pin = GPIO_PIN_0;
    HAL_GPIO_Init(GPIOB, &GPIO_InitStructure);
	
	// ADC1使用DMA2，数据流0，通道0，这个是手册固定死的
	DMA_Init_Handle.Instance 					= DMA2_Stream0;
    DMA_Init_Handle.Init.Direction 				= DMA_PERIPH_TO_MEMORY;
    DMA_Init_Handle.Init.PeriphInc 				= DMA_PINC_DISABLE;
    DMA_Init_Handle.Init.MemInc 				= DMA_MINC_ENABLE;
    DMA_Init_Handle.Init.PeriphDataAlignment 	= DMA_PDATAALIGN_HALFWORD;
    DMA_Init_Handle.Init.MemDataAlignment 		= DMA_MDATAALIGN_HALFWORD;
    DMA_Init_Handle.Init.Mode 					= DMA_CIRCULAR;
    DMA_Init_Handle.Init.Priority 				= DMA_PRIORITY_HIGH;
    DMA_Init_Handle.Init.FIFOMode 				= DMA_FIFOMODE_DISABLE;
    DMA_Init_Handle.Init.FIFOThreshold 			= DMA_FIFO_THRESHOLD_HALFFULL;
    DMA_Init_Handle.Init.MemBurst 				= DMA_MBURST_SINGLE;
    DMA_Init_Handle.Init.PeriphBurst 			= DMA_PBURST_SINGLE;
    // 选择 DMA 通道，通道存在于流中
    DMA_Init_Handle.Init.Channel 				= DMA_CHANNEL_0;
    //初始化DMA流，流相当于一个大的管道，管道里面有很多通道
    HAL_DMA_Init(&DMA_Init_Handle);
 
    __HAL_LINKDMA(&ADC_Handle, DMA_Handle, DMA_Init_Handle);
	
	ADC_Handle.Instance 					= ADC1;
    ADC_Handle.Init.ClockPrescaler 			= ADC_CLOCKPRESCALER_PCLK_DIV4;
    ADC_Handle.Init.Resolution 				= ADC_RESOLUTION_12B;
    ADC_Handle.Init.ScanConvMode 			= ENABLE;
    ADC_Handle.Init.ContinuousConvMode 		= ENABLE;
    ADC_Handle.Init.DiscontinuousConvMode 	= DISABLE;
    ADC_Handle.Init.NbrOfDiscConversion   	= 0;
    ADC_Handle.Init.ExternalTrigConvEdge 	= ADC_EXTERNALTRIGCONVEDGE_NONE;
    ADC_Handle.Init.ExternalTrigConv 		= ADC_SOFTWARE_START;
    ADC_Handle.Init.DataAlign 				= ADC_DATAALIGN_LEFT;
    ADC_Handle.Init.NbrOfConversion 		= 2;
    ADC_Handle.Init.DMAContinuousRequests 	= ENABLE;
    ADC_Handle.Init.EOCSelection          	= ADC_EOC_SINGLE_CONV;
    HAL_ADC_Init(&ADC_Handle);
	
	ADC_ChannelConfTypeDef ADC_Config;
 
    ADC_Config.Channel      = ADC_CHANNEL_9;
    ADC_Config.Rank         = 1;
    ADC_Config.SamplingTime = ADC_SAMPLETIME_3CYCLES;
    ADC_Config.Offset       = 0;
    HAL_ADC_ConfigChannel(&ADC_Handle, &ADC_Config);
 
    /** Configure the analog watchdog
    */
    ADC_AnalogWDGConfTypeDef AnalogWDGConfig = {0};
 
    AnalogWDGConfig.WatchdogMode 	= ADC_ANALOGWATCHDOG_SINGLE_REG;
    AnalogWDGConfig.HighThreshold 	= VBUS_HEX_MAX;
    AnalogWDGConfig.LowThreshold 	= VBUS_HEX_MIN;
    AnalogWDGConfig.Channel 		= ADC_CHANNEL_8;
    AnalogWDGConfig.ITMode 			= ENABLE;
 
    if (HAL_ADC_AnalogWDGConfig(&ADC_Handle, &AnalogWDGConfig) != HAL_OK)
    {
        while (1);
    }
 
    /** Configure for the selected ADC regular channel its corresponding rank in the sequencer and its sample time.
    */
    ADC_Config.Channel 		= ADC_CHANNEL_8;
    ADC_Config.Rank 		= 2;
    ADC_Config.SamplingTime = ADC_SAMPLETIME_3CYCLES;
    ADC_Config.Offset       = 0;
 
    if (HAL_ADC_ConfigChannel(&ADC_Handle, &ADC_Config) != HAL_OK)
    {
        while (1);
    }
 
    // 外设中断优先级配置和使能中断配置
    HAL_NVIC_SetPriority(DMA2_Stream0_IRQn, 4, 0);
    HAL_NVIC_EnableIRQ(DMA2_Stream0_IRQn);
 
    HAL_NVIC_SetPriority(ADC_IRQn, 3, 0);
    HAL_NVIC_EnableIRQ(ADC_IRQn);
 
    HAL_ADC_Start_DMA(&ADC_Handle, (uint32_t *)&adc_buff, 1024);
}

配置基本定时器6产生定时中断读取当前电路中驱动电机的电流值并执行PID运算
TIM_HandleTypeDef TIM_TimeBaseStructure;
 
/**
  * @brief  初始化基本定时器定时，默认50ms产生一次中断
  * @param  无
  * @retval 无
  */
void TIMx_Configuration(void)
{
    HAL_NVIC_SetPriority(TIM6_DAC_IRQn, 1, 3);
    HAL_NVIC_EnableIRQ(TIM6_DAC_IRQn);
	
	__TIM6_CLK_ENABLE();
	
	TIM_TimeBaseStructure.Instance = TIM6;
    TIM_TimeBaseStructure.Init.Period = 50 * 50 - 1;
    TIM_TimeBaseStructure.Init.Prescaler = 1680 - 1;
    TIM_TimeBaseStructure.Init.CounterMode = TIM_COUNTERMODE_UP;
    TIM_TimeBaseStructure.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
    HAL_TIM_Base_Init(&TIM_TimeBaseStructure);
 
    // 开启定时器更新中断
    HAL_TIM_Base_Start_IT(&TIM_TimeBaseStructure);
	
    uint32_t temp = (__HAL_TIM_GET_AUTORELOAD(&TIM_TimeBaseStructure) + 1) / 50.0;  // 计算周期，单位ms
    set_computer_value(SEND_PERIOD_CMD, CURVES_CH1, &temp, 1);  					// 给通道 1 发送目标值
}
 
/**
  * @brief  定时器更新事件回调函数
  * @param  无
  * @retval 无
  */
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
    if (htim == (&TIM_TimeBaseStructure))
    {
        motor_pid_control();	// 每50ms执行一次PID运算
    }
}

配置定时器1输出PWM控制电机
TIM_HandleTypeDef  DCM_TimeBaseStructure;
 
/**
  * @brief  初始化控制通用定时器
  * @param  无
  * @retval 无
  */
void Motor_TIMx_Configuration(void)
{
    GPIO_InitTypeDef GPIO_InitStruct;
    TIM_OC_InitTypeDef  TIM_OCInitStructure;
 
	__HAL_RCC_GPIOA_CLK_ENABLE();
    __TIM1_CLK_ENABLE();
 
	// PA8--PWM_TIM_CH1
	GPIO_InitStruct.Pin 		= GPIO_PIN_8;
    GPIO_InitStruct.Mode 		= GPIO_MODE_AF_PP;
    GPIO_InitStruct.Speed 		= GPIO_SPEED_FREQ_HIGH;
    GPIO_InitStruct.Alternate 	= PWM_TIM_GPIO_AF;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
 
	// PA9--PWM_TIM_CH2
    GPIO_InitStruct.Pin 		= GPIO_PIN_9;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
 
	// TIM1 66.7us一次周期
    DCM_TimeBaseStructure.Instance = TIM1;
    DCM_TimeBaseStructure.Init.Period = 5600 - 1;
    DCM_TimeBaseStructure.Init.Prescaler = 1 - 1;
    DCM_TimeBaseStructure.Init.CounterMode = TIM_COUNTERMODE_UP;
    DCM_TimeBaseStructure.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
    HAL_TIM_PWM_Init(&DCM_TimeBaseStructure);
 
    /*PWM模式配置*/
    TIM_OCInitStructure.OCMode = TIM_OCMODE_PWM1;
    TIM_OCInitStructure.Pulse = 0;
    TIM_OCInitStructure.OCPolarity = TIM_OCPOLARITY_HIGH;
    TIM_OCInitStructure.OCNPolarity = TIM_OCNPOLARITY_HIGH;
    TIM_OCInitStructure.OCIdleState = TIM_OCIDLESTATE_SET;
    TIM_OCInitStructure.OCNIdleState = TIM_OCNIDLESTATE_RESET;
 
    /*配置PWM通道*/
    HAL_TIM_PWM_ConfigChannel(&DCM_TimeBaseStructure, &TIM_OCInitStructure, TIM_CHANNEL_1);
    /*开始输出PWM*/
    HAL_TIM_PWM_Start(&DCM_TimeBaseStructure, TIM_CHANNEL_1);
 
    /*配置PWM通道*/
    HAL_TIM_PWM_ConfigChannel(&DCM_TimeBaseStructure, &TIM_OCInitStructure, TIM_CHANNEL_2);
    /*开始输出PWM*/
    HAL_TIM_PWM_Start(&DCM_TimeBaseStructure, TIM_CHANNEL_2);
}
 
/**
  * @brief  设置TIM通道的占空比
	* @param  channel		通道	（1,2,3,4）
	* @param  compare		占空比
	*	@note 	无
  * @retval 无
  */
void TIM1_SetPWM_pulse(uint32_t channel, int compare)
{
    switch (channel)
    {
        case TIM_CHANNEL_1:
            __HAL_TIM_SET_COMPARE(&DCM_TimeBaseStructure, TIM_CHANNEL_1, compare);
            break;
 
        case TIM_CHANNEL_2:
            __HAL_TIM_SET_COMPARE(&DCM_TimeBaseStructure, TIM_CHANNEL_2, compare);
            break;
 
        case TIM_CHANNEL_3:
            __HAL_TIM_SET_COMPARE(&DCM_TimeBaseStructure, TIM_CHANNEL_3, compare);
            break;
 
        case TIM_CHANNEL_4:
            __HAL_TIM_SET_COMPARE(&DCM_TimeBaseStructure, TIM_CHANNEL_4, compare);
            break;
    }
}

配置定时器3读取编码器的计数值
TIM_HandleTypeDef  DCM_TimeBaseStructure;
 
/**
  * @brief  初始化控制通用定时器
  * @param  无
  * @retval 无
  */
void Motor_TIMx_Configuration(void)
{
    GPIO_InitTypeDef GPIO_InitStruct;
    TIM_OC_InitTypeDef  TIM_OCInitStructure;
 
	__HAL_RCC_GPIOA_CLK_ENABLE();
    __TIM1_CLK_ENABLE();
 
	// PA8--PWM_TIM_CH1
	GPIO_InitStruct.Pin 		= GPIO_PIN_8;
    GPIO_InitStruct.Mode 		= GPIO_MODE_AF_PP;
    GPIO_InitStruct.Speed 		= GPIO_SPEED_FREQ_HIGH;
    GPIO_InitStruct.Alternate 	= PWM_TIM_GPIO_AF;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
 
	// PA9--PWM_TIM_CH2
    GPIO_InitStruct.Pin 		= GPIO_PIN_9;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
 
	// TIM1 66.7us一次周期
    DCM_TimeBaseStructure.Instance = TIM1;
    DCM_TimeBaseStructure.Init.Period = 5600 - 1;
    DCM_TimeBaseStructure.Init.Prescaler = 1 - 1;
    DCM_TimeBaseStructure.Init.CounterMode = TIM_COUNTERMODE_UP;
    DCM_TimeBaseStructure.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
    HAL_TIM_PWM_Init(&DCM_TimeBaseStructure);
 
    /*PWM模式配置*/
    TIM_OCInitStructure.OCMode = TIM_OCMODE_PWM1;
    TIM_OCInitStructure.Pulse = 0;
    TIM_OCInitStructure.OCPolarity = TIM_OCPOLARITY_HIGH;
    TIM_OCInitStructure.OCNPolarity = TIM_OCNPOLARITY_HIGH;
    TIM_OCInitStructure.OCIdleState = TIM_OCIDLESTATE_SET;
    TIM_OCInitStructure.OCNIdleState = TIM_OCNIDLESTATE_RESET;
 
    /*配置PWM通道*/
    HAL_TIM_PWM_ConfigChannel(&DCM_TimeBaseStructure, &TIM_OCInitStructure, TIM_CHANNEL_1);
    /*开始输出PWM*/
    HAL_TIM_PWM_Start(&DCM_TimeBaseStructure, TIM_CHANNEL_1);
 
    /*配置PWM通道*/
    HAL_TIM_PWM_ConfigChannel(&DCM_TimeBaseStructure, &TIM_OCInitStructure, TIM_CHANNEL_2);
    /*开始输出PWM*/
    HAL_TIM_PWM_Start(&DCM_TimeBaseStructure, TIM_CHANNEL_2);
}
 
/**
  * @brief  定时器更新事件回调函数
  * @param  无
  * @retval 无
  */
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
    if (htim == (&TIM_EncoderHandle))
    {
        /* 判断当前计数器计数方向 */
        if (__HAL_TIM_IS_TIM_COUNTING_DOWN(&TIM_EncoderHandle))
            /* 下溢 */
        {
            Encoder_Overflow_Count--;
        }
        else
            /* 上溢 */
        {
            Encoder_Overflow_Count++;
        }
    }
}

ADC数据处理
static uint16_t flag_num = 0;
/**
  * @brief  常规转换在非阻塞模式下完成回调
  * @param  hadc: ADC  句柄.
  * @retval 无
  */
void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef *hadc)
{
    uint32_t adc_mean = 0;
 
    HAL_ADC_Stop_DMA(hadc);       // 停止 ADC 采样，处理完一次数据在继续采样
 
    /* 计算电流通道采样的平均值 */
    for (uint32_t count = 0; count < 1024; count += 2)
    {
        adc_mean += (uint32_t)adc_buff[count];
    }
 
    adc_mean_sum += adc_mean / (1024 / 2);    // 保存平均值
    adc_mean_count++;
 
    adc_mean = 0;
 
    /* 计算电压通道采样的平均值 */
    for (uint32_t count = 1; count < 1024; count += 2)
    {
        adc_mean += (uint32_t)adc_buff[count];
    }
 
    vbus_adc_mean = adc_mean / (1024 / 2);    // 保存平均值
 
    HAL_ADC_Start_DMA(&ADC_Handle, (uint32_t *)&adc_buff, 1024); // 开始 ADC 采样
}
 
/**
  * @brief  在非阻塞模式模拟看门狗回调
  * @param  hadc: ADC  句柄.
  * @retval 无
  */
void HAL_ADC_LevelOutOfWindowCallback(ADC_HandleTypeDef *hadc)
{
    float temp_adc;
 
    flag_num++;     	// 电源电压超过阈值电压
 
    temp_adc = get_vbus_val();
 
    if (temp_adc > VBUS_MIN && temp_adc < VBUS_MAX)
    {
        flag_num = 0;
    }
 
    if (flag_num > 10) 	// 电源电压超过阈值电压10次
    {
        set_motor_disable();
        flag_num = 0;
        printf("电源电压超过限制！请检查原因，复位开发板在试！\r\n");
 
        while (1);
    }
}
 
/**
  * @brief  获取电流值（应定时调用）
  * @param  无
  * @retval 转换得到的电流值
  */
int32_t get_curr_val(void)
{
    static uint8_t flag = 0;
    static uint32_t adc_offset = 0;    				// 偏置电压
    int16_t curr_adc_mean = 0;         				// 电流 ACD 采样结果平均值
 
    curr_adc_mean = adc_mean_sum / adc_mean_count;  // 保存平均值
 
    adc_mean_count = 0;
    adc_mean_sum = 0;
 
    if (flag < 17 && is_motor_en == 0)				//	仅在电机未启动时记录
    {
        adc_offset = curr_adc_mean;    				// 多次记录偏置电压，待系统稳定偏置电压才为有效值
        flag += 1;
    }
 
    if (curr_adc_mean >= adc_offset)
    {
        curr_adc_mean -= adc_offset;                // 减去偏置电压
    }
    else
    {
        curr_adc_mean = 0;
    }
 
	float vdc = (float)curr_adc_mean/(float)65536 * 3.3f;	// 获取电压值
    return (float)vdc / 8.0f / 0.02f * 1000.0f;
}
 
/**
  * @brief  获取电源电压值
  * @param  无
  * @retval 转换得到的电流值
  */
float get_vbus_val(void)
{
    float vdc = (float)vbus_adc_mean/(float)65536 * 3.3f;	// 获取电压值
    return ((float)vdc - (float)1.24) * (float)37.0;		// 电源电压值（测量电压是电源电压的1/37）
}

编写位置式PID算法
typedef struct
{
    float target_val;	// 目标值
    float actual_val;	// 实际值
    float err;       	// 定义偏差值
    float err_last;  	// 定义上一个偏差值
    float Kp,Ki,Kd;  	// 定义比例、积分、微分系数
    float integral;  	// 定义积分值
}_pid;
_pid pid_location;		// 位置环控制
_pid pid_curr;			// 电流环控制
_pid pid_speed;			// 速度环控制

/**
  * @brief  PID参数初始化
	*	@note 	无
  * @retval 无
  */
void PID_param_init(void)
{
    /* 位置相关初始化参数 */
    pid_location.target_val = 0.0;
    pid_location.actual_val = 0.0;
    pid_location.err 		= 0.0;
    pid_location.err_last 	= 0.0;
    pid_location.integral 	= 0.0;
    pid_location.Kp 		= 0.011;
    pid_location.Ki 		= 0.0018;
    pid_location.Kd 		= 0.0;

    /* 速度相关初始化参数 */
    pid_speed.target_val 	= 100.0;
    pid_speed.actual_val 	= 0.0;
    pid_speed.err 			= 0.0;
    pid_speed.err_last 		= 0.0;
    pid_speed.integral 		= 0.0;
    pid_speed.Kp 			= 2.0;
    pid_speed.Ki 			= 0.02;
    pid_speed.Kd 			= 0.00;

    /* 电流相关初始化参数 */
    pid_curr.target_val 	= 80.0;
    pid_curr.actual_val 	= 0.0;
    pid_curr.err 			= 0.0;
    pid_curr.err_last 		= 0.0;
    pid_curr.integral 		= 0.0;
    pid_curr.Kp 			= 0.0;
    pid_curr.Ki 			= 3.5;
    pid_curr.Kd 			= 0.00;

    float pid_temp[3] = {pid_location.Kp, pid_location.Ki, pid_location.Kd};
    set_computer_value(SEND_P_I_D_CMD, CURVES_CH1, pid_temp, 3);     // 给通道 1 发送 P I D 值

    pid_temp[0] = pid_speed.Kp;
    pid_temp[1] = pid_speed.Ki;
    pid_temp[2] = pid_speed.Kd;
    set_computer_value(SEND_P_I_D_CMD, CURVES_CH2, pid_temp, 3);     // 给通道 2 发送 P I D 值

    pid_temp[0] = pid_curr.Kp;
    pid_temp[1] = pid_curr.Ki;
    pid_temp[2] = pid_curr.Kd;
    set_computer_value(SEND_P_I_D_CMD, CURVES_CH3, pid_temp, 3);     // 给通道 3 发送 P I D 值
}

/**
  * @brief  设置目标值
  * @param  val		目标值
	*	@note 	无
  * @retval 无
  */
void set_pid_target(_pid *pid, float temp_val)
{
    pid->target_val = temp_val;    // 设置当前的目标值
}

/**
  * @brief  获取目标值
  * @param  无
	*	@note 	无
  * @retval 目标值
  */
float get_pid_target(_pid *pid)
{
    return pid->target_val;    // 设置当前的目标值
}

/**
  * @brief  设置比例、积分、微分系数
  * @param  p：比例系数 P
  * @param  i：积分系数 i
  * @param  d：微分系数 d
	*	@note 	无
  * @retval 无
  */
void set_p_i_d(_pid *pid, float p, float i, float d)
{
    pid->Kp = p;    // 设置比例系数 P
    pid->Ki = i;    // 设置积分系数 I
    pid->Kd = d;    // 设置微分系数 D
}

/**
  * @brief  位置环位置式PID算法实现
  * @param  actual_val:实际值
  *	@note 	无
  * @retval 通过PID计算后的输出
  */
float location_pid_realize(_pid *pid, float actual_val)
{
    /*计算目标值与实际值的误差*/
    pid->err = pid->target_val - actual_val;

    /* 限定闭环死区 */
    if ((pid->err >= -40) && (pid->err <= 40))
    {
        pid->err = 0;
        pid->integral = 0;
    }

    /* 积分分离，偏差较大时去掉积分作用 */
    if (pid->err > -1500 && pid->err < 1500)
    {
        pid->integral += pid->err;    // 误差累积

        /* 限定积分范围，防止积分饱和 */
        if (pid->integral > 4000)
        {
            pid->integral = 4000;
        }
        else if (pid->integral < -4000)
        {
            pid->integral = -4000;
        }
    }

    /*PID算法实现*/
    pid->actual_val = pid->Kp * pid->err + pid->Ki * pid->integral + pid->Kd * (pid->err - pid->err_last);

    /*误差传递*/
    pid->err_last = pid->err;

    /*返回当前实际值*/
    return pid->actual_val;
}

/**
  * @brief  速度环位置式PID算法实现
  * @param  actual_val:实际值
  *	@note 	无
  * @retval 通过PID计算后的输出
  */
float speed_pid_realize(_pid *pid, float actual_val)
{
    /*计算目标值与实际值的误差*/
    pid->err = pid->target_val - actual_val;

    if ((pid->err < 0.2f) && (pid->err > -0.2f))
    {
        pid->err = 0.0f;
    }

    pid->integral += pid->err;    // 误差累积

    /*PID算法实现*/
    pid->actual_val = pid->Kp * pid->err + pid->Ki * pid->integral + pid->Kd * (pid->err - pid->err_last);

    /*误差传递*/
    pid->err_last = pid->err;

    /*返回当前实际值*/
    return pid->actual_val;
}

/**
  * @brief  电流环位置式PID算法实现
  * @param  actual_val:实际值
	*	@note 	无
  * @retval 通过PID计算后的输出
  */
float curr_pid_realize(_pid *pid, float actual_val)
{
    /*计算目标值与实际值的误差*/
    pid->err = pid->target_val - actual_val;

    pid->integral += pid->err;    // 误差累积

    /* 限定积分范围，防止积分饱和 */
    if (pid->integral > 2000)
    {
        pid->integral = 2000;
    }
    else if (pid->integral < -2000)
    {
        pid->integral = -2000;
    }

    /*PID算法实现*/
    pid->actual_val = pid->Kp * pid->err + pid->Ki * pid->integral + pid->Kd * (pid->err - pid->err_last);

    /*误差传递*/
    pid->err_last = pid->err;

    /*返回当前实际值*/
    return pid->actual_val;
}

#define TARGET_CURRENT_MAX    200    // 目标电流的最大值 mA
#define TARGET_SPEED_MAX      200    // 目标速度的最大值 r/m

/**
  * @brief  电机位置式 PID 控制实现(定时调用)
  * @param  无
  * @retval 无
  */
void motor_pid_control(void)
{
    static uint32_t louter_ring_timer = 0;      // 外环环周期（电流环计算周期为定时器周期T，速度环为2T，位置环为3T）
    int32_t actual_current = get_curr_val();    // 读取当前电流值

    if (actual_current > TARGET_CURRENT_MAX)
    {
        actual_current = TARGET_CURRENT_MAX;
    }

    if (is_motor_en == 1)                  		// 电机在使能状态下才进行控制处理
    {
        static int32_t Capture_Count = 0;    	// 当前时刻总计数值
        static int32_t Last_Count = 0;       	// 上一时刻总计数值
        float cont_val = 0;                  	// 当前控制值

        /* 当前时刻总计数值 = 计数器值 + 计数溢出次数 * ENCODER_TIM_PERIOD  */
        Capture_Count = __HAL_TIM_GET_COUNTER(&TIM_EncoderHandle) + (Encoder_Overflow_Count * 65535);

        /* 位置环计算 */
        if (louter_ring_timer++ % 3 == 0)
        {
            cont_val = location_pid_realize(&pid_location, Capture_Count);    // 进行 PID 计算

            /* 目标速度上限处理 */
            if (cont_val > TARGET_SPEED_MAX)
            {
                cont_val = TARGET_SPEED_MAX;
            }
            else if (cont_val < -TARGET_SPEED_MAX)
            {
                cont_val = -TARGET_SPEED_MAX;
            }

            set_pid_target(&pid_speed, cont_val);    // 设定速度的目标值

            int32_t temp = cont_val;
            set_computer_value(SEND_TARGET_CMD, CURVES_CH2, &temp, 1);     // 给通道 2 发送目标值
        }

        /* 速度环计算 */
        static int32_t actual_speed = 0;             // 实际测得速度

        if (louter_ring_timer % 2 == 0)
        {
            /* 转轴转速 = 单位时间内的计数值 / 编码器总分辨率 * 时间系数  */
            actual_speed = ((float)(Capture_Count - Last_Count) / 16 * 4 / 30) / (GET_BASIC_TIM_PERIOD() * 2 / 1000.0 / 60.0);

            /* 记录当前总计数值，供下一时刻计算使用 */
            Last_Count = Capture_Count;

            cont_val = speed_pid_realize(&pid_speed, actual_speed);    		// 进行 PID 计算

            if (cont_val > 0)    					// 判断电机方向
            {
                set_motor_direction(MOTOR_FWD);
            }
            else
            {
                cont_val = -cont_val;
                set_motor_direction(MOTOR_REV);
            }

            cont_val = (cont_val > TARGET_CURRENT_MAX) ? TARGET_CURRENT_MAX : cont_val;    // 电流上限处理
            set_pid_target(&pid_curr, cont_val);    						// 设定电流的目标值

            int32_t temp = cont_val;
            set_computer_value(SEND_TARGET_CMD, CURVES_CH3, &temp, 1);     	// 给通道 3 发送目标值
        }

        /* 电流环计算 */
        cont_val = curr_pid_realize(&pid_curr, actual_current);    			// 进行 PID 计算

        if (cont_val < 0)
        {
            cont_val = 0;    	// 下限处理
        }
        else if (cont_val > 5500)
        {
            cont_val = 5500;	// 速度上限处理
        }

        set_motor_speed(cont_val);                                                 // 设置 PWM 占空比

        set_computer_value(SEND_FACT_CMD, CURVES_CH1, &Capture_Count,  1);         // 给通道 1 发送实际值
    }
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mfbz.cn/a/186058.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

jenkins + gitlab 自动部署(webhook)

jenkins + gitlab 自动部署(webhook)

Jenkins是一个流行的开源CI/CD工具&#xff0c;可以与Git等版本控制系统集成&#xff0c;实现自动构建、测试和部署。Webhook是一种机制&#xff0c;可以在Git仓库中设置&#xff0c;在代码提交或合并请求时触发Jenkins构建任务&#xff0c;以完成自动化部署。 实操 设备信息 …
阅读更多...
DELL MD3600F存储重置管理软件密码

DELL MD3600F存储重置管理软件密码

注意&#xff1a;密码清除可能会导致业务秒断&#xff0c;建议非业务时间操作 针对一台控制器操作即可&#xff0c;另一控制器会同步操作 重置后密码为空&#xff01; 需求&#xff1a;重置存储管理软件密码 管理软件中分配物理磁盘时提示输入密码(类似是否了解风险确认操作的提…
阅读更多...
前端（HTML + CSS + JS）

前端（HTML + CSS + JS）

文章目录 一、HTML1. 概念&#xff08;1&#xff09;HTML 文件基本结构&#xff08;2&#xff09;HTML代码框架 2. 、HTML常见标签 二、CSS1. CSS基本语法规范2. 用法&#xff08;1&#xff09; 引用方式&#xff08;2&#xff09;选择器&#xff08;3&#xff09;常用元素属性…
阅读更多...
面向对象三大特性,类与接口，java重写与重载，对象相等的判断， hashCode 与 equals

面向对象三大特性,类与接口，java重写与重载，对象相等的判断， hashCode 与 equals

文章目录 2.1 面向对象三大特性2.1.1 封装 继承 多态2.1.2 其中Java 面向对象编程三大特性&#xff1a;封装 继承 多态2.1.3 关于继承如下 3 点请记住&#xff1a;2.1.4 什么是多态机制&#xff1f;Java语言是如何实现多态的&#xff1f;2.1.5 Java实现多态有三个必要条件&…
阅读更多...
H5ke12--2--学生选课表格的编辑

H5ke12--2--学生选课表格的编辑

方法1不可以修改的用label,如何按了哪一行 就会在下面有个文本显示可编辑的一行 方法2每一行后面都有一个编辑, 3对每一个修改,每一个td失去焦点都会有,直接到达我们服务器 注意 如果用span的每一个html元素都可以自己定义属性 Data-属性名,data-Address links也要给为span 1…
阅读更多...
Qt学习(2)

Qt学习(2)

1.QObject 只有继承了QObject类的类&#xff0c;才具有信号槽的能力。所以&#xff0c;为了使用信号槽&#xff0c;必须继承QObject。凡是QObject类&#xff08;不管是直接子类还是间接子类&#xff09;&#xff0c;都应该在第一行代码写上Q_OBJECT。不管是不是使用信号槽&…
阅读更多...
【LeetCode】挑战100天 Day14（热题+面试经典150题）

【LeetCode】挑战100天 Day14（热题+面试经典150题）

【LeetCode】挑战100天 Day14&#xff08;热题面试经典150题&#xff09; 一、LeetCode介绍二、LeetCode 热题 HOT 100-162.1 题目2.2 题解 三、面试经典 150 题-163.1 题目3.2 题解 一、LeetCode介绍 LeetCode是一个在线编程网站&#xff0c;提供各种算法和数据结构的题目&…
阅读更多...
nohup 实现远程运行不关机操作

nohup 实现远程运行不关机操作

nohup 实现远程运行不宕机操作 python nohup 实现远程运行不宕机操作 - python教程网 远程运行最怕断电&#xff0c;训练了几个小时的数据说没就没&#xff0c;或者停止运行。 用nohup 记录代码的输出&#xff0c;还可以不受断电的影响。 方法 1. 用nohup 运行一个python文…
阅读更多...
HTML网站稳定性状态监控平台源码

HTML网站稳定性状态监控平台源码

这是一款网站稳定性状态监控平台源码&#xff0c;它基于UptimeRobot接口进行开发。当您的网站遇到故障时&#xff0c;该平台能够通过邮件或短信通知您。下面是对安装过程的详细说明&#xff1a; 安装步骤 将源码上传至您的主机或服务器&#xff0c;并进行解压操作。 在Uptim…
阅读更多...
Redis高并发缓存架构

Redis高并发缓存架构

前言&#xff1a; 针对缓存我们并不陌生&#xff0c;而今天所讲的是使用redis作为缓存工具进行缓存数据。redis缓存是将数据保存在内存中的&#xff0c;而内存的珍贵性是不可否认的。所以在缓存之前&#xff0c;我们需要明确缓存的对象&#xff0c;是否有必要缓存&#xff0c;怎…
阅读更多...
C++之模版初阶（简单使用模版）

C++之模版初阶（简单使用模版）

前言 在学习C的模版之前&#xff0c;咱们先来说一说模版的概念&#xff0c;模版在我们的日常生活中非常常见&#xff0c;比如我们要做一个ppt&#xff0c;我们会去在WPS找个ppt的模版&#xff0c;我们只需要写入内容即可&#xff1b;比如我们的数学公式&#xff0c;给公式套值&…
阅读更多...
DBS note5：Relational Algebra（关系代数）

DBS note5：Relational Algebra（关系代数）

目录 一、关系代数简介 二、Projection () 三、Selection () 四、Union () 五、Set Difference (-) 六、Intersection () 七、Cross Product () 八、Joins () 九、Rename () 十、Group By / Aggregation () 一、关系代数简介 关系代数中的所有运算符都接受一个关系并…
阅读更多...
mac上Homebrew的安装与使用

mac上Homebrew的安装与使用

打开终端&#xff1a;command空格 &#xff0c;搜索‘’终端 ’&#xff0c;打开终端 在终端中输入以下命令并按下回车键&#xff1a; /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"这个命令会自动下载并安装…
阅读更多...
RocketMQ 消息中间件 知识点汇总

RocketMQ 消息中间件 知识点汇总

目录 RocketMQ1、什么是RocketMQ？常用术语：2、为什么需要消息队列3、什么是异步处理4、什么是服务解耦5、什么是流量控制6、消息队列两种模型队列模型：发布/订阅模型：总结：7、怎么保证消息不丢失8、如何处理消息被重复消费**出现消息重复的情况：****解决方法：**9、如何保…
阅读更多...
github国内访问小解（windows）

github国内访问小解（windows）

git 下载安装 使用 github 前必须确保电脑上已经安装了 Git&#xff0c;可以从 Git 官方网站去下载。 官方的网站在国内访问会比较慢&#xff0c;这里可以选择国内镜像&#xff1a;https://registry.npmmirror.com/binary.html?pathgit-for-windows/ github 之旅 确认电脑已…
阅读更多...
多功能PHP图床源码：Lsky Pro开源版v2.1 – 最新兰空图床

多功能PHP图床源码：Lsky Pro开源版v2.1 – 最新兰空图床

Lsky Pro是一款功能丰富的在线图片上传和管理工具&#xff0c;即兰空图床。它不仅可以作为个人云相册&#xff0c;还可以用作写作贴图库。 该程序的初始版本于2017年10月由ThinkPHP 5开发&#xff0c;经过多个版本的迭代&#xff0c;于2022年3月发布了全新的2.0版本。 Lsky Pro…
阅读更多...
jQuery_02 引入jQuery，初试牛刀

jQuery_02 引入jQuery，初试牛刀

引入jquery文件 我们在官网上点击dowmload那个 会发现进入了一个网页&#xff0c;里面全部是代码&#xff0c;你可能还在想为什么下载不了&#xff0c;其实jquery不跟vue一样&#xff0c;整个jquery就是一个js文件而已&#xff0c;所以直接ctrla 全选 ctrlc复制 &#xff0c;然…
阅读更多...
PasteNow for mac剪贴板工具

PasteNow for mac剪贴板工具

PasteNow 是一款简单易用的剪贴板管理工具&#xff0c;可帮助用户快速存储和管理剪贴板上的文本和图片内容。用户可以使用 PasteNow 软件快速将文本内容保存到不同的笔记或页面中&#xff0c;也可以方便地将剪贴板上的图片保存到本地或分享给其他应用程序。 此外&#xff0c;P…
阅读更多...
nodejs+vue＋python＋PHP+微信小程序-青云商场管理系统的设计与实现-安卓-计算机毕业设计

nodejs+vue＋python＋PHP+微信小程序-青云商场管理系统的设计与实现-安卓-计算机毕业设计

研究步骤、措施&#xff1a; &#xff08;1&#xff09;与指导老师确定系统主要功能&#xff1b; &#xff08;2&#xff09;做需求分析及功能模块划分&#xff1b; &#xff08;3&#xff09;指导老师通过后&#xff0c;设计出用例图&#xff0c;E-R图&#xff0c;功能模块图 …
阅读更多...
Python开发运维：Django 4.2.7 使用Celery 5.3.5 完成异步和定时任务

Python开发运维：Django 4.2.7 使用Celery 5.3.5 完成异步和定时任务

目录 一、实验 1.Django使用Celery完成异步和定时任务 二、实验 1. 如何查看Django版本 一、实验 1.Django使用Celery完成异步和定时任务 (1)安装Django (2)新建Django项目 (3)初始框架 (4)urls.py引用视图views from django.contrib import admin from django.urls imp…
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站