DRV8311: Application issues.

Reed
Expert 1910 points
Part Number: DRV8311
Tool/software:
Hi team,
According to the specification sheet, during the falling edge of the PWM_SYNC synchronization signal, the upper bridge HS is closed and the lower bridge LS is open, and the U-phase should be at a low level. Why is the actual waveform collected at a high level? Is it a configuration issue?
Channel 0 is PWM_SYNC, and Channel 1 is the voltage of U relative to ground.
Fullscreen drv8311.c Download
#include "gd32f4xx.h"
#include "drv8311.h"
#include <string.h>

const uint8_t drv8311_reg_addr[21] = { // DRV8311的寄存器的地址
    DEV_STS1_ADDR,
    OT_STS_ADDR,
    SUP_STS_ADDR,
    DRV_STS_ADDR,
    SYS_STS_ADDR,
    PWM_SYNC_PRD_ADDR,
    FLT_MODE_ADDR,
    SYSF_CTRL_ADDR,
    DRVF_CTRL_ADDR,
    FLT_TCTRL_ADDR,
    FLT_CLR_ADDR,
    PWMG_PERIOD_ADDR,
    PWMG_A_DUTY_ADDR,
    PWMG_B_DUTY_ADDR,
    PWMG_C_DUTY_ADDR,
    PWM_STATE_ADDR,
    PWMG_CTRL_ADDR,
    PWM_CTRL1_ADDR,
    DRV_CTR_ADDR,
    CSA_CTRL_ADDR,
    SYS_CTRL_ADDR};
uint16_t drv8311_reg_val[3][21]; // 3片DRV8311读取到的寄存器的值
uint16_t spi_send_array[5];      // SPI_DMA发送数据
uint16_t spi_recv_array[5];      // SPI_DMA接收数据
uint8_t spi_dma_type[3];         // 3个从站的SPI_DMA操作的类型[读1个][读4个][写1个][写3个]
uint8_t spi_dma_reg[3];          // 3个从站的SPI_DMA操作的寄存器的序号[0...20]
uint16_t spi_dma_data[3][3];     // 3个从站的SPI_DMA写入的数据值，一次最多写入3个寄存器值
uint8_t spi_dma_chip;            // 当前正在进行SPI_DMA通信的DRV8311序号[0][1][2]

// DRV8311的控制/状态IO引脚初始化
void drv8311_io_init(void)
{
    rcu_periph_clock_enable(RCU_GPIOA);
    rcu_periph_clock_enable(RCU_GPIOE);

    // PE0(nSLEEP1), PE1(nSLEEP2), PE2(nSLEEP3)
    gpio_mode_set(GPIOE, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_2);
    gpio_output_options_set(GPIOE, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_2);
    gpio_bit_set(GPIOE, GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_2); // 拉高nSLEEP退出休眠模式，1ms后才能正常读写DRV8311寄存器

    // PE3(nFAULT1), PE4(nFAULT2), PE5(nFAULT3)
    gpio_mode_set(GPIOE, GPIO_MODE_INPUT, GPIO_PUPD_NONE, GPIO_PIN_3 | GPIO_PIN_4 | GPIO_PIN_5);
    gpio_output_options_set(GPIOE, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_3 | GPIO_PIN_4 | GPIO_PIN_5);

    // PA8(SYNC1), PA9(SYNC2), PA10(SYNC3)，由TIMER0_CH0/CH1/CH2控制输出PWM
    gpio_mode_set(GPIOA, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_8 | GPIO_PIN_9 | GPIO_PIN_10);
    gpio_output_options_set(GPIOA, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_8 | GPIO_PIN_9 | GPIO_PIN_10);
    gpio_af_set(GPIOA, GPIO_AF_1, GPIO_PIN_8 | GPIO_PIN_9 | GPIO_PIN_10);
}

