Hi all, I am unable to read and write Commands through SPI to STGAP1AS motor driver IC. I am using tms320f28377s processor to read and write data to STGAP1AS.

This is my code to write CFG1 register and read from same register and i have followed the steps given in data sheet for SPI communication , not using CRC for now and implementing for only one gate driver .

#include "driverlib.h"
#include "device.h"
 
#define WRITE_COMMAND 0X80
#define READ_COMMAND 0xA0
#define CFG1_REG_ADDR 0x0C
#define StartConfiguration 0x2A
#define StopConfiguration 0x3A
#define CFG1Value 0x00
#define CRC 0x00
#define RESET_COMMAND 0xD0
 
typedef char uint8_t;
 
// Function Prototypes
//
void initSPIA(void);
void SPIA_Gpio_Config( void );
void SPI_GateDriver_Config(void);
void SPI_GateDriver_Write_Reg( uint8_t, uint8_t);
void Write_SPI_Data( uint16_t);
uint16_t Read_SPI_Data( uint16_t);
 
 
uint16_t read_data=0;
//
// Main
//
void main(void)
{
 
 // Initialize device clock and peripherals
 //
 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();
 //
 // Set up SPI, initializing it for FIFO mode
 //
 initSPIA();
 //
 // Enable Global Interrupt (INTM) and realtime interrupt (DBGM)
 //
 EINT;
 ERTM;
 //
 // Loop forever. Suspend or place breakpoints to observe the buffers.
 //
 while(1)
 {
 
 SPI_GateDriver_Config();
 read_data = Read_SPI_Data( CFG1_REG_ADDR );
 
 }
}
 
//
// Function to configure SPI A in FIFO mode.
//
void initSPIA()
{
 //
 // Must put SPI into reset before configuring it
 //
 SPI_disableModule(SPIA_BASE);
 SPIA_Gpio_Config();
 SPI_disableLoopback(SPIA_BASE);
 //
 // SPI configuration. Use a 1MHz SPICLK and 16-bit word size.
 //
 SPI_setConfig(SPIA_BASE, DEVICE_LSPCLK_FREQ, SPI_PROT_POL0PHA1,
 SPI_MODE_MASTER, 1000000, 16);
 GPIO_setDirectionMode(19,GPIO_DIR_MODE_OUT);
 //SPI_setBaudRate(SPIA_BASE,DEVICE_LSPCLK_FREQ,115200);
 SPI_setEmulationMode(SPIA_BASE, SPI_EMULATION_STOP_AFTER_TRANSMIT);
 
 //
 // Configuration complete. Enable the module.
 //
 SPI_enableModule(SPIA_BASE);
}
 
void SPIA_Gpio_Config( void )
{
 //GPIO17 is the SPISOMIA.
 GPIO_setMasterCore( 17, GPIO_CORE_CPU1 );
 GPIO_setPinConfig( GPIO_17_SPISOMIA );
 GPIO_setPadConfig( 17, GPIO_PIN_TYPE_PULLUP );
 GPIO_setQualificationMode( 17, GPIO_QUAL_ASYNC );
 
 //GPIO16 is the SPISIMOA.
 GPIO_setMasterCore( 16, GPIO_CORE_CPU1 );
 GPIO_setPinConfig( GPIO_16_SPISIMOA );
 GPIO_setPadConfig( 16, GPIO_PIN_TYPE_PULLUP );
 GPIO_setQualificationMode( 16, GPIO_QUAL_ASYNC );
 
 //GPIO18 is the SPICLKA.
 GPIO_setMasterCore( 18, GPIO_CORE_CPU1 );
 GPIO_setPinConfig(GPIO_18_SPICLKA );
 GPIO_setPadConfig( 18, GPIO_PIN_TYPE_PULLUP );
 GPIO_setQualificationMode( 18, GPIO_QUAL_ASYNC );
 
 //GPIO19 is the CS(active low).
 GPIO_setMasterCore(19, GPIO_CORE_CPU1 );
 GPIO_setPinConfig( GPIO_20_GPIO20 );
 GPIO_setPadConfig(19, GPIO_PIN_TYPE_PULLUP );
 GPIO_setQualificationMode(19, GPIO_QUAL_ASYNC );
 
 
 GPIO_setMasterCore( 20, GPIO_CORE_CPU1 );
 GPIO_setPinConfig( GPIO_20_GPIO20 );
 GPIO_setPadConfig( 20,GPIO_PIN_TYPE_STD );
 GPIO_setQualificationMode( 20, GPIO_QUAL_ASYNC );
 GPIO_setDirectionMode(20,GPIO_DIR_MODE_OUT);
}
 
void SPI_GateDriver_Config()
{
 GPIO_writePin( GATE_DRIVER_SHTDN_GPIO, 0 );//pull gate driver Shutdown pin to low
 
Write_SPI_Data( RESET_COMMAND);
Write_SPI_Data(StartConfiguration);
SPI_GateDriver_Write_Reg( CFG1_REG_ADDR,CFG1Value);
Write_SPI_Data(StopConfiguration);
}
 
 void SPI_GateDriver_Write_Reg( uint8_t reg_address, uint8_t data )
{
uint16_t spi_data = 0;
 
spi_data = ( WRITE_COMMAND | reg_address );
Write_SPI_Data( spi_data );
Write_SPI_Data( data );
 
}
 
void Write_SPI_Data( uint16_t command )
{
uint16_t i = 0;
 
GPIO_writePin( GATEDRIVE_CS_GPIO, 0 ); //assert chip select low
SPI_writeDataNonBlocking(SPIA_BASE, command );
GPIO_writePin( GATEDRIVE_CS_GPIO, 1 ); //assert chip select high
 
 
GPIO_writePin( GATEDRIVE_CS_GPIO, 0 ); //assert chip select low
SPI_writeDataNonBlocking(SPIA_BASE, CRC );
GPIO_writePin( GATEDRIVE_CS_GPIO, 1 ); //assert chip select high
 
DEVICE_DELAY_US(3000);
 
}
 
 
uint16_t Read_SPI_Data( uint16_t reg_addr )
{
uint16_t i = 0;
uint16_t ret_val = 0;
uint8_t data = 0;
 
data = ( reg_addr | READ_COMMAND );
 
Write_SPI_Data( data );
Write_SPI_Data(0x00);
 
ret_val = SPI_readDataNonBlocking( SPIA_BASE );
return ( ret_val );
}
 

Please tell if i am missing anything.

Thank you