[参考译文] TMS320F2.8379万D：BLDC电机

延迟时间应与霍尔传感器输入信号相关。 在大多数情况下，当采样新的霍尔模式信号时，电机应立即进行换向。

您可以查看下面的链接，并在controlSUITE中找到一个基于霍尔感应的BLDC控制的示例项目。

[FAQ]使用C2000控制器上的霍尔效应传感器对BLDC电机进行梯形控制

https://e2e.ti.com/support/microcontrollers/c2000/f/171/t/864875</s>86.4875万

controlSUITE

C：\ti\controlSUIT\development _kits\HVMotorCtrl+PfcKit_v 2.1 \HVBLDC_Sensored

https://www.ti.com/tool/controlsuite

感谢您的回复。

我根据我的董事会实施了hallGPio.h ，它解决了我的弹跳问题。 但无法实现更大的双循环范围。

在该BLDCPWM宏库中，它们使用Dutyfunction和IQ设置双循环。 当我尝试以这种方式实施时，电机根本不旋转！！！

#define BLDCPWM_MACRO (v)\
   /*将“周期”(Q15)调制函数转换为Q0 */\
   TMP =(Int32)v.PeriodMax*(Int32)v.MfunfuncPeriod; /* Q15 = Q0xQ15 */\
   句点=(Int16)(tmp>>>15)；                     /* Q15 -> Q0 (句点)*/\
   \
   /*检查PwmActive设置*/\
   如果(v.PwmActive==1)/* PWM活动高*/\
   ｛\
       GPR0_BLDC_PWM = 0x7FFF - v.DutyFunc；\
       CMPB_SMPL_point = 0x7FFF -(v.DutyFunc >>1)；/*使用CMBB */\的PWM脉冲中心采样
   }\
   否则，如果(v.PwmActive=0)/* PWM活动低*/\
   ｛\
       GPR0_BLDC_PWM = v.DutyFunc；\
       CMPB_SMPL_point = v.DutyFunc >> 1；/*使用CMBB */\的PWM脉冲中心采样
   }\
   \
   /*将"DutyFunc"或"GPR0_BLDC_PWM"(Q15)负载调制功能转换为Q0 */\
   TMP =(Int32)Period*(Int32)GPR0_BLDC_PWM；/* Q15 = Q0xQ15 */\
   Tmp2 =(Int32)Period*(Int32)CMPB_SMPL_POIN; /* Q15 = Q0xQ15 */\
   EPwm1Regs.CMBB =(Int16)(Tmp2>>15);/*使用CMBB */\的PWM脉冲中心采样
   \
   /*状态1：电流从相位A->B流向电动机线圈，断电相位= C */\
   如果(v.CmtnPointer=0)\
   ｛\
       EPwm1Regs.AQCSFRC.bit.CSFB =0；        /*在EPWM1 */\的输出B上强制禁用
       EPwm1Regs.AQCTLB.bit.CAU =2;/*          当CTR = CMPA on up计数*/\时设置为高
       EPwm1Regs.AQCTLB.bit.ZRO = 1；          /*当CTR =零*/\时设置为低电平
       EPwm1Regs.CMPA.Halt.CMPA =(Int16)(tmp>>>15); /* EPWM1 (Q15->Q0)输出B上的PWM信号*/\
       EPwm1Regs.AQCSFRC.bit.CSFA =2;/*        在EPWM1 */\的输出A上强制达到连续高电平
       \
       EPwm2Regs.AQCSRC.bit.CFFA =1;/*        在EPWM2的输出A上强制连续低电平*/\
       EPwm2Regs.AQCSFRC.bit.CSFB =2;/*        在EPWM2的输出B上强制达到连续高电平*/\
       \
       EPwm3Regs.AQCSFRC.bit.CSFA =1;/*        在EPWM3 */\的输出A上强制输入连续低电平
       EPwm3Regs.AQCSFRC.bit.CSFB =1；        /*在EPWM3 */\的输出B上强制输入连续低电平
   }\       

你能帮我了解他们是如何通过改变双周期来改变速度的吗？       

请按照应用说明按正确顺序连接霍尔传感器和电机导线。 在制造级别2，3中运行电机，以验证是否正确检测到霍尔传感器信号。

您好，Vasanth，

