3.22.1 SPI - Serial Peripheral Interface

This header file provides API prototypes for the SPI1 driver.

This header file provides API prototypes for the SPI2 driver.

This header file provides API prototypes for the SPI module in Polling and Interrupt mode.

This header file provides type definitions for the SPI module operation in Polling mode.

This header file provides type definitions for the SPI module operation in Interrupt mode.

• uint8_t con0

• uint8_t con1

• uint8_t con2

• uint8_t baud

• uint8_t clksel

The documentation for this struct was generated from the following files:

source/source-files/

spi_interrupt_types.h

source/source-files/

spi_polling_types.h

• uint8_t * transmitBuffer

• uint8_t * receiveBuffer

• size_t bytesToTransmit

• size_t bytesToReceive

• spi_status_t status

The documentation for this struct was generated from the following file:

source/source-files/

spi_interrupt_types.h

Defines an object for SPI_INTERFACE functions.

SPI Driver prototypes struct.

SPI driver interface object.

Section: Included Files

#include <spi_interface_interrupt.h>

The documentation for this struct was generated from the following files:

source/source-files/

spi_interface_interrupt.h

source/source-files/

spi_interface_polling.h

• void SPI1_Initialize (void)

  Initializes the SPI1 module.

• void SPI1_Deinitialize (void)

  Deinitializes the SPI1 module.

• bool SPI1_Open (uint8_t spiConfigIndex)

  Enables the SPI1 module with the configurations passed as the parameter. See spi1_config_names_t for the available configurations.

• void SPI1_Close (void)

  Closes the active configuration of the SPI1 module.

• void SPI1_BufferExchange (void *bufferData, size_t bufferSize)

  Exchanges the buffer using the SPI protocol. This function is blocking in Polling mode.

• void SPI1_BufferWrite (void *bufferData, size_t bufferSize)

  Writes a buffer using the SPI protocol. This function is blocking in Polling mode.

• void SPI1_BufferRead (void *bufferData, size_t bufferSize)

  Reads a buffer using the SPI protocol. This function is blocking in Polling mode.

• uint8_t SPI1_ByteExchange (uint8_t byteData)

  Exchanges one byte using the SPI protocol. This function is blocking.

• void SPI1_ByteWrite (uint8_t byteData)

  Writes one byte using the SPI protocol.

• uint8_t SPI1_ByteRead (void)

  Receives one byte using the SPI protocol.

• bool SPI1_IsTxReady (void)

  Checks if the SPI1 is ready to write data.

• bool SPI1_IsRxReady (void)

  Checks if the SPI1 module is ready to read data.

• const struct SPI_INTERFACE SPI1

• static const spi_configuration_t spi1_configuration []

• void SPI1_Initialize (void)

  Initializes the SPI1 module.

• void SPI1_Deinitialize (void)

  Deinitializes the SPI1 module.

• bool SPI1_Open (uint8_t spiConfigIndex)

  Enables the SPI1 module with the configurations passed as the parameter. See spi1_config_names_t for the available configurations.

• void SPI1_Close (void)

  Closes the active configuration of the SPI1 module.

• void SPI1_BufferExchange (void *bufferData, size_t bufferSize)

  Exchanges the buffer using the SPI protocol. This function is blocking in Polling mode.

• void SPI1_BufferWrite (void *bufferData, size_t bufferSize)

  Writes a buffer using the SPI protocol. This function is blocking in Polling mode.

• void SPI1_BufferRead (void *bufferData, size_t bufferSize)

  Reads a buffer using the SPI protocol. This function is blocking in Polling mode.

• uint8_t SPI1_ByteExchange (uint8_t byteData)

  Exchanges one byte using the SPI protocol. This function is blocking.

• void SPI1_ByteWrite (uint8_t byteData)

  Writes one byte using the SPI protocol.

• uint8_t SPI1_ByteRead (void)

  Receives one byte using the SPI protocol.

• bool SPI1_IsRxReady (void)

  Checks if the SPI1 module is ready to read data.

• bool SPI1_IsTxReady (void)

  Checks if the SPI1 is ready to write data.

• enum spi1_configuration_name_t { SPI1_DEFAULT }

  Enumeration of the different configurations supported by the driver. A configuration is specified as parameter to Open() and is used by the function to set SPI parameters as specified by the configuration.

• const struct SPI_INTERFACE SPI1

• void SPI2_Initialize (void)

  Initializes the SPI2 module.

