21ic电子技术开发论坛 › 单片机与嵌入式系统 › 新唐MCU › 闭回路无刷直流(BLDC)马达控制
返回列表 发新帖我要提问

[应用方案] 闭回路无刷直流(BLDC)马达控制

[复制链接]
2153|14
 楼主| antusheng 发表于 2020-5-12 21:06 | 显示全部楼层 |阅读模式
BLDC, 回路, 无刷直流, 马达控制, 直流马达
本范例代码基于N76E003平台，使用PWM功能控制闭回路无刷直流马达马达。
脉冲宽度调制(Pulse Width Modulation, PWM)，是一种输出方波的技巧，透过改变占空比来改
变等效的输出能量与电压，例如马达调速、阀门控制等都是透过这种方式控制的。要产生一个
三相弦波，可以在PWM的基础上改变调制脉冲的方式，将脉冲宽度时间的占空比按照正弦波规
律排列，即可获得正弦波输出，以控制逆变器电路中的开关通断，这种调制方式在现今的变频
器领域已经被广泛地采用，可用于控制三相电动机等。
无刷直流马达 (Brushless DC Motor, BLDC Motor) 在整流的处理上舍弃了传统马达所使用的电
刷，以电子装置取代，因此能够提升其可靠度与耐用度。无刷直流马达马达其优势为：体积比
相同功率输出的有刷马达更小更轻、可靠度与耐用度高。无刷直流马达马达的缺点为：需要电
子管理装置(微控制器)才能够运作。一个基本的无刷直流马达会配有霍尔传感器，依照霍尔传
感器回馈的转子位置讯号，微控制器能够输出对应的控制讯号，因此一个三相马达需要六组
PWM控制上下臂，以及三条线接收霍尔讯号。
开回路控制是一种控制器，使用系统数学模型与目前状态产生控制讯号，闭回路控制器则会加
入回授信号来判断系统是否已达到理想输出状态。在开回路与闭回路的差异上，开回路的架构
相对闭回路简单，系统稳定性较闭回路差，但成本较低。若是系统比较不需要精准性控制，可
采用开回路系统实现。
本范例程序使用闭回路的方式控制BLDC马达，并使用可变电阻控制转速。
N76E003_Close_Loop_BLDC_Motor_Readme_SC.pdf (644.37 KB, 下载次数: 96)

回复

收藏1 举报

相关帖子
 楼主| antusheng 发表于 2020-5-12 21:07 | 显示全部楼层
608475eba9f6b0b6d3.png
如何执行范例程序
1. 根据目录信息章节进入 EC_N76E003_Close_Loop_BLDC_Motor_V1.00\
Sample_Code\ExampleCode\Close_Loop_BLDC_Motor_V1.00，双击路径中
CloseLoopBLDCMotor.uvproj 开启专案。
2. 进入编译模式接口
a. 编译
b. 下载代码至内存
c. 进入 / 离开除错模式
3. 进入除错模式接口
a. 执行代码
回复

收藏1 举报

 楼主| antusheng 发表于 2020-5-12 21:07 | 显示全部楼层
EC_N76E003_Close_Loop_BLDC_Motor_V1.00.zip (641.23 KB, 下载次数: 104)
回复

收藏1 举报

 楼主| antusheng 发表于 2020-5-12 21:08 | 显示全部楼层
