[参考译文] DRV8305：SPI 写入/读取问题？

您好、团队、我们需要对此进行更新。

您能否向我们提供更新？

团队、请提供帮助  

尊敬的 Sourabh：

您能否确认 nSCS 被保持的时间足够长、以便在最后一个时钟脉冲之后至少保持50ns 之后处于低电平？

另一个请求、您能否读取所有寄存器并确保读回默认值？

此致、

Yara

您好团队：
以下是我们在最后一个时钟脉冲变为低电平且 CS 变为高电平后添加延迟的代码。
我们已经编程了 GPIO61以用作 CS。
此外、我们还启用了 DRV8305EVM 的 WAKE 和 EN_GATE 引脚、延迟约为30ms、该延迟大于建议的10ms 时间 tSPI_READY (上电后的 SPI 读取)。  

#include "driverlib.h"
#include "device.h"

void initSPIA(void);
void initGPIOForSPIA(void);
//interrupt void spi_isr(void);
void main(void)
{
    // Initialize device and disable interrupts
    Device_init();

    //
    // Disable pin locks and enable internal pullups.
    //
    Device_initGPIO();

    //
    // Initialize PIE and clear PIE registers. Disables CPU interrupts.
    //
    Interrupt_initModule();

    //
    // Initialize the PIE vector table with pointers to the shell Interrupt
    // Service Routines (ISR).
    //
    Interrupt_initVectorTable();

    //
    // Interrupts that are used in this example are re-mapped to ISR functions
    //
    //Interrupt_register(INT_SPIA_RX, &spi_isr); // read SPI interrupts first and then reconfigure if required 

    // Initialize GPIO for SPIA
    initGPIOForSPIA(); 


    // Initialize SPIA as master
    initSPIA();

    // Enable global interrupts
    EINT;
    ERTM;

    uint16_t txData = 0x3896;
    volatile uint16_t rxData;
    volatile uint16_t rxData1;
    volatile uint16_t rxData2;

    while(1)
    {
    
        //CS_low();
        GPIO_writePin( 61, 0);
        // Send data
        SPI_writeDataBlockingNonFIFO(SPIA_BASE, txData);
        // Read received data
        rxData = SPI_readDataBlockingNonFIFO(SPIA_BASE);
        DEVICE_DELAY_US(1); // 1 us delay before chip select goes high
        //CS_high();
        GPIO_writePin( 61, 1);
        // Optional: insert delay if needed
        DEVICE_DELAY_US(1000);


     
        
        //CS_low();
        GPIO_writePin( 61, 0);
        // Send data
        SPI_writeDataBlockingNonFIFO(SPIA_BASE, 0xB800);
        // Read received data
        rxData1 = SPI_readDataBlockingNonFIFO(SPIA_BASE); 
        DEVICE_DELAY_US(1); // 1 us delay before chip select goes high
        //CS_high();
        GPIO_writePin( 61, 1);
        // Optional: insert delay if needed
        DEVICE_DELAY_US(1000);


    }
}





void initSPIA(void)
{
    //***********************
    // Reset the SPI module
    SPI_disableModule(SPIA_BASE);
    //SPI_resetModule(SPIA_BASE);

    // Set the SPI configuration
    SPI_setConfig(SPIA_BASE, DEVICE_LSPCLK_FREQ,
                  SPI_PROT_POL0PHA1,      // Polarity 0, Phase 1
                  SPI_MODE_MASTER,        // Master mode
                  1000000,                // Baud rate = 1 MHz
                  16);                    // 16-bit word size

    // Enable FIFO (optional)
    SPI_disableFIFO(SPIA_BASE);
    SPI_clearInterruptStatus(SPIA_BASE, SPI_INT_RXFF);

    // SPI_enableInterrupt(SPIA_BASE,SPI_INT_RX_OVERRUN);
    // SPI_enableInterrupt(SPIA_BASE,SPI_INT_RX_DATA_TX_EMPTY);

    // Enable SPI module
    SPI_enableModule(SPIA_BASE);
    //***********************
   

}