// DRV8311的SPI引脚初始化，SPI外设初始化，DMA初始化
void drv8311_comm_init(void)
{
    rcu_periph_clock_enable(RCU_GPIOA);
    rcu_periph_clock_enable(RCU_GPIOB);
    rcu_periph_clock_enable(RCU_DMA1);
    rcu_periph_clock_enable(RCU_SPI0);

    // PA5(SCK), PA6(MISO), PA7(MOSI)
    gpio_af_set(GPIOA, GPIO_AF_5, GPIO_PIN_5 | GPIO_PIN_6 | GPIO_PIN_7);
    gpio_mode_set(GPIOA, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_5 | GPIO_PIN_6 | GPIO_PIN_7);
    gpio_output_options_set(GPIOA, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_5 | GPIO_PIN_6 | GPIO_PIN_7);

    // PA4(CS1), PB12(CS2), PA15(CS3)
    gpio_mode_set(GPIOA, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO_PIN_4 | GPIO_PIN_15);
    gpio_output_options_set(GPIOA, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_4 | GPIO_PIN_15);
    gpio_bit_set(GPIOA, GPIO_PIN_4 | GPIO_PIN_15); // 拉高CS取消选中SPI从站
    gpio_mode_set(GPIOB, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO_PIN_12);
    gpio_output_options_set(GPIOB, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_12);
    gpio_bit_set(GPIOB, GPIO_PIN_12); // 拉高CS取消选中SPI从站

    dma_single_data_parameter_struct dma_init_struct;
    // 初始化SPI0_TX的DMA1_CH5
    dma_deinit(DMA1, DMA_CH5);
    dma_init_struct.periph_addr = (uint32_t)&SPI_DATA(SPI0);
    dma_init_struct.memory0_addr = (uint32_t)(spi_send_array);
    dma_init_struct.direction = DMA_MEMORY_TO_PERIPH;
    dma_init_struct.periph_memory_width = DMA_PERIPH_WIDTH_16BIT; // 每16bit处理一次收发
    dma_init_struct.priority = DMA_PRIORITY_LOW;
    dma_init_struct.number = 2;
    dma_init_struct.periph_inc = DMA_PERIPH_INCREASE_DISABLE;
    dma_init_struct.memory_inc = DMA_MEMORY_INCREASE_ENABLE;
    dma_init_struct.circular_mode = DMA_CIRCULAR_MODE_DISABLE;
    dma_single_data_mode_init(DMA1, DMA_CH5, &dma_init_struct);
    dma_channel_subperipheral_select(DMA1, DMA_CH5, DMA_SUBPERI3);
    // 初始化SPI0_RX的DMA1_CH0
    dma_deinit(DMA1, DMA_CH0);
    dma_init_struct.periph_addr = (uint32_t)&SPI_DATA(SPI0);
    dma_init_struct.memory0_addr = (uint32_t)(spi_recv_array);
    dma_init_struct.direction = DMA_PERIPH_TO_MEMORY;
    dma_init_struct.periph_memory_width = DMA_PERIPH_WIDTH_16BIT; // 每16bit处理一次收发
    dma_init_struct.priority = DMA_PRIORITY_HIGH;
    dma_init_struct.number = 2;
    dma_init_struct.periph_inc = DMA_PERIPH_INCREASE_DISABLE;
    dma_init_struct.memory_inc = DMA_MEMORY_INCREASE_ENABLE;
    dma_init_struct.circular_mode = DMA_CIRCULAR_MODE_DISABLE;
    dma_single_data_mode_init(DMA1, DMA_CH0, &dma_init_struct);
    dma_channel_subperipheral_select(DMA1, DMA_CH0, DMA_SUBPERI3);
    dma_interrupt_enable(DMA1, DMA_CH0, DMA_CHXCTL_FTFIE); // DMA接收完成中断
    nvic_irq_enable(DMA1_Channel0_IRQn, 0, 0);             // 优先级00

    spi_parameter_struct spi_init_struct;
    // 初始化SPI0
    spi_struct_para_init(&spi_init_struct);
    spi_init_struct.trans_mode = SPI_TRANSMODE_FULLDUPLEX;
    spi_init_struct.device_mode = SPI_MASTER;
    spi_init_struct.frame_size = SPI_FRAMESIZE_16BIT;              // 每16bit处理一次收发
    spi_init_struct.clock_polarity_phase = SPI_CK_PL_LOW_PH_2EDGE; // SCK空闲时低电平，第2个跳变沿(下降沿)采集数据
    spi_init_struct.nss = SPI_NSS_SOFT;
    spi_init_struct.prescale = SPI_PSC_16; // SPI0用PCLK2=120MHz，16分频是7.5MHz，小于DRV8311的最大时钟10MHz
    spi_init_struct.endian = SPI_ENDIAN_MSB;
    spi_init(SPI0, &spi_init_struct);
    spi_enable(SPI0);
    spi_dma_enable(SPI0, SPI_DMA_RECEIVE);
    spi_dma_enable(SPI0, SPI_DMA_TRANSMIT);
}

