/**
* @brief Main routine for SPI example
* @return Function should not exit
*/
int main(void)
{
/* Generic Initialization */
SystemCoreClockUpdate();
Board_Init();
/* Clear activity LED */
Board_LED_Set(0, false);
/* Setup SPI pin muxing */
Init_SPI_PinMux();
/* Allocate SPI handle, setup rate, and initialize clocking */
setupSpiMaster();
/* Enable SPI0 interrupt */
NVIC_EnableIRQ(SPI0_IRQn);
/* Loop forever */
while (1) {
/* Write simple message over SPI */
WriteSpiMssg(xferArray, sizeof(xferArray) / sizeof(xferArray[0]));
/* Toggle LED to show activity. */
Board_LED_Toggle(0);
}
/* Code never reaches here. Only used to satisfy standard main() */
return 0;
}
/**
* @brief Main routine for SPI example
* @return Does not return
*/
int main(void)
{
uint16_t seed = 0;
SystemCoreClockUpdate();
Board_Init();
/* SPI initialization */
Init_SPI_PinMux();
/* Initialize stopwatch driver so some event times can be measured */
StopWatch_Init();
/* Setup SPI controllers */
setupMaster();
setupSlave();
/* Enable SPI controller interrupts */
NVIC_EnableIRQ(LPC_SPIMASTERIRQNUM);
NVIC_EnableIRQ(LPC_SPISLAVEIRQNUM);
DEBUGSTR("SPI master/slave combined example\r\n");
/* If you enable loopback mode and connect the master and slave controller's clock
and SSEL lines together, the master and slave will wrap data to each other */
// Chip_SPIM_EnableLoopBack(LPC_SPIMASTERPORT);
/* Loop forever */
while (1) {
/* Setup some data for transmit from master to slave and slave to master */
seed = bufferInit(seed);
/* Set slave transfer, this is only the initial transfer,
the callbacks can change this later */
spiSlaveXfer.pTXData16 = slaveTXBuffer16;
spiSlaveXfer.txCount = sizeof(slaveTXBuffer16) / sizeof(uint16_t); /* Count is in transfer size */
spiSlaveXfer.pRXData16 = slaveRXBuffer16;
spiSlaveXfer.rxCount = sizeof(slaveRXBuffer16) / sizeof(uint16_t); /* Count is in transfer size */
/* Set master transfer, this is only the initial transfer,
the callbacks can change this later */
spiMasterXfer.pTXData16 = masterTXBuffer16; /* Use NULL to send 0x0 */
spiMasterXfer.txCount = sizeof(masterTXBuffer16) / sizeof(uint16_t);/* Count is in transfer size */
spiMasterXfer.pRXData16 = masterRXBuffer16;
spiMasterXfer.rxCount = sizeof(masterRXBuffer16) / sizeof(uint16_t);/* Count is in transfer size */
/* Setup master transfer options - 16 data bits per transfer, EOT, EOF */
spiMasterXfer.options =
SPI_TXCTL_FLEN(16) | /* This must be enabled as a minimum, use 16 data bits */
// SPI_TXCTL_EOT | /* Enable this to assert and deassert SSEL for each individual byte/word, current slave functions for this example do not support this */
// SPI_TXCTL_EOF | /* Insert a delay between bytes/words as defined by frame delay time */
// SPI_TXCTL_RXIGNORE | /* Enable this to ignore incoming data, or set spiMasterXfer.pRXData16 to NULL to ignore RX data */
0;
/* Transfer will terminate after current buffer is sent. If terminate is not set, the buffers
must be setup by the callbacks */
spiMasterXfer.terminate = true;
/* Use SPI select 0 */
spiMasterXfer.sselNum = 0;
/* Time master and slave transfers */
masterTime = StopWatch_Start();
/* Limitation: The call below 'pre-buffers' the initial slave transmit datum.
If this isn't pre-buffered, a slave transmit underflow will always occur
at slave assertion time for the initial transmit datum. The datum sent to the
master will be 0. This is ok as we are only using a single slave, but with multiple
slaves pre-buffering is not always an option and the master might need to toss the
first byte. */
Chip_SPI_FlushFifos(LPC_SPIMASTERPORT);
Chip_SPI_FlushFifos(LPC_SPISLAVEPORT);
Chip_SPIS_PreBuffSlave(LPC_SPISLAVEPORT, &spiSlaveXfer);
/* Start master transfer */
Chip_SPIM_Xfer(LPC_SPIMASTERPORT, &spiMasterXfer);
/* Sleep until transfers are complete */
mEnd = sEnd = false;
while ((mEnd == false) || (sEnd == false)) {
__WFI();
}
/* Toggle LED */
Board_LED_Toggle(0);
/* Display some information about the transfer */
Print_Val("\r\nTRANSFER COMPLETE: errors = 0x", errors);
errors = 0;
Print_Val("Master total transfer time in uS: 0x", StopWatch_TicksToUs(StopWatch_Elapsed(masterTime)));
/* Show data */
showData("Master TX data", masterTXBuffer16);
showData("Master RX data", masterRXBuffer16);
showData("Slave TX data", slaveTXBuffer16);
showData("Slave RX data", slaveRXBuffer16);
}
}
/**
* @brief Main routine for SPI example
* @return Function should not exit
*/
int main(void)
{
uint32_t memSize, *devMem;
ROM_SPIS_INIT_T spisInit;
ROM_SPIS_SLAVE_T spisConfig;
int i;
/* Generic Initialization */
SystemCoreClockUpdate();
Board_Init();
/* Setup I2C pin muxing, enable S{I clock and reset I peripheral */
Init_SPI_PinMux();
Chip_Clock_EnablePeriphClock(LPC_SPIS_CLOCK);
Chip_SYSCON_PeriphReset(LPC_SPIS_RESET);
/* Get needed size for driver context memory */
memSize = ROM_SPIS_GetMemSize();
if (memSize > sizeof(drvData)) {
errorOut("Can't allocate memory for SPIS driver context\r\n");
}
devMem = drvData; /* Or just use malloc(memSize) */
/* Initialize driver */
spisInit.pUserData = (void *) &xferDone;
spisInit.base = (uint32_t) LPC_SPIS_PORT;
spisInit.spiPol[0] = 0; /* Active low select for SSEL0 */
spisInit.spiPol[1] = 0;
spisInit.spiPol[2] = 0;
spisInit.spiPol[3] = 0;
spisHandle = ROM_SPIS_Init(devMem, &spisInit);
if (spisHandle == NULL) {
/* Error initializing SPI */
errorOut("Error initializing ROM\r\n");
}
/* Set SPI transfer configuration */
spisConfig.mode = ROM_SPI_CLOCK_MODE0;
spisConfig.lsbFirst = 0;
spisConfig.dataBits = 8;
if (ROM_SPIS_SetupSlave(spisHandle, &spisConfig) != LPC_OK) {
errorOut("SPI configuration is invalid\r\n");
}
/* Callback registration */
ROM_SPIS_RegisterCallback(spisHandle, ROM_SPIS_ASSERTSSEL_CB, (void *) CBspiSlaveXferCSAssertCB);
ROM_SPIS_RegisterCallback(spisHandle, ROM_SPIS_DEASSERTSSEL_CB, (void *) CBspiSlaveXferCSDeAssertCB);
DEBUGSTR("SPI slave example\r\n");
/* Enable the interrupt for the SPI */
NVIC_EnableIRQ(LPC_SPIIRQNUM);
/* Read data as fast as possible in loop */
while (1) {
/* Setup transfer buffers and maximum transfer sizes, no transfer flags */
sXfer.txBuff = tx16;
sXfer.txSz = BUFFSENDSIZE;
sXfer.rxBuff = rx16;
sXfer.rxSz = BUFFSENDSIZE;
sXfer.flags = 0;
/* Start transfer. Will return immediately */
xferDone = false;
ROM_SPIS_Transfer(spisHandle, &sXfer);
/* Can monitor transfer status or completion flag to determine
end of transfer */
while (xferDone == false) {
/* Can sleep while waiting for SPI interrupts and end of trnasfer */
__WFI();
}
/* Check status of the transfer */
if (sXfer.status != LPC_OK) {
DEBUGOUT("-Error performing transfer = %x\r\n", sXfer.status);
}
else {
DEBUGOUT("-SPI transfer completed: status = %x\r\n", sXfer.status);
for (i = 0; i < sXfer.rxRecv; i++) {
DEBUGOUT("T:%04x R:%04x : ", tx16[i], rx16[i]);
}
DEBUGSTR("\r\n");
}
for (i = 0; i < sXfer.rxRecv; i++) {
tx16[i] = rx16[i];
}
}
/* Code never reaches here. Only used to satisfy standard main() */
return 0;
}