• void SPI2_Deinitialize (void)

  Deinitializes the SPI2 module.

• bool SPI2_Open (uint8_t spiConfigIndex)

  Enables the SPI2 module with the configurations passed as the parameter. See spi2_config_names_t for the available configurations.

• void SPI2_Close (void)

  Closes the active configuration of the SPI2 module.

• void SPI2_BufferExchange (void *bufferData, size_t bufferSize)

  Exchanges the buffer using the SPI protocol. This function is blocking in Polling mode.

• void SPI2_BufferWrite (void *bufferData, size_t bufferSize)

  Writes a buffer using the SPI protocol. This function is blocking in Polling mode.

• void SPI2_BufferRead (void *bufferData, size_t bufferSize)

  Reads a buffer using the SPI protocol. This function is blocking in Polling mode.

• uint8_t SPI2_ByteExchange (uint8_t byteData)

  Exchanges one byte using the SPI protocol. This function is blocking.

• void SPI2_ByteWrite (uint8_t byteData)

  Writes one byte using the SPI protocol.

• uint8_t SPI2_ByteRead (void)

  Receives one byte using the SPI protocol.

• bool SPI2_IsTxReady (void)

  Checks if the SPI2 is ready to write data.

• bool SPI2_IsRxReady (void)

  Checks if the SPI2 module is ready to read data.

• void SPI2_RxCompleteCallbackRegister (void(*rxCompleteCallbackHandler)(void))

  Sets the callback function to be executed at the completion of data transfer receive in Interrupt mode.

• void SPI2_TxCompleteCallbackRegister (void(*txCompleteCallbackHandler)(void))

  Sets the callback function to be executed at the completion of data transfer transmit in Interrupt mode.

• void SPI2_Receive_ISR (void)

  Interrupt service routine (ISR) with receive interrupt RXIF for the SPI2 module.

• void SPI2_Transmit_ISR (void)

  ISR with transmit interrupt TXIF for the SPI2 module.

• void SPI2_ISR (void)

  ISR for the SPI2 module.

• const struct SPI_INTERFACE SPI2

• static void(* SPI2_RxCompleteCallback )(void)

• static void(* SPI2_TxCompleteCallback )(void)

• static spi_descriptor_t spi2_descriptor

• static const spi_configuration_t spi2_configuration []

• void SPI2_Initialize (void)

  Initializes the SPI2 module.

• void SPI2_Deinitialize (void)

  Deinitializes the SPI2 module.

• bool SPI2_Open (uint8_t spiConfigIndex)

  Enables the SPI2 module with the configurations passed as the parameter. See spi2_config_names_t for the available configurations.

• void SPI2_Close (void)

  Closes the active configuration of the SPI2 module.

• void SPI2_BufferExchange (void *bufferData, size_t bufferSize)

  Exchanges the buffer using the SPI protocol. This function is blocking in Polling mode.

• void SPI2_BufferWrite (void *bufferData, size_t bufferSize)

  Writes a buffer using the SPI protocol. This function is blocking in Polling mode.

• void SPI2_BufferRead (void *bufferData, size_t bufferSize)

  Reads a buffer using the SPI protocol. This function is blocking in Polling mode.

• uint8_t SPI2_ByteExchange (uint8_t byteData)

  Exchanges one byte using the SPI protocol. This function is blocking.

• void SPI2_ByteWrite (uint8_t byteData)

  Writes one byte using the SPI protocol.

• uint8_t SPI2_ByteRead (void)

  Receives one byte using the SPI protocol.

• bool SPI2_IsRxReady (void)

  Checks if the SPI2 module is ready to read data.

• bool SPI2_IsTxReady (void)

  Checks if the SPI2 is ready to write data.

• void SPI2_RxCompleteCallbackRegister (void(*rxCompleteCallbackHandler)(void))

  Sets the callback function to be executed at the completion of data transfer receive in Interrupt mode.

• void SPI2_TxCompleteCallbackRegister (void(*txCompleteCallbackHandler)(void))

  Sets the callback function to be executed at the completion of data transfer transmit in Interrupt mode.

• void SPI2_Receive_ISR (void)

  Interrupt service routine (ISR) with receive interrupt RXIF for the SPI2 module.

• void SPI2_Transmit_ISR (void)

  ISR with transmit interrupt TXIF for the SPI2 module.

• void SPI2_ISR (void)

  ISR for the SPI2 module.