void initGPIOForSPIA(void)
{
    EALLOW;
    // Configure GPIO58 as SPIA SIMO (Master Out, Slave In)
    GPIO_setPinConfig(GPIO_58_SPISIMOA); // for master out slave in (MOSI) functionality
    GPIO_setDirectionMode(58, GPIO_DIR_MODE_OUT);
    GPIO_setPadConfig(58, GPIO_PIN_TYPE_STD);
    GPIO_setMasterCore(58,GPIO_CORE_CPU1);
    


    // Configure GPIO59 as SPIA SOMI (Master In, Slave Out)
    GPIO_setPinConfig(GPIO_59_SPISOMIA); // for master in slave out (MISO) functionality
    GPIO_setDirectionMode(59, GPIO_DIR_MODE_IN);
    GPIO_setPadConfig(59, GPIO_PIN_TYPE_STD);
    GPIO_setMasterCore(59,GPIO_CORE_CPU1);
    GPIO_setQualificationMode(59,GPIO_QUAL_ASYNC);

    // Configure GPIO60 as SPIA CLK
    GPIO_setPinConfig(GPIO_60_SPICLKA);
    GPIO_setDirectionMode(60, GPIO_DIR_MODE_OUT);
    GPIO_setPadConfig(60, GPIO_PIN_TYPE_STD);
    GPIO_setMasterCore(60,GPIO_CORE_CPU1);

    // Configure GPIO61 as SPIA CS/STE (chip select, active low)
    //GPIO_setPinConfig(GPIO_61_SPISTEA);//  GPIO_61_SPISTEA
    GPIO_setPinConfig(GPIO_61_GPIO61); // using GPIO to function as SPISTE
    GPIO_setDirectionMode(61, GPIO_DIR_MODE_OUT);
    GPIO_setPadConfig(61, GPIO_PIN_TYPE_STD);
    GPIO_setMasterCore(61,GPIO_CORE_CPU1);


    // include settings for PWRGD, ENGATE, WAKE
    // ENGATE pin initialization.
    GPIO_setPinConfig(GPIO_124_GPIO124);
    GPIO_setDirectionMode(124, GPIO_DIR_MODE_OUT); /*pin is set as OUTPUT for enabling ENGATE
    ENGATE enables gate driver and current shunt amplifier*/
    GPIO_setPadConfig(124, GPIO_PIN_TYPE_STD);
    GPIO_setMasterCore(124,GPIO_CORE_CPU1); 

    // WAKE pin initialization.
    GPIO_setPinConfig(GPIO_125_GPIO125);
    GPIO_setDirectionMode(125, GPIO_DIR_MODE_OUT); /*pin is set as OUTPUT for enabling WAKE
    Used to bring the device out of its low power sleep mode*/
    GPIO_setPadConfig(125, GPIO_PIN_TYPE_STD);
    GPIO_setMasterCore(125,GPIO_CORE_CPU1);

    GPIO_writePin( 125, 1); // enabling WAKE
    // DEVICE_DELAY_US(50); 
    GPIO_writePin( 124, 1); //delay post enabling EN_GATE
    //DEVICE_DELAY_US(50);

    DEVICE_DELAY_US(30000); // SPI input data hold time delay
    
    
    EDIS;

}

// __interrupt void
// spi_isr(void)
// {
    
//     Interrupt_clearACKGroup(INTERRUPT_ACK_GROUP1);
// }

尊敬的 Yara 和团队：

请帮助我们解决此问题。

我们需要您的帮助来优先处理这件事、因为我们在这方面受到了某种程度的阻碍。

感谢您的帮助。

尊敬的 Vibhav 和 Sourabh：

您是否考虑过使用此电路板专为之设计的 LaunchPad？ Piccolo LAUNCHXL-F28027F LaunchPad。

或者、是否将  LAUNCHXL-F28027F 的引脚输出与您使用的电路板进行比较、以确保引脚相同？

下面是一些用于 LAUNCHXL-F28027F 的固件、也许您可以使用这些代码块来调试所使用的固件可能存在的问题：