109.2752万"]其他2.8379万其他参数是：PWM频率1kHz

从24V下降到8v，逆变器NFET可能是在不安全区域65 % 占空比中切换电流？ 也许尝试12-20kHz PWM频率，看看是否有帮助。

您使用哪个示例项目作为参考？ 是否更改 了tms320f2.8379万D项目中的配置代码？  您正在进行哪个构建级别的工作？

是的，我试过了。但是其他频率的电机根本不运行！！ 但将电流限制从1A更改为1.5 A可使电动机平稳旋转。

感谢您的回复。

我正在使用以下 参考代码：

C：\ti\controlSUIT\development _kits\HVMotorCtrl+PfcKit_v 2.1 \HVBLDC_Sensored

我从2级开始。 他们使用的频率和荷兰循环不能理解。

但2000但使用109.2752万使用其它2.8379万其它频率407.5343万频率马达407.5343万马达时根本无法运行！！ [/引述]

PWM频率1KHz调制通常不安全，但1.5A可能没有立即注意到的问题。 在1KHz下，工作周期可能非常小？

正如GI提到的，频率对于 使用霍尔传感器运行电机来说太低，您可以尝试使用10~20kHz的PWM频率。

您可以尝试运行1级和2级以检查PWM输出和ADC采样是否 正确，以验证您更改的代码是否适用于此套件。

在验证硬件套件上的PWM输出之前，请勿尝试添加直流总线电压并运行电机。

我将PWM频率1kHz更改为12kHz，电机运行速度非常慢，即使在50 % 双循环下也是如此！！

参数：DRV8305

代码如下：

//
// Included Files
//
#include "F28x_Project.h"
//#include "Example_posspeed.h"

//#define u 1;
//#define v 0;

__interrupt void cpu_timer0_isr(void);

//
// Globals
//

#define EPWM1_MAX_DB   0x01
#define EPWM2_MAX_DB   0x01
#define EPWM3_MAX_DB   0x01

#define val  600
#define ISRFRQ  100
#define ISRTIME  100

//
// Globals
//

//POSSPEED qep_posspeed = POSSPEED_DEFAULTS;
Uint16 InterruptCount = 0;
//Uint16 u;
int cnttt;
int pin;
unsigned int pos16bval;
unsigned int temp1;
float angle;
float var;
int mechthe;
volatile long i;
Uint16 A = 0;
//unsigned int x1;
//unsigned int x2;
float x1;
float x2;
float diff;
float speed;
float speed_1;
//unsigned int diff;
//unsigned int speed;
Uint16 GPIO_54;
Uint16 GPIO_55;
Uint16 GPIO_57;

Uint16 CmtnTrigHall = 0; // Output: Commutation trigger for Mod6cnt input (0 or 0x7FFF)
Uint16 CapCounter = 0; // Variable: Running count of detected edges on ECAP1,2,3
Uint16 DebounceCount = 0;   // Variable: Counter/debounce delay current value
Uint16 DebounceAmount = 10; // Parameter: Counter delay amount to validate/debounce GPIO readings
Uint16 HallGpio = 0;        // Variable: Most recent logic level on ECAP/GPIO
Uint16 HallGpioBuffer = 0; // Variable: Buffer of last logic level on ECAP/GPIO while being debounced
Uint16 HallGpioAccepted = 0; // Variable: Debounced logic level on ECAP/GPIO
Uint16 EdgeDebounced = 0; // Variable: Trigger from Debounce function to Hall_Drv, if = 0x7FFF edge is debounced
Uint16 HallMap[6] = { 0, 0, 0, 0, 0, 0 }; // Variable: ECAP/GPIO logic levels for HallMapPointer = 0-5
Uint16 CapFlag = 0; // Variable: ECAP flags, indicating which ECAP detected the edge
Uint16 StallCount = 0xFFFF; // Variable: If motor stalls, this counter overflow triggers
//           commutation to start rotation. Rotation is defined as
//           an edge detection of a hall signal.
Uint16 HallMapPointer = 0; // Input/Output (see note below): During hall map creation, this variable points to the
//            current commutation state.  After map creation, it
//            points to the next commutation state.
int16 Revolutions = -10; // Parameter: Running counter, with a revolution defined as 1-cycle
//            of the 6 hall states
Uint16 CmtnPointer = 0;
//
Uint16 Hall_SeqArray[50];
// Function Prototypes
//
//void initEpwm();
//__interrupt void prdTick(void);