复制
  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]    Close 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 InitTimer2forCapture(void)
    

  225. {
    

  226.     /* Initial the Timer2 for capture motor speed */
    

  227.     TIMER2_CAP0_Capture_Mode;
    

  228.     IC6_P05_CAP0_RisingEdge_Capture;
    

  229.     TIMER2_DIV_512;
    

  230.     /* Enable Capture interrupt */
    

  231.     set_ECAP;
    

  232.     /* Triger Timer2 */
    

  233.     set_TR2;
    

  234. }
    


  235. 

  236. void InitGPIO(void)
    

  237. {
    

  238.     Set_All_GPIO_Quasi_Mode;
    

  239.     P05_Input_Mode;
    

  240.     P06_Input_Mode;
    

  241.     P07_Input_Mode;
    

  242.     P15_Input_Mode;
    

  243.     P04_PushPull_Mode;
    

  244.     P12_PushPull_Mode;
    

  245.     P14_PushPull_Mode;
    

  246.     P10_PushPull_Mode;
    

  247.     P00_PushPull_Mode;
    

  248.     P01_PushPull_Mode;
    

  249.     P03_PushPull_Mode;
    

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

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

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

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

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

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

  256.     Enable_ADC_AIN0; /* ADC input */
    


  257. 

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

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

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

  261.     set_EPI;        /* Enable pin interrupt */
    

  262.     set_EX0;        /* Enable external interrupt */
    

  263. }
    


  264. 

  265. void InitTimer0(void)
    

  266. {
    

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

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

  269.     
    

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

  271.     g_u8TH0_Tmp = HIBYTE(TIMER0_VALUE);
    

  272.     g_u8TL0_Tmp = LOBYTE(TIMER0_VALUE);
    


  273. 

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

  275.     TH0 = g_u8TH0_Tmp;
    

  276.     TL0 = g_u8TL0_Tmp;
    


  277. 

  278.     set_ET0;        /* enable Timer0 interrupt */
    

  279.     set_TR0;        /* Timer0 start */
    

  280. }
    


  281. 

  282. unsigned int GetTargetSpeed(void)
    

  283. {
    

  284.     unsigned int data u16TargetSpeed;
    

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

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

  287.     u16TargetSpeed = (((unsigned long int)4500 * (unsigned long int)ADCRH) / 255);
    


  288. 

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

  290.     if (u16TargetSpeed < 450) u16TargetSpeed = 450;
    

  291.     if (u16TargetSpeed > 4500) u16TargetSpeed = 4500;
    


  292. 

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

  294.     clr_ADCF;
    

  295.     set_ADCS;
    

  296.     return u16TargetSpeed;
    

  297. }
    


  298. 

  299. void main(void)
    

  300. {
    

  301.     int data s16SpeedDiff = 0;
    

  302.     unsigned int data u16TargetSpeed = 0;
    

  303.     unsigned char data u8TimerCntForUART;
    

  304.     unsigned char data u8OldMotorPhaseState;
    

  305.     unsigned short data u16PWMDutyValue;
    

  306.     
    

  307.     InitGPIO();
    

  308.     
    

  309. #ifdef UART1_DEBUG
    

  310.     /* Initialize UART1 for Debug */
    

  311.     u8TimerCntForUART = 0;
    

  312.     InitialUART1_Timer3(115200);
    

  313. #endif
    

  314.     
    

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

  316.     InitPWM(&u16PWMDutyValue, &u8OldMotorPhaseState);
    

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

  318.     InitTimer0();
    

  319.     /* Initial Timer 2 for capturing the motor speed */
    

  320.     InitTimer2forCapture();
    


  321. 

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

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


  324. 

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

  326.     clr_ADCF;
    

  327.     g_u8TimerIntCount = 0;      
    

  328.    
    

  329.     /* Enable all interrupts */
    

  330.     set_EA;
    

  331.     
    

  332.     /* Start the ADC and PWM */
    

  333.     set_ADCS;
    

  334.     set_LOAD;
    

  335.     set_PWMRUN;
    


  336. 

  337.     while (1)
    

  338.     {
    

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

  340.         if (ADCF == ADC_CONVERT_FINISH)
    

  341.         {
    

  342.             u16TargetSpeed = GetTargetSpeed();
    

  343.         }
    


  344. 

  345.         if (MOTOR_ON_OFF_SWITCH == MOTOR_OFF)
    

  346.         {
    

  347.             /* Stop the motor */
    

  348.             clr_PWMRUN;
    

  349.             PMEN = 0xff;
    

  350.             PMD = 0x00;
    


  351. 

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

  353.             while (MOTOR_ON_OFF_SWITCH == MOTOR_OFF);
    


  354. 

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

  356.             
    

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

  358.             u16PWMDutyValue = 0x1F3 * MotorBoostDuty;
    

  359.             
    

  360.             /* Initialize the pwm value */
    

  361.             PWM0H = HIBYTE(u16PWMDutyValue);
    

  362.             PWM0L = LOBYTE(u16PWMDutyValue);
    

  363.             
    

  364.             /* Initialize the Motor phase parameter */
    

  365.             u8OldMotorPhaseState = 0xFF;
    

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

  367.             
    

  368.             /* Start the PWM */
    

  369.             set_LOAD;
    

  370.             set_PWMRUN;
    

  371.             
    

  372.             /* Clear the Timer interrupt cnt */
    

  373.             g_u8TimerIntCount = 0;
    

  374.         }
    

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

  376.         {
    

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

  378.             g_u8TimerIntCount = 0;
    

  379.             
    

  380.             /* Calculate the differentiation between target and current speed */
    

  381.             /*---------------------------------------------------------------------*/
    

  382.             //    PWM frequency =  32KHz (0.03125 ms)
    

  383.             //    Timer Capture (PWM clock number) * PWM clock Period = 1/2 Round
    

  384.             // => Timer Capture (PWM clock number) * PWM clock Period : 1/2 Round = 60s (1min) : X Round
    

  385.             // => X(s16SpeedDiff) = ((1/2) * 60) / ( 1/32k * Timer Capture (PWM clock number) )
    

  386.             /*---------------------------------------------------------------------*/
    

  387.                         
    

  388.             s16SpeedDiff = (unsigned long int)u16TargetSpeed - ((unsigned long int)30000000 / ((unsigned long int)(g_u16CurrentSpeed) * 32));
    


  389. 

  390. #ifdef UART1_DEBUG
    

  391.             /* Print the speed of motor */
    

  392.             u8TimerCntForUART++;
    

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

  394.             {
    

  395.                 Send_Data_To_UART1(((u16TargetSpeed - s16SpeedDiff)));
    

  396.                 u8TimerCntForUART = 0;
    

  397.             }
    

  398. #endif
    

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

  400.             u16PWMDutyValue += ((s16SpeedDiff > 0) ? 1 : (-1));
    


  401. 

  402.             /* Set new PWM duty */
    

  403.             PWM0H = HIBYTE(u16PWMDutyValue);
    

  404.             PWM0L = LOBYTE(u16PWMDutyValue);
    

  405.             set_LOAD;
    

  406.         }
    


  407. 

  408.         /* Change the Motor phase */
    

  409.         if (u8OldMotorPhaseState != g_u8HallSensorMotorPhaseState)
    

  410.         {
    

  411.             /* Record the last motor phase */
    

  412.             u8OldMotorPhaseState = g_u8HallSensorMotorPhaseState;
    

  413.             /* Change the motor phase */
    

  414.             ChangeMotorPhaseClockwise();
    

  415.         }
    

  416.     }
    

  417. }
    

  418. /*---------------------------------------------------------------------------------------------------------*/
    

  419. /* Interrupt                                                                                               */
    

  420. /*---------------------------------------------------------------------------------------------------------*/
    


  421. 

  422. void PinInterrupt_ISR(void) interrupt 7
    

  423. {
    

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

  425.     CheckMotorPhaseByHallSensor(P0 & 0xe0);
    

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

  427.     PIF = 0x00;
    

  428. }
    


  429. 

  430. void Timer0_ISR(void) interrupt 1
    

  431. {
    

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

  433.     TH0 = g_u8TH0_Tmp;
    

  434.     TL0 = g_u8TL0_Tmp;
    

  435.     /* Recorded the interrupt times. */
    

  436.     g_u8TimerIntCount++;
    

  437. }
    


  438. 

  439. void Capture_ISR(void) interrupt 12
    

  440. {
    

  441.     /* Clear capture0 interrupt flag */
    

  442.     clr_CAPF0;
    

  443.     /* Get the current motor speed */
    

  444.     g_u16CurrentSpeed = (C0L + (C0H << 8));
    


  445. 

  446.     clr_TF2;
    

  447. }
    

  448. /*** (C) COPYRIGHT 2019 Nuvoton Technology Corp. ***/