// DRV8311的电流采样引脚初始化，ADC外设初始化
void drv8311_adc_init(void)
{
}

// 获取DRV8311的硬件报错状态
// chip_num: [0]第1片DRV8311，[1]第2片DRV8311，[2]第3片DRV8311
// return: [0]DRV8311无硬件报错，[1]DRV8311硬件报错
uint8_t drv8311_get_fault(uint8_t chip_num)
{
    uint32_t port[3] = {GPIOE, GPIOE, GPIOE};
    uint32_t pin[3] = {GPIO_PIN_3, GPIO_PIN_4, GPIO_PIN_5};

    return (1 - gpio_input_bit_get(port[chip_num], pin[chip_num]));
}

// 设置DRV8311片选CS低电平
// chip_num: [0]第1片DRV8311，[1]第2片DRV8311，[2]第3片DRV8311
void drv8311_set_cs_low(uint8_t chip_num)
{
    uint32_t port[3] = {GPIOA, GPIOB, GPIOA};
    uint32_t pin[3] = {GPIO_PIN_4, GPIO_PIN_12, GPIO_PIN_15};

    gpio_bit_reset(port[chip_num], pin[chip_num]);
}

// 设置DRV8311片选CS高电平
// chip_num: [0]第1片DRV8311，[1]第2片DRV8311，[2]第3片DRV8311
void drv8311_set_cs_high(uint8_t chip_num)
{
    uint32_t port[3] = {GPIOA, GPIOB, GPIOA};
    uint32_t pin[3] = {GPIO_PIN_4, GPIO_PIN_12, GPIO_PIN_15};

    gpio_bit_set(port[chip_num], pin[chip_num]);
}

// 单次16bit数据SPI通信，轮询模式，用于初始化
// data: MOSI发送的数据
// return: MISO接收的数据
uint16_t drv8311_spi_read_write(uint16_t data)
{
    while (RESET == spi_i2s_flag_get(SPI0, SPI_FLAG_TBE)) // 等待发送缓冲区为空
    {
    }
    spi_i2s_data_transmit(SPI0, data); // 发送数据

    while (RESET == spi_i2s_flag_get(SPI0, SPI_FLAG_RBNE)) // 等待接收缓冲区非空
    {
    }
    uint16_t recv_data = spi_i2s_data_receive(SPI0); // 读取接收到的数据

    return recv_data;
}

// DRV8311 tSPI帧格式: 16bit命令+16bit数据
// bit31: R/W位, 0=写, 1=读
// bit30-27: 4bit从站地址00(AD1)(AD0)，原理图是0000
// bit26-19: 8bit寄存器地址
// bit18-17: 2bit保留位00
// bit16: 校验位(偶校验)
// bit15: 校验位(偶校验)
// bit14-0: 15bit数据

// 读1个寄存器值，轮询模式，用于初始化
// chip_num: [0]第1片DRV8311，[1]第2片DRV8311，[2]第3片DRV8311
// reg: DRV8311寄存器序号
// return: DRV8311的寄存器值
uint16_t drv8311_read_reg(uint8_t chip_num, uint8_t reg)
{
    uint16_t send_data[2];
    uint16_t recv_data[2];

    send_data[0] = 0x8000 | (drv8311_reg_addr[reg] << 3);
    send_data[1] = 0x0000;

    drv8311_set_cs_low(chip_num);
    recv_data[0] = drv8311_spi_read_write(send_data[0]);
    recv_data[1] = drv8311_spi_read_write(send_data[1]);
    drv8311_set_cs_high(chip_num);

    drv8311_reg_val[chip_num][DEV_STS1_REG] = recv_data[0] & 0xFF;
    drv8311_reg_val[chip_num][reg] = recv_data[1];

    return recv_data[1];
}

// 写1个寄存器值，轮询模式，用于初始化
// chip_num: [0]第1片DRV8311，[1]第2片DRV8311，[2]第3片DRV8311
// reg: DRV8311寄存器序号
// reg_data: 写入值
void drv8311_write_reg(uint8_t chip_num, uint8_t reg, uint16_t reg_data)
{
    uint16_t send_data[2];
    uint16_t recv_data[2];

    send_data[0] = drv8311_reg_addr[reg] << 3;
    send_data[1] = reg_data;

    drv8311_set_cs_low(chip_num);
    recv_data[0] = drv8311_spi_read_write(send_data[0]);
    recv_data[1] = drv8311_spi_read_write(send_data[1]);
    drv8311_set_cs_high(chip_num);

    drv8311_reg_val[chip_num][DEV_STS1_REG] = recv_data[0] & 0xFF;
}

