spi_driver.c

Go to the documentation of this file.

/* This file has been prepared for Doxygen automatic documentation generation.*/
#include "spi_driver.h"



void SPI_MasterInit(SPI_Master_t *spi,
                    SPI_t *module,
                    PORT_t *port,
                    bool lsbFirst,
                    SPI_MODE_t mode,
                    SPI_INTLVL_t intLevel,
                    bool clk2x,
                    SPI_PRESCALER_t clockDivision)
{
        spi->module         = module;
        spi->port           = port;
        spi->interrupted    = false;

        spi->module->CTRL   = clockDivision |                  /* SPI prescaler. */
                              (clk2x ? SPI_CLK2X_bm : 0) |     /* SPI Clock double. */
                              SPI_ENABLE_bm |                  /* Enable SPI module. */
                              (lsbFirst ? SPI_DORD_bm  : 0) |  /* Data order. */
                              SPI_MASTER_bm |                  /* SPI master. */
                              mode;                            /* SPI mode. */

        /* Interrupt level. */
        spi->module->INTCTRL = intLevel;

        /* No assigned data packet. */
        spi->dataPacket = NULL;

        /* MOSI and SCK as output. */
        spi->port->DIRSET  = SPI_MOSI_bm | SPI_SCK_bm;
}



void SPI_SlaveInit(SPI_Slave_t *spi,
                   SPI_t *module,
                   PORT_t *port,
                   bool lsbFirst,
                   SPI_MODE_t mode,
                   SPI_INTLVL_t intLevel)
{
        /* SPI module. */
        spi->module       = module;
        spi->port         = port;

        spi->module->CTRL = SPI_ENABLE_bm |                /* Enable SPI module. */
                            (lsbFirst ? SPI_DORD_bm : 0) | /* Data order. */
                            mode;                          /* SPI mode. */

        /* Interrupt level. */
        spi->module->INTCTRL = intLevel;

        /* MISO as output. */
        spi->port->DIRSET = SPI_MISO_bm;
}



void SPI_MasterCreateDataPacket(SPI_DataPacket_t *dataPacket,
                                const uint8_t *transmitData,
                                uint8_t *receiveData,
                                uint8_t bytesToTransceive,
                                PORT_t *ssPort,
                                uint8_t ssPinMask)
{
        dataPacket->ssPort            = ssPort;
        dataPacket->ssPinMask         = ssPinMask;
        dataPacket->transmitData      = transmitData;
        dataPacket->receiveData       = receiveData;
        dataPacket->bytesToTransceive  = bytesToTransceive;
        dataPacket->bytesTransceived   = 0;
        dataPacket->complete          = false;
}



void SPI_MasterInterruptHandler(SPI_Master_t *spi)
{
        uint8_t data;
        uint8_t bytesTransceived = spi->dataPacket->bytesTransceived;

        /* If SS pin interrupt (SS used and pulled low).
        *  No data received at this point. */
        if ( !(spi->module->CTRL & SPI_MASTER_bm) ) {
                spi->interrupted = true;
        }

        else {  /* Data interrupt. */

                /* Store received data. */
                data = spi->module->DATA;
                spi->dataPacket->receiveData[bytesTransceived] = data;

                /* Next byte. */
                bytesTransceived++;

                /* If more data. */
                if (bytesTransceived < spi->dataPacket->bytesToTransceive) {
                        /* Put data byte in transmit data register. */
                        data = spi->dataPacket->transmitData[bytesTransceived];
                        spi->module->DATA = data;
                }

                /* Transmission complete. */
                else {

                        /* Release SS to slave(s). */
                        uint8_t ssPinMask = spi->dataPacket->ssPinMask;
                        SPI_MasterSSHigh(spi->dataPacket->ssPort, ssPinMask);

                        spi->dataPacket->complete = true;
                }
        }
        /* Write back bytesTransceived to data packet. */
        spi->dataPacket->bytesTransceived = bytesTransceived;
}



uint8_t SPI_MasterInterruptTransceivePacket(SPI_Master_t *spi,
                                            SPI_DataPacket_t *dataPacket)
{
        uint8_t data;
        bool interrupted = spi->interrupted;

        /* If no packets sent so far. */
        if (spi->dataPacket == NULL) {
                spi->dataPacket = dataPacket;
        }

        /* If ongoing transmission. */
        else if (spi->dataPacket->complete == false) {
                return (SPI_BUSY);
        }

        /* If interrupted by other master. */
        else if (interrupted) {
                /* If SS released. */
                if (spi->port->OUT & SPI_SS_bm) {
                        /* No longer interrupted. */
                        interrupted = false;
                }
                else {
                        return (SPI_INTERRUPTED);
                }
        }

        /* NOT interrupted by other master.
        * Start transmission. */
        spi->dataPacket = dataPacket;
        spi->dataPacket->complete = false;
        spi->interrupted = false;

        /* SS to slave(s) low.*/
        uint8_t ssPinMask = spi->dataPacket->ssPinMask;
        SPI_MasterSSLow(spi->dataPacket->ssPort, ssPinMask);

        spi->dataPacket->bytesTransceived = 0;

        /* Start sending data. */
        data = spi->dataPacket->transmitData[0];
        spi->module->DATA = data;

        /* Successs */
        return (SPI_OK);
}


uint8_t SPI_MasterTransceiveByte(SPI_Master_t *spi, uint8_t TXdata)
{
        /* Send pattern. */
        spi->module->DATA = TXdata;

        /* Wait for transmission complete. */
        while(!(spi->module->STATUS & SPI_IF_bm)) {

        }
        /* Read received data. */
        uint8_t result = spi->module->DATA;

        return(result);
}



bool SPI_MasterTransceivePacket(SPI_Master_t *spi,
                                SPI_DataPacket_t *dataPacket)
{
        /* Check if data packet has been created. */
        if(dataPacket == NULL) {
                return false;
        }

        /* Assign datapacket to SPI module. */
        spi->dataPacket = dataPacket;

        uint8_t ssPinMask = spi->dataPacket->ssPinMask;

        /* If SS signal to slave(s). */
        if (spi->dataPacket->ssPort != NULL) {
                /* SS to slave(s) low. */
                SPI_MasterSSLow(spi->dataPacket->ssPort, ssPinMask);
        }

        /* Transceive bytes. */
        uint8_t bytesTransceived = 0;
        uint8_t bytesToTransceive = dataPacket->bytesToTransceive;
        while (bytesTransceived < bytesToTransceive) {

                /* Send pattern. */
                uint8_t data = spi->dataPacket->transmitData[bytesTransceived];
                spi->module->DATA = data;

                /* Wait for transmission complete. */
                while(!(spi->module->STATUS & SPI_IF_bm)) {

                }
                /* Read received data. */
                data = spi->module->DATA;
                spi->dataPacket->receiveData[bytesTransceived] = data;

                bytesTransceived++;
        }

        /* If SS signal to slave(s). */
        if (spi->dataPacket->ssPort != NULL) {
                /* Release SS to slave(s). */
                SPI_MasterSSHigh(spi->dataPacket->ssPort, ssPinMask);
        }

        /* Set variables to indicate that transmission is complete. */
        spi->dataPacket->bytesTransceived = bytesTransceived;
        spi->dataPacket->complete = true;

        /* Report success. */
        return true;
}