void InitEPwmExample();

void HALL3_CREATE_MAP( void);
void HALL3_NEXT_STATE_MACRO();
void HALL3_DETERMINE_STATE_MACRO();
void HALL3_READ_MACRO();
void HALL3_DEBOUNCE_MACRO();

void comm(void);
//
// Main
//
void main(void)
{
   // static int idx = 0;

//
// Step 1. Initialize System Control:
// PLL, WatchDog, enable Peripheral Clocks
// This example function is found in the F2837xD_SysCtrl.c file.
//
    InitSysCtrl();

//
// Step 2. Initialize GPIO:
// This example function is found in the F2837xD_Gpio.c file and
// illustrates how to set the GPIO to its default state.
//

    InitGpio();

    GPIO_SetupPinMux(34, GPIO_MUX_CPU1, 1);
    GPIO_SetupPinOptions(34, GPIO_OUTPUT, GPIO_PUSHPULL);
    GPIO_SetupPinMux(54, GPIO_MUX_CPU1, 5);
    GPIO_SetupPinOptions(54, GPIO_INPUT, GPIO_PUSHPULL);

    GPIO_SetupPinMux(55, GPIO_MUX_CPU1, 5);
    GPIO_SetupPinOptions(55, GPIO_INPUT, GPIO_PUSHPULL);

    GPIO_SetupPinMux(57, GPIO_MUX_CPU1, 5);
    GPIO_SetupPinOptions(57, GPIO_INPUT, GPIO_PUSHPULL);

    EALLOW;
    GpioCtrlRegs.GPBMUX1.bit.GPIO34 = 0;
    GpioCtrlRegs.GPBDIR.bit.GPIO34 = 1;
    EDIS;


// For this case only init GPIO for eQEP1 and ePWM1
// This function is found in F2837xD_EQep.c
//

    CpuSysRegs.PCLKCR2.bit.EPWM1 = 1;
    CpuSysRegs.PCLKCR2.bit.EPWM2 = 1;
    CpuSysRegs.PCLKCR2.bit.EPWM3 = 1;

    InitEQep1Gpio();
    InitEPwm1Gpio();
    InitEPwm2Gpio();
    InitEPwm3Gpio();
//
// Step 3. Clear all __interrupts and initialize PIE vector table:
// Disable CPU __interrupts
//
    DINT;

//
// Initialize the PIE control registers to their default state.
// The default state is all PIE __interrupts disabled and flags
// are cleared.
// This function is found in the F2837xD_PieCtrl.c file.
//
    InitPieCtrl();

//
// Disable CPU __interrupts and clear all CPU __interrupt flags:
//
    IER = 0x0000;
    IFR = 0x0000;

//
// Initialize the PIE vector table with pointers to the shell Interrupt
// Service Routines (ISR).
// This will populate the entire table, even if the __interrupt
// is not used in this example.  This is useful for debug purposes.
// The shell ISR routines are found in F2837xD_DefaultIsr.c.
// This function is found in F2837xD_PieVect.c.
//
    InitPieVectTable();

//
// Interrupts that are used in this example are re-mapped to
// ISR functions found within this file.
//

    EALLOW;  // This is needed to write to EALLOW protected registers
    PieVectTable.TIMER0_INT = &cpu_timer0_isr;

    //  PieVectTable.TIMER1_INT = &cpu_timer1_isr;
    //  PieVectTable.TIMER2_INT = &cpu_timer2_isr;
    EDIS;

    InitCpuTimers();

    ConfigCpuTimer(&CpuTimer0, ISRFRQ, ISRTIME); // 50000 =50ms , 100000=100ms, 10000=10ms

    CpuTimer0Regs.TCR.all = 0x4001;
    //  Step 5. User specific code, enable __interrupts:
    // Enable CPU INT1 which is connected to CPU-Timer 0:
    //
    //IER |= M_INT3;
    IER |= M_INT1;

    //
    // Enable TINT0 in the PIE: Group 3 __interrupt 1
    //
    // PieCtrlRegs.PIEIER3.bit.INTx1 = 1;
    PieCtrlRegs.PIEIER1.bit.INTx7 = 1;
//
// Enable global Interrupts and higher priority real-time debug events:
//
    EINT;
    // Enable Global __interrupt INTM
    ERTM;
    // Enable Global realtime __interrupt DBGM

    // qep_posspeed.init(&qep_posspeed);
    //POSSPEED_Init();
   // InitECapture();

    DebounceAmount = 0;
    Revolutions = -3;
    HALL3_DETERMINE_STATE_MACRO();

    HallGpioBuffer = HallGpio; /* Init with current ECAP/GPIO logic levels*/
    HallGpioAccepted = HallGpio; /* Init with current ECAP/GPIO logic levels*/
    // GpioDataRegs.GPADAT.bit.GPIO0=u;
    EALLOW;
    CpuSysRegs.PCLKCR0.bit.TBCLKSYNC = 0;
    EDIS;

    InitEPwmExample();

    EALLOW;
    CpuSysRegs.PCLKCR0.bit.TBCLKSYNC = 1;
    EDIS;
    for (;;)
    {


    }

}