void Config_evm_spi(void)
{
    //Pin Config
    EALLOW;
    // SPI_MOSI
    GPIO_SetupPinOptions(16, GPIO_INPUT, GPIO_ASYNC | GPIO_PULLUP);
    // SPI_MISO
    GPIO_SetupPinOptions(17, GPIO_INPUT, GPIO_ASYNC | GPIO_PULLUP);
    // SPI_CS
    GPIO_SetupPinOptions(56, GPIO_INPUT, GPIO_ASYNC | GPIO_PULLUP);
    // SPI_CLK
    GPIO_SetupPinOptions(57, GPIO_INPUT, GPIO_ASYNC | GPIO_PULLUP);

    GPIO_SetupPinMux(16, GPIO_MUX_CPU1, 1);
    GPIO_SetupPinMux(17, GPIO_MUX_CPU1, 1);
    GPIO_SetupPinMux(56, GPIO_MUX_CPU1, 1);
    GPIO_SetupPinMux(57, GPIO_MUX_CPU1, 1);
    EDIS;

    EALLOW;
    ClkCfgRegs.LOSPCP.all = 0;
    EDIS;

    // Initialize SPI FIFO registers
    SpiaRegs.SPIFFTX.all=0xE040;
    SpiaRegs.SPIFFRX.all=0x2044;
    SpiaRegs.SPIFFCT.all=0x0;

    //SPI Settings
    SpiaRegs.SPICCR.bit.SPISWRESET = 0;     //SPI Reset On
    SpiaRegs.SPICCR.bit.CLKPOLARITY = 0;    //SCLK Active High
    SpiaRegs.SPICCR.bit.SPICHAR = 0xF;      //16-bit SPI char
    SpiaRegs.SPICCR.bit.SPILBK = 0;

    SpiaRegs.SPICTL.bit.OVERRUNINTENA = 0;  //No overrun interrupt
    SpiaRegs.SPICTL.bit.CLK_PHASE = 0;      //Phase 0
    SpiaRegs.SPICTL.bit.MASTER_SLAVE = 1;   //Master mode
    SpiaRegs.SPICTL.bit.TALK = 1;           //nSCS enabled
    SpiaRegs.SPICTL.bit.SPIINTENA = 0;      //TX/RX Interrupt Disabled

    SpiaRegs.SPIBRR.bit.SPI_BIT_RATE = ((25000000 / 1000000) - 1);              //Set baud rate to 1MHz
    SpiaRegs.SPIPRI.bit.FREE = 1;           //Set so breakpoints don't disturb transmission
    SpiaRegs.SPICCR.bit.SPISWRESET = 1;   //Exit SPI reset

}

Uint16 spi_xmit(Uint16 spiFrame)
{
    SpiaRegs.SPITXBUF=spiFrame;

    //Wait for RX flag to indicate SPI frame completion
    while(SpiaRegs.SPIFFRX.bit.RXFFST != 1)
    {
    }

    return SpiaRegs.SPIRXBUF;
}

Uint16 spi_read(Uint16 addr)
{
    Uint16 commandword = (0x8000 | (addr << 11));
    return spi_xmit(commandword);
}

Uint16 spi_write(Uint16 addr, Uint16 data)
{
    Uint16 commandword = ((addr << 11) | data);
    return spi_xmit(commandword);
}

此致、

Yara

尊敬的 Yara：

感谢您的答复。

我们使用 LAUNCHXL-F28379D 、我们将在终端应用中使用该器件。 我相信它也与 BOOSTXL-DRV8305EVM 兼容。

我们已经确认了这两个开发板的引脚排列、并确保了兼容性。

我们将在进行必要修改后参考此示例

尊敬的  Sourabh：

是否有任何更新？

嗨、Yara！  感谢您的跟进,我们尝试了一些事情,并 能够以某种方式读取 MISO 上的数据,但   
我们得到的数据不够一致。

我们观察到数据不正确的回读值实例。 例如、如果我们连续读取0x7寄存器、我们 会在某些时候观察到正确的值(即0x0344是地址0x7中的默认值)、但在后续帧中、我们会观察到类似0x300或任何其他随机值。

现在、我们要缩小两个结论
1)这是否是 SPI 缓冲器本身中与数据损坏相关的内容(似乎不太可能)

或

2)通过 SPI 线路传输数据时发生数据损坏)。

我们还观察到、当两个事务之间的时间延迟接近500微秒时、在 MISO 上获得正确响应的频率高于在延迟高于或低于500微秒时的频率

我们正在尝试另外一些与两个连续 SPI 事务之间的时序相关的内容。  
无论如何,你是否有任何关于这种数据不一致的可能原因的想法。

和你分享代码… (我们使用了位域和 driverlib 函数)

//
// Included Files
//
#include "F28x_Project.h"
#include "driverlib.h"
#include "device.h"


