Part Number: TMS320F280049
Dear All:
I want to use a SPI B of Ti 280049 to receive another MCU's data.
Ti 280049 is a slave mode, spi clock is 20MHz, Pin define as below
SPIB_CLK:GPIO_22
SPIB_SIMO:GPIO_7
SPIB_SOMI:GPIO_6
SPIB_STE:GPIO_29
So far, I can't enter interrupt to receive data of master, and I don't sure how to correct setting the SPIB clock(20MHz)
My code as below
//
// Included Files
//
#include "driverlib.h"
#include "device.h"
// Globals
volatile uint16_t rData[8]; // Receive data buffer
volatile uint16_t rDataPoint = 0; // To keep track of where we are in the data stream to check received data
// Function Prototypes
void initSPIBSlave(void);
void configGPIOs(void);
__interrupt void spibRxFIFOISR(void);
// Main
void main(void)
{
Device_init(); // Initialize device clock and peripherals
Device_initGPIO(); // Disable pin locks and enable internal pullups.
Interrupt_initModule(); // Initialize PIE and clear PIE registers. Disables CPU interrupts.
Interrupt_initVectorTable(); // Initialize the PIE vector table with pointers to the shell Interrupt Service Routines (ISR).
Interrupt_register(INT_SPIB_RX, &spibRxFIFOISR); // Interrupts that are used in this example are re-mapped to ISR functions found within this file.
configGPIOs(); // Configure GPIOs for external loopback.
initSPIBSlave(); // Set up SPI B as slave, initializing it for FIFO mode
// Enable interrupts required for this example
Interrupt_enable(INT_SPIB_RX);
// Enable Global Interrupt (INTM) and realtime interrupt (DBGM)
EINT;
ERTM;
// Loop forever. Suspend or place breakpoints to observe the buffers.
while(1)
{
;
}
}
// Function to configure SPI B as slave with FIFO enabled.
void initSPIBSlave(void)
{
// SPI B
// Must put SPI into reset before configuring it
SPI_disableModule(SPIB_BASE);
// SPI configuration. Use a 20 MHz SPICLK and 16-bit word size.
SPI_enableHighSpeedMode(SPIB_BASE);
SPI_setConfig(SPIB_BASE, DEVICE_LSPCLK_FREQ, SPI_PROT_POL0PHA1, SPI_MODE_SLAVE, 20000000, 16);
SPI_disableLoopback(SPIB_BASE);
SPI_setEmulationMode(SPIB_BASE, SPI_EMULATION_FREE_RUN);
// FIFO and interrupt configuration
SPI_enableFIFO(SPIB_BASE);
SPI_clearInterruptStatus(SPIB_BASE, SPI_INT_RXFF | SPI_INT_TXFF);
SPI_setFIFOInterruptLevel(SPIB_BASE, SPI_FIFO_TX8, SPI_FIFO_RX8);
SPI_enableInterrupt(SPIB_BASE, SPI_INT_RXFF | SPI_INT_TXFF);
SPI_enableModule(SPIB_BASE); // Configuration complete. Enable the module.
}
// Configure GPIOs for external loopback.
void configGPIOs(void)
{
GPIO_setPinConfig(DEVICE_GPIO_CFG_LED1);
GPIO_setMasterCore(DEVICE_GPIO_PIN_LED1, GPIO_CORE_CPU1);
GPIO_setPadConfig(DEVICE_GPIO_PIN_LED1, GPIO_PIN_TYPE_OD);
GPIO_setDirectionMode(DEVICE_GPIO_PIN_LED1, GPIO_DIR_MODE_OUT);
// SPI SOMI B.
GPIO_setMasterCore(DEVICE_GPIO_PIN_SPISOMIB, GPIO_CORE_CPU1);
GPIO_setPinConfig(DEVICE_GPIO_CFG_SPISOMIB);
GPIO_setPadConfig(DEVICE_GPIO_PIN_SPISOMIB, GPIO_PIN_TYPE_PULLUP);
GPIO_setQualificationMode(DEVICE_GPIO_PIN_SPISOMIB, GPIO_QUAL_ASYNC);
// SPI SIMO B clock pin.
GPIO_setMasterCore(DEVICE_GPIO_PIN_SPISIMOB, GPIO_CORE_CPU1);
GPIO_setPinConfig(DEVICE_GPIO_CFG_SPISIMOB);
GPIO_setPadConfig(DEVICE_GPIO_PIN_SPISIMOB, GPIO_PIN_TYPE_PULLUP);
GPIO_setQualificationMode(DEVICE_GPIO_PIN_SPISIMOB, GPIO_QUAL_ASYNC);
// SPI STE B. STE = slave transmit enable
GPIO_setMasterCore(DEVICE_GPIO_PIN_SPISTEB, GPIO_CORE_CPU1);
GPIO_setPinConfig(DEVICE_GPIO_CFG_SPISTEB);
GPIO_setPadConfig(DEVICE_GPIO_PIN_SPISTEB, GPIO_PIN_TYPE_PULLUP);
GPIO_setQualificationMode(DEVICE_GPIO_PIN_SPISTEB, GPIO_QUAL_ASYNC);
// SPI CLK B.
GPIO_setAnalogMode(DEVICE_GPIO_PIN_SPICLKB, GPIO_ANALOG_DISABLED);
GPIO_setMasterCore(DEVICE_GPIO_PIN_SPICLKB, GPIO_CORE_CPU1);
GPIO_setPinConfig(DEVICE_GPIO_CFG_SPICLKB);
GPIO_setPadConfig(DEVICE_GPIO_PIN_SPICLKB, GPIO_PIN_TYPE_PULLUP);
GPIO_setQualificationMode(DEVICE_GPIO_PIN_SPICLKB, GPIO_QUAL_ASYNC);
}
// SPI B Receive FIFO ISR
__interrupt void spibRxFIFOISR(void)
{
uint16_t i;
// Read data
for(i = 0; i < 8; i++)
{
rData[i] = SPI_readDataNonBlocking(SPIB_BASE);
}
//
// Clear interrupt flag and issue ACK
//
SPI_clearInterruptStatus(SPIB_BASE, SPI_INT_RXFF);
Interrupt_clearACKGroup(INTERRUPT_ACK_GROUP6);
}
regards Jonny