__interrupt void cpu_timer0_isr(void)
{
    GpioDataRegs.GPBTOGGLE.bit.GPIO34 = 1;

    HALL3_READ_MACRO();

    if (HallGpioAccepted == 5)

    {
        CmtnPointer = 0;
    }

    else if (HallGpioAccepted == 1)
    {
        CmtnPointer = 1;
    }

    else if (HallGpioAccepted == 3)
    {
        CmtnPointer = 2;
    }

    else if (HallGpioAccepted == 2)
    {
        CmtnPointer = 3;
    }

    else if (HallGpioAccepted == 6)
    {
        CmtnPointer = 4;
    }

    else if (HallGpioAccepted == 4)
    {
        CmtnPointer = 5;
    }
    comm();

    PieCtrlRegs.PIEACK.all = PIEACK_GROUP1;

}


// InitEPwm1Example - Initialize EPWM1 configuration
//
void InitEPwmExample()
{
    EPwm1Regs.TBPRD = 1200;                        // Set timer period
    EPwm2Regs.TBPRD = 1200;                        // Set timer period
    EPwm3Regs.TBPRD = 1200;                        // Set timer period

    EPwm1Regs.TBPHS.bit.TBPHS = 0x0000;            // Phase is 0
    EPwm2Regs.TBPHS.bit.TBPHS = 0x0000;            // Phase is 0
    EPwm3Regs.TBPHS.bit.TBPHS = 0x0000;            // Phase is 0

    EPwm1Regs.TBCTR = 0x0000;                      // Clear counter
    EPwm2Regs.TBCTR = 0x0000;                      // Clear counter
    EPwm3Regs.TBCTR = 0x0000;                      // Clear counter

    //
    // Setup TBCLK
    //
    EPwm1Regs.TBCTL.bit.CTRMODE = TB_COUNT_UP; // Count up
    EPwm1Regs.TBCTL.bit.PHSEN = TB_DISABLE;        // Disable phase loading
    EPwm1Regs.TBCTL.bit.HSPCLKDIV = TB_DIV2;       // Clock ratio to SYSCLKOUT
    EPwm1Regs.TBCTL.bit.CLKDIV = TB_DIV2;          // Slow so we can observe on
    EPwm2Regs.TBCTL.bit.CTRMODE = TB_COUNT_UP; // Count up
    EPwm2Regs.TBCTL.bit.PHSEN = TB_DISABLE;        // Disable phase loading
    EPwm2Regs.TBCTL.bit.HSPCLKDIV = TB_DIV2;       // Clock ratio to SYSCLKOUT
    EPwm2Regs.TBCTL.bit.CLKDIV = TB_DIV2;          // Slow so we can observe on
    EPwm3Regs.TBCTL.bit.CTRMODE = TB_COUNT_UP; // Count up
    EPwm3Regs.TBCTL.bit.PHSEN = TB_DISABLE;        // Disable phase loading
    EPwm3Regs.TBCTL.bit.HSPCLKDIV = TB_DIV2;       // Clock ratio to SYSCLKOUT
    EPwm3Regs.TBCTL.bit.CLKDIV = TB_DIV2;          // Slow so we can observe on
                                                   // the scope

    EPwm1Regs.CMPCTL.bit.SHDWAMODE = CC_IMMEDIATE;    // Load registers every ZERO
    EPwm1Regs.CMPCTL.bit.SHDWBMODE = CC_IMMEDIATE;
    EPwm1Regs.CMPCTL.bit.LOADAMODE = CC_CTR_ZERO;
    EPwm1Regs.CMPCTL.bit.LOADBMODE = CC_CTR_ZERO;

    EPwm2Regs.CMPCTL.bit.SHDWAMODE = CC_IMMEDIATE;    // Load registers every ZERO
    EPwm2Regs.CMPCTL.bit.SHDWBMODE = CC_IMMEDIATE;
    EPwm2Regs.CMPCTL.bit.LOADAMODE = CC_CTR_ZERO;
    EPwm2Regs.CMPCTL.bit.LOADBMODE = CC_CTR_ZERO;

    EPwm3Regs.CMPCTL.bit.SHDWAMODE = CC_IMMEDIATE;    // Load registers every ZERO
    EPwm3Regs.CMPCTL.bit.SHDWBMODE = CC_IMMEDIATE;
    EPwm3Regs.CMPCTL.bit.LOADAMODE = CC_CTR_ZERO;
    EPwm3Regs.CMPCTL.bit.LOADBMODE = CC_CTR_ZERO;
    //    //
    // Setup compare
    //
    EPwm1Regs.CMPA.bit.CMPA = val;
    EPwm1Regs.CMPB.bit.CMPB = val;
    EPwm2Regs.CMPA.bit.CMPA = val;
    EPwm2Regs.CMPB.bit.CMPB = val;
    EPwm3Regs.CMPA.bit.CMPA = val;
    EPwm3Regs.CMPB.bit.CMPB = val;
}

