spi_polled_example.c

Go to the documentation of this file.

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


#define NUM_BYTES     4

/* Global variables */

SPI_Master_t spiMasterC;

SPI_Slave_t spiSlaveD;

SPI_DataPacket_t dataPacket;

uint8_t masterSendData[NUM_BYTES] = {0x11, 0x22, 0x33, 0x44};

uint8_t masterReceivedData[NUM_BYTES];

bool success = true;



int main(void)
{
        /* Init SS pin as output with wired AND and pull-up. */
        PORTC.DIRSET = PIN4_bm;
        PORTC.PIN4CTRL = PORT_OPC_WIREDANDPULL_gc;

        /* Set SS output to high. (No slave addressed). */
        PORTC.OUTSET = PIN4_bm;

        /* Instantiate pointer to ssPort. */
        PORT_t *ssPort = &PORTC;

        /* Initialize SPI master on port C. */
        SPI_MasterInit(&spiMasterC,
                       &SPIC,
                       &PORTC,
                       false,
                       SPI_MODE_0_gc,
                       SPI_INTLVL_OFF_gc,
                       false,
                       SPI_PRESCALER_DIV4_gc);

        /* Initialize SPI slave on port D. */
        SPI_SlaveInit(&spiSlaveD,
                      &SPID,
                      &PORTD,
                      false,
                                  SPI_MODE_0_gc,
                                  SPI_INTLVL_OFF_gc);

        /* PHASE 1: Transceive individual bytes. */

        /* MASTER: Pull SS line low. This has to be done since
         *         SPI_MasterTransceiveByte() does not control the SS line(s). */
        SPI_MasterSSLow(ssPort, PIN4_bm);

        for(uint8_t i = 0; i < NUM_BYTES; i++) {
                /* MASTER: Transmit data from master to slave. */
                SPI_MasterTransceiveByte(&spiMasterC, masterSendData[i]);

                /* SLAVE: Wait for data to be available. */
                while (SPI_SlaveDataAvailable(&spiSlaveD) == false) {

                }

                /* SLAVE: Get the byte received. */
                uint8_t slaveByte = SPI_SlaveReadByte(&spiSlaveD);

                /* SLAVE: Increment received byte and send back. */
                slaveByte++;
                SPI_SlaveWriteByte(&spiSlaveD, slaveByte);

                /* MASTER: Transmit dummy data to shift data from slave to master. */
                uint8_t masterReceivedByte = SPI_MasterTransceiveByte(&spiMasterC, 0x00);

                /* MASTER: Check if the correct value was received. */
                if (masterReceivedByte != (masterSendData[i] + 1) ) {
                        success = false;
                }
        }

        /* MASTER: Release SS to slave. */
        SPI_MasterSSHigh(ssPort, PIN4_bm);

        /* PHASE 2: Transceive data packet. */

        /* Create data packet (SS to slave by PC4). */
        SPI_MasterCreateDataPacket(&dataPacket,
                                   masterSendData,
                                   masterReceivedData,
                                   NUM_BYTES,
                                   &PORTC,
                                   PIN4_bm);

        /* Transceive packet. */
        SPI_MasterTransceivePacket(&spiMasterC, &dataPacket);

        /* Check that correct data was received. Assume success at first. */
        for (uint8_t i = 0; i < NUM_BYTES - 1; i++) {
                if (masterReceivedData[i + 1] != masterSendData[i]) {
                        success = false;
                }
        }

        while(true) {
                nop();
        }
}