回复

收藏1 举报

 楼主| antusheng 发表于 2020-5-12 21:08 | 显示全部楼层
更详细 的请下载压缩包，里面是完整的工程与说明。
回复

收藏1 举报

wahahaheihei 发表于 2020-5-20 22:43 | 显示全部楼层
资料很棒。
回复

收藏1 举报

643757107 发表于 2020-5-20 23:20 | 显示全部楼层
没想到003也可以玩这么高级的。
回复

收藏1 举报

gwsan 发表于 2020-6-1 17:50 | 显示全部楼层
非常感谢楼主分享
回复

收藏1 举报

kxsi 发表于 2020-6-1 17:50 | 显示全部楼层
非常感谢楼主分享
回复

收藏1 举报

nawu 发表于 2020-6-1 17:51 | 显示全部楼层
精度能达到多少
回复

收藏1 举报

qcliu 发表于 2020-6-1 17:51 | 显示全部楼层
响应速度快吗
回复

收藏1 举报

tfqi 发表于 2020-6-1 17:51 | 显示全部楼层
驱动能力大不大
回复

收藏1 举报

guyufeng×× 发表于 2020-10-5 15:02 | 显示全部楼层
小白请教问题：
#define HallSensorPhase1 (0x05<<5)
#define HallSensorPhase2 (0x01<<5)
#define HallSensorPhase3 (0x03<<5)
#define HallSensorPhase4 (0x02<<5)
#define HallSensorPhase5 (0x06<<5)
#define HallSensorPhase6 (0x04<<5）
这几个值是什么值？是HALL 引脚采集到的电平吗？
回复

收藏1 举报

rgjinxuan 发表于 2020-12-5 13:20 | 显示全部楼层
非常感谢楼主分享
回复

收藏1 举报

guijial511 发表于 2020-12-7 21:08 来自手机 | 显示全部楼层
学习了，感谢楼主分享经验。
回复

收藏1 举报

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

本版积分规则

antusheng

86

主题

1723

帖子

5

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