• enum spi2_configuration_name_t { SPI2_DEFAULT }

  Enumeration of the different configurations supported by the driver. A configuration is specified as parameter to Open() and is used by the function to set SPI parameters as specified by the configuration.

• const struct SPI_INTERFACE SPI2

• struct SPI_INTERFACE

  Defines an object for SPI_INTERFACE functions.

• struct SPI_INTERFACE

  Defines an object for SPI_INTERFACE functions.

• struct spi_descriptor_t

• struct spi_configuration_t

• enum spi_status_t { SPI_RESET = 0x00U, SPI_IDLE = 0x81U, SPI_BUSY = 0x42U }

  Enumeration for the different states of the SPI module.

SPI Type Definitions Header File

• struct spi_configuration_t

SPI Type Definitions Header File

The use cases show example uses of the SPI PLIB Driver, within a MCC Melody project:

This example shows how to Setup Host Mode and to transmit a byte of data via the SPI peripheral.

#include "mcc_generated_files/system/system.h"  

int main(void)
{
    SYSTEM_Initialize();
    SPI1_Close();

    uint8_t    data = 0xA5;
    while(1)
    {
    //Send Byte via SPI
    SPI1_Open(SPI1_DEFAULT);
    SPI1TCNT = 1;
    SPI1_ByteWrite(data);
    while(!PIR3bits.SPI1RXIF);
    SPI1_Close();
    }    
}

This example shows how to Setup Host Mode and to Receive a byte of data via the SPI peripheral.

After configuring the components as described above, click 'Generate' to generate code. Then add the following code snippets to your application:

#include "mcc_generated_files/system/system.h"  

int main(void)
{
    SYSTEM_Initialize();
    SPI1_Close();

    while(1)
    {
    uint8_t    receivedData;
    SPI1_Open(SPI1_DEFAULT);
    receivedData = SPI1_ByteRead();
    __delay_us(80);
    SPI1_Close();
    }    
}

This example shows how to Setup Host Mode and to Exchange a byte of data via the SPI peripheral.

After configuring the components as described above, click 'Generate' to generate code. Then add the following code snippets to your application:  

#include "mcc_generated_files/system/system.h"  

int main(void)
{
    SYSTEM_Initialize();
    SPI1_Close();

    while(1)
    {
                            //Exchange Byte via SPI
uint8_t    data = 0xA5;
uint8_t    receivedData;
    SPI1_Open(SPI1_DEFAULT);
    receivedData  = SPI1_ByteExchange(data);
    SPI1_Close();
    }    
}

This example shows how to Setup Host Mode and to transmit a block of data via the SPI peripheral.

After configuring the components as described above, click 'Generate' to generate code. Then add the following code snippets to your application:

#include "mcc_generated_files/system/system.h"  

uint32_t    bufferSize = 64;        
uint8_t dataBufPtr[] =
        {
        0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
        0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10,
        0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
        0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20,
        0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
        0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30,
        0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38,
        0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F, 0x40
    };
int main(void)
{
    SYSTEM_Initialize();
    SPI1_Close();

    while(1)
    {
    SPI1_Open(SPI1_DEFAULT);
    SPI1_BufferWrite(dataBufPtr, bufferSize);
    SPI1_Close();
    }    
}

This example shows how to Setup Host Mode and to Receive a block of data via the SPI peripheral.

After configuring the components as described above, click 'Generate' to generate code. Then add the following code snippets to your application:

#include "mcc_generated_files/system/system.h"  

int main(void)
{
    SYSTEM_Initialize();
    SPI1_Close();

    while(1)
    {
#define bufferSize 64        
volatile uint8_t readDataBuffer[bufferSize];

    SPI1_Open(SPI1_DEFAULT);
    SS1_SetLow();
    SPI1_BufferRead(readDataBuffer, bufferSize);
    SS1_SetHigh();
    SPI1_Close();
    }    
}

This example shows how to setup Host Mode and to Exchange a block of data via the SPI peripheral.

After configuring the components as described above, click 'Generate' to generate code. Then add the following code snippets to your application:  

#include "mcc_generated_files/system/system.h"  

uint32_t    bufferSize = 64;
volatile uint8_t dataBufPtr[] =
        {
        0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
        0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10,
        0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
        0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20,
        0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
        0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30,
        0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38,
        0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F, 0x40,
    };
int main(void)
{
    SYSTEM_Initialize();
    SPI1_Close();
    
    SPI1_Open(SPI1_DEFAULT);
    SS1_SetLow();
    SPI1_BufferWrite(dataBufPtr, bufferSize);
    SS1_SetHigh();
    SPI1_Close();
    while(1)
    {
    }    
}