// DRV8311寄存器值上电初始化配置，轮询模式，用于初始化
void drv8311_reg_init(void)
{
    // DEV_STS1无需配置，状态寄存器
    // OT_STS无需配置，状态寄存器
    // SUP_STS无需配置，状态寄存器
    // DRV_STS无需配置，状态寄存器
    // SYS_STS无需配置，状态寄存器
    // PWM_SYNC_PRD无需配置，内容是DRV8311捕获PWM_SYNC脉宽的测量值
    drv8311_write_reg(DRV_1, FLT_MODE_REG, 0x0015);  // 非默认值，报警后会(快速)恢复发波(5ms)，OTP read fault写1写不进去，关不掉
    drv8311_write_reg(DRV_1, SYSF_CTRL_REG, 0x0515); // 默认值
    drv8311_write_reg(DRV_1, DRVF_CTRL_REG, 0x0030); // 默认值，在PWN电平切换附近(1us)忽略过流，电流大于(9A)持续(1us)报警过流
    drv8311_write_reg(DRV_1, FLT_TCTRL_REG, 0x0003); // 默认值，(慢速)恢复发波的时间是(0.5s)，(快速)恢复发波的时间是(5ms)
    drv8311_write_reg(DRV_1, FLT_CLR_REG, 0x0001);   // 非默认值，清除故障位
    drv8311_write_reg(DRV_1, PWMG_PERIOD_REG, 625);  // 非默认值，DRV8311时钟20MHz，载波16KHz，中心模式，计数值625->0->625，在PWM_SYNC模式下无效
    drv8311_write_reg(DRV_1, PWMG_A_DUTY_REG, 156);    // 非默认值，初始化占空比
    drv8311_write_reg(DRV_1, PWMG_B_DUTY_REG, 312);    // 非默认值，初始化占空比
    drv8311_write_reg(DRV_1, PWMG_C_DUTY_REG, 468);    // 非默认值，初始化占空比
    drv8311_write_reg(DRV_1, PWM_STATE_REG, 0x0777); // 默认值，启用上下桥，上桥极性=PWM，下桥极性=PWM取反
    drv8311_write_reg(DRV_1, PWMG_CTRL_REG, 0x0040); // 默认值，禁止发波，PWM中心模式，启用PWM_SYNC功能，SPICLK校准功能保持默认
    drv8311_write_reg(DRV_1, PWM_CTRL1_REG, 0x0007); // 默认值，PWM Generation mode
    drv8311_write_reg(DRV_1, DRV_CTR_REG, 0x0033);   // 非默认值，死区0.6us，MOS开关电压斜率设为最大230V/us
    drv8311_write_reg(DRV_1, CSA_CTRL_REG, 0x0008);  // 默认值，启用电流检测，电流检测输出比例=0.25V/A(量程大精度低)
    drv8311_write_reg(DRV_1, SYS_CTRL_REG, 0x5000);  // 非默认值，解锁这个寄存器，然后写0
}

// 读1个寄存器值，DMA模式，用于运行中
// [读1个寄存器][读4个状态寄存器][写1个寄存器值][写3个占空比寄存器]，每个电流环4选1来执行
// chip_num: [0]第1片DRV8311，[1]第2片DRV8311，[2]第3片DRV8311
// reg: DRV8311寄存器序号
void drv8311_read_reg_dma(uint8_t chip_num, uint8_t reg)
{
    spi_dma_type[chip_num] = READ_1_REG;
    spi_dma_reg[chip_num] = reg; // 读取spi_dma_reg[chip_num]指定的寄存器的值
}

// 读4个状态寄存器，DMA模式，用于运行中
// [读1个寄存器][读4个状态寄存器][写1个寄存器值][写3个占空比寄存器]，每个电流环4选1来执行
// chip_num: [0]第1片DRV8311，[1]第2片DRV8311，[2]第3片DRV8311
void drv8311_get_state_dma(uint8_t chip_num)
{
    spi_dma_type[chip_num] = READ_4_REG;
}