// =======================
// ENABLE DRV8305 VIA GPIO
// =======================
void Init_DRV8305_EN_GATE_WAKE()
{
    EALLOW;

    // GPIO124 (EN_GATE)
    GpioCtrlRegs.GPDLOCK.bit.GPIO124 = 0; // Unlock config
    GpioCtrlRegs.GPDCSEL4.bit.GPIO124 = 0; // CPU1 owns pin

    GpioCtrlRegs.GPDGMUX2.bit.GPIO124 = 0;
    GpioCtrlRegs.GPDMUX2.bit.GPIO124 = 0;
    GpioCtrlRegs.GPDDIR.bit.GPIO124  = 1;
    GpioDataRegs.GPDSET.bit.GPIO124  = 1;

    //  GPIO125 (WAKE)
    GpioCtrlRegs.GPDLOCK.bit.GPIO125 = 0; // Unlock config
    GpioCtrlRegs.GPDCSEL4.bit.GPIO125 = 0; // CPU1 owns pin

    GpioCtrlRegs.GPDGMUX2.bit.GPIO125 = 0;
    GpioCtrlRegs.GPDMUX2.bit.GPIO125 = 0;
    GpioCtrlRegs.GPDDIR.bit.GPIO125  = 1;
    GpioDataRegs.GPDSET.bit.GPIO125  = 1;

    EDIS;

    DEVICE_DELAY_US(30000); // SPI input data hold time delay
}

// =======================
// SPIA GPIO CONFIGURATION
// =======================
void InitSPIAGPIO()
{
    EALLOW;

    // Unlock and assign ownership to CPU1 for GPIO58–61
    GpioCtrlRegs.GPBLOCK.bit.GPIO58 = 0;
    GpioCtrlRegs.GPBCSEL4.bit.GPIO58 = 0; //CPU1 MASTER CORE

    GpioCtrlRegs.GPBLOCK.bit.GPIO59 = 0;
    GpioCtrlRegs.GPBCSEL4.bit.GPIO59 = 0; //CPU1 MASTER CORE
 
    GpioCtrlRegs.GPBLOCK.bit.GPIO60 = 0;
    GpioCtrlRegs.GPBCSEL4.bit.GPIO60 = 0; //CPU1 MASTER CORE

    GpioCtrlRegs.GPBLOCK.bit.GPIO61 = 0;
    GpioCtrlRegs.GPBCSEL4.bit.GPIO61 = 0; //CPU1 MASTER CORE

    // Configure MUX and GMUX for SPIA
    GpioCtrlRegs.GPBGMUX2.bit.GPIO58 = 3; // SPISIMO-A
    GpioCtrlRegs.GPBMUX2.bit.GPIO58  = 3;

    GpioCtrlRegs.GPBGMUX2.bit.GPIO59 = 3; // SPISOMI-A
    GpioCtrlRegs.GPBMUX2.bit.GPIO59  = 3;

    GpioCtrlRegs.GPBGMUX2.bit.GPIO60 = 3; // SPICLK-A
    GpioCtrlRegs.GPBMUX2.bit.GPIO60  = 3;

    GpioCtrlRegs.GPBGMUX2.bit.GPIO61 = 3; // SPISTE-A
    GpioCtrlRegs.GPBMUX2.bit.GPIO61  = 3;

    // Async qualification
   // GpioCtrlRegs.GPBQSEL2.bit.GPIO58 = 3;
    GpioCtrlRegs.GPBQSEL2.bit.GPIO59 = 3;
   // GpioCtrlRegs.GPBQSEL2.bit.GPIO60 = 3;
   // GpioCtrlRegs.GPBQSEL2.bit.GPIO61 = 3;

    // Direction
    GpioCtrlRegs.GPBDIR.bit.GPIO58 = 1; // output
    GpioCtrlRegs.GPBDIR.bit.GPIO59 = 0; // input
    GpioCtrlRegs.GPBDIR.bit.GPIO60 = 1; // output
    GpioCtrlRegs.GPBDIR.bit.GPIO61 = 1; // output

    GpioDataRegs.GPBSET.bit.GPIO61 = 1; // output

    EDIS;
}

// =======================
// SPIA MODULE SETUP
// =======================
void InitSPIA()
{
    EALLOW;
    CpuSysRegs.PCLKCR8.bit.SPI_A = 1;
    SpiaRegs.SPICCR.bit.SPISWRESET = 0;

    SpiaRegs.SPICCR.all = 0x000F;              // 16-bit char
    SpiaRegs.SPICTL.all = 0x0006;              // Master mode, clock phase = 1
    SpiaRegs.SPICCR.bit.CLKPOLARITY = 0;   //clock polarity = 0
    SpiaRegs.SPIBRR.bit.SPI_BIT_RATE = 49;     // 1 MHz SPI

    SpiaRegs.SPICCR.bit.SPISWRESET = 1;
    SpiaRegs.SPIPRI.bit.FREE = 1;
    EDIS;
}

