21ic电子技术开发论坛 › 单片机与嵌入式系统 › 新唐MCU › N76E003 控制开环无刷直流（BLDC）电机
返回列表 发新帖我要提问

[DemoCode下载] N76E003 控制开环无刷直流（BLDC）电机

[复制链接]
1945|7
 楼主| wanduzi 发表于 2024-2-25 19:52 | 显示全部楼层 |阅读模式
se, N76E003, 控制, 电机, 无刷直流, BLDC
EC_N76E003_Open_Loop_BLDC_Motor_V1.00 (3).zip (639.95 KB, 下载次数: 42)
复制
  1. /**************************************************************************//**
    

  2. * [url=home.php?mod=space&uid=288409]@file[/url]     main.c
    

  3. * [url=home.php?mod=space&uid=895143]@version[/url]  V1.00
    

  4. * [url=home.php?mod=space&uid=247401]@brief[/url]    Open Loop BLDC Motor
    

  5. *
    

  6. * @note
    

  7. * Copyright (C) 2019 Nuvoton Technology Corp. All rights reserved.
    

  8. *****************************************************************************/
    


  9. 

  10. /*---------------------------------------------------------------------------------------------------------*/
    

  11. /* Pin Functions                                                                                           */
    

  12. /*---------------------------------------------------------------------------------------------------------*/
    

  13. //P07 - HALL Sensor W Phase, HALL_W
    

  14. //P06 - HALL Sensor V Phase, HALL_V
    

  15. //P05 - HALL Sensor U Phase, HALL_U
    

  16. //P12 - Upper-arm MOS control of U phase, uh
    

  17. //P14 - Lower-arm MOS control of U phase, ul
    

  18. //P10 - Upper-arm MOS control of V phase, vh
    

  19. //P00 - Lower-arm MOS control of V phase, vl
    

  20. //P01 - Upper-arm MOS control of W phase, wh
    

  21. //P03 - Lower-arm MOS control of W phase, wl
    

  22. //P15 - Motor on/off switch
    

  23. //P02 - UART RX
    

  24. //P16 - UART TX
    

  25. //P17 - ADC input
    


  26. 

  27. /*---------------------------------------------------------------------------------------------------------*/
    

  28. /* Include File                                                                                            */
    

  29. /*---------------------------------------------------------------------------------------------------------*/
    

  30. #include "N76E003.h"
    

  31. #include "Common.h"
    

  32. #include "Delay.h"
    

  33. #include "SFR_Macro.h"
    

  34. #include "Function_define.h"
    


  35. 

  36. /*---------------------------------------------------------------------------------------------------------*/
    

  37. /* Macro                                                                                                   */
    

  38. /*---------------------------------------------------------------------------------------------------------*/
    


  39. 

  40. #define UART1_DEBUG 0
    


  41. 

  42. #define ABS(X) (X) >= 0 ? (X) : -(X)
    


  43. 

  44. #define TIMER0_VALUE 65536-13333  //10ms
    

  45. #define MotorBoostDuty 0.15
    


  46. 

  47. #define HallSensorPhase1 (0x05<<5)
    

  48. #define HallSensorPhase2 (0x01<<5)
    

  49. #define HallSensorPhase3 (0x03<<5)
    

  50. #define HallSensorPhase4 (0x02<<5)
    

  51. #define HallSensorPhase5 (0x06<<5)
    

  52. #define HallSensorPhase6 (0x04<<5)
    


  53. 

  54. #define ADC_CONVERT_FINISH 1
    

  55. #define MOTOR_ON_OFF_SWITCH P15
    

  56. #define MOTOR_OFF 0
    


  57. 

  58. /*---------------------------------------------------------------------------------------------------------*/
    

  59. /* Global variables                                                                                        */
    

  60. /*---------------------------------------------------------------------------------------------------------*/
    

  61. unsigned char data g_u8HallSensorMotorPhaseState = 0;
    

  62. unsigned char data g_u8TimerIntCount;
    

  63. unsigned char data g_u8TH0_Tmp, g_u8TL0_Tmp;
    

  64. unsigned short data g_u16CurrentSpeed = 0;
    


  65. 

  66. /*---------------------------------------------------------------------------------------------------------*/
    

  67. /* Functions                                                                                               */
    

  68. /*---------------------------------------------------------------------------------------------------------*/
    


  69. 

  70. void CheckMotorPhaseByHallSensor(unsigned char HallSensorInput)
    

  71. {
    

  72.     switch (HallSensorInput)
    

  73.     {
    

  74.         case HallSensorPhase1:
    

  75.         {
    

  76.             g_u8HallSensorMotorPhaseState = 1;
    

  77.             break;
    

  78.         }
    

  79.         case HallSensorPhase2:
    

  80.         {
    

  81.             g_u8HallSensorMotorPhaseState = 2;
    

  82.             break;
    

  83.         }
    

  84.         case HallSensorPhase3:
    

  85.         {
    

  86.             g_u8HallSensorMotorPhaseState = 3;
    

  87.             break;
    

  88.         }
    

  89.         case HallSensorPhase4:
    

  90.         {
    

  91.             g_u8HallSensorMotorPhaseState = 4;
    

  92.             break;
    

  93.         }
    

  94.         case HallSensorPhase5:
    

  95.         {
    

  96.             g_u8HallSensorMotorPhaseState = 5;
    

  97.             break;
    

  98.         }
    

  99.         case HallSensorPhase6:
    

  100.         {
    

  101.             g_u8HallSensorMotorPhaseState = 6;
    

  102.             break;
    

  103.         }
    

  104.     }
    

  105. }
    


  106. 

  107. void ChangeMotorPhaseClockwise(void)
    

  108. {
    

  109.     /* Change motor phase to next phase. */
    

  110.     switch (g_u8HallSensorMotorPhaseState)
    

  111.     {
    

  112.         case 1:
    

  113.         {
    

  114.             PMEN = 0xfe; //uh
    

  115.             PMD = 0x20; //wl
    

  116.             break;
    

  117.         }
    

  118.         case 2:
    

  119.         {
    

  120.             PMEN = 0xfb; //vh
    

  121.             PMD = 0x20; //wl
    

  122.             break;
    

  123.         }
    

  124.         case 3:
    

  125.         {
    

  126.             PMEN = 0xfb; //vh
    

  127.             PMD = 0x02; //ul
    

  128.             break;
    

  129.         }
    

  130.         case 4:
    

  131.         {
    

  132.             PMEN = 0xef; //wh
    

  133.             PMD = 0x02; //ul
    

  134.             break;
    

  135.         }
    

  136.         case 5:
    

  137.         {
    

  138.             PMEN = 0xef; //wh
    

  139.             PMD = 0x08; //vl
    

  140.             break;
    

  141.         }
    

  142.         case 6:
    

  143.         {
    

  144.             PMEN = 0xfe; //uh
    

  145.             PMD = 0x08; //vl
    

  146.             break;
    

  147.         }
    

  148.     }
    

  149. }
    


  150. 

  151. void ChangeMotorPhaseCounterClockwise(void)
    

  152. {
    

  153.     /* Change motor phase to next phase. */
    

  154.     switch (g_u8HallSensorMotorPhaseState)
    

  155.     {
    

  156.         case 6:
    

  157.         {
    

  158.             PMEN = 0xfe; //uh
    

  159.             PMD = 0x20; //wl
    

  160.             break;
    

  161.         }
    

  162.         case 5:
    

  163.         {
    

  164.             PMEN = 0xfb; //vh
    

  165.             PMD = 0x20; //wl
    

  166.             break;
    

  167.         }
    

  168.         case 4:
    

  169.         {
    

  170.             PMEN = 0xfb; //vh
    

  171.             PMD = 0x02; //ul
    

  172.             break;
    

  173.         }
    

  174.         case 3:
    

  175.         {
    

  176.             PMEN = 0xef; //wh
    

  177.             PMD = 0x02; //ul
    

  178.             break;
    

  179.         }
    

  180.         case 2:
    

  181.         {
    

  182.             PMEN = 0xef; //wh
    

  183.             PMD = 0x08; //vl
    

  184.             break;
    

  185.         }
    

  186.         case 1:
    

  187.         {
    

  188.             PMEN = 0xfe; //uh
    

  189.             PMD = 0x08; //vl
    

  190.             break;
    

  191.         }
    

  192.     }
    

  193. }
    


  194. 

  195. void InitPWM(unsigned short *u16PWMDutyValue, unsigned char *u8OldMotorPhaseState)
    

  196. {
    

  197.     /* Initialize the pwm mode and clock. */
    

  198.     PWM_GP_MODE_ENABLE;
    

  199.     PWM_SYNCHRONIZED_MODE;
    

  200.     PWM_CLOCK_FSYS;
    

  201.     PWMPH = 0x01;
    

  202.     PWMPL = 0xF3;
    

  203.     /*----------------------------------------------------------------------
    

  204.         PWM frequency = Fpwm/((PWMPH,PWMPL) + 1), Fpwm = Fsys/PWM_CLOCK_DIV
    

  205.                       = (16MHz)/(0x1F3 + 1)
    

  206.                       = 32KHz (0.03125 ms)
    

  207.     ----------------------------------------------------------------------*/
    

  208.     /* Set PWM duty value on motor boost. */
    

  209.     *u16PWMDutyValue = 0x1F3 * MotorBoostDuty;
    

  210.     
    

  211.     /* Initialize the pwm value */
    

  212.     PWM0H = HIBYTE(*u16PWMDutyValue);
    

  213.     PWM0L = LOBYTE(*u16PWMDutyValue);
    


  214. 

  215.     /* Initialize the Motor phase parameter */
    

  216.     *u8OldMotorPhaseState = 0xFF;
    

  217.     CheckMotorPhaseByHallSensor((P0 & 0xE0));
    


  218. 

  219.     /* Initialize the pwm pin mode and close whole MOS. */
    

  220.     PMEN = 0xff;
    

  221.     PMD = 0x00;
    

  222. }
    


  223. 

  224. void InitGPIO(void)
    

  225. {
    

  226.     Set_All_GPIO_Quasi_Mode;
    

  227.     P05_Input_Mode;
    

  228.     P06_Input_Mode;
    

  229.     P07_Input_Mode;
    

  230.     P15_Input_Mode;
    

  231.     P04_PushPull_Mode;
    

  232.     P12_PushPull_Mode;
    

  233.     P14_PushPull_Mode;
    

  234.     P10_PushPull_Mode;
    

  235.     P00_PushPull_Mode;
    

  236.     P01_PushPull_Mode;
    

  237.     P03_PushPull_Mode;
    

  238.     PWM0_P12_OUTPUT_ENABLE; /* P12 - Upper-arm MOS control of U phase, uh */
    

  239.     PWM1_P14_OUTPUT_ENABLE; /* P14 - Lower-arm MOS control of U phase, ul */
    

  240.     PWM2_P10_OUTPUT_ENABLE; /* P10 - Upper-arm MOS control of V phase, vh */
    

  241.     PWM3_P00_OUTPUT_ENABLE; /* P00 - Lower-arm MOS control of V phase, vl */
    

  242.     PWM4_P01_OUTPUT_ENABLE; /* P01 - Upper-arm MOS control of W phase, wh */
    

  243.     PWM5_P03_OUTPUT_ENABLE; /* P03 - Lower-arm MOS control of W phase, wl */
    

  244.     Enable_ADC_AIN0; /* ADC input */
    


  245. 

  246.     PICON = 0xFC;   /* PORT 0 interrupt (Pin int control) */
    

  247.     PINEN = 0XE0;   /* Generates the pin interrupt when falling edge trigger */
    

  248.     PIPEN = 0XE0;   /* Generates the pin interrupt when rising edge trigger */
    

  249.     set_EPI;        /* Enable pin interrupt */
    

  250.     set_EX0;        /* Enable external interrupt */
    

  251. }
    


  252. 

  253. void InitTimer0(void)
    

  254. {
    

  255.     clr_T0M;        /* T0M=0, Timer0 Clock = Fsys/12 */
    

  256.     TMOD |= 0x01;   /* Timer0 is 16-bit mode */
    

  257.     
    

  258.     /* Calculate the timer counter value for controlling the interrupt period on 10ms. */
    

  259.     g_u8TH0_Tmp = HIBYTE(TIMER0_VALUE);
    

  260.     g_u8TL0_Tmp = LOBYTE(TIMER0_VALUE);
    


  261. 

  262.     /* Sets the timer counter value for controlling the interrupt period. The period is setting on 10ms. */
    

  263.     TH0 = g_u8TH0_Tmp;
    

  264.     TL0 = g_u8TL0_Tmp;
    


  265. 

  266.     set_ET0;        /* enable Timer0 interrupt */
    

  267.     set_TR0;        /* Timer0 start */
    

  268. }
    


  269. 

  270. unsigned int GetTargetSpeed(void)
    

  271. {
    

  272.     unsigned int data s16TargetSpeed;
    

  273.     /* ADC will sample the variable resistor value on ADCRH. */
    

  274.     /* Calculate the percentage of Max rotate speed 4500 rpm to target speed. */
    

  275.     s16TargetSpeed = (((unsigned long int)4500 * (unsigned long int)ADCRH) / 255);
    


  276. 

  277.     /* Set the upper bound and lower bound on 450 and 4500 rpm. */
    

  278.     if (s16TargetSpeed < 450) s16TargetSpeed = 450;
    

  279.     if (s16TargetSpeed > 4500) s16TargetSpeed = 4500;
    


  280. 

  281.     /* Clear ADN interrupt flag and re-trigger ADC to convert. */
    

  282.     clr_ADCF;
    

  283.     set_ADCS;
    

  284.     return s16TargetSpeed;
    

  285. }
    


  286. 

  287. void main(void)
    

  288. {
    

  289.     int data s16SpeedDiff = 0;
    

  290.     unsigned int data s16TargetSpeed = 0;
    

  291.     unsigned char data u8TimerCntForUART;
    

  292.     unsigned char data u8OldMotorPhaseState;
    

  293.     unsigned short data u16PWMDutyValue;
    

  294.     int data temp;
    

  295.     InitGPIO();
    

  296.     
    

  297. #ifdef UART1_DEBUG
    

  298.     /* Initialize UART1 for Debug */
    

  299.     u8TimerCntForUART = 0;
    

  300.     InitialUART1_Timer3(115200);
    

  301. #endif
    

  302.     
    

  303.     /* Initial PWM for controlling the 3 phase of motor */
    

  304.     InitPWM(&u16PWMDutyValue, &u8OldMotorPhaseState);
    

  305.     /* Initial Timer 0 for interrupt per 10 ms */
    

  306.     InitTimer0();
    


  307. 

  308.     /* Reset timer and check the motor phase */
    

  309.     CheckMotorPhaseByHallSensor((P0 & 0xE0));
    


  310. 

  311.     /* Clear ADC Flag and Reset Timer interrupt cnt */
    

  312.     clr_ADCF;
    

  313.     g_u8TimerIntCount = 0;
    

  314.    
    

  315.     /* Enable all interrupts */
    

  316.     set_EA;
    

  317.     
    

  318.     /* Start the ADC and PWM */
    

  319.     set_ADCS;
    

  320.     set_LOAD;
    

  321.     set_PWMRUN;
    


  322. 

  323.     while (1)
    

  324.     {
    

  325.         /* Get Motor realtime speed by ADC */
    

  326.         if (ADCF == ADC_CONVERT_FINISH)
    

  327.         {
    

  328.             s16TargetSpeed = GetTargetSpeed();
    

  329.         }
    


  330. 

  331.         if (MOTOR_ON_OFF_SWITCH == MOTOR_OFF)
    

  332.         {
    

  333.             /* Stop the motor */
    

  334.             clr_PWMRUN;
    

  335.             PMEN = 0xff;
    

  336.             PMD = 0x00;
    


  337. 

  338.             /* If the on/off switch is keeping in off state, stay on this while loop. */
    

  339.             while (MOTOR_ON_OFF_SWITCH == MOTOR_OFF);
    


  340. 

  341.             /* Motor on/off switch is switching to on, re-initial the pwm for starting rotate. */
    

  342.             
    

  343.             /* Set PWM duty value on motor boost. */
    

  344.             u16PWMDutyValue = 0x1F3 * MotorBoostDuty;
    

  345.             
    

  346.             /* Initialize the pwm value */
    

  347.             PWM0H = HIBYTE(u16PWMDutyValue);
    

  348.             PWM0L = LOBYTE(u16PWMDutyValue);
    

  349.             
    

  350.             /* Initialize the Motor phase parameter */
    

  351.             u8OldMotorPhaseState = 0xFF;
    

  352.             CheckMotorPhaseByHallSensor((P0 & 0xE0));
    

  353.             
    

  354.             /* Start the PWM */
    

  355.             set_LOAD;
    

  356.             set_PWMRUN;
    

  357.             
    

  358.             /* Clear the Timer interrupt cnt */
    

  359.             g_u8TimerIntCount = 0;
    

  360.         }
    

  361.         else if (g_u8TimerIntCount >= 1) /* if the time past x * 10ms( x = 1 ), entering this if. */
    

  362.         {
    

  363.             /* Reset the timer interrupt times counter */
    

  364.             g_u8TimerIntCount = 0;
    


  365. 

  366. #ifdef UART1_DEBUG
    

  367.             /* Print the speed of motor */
    

  368.             u8TimerCntForUART++;
    

  369.             if (u8TimerCntForUART >= 30)   //Per 300ms send UART data
    

  370.             {
    

  371.                 Send_Data_To_UART1(s16TargetSpeed);
    

  372.                 u8TimerCntForUART = 0;
    

  373.             }
    

  374. #endif
    

  375.             
    

  376.             /* Modified the PWM duty for tracing the target speed */
    

  377.             temp = ((((signed long int)0x1F3 * (signed long int)s16TargetSpeed)) / (signed long int)4500);
    

  378.             u16PWMDutyValue += (( temp > u16PWMDutyValue) ? 1 : (-1));
    


  379. 

  380.             /* Set new PWM duty */
    

  381.             PWM0H = HIBYTE(u16PWMDutyValue);
    

  382.             PWM0L = LOBYTE(u16PWMDutyValue);
    

  383.             set_LOAD;
    

  384.         }
    


  385. 

  386.         /* Change the Motor phase */
    

  387.         if (u8OldMotorPhaseState != g_u8HallSensorMotorPhaseState)
    

  388.         {
    

  389.             /* Record the last motor phase */
    

  390.             u8OldMotorPhaseState = g_u8HallSensorMotorPhaseState;
    

  391.             /* Change the motor phase */
    

  392.             ChangeMotorPhaseClockwise();
    

  393.         }
    

  394.     }
    

  395. }
    

  396. /*---------------------------------------------------------------------------------------------------------*/
    

  397. /* Interrupt                                                                                               */
    

  398. /*---------------------------------------------------------------------------------------------------------*/
    


  399. 

  400. void PinInterrupt_ISR(void) interrupt 7
    

  401. {
    

  402.     /* Detecting the motor phase by hall sensor. */ 
    

  403.     CheckMotorPhaseByHallSensor(P0 & 0xe0);
    

  404.     /* Clear the Pin interrupt flag. */
    

  405.     PIF = 0x00;
    

  406. }
    


  407. 

  408. void Timer0_ISR(void) interrupt 1
    

  409. {
    

  410.     /* Sets the timer counter value for controlling the interrupt period. The period is setting on 10ms. */
    

  411.     TH0 = g_u8TH0_Tmp;
    

  412.     TL0 = g_u8TL0_Tmp;
    

  413.     /* Recorded the interrupt times. */
    

  414.     g_u8TimerIntCount++;
    

  415. }
    


  416. 

  417. /*** (C) COPYRIGHT 2019 Nuvoton Technology Corp. ***/


