int32_t DRV_SPI_MasterEBMSend8BitISR( struct DRV_SPI_DRIVER_OBJECT * pDrvInstance )
{
register SPI_MODULE_ID spiId = pDrvInstance->spiId;
register DRV_SPI_JOB_OBJECT * currentJob = pDrvInstance->currentJob;
/* Determine the maximum number of bytes we can send to the FIFO*/
uint8_t symbolsInTransit = MAX(pDrvInstance->symbolsInProgress, PLIB_SPI_FIFOCountGet(spiId, SPI_FIFO_TYPE_TRANSMIT));
uint8_t bufferBytes = PLIB_SPI_TX_8BIT_FIFO_SIZE(spiId) - symbolsInTransit;
/* Figure out how much data we can send*/
size_t dataUnits = MIN(currentJob->dataLeftToTx, bufferBytes);
size_t counter;
if (dataUnits != 0)
{
/* Adjust the maximum buffer size downwards based on how much data we'll be sending*/
bufferBytes -= dataUnits;
currentJob->dataLeftToTx -= dataUnits;
/* Set the location in the buffer of where to start sending from*/
uint8_t *bufferLoc = &(currentJob->txBuffer[currentJob->dataTxed]);
for (counter = 0; counter < dataUnits; counter++)
{
/* Send a unit/symbol of data*/
PLIB_SPI_BufferWrite(spiId, bufferLoc[counter]);
}
/* Update the number of bytes transmitted*/
currentJob->dataTxed += dataUnits;
/* Adjust the symbols in progress */
pDrvInstance->symbolsInProgress += dataUnits;
}
size_t dummyUnits = MIN(currentJob->dummyLeftToTx, bufferBytes);
if (dummyUnits != 0)
{
currentJob->dummyLeftToTx -= dummyUnits;
/* Adjust the symbols in progress */
pDrvInstance->symbolsInProgress += dummyUnits;
for (counter = 0; counter < dummyUnits; counter++)
{
PLIB_SPI_BufferWrite(spiId, 0xff);
}
}
if (currentJob->dataLeftToTx + currentJob->dummyLeftToTx == 0)
{
/* We have no more data to send, turn off the TX interrupt*/
PLIB_SPI_FIFOInterruptModeSelect(spiId, SPI_FIFO_INTERRUPT_WHEN_TRANSMIT_BUFFER_IS_COMPLETELY_EMPTY);
pDrvInstance->txEnabled = false;
/* Turn on the RX Interrupt*/
pDrvInstance->rxEnabled = true;
}
return 0;
}
int32_t DRV_SPI0_BufferAddWriteRead(const void * txBuffer, void * rxBuffer, uint32_t size)
{
bool continueLoop;
int32_t txcounter = 0;
int32_t rxcounter = 0;
uint8_t unitsTxed = 0;
const uint8_t maxUnits = 16;
do {
continueLoop = false;
unitsTxed = 0;
if (PLIB_SPI_TransmitBufferIsEmpty(SPI_ID_4))
{
while (!PLIB_SPI_TransmitBufferIsFull(SPI_ID_4) && (txcounter < size) && unitsTxed != maxUnits)
{
PLIB_SPI_BufferWrite(SPI_ID_4, ((uint8_t*)txBuffer)[txcounter]);
txcounter++;
continueLoop = true;
unitsTxed++;
}
}
while (txcounter != rxcounter)
{
while (PLIB_SPI_ReceiverFIFOIsEmpty(SPI_ID_4));
((uint8_t*)rxBuffer)[rxcounter] = PLIB_SPI_BufferRead(SPI_ID_4);
rxcounter++;
continueLoop = true;
}
if (txcounter > rxcounter)
{
continueLoop = true;
}
}while(continueLoop);
return txcounter;
}
int32_t DRV_SPI1_BufferAddWriteRead(const void * txBuffer, void * rxBuffer, uint32_t size)
{
bool continueLoop;
int32_t txcounter = 0;
int32_t rxcounter = 0;
do {
continueLoop = false;
if(!PLIB_SPI_TransmitBufferIsFull(SPI_ID_2) && txcounter < size)
{
PLIB_SPI_BufferWrite(SPI_ID_2, ((uint8_t*)txBuffer)[txcounter]);
txcounter++;
continueLoop = true;
}
while (txcounter != rxcounter)
{
while(!PLIB_SPI_ReceiverBufferIsFull(SPI_ID_2));
((uint8_t*)rxBuffer)[rxcounter] = PLIB_SPI_BufferRead(SPI_ID_2);
rxcounter++;
continueLoop = true;
}
if (txcounter > rxcounter)
{
continueLoop = true;
}
}while(continueLoop);
return txcounter;
}
int32_t DRV_SPI_MasterRMSend8BitISR( struct DRV_SPI_DRIVER_OBJECT * pDrvInstance )
{
register SPI_MODULE_ID spiId = pDrvInstance->spiId;
register DRV_SPI_JOB_OBJECT * currentJob = pDrvInstance->currentJob;
/* Check to see if we have any more bytes to transmit */
if (currentJob->dataLeftToTx + currentJob->dummyLeftToTx == 0)
{
/* We don't have any more data to send make sure the transmit interrupt is disabled */
pDrvInstance->txEnabled = false;
return 0;
}
/* Check to see if the transmit buffer is empty*/
if (!PLIB_SPI_TransmitBufferIsEmpty(spiId))
{
return 0;
}
/* Make sure that we don't have something in progress and overrun the RX buffer */
if (pDrvInstance->symbolsInProgress != 0)
{
return 0;
}
if (currentJob->dataLeftToTx != 0)
{
/* Transmit the data & update the counts */
PLIB_SPI_BufferWrite(spiId, currentJob->txBuffer[currentJob->dataTxed]);
currentJob->dataTxed++;
currentJob->dataLeftToTx--;
}
else
{
/* Transmit the dummy data & update the counts */
PLIB_SPI_BufferWrite(spiId, 0xff);
currentJob->dummyLeftToTx--;
}
/* We now have a symbol in progress*/
pDrvInstance->symbolsInProgress = 1;
return 0;
}
void SPIPut(uint16_t channel, unsigned char data)
{
// Wait for free buffer
while(!PLIB_SPI_TransmitBufferIsEmpty(channel));
PLIB_SPI_BufferWrite(channel, data);
// Wait for data byte
while(!PLIB_SPI_ReceiverBufferIsFull(channel));
return;
}