This example shows how to setup Client Mode to transmit a byte of data via the SPI peripheral.

#include "mcc_generated_files/system/system.h"  

int main(void)
{
    SYSTEM_Initialize();
    SPI1_Close();

uint8_t    data = 0xA5;
    while(1)
    {
    SPI1_Open(SPI1_DEFAULT);
    SPI1_ByteWrite(data);
    SPI1_Close();
    }    
}

This example shows how to setup Client Mode to Receive a byte of data via the SPI peripheral.

#include "mcc_generated_files/system/system.h"  

int main(void)
{
    SYSTEM_Initialize();
    SPI1_Close();

    while(1)
    {
    uint8_t    receivedData;
    SPI1_Open(SPI1_DEFAULT);
    receivedData = SPI1_ByteRead();
    SPI1_Close();
    }    
}

This example shows how to setup Client Mode to Exchange a byte of data via the SPI peripheral.

#include "mcc_generated_files/system/system.h"  

int main(void)
{
    SYSTEM_Initialize();
    SPI1_Close();

    while(1)
    {
                            //Exchange Byte via SPI
uint8_t    data = 0xA5;
uint8_t    receivedData;
    SPI1_Open(SPI1_DEFAULT);
    receivedData  = SPI1_ByteExchange(data);
    SPI1_Close();
    }    
}

This example shows how to setup Client Mode to Transmit a block of data via the SPI peripheral.

uint32_t    bufferSize = 64;        
volatile uint8_t dataBufPtr[] =
        {
        0x40, 0x3F, 0x3E, 0x3D, 0x3C, 0x3B, 0x3A, 0x39,
        0x38, 0x37, 0x36, 0x35, 0x34, 0x33, 0x32, 0x31,
        0x30, 0x2F, 0x2E, 0x2D, 0x2C, 0x2B, 0x2A, 0x29,
        0x28, 0x27, 0x26, 0x25, 0x24, 0x23, 0x22, 0x21,
        0x20, 0x1F, 0x1E, 0x1D, 0x1C, 0x1B, 0x1A, 0x19,
        0x18, 0x17, 0x16, 0x15, 0x14, 0x13, 0x12, 0x11,
        0x10, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09,
        0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01
    };
int main(void)
{
    SYSTEM_Initialize();
    SPI1_Close();
    SPI1_Open(SPI1_DEFAULT);
    SPI1_BufferExchange(dataBufPtr, bufferSize);
    SPI1_Close();
    while(1)
    { 
    }    
}

This example shows how to Setup Client Mode and to Receive a block of data via the SPI peripheral.

After configuring the components as described above, click 'Generate' to generate code. Then add the following code snippets to your application:

#include "mcc_generated_files/system/system.h"  

int main(void)
{
    SYSTEM_Initialize();
    SPI1_Close();

    while(1)
    {
        uint8_t    receivedData;
    SPI1_Open(SPI1_DEFAULT);
    receivedData = SPI1_ByteRead();
    SPI1_Close();
    }    
}

This example shows how to setup Client Mode and to Exchange a block of data via the SPI peripheral.

After configuring the components as described above, click 'Generate' to generate code. Then add the following code snippets to your application:  

#include "mcc_generated_files/system/system.h"  

uint32_t    bufferSize = 64;        
volatile uint8_t dataBufPtr[] =
        {
        0x40, 0x3F, 0x3E, 0x3D, 0x3C, 0x3B, 0x3A, 0x39,
        0x38, 0x37, 0x36, 0x35, 0x34, 0x33, 0x32, 0x31,
        0x30, 0x2F, 0x2E, 0x2D, 0x2C, 0x2B, 0x2A, 0x29,
        0x28, 0x27, 0x26, 0x25, 0x24, 0x23, 0x22, 0x21,
        0x20, 0x1F, 0x1E, 0x1D, 0x1C, 0x1B, 0x1A, 0x19,
        0x18, 0x17, 0x16, 0x15, 0x14, 0x13, 0x12, 0x11,
        0x10, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09,
        0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01
    };
int main(void)
{
    SYSTEM_Initialize();
    SPI1_Close();
    SPI1_Open(SPI1_DEFAULT);
    SPI1_BufferExchange(dataBufPtr, bufferSize);
    SPI1_Close();
    while(1)
    { 
    }    
}