回复

收藏 举报

相关帖子
 楼主| wanduzi 发表于 2024-2-25 19:52 | 显示全部楼层
这段代码是用于控制开环无刷直流（BLDC）电机的，采用了 N76E003 微控制器。让我们逐步解析代码的主要组成部分和功能：

引脚功能：描述了微控制器各引脚的功能，包括连接到霍尔传感器、用于电机控制的MOSFET、用于调试的UART，以及用于传感的ADC输入等。

包含文件：N76E003 微控制器的标准包含文件。

宏：定义了代码中使用的各种常量和宏，如UART1_DEBUG、ABS(X)、TIMER0_VALUE等。

全局变量：声明了代码中使用的全局变量，包括电机相位状态、定时器中断计数、当前速度等。

函数：

CheckMotorPhaseByHallSensor：根据霍尔传感器的输入确定电机的相位。
ChangeMotorPhaseClockwise 和 ChangeMotorPhaseCounterClockwise：根据当前电机相位状态更改电机相位。
InitPWM：初始化 PWM（脉冲宽度调制）用于控制电机相位。
InitGPIO：初始化 GPIO（通用输入输出）引脚。
InitTimer0：初始化定时器0，用于每10毫秒生成中断。
GetTargetSpeed：根据 ADC 读数计算电机的目标速度。
main：主函数，其中实现了电机控制逻辑。它根据 ADC 读数和霍尔传感器检测到的电机相位变化不断调整电机速度。
中断服务子程序（ISR）：

