BOOSTXL-DRV8323RS: SPI communication failed, READ and WRITE not working

Danny,

Please note that there are 2 ways to enable communication from the SPI controller to a peripheral device.

1. Chip Select/CS, which requires you to manually control the CS GPIO
2. The built-in PTE (formerly STE) functionality, which allows the SPI peripheral to automatically control the transmit signal for you. This hands CS control to the peripheral, minimizing code requirements and minimizing how much time is spent in the ISR.

By default, the Universal Motor Control Lab F28002x + DRV8323RS utilizes this functionality.

Notice: 

Make sure that the SPIA_STE pin or the CS_GPIO pin (whichever one you intend on using) is properly connected to the nSCS pin of the DRV8323RS. I personally recommend continuing to utilize the STE functionality- it definitely removes a lot of the hassle of manipulating the CS GPIO.

Regards,
Jason Osborn

Hi Jason,

My board is connect GPIO_8 to DRV8323 nSCS pin follow TI example, do you mean 

1. I re-design my board with either GPIO_0_SPIA_STE, GPIO_5_SPIA_STE, GPIO_11_SPIA_STE, GPIO_19_SPIA_STE connect to nSCS?

2. or stay with my current board design which's GPIO_8 connect to nSCS, and remove the predefined symbols DRV_CS_GPIO like below 

HAL_setupGPIOs function use GPIO_8_GPIO8 instead of STE, by default set to HIGH 

void HAL_setupGPIOs(HAL_Handle handle)
{
    .
    .
    .
    // GPIO8->CS
    GPIO_setPinConfig(GPIO_8_GPIO8);
    GPIO_writePin(8, 1);
    GPIO_setDirectionMode(8, GPIO_DIR_MODE_OUT);
    GPIO_setPadConfig(8, GPIO_PIN_TYPE_PULLUP);

    // GPIO12->M1_DRV_SCLK*
    GPIO_setPinConfig(GPIO_12_SPIA_CLK);
    GPIO_setDirectionMode(12, GPIO_DIR_MODE_OUT);
    GPIO_setPadConfig(12, GPIO_PIN_TYPE_PULLUP);

    // GPIO13->SPIA_SOMI->M1_DRV_SDO*
    GPIO_setPinConfig(GPIO_13_SPIA_SOMI);
    GPIO_setDirectionMode(13, GPIO_DIR_MODE_IN);
    GPIO_setPadConfig(13, GPIO_PIN_TYPE_PULLUP);

    // GPIO16->SPIA_SIMO->M1_DRV_SDI*
    GPIO_setPinConfig(GPIO_16_SPIA_SIMO);
    GPIO_setDirectionMode(16, GPIO_DIR_MODE_IN);
    GPIO_setPadConfig(16, GPIO_PIN_TYPE_PULLUP);

    // GPIO31->M1_DRV_ENABLE*
    GPIO_setPinConfig(GPIO_31_GPIO31);
    GPIO_writePin(31, 1);
    GPIO_setDirectionMode(31, GPIO_DIR_MODE_OUT);
    GPIO_setPadConfig(31, GPIO_PIN_TYPE_STD);
    .
    .
    .
}

inside both DRV8323_readSPI and DRV8323_writeSPI function, manually pull CS pin to LOW e.g. GPIO_writePin(obj->gpioNumber_CS, 0), after that set CS to HIGH