// =======================
// SPI WRITE FUNCTION
// =======================
void DRV8305_SPI_Write(Uint16 data)
{
    GpioDataRegs.GPBCLEAR.bit.GPIO61 = 1;
    DELAY_US(1);

    SpiaRegs.SPITXBUF = data << 8;
    while (SpiaRegs.SPISTS.bit.INT_FLAG == 0);
    Uint16 dummy = SpiaRegs.SPIRXBUF >> 8;

    DELAY_US(1);
    GpioDataRegs.GPBSET.bit.GPIO61 = 1;
    DELAY_US(1);
}

// =======================
// SPI READ FUNCTION
// =======================
Uint16 DRV8305_SPI_Read(Uint16 read_cmd)
{
    Uint16 read_value;

    // Frame 1
    GpioDataRegs.GPBCLEAR.bit.GPIO61 = 1;
    DELAY_US(1);
    SpiaRegs.SPITXBUF = read_cmd << 8;
    while (SpiaRegs.SPISTS.bit.INT_FLAG == 0);
    Uint16 dummy = SpiaRegs.SPIRXBUF >> 8;
    DELAY_US(1);
    GpioDataRegs.GPBSET.bit.GPIO61 = 1;
    DELAY_US(1);

    // Frame 2
    GpioDataRegs.GPBCLEAR.bit.GPIO61 = 1;
    DELAY_US(1);
    SpiaRegs.SPITXBUF = 0x0000;
    while (SpiaRegs.SPISTS.bit.INT_FLAG == 0);
    read_value = SpiaRegs.SPIRXBUF >> 8;
    DELAY_US(1);
    GpioDataRegs.GPBSET.bit.GPIO61 = 1;

    return read_value;
}

// =======================
// MAIN FUNCTION
// =======================
void main(void)
{
    Uint16 readback;

    // VARIABLES USED FROM DRIVERLIB PROGRAM
     uint16_t txData = 0x3896;
    volatile uint16_t rxData;
    volatile uint16_t rxData1;
    volatile uint16_t rxData2;


    InitSysCtrl();
    Init_DRV8305_EN_GATE_WAKE();    // Wake and enable driver
    InitSPIAGPIO();                 // SPIA GPIO + unlock + CPU1 select
    InitSPIA();                     // SPIA peripheral

    DELAY_US(2000);                 // Wait for DRV8305 ready

    while (1)
    {
        // DRV8305_SPI_Write(0x3A96);       // Write to register 0x07
        // DELAY_US(100);

        // readback = DRV8305_SPI_Read(0xB800);  // Read back register 0x07
        // DELAY_US(1000);                 // Wait for visibility

        // // Set breakpoint here to inspect readback (should be 0x0296)

    // FROM DRIVERLIB CODE

    // //CS_low();
    //     GPIO_writePin( 61, 0);


        // // Send data
        // SPI_writeDataBlockingNonFIFO(SPIA_BASE, txData);
        // // Read received data
        // rxData = SPI_readDataBlockingNonFIFO(SPIA_BASE);
        
        // // DEVICE_DELAY_US(1); // 1 us delay before chip select goes high
        // // //CS_high();
        // // GPIO_writePin( 61, 1);

        // // Optional: insert delay if needed
        // DEVICE_DELAY_US(1000);


     
        
        // //CS_low();
        // GPIO_writePin( 61, 0);
        
        // Send data
        SPI_writeDataBlockingNonFIFO(SPIA_BASE, 0xA800);
        // Read received data
        rxData1 = SPI_readDataBlockingNonFIFO(SPIA_BASE); 
        
        // DEVICE_DELAY_US(1); // 1 us delay before chip select goes high
        // //CS_high();
        // GPIO_writePin( 61, 1);

        // Optional: insert delay if needed
        DEVICE_DELAY_US(454);





    }
}

我们在 while (1)循环中使用 Driverlib 函数进行写入和读取操作

下面是输出中数据不一致的视频。

e2e.ti.com/.../WaveForms-_2800_new-workspace_2900_-2025_2D00_06_2D00_03-10_2D00_09_2D00_56.mp4


共享一个接一个的数据帧

尊敬的 Vibhav 和 Sourabh：

我邀请了 C2000团队的某个人、他们可能会就这个问题提供一些指导。

此致、

Yara