PinInterrupt_ISR：用于处理引脚中断的中断服务子程序，特别是用于通过霍尔传感器检测电机相位变化。
Timer0_ISR：用于定时操作和每10毫秒生成中断的定时器0的中断服务子程序。
总的来说，这段代码设置了微控制器以控制开环无刷直流电机。它从 ADC 输入读取电机速度，根据需要调整 PWM 占空比以维持所需速度，并根据霍尔传感器的信号更改电机相位。另外，如果启用了，它还包括通过UART1进行调试的功能
回复

收藏 举报

jiekou001 发表于 2024-2-26 17:19 | 显示全部楼层
开环控制无法实现速度设定吧
回复

收藏 举报

捉虫天师 发表于 2024-2-27 22:08 | 显示全部楼层
开环一般用于什么场景呢？
回复

收藏 举报

xinxianshi 发表于 2024-2-27 22:52 | 显示全部楼层
MCU是连接什么元件来驱动电机呢？
回复

收藏 举报

xinxianshi 发表于 2024-2-27 22:52 | 显示全部楼层
可以实现调速控制吗？
回复

收藏 举报

天灵灵地灵灵 发表于 2024-2-28 15:25 | 显示全部楼层
这种代码看着有点难懂。
回复

收藏 举报

夜晚有三年 发表于 2025-9-11 14:09 | 显示全部楼层
N76E003 通过定时器生成 6 路 PWM，按霍尔信号或换相表控制三相桥，依次导通对应桥臂，驱动 BLDC 开环运转
回复

收藏 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

wanduzi

156

主题

1882

帖子

3

粉丝
快速回复 在线客服 返回列表 返回顶部