uint16_t DRV8323_readSPI(DRV8323_Handle handle, const DRV8323_Address_e regAddr)
{
    DRV8323_Obj *obj = (DRV8323_Obj *)handle;
    uint16_t ctrlWord;
    uint16_t n;
    const uint16_t data = 0;
    volatile uint16_t readWord;
    volatile uint16_t WaitTimeOut = 0;

    volatile SPI_RxFIFOLevel RxFifoCnt = SPI_FIFO_RXEMPTY;

    // build the control word
    ctrlWord = (uint16_t)DRV8323_buildCtrlWord(DRV8323_CTRLMODE_READ, regAddr, data);

    // GPIO 8 CS PIN
    GPIO_writePin(obj->gpioNumber_CS, 0);
    GPIO_writePin(obj->gpioNumber_CS, 0);


    // wait for registers to update
    for(n = 0; n < 0x10; n++)
    {
        __asm(" NOP");
    }

    // reset the Rx fifo pointer to zero
    SPI_resetRxFIFO(obj->spiHandle);
    SPI_enableFIFO(obj->spiHandle);

    // wait for registers to update
    for(n = 0; n < 0x20; n++)
    {
        __asm(" NOP");
    }

    // write the command
    SPI_writeDataBlockingNonFIFO(obj->spiHandle, ctrlWord);

    // wait for two words to populate the RX fifo, or a wait timeout will occur
    while(RxFifoCnt < SPI_FIFO_RX1)
    {
        RxFifoCnt = SPI_getRxFIFOStatus(obj->spiHandle);

        if(++WaitTimeOut > 0xfffe)
        {
            obj->rxTimeOut = true;
        }
    }

    WaitTimeOut = 0xffff;

    // wait for registers to update
    for(n = 0; n < 0x100; n++)
    {
        __asm(" NOP");
    }

    // GPIO 8 CS PIN
    GPIO_writePin(obj->gpioNumber_CS, 1);
    GPIO_writePin(obj->gpioNumber_CS, 1);


    // Read the word
    readWord = SPI_readDataNonBlocking(obj->spiHandle);

    return(readWord & DRV8323_DATA_MASK);
} // end of DRV8323_readSPI() function

void DRV8323_writeSPI(DRV8323_Handle handle, const DRV8323_Address_e regAddr, const uint16_t data)
{
    DRV8323_Obj *obj = (DRV8323_Obj *)handle;
    uint16_t ctrlWord;
    uint16_t n;

    // build the control word
    ctrlWord = (uint16_t)DRV8323_buildCtrlWord(DRV8323_CTRLMODE_WRITE, regAddr, data);

    // GPIO 8 PIN
    GPIO_writePin(obj->gpioNumber_CS, 0);
    GPIO_writePin(obj->gpioNumber_CS, 0);
 

    // wait for GPIO
    for(n = 0; n < 0x10; n++)
    {
        __asm(" NOP");
    }

    // reset the Rx fifo pointer to zero
    SPI_resetRxFIFO(obj->spiHandle);
    SPI_enableFIFO(obj->spiHandle);

    // wait for registers to update
    for(n = 0; n < 0x20; n++)
    {
        __asm(" NOP");
    }

    // write the command
    SPI_writeDataBlockingNonFIFO(obj->spiHandle, ctrlWord);

    // wait for registers to update
    for(n = 0; n < 0x100; n++)
    {
        __asm(" NOP");
    }

    // GPIO 8 PIN
    GPIO_writePin(obj->gpioNumber_CS, 1);
    GPIO_writePin(obj->gpioNumber_CS, 1);
 

    return;
}  // end of DRV8323_writeSPI() function

below is SPI_ex6_eeprom example the way its READ and WRITE action .... 

void writeData(uint16_t address, uint16_t *data, uint16_t length, uint16_t txdly)
{
    uint32_t base = SPIA_BASE;

    // Pull chip select low.
    CS_LOW;

    // Send the WRITE opcode.
    SPI_transmitByte(base, WRITE);

    // Send EEPROM address to write data
    SPI_transmitByte(base, address>>8);
    SPI_transmitByte(base, address);

    // Send data to be programmed
    SPI_transmitNBytes(base, data, length, txdly);

    // Pull chip select high.
    CS_HIGH;
}

//
// Function to read data from the EEPROM
// - address is the byte address of the EEPROM
// - data is a pointer to an array of data being received
// - length is the number of characters in the array to receive
//
void readData(uint16_t address, uint16_t *data, uint16_t length, uint16_t txdly)
{
    uint32_t base = SPIA_BASE;

    CS_LOW;

    // Send the READ opcode.
    SPI_transmitByte(base, READ);

    // Send EEPROM address to write data
    SPI_transmitByte(base, address>>8);
    SPI_transmitByte(base, address);

    // Receive length number of bytes
    SPI_receiveNBytes(base, data, length, txdly);


    CS_HIGH;
}

the reason I need to use GPIO instead of STE because I need to add BMS module like BQ76952 later on my custom board!

any further suggestions ?

Danny