void comm()
{
    static Uint16 CmtnPointer_Prev = 0x0;
    static  int idx=0;
//    Uint16 HallGpioBitA, HallGpioBitB, HallGpioBitC;
//
//    HallGpioBitA = GPIO_ReadPin(54);
//    HallGpioBitB = GPIO_ReadPin(55);
//    HallGpioBitC = GPIO_ReadPin(57);
//
//    HallGpio = (HallGpioBitA << 2) + (HallGpioBitB << 1) + HallGpioBitC;

    if(CmtnPointer != CmtnPointer_Prev)
    {
        Hall_SeqArray[idx] = HallGpioAccepted;

        if (idx <= 49)
        {
            idx = idx + 1;
        }
        else
        {
            idx = 0;
        }

    if (CmtnPointer == 0)
    {
        /*    InitEPwm1Example();         //1&6
         // InitEPwm2Example();
         InitEPwm3Example();*/

        EPwm1Regs.AQCSFRC.bit.CSFB = 1;         //2
        EPwm3Regs.AQCSFRC.bit.CSFA = 1;         //5

        EPwm2Regs.AQCSFRC.bit.CSFB = 1;         //4
        EPwm2Regs.AQCSFRC.bit.CSFA = 1;         //3

        EPwm1Regs.AQCSFRC.bit.CSFA = 0;         //1
        EPwm3Regs.AQCSFRC.bit.CSFB = 0;         //6


        EPwm1Regs.AQCTLA.bit.CAU = 2; /* Set high when CTR = CMPA on UP-count             */
        EPwm1Regs.AQCTLA.bit.ZRO = 1;
        EPwm3Regs.AQCTLB.bit.CBU = 2; /* Set high when CTR = CMPA on UP-count             */
        EPwm3Regs.AQCTLB.bit.ZRO = 1;

    }

   if (CmtnPointer == 1)
    {
        /*  // InitEPwm1Example();         //1&4
         InitEPwm2Example();
         InitEPwm3Example();*/

       EPwm2Regs.AQCSFRC.bit.CSFB = 1;       //4
       EPwm3Regs.AQCSFRC.bit.CSFA = 1;       //5

       EPwm1Regs.AQCSFRC.bit.CSFB = 1;       //2
       EPwm1Regs.AQCSFRC.bit.CSFA = 1;       //1

       EPwm3Regs.AQCSFRC.bit.CSFB = 0;       //6
       EPwm2Regs.AQCSFRC.bit.CSFA = 0;       //3

       EPwm2Regs.AQCTLA.bit.CAU = 2;         //3
       EPwm2Regs.AQCTLA.bit.ZRO = 1;
       EPwm3Regs.AQCTLB.bit.CBU = 2;         //6
       EPwm3Regs.AQCTLB.bit.ZRO = 1;
    }

   if (CmtnPointer == 2)
    {
       EPwm2Regs.AQCSFRC.bit.CSFA = 1;       //3
       EPwm3Regs.AQCSFRC.bit.CSFB = 1;       //6

       EPwm1Regs.AQCSFRC.bit.CSFB = 1;       //2
       EPwm1Regs.AQCSFRC.bit.CSFA = 1;       //1

       EPwm3Regs.AQCSFRC.bit.CSFA = 0;       //5
       EPwm2Regs.AQCSFRC.bit.CSFB = 0;       //4

       EPwm2Regs.AQCTLB.bit.CBU = 2;         //4
       EPwm2Regs.AQCTLB.bit.ZRO = 1;
       EPwm3Regs.AQCTLA.bit.CAU = 2;         //5
       EPwm3Regs.AQCTLA.bit.ZRO = 1;
    }

if (CmtnPointer == 3)
    {
    EPwm1Regs.AQCSFRC.bit.CSFB = 1;         //2
    EPwm2Regs.AQCSFRC.bit.CSFA = 1;         //3

    EPwm3Regs.AQCSFRC.bit.CSFB = 1;         //6
    EPwm3Regs.AQCSFRC.bit.CSFA = 1;         //5

    EPwm1Regs.AQCSFRC.bit.CSFA = 0;         //1
    EPwm2Regs.AQCSFRC.bit.CSFB = 0;         //4

    EPwm1Regs.AQCTLA.bit.CAU = 2; /* Set high when CTR = CMPA on UP-count             */\
    EPwm1Regs.AQCTLA.bit.ZRO = 1;
    EPwm2Regs.AQCTLB.bit.CBU = 2; /* Set high when CTR = CMPA on UP-count             */\
    EPwm2Regs.AQCTLB.bit.ZRO = 1;
    }



 if (CmtnPointer == 4)
    {
     EPwm1Regs.AQCSFRC.bit.CSFA = 1;      //1
     EPwm2Regs.AQCSFRC.bit.CSFB = 1;      //4

     EPwm3Regs.AQCSFRC.bit.CSFB = 1;      //5
     EPwm3Regs.AQCSFRC.bit.CSFA = 1;      //6

     EPwm1Regs.AQCSFRC.bit.CSFB = 0;      //2
     EPwm2Regs.AQCSFRC.bit.CSFA = 0;      //3

     EPwm2Regs.AQCTLA.bit.CAU = 2;         //3
     EPwm2Regs.AQCTLA.bit.ZRO = 1;
     EPwm1Regs.AQCTLB.bit.CBU = 2;         //2
     EPwm1Regs.AQCTLB.bit.ZRO = 1;
    }



 if (CmtnPointer == 5)
    {
     EPwm1Regs.AQCSFRC.bit.CSFA = 1;         //1
     EPwm3Regs.AQCSFRC.bit.CSFB = 1;         //6

     EPwm2Regs.AQCSFRC.bit.CSFB = 1;         //4
     EPwm2Regs.AQCSFRC.bit.CSFA = 1;         //3

     EPwm1Regs.AQCSFRC.bit.CSFB = 0;         //2
     EPwm3Regs.AQCSFRC.bit.CSFA = 0;         //5

     EPwm3Regs.AQCTLA.bit.CAU = 2;         //5
     EPwm3Regs.AQCTLA.bit.ZRO = 1;
     EPwm1Regs.AQCTLB.bit.CBU = 2;         //2
     EPwm1Regs.AQCTLB.bit.ZRO = 1;

    }
    }

    CmtnPointer_Prev = CmtnPointer;

}

