ucosii+STM32 BLDC电机控制器设计附源程序Proteus仿真 -

在这次设计过程中，期间遇到许许多多问题，对电机的控制不熟悉导致换向失败，仿真过程不收敛，定时器不起作用，引脚之间相互干扰，输入捕获无法同时进行，pwm模式设置错误导致pid控制越调速度越快等等问题，最后都比较好的解决了这些问题，当然程序和设计中还存在一些问题，由于时间关系无法全部解决，在以后的学习过程中，如果有机会会继续深入学习。

单片机源程序如下:

/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "adc.h"
#include "tim.h"
#include "gpio.h"
/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include "includes.h"
#include "lcd.h"
/* USER CODE END Includes */
/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */
/* USER CODE END PTD */
/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
#define HALL_GPIO GPIOA
//START 任务
//设置任务优先级
#define START_TASK_PRIO 10 //开始任务的优先级设置为最低
//设置任务堆栈大小
#define START_STK_SIZE 64
//任务堆栈
OS_STK START_TASK_STK[START_STK_SIZE];
//任务函数
void start_task(void *pdata);
//LED0任务
//设置任务优先级
#define LED0_TASK_PRIO 2
//设置任务堆栈大小
#define LED0_STK_SIZE 64
//任务堆栈
OS_STK LED0_TASK_STK[LED0_STK_SIZE];
//任务函数
void led0_task(void *pdata);
//Speed_ADC 任务
//设置任务优先级
#define SPEED_ADC_TASK_PRIO 1
//设置任务堆栈大小
#define SPEED_ADC_STK_SIZE 64
//任务堆栈
OS_STK SPEED_ADC_TASK_STK[SPEED_ADC_STK_SIZE];
//任务函数
void speed_adc_task(void *pdata);
/* USER CODE END PD */
/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */
/* USER CODE END PM */
/* Private variables ---------------------------------------------------------*/
/* USER CODE BEGIN PV */
//定时器2捕获通道参数
/* Private variables ---------------------------------------------------------*/
uint16_t Channel1HighTime, Channel2HighTime, Channel3HighTime; //高电平时间
uint16_t Channel1Period, Channel2Period, Channel3Period; //周期
uint8_t Channel1Edge = 0, Channel2Edge = 0, Channel3Edge = 0; //上升沿
uint16_t Channel1Percent, Channel2Percent, Channel3Percent; //占空比
uint16_t Channel1PercentTemp[3] = {0, 0, 0};
uint8_t Channel1TempCount = 0;
uint16_t Channel1RisingTimeLast=0, Channel1RisingTimeNow, Channel1FallingTime;
uint16_t Channel2RisingTimeLast=0, Channel2RisingTimeNow, Channel2FallingTime;
uint16_t Channel3RisingTimeLast=0, Channel3RisingTimeNow, Channel3FallingTime;
extern int motor_period;
extern int motor_duty;
extern int clock_wise;
int current_speed = 0;
int ADC_Speed = 500; //555 / 90% = 500
int ADC_Value = 555; //
BOOLEAN state = 0; // 0 关闭中 1 启动中
/* USER CODE END PV */
/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
/* USER CODE BEGIN PFP */
/* USER CODE END PFP */
/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
/* USER CODE END 0 */
/**
* @brief The application entry point.
* @retval int
*/
int main(void)
{
/* USER CODE BEGIN 1 */
HAL_NVIC_SetPriorityGrouping(NVIC_PRIORITYGROUP_2);//设置中断优先级分组为组2：2位抢占优先级，2位响应优先级
OSInit();
OSTaskCreate(start_task,(void *)0,(OS_STK *)&START_TASK_STK[START_STK_SIZE-1],START_TASK_PRIO );//创建起始任务
/* USER CODE END 1 */
/* MCU Configuration--------------------------------------------------------*/
/* Reset of all peripherals, Initializes the Flash interface and the Systick. */
HAL_Init();
/* USER CODE BEGIN Init */
/* USER CODE END Init */
/* Configure the system clock */
SystemClock_Config();
/* USER CODE BEGIN SysInit */
/* USER CODE END SysInit */
/* Initialize all configured peripherals */
MX_GPIO_Init();
MX_TIM1_Init();
MX_ADC1_Init();
MX_TIM2_Init();
/* USER CODE BEGIN 2 */
OSStart();
/* USER CODE END 2 */
/* Infinite loop */
/* USER CODE BEGIN WHILE */
while (1)
{
/* USER CODE END WHILE */
/* USER CODE BEGIN 3 */
}
/* USER CODE END 3 */
}
/**
* @brief System Clock Configuration
* @retval None
*/
void SystemClock_Config(void)
{
RCC_OscInitTypeDef RCC_OscInitStruct = {0};
RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
RCC_PeriphCLKInitTypeDef PeriphClkInit = {0};
/** Initializes the CPU, AHB and APB busses clocks
*/
RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
RCC_OscInitStruct.HSEState = RCC_HSE_ON;
RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
RCC_OscInitStruct.HSIState = RCC_HSI_ON;
RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL2;
if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
{
Error_Handler();
}
/** Initializes the CPU, AHB and APB busses clocks
*/
RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
|RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV2;
RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_0) != HAL_OK)
{
Error_Handler();
}
PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_ADC;
PeriphClkInit.AdcClockSelection = RCC_ADCPCLK2_DIV2;
if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)
{
Error_Handler();
}
}
/* USER CODE BEGIN 4 */
//开始任务
void start_task(void *pdata)
{
// //设置通道1的脉宽。 width = (1000 - 500) / 1000 = 50%
__HAL_TIM_SET_COMPARE(&htim1, TIM_CHANNEL_1, motor_duty);
__HAL_TIM_SET_COMPARE(&htim1, TIM_CHANNEL_2, motor_duty);
__HAL_TIM_SET_COMPARE(&htim1, TIM_CHANNEL_3, motor_duty);
//打开定时器2通道，中断使能
HAL_TIM_IC_Start_IT(&htim2, TIM_CHANNEL_1);
HAL_TIM_IC_Start_IT(&htim2, TIM_CHANNEL_2);
HAL_TIM_IC_Start_IT(&htim2, TIM_CHANNEL_3);
HAL_Delay(100);
//开启定时器1的通道1
HAL_TIMEx_PWMN_Start(&htim1, TIM_CHANNEL_1);
HAL_TIMEx_PWMN_Start(&htim1, TIM_CHANNEL_2);
HAL_TIMEx_PWMN_Start(&htim1, TIM_CHANNEL_3);
//
HAL_TIM_PWM_Start(&htim1, TIM_CHANNEL_1);
HAL_TIM_PWM_Start(&htim1, TIM_CHANNEL_2);
HAL_TIM_PWM_Start(&htim1, TIM_CHANNEL_3);
//
uint16_t hall_read = (HALL_GPIO->IDR)&0x0007; // 获取霍尔传感器状态 pin0 1 2__IO uint8_t uwStep = 0;
BLDC_PHASE_CHANGE(hall_read); // 驱动换相
//PID初始化
Speed_PIDInit();
OS_CPU_SR cpu_sr=0;
OS_ENTER_CRITICAL(); //进入临界区(无法被中断打断)
OSTaskCreate(led0_task,(void *)0,(OS_STK*)&LED0_TASK_STK[LED0_STK_SIZE-1],LED0_TASK_PRIO);
OSTaskCreate(speed_adc_task,(void *)0,(OS_STK*)&SPEED_ADC_TASK_STK[SPEED_ADC_STK_SIZE-1],SPEED_ADC_TASK_PRIO);
OSTaskSuspend(START_TASK_PRIO); //挂起起始任务.
OS_EXIT_CRITICAL(); //退出临界区(可以被中断打断)
}
//LED0任务
void speed_adc_task(void *pdata)
{
lcd_system_reset();
unsigned char temp_table[16] ={"Cur_Speed:"};
unsigned char temp_table1[16] ={"Tar_Speed:"};
for(uint8_t i=0;i<10;i++)
{
lcd_char_write(i,0,temp_table[i]);
lcd_char_write(i,1,temp_table1[i]);
}
HAL_ADC_Start(&hadc1);
while(1)
{
HAL_ADC_PollForConversion(&hadc1,0); //等待转换完成,第二个参数代表最长等待时间ms
if(HAL_IS_BIT_SET(HAL_ADC_GetState(&hadc1), HAL_ADC_STATE_REG_EOC))
{
ADC_Value = HAL_ADC_GetValue(&hadc1); // 读取ADC数据，4096 -> 3.3V
ADC_Speed = ADC_Value + 500; //转换公式 0-4096 -> 500 - 4596
// if(ADC_Speed > 100){
// HAL_GPIO_TogglePin(led_GPIO_Port, led_Pin);
// }
}
//当前速度
temp_table[10]=current_speed/1000+'0';
temp_table[11]=current_speed/100%10+'0';
temp_table[12]=current_speed/10%10+'0';
temp_table[13]=current_speed%10+'0';
//目标速度
temp_table1[10]=ADC_Speed/1000+'0';
temp_table1[11]=ADC_Speed/100%10+'0';
temp_table1[12]=ADC_Speed/10%10+'0';
temp_table1[13]=ADC_Speed%10+'0';
for(uint8_t i=10;i<14;i++)
{
lcd_char_write(i,0,temp_table[i]);
lcd_char_write(i,1,temp_table1[i]);
}
}
}
//speed adc 采样函数
void led0_task(void *pdata)
{
while(1)
{
HAL_GPIO_WritePin(led_GPIO_Port, led_Pin, GPIO_PIN_SET);
OSTimeDly(10);
HAL_GPIO_WritePin(led_GPIO_Port, led_Pin, GPIO_PIN_RESET);
OSTimeDly(10);
}
}
//外部中断服务函数
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
if(!state)
{
__IO uint8_t uwStep = 0;
uint16_t hall_read=(HALL_GPIO->IDR)&0x0007; // 获取霍尔传感器状态 pin0 1 2
uwStep = hall_read;
BLDC_PHASE_CHANGE(uwStep); // 驱动换相
}
uint16_t key_read =(Start_GPIO_Port->IDR)&0x00e0;
if(key_read == 0x00c0)
{
// state = !state;
// HAL_TIM_PWM_Stop(&htim1, TIM_CHANNEL_1);
// HAL_TIM_PWM_Stop(&htim1, TIM_CHANNEL_2);
// HAL_TIM_PWM_Stop(&htim1, TIM_CHANNEL_3);
//
// //BLDC_PHASE_CHANGE(7);
// HAL_TIM_Base_MspDeInit(&htim1);
//
// HAL_Delay(300);
// HAL_TIM_Base_MspDeInit(&htim1);
// HAL_TIM_PWM_Start(&htim1, TIM_CHANNEL_1);
// HAL_TIM_PWM_Start(&htim1, TIM_CHANNEL_2);
// HAL_TIM_PWM_Start(&htim1, TIM_CHANNEL_3);
// BLDC_PHASE_CHANGE(7);
//HAL_GPIO_TogglePin(led_GPIO_Port, led_Pin);
}else if(key_read == 0x00a0)
{
clock_wise = 0;
}else if(key_read == 0x0060)
{
clock_wise = 1;
}
}
//定时器2中断函数
//溢出时间为1s
//溢出值1000 每个点为1ms
void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim)
{
if(htim->Channel == HAL_TIM_ACTIVE_CHANNEL_1) //捕获中断
{
/*
测速逻辑
1、中断产生，先判断是否为第一次上升沿
2、捕获到上升沿后，将时间点存入变量，切换捕获下降沿
3、捕获到下降沿后，记下时间点，切换为捕获上升沿
4、捕获到上升沿后，记下时间点
5、计算周期和占空比
6、问题如果经过多个周期才有一次上升沿和下降沿怎么办，需要记录溢出次数
如果溢出的时候有上升沿标志位
问题：proteus三路输入捕获计算，测转速时，如果第一个上升沿和第二个上升沿不在一个定时器计数周期，会计算失败
*/
if(Channel1Edge == 0)
{
//获取通道1上升沿时间点
Channel1RisingTimeNow = HAL_TIM_ReadCapturedValue(&htim2, TIM_CHANNEL_1);
Channel1Edge = 1;//捕获上升沿置位
Channel1RisingTimeLast = Channel1RisingTimeNow;
}else if(Channel1Edge == 1)
{
Channel1RisingTimeNow = HAL_TIM_ReadCapturedValue(&htim2, TIM_CHANNEL_1);
if(Channel1RisingTimeNow > Channel1RisingTimeLast)
{
Channel1Period = Channel1RisingTimeNow - Channel1RisingTimeLast;
}
else
{
//Channel2Period = Channel2RisingTimeNow + 1000 - Channel2RisingTimeLast + 1;
}
Channel1Edge = 0;
//pid计算
// current_speed = 60*1000 / Channel1Period; //转速计算
// current_speed = current_speed * 5; //速度调整系数
// motor_duty = Speed_PIDAdjust(current_speed);
}
}else if(htim->Channel == HAL_TIM_ACTIVE_CHANNEL_2)
{
if(Channel2Edge == 0)
{
Channel2RisingTimeNow = HAL_TIM_ReadCapturedValue(&htim2, TIM_CHANNEL_2);
Channel2Edge = 1;
Channel2RisingTimeLast = Channel2RisingTimeNow;
}
else if(Channel2Edge == 1)
{
Channel2RisingTimeNow = HAL_TIM_ReadCapturedValue(&htim2, TIM_CHANNEL_2);
if(Channel2RisingTimeNow > Channel2RisingTimeLast)
{
Channel2Period = Channel2RisingTimeNow - Channel2RisingTimeLast;
}
else
{
//Channel2Period = Channel2RisingTimeNow + 1000 - Channel2RisingTimeLast + 1;
}
current_speed = 60*1000 / Channel2Period;
current_speed = current_speed * 5; //速度调整系数
motor_duty = Speed_PIDAdjust(current_speed);
Channel2Edge = 0;
}
}
else if(htim->Channel == HAL_TIM_ACTIVE_CHANNEL_3)
{
if(Channel3Edge == 0)
{
Channel3RisingTimeNow = HAL_TIM_ReadCapturedValue(&htim2, TIM_CHANNEL_3);
Channel3Edge = 1;
Channel3RisingTimeLast = Channel3RisingTimeNow;
}
else if(Channel3Edge == 1)
{
Channel3RisingTimeNow = HAL_TIM_ReadCapturedValue(&htim2, TIM_CHANNEL_3);
if(Channel3RisingTimeNow > Channel3RisingTimeLast)
{
Channel3Period = Channel3RisingTimeNow - Channel3RisingTimeLast;
}
else
{
//Channel3Period = Channel3RisingTimeNow + 1000 - Channel3RisingTimeLast + 1;
}
// current_speed = 60*1000 / Channel3Period;
// current_speed = current_speed * 5; //速度调整系数
// motor_duty = Speed_PIDAdjust(current_speed);
Channel3Edge = 0;
}
}
}
/* USER CODE END 4 */
/**
* @brief This function is executed in case of error occurrence.
* @retval None
*/
void Error_Handler(void)
{
/* USER CODE BEGIN Error_Handler_Debug */
/* User can add his own implementation to report the HAL error return state */
/* USER CODE END Error_Handler_Debug */
}
#ifdef USE_FULL_ASSERT
/**
* @brief Reports the name of the source file and the source line number
* where the assert_param error has occurred.
* @param file: pointer to the source file name
* @param line: assert_param error line source number
* @retval None
*/
void assert_failed(uint8_t *file, uint32_t line)
{
/* USER CODE BEGIN 6 */
/* User can add his own implementation to report the file name and line number,
tex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
/* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

复制代码

所有资料51hei提供下载:

Proteus.zip (102.55 KB, 下载次数: 554)

文档.docx (758.47 KB, 下载次数: 378)

uCos_ii_Demo.7z (5.21 MB, 下载次数: 497)