// 写1个寄存器值，DMA模式，用于运行中
// [读1个寄存器][读4个状态寄存器][写1个寄存器值][写3个占空比寄存器]，每个电流环4选1来执行
// chip_num: [0]第1片DRV8311，[1]第2片DRV8311，[2]第3片DRV8311
// reg: DRV8311寄存器序号
// reg_data: 写入值
void drv8311_write_reg_dma(uint8_t chip_num, uint8_t reg, uint16_t reg_data)
{
    spi_dma_type[chip_num] = WRITE_1_REG;
    spi_dma_reg[chip_num] = reg;
    spi_dma_data[chip_num][0] = reg_data;
}

// 写3个占空比寄存器，DMA模式，用于运行中
// [读1个寄存器][读4个状态寄存器][写1个寄存器值][写3个占空比寄存器]，每个电流环4选1来执行
// chip_num: [0]第1片DRV8311，[1]第2片DRV8311，[2]第3片DRV8311
// duty_a: DRV8311的A相占空比
// duty_b: DRV8311的B相占空比
// duty_c: DRV8311的C相占空比
void drv8311_set_duty_dma(uint8_t chip_num, uint16_t duty_a, uint16_t duty_b, uint16_t duty_c)
{
    spi_dma_type[chip_num] = WRITE_3_REG;
    spi_dma_data[chip_num][0] = duty_a;
    spi_dma_data[chip_num][1] = duty_b;
    spi_dma_data[chip_num][2] = duty_c;
}

// 启动DRV8311的SPI_DMA收发
// chip_num: [0]第1片DRV8311，[1]第2片DRV8311，[2]第3片DRV8311
void drv8311_dma_start(uint8_t chip_num)
{
    uint32_t num = 0;

    spi_dma_chip = chip_num;

    // 拼装读1个寄存器的数据帧
    if (READ_1_REG == spi_dma_type[chip_num])
    {
        spi_send_array[0] = 0x8000 | (drv8311_reg_addr[spi_dma_reg[chip_num]] << 3);
        spi_send_array[1] = 0;
        num = 2;
    }
    // 拼装读4个状态寄存器的数据帧
    else if (READ_4_REG == spi_dma_type[chip_num])
    {
        spi_send_array[0] = 0x8000 | (OT_STS_ADDR << 3); // 从OT_STS_ADDR开始连读4个寄存器
        spi_send_array[1] = 0;
        spi_send_array[2] = 0;
        spi_send_array[3] = 0;
        spi_send_array[4] = 0;
        num = 5;
    }
    // 拼装写1个寄存器的数据帧
    else if (WRITE_1_REG == spi_dma_type[chip_num])
    {
        spi_send_array[0] = drv8311_reg_addr[spi_dma_reg[chip_num]] << 3;
        spi_send_array[1] = spi_dma_data[chip_num][0];
        num = 2;
    }
    // 拼装写3个占空比寄存器的数据帧
    else if (WRITE_3_REG == spi_dma_type[chip_num])
    {
        spi_send_array[0] = PWMG_A_DUTY_ADDR << 3; // 从PWMG_A_DUTY开始连写3个寄存器
        spi_send_array[1] = spi_dma_data[chip_num][0];
        spi_send_array[2] = spi_dma_data[chip_num][1];
        spi_send_array[3] = spi_dma_data[chip_num][2];
        num = 4;
    }

    // 设置片选，设置DMA传输数量，启动DMA
    drv8311_set_cs_low(chip_num);
    dma_channel_disable(DMA1, DMA_CH5);
    dma_channel_disable(DMA1, DMA_CH0);
    dma_flag_clear(DMA1, DMA_CH5, DMA_FLAG_FTF);
    dma_flag_clear(DMA1, DMA_CH0, DMA_FLAG_FTF);
    dma_transfer_number_config(DMA1, DMA_CH5, num);
    dma_transfer_number_config(DMA1, DMA_CH0, num);
    dma_channel_enable(DMA1, DMA_CH5);
    dma_channel_enable(DMA1, DMA_CH0);
}