void HALL3_DETERMINE_STATE_MACRO()
{
    //Uint32 temp;
    Uint16 HallGpioBitA, HallGpioBitB, HallGpioBitC;

    HallGpioBitA = GPIO_ReadPin(54);
    HallGpioBitB = GPIO_ReadPin(55);
    HallGpioBitC = GPIO_ReadPin(57);

    HallGpio = (HallGpioBitA << 2) + (HallGpioBitB << 1) + HallGpioBitC;

}
void HALL3_READ_MACRO()
{
    CmtnTrigHall = 0; /* Reset trigger, it only handshakes with calling program.*/
    if (EdgeDebounced == 0) /* Debounce current position. */
    {
        HALL3_DEBOUNCE_MACRO();
        CmtnTrigHall = EdgeDebounced; /* Set Commutation trigger here*/
    }
    else
    { /* If current position is debounced, find match in table */
        HALL3_NEXT_STATE_MACRO(); /* and return pointer to current state.  Ptr to be incremented*/
    } /* by MOD6CNT after RET.*/
//
    EdgeDebounced = 0; /* Reset trigger*/
}

void HALL3_DEBOUNCE_MACRO()
/* read HallGpio*/
{
    HALL3_DETERMINE_STATE_MACRO();

    if (HallGpio == HallGpioAccepted) /* GPIO_UNCHANGED: Current GPIO reading == debounced ..*/
    /*..GPIO reading, no change in state (no edge yet)  */
    {
        if (Revolutions <= 0) /* Only create hall map during initial Revolutions*/
        {
            HALL3_CREATE_MAP( );
        }
        StallCount -= 1; /* Decrement stall counter*/
        if (StallCount == 0)
        {
            EdgeDebounced = 0x7FFF; /* 0x7FFF If motor has stalled, then user trigger to commutate*/\

            StallCount = 0xFFFF; /* Reset counter to starting value*/
        }

        DebounceCount = 0;
    }
    else /* GPIO_CHANGED: Motor might have moved to a new position.*/
    {
        if (HallGpio == HallGpioBuffer) /* Current GPIO reading == previous GPIO reading?*/
        {
            if (DebounceCount >= DebounceAmount) /* If equal, is current GPIO reading debounced?*/
            {
                HallGpioAccepted = HallGpioBuffer; /* Current GPIO reading is now debounced*/
                EdgeDebounced = 0x7FFF; /*Edge/position debounced, trigger commutation*/\

                StallCount = 0xFFFF; /* On new edge, reset stall counter*/
                CapCounter += 1; /* Increment running edge detection counter*/

                DebounceCount = 0; /* Reset debounce counter*/

                if (HallMapPointer == 0)
                    Revolutions += 1; /* Increment on every rev (HallMapPointer = 0)*/
            }
            else
                /* DEBOUNCE_MORE*/
                DebounceCount += 1; /* Increment debounce counter*/
        }
        else /* NEW_READING*/
        {
            HallGpioBuffer = HallGpio; /* Save new reading and reset debounce counter*/
            DebounceCount = 0;
        }
    }
}

