• BLDC的列子2

    1.三相采样电流的采集以u相为举例。

    采集下桥臂I-V的电压。在除以采样电阻。就可以得到采样电流。但由于I-V的电压比较小。

    需要一个放大电路把电压放大ADC才采集的到。

    放大后的电压是AMP_IU.用ADC去采集这个电压。从而算出I_V的电压。 

    在电机停止的时候也会有微小的电压。并且包括1.25V的抬升电压。所以实际的电压如下计算：

     先求电机停止时的偏置电压，在求运行时的电压。

    I = (运行时的电压 - 偏置电压)/0.12 

     2.电源电压

     

    运放是一个射极跟随器所以VBUS等于A点的电压 。当用ADC采集VBUS的电压就知道A点的电压。从而可以计算出POWER的电压（分压公式）。因为POWER是电机的供电电压。当比较相差很大时就可以判断有故障发生。

    3.板子温度的采集

    板子上有一个热敏电阻随温度的变化而变化。

    跟电源电压一样运放是射极跟随器。VTEMP点的电压等于A点的电压。VCC等于3. 3v。可以求出R106的阻值。

    上面实际温度的公式是根据热敏电阻的手册可以查出的。

     上面的有些参数需要查手册如下：Rt就是通过上面分压计算得到。

     4.速度环

    当只有一对极时。旋转一圈有180度的高电平与180度的低电平（如图：霍尔1,2,3）。

    当我们求出高电平的时间（t）=高电平的计数值*PWM的频率(不是定时器的频率）。

    总的时间：2t(因为高电平与低电平相等) T=2(Cnt/fpwm) 单位s/圈。

    倒数就是：圈每秒 T=fpwm/2*Cnt   如果转为RPM乘上60即可。

    如果是两对极 T=fpwm/4*Cnt   霍尔1,2,3会经历两次的N-S。多对极依次推。

     速度环的框图：

     

     dome：速度-电流PID

    高级定时器T1(开启更新中断55us进入一次），定时器6(计时作用防止堵转）。ADC采集温度，电源电源电压，三相采样电流(力矩）。开启DMA。各采集50次求平均值。减小误差。

    高级定时器.h 与定时器6.h 一起

    1. #ifndef __BLDC_TIM_H
    2. #define __BLDC_TIM_H
    3.  
    4. #include "./SYSTEM/sys/sys.h"
    5.  
    6. /******************************************************************************************/
    7. /* 高级定时器 定义 */
    8. extern TIM_HandleTypeDef g_atimx_handle;      /* 定时器x句柄 */
    9.  /* TIMX PWM 定义 
    10.  * 注意: 通过修改这几个宏定义, 可以支持TIM1/TIM8定时器
    11.  */
    12. #define ATIM_TIMX_PWM_CH1_GPIO_PORT            GPIOA
    13. #define ATIM_TIMX_PWM_CH1_GPIO_PIN             GPIO_PIN_8
    14. #define ATIM_TIMX_PWM_CH1_GPIO_CLK_ENABLE()    do{  __HAL_RCC_GPIOA_CLK_ENABLE(); }while(0)    /* PA口时钟使能 */
    15.  
    16. #define ATIM_TIMX_PWM_CH2_GPIO_PORT            GPIOA
    17. #define ATIM_TIMX_PWM_CH2_GPIO_PIN             GPIO_PIN_9
    18. #define ATIM_TIMX_PWM_CH2_GPIO_CLK_ENABLE()    do{  __HAL_RCC_GPIOA_CLK_ENABLE(); }while(0)    /* PA口时钟使能 */
    19.  
    20. #define ATIM_TIMX_PWM_CH3_GPIO_PORT            GPIOA
    21. #define ATIM_TIMX_PWM_CH3_GPIO_PIN             GPIO_PIN_10
    22. #define ATIM_TIMX_PWM_CH3_GPIO_CLK_ENABLE()    do{  __HAL_RCC_GPIOA_CLK_ENABLE(); }while(0)    /* PA口时钟使能 */
    23.  
    24. /* 互补通道IO */
    25. #define M1_LOW_SIDE_U_PORT                      GPIOB
    26. #define M1_LOW_SIDE_U_PIN                       GPIO_PIN_13
    27. #define M1_LOW_SIDE_U_GPIO_CLK_ENABLE()         do{  __HAL_RCC_GPIOB_CLK_ENABLE(); }while(0)    /* PB口时钟使能 */
    28.  
    29. #define M1_LOW_SIDE_V_PORT                      GPIOB
    30. #define M1_LOW_SIDE_V_PIN                       GPIO_PIN_14
    31. #define M1_LOW_SIDE_V_GPIO_CLK_ENABLE()         do{  __HAL_RCC_GPIOB_CLK_ENABLE(); }while(0)    /* PB口时钟使能 */
    32.  
    33. #define M1_LOW_SIDE_W_PORT                      GPIOB
    34. #define M1_LOW_SIDE_W_PIN                       GPIO_PIN_15
    35. #define M1_LOW_SIDE_W_GPIO_CLK_ENABLE()         do{  __HAL_RCC_GPIOB_CLK_ENABLE(); }while(0)    /* PB口时钟使能 */
    36.  
    37. #define ATIM_TIMX_PWM_CHY_GPIO_AF               GPIO_AF1_TIM1
    38.  
    39. #define ATIM_TIMX_PWM                           TIM1
    40. #define ATIM_TIMX_PWM_IRQn                      TIM1_UP_TIM10_IRQn
    41. #define ATIM_TIMX_PWM_IRQHandler                TIM1_UP_TIM10_IRQHandler
    42. #define ATIM_TIMX_PWM_CH1                       TIM_CHANNEL_1                                   /* 通道1 */
    43. #define ATIM_TIMX_PWM_CH2                       TIM_CHANNEL_2                                   /* 通道2 */
    44. #define ATIM_TIMX_PWM_CH3                       TIM_CHANNEL_3                                   /* 通道3 */
    45. #define ATIM_TIMX_PWM_CHY_CLK_ENABLE()          do{ __HAL_RCC_TIM1_CLK_ENABLE(); }while(0)      /* TIM1 时钟使能 */
    46.  
    47.  
    48. /******************************************************************************************/
    49. /* 基本定时器 定义 */
    50.  
    51. /* TIMX 中断定义 
    52.  * 默认是针对TIM6
    53.  */
    54.  
    55. #define BTIM_TIMX_INT                           TIM6
    56. #define BTIM_TIMX_INT_IRQn                      TIM6_DAC_IRQn
    57. #define BTIM_TIMX_INT_IRQHandler                TIM6_DAC_IRQHandler
    58. #define BTIM_TIMX_INT_CLK_ENABLE()              do{ __HAL_RCC_TIM6_CLK_ENABLE(); }while(0)      /* TIM6 时钟使能 */
    59.  
    60. extern TIM_HandleTypeDef g_atimx_handle;                                                        /* 定时器x句柄 */
    61. /******************************************************************************************/
    62.  
    63. void atim_timx_oc_chy_init(uint16_t arr, uint16_t psc);                                         /* 高级定时器 PWM初始化函数 */
    64. void btim_timx_int_init(uint16_t arr, uint16_t psc);                                            /* 基本定时器中断初始化 */
    65.  
    66. #endif

    高级定时器.c与定时器6.c 一起 

    1. #include "./BSP/TIMER/bldc_tim.h"
    2. #include "./BSP/LED/led.h"
    3. #include "./BSP/BLDC/bldc.h"
    4. #include "./BSP/PID/pid.h"
    5. #include "./SYSTEM/delay/delay.h"
    6. #include "./BSP/ADC/adc.h"
    7. #include "./DEBUG/debug.h"
    8.  
    9. /******************************** 定时器配置句柄 定义 ***********************************/
    10.  
    11. TIM_HandleTypeDef g_atimx_handle;           /* 定时器x句柄 */
    12. TIM_OC_InitTypeDef g_atimx_oc_chy_handle;   /* 定时器输出句柄 */
    13.  
    14. /******************************** 定义全局变量 ************************************/
    15.  
    16. extern _bldc_obj g_bldc_motor1;
    17. extern PID_TypeDef  g_speed_pid;            /* 位置PID参数结构体 */
    18.  
    19. /******************************************************************************************/
    20.  
    21. /**
    22.  * @brief       高级定时器TIMX PWM 初始化函数
    23.  * @note
    24.  *              高级定时器的时钟来自APB2, 而PCLK2 = 168Mhz, 我们设置PPRE2不分频, 因此
    25.  *              高级定时器时钟 = 168Mhz
    26.  *              定时器溢出时间计算方法: Tout = ((arr + 1) * (psc + 1)) / Ft us.
    27.  *              Ft=定时器工作频率,单位:Mhz
    28.  *
    29.  * @param       arr: 自动重装值
    30.  * @param       psc: 时钟预分频数
    31.  * @retval      无
    32.  */
    33. void atim_timx_oc_chy_init(uint16_t arr, uint16_t psc)
    34. {
    35.     ATIM_TIMX_PWM_CHY_CLK_ENABLE();                             /* TIMX 时钟使能 */
    36.  
    37.  
    38.     g_atimx_handle.Instance = ATIM_TIMX_PWM;                    /* 定时器x */
    39.     g_atimx_handle.Init.Prescaler = psc;                        /* 定时器分频 */
    40.     g_atimx_handle.Init.CounterMode = TIM_COUNTERMODE_UP;       /* 向上计数模式 */
    41.     g_atimx_handle.Init.Period = arr;                           /* 自动重装载值 */
    42.     g_atimx_handle.Init.ClockDivision=TIM_CLOCKDIVISION_DIV1;   /* 分频因子 */
    43.     g_atimx_handle.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE; /*使能TIMx_ARR进行缓冲*/
    44.     g_atimx_handle.Init.RepetitionCounter = 0;                  /* 开始时不计数*/
    45.     HAL_TIM_PWM_Init(&g_atimx_handle);                          /* 初始化PWM */
    46.  
    47.     g_atimx_oc_chy_handle.OCMode = TIM_OCMODE_PWM1;             /* 模式选择PWM1 */
    48.     g_atimx_oc_chy_handle.Pulse = 0;
    49.     g_atimx_oc_chy_handle.OCPolarity = TIM_OCPOLARITY_HIGH;     /* 输出比较极性为高 */
    50.     g_atimx_oc_chy_handle.OCNPolarity = TIM_OCNPOLARITY_HIGH;
    51.     g_atimx_oc_chy_handle.OCFastMode = TIM_OCFAST_DISABLE;
    52.     g_atimx_oc_chy_handle.OCIdleState = TIM_OCIDLESTATE_RESET;
    53.     g_atimx_oc_chy_handle.OCNIdleState = TIM_OCNIDLESTATE_RESET;
    54.     HAL_TIM_PWM_ConfigChannel(&g_atimx_handle, &g_atimx_oc_chy_handle, ATIM_TIMX_PWM_CH1); /* 配置TIMx通道y */
    55.     HAL_TIM_PWM_ConfigChannel(&g_atimx_handle, &g_atimx_oc_chy_handle, ATIM_TIMX_PWM_CH2); /* 配置TIMx通道y */
    56.     HAL_TIM_PWM_ConfigChannel(&g_atimx_handle, &g_atimx_oc_chy_handle, ATIM_TIMX_PWM_CH3); /* 配置TIMx通道y */
    57.     
    58.     /* 开启定时器通道1输出PWM */
    59.     HAL_TIM_PWM_Start(&g_atimx_handle,TIM_CHANNEL_1);
    60.  
    61.     /* 开启定时器通道2输出PWM */
    62.     HAL_TIM_PWM_Start(&g_atimx_handle,TIM_CHANNEL_2);
    63.  
    64.     /* 开启定时器通道3输出PWM */
    65.     HAL_TIM_PWM_Start(&g_atimx_handle,TIM_CHANNEL_3);
    66.  
    67.     HAL_NVIC_SetPriority(TIM1_UP_TIM10_IRQn, 2, 2);
    68.     HAL_NVIC_EnableIRQ(TIM1_UP_TIM10_IRQn);
    69.  
    70.     HAL_TIM_Base_Start_IT(&g_atimx_handle);                         /* 启动高级定时器1 */
    71. }
    72.  
    73.  
    74. /**
    75.  * @brief       定时器底层驱动，时钟使能，引脚配置
    76.                 此函数会被HAL_TIM_PWM_Init()调用
    77.  * @param       htim:定时器句柄
    78.  * @retval      无
    79.  */
    80. void HAL_TIM_PWM_MspInit(TIM_HandleTypeDef *htim)
    81. {
    82.     if (htim->Instance == ATIM_TIMX_PWM)
    83.     {
    84.         GPIO_InitTypeDef gpio_init_struct;
    85.         ATIM_TIMX_PWM_CHY_CLK_ENABLE();                             /* 开启通道y的IO时钟 */
    86.         /* 三个上桥臂对应IO时钟使能 */
    87.         ATIM_TIMX_PWM_CH1_GPIO_CLK_ENABLE();                        /* IO时钟使能 */
    88.         ATIM_TIMX_PWM_CH2_GPIO_CLK_ENABLE();                        /* IO时钟使能 */
    89.         ATIM_TIMX_PWM_CH3_GPIO_CLK_ENABLE();                        /* IO时钟使能 */
    90.         /* 三个下桥臂对应IO时钟使能 */
    91.         M1_LOW_SIDE_U_GPIO_CLK_ENABLE();                            /* IO时钟使能 */
    92.         M1_LOW_SIDE_V_GPIO_CLK_ENABLE();                            /* IO时钟使能 */
    93.         M1_LOW_SIDE_W_GPIO_CLK_ENABLE();                            /* IO时钟使能 */
    94.  
    95.         /* UVW_LOW的IO初始化 */
    96.         gpio_init_struct.Pin = M1_LOW_SIDE_U_PIN;
    97.         gpio_init_struct.Pull = GPIO_NOPULL;
    98.         gpio_init_struct.Speed = GPIO_SPEED_HIGH;
    99.         gpio_init_struct.Mode = GPIO_MODE_OUTPUT_PP;                /* 推挽输出模式 */
    100.         HAL_GPIO_Init(M1_LOW_SIDE_U_PORT, &gpio_init_struct);
    101.  
    102.         gpio_init_struct.Pin = M1_LOW_SIDE_V_PIN;
    103.         HAL_GPIO_Init(M1_LOW_SIDE_V_PORT, &gpio_init_struct);
    104.  
    105.         gpio_init_struct.Pin = M1_LOW_SIDE_W_PIN;
    106.         HAL_GPIO_Init(M1_LOW_SIDE_W_PORT, &gpio_init_struct);
    107.  
    108.  
    109.         /*定时器IO初始化*/
    110.         gpio_init_struct.Pin = ATIM_TIMX_PWM_CH1_GPIO_PIN;          /* 通道y的IO口 */
    111.         gpio_init_struct.Mode = GPIO_MODE_AF_PP;                    /* 复用推挽输出 */
    112.         gpio_init_struct.Pull = GPIO_NOPULL;                        /* 上拉 */
    113.         gpio_init_struct.Speed = GPIO_SPEED_FREQ_HIGH;              /* 高速 */
    114.         gpio_init_struct.Alternate = ATIM_TIMX_PWM_CHY_GPIO_AF;     /* 端口复用 */
    115.         HAL_GPIO_Init(ATIM_TIMX_PWM_CH1_GPIO_PORT, &gpio_init_struct);
    116.  
    117.         gpio_init_struct.Pin = ATIM_TIMX_PWM_CH2_GPIO_PIN;    
    118.         HAL_GPIO_Init(ATIM_TIMX_PWM_CH2_GPIO_PORT, &gpio_init_struct);
    119.  
    120.         gpio_init_struct.Pin = ATIM_TIMX_PWM_CH3_GPIO_PIN;       
    121.         HAL_GPIO_Init(ATIM_TIMX_PWM_CH3_GPIO_PORT, &gpio_init_struct);
    122.     }
    123. }
    124. /**
    125.  * @brief       高级定时器TIMX中断服务函数
    126.  * @param       无
    127.  * @retval      无
    128.  */
    129. void ATIM_TIMX_PWM_IRQHandler(void)
    130. {
    131.     HAL_TIM_IRQHandler(&g_atimx_handle);
    132. }
    133.  
    134. /******************************************基本定时器初始化**********************************************************/
    135. TIM_HandleTypeDef timx_handler;         /* 定时器参数句柄 */
    136.  
    137.  
    138. /**
    139.  * @brief       基本定时器TIMX定时中断初始化函数
    140.  * @note
    141.  *              基本定时器的时钟来自APB1,当PPRE1 ≥ 2分频的时候
    142.  *              基本定时器的时钟为APB1时钟的2倍, 而APB1为42 所以定时器时钟 = 84MHZ
    143.  *              定时器溢出时间计算方法: Tout = ((arr + 1) * (psc + 1)) / Ft us.
    144.  *              Ft=定时器工作频率,单位:Mhz
    145.  *
    146.  * @param       arr: 自动重装值。
    147.  * @param       psc: 时钟预分频数
    148.  * @retval      无
    149.  */
    150. void btim_timx_int_init(uint16_t arr, uint16_t psc)
    151. {
    152.     timx_handler.Instance = BTIM_TIMX_INT;                      /* 基本定时器X */
    153.     timx_handler.Init.Prescaler = psc;                          /* 设置预分频器  */
    154.     timx_handler.Init.CounterMode = TIM_COUNTERMODE_UP;         /* 向上计数器 */
    155.     timx_handler.Init.Period = arr;                             /* 自动装载值 */
    156.     timx_handler.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;   /* 时钟分频因子 */
    157.     HAL_TIM_Base_Init(&timx_handler);
    158.  
    159.     HAL_TIM_Base_Start_IT(&timx_handler);                       /* 使能通用定时器x和及其更新中断：TIM_IT_UPDATE */
    160.     __HAL_TIM_CLEAR_IT(&timx_handler,TIM_IT_UPDATE);            /* 清除更新中断标志位 */
    161. }
    162.  
    163. /**
    164.  * @brief       定时器底册驱动，开启时钟，设置中断优先级
    165.                 此函数会被HAL_TIM_Base_Init()函数调用
    166.  * @param       无
    167.  * @retval      无
    168.  */
    169. void HAL_TIM_Base_MspInit(TIM_HandleTypeDef *htim)
    170. {
    171.     if (htim->Instance == BTIM_TIMX_INT)
    172.     {
    173.         BTIM_TIMX_INT_CLK_ENABLE();                     /* 使能TIM时钟*/
    174.         HAL_NVIC_SetPriority(BTIM_TIMX_INT_IRQn, 1, 3); /* 抢占1，子优先级3，组2 */
    175.         HAL_NVIC_EnableIRQ(BTIM_TIMX_INT_IRQn);         /* 开启ITM3中断 */
    176.     }
    177. }
    178.  
    179. /**
    180.  * @brief       基本定时器TIMX中断服务函数
    181.  * @param       无
    182.  * @retval      无
    183.  */
    184. void BTIM_TIMX_INT_IRQHandler(void)
    185. {
    186.     HAL_TIM_IRQHandler(&timx_handler);  /*定时器回调函数*/
    187. }
    188.  
    189.  
    190. /***********************************************定时器中断回调函数***********************************************/
    191. static uint8_t pid_s_count = 0;         /* 速度环运行标志 */
    192. static uint8_t pid_c_count = 0;         /* 电流环运行标志 */
    193. static uint8_t cf_count = 0;            /* 定时器时间记录 */
    194. int32_t temp_pwm1 = 0;                  /* 存放速度环的PID计算结果 */
    195. int32_t temp_pwm2 = 0;                  /* 存放电流环的PID计算结果 */
    196.  
    197. /* 将PID期望值进行一阶滤波后存放至以下变量 */
    198. int32_t motor_pwm_s = 0;
    199. int32_t motor_pwm_c = 0;
    200. int32_t motor_pwm_sl= 0;
    201.  
    202. /* 停机状态下电流采集使用 */
    203. #define ADC_AMP_OFFSET_TIMES 50    
    204. uint16_t adc_amp_offset[3][ADC_AMP_OFFSET_TIMES+1];
    205. uint8_t adc_amp_offset_p = 0;
    206. int16_t adc_amp[3];
    207. volatile uint16_t adc_val_m1[ADC_CH_NUM];
    208. int16_t adc_amp_un[3];
    209. float adc_amp_bus = 0.0f;
    210.  
    211. float debug_data_temp = 0.0f;
    212. float *user_setpoint = (float*)(&g_speed_pid.SetPoint); /* 目标值赋值 */
    213. uint8_t clc = 0;                                        /* 等待时间进入堵塞控制时间 */
    214. /**
    215.  * @brief       定时器中断回调
    216.  * @param       无
    217.  * @retval      无
    218.  */
    219. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
    220. {
    221.     uint8_t i;
    222.     uint8_t bldc_dir=0;
    223.     static uint8_t times_count=0;                       /* 定时器时间记录 */
    224.     int16_t temp_speed=0;                               /* 临时速度存储 */
    225.     if(htim->Instance == ATIM_TIMX_PWM)                 /* 55us */
    226.     {
    227.         if(g_bldc_motor1.run_flag == RUN)
    228.         {
    229.             /******************************* 三相电流计算 *******************************/
    230.             for(i=0; i<3; i++)
    231.             {
    232.                 adc_val_m1[i] = g_adc_val[i+2];         /* UVW三相ADC通道 */
    233.                 adc_amp[i] = adc_val_m1[i] - adc_amp_offset[i][ADC_AMP_OFFSET_TIMES];
    234.  
    235.                if(adc_amp[i] >= 0)                      /* 去除反电动势引起的负电流数据 */
    236.                adc_amp_un[i] = adc_amp[i];
    237.             }
    238.             /* 运算母线电流（母线电流为任意两个有开关动作的相电流之和）*/
    239.             if(g_bldc_motor1.step_sta == 0x05)
    240.             {
    241.                 adc_amp_bus = (adc_amp_un[0] + adc_amp_un[1])*ADC2CURT; /* UV */
    242.             }
    243.             else if(g_bldc_motor1.step_sta == 0x01)
    244.             {
    245.                 adc_amp_bus = (adc_amp_un[0] + adc_amp_un[2])*ADC2CURT; /* UW */
    246.             }
    247.             else if(g_bldc_motor1.step_sta == 0x03)
    248.             {
    249.                 adc_amp_bus = (adc_amp_un[1]+ adc_amp_un[2])*ADC2CURT;  /* VW */
    250.             }
    251.             else if(g_bldc_motor1.step_sta == 0x02)
    252.             {
    253.                 adc_amp_bus = (adc_amp_un[0]+ adc_amp_un[1])*ADC2CURT;  /* UV */
    254.             }
    255.             else if(g_bldc_motor1.step_sta == 0x06)
    256.             {
    257.                 adc_amp_bus= (adc_amp_un[0]+ adc_amp_un[2])*ADC2CURT;   /* WU */
    258.             }
    259.             else if(g_bldc_motor1.step_sta == 0x04)
    260.             {
    261.                 adc_amp_bus= (adc_amp_un[2]+ adc_amp_un[1])*ADC2CURT;   /* WV */
    262.             }
    263.             
    264.             /******************************* 六步换向 *******************************/
    265.             if(g_bldc_motor1.dir == CW)
    266.             {
    267.                 g_bldc_motor1.step_sta = hallsensor_get_state(MOTOR_1);
    268.             }
    269.             else
    270.             {
    271.                 g_bldc_motor1.step_sta = 7 - hallsensor_get_state(MOTOR_1);
    272.             }
    273.             if((g_bldc_motor1.step_sta <= 6)&&(g_bldc_motor1.step_sta >= 1))     
    274.             {
    275.                 pfunclist_m1[g_bldc_motor1.step_sta-1]();
    276.             }
    277.             else    /* 编码器错误、接触不良、断开等情况 */
    278.             {
    279.                 stop_motor1();
    280.                 g_bldc_motor1.run_flag = STOP;
    281.             }
    282.             /******************************* 速度计算 *******************************/
    283.             g_bldc_motor1.count_j++;                /* 计算速度专用计数值 */
    284.             g_bldc_motor1.hall_sta_edge = uemf_edge(g_bldc_motor1.hall_single_sta);
    285.             if(g_bldc_motor1.hall_sta_edge == 0)    /* 统计单个霍尔信号的高电平时间 */
    286.             {
    287.                 /* 计算速度 */
    288.                 if(g_bldc_motor1.dir == CW)
    289.                     temp_speed = (SPEED_COEFF/g_bldc_motor1.count_j);
    290.                 else
    291.                     temp_speed = -(SPEED_COEFF/g_bldc_motor1.count_j);
    292.                 FirstOrderRC_LPF(g_bldc_motor1.speed,temp_speed,0.2379);
    293.                 g_bldc_motor1.no_single = 0;
    294.                 g_bldc_motor1.count_j = 0;
    295.             }
    296.             if(g_bldc_motor1.hall_sta_edge == 1)
    297.             {
    298.                 g_bldc_motor1.no_single = 0;
    299.                 g_bldc_motor1.count_j = 0;
    300.             }
    301.             if(g_bldc_motor1.hall_sta_edge == 2)            /* 霍尔值一直不变代表未换向 */
    302.             {
    303.                 g_bldc_motor1.no_single++;                  /* 不换相时间累计 超时则判定速度为0 */
    304.                 if(g_bldc_motor1.no_single > 15000)
    305.                 {
    306.                     g_bldc_motor1.no_single = 0;
    307.                     g_bldc_motor1.speed = 0;                /* 超时换向 判定为停止 速度为0 */
    308.                 }
    309.             }
    310.             /******************************* 位置记录以及堵转标记 *******************************/
    311.             if(g_bldc_motor1.step_last != g_bldc_motor1.step_sta)
    312.             {
    313.                 g_bldc_motor1.hall_keep_t = 0;
    314.                 bldc_dir = check_hall_dir(&g_bldc_motor1);
    315.                 if(bldc_dir == CCW)
    316.                 {
    317.                     g_bldc_motor1.pos -= 1;
    318.                 }
    319.                 else if(bldc_dir == CW)
    320.                 {
    321.                     g_bldc_motor1.pos += 1;
    322.                 }
    323.                 g_bldc_motor1.step_last = g_bldc_motor1.step_sta;
    324.             }
    325.             else if(g_bldc_motor1.run_flag == RUN)          /* 运行且霍尔保持时 */
    326.             {
    327.                 g_bldc_motor1.hall_keep_t++;                /* 换向一次所需计数值（时间） 单位1/18k */
    328.                 if(g_bldc_motor1.hall_keep_t > 15000)       /* 堵转 */
    329.                 {
    330.                     g_bldc_motor1.hall_keep_t = 0;
    331. #if LOCK_TAC
    332.                     stop_motor1();
    333.                     g_bldc_motor1.run_flag = STOP;;         /* 标记停机 */
    334.                     g_bldc_motor1.pwm_duty = 0;
    335. #endif
    336.                     g_bldc_motor1.locked_rotor = 1;         /* 标记堵转 */
    337.                 }
    338.             }
    339.         /******************************* PID控制 *******************************/
    340.         if(g_bldc_motor1.run_flag == RUN)                   /* 进入PID闭环控制 */
    341.         {
    342.             pid_c_count++;
    343.             pid_s_count++;
    344.  
    345.             if(pid_s_count > 2)
    346.             {
    347.          /******************************* PID计算 *******************************/
    348.                 temp_pwm1 = increment_pid_ctrl(&g_speed_pid,g_bldc_motor1.speed); /* 速度环PID的控制 */
    349.                 FirstOrderRC_LPF(motor_pwm_s,temp_pwm1,0.085); /* 一阶 */
    350.                 if(motor_pwm_s < 0)
    351.                 {
    352.                     motor_pwm_sl = -motor_pwm_s;
    353.                 }
    354.                 else
    355.                 {
    356.                     motor_pwm_sl = motor_pwm_s;
    357.                 }
    358.  
    359.                 *user_setpoint = debug_data_temp;   /* 重新保持上位机指令要求 */
    360.                 pid_s_count = 0;
    361.             }
    362.  
    363.             if(pid_c_count > 1)                     /* 电流环 */
    364.             {
    365.                 /* 换向尖峰电流大于设定的电流值将导致PID调节转至电流环调节 速度环无法起作用，转速无法调节 */
    366.                 if(adc_amp_bus > (g_current_pid.SetPoint - 20))
    367.                 {
    368.                     cf_count++;                     /* 滤除换向尖峰电流的影响 */
    369.                     if(cf_count > 4)
    370.                     {
    371.                         cf_count = 0;
    372.                         temp_pwm2 = increment_pid_ctrl(&g_current_pid,adc_amp_bus); /* 电流环PID计算 */
    373.                         FirstOrderRC_LPF(motor_pwm_c,temp_pwm2,0.085);/* 一阶数字滤波 滤波系数0.08 */
    374.                     }
    375.                 }
    376.                 else
    377.                 {
    378.                     cf_count = 0;
    379.                     temp_pwm2 = increment_pid_ctrl(&g_current_pid,adc_amp_bus);
    380.                     FirstOrderRC_LPF(motor_pwm_c,temp_pwm2,0.085);
    381.                 }
    382.                 pid_c_count = 0;
    383.             }
    384.             
    385.             /* 电流环输出值大于速度环输出则使用速度环调节 */
    386.             if(motor_pwm_c > motor_pwm_sl)
    387.             {
    388.                 g_bldc_motor1.pwm_duty = motor_pwm_sl;
    389.               
    390.                 if(motor_pwm_s < 0)                     /* 正反转积分控制 */
    391.                     g_current_pid.Ui = -g_speed_pid.Ui; /* 速度环积分给电流环 */
    392.                 else
    393.                     g_current_pid.Ui = g_speed_pid.Ui;
    394.             }
    395.             else  /* 速度环输出值大于电流环输出则使用电流环调节 */
    396.             {
    397.                 g_bldc_motor1.pwm_duty = motor_pwm_c;
    398.                 if(motor_pwm_s < 0)
    399.                     g_speed_pid.Ui = -g_current_pid.Ui;/* 电流环积分给速度环 */
    400.                 else
    401.                     g_speed_pid.Ui = g_current_pid.Ui;
    402.             }
    403.         }
    404.         }
    405.     }
    406.     if(htim->Instance == TIM6)
    407.     {
    408.         /******************************* 采集电机停机状态下的偏置电压 *******************************/
    409.         times_count++;
    410.         if(g_bldc_motor1.run_flag == STOP)
    411.         {
    412.             uint8_t i;
    413.             uint32_t avg[3] = {0,0,0};
    414.             adc_amp_offset[0][adc_amp_offset_p] = g_adc_val[2];     /* 得到还未开始运动时三相的基准电压 */
    415.             adc_amp_offset[1][adc_amp_offset_p] = g_adc_val[3];
    416.             adc_amp_offset[2][adc_amp_offset_p] = g_adc_val[4];
    417.  
    418.             adc_amp_offset_p++;
    419.             NUM_CLEAR(adc_amp_offset_p,ADC_AMP_OFFSET_TIMES);       /* 最大采集ADC_AMP_OFFSET_TIMES次，超过即从0开始继续采集 */
    420.             for(i = 0; i < ADC_AMP_OFFSET_TIMES; i++)               /* 将采集的每个通道值累加 */
    421.             {
    422.                 avg[0] += adc_amp_offset[0][i];
    423.                 avg[1] += adc_amp_offset[1][i];
    424.                 avg[2] += adc_amp_offset[2][i];
    425.             }
    426.             for(i = 0; i < 3; i++)                                  /* 取平均即软件滤波 */
    427.             {
    428.                 avg[i] /= ADC_AMP_OFFSET_TIMES;
    429.                 adc_amp_offset[i][ADC_AMP_OFFSET_TIMES] = avg[i];   /* 得到还未开始运动时的基准电压 */
    430.             }
    431.         }
    432.         /******************************* 定时判断电机是否发生堵塞 *******************************/
    433.         if(times_count == SMAPLSE_PID_SPEED)
    434.         {
    435. #if (LOCK_TAC == 2)
    436.             if(g_bldc_motor1.locked_rotor == 1)         /* 堵转处理，当到达一定速度后可进入闭环控制 */
    437.             {
    438.                 clc++;
    439.                 if(clc > 50)                            /* 延迟2s后重新启动 */
    440.                 {
    441. #if DEBUG_ENABLE /*开启调试*/
    442.                     debug_send_motorstate(RUN_STATE);   /* 电机运行*/
    443. #endif
    444.                     clc = 0;
    445.                     pid_init();
    446.                     stop_motor1();
    447.                     g_speed_pid.SetPoint = 400.0;       /* 400PRM */
    448.                     g_bldc_motor1.pwm_duty = 500;       /* 加速启动速度 */
    449.                     g_bldc_motor1.run_flag = RUN;       /* 开启运行 */
    450.                     start_motor1();                     /* 运行电机 */
    451.                     g_bldc_motor1.locked_rotor = 0;
    452.                 }
    453.             }
    454. #endif
    455.             times_count = 0;
    456.         }
    457.  
    458.     }
    459. }

     霍尔传感器.h

    1. #ifndef __BLDC_H
    2. #define __BLDC_H
    3.  
    4. #include "./SYSTEM/sys/sys.h"
    5.  
    6. /******************************************************************************************/
    7. typedef struct 
    8. {
    9.     __IO uint8_t    run_flag;       /* 运行标志 */
    10.     __IO uint8_t    locked_rotor;   /* 堵转标记 */     
    11.     __IO uint8_t    step_sta;       /* 本次霍尔状态 */
    12.     __IO uint8_t    hall_single_sta;/* 单个霍尔状态 */
    13.     __IO uint8_t    hall_sta_edge;  /* 单个霍尔状态跳变 */
    14.     __IO uint8_t    step_last;      /* 上次霍尔状态 */
    15.     __IO uint8_t    dir;            /* 电机旋转方向 */
    16.     __IO int32_t    pos;            /* 电机位置 */
    17.     __IO int32_t    speed;          /* 电机速度 */
    18.     __IO int16_t    current;        /* 电机速度 */
    19.     __IO uint16_t   pwm_duty;       /* 电机占空比 */
    20.     __IO uint32_t   hall_keep_t;    /* 霍尔保持时间 */
    21.     __IO uint32_t   hall_pul_num;   /* 霍尔传感器脉冲数 */
    22.     __IO uint32_t   lock_time;      /* 电机堵转时间 */
    23.     __IO uint32_t   no_single;
    24.     __IO uint32_t   count_j;
    25.     __IO uint64_t   sum_pos;
    26. } _bldc_obj;
    27.  
    28. /******************************************************************************************/
    29. #define MOTOR_1                     1
    30. #define MOTOR_2                     2
    31.  
    32.  
    33. extern _bldc_obj g_bldc_motor1;
    34. /********************************************************************************************/
    35. /*刹车引脚*/
    36. #define SHUTDOWN_PIN                      GPIO_PIN_10    
    37. #define SHUTDOWN_PIN_GPIO                 GPIOF
    38. #define SHUTDOWN_PIN_GPIO_CLK_ENABLE()    do{  __HAL_RCC_GPIOF_CLK_ENABLE(); }while(0)    /* PF口时钟使能 */
    39.  
    40. #define SHUTDOWN2_PIN                     GPIO_PIN_2    
    41. #define SHUTDOWN2_PIN_GPIO                GPIOF
    42. #define SHUTDOWN2_PIN_GPIO_CLK_ENABLE()   do{  __HAL_RCC_GPIOF_CLK_ENABLE(); }while(0)    /* PF口时钟使能 */
    43.  
    44. #define SHUTDOWN_EN                       HAL_GPIO_WritePin(SHUTDOWN_PIN_GPIO,SHUTDOWN_PIN,GPIO_PIN_SET);
    45. #define SHUTDOWN_OFF                      HAL_GPIO_WritePin(SHUTDOWN_PIN_GPIO,SHUTDOWN_PIN,GPIO_PIN_RESET);
    46.  
    47.  
    48. #define SHUTDOWN2_EN                      HAL_GPIO_WritePin(SHUTDOWN2_PIN_GPIO,SHUTDOWN2_PIN,GPIO_PIN_SET);
    49. #define SHUTDOWN2_OFF                     HAL_GPIO_WritePin(SHUTDOWN2_PIN_GPIO,SHUTDOWN2_PIN,GPIO_PIN_RESET);
    50.  
    51. /******************************************************************************************/
    52. /*霍尔传感器接口一*/
    53.  
    54. #define HALL1_TIM_CH1_PIN           GPIO_PIN_10     /* U */
    55. #define HALL1_TIM_CH1_GPIO          GPIOH
    56. #define HALL1_U_GPIO_CLK_ENABLE()   do{  __HAL_RCC_GPIOH_CLK_ENABLE(); }while(0)    /* PH口时钟使能 */
    57.  
    58. #define HALL1_TIM_CH2_PIN           GPIO_PIN_11     /* V */
    59. #define HALL1_TIM_CH2_GPIO          GPIOH
    60. #define HALL1_V_GPIO_CLK_ENABLE()   do{  __HAL_RCC_GPIOH_CLK_ENABLE(); }while(0)    /* PH口时钟使能 */
    61.  
    62. #define HALL1_TIM_CH3_PIN           GPIO_PIN_12     /* W */
    63. #define HALL1_TIM_CH3_GPIO          GPIOH
    64. #define HALL1_W_GPIO_CLK_ENABLE()   do{  __HAL_RCC_GPIOH_CLK_ENABLE(); }while(0)    /* PH口时钟使能 */
    65.  
    66. /*霍尔传感器接口二*/
    67. #define HALL2_TIM_CH1_PIN           GPIO_PIN_12     /* U */
    68. #define HALL2_TIM_CH1_GPIO          GPIOD
    69. #define HALL2_U_GPIO_CLK_ENABLE()   do{  __HAL_RCC_GPIOD_CLK_ENABLE(); }while(0)    /* PD口时钟使能 */
    70.  
    71. #define HALL2_TIM_CH2_PIN           GPIO_PIN_13     /* V */
    72. #define HALL2_TIM_CH2_GPIO          GPIOD
    73. #define HALL2_V_GPIO_CLK_ENABLE()   do{  __HAL_RCC_GPIOD_CLK_ENABLE(); }while(0)    /* PD口时钟使能 */
    74.  
    75. #define HALL2_TIM_CH3_PIN           GPIO_PIN_8      /* W */
    76. #define HALL2_TIM_CH3_GPIO          GPIOB
    77. #define HALL2_W_GPIO_CLK_ENABLE()   do{  __HAL_RCC_GPIOB_CLK_ENABLE(); }while(0)    /* PB口时钟使能 */
    78.  
    79.  
    80.  
    81.  
    82. /********************************************************************************************/
    83. #define MAX_PWM_DUTY    (((168000/18) - 1)*0.96)
    84.  
    85. #define H_PWM_L_ON
    86. #ifndef H_PWM_L_ON
    87. #define H_PWM_L_PWM
    88. #endif
    89.  
    90. #define CCW                         (1)                 /* 逆时针 */
    91. #define CW                          (2)                 /* 顺时针 */
    92. #define HALL_ERROR                  (0xF0)              /* 霍尔错误标志 */
    93. #define RUN                         (1)                 /* 电机运动标志 */
    94. #define STOP                        (0)                 /* 电机停机标志 */
    95. #define LOCK_TAC                     2                  /* 堵转处理：2为开启，其他关闭 */
    96.  
    97. #define SPEED_COEFF      (uint32_t)((18000/4)*60)       /* 旋转一圈变化4个信号，2对级永磁体特性，NSNS共4级数*/
    98.  
    99. #define ADC2CURT    (float)(3.3f/4.096f/0.12f)
    100. #define ADC2VBUS    (float)(3.3f*25/4096)
    101.  
    102. #define NUM_CLEAR(para,val)     {if(para >= val){para=0;}}
    103. #define NUM_MAX_LIMIT(para,val) {if(para > val){para=val;}}
    104. #define NUM_MIN_LIMIT(para,val) {if(para < val){para=val;}}
    105.  
    106. typedef void(*pctr) (void);
    107.  
    108. void stop_motor1(void);
    109. void start_motor1(void);
    110.  
    111. #define FirstOrderRC_LPF(Yn_1,Xn,a) Yn_1 = (1-a)*Yn_1 + a*Xn;   /* Yn:out;Xn:in;a:系数 */
    112. /******************************************************************************************/
    113. /* 外部接口函数*/
    114. void bldc_init(uint16_t arr, uint16_t psc);                     /* BLDC初始化 */
    115. uint8_t check_hall_dir(_bldc_obj * obj);                        /* 检测电机旋转方向 */
    116. extern pctr pfunclist_m1[6];                                    /* 六步换相函数指针数组 */
    117. void bldc_ctrl(uint8_t motor_id,int32_t dir,float duty);        /* bldc控制函数 */
    118. uint8_t uemf_edge(uint8_t val);                                 /* 波形状态检测 */
    119. float get_temp(uint16_t para);                                  /* 获取温度值 */
    120. void calc_adc_val(uint16_t * p);                                /* adc数据软件滤波函数 */
    121. void hall_gpio_init(void);                                      /* 霍尔接口初始化 */
    122. uint32_t hallsensor_get_state(uint8_t motor_id);                /* 获取霍尔状态 */
    123. /* 六步换相 */
    124. void m1_uhvl(void);
    125. void m1_uhwl(void);
    126. void m1_vhwl(void);
    127. void m1_vhul(void);
    128. void m1_whul(void);
    129. void m1_whvl(void);
    130.  
    131. #endif

      霍尔传感器.C

    1.  
    2. #include "./BSP/BLDC/bldc.h"
    3. #include "./BSP/TIMER/bldc_tim.h"
    4. #include "./BSP/ADC/adc.h"
    5. #include "math.h"
    6.  
    7. _bldc_obj g_bldc_motor1 = {STOP,0,0,CCW,0,0,0,0,0,0};   /* 电机结构体 */
    8.  
    9. const uint8_t hall_table_cw[6] = {6,2,3,1,5,4};         /* 顺时针旋转表 */
    10. const uint8_t hall_table_ccw[6] = {5,1,3,2,6,4};        /* 逆时针旋转表 */
    11.  
    12. const uint8_t hall_cw_table[12] = {0x62,0x23,0x31,0x15,0x54,0x46,0x63,0x21,0x35,0x14,0x56,0x42};  /* 顺方向组合 */
    13. const uint8_t hall_ccw_table[12] = {0x45,0x51,0x13,0x32,0x26,0x64,0x41,0x53,0x12,0x36,0x24,0x65}; /* 逆方向组合 */
    14. /**
    15.  * @brief       无刷电机初始化，包括定时器，霍尔接口以及SD引脚初始化
    16.  * @param       arr: 自动重装值
    17.  * @param       psc: 时钟预分频数
    18.  * @retval      无
    19.  */
    20. void bldc_init(uint16_t arr, uint16_t psc)
    21. {       
    22.     GPIO_InitTypeDef gpio_init_struct;
    23.     
    24.     SHUTDOWN_PIN_GPIO_CLK_ENABLE();
    25.     SHUTDOWN2_PIN_GPIO_CLK_ENABLE();
    26.   
    27.     gpio_init_struct.Pin = SHUTDOWN_PIN;
    28.     gpio_init_struct.Mode = GPIO_MODE_OUTPUT_PP;
    29.     gpio_init_struct.Pull = GPIO_NOPULL;
    30.     gpio_init_struct.Speed = GPIO_SPEED_FREQ_LOW;
    31.     HAL_GPIO_Init(SHUTDOWN_PIN_GPIO, &gpio_init_struct);    
    32.     
    33.     gpio_init_struct.Pin = SHUTDOWN2_PIN;
    34.     HAL_GPIO_Init(SHUTDOWN2_PIN_GPIO, &gpio_init_struct);  
    35.     hall_gpio_init();             /* 霍尔接口初始化 */
    36.     atim_timx_oc_chy_init(arr,  psc);
    37.     btim_timx_int_init(1000 - 1 , 84 - 1);
    38. }
    39.  
    40. /**
    41.  * @brief       BLDC控制函数
    42.  * @param       dir :电机方向, Duty:PWM占空比
    43.  * @retval      无
    44.  */
    45. void bldc_ctrl(uint8_t motor_id,int32_t dir,float duty)
    46. {
    47.     if(motor_id == MOTOR_1)
    48.     {
    49.         g_bldc_motor1.dir = dir;            /* 方向 */
    50.         g_bldc_motor1.pwm_duty = duty;      /* 占空比 */
    51.     }
    52. }
    53. /**
    54.  * @brief       旋转方向检测函数
    55.  * @param       obj:电机控制句柄
    56.  * @retval      旋转方向定义如下：
    57.  *              正转，CW
    58.  *              反转，CCW
    59.  */
    60. uint8_t check_hall_dir(_bldc_obj * obj)
    61. {
    62.     uint8_t temp,res = HALL_ERROR;
    63.     if((obj->step_last <= 6)&&(obj->step_sta <= 6))
    64.     {
    65.         temp = ((obj->step_last & 0x0F) << 4)|(obj->step_sta & 0x0F);
    66.         if((temp == hall_ccw_table[0])||(temp == hall_ccw_table[1])||\
    67.                 (temp == hall_ccw_table[2])||(temp == hall_ccw_table[3])||\
    68.                 (temp == hall_ccw_table[4])||(temp == hall_ccw_table[5]))
    69.         {
    70.             res  = CCW;
    71.         }
    72.         else if((temp == hall_cw_table[0])||(temp == hall_cw_table[1])||\
    73.                 (temp == hall_cw_table[2])||(temp == hall_cw_table[3])||\
    74.                 (temp == hall_cw_table[4])||(temp == hall_cw_table[5]))
    75.         {
    76.             res  = CW;
    77.         }
    78.     }
    79.     return res;
    80. }
    81. /*****************************************************************************************/
    82. /*霍尔接口初始化*/
    83.  
    84. /**
    85.   * @brief  霍尔传感器定时器初始化
    86.   * @param  无
    87.   * @retval 无
    88.   */
    89. void hall_gpio_init(void)
    90. {
    91.     GPIO_InitTypeDef gpio_init_struct;
    92.     HALL1_U_GPIO_CLK_ENABLE();
    93.     HALL1_V_GPIO_CLK_ENABLE();
    94.     HALL1_W_GPIO_CLK_ENABLE();
    95.  
    96.     HALL2_U_GPIO_CLK_ENABLE();
    97.     HALL2_V_GPIO_CLK_ENABLE();
    98.     HALL2_W_GPIO_CLK_ENABLE();
    99.  
    100.     /* 霍尔通道 1 引脚初始化 */
    101.     gpio_init_struct.Pin = HALL1_TIM_CH1_PIN;
    102.     gpio_init_struct.Mode = GPIO_MODE_INPUT;
    103.     gpio_init_struct.Pull = GPIO_PULLUP;
    104.     HAL_GPIO_Init(HALL1_TIM_CH1_GPIO, &gpio_init_struct);
    105.  
    106.     /* 霍尔通道 2 引脚初始化 */
    107.     gpio_init_struct.Pin = HALL1_TIM_CH2_PIN;
    108.     HAL_GPIO_Init(HALL1_TIM_CH2_GPIO, &gpio_init_struct);
    109.  
    110.     /* 霍尔通道 3 引脚初始化 */
    111.     gpio_init_struct.Pin = HALL1_TIM_CH3_PIN;
    112.     HAL_GPIO_Init(HALL1_TIM_CH3_GPIO, &gpio_init_struct);
    113.  
    114. }
    115.  
    116.  
    117. /**
    118.  * @brief       获取霍尔传感器引脚状态
    119.  * @param       无
    120.  * @retval      霍尔传感器引脚状态
    121.  */
    122. uint32_t hallsensor_get_state(uint8_t motor_id)
    123. {
    124.     __IO static uint32_t State ;
    125.     State  = 0;
    126.     if(motor_id == MOTOR_1)
    127.     {
    128.         if(HAL_GPIO_ReadPin(HALL1_TIM_CH1_GPIO,HALL1_TIM_CH1_PIN) != GPIO_PIN_RESET)  /* 霍尔传感器状态获取 */
    129.         {
    130.             State |= 0x01U;
    131.         }
    132.         if(HAL_GPIO_ReadPin(HALL1_TIM_CH2_GPIO,HALL1_TIM_CH2_PIN) != GPIO_PIN_RESET)  /* 霍尔传感器状态获取 */
    133.         {
    134.             State |= 0x02U;
    135.         }
    136.         if(HAL_GPIO_ReadPin(HALL1_TIM_CH3_GPIO,HALL1_TIM_CH3_PIN) != GPIO_PIN_RESET)  /* 霍尔传感器状态获取 */
    137.         {
    138.             State |= 0x04U;
    139.             g_bldc_motor1.hall_single_sta=1;
    140.         }
    141.         else
    142.             g_bldc_motor1.hall_single_sta=0;
    143.     }
    144.     return State;
    145. }
    146.  
    147. /************************************* BLDC相关函数 *************************************/
    148. /* 关闭电机运转 */
    149. void stop_motor1(void)
    150. {
    151.     /* 关闭半桥芯片输出 */
    152.     SHUTDOWN_OFF;
    153.     /* 关闭PWM输出 */
    154.     HAL_TIM_PWM_Stop(&g_atimx_handle,TIM_CHANNEL_1);
    155.     HAL_TIM_PWM_Stop(&g_atimx_handle,TIM_CHANNEL_2);
    156.     HAL_TIM_PWM_Stop(&g_atimx_handle,TIM_CHANNEL_3);
    157.     /* 上下桥臂全部关断 */
    158.     g_atimx_handle.Instance->CCR2 = 0;
    159.     g_atimx_handle.Instance->CCR1 = 0;
    160.     g_atimx_handle.Instance->CCR3 = 0;
    161.     HAL_GPIO_WritePin(M1_LOW_SIDE_U_PORT,M1_LOW_SIDE_U_PIN,GPIO_PIN_RESET);
    162.     HAL_GPIO_WritePin(M1_LOW_SIDE_V_PORT,M1_LOW_SIDE_V_PIN,GPIO_PIN_RESET);
    163.     HAL_GPIO_WritePin(M1_LOW_SIDE_W_PORT,M1_LOW_SIDE_W_PIN,GPIO_PIN_RESET);
    164. }
    165.  
    166. /* 开启电机运转 */
    167. void start_motor1(void)
    168. {
    169.     SHUTDOWN_EN;
    170.     /* 使能PWM输出 */
    171.     HAL_TIM_PWM_Start(&g_atimx_handle,TIM_CHANNEL_1);
    172.     HAL_TIM_PWM_Start(&g_atimx_handle,TIM_CHANNEL_2);
    173.     HAL_TIM_PWM_Start(&g_atimx_handle,TIM_CHANNEL_3);
    174. }
    175.  
    176. /*****************************************************************************************/
    177. /*  六步换向函数指针 */
    178. pctr pfunclist_m1[6] =
    179. {
    180.     &m1_uhwl, &m1_vhul, &m1_vhwl,
    181.     &m1_whvl, &m1_uhvl, &m1_whul
    182. };
    183.  
    184. /* 上下桥臂的导通情况，共6种，也称为6步换向 */
    185. void m1_uhvl(void)
    186. {
    187.     g_atimx_handle.Instance->CCR2 = 0;
    188.     g_atimx_handle.Instance->CCR1 = g_bldc_motor1.pwm_duty;                 /* U相上桥臂PWM */
    189.     g_atimx_handle.Instance->CCR3 = 0;
    190.     HAL_GPIO_WritePin(M1_LOW_SIDE_V_PORT,M1_LOW_SIDE_V_PIN,GPIO_PIN_SET);   /* V相下桥臂导通 */
    191.     HAL_GPIO_WritePin(M1_LOW_SIDE_U_PORT,M1_LOW_SIDE_U_PIN,GPIO_PIN_RESET); /* U相下桥臂关闭 */
    192.     HAL_GPIO_WritePin(M1_LOW_SIDE_W_PORT,M1_LOW_SIDE_W_PIN,GPIO_PIN_RESET); /* W相下桥臂关闭 */
    193. }
    194.  
    195. void m1_uhwl(void)
    196. {
    197.     g_atimx_handle.Instance->CCR2 = 0;
    198.     g_atimx_handle.Instance->CCR1 = g_bldc_motor1.pwm_duty;
    199.     g_atimx_handle.Instance->CCR3 = 0;
    200.     HAL_GPIO_WritePin(M1_LOW_SIDE_W_PORT,M1_LOW_SIDE_W_PIN,GPIO_PIN_SET);
    201.     HAL_GPIO_WritePin(M1_LOW_SIDE_U_PORT,M1_LOW_SIDE_U_PIN,GPIO_PIN_RESET);
    202.     HAL_GPIO_WritePin(M1_LOW_SIDE_V_PORT,M1_LOW_SIDE_V_PIN,GPIO_PIN_RESET);
    203. }
    204.  
    205. void m1_vhwl(void)
    206. {
    207.     g_atimx_handle.Instance->CCR1=0;
    208.     g_atimx_handle.Instance->CCR2 = g_bldc_motor1.pwm_duty;
    209.     g_atimx_handle.Instance->CCR3=0;
    210.     HAL_GPIO_WritePin(M1_LOW_SIDE_W_PORT,M1_LOW_SIDE_W_PIN,GPIO_PIN_SET);
    211.     HAL_GPIO_WritePin(M1_LOW_SIDE_U_PORT,M1_LOW_SIDE_U_PIN,GPIO_PIN_RESET);
    212.     HAL_GPIO_WritePin(M1_LOW_SIDE_V_PORT,M1_LOW_SIDE_V_PIN,GPIO_PIN_RESET);
    213. }
    214.  
    215. void m1_vhul(void)
    216. {
    217.     g_atimx_handle.Instance->CCR1 = 0;
    218.     g_atimx_handle.Instance->CCR2 = g_bldc_motor1.pwm_duty;
    219.     g_atimx_handle.Instance->CCR3 = 0;
    220.     HAL_GPIO_WritePin(M1_LOW_SIDE_U_PORT,M1_LOW_SIDE_U_PIN,GPIO_PIN_SET);
    221.     HAL_GPIO_WritePin(M1_LOW_SIDE_V_PORT,M1_LOW_SIDE_V_PIN,GPIO_PIN_RESET);
    222.     HAL_GPIO_WritePin(M1_LOW_SIDE_W_PORT,M1_LOW_SIDE_W_PIN,GPIO_PIN_RESET);
    223. }
    224.  
    225.  
    226. void m1_whul(void)
    227. {
    228.     g_atimx_handle.Instance->CCR2 = 0;
    229.     g_atimx_handle.Instance->CCR3 = g_bldc_motor1.pwm_duty;
    230.     g_atimx_handle.Instance->CCR1 = 0;
    231.     HAL_GPIO_WritePin(M1_LOW_SIDE_U_PORT,M1_LOW_SIDE_U_PIN,GPIO_PIN_SET);
    232.     HAL_GPIO_WritePin(M1_LOW_SIDE_V_PORT,M1_LOW_SIDE_V_PIN,GPIO_PIN_RESET);
    233.     HAL_GPIO_WritePin(M1_LOW_SIDE_W_PORT,M1_LOW_SIDE_W_PIN,GPIO_PIN_RESET);
    234. }
    235.  
    236. void m1_whvl(void)
    237. {
    238.     g_atimx_handle.Instance->CCR2 = 0;
    239.     g_atimx_handle.Instance->CCR3 = g_bldc_motor1.pwm_duty;
    240.     g_atimx_handle.Instance->CCR1 = 0;
    241.     HAL_GPIO_WritePin(M1_LOW_SIDE_V_PORT,M1_LOW_SIDE_V_PIN,GPIO_PIN_SET);
    242.     HAL_GPIO_WritePin(M1_LOW_SIDE_U_PORT,M1_LOW_SIDE_U_PIN,GPIO_PIN_RESET);
    243.     HAL_GPIO_WritePin(M1_LOW_SIDE_W_PORT,M1_LOW_SIDE_W_PIN,GPIO_PIN_RESET);
    244. }
    245.  
    246. /**
    247.  * @brief       检测输入信号是否发生变化
    248.  * @param       val :输入信号
    249.  * @note        测量速度使用，获取输入信号状态翻转情况，计算速度
    250.  * @retval      0：计算高电平时间，1：计算低电平时间，2：信号未改变
    251.  */
    252. uint8_t uemf_edge(uint8_t val)
    253. {
    254.     /* 主要是检测val信号从0 - 1 在从 1 - 0的过程，即高电平所持续的过程 */
    255.     static uint8_t oldval=0;
    256.     if(oldval != val)
    257.     {
    258.         oldval = val;
    259.         if(val == 0) return 0;
    260.         else return 1;
    261.     }
    262.     return 2;
    263. }
    264.  
    265. /*************************************    第二部分    电压电流温度采集    **********************************************/
    266. /*
    267.     Rt = Rp *exp(B*(1/T1-1/T2))
    269.     Rt 是热敏电阻在T1温度下的阻值；
    270.     Rp是热敏电阻在T2常温下的标称阻值；
    271.     exp是e的n次方，e是自然常数，就是自然对数的底数，近似等于 2.7182818；
    272.     B值是热敏电阻的重要参数，教程中用到的热敏电阻B值为3380；
    273.     这里T1和T2指的是开尔文温度，T2是常温25℃，即(273.15+25)K
    274.     T1就是所求的温度
    275. */
    276. const float Rp = 10000.0f;          /* 10K */
    277. const float T2 = (273.15f + 25.0f); /* T2 */
    278. const float Bx = 3380.0f;           /* B */
    279. const float Ka = 273.15f;
    280.  
    281. /**
    282.  * @brief       计算温度值
    283.  * @param       para: 温度采集对应ADC通道的值（已滤波）
    284.  * @note        计算温度分为两步：
    285.                 1.根据ADC采集到的值计算当前对应的Rt
    286.                 2.根据Rt计算对应的温度值
    287.  * @retval      温度值
    288.  */
    289. float get_temp(uint16_t para)
    290. {
    291.     float Rt;
    292.     float temp;
    293.     Rt = 3.3f / (para * 3.3f / 4096.0f / 4700.0f) - 4700.0f;
    294.     /* like this R=5000, T2=273.15+25,B=3470, RT=5000*EXP(3470*(1/T1-1/(273.15+25)) */
    295.     temp = Rt / Rp;
    296.     temp = log(temp);       /* ln(Rt/Rp) */
    297.     temp /= Bx;             /* ln(Rt/Rp)/B */
    298.     temp += (1.0f / T2);
    299.     temp = 1.0f / (temp);
    300.     temp -= Ka;
    301.     return temp;
    302. }
    303.  
    304. extern uint16_t g_adc_value[ADC_CH_NUM * ADC_COLL];
    305. /**
    306.  * @brief       计算ADC的平均值（滤波）
    307.  * @param       * p ：存放ADC值的指针地址
    308.  * @note        此函数对电压、温度、电流对应的ADC值进行滤波
    309.  * @retval      无
    310.  */
    311. void calc_adc_val(uint16_t * p)
    312. {
    313.     uint32_t temp[ADC_CH_NUM] = {0,0,0};             /* 定义一个缓存数组 */
    314.     int i,j;                                         /* 循环采集ADC_COLL次数 */
    315.     for(i=0;i/* 根据ADC通道数循环获取，并累加 */
    316.     {
    317.         for(j=0;j/* 将采集到的ADC值，各通道进行累加 */
    318.         {
    319.             temp[j] += g_adc_value[j+i*ADC_CH_NUM];
    320.         }
    321.     }
    322.     for(j=0;j
    323.     {
    324.         temp[j] /= ADC_COLL;                         /* 获取平均值 */
    325.         p[j] = temp[j];                              /* 存到*p */
    326.     }
    327. }

    ADC.h

    1. #ifndef __ADC_H
    2. #define __ADC_H
    3.  
    4. #include "./SYSTEM/sys/sys.h"
    5.  
    6.  
    7. /******************************************************************************************/
    8. /* ADC及引脚 定义 */
    9.  
    10. #define ADC_ADCX_CH0_GPIO_PORT              GPIOB                                               /* 电源电压采集引脚 */
    11. #define ADC_ADCX_CH0_GPIO_PIN               GPIO_PIN_1
    12. #define ADC_ADCX_CH0_GPIO_CLK_ENABLE()      do{ __HAL_RCC_GPIOB_CLK_ENABLE(); }while(0)
    13.  
    14. #define ADC_ADCX_CH1_GPIO_PORT              GPIOA                                               /* 温度采集引脚 */
    15. #define ADC_ADCX_CH1_GPIO_PIN               GPIO_PIN_0
    16. #define ADC_ADCX_CH1_GPIO_CLK_ENABLE()      do{ __HAL_RCC_GPIOA_CLK_ENABLE(); }while(0)
    17.  
    18. #define ADC_ADCX_CH2_GPIO_PORT              GPIOB                                               /* U相采集引脚 */
    19. #define ADC_ADCX_CH2_GPIO_PIN               GPIO_PIN_0
    20. #define ADC_ADCX_CH2_GPIO_CLK_ENABLE()      do{ __HAL_RCC_GPIOB_CLK_ENABLE(); }while(0)
    21.  
    22. #define ADC_ADCX_CH3_GPIO_PORT              GPIOA                                               /* V相采集引脚 */
    23. #define ADC_ADCX_CH3_GPIO_PIN               GPIO_PIN_6
    24. #define ADC_ADCX_CH3_GPIO_CLK_ENABLE()      do{ __HAL_RCC_GPIOA_CLK_ENABLE(); }while(0)
    25.  
    26. #define ADC_ADCX_CH4_GPIO_PORT              GPIOA                                               /* W相采集引脚 */
    27. #define ADC_ADCX_CH4_GPIO_PIN               GPIO_PIN_3
    28. #define ADC_ADCX_CH4_GPIO_CLK_ENABLE()      do{ __HAL_RCC_GPIOA_CLK_ENABLE(); }while(0)
    29.  
    30. #define ADC_ADCX                            ADC1 
    31. #define ADC_ADCX_CH0                        ADC_CHANNEL_9                                       /* 通道Y,  0 <= Y <= 17 */ 
    32. #define ADC_ADCX_CH1                        ADC_CHANNEL_0
    33. #define ADC_ADCX_CH2                        ADC_CHANNEL_8
    34. #define ADC_ADCX_CH3                        ADC_CHANNEL_6
    35. #define ADC_ADCX_CH4                        ADC_CHANNEL_3
    36.  
    37. #define ADC_ADCX_CHY_CLK_ENABLE()           do{ __HAL_RCC_ADC1_CLK_ENABLE(); }while(0)          /* ADC1 时钟使能 */
    38.  
    39. #define ADC_CH_NUM                          5                                                   /* 需要转换的通道数目 */
    40. #define ADC_COLL                            50                                                  /* 单采集次数 */
    41. #define ADC_SUM                             ADC_CH_NUM * ADC_COLL                               /* 总采集次数 */
    42.  
    43. /* ADC单通道/多通道 DMA采集 DMA数据流相关 定义
    44.  * 注意: 这里我们的通道还是使用上面的定义.
    45.  */
    46. #define ADC_ADCX_DMASx                      DMA2_Stream4
    47. #define ADC_ADCX_DMASx_Chanel               DMA_CHANNEL_0                                       /* ADC1_DMA请求源 */
    48. #define ADC_ADCX_DMASx_IRQn                 DMA2_Stream4_IRQn
    49. #define ADC_ADCX_DMASx_IRQHandler           DMA2_Stream4_IRQHandler
    50.  
    51. extern uint16_t g_adc_val[ADC_CH_NUM];
    52.  
    53.  
    54. /******************************************************************************************/
    55.  
    56. void adc_init(void);                                                                            /* ADC初始化 */
    57. uint32_t adc_get_result_average(uint8_t ch);                                                    /* 获得某个通道值  */
    58. void adc_nch_dma_init(void);
    59.  
    60. #endif

     ADC.c

    1.  
    2. #include "./BSP/ADC/adc.h"
    3. #include "./SYSTEM/delay/delay.h"
    4. #include "./BSP/DMA/dma.h"
    5. #include "./BSP/BLDC/bldc.h"
    6. #include "./BSP/TIMER/bldc_tim.h"
    7.  
    8. /* 多通道ADC采集 DMA读取 */
    9. ADC_HandleTypeDef g_adc_nch_dma_handle;     /* 与DMA关联的ADC句柄 */
    10. DMA_HandleTypeDef g_dma_nch_adc_handle;     /* 与ADC关联的DMA句柄 */
    11. uint8_t g_adc_dma_sta = 0;                  /* DMA传输状态标志, 0,未完成; 1, 已完成 */
    12.  
    13. uint16_t g_adc_value[ADC_CH_NUM * ADC_COLL] = {0};     /* 存储ADC原始值 */
    14. float g_adc_u_value[ADC_CH_NUM] = {0};      /* 存储ADC转换后的电压值 */
    15.  
    16. /***************************************多通道ADC采集(DMA读取)程序*****************************************/
    17.  
    18.  
    19. /**
    20.  * @brief       ADC初始化
    21.  * @param       无
    22.  * @retval      无
    23.  */
    24. void adc_init(void)
    25. {
    26.     ADC_ChannelConfTypeDef sConfig = {0};
    27.  
    28.     g_adc_nch_dma_handle.Instance = ADC_ADCX;
    29.     g_adc_nch_dma_handle.Init.ClockPrescaler = ADC_CLOCK_SYNC_PCLK_DIV4;            /* 4分频，ADCCLK = PCLK2/4 = 84/4 = 21Mhz */
    30.     g_adc_nch_dma_handle.Init.Resolution = ADC_RESOLUTION_12B;                      /* 12位模式 */
    31.     g_adc_nch_dma_handle.Init.ScanConvMode = ENABLE;                                /* 扫描模式 多通道使用 */
    32.     g_adc_nch_dma_handle.Init.ContinuousConvMode = ENABLE;                          /* 连续转换模式，转换完成之后接着继续转换 */
    33.     g_adc_nch_dma_handle.Init.DiscontinuousConvMode = DISABLE;                      /* 禁止不连续采样模式 */
    34.     g_adc_nch_dma_handle.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE; /* 使用软件触发 */
    35.     g_adc_nch_dma_handle.Init.ExternalTrigConv = ADC_SOFTWARE_START;                /* 软件触发 */
    36.     g_adc_nch_dma_handle.Init.DataAlign = ADC_DATAALIGN_RIGHT;                      /* 右对齐 */
    37.     g_adc_nch_dma_handle.Init.NbrOfConversion = ADC_CH_NUM;                         /* 使用转换通道数，需根据实际转换通道去设置 */
    38.     g_adc_nch_dma_handle.Init.DMAContinuousRequests = ENABLE;                       /* 开启DMA连续转换 */
    39.     g_adc_nch_dma_handle.Init.EOCSelection = ADC_EOC_SEQ_CONV;
    40.     HAL_ADC_Init(&g_adc_nch_dma_handle);
    41.  
    42.     /* 配置使用的ADC通道，采样序列里的第几个转换，增加或者减少通道需要修改这部分 */
    43.     sConfig.Channel = ADC_ADCX_CH0;                         /* 电源电压采集 */
    44.     sConfig.Rank = 1;
    45.     sConfig.SamplingTime = ADC_SAMPLETIME_28CYCLES;
    46.     HAL_ADC_ConfigChannel(&g_adc_nch_dma_handle, &sConfig);
    47.  
    48.     sConfig.Channel = ADC_ADCX_CH1;                         /* 温度采集 */
    49.     sConfig.Rank = 2;
    50.     HAL_ADC_ConfigChannel(&g_adc_nch_dma_handle, &sConfig);
    51.  
    52.     sConfig.Channel = ADC_ADCX_CH2;                         /* U相电压采集 */
    53.     sConfig.Rank = 3;
    54.     HAL_ADC_ConfigChannel(&g_adc_nch_dma_handle, &sConfig);
    55.     
    56.     sConfig.Channel = ADC_ADCX_CH3;                         /* V相电压采集 */
    57.     sConfig.Rank = 4;
    58.     HAL_ADC_ConfigChannel(&g_adc_nch_dma_handle, &sConfig);
    59.     
    60.     sConfig.Channel = ADC_ADCX_CH4;                         /* W相电压采集 */
    61.     sConfig.Rank = 5;
    62.     HAL_ADC_ConfigChannel(&g_adc_nch_dma_handle, &sConfig);
    63.     
    64. }
    65.  
    66. /**
    67.  * @brief       ADC DMA读取 初始化函数
    68.  *   @note      本函数还是使用adc_init对ADC进行大部分配置,有差异的地方再单独配置
    69.  * @param       par         : 外设地址
    70.  * @param       mar         : 存储器地址
    71.  * @retval      无
    72.  */
    73. void adc_nch_dma_init(void)
    74. {
    75.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    76.       
    77.     ADC_ADCX_CHY_CLK_ENABLE();           /* 使能ADCx时钟 */
    78.     ADC_ADCX_CH0_GPIO_CLK_ENABLE();      /* 开启GPIO时钟 */
    79.     ADC_ADCX_CH1_GPIO_CLK_ENABLE();
    80.     ADC_ADCX_CH2_GPIO_CLK_ENABLE();
    81.     ADC_ADCX_CH3_GPIO_CLK_ENABLE();
    82.     ADC_ADCX_CH4_GPIO_CLK_ENABLE();
    83.     
    84.     /* AD采集引脚模式设置,模拟输入 */
    85.     GPIO_InitStruct.Pin = ADC_ADCX_CH0_GPIO_PIN;
    86.     GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
    87.     GPIO_InitStruct.Pull = GPIO_NOPULL;
    88.     HAL_GPIO_Init(ADC_ADCX_CH0_GPIO_PORT, &GPIO_InitStruct);
    89.  
    90.     GPIO_InitStruct.Pin = ADC_ADCX_CH1_GPIO_PIN;
    91.     HAL_GPIO_Init(ADC_ADCX_CH1_GPIO_PORT, &GPIO_InitStruct);
    92.     
    93.     GPIO_InitStruct.Pin = ADC_ADCX_CH2_GPIO_PIN;   
    94.     HAL_GPIO_Init(ADC_ADCX_CH2_GPIO_PORT, &GPIO_InitStruct); 
    95.     
    96.     GPIO_InitStruct.Pin = ADC_ADCX_CH3_GPIO_PIN;   
    97.     HAL_GPIO_Init(ADC_ADCX_CH3_GPIO_PORT, &GPIO_InitStruct); 
    98.     
    99.     GPIO_InitStruct.Pin = ADC_ADCX_CH4_GPIO_PIN;   
    100.     HAL_GPIO_Init(ADC_ADCX_CH4_GPIO_PORT, &GPIO_InitStruct); 
    101.     
    102.     adc_init();
    103.     
    104.     if ((uint32_t)ADC_ADCX_DMASx > (uint32_t)DMA2)                              /* 大于DMA1_Channel7, 则为DMA2的通道了 */
    105.     {
    106.         __HAL_RCC_DMA2_CLK_ENABLE();                                            /* DMA2时钟使能 */
    107.     }
    108.     else 
    109.     {
    110.         __HAL_RCC_DMA1_CLK_ENABLE();                                            /* DMA1时钟使能 */
    111.     }
    112.  
    113.     /* DMA配置 */
    114.     g_dma_nch_adc_handle.Instance = ADC_ADCX_DMASx;                             /* 设置DMA通道 */
    115.     g_dma_nch_adc_handle.Init.Channel = DMA_CHANNEL_0;
    116.     g_dma_nch_adc_handle.Init.Direction = DMA_PERIPH_TO_MEMORY;                 /* DIR = 1 ,  外设到存储器模式 */
    117.     g_dma_nch_adc_handle.Init.PeriphInc = DMA_PINC_DISABLE;                     /* 外设非增量模式 */
    118.     g_dma_nch_adc_handle.Init.MemInc = DMA_MINC_ENABLE;                         /* 存储器增量模式 */
    119.     g_dma_nch_adc_handle.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD;    /* 外设数据长度:16位 */
    120.     g_dma_nch_adc_handle.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD;       /* 存储器数据长度:16位 */
    121.     g_dma_nch_adc_handle.Init.Mode = DMA_CIRCULAR;                              /* 外设流控模式 */
    122.     g_dma_nch_adc_handle.Init.Priority = DMA_PRIORITY_MEDIUM;                   /* 中等优先级 */
    123.     HAL_DMA_Init(&g_dma_nch_adc_handle);
    124.  
    125.     __HAL_LINKDMA(&g_adc_nch_dma_handle,DMA_Handle,g_dma_nch_adc_handle);
    126.  
    127.     HAL_NVIC_SetPriority(ADC_ADCX_DMASx_IRQn, 2, 1);
    128.     HAL_NVIC_EnableIRQ(ADC_ADCX_DMASx_IRQn);
    129.     
    130.     HAL_ADC_Start_DMA(&g_adc_nch_dma_handle,(uint32_t *)g_adc_value,ADC_CH_NUM * ADC_COLL);
    131. }
    132.  
    133.  
    134. /**
    135.  * @brief       ADC DMA采集中断服务函数
    136.  * @param       无 
    137.  * @retval      无
    138.  */
    139. void ADC_ADCX_DMASx_IRQHandler(void)
    140. {
    141.     HAL_DMA_IRQHandler(&g_dma_nch_adc_handle);
    142. }
    143.  
    144. uint16_t g_adc_val[ADC_CH_NUM];                     /* ADC平均值存放数组 */
    145.  
    146. void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* hadc)
    147. {
    148.     if (hadc->Instance == ADC1)                     /* 大约2.6ms采集完成进入中断 */
    149.     { 
    150.         HAL_ADC_Stop_DMA(&g_adc_nch_dma_handle);    /* 关闭DMA转换 */
    151.         calc_adc_val(g_adc_val);                    /* ADC数值转换 */
    152.         HAL_ADC_Start_DMA(&g_adc_nch_dma_handle, (uint32_t *)&g_adc_value, (uint32_t)(ADC_SUM)); /* 再启动DMA转换 */
    153.     }
    154. }
    155.  
    156.  
    157. /**
    158.  * @brief       获取通道ch的转换值，取times次, 然后平均
    159.  * @param       ch      : 通道号, 0~17
    160.  * @retval      通道ch的times次转换结果平均值
    161.  */
    162. uint32_t adc_get_result_average(uint8_t ch)
    163. {
    164.     uint32_t temp_val = 0;
    165.     uint16_t t;
    166.  
    167.     for (t = ch; t < ADC_SUM; t += ADC_CH_NUM )     /* 获取times次数据 */
    168.     {
    169.         temp_val += g_adc_value[t];
    170.     }
    171.  
    172.     return temp_val / ADC_COLL;                     /* 返回平均值 */
    173. }

     pid.h

    1. #ifndef __PID_H
    2. #define __PID_H
    3.  
    4. #include "./SYSTEM/sys/sys.h"
    5.  
    6. /************************************ PID相关参数 ****************************************/
    7.  
    8. #define  C_KP      2.00f            /* P参数 */
    9. #define  C_KI      0.20f            /* I参数 */
    10. #define  C_KD      0.01f            /* D参数 */
    11.  
    12. #define  S_KP      0.00800f         /* P参数 */
    13. #define  S_KI      0.00025f         /* I参数 */
    14. #define  S_KD      0.00020f         /* D参数 */
    15.  
    16. #define SMAPLSE_PID_SPEED  40       /* 采样率 单位ms */
    17.  
    18. /*PID结构体*/
    19. typedef struct
    20. {
    21.     __IO float  SetPoint;           /* 设定目标 */
    22.     __IO float  ActualValue;        /* 实际值 */
    23.     __IO float  SumError;           /* 误差累计 */
    24.     __IO float  Up;                 /* 比例项 */
    25.     __IO float  Ui;                 /* 积分项 */
    26.     __IO float  Ud;                 /* 微分项 */
    27.     __IO float  Proportion;         /* 比例常数 P */
    28.     __IO float  Integral;           /* 积分常数 I */
    29.     __IO float  Derivative;         /* 微分常数 D */
    30.     __IO float  Error;              /* Error[-1] */
    31.     __IO float  LastError;          /* Error[-1] */
    32.     __IO float  PrevError;          /* Error[-2] */
    33.     __IO float  IngMin;
    34.     __IO float  IngMax;
    35.     __IO float  OutMin;
    36.     __IO float  OutMax;
    37. } PID_TypeDef;
    38.  
    39. #define LIMIT_OUT(var,max,min) {(var)=(var)>(max)?(max):(var);(var)=(var)<(min)?(min):(var);}
    40.  
    41. extern PID_TypeDef  g_current_pid;  /* 电流PID参数结构体 */
    42. extern PID_TypeDef  g_speed_pid;    /* 速度PID参数结构体 */
    43.  
    44. /*********************************** 函数声明 **************************************/
    45.  
    46. void pid_init(void);                /* PID初始化函数 */
    47. int32_t increment_pid_ctrl(PID_TypeDef *PID,float Feedback_value); /* PID控制算法 */
    48.  
    49. #endif

    pid.c

    1. #include "./BSP/PID/pid.h"
    2. #include "./BSP/BLDC/bldc.h"
    3.  
    4. PID_TypeDef  g_current_pid;             /* 电流PID参数结构体 */
    5. PID_TypeDef  g_speed_pid;               /* 速度PID参数结构体 */
    6. /**
    7.  * @brief       初始化PID
    8.  * @param       无
    9.  * @retval      无
    10.  */
    11. void pid_init(void)
    12. {
    13.     /* 设定电流目标1500mA(空载最小电流400mA左右)较高的转速对应的电流较大，力矩较大，可适应较高的转速调节*/
    14.     /* 【注意】如设置的转速对应的电流超过了电流设定值，将导致PID转至电流环调节，转速将无法继续提升 */
    15.     g_current_pid.SetPoint = 1500.0;
    16.     g_current_pid.ActualValue = 0.0;    /* 设定目标Desired Value */
    17.     g_current_pid.LastError = 0.0;      /* Error[1] */
    18.     g_current_pid.LastError = 0.0;      /* Error[-1] */
    19.     g_current_pid.PrevError = 0.0;      /* Error[-2] */
    20.     g_current_pid.Proportion = C_KP;    /* 比例常数 Proportional Const */
    21.     g_current_pid.Integral = C_KI;      /* 积分常数 Integral Const */
    22.     g_current_pid.Derivative = C_KD;    /* 微分常数 Derivative Const */
    23.     g_current_pid.IngMax = 9000;        /* 积分限制 */
    24.     g_current_pid.IngMin = 600;
    25.     g_current_pid.OutMin = 600;
    26.     g_current_pid.OutMax = 9000;        /* 期望限制 */
    27.     
    28.     g_speed_pid.SetPoint = 0;           /* 设定目标Desired Value */
    29.     g_speed_pid.ActualValue = 0.0;      /* 设定目标Desired Value */
    30.     g_speed_pid.Ui = 0.0;
    31.     g_speed_pid.Up = 0.0;
    32.     g_speed_pid.Ud = 0.0;
    33.     g_speed_pid.Error = 0.0;            /* Error[1] */
    34.     g_speed_pid.LastError = 0.0;        /* Error[-1] */
    35.     g_speed_pid.PrevError = 0.0;        /* Error[-2] */
    36.     g_speed_pid.Proportion = S_KP;      /* 比例常数 Proportional Const */
    37.     g_speed_pid.Integral = S_KI;        /* 积分常数 Integral Const */
    38.     g_speed_pid.Derivative = S_KD;      /* 微分常数 Derivative Const */ 
    39.     g_speed_pid.IngMax = 9000;
    40.     g_speed_pid.IngMin = -9000;
    41.     g_speed_pid.OutMax = 9000;          /* 输出限制 */
    42.     g_speed_pid.OutMin = -9000;
    43. }
    44.  
    45. /**
    46.  * @brief       位置式PID算法
    47.  * @param       *PID：PID结构体句柄所对应的目标值
    48.  * @param       Feedback_value ： 实际值
    49.  * @retval      目标控制量
    50.  */
    51. int32_t increment_pid_ctrl(PID_TypeDef *PID,float Feedback_value)
    52. {
    53.     PID->Error = (float)(PID->SetPoint - Feedback_value);   /* 目标值与实际值的偏差值 */
    54.     PID->Up = PID->Proportion * PID->Error;
    55.     PID->Ui += (PID->Error * PID->Integral);
    56.     LIMIT_OUT(PID->Ui,PID->IngMax,PID->IngMin);             /* 积分限制 */
    57.     PID->Ud = PID->Derivative * (PID->Error - PID->LastError);
    58.     PID->ActualValue = PID->Up + PID->Ui + PID->Ud;
    59.     LIMIT_OUT(PID->ActualValue,PID->OutMax,PID->OutMin);    /* 输出限制 */
    60.     PID->LastError = PID->Error;                            /* 存储上次误差，以便下次计算使用 */
    61.     return ((int32_t)(PID->ActualValue));                   /* 返回实际控制数值 */
    62. }

     main.c

    1. #include "./SYSTEM/sys/sys.h"
    2. #include "./SYSTEM/usart/usart.h"
    3. #include "./SYSTEM/delay/delay.h"
    4. #include "./BSP/LED/led.h"
    5. #include "./BSP/TIMER/bldc_tim.h"
    6. #include "./BSP/KEY/key.h"
    7. #include "./BSP/LCD/lcd.h"
    8. #include "./BSP/BLDC/bldc.h"
    9. #include "./BSP/PID/pid.h"
    10. #include "./DEBUG/debug.h"
    11. #include "./BSP/ADC/adc.h"
    12.  
    13. extern float*user_setpoint;
    14. extern float debug_data_temp;
    15. extern int32_t motor_pwm_s;
    16. extern int32_t temp_pwm1;
    17. extern int16_t adc_amp_un[3];
    18. extern float  adc_amp_bus;
    19. extern uint16_t g_adc_value[ADC_CH_NUM * ADC_COLL];
    20. extern uint8_t clc;
    21. void bldc_speed_stop(void);                  /* 清除电机状态并关闭电机 */
    22.  
    23. int main(void)
    24. {
    25.     uint8_t debug_cmd = 0;                   /* 存放上位机指令 */
    26.     float current_lpf[4] = {0.0f};           /* 存放三相电流以及母线电流 */
    27.     uint8_t key,t;
    28.     char buf[32];
    29.     float current[3] = {0.0f};
    30.     int16_t speed_diplay = 0;
    31.     float user_setpoint_temp  = 0.0;
    32.  
    33.     HAL_Init();                              /* 初始化HAL库 */
    34.     sys_stm32_clock_init(336, 8, 2, 7);      /* 设置时钟,168Mhz */
    35.     delay_init(168);                         /* 延时初始化 */
    36.     usart_init(115200);                      /* 串口初始化为115200 */
    37.     led_init();                              /* 初始化LED */
    38.     key_init();                              /* 初始化按键 */
    39.     lcd_init();                              /* 初始化LCD */
    40.     bldc_init(168000/18-1,0);                /* 18KHz */
    41.     bldc_ctrl(MOTOR_1,CCW,0);                /* 初始无刷电机接口1速度 */
    42.     pid_init();
    43.     g_point_color = WHITE;
    44.     g_back_color  = BLACK;
    45.     adc_nch_dma_init();
    46.     while (1)
    47.     {
    48.         t++;
    49.         if(t % 20 == 0)
    50.         {
    51.             sprintf(buf,"PWM_Duty:%.1f%%  ",(float)((g_bldc_motor1.pwm_duty/MAX_PWM_DUTY)*100));        /* 显示控制PWM占空比 */
    52.             lcd_show_string(10,110,200,16,16,buf,g_point_color);
    53.  
    54.             user_setpoint_temp = (*user_setpoint);
    55.             speed_diplay = g_bldc_motor1.speed;
    56.             sprintf(buf,"SetSpeed:%4d   ",(int16_t)user_setpoint_temp);                                 /* 显示设置速度 */
    57.             lcd_show_string(10,110,200,16,16,buf,g_point_color);
    58.             sprintf(buf,"M1 speed:%4d   ",speed_diplay);                                                /* 显示转速 */
    59.             lcd_show_string(10,130,200,16,16,buf,g_point_color);
    60.             sprintf(buf,"M1 pos:%4d",g_bldc_motor1.pos);                                                /* 显示位置变化 */
    61.             lcd_show_string(10,150,200,16,16,buf,g_point_color);
    62.             sprintf(buf,"PWM_Duty:%.1f%%  ",(float)((g_bldc_motor1.pwm_duty/(float)MAX_PWM_DUTY)*100)); /* 显示控制PWM占空比 */
    63.             lcd_show_string(10,170,200,16,16,buf,g_point_color);
    64.  
    65.  
    66.             sprintf(buf,"Power:%.3fV ",g_adc_value[0]*ADC2VBUS);
    67.             lcd_show_string(10,190,200,16,16,buf,g_point_color);
    68.             sprintf(buf,"Temp:%.1fC ",get_temp(g_adc_value[1]));
    69.             lcd_show_string(10,210,200,16,16,buf,g_point_color);
    70.             LED0_TOGGLE();                                                                              /* LED0(红灯) 翻转 */
    71.             /* 三相电流计算 */
    72.             current[0] = adc_amp_un[0]* ADC2CURT;/*U*/
    73.             current[1] = adc_amp_un[1]* ADC2CURT;/*V*/
    74.             current[2] = adc_amp_un[2]* ADC2CURT;/*W*/
    75.  
    76.             /*一阶数字滤波 滤波系数0.1 用于显示*/
    77.             FirstOrderRC_LPF(current_lpf[0],current[0],0.1f);
    78.             FirstOrderRC_LPF(current_lpf[1],current[1],0.1f);
    79.             FirstOrderRC_LPF(current_lpf[2],current[2],0.1f);
    80.             FirstOrderRC_LPF(current_lpf[3],adc_amp_bus,0.1f);
    81.             if(g_bldc_motor1.run_flag == STOP)                  /* 停机的电流显示 */
    82.             {
    83.                 current_lpf[0]=0;
    84.                 current_lpf[1]=0;
    85.                 current_lpf[2]=0;
    86.                 current_lpf[3]=0;
    87.             }
    88.             
    89.         }
    90.  
    91.         key = key_scan(0);
    92.         if(key == KEY0_PRES)                                    /* 按下KEY0目标速度值++ */
    93.         {
    94.             g_bldc_motor1.run_flag = RUN;                       /* 开启运行 */
    95.             start_motor1();                                     /* 开启运行 */
    96.  
    97.             if(g_bldc_motor1.dir == CCW && *user_setpoint == 0) /* 切换方向条件*/
    98.             {
    99.                 g_bldc_motor1.dir = CW; 
    100.             }
    101.             *user_setpoint += 400;                              /* 逆时针旋转下递增 */
    102.             if(*user_setpoint >= 3000)                          /* 最高不超过3000PRM */
    103.                 *user_setpoint = 3000;
    104.             if(*user_setpoint == 0)
    105.             {
    106.                 pid_init();                                     /* 初始化PID */
    107.                 g_bldc_motor1.run_flag = STOP;                  /* 标记停机 */
    108.                 stop_motor1();                                  /* 停机 */
    109.                 g_bldc_motor1.speed = 0;
    110.                 motor_pwm_s = 0;
    111.                 g_bldc_motor1.pwm_duty = 0;
    112.             }
    113.             debug_data_temp = *user_setpoint;
    114.         }
    115.         else if(key == KEY1_PRES)                               /* 按下KEY1目标速度值-- */
    116.         {
    117.             g_bldc_motor1.run_flag = RUN;                       /* 开启运行 */
    118.             start_motor1();                                     /* 运行电机 */
    119.             /* 切换方向条件 */
    120.             if(g_bldc_motor1.dir == CW && *user_setpoint == 0)
    121.             {
    122.                 g_bldc_motor1.dir = CCW;
    123.             }
    124.             *user_setpoint -= 400;                              /* 逆时针旋转下递增 */
    125.             if(*user_setpoint <= -3000)                         /* 最高不超过300PRM */
    126.                 *user_setpoint = -3000;
    127.             if(*user_setpoint == 0)
    128.             {
    129.                 pid_init();                                     /* 初始化PID */
    130.                 g_bldc_motor1.run_flag = STOP;                  /* 标记停机 */
    131.                 stop_motor1();                                  /* 停机 */
    132.                 g_bldc_motor1.speed = 0;
    133.                 motor_pwm_s = 0;
    134.                 g_bldc_motor1.pwm_duty = 0;
    135.             }
    136.  
    137.             debug_data_temp = *user_setpoint;
    138.         }
    139.         else if(key == KEY2_PRES)                               /* 按下KEY2关闭电机 */
    140.         {
    141.             bldc_speed_stop();
    142.         }
    143.  
    144.         delay_ms(10);
    145.     }
    146. }
    147. /**
    148.  * @brief       关闭电机并清除状态
    149.  * @param       无
    150.  * @retval      无
    151.  */
    152. void bldc_speed_stop(void)
    153. {
    154.     pid_init();
    155.     g_bldc_motor1.run_flag = STOP;  /* 标记停机 */
    156.     stop_motor1();                  /* 停机 */
    157.     g_bldc_motor1.speed = 0;
    158.     motor_pwm_s = 0;
    159.     g_bldc_motor1.pwm_duty = 0;
    160. }

     g_bldc_motor1.count_j就是高电平的计数值。在高电平时先清零累加。从1到0为低电平时。后去 g_bldc_motor1.count_j的值就是高电平的计数值。

    #define SPEED_COEFF      (uint32_t)((18000/4)*60)       /* 旋转一圈变化4个信号，2对级永磁体特性，NSNS共4级数 */

    速度计算：temp_speed = (SPEED_COEFF/g_bldc_motor1.count_j)

    速度的计算在代码的体现：电机是两对极。完全与公式是相同的。

      

     

  • 相关阅读:
    MySQL高级篇——事务
    基于nodejs+vue云旅青城系统
    全网超50万粉丝的Linux大咖良许，出书了！
    pg 时间操作方法
    入侵防御系统（IPS）网络安全设备介绍
    Django项目 - 合并PDF文件
    基于Java+vue前后端分离失物招领信息交互平台设计实现(源码+lw+部署文档+讲解等)
    PHP学习笔记（一往无前）
    实时监控Mysql等数据库变化_进行数据同步_了解Debezium_--Debezium工作笔记001
    R语言ggplot2可视化：使用patchwork包将2个ggplot2可视化结果横向组合、并自定义修改（更改）组合图像中指定子图的主题（theme）
  • 原文地址：https://blog.csdn.net/qq_41328470/article/details/127950618