// 结束DRV8311的SPI_DMA收发
// chip_num: [0]第1片DRV8311，[1]第2片DRV8311，[2]第3片DRV8311
void drv8311_dma_end(uint8_t chip_num)
{
    // 取消片选，停止DMA
    drv8311_set_cs_high(chip_num);
    dma_channel_disable(DMA1, DMA_CH5);
    dma_channel_disable(DMA1, DMA_CH0);
    dma_flag_clear(DMA1, DMA_CH5, DMA_FLAG_FTF);
    dma_flag_clear(DMA1, DMA_CH0, DMA_FLAG_FTF);

    // 读取1个寄存器的操作完成，将SPI接收数据更新至寄存器值
    if (READ_1_REG == spi_dma_type[chip_num])
    {
        drv8311_reg_val[chip_num][DEV_STS1_REG] = spi_recv_array[0] & 0xFF;   // 读取到DEV_STS1寄存器的值
        drv8311_reg_val[chip_num][spi_dma_reg[chip_num]] = spi_recv_array[1]; // 读取到spi_dma_reg[chip_num]指定的寄存器的值
    }
    // 读取4个寄存器的操作完成，将SPI接收数据更新至寄存器值
    else if (READ_4_REG == spi_dma_type[chip_num])
    {
        drv8311_reg_val[chip_num][DEV_STS1_REG] = spi_recv_array[0] & 0xFF; // 读取到DEV_STS1寄存器的值
        drv8311_reg_val[chip_num][OT_STS_REG] = spi_recv_array[1];          // 读取到OT_STS寄存器的值
        drv8311_reg_val[chip_num][SUP_STS_REG] = spi_recv_array[2];         // 读取到SUP_STS寄存器的值
        drv8311_reg_val[chip_num][DRV_STS_REG] = spi_recv_array[3];         // 读取到DRV_STS寄存器的值
        drv8311_reg_val[chip_num][SYS_STS_REG] = spi_recv_array[4];         // 读取到SYS_STS寄存器的值
    }
    // 写入1个寄存器的操作完成
    else if (WRITE_1_REG == spi_dma_type[chip_num])
    {
        // 写入操作的回复帧不处理
    }
    // 写入3个寄存器的操作完成
    else if (WRITE_3_REG == spi_dma_type[chip_num])
    {
        // 写入操作的回复帧不处理
    }

    // 变量重置
    memset(spi_send_array, 0, sizeof(spi_send_array));
    memset(spi_recv_array, 0, sizeof(spi_recv_array));
    spi_dma_type[chip_num] = READ_1_REG;  // 默认读1个寄存器
    spi_dma_reg[chip_num] = DEV_STS1_REG; // 默认读DEV_STS1寄存器
    spi_dma_data[chip_num][0] = 0;
    spi_dma_data[chip_num][1] = 0;
    spi_dma_data[chip_num][2] = 0;
}

// DRV8311的SPI_DMA接收完成中断函数
void drv8311_spi_dma_isr(void)
{
    // 第1次进中断，第1片DRV8311的SPI_DMA收发完成
    if (DRV_1 == spi_dma_chip)
    {
        drv8311_dma_end(DRV_1); // 结束第1片DRV8311的SPI_DMA收发
        // drv8311_dma_start(DRV_2); // 启动第2片DRV8311的SPI_DMA收发
    }
    // 第2次进中断，第2片DRV8311的SPI_DMA收发完成
    /*else if (DRV_2 == spi_dma_chip)
    {

        drv8311_dma_end(DRV_2);   // 结束第2片DRV8311的SPI_DMA收发
        drv8311_dma_start(DRV_3); // 启动第3片DRV8311的SPI_DMA收发
    }
    // 第3次进中断，第3片DRV8311的SPI_DMA收发完成
    else if (DRV_3 == spi_dma_chip)
    {
        drv8311_dma_end(DRV_2); // 结束第3片DRV8311的SPI_DMA收发
        spi_dma_chip = DRV_1;   // 初始化
    }*/
}

// 使能PWM发波
// chip_num: [0]第1片DRV8311，[1]第2片DRV8311，[2]第3片DRV8311
void drv8311_enable_pwm(uint8_t chip_num)
{
    drv8311_write_reg_dma(chip_num, PWMG_CTRL_REG, 0x0440);
}

// 禁止PWM发波
// chip_num: [0]第1片DRV8311，[1]第2片DRV8311，[2]第3片DRV8311
void drv8311_disable_pwm(uint8_t chip_num)
{
    drv8311_write_reg_dma(chip_num, PWMG_CTRL_REG, 0x0040);
}
drv8311.h
25 days ago
0 Yara Al Shami 21 days ago
TI__Genius 15225 points
Hi Reed
I'm not entirely familiar with this. but from my understanding this device is an integrated FET device so you can not probe "HS_ON" and "LS_ON" like the figure 8-11 shows
Regards,
Yara
Motor drivers

Motor drivers forum

DRV8311: Application issues.