void HALL3_NEXT_STATE_MACRO()
{

    if (Revolutions > 0) /* Only run function after map has been created.*/
    {
        int16 i, HallPointer;
        for (i = 0; i <= 5; i++) /* Search for a match of current debounced GPIO position*/
        { /* and the table entries.*/
            if (HallMap[i] == HallGpioAccepted) /* Match_Found*/
            {
                HallPointer = i;
            }
        }

        HallMapPointer = HallPointer; /* On match, save pointer position. Pointer will be incremented */
    } /* by 1 since MOD6CNT will receive a positive trigger*/
}
void  HALL3_CREATE_MAP(void)
{

    HallMap[HallMapPointer] = HallGpioAccepted; /* Save debounced GPIO to table.*/
//return HallGpioAccepted ;
}

检查霍尔传感器和电机导线连接顺序是否正确，直流总线电压是否足以满足您的电机。

只是想检查一下，看看您方面是否有任何更新，我有一周没有收到您的消息，所以我假设您能够解决您的问题。 如果您有任何疑问，请告诉我。 如果没有其他问题，我们将关闭此线程。 谢谢。

否， 问题未解决。 我检查 了连接。没有问题。 我是否应该尝试DRV8305与午餐板的SPI接口？ 它能解决我的问题吗？

如上所述，请先在内部版本1和2中运行项目以验证PWM输出和ADC感应信号，然后按照 本示例应用说明中所述，以开环运行电机以验证霍尔传感器和换向。

是的，如果要使用电流反馈信号以电流闭环运行电动机，则必须配置DRV8305控制寄存器。

好的，我会再试一次。 感谢您的回复。