SPI Library

The mikroC PRO for PIC provides a library for comfortable with SPI work in Master mode. The PIC MCU can easily communicate with other devices via SPI: A/D converters, D/A converters, MAX7219, LTC1290, etc.

Important :

SPI routines require you to specify the module you want to use. To select the desired SPI, simply change the letter x in the prototype for a number from 1 to 2.
Number of SPI modules per MCU differs from chip to chip. Please, read the appropriate datasheet before utilizing this library.
Some MCUs have multiple SPI modules. Switching between the SPI modules in the SPI library is done by the SPI_Set_Active function (SPI module has to be previously initialized).
Some of the MCUs do not support SPIx_Init_Advanced routine. Please, refer to the appropriate datasheet.
Certain SPI lines on some PIC16 Enhanced Family MCUs can be routed through a alternative pins. These pins are selected by configuring APFCON register and appropriate TRIS register.

Generic Routines

SPI_Read
SPI_Write

SPIx_Init

Prototype	void SPIx_Init();
Returns	Nothing.
Description	This routine configures and enables SPI module with the following settings: master mode clock Fosc/4 clock idle state low data transimtted on low to high edge input data sampled at the middle of interval
Requires	You need PIC MCU with hardware integrated SPI.
Example	// Initialize the SPI1 module with default settings SPI1_Init();

SPIx_Init_Advanced

Prototype

void SPIx_Init_Advanced(unsigned short master_slav, unsigned short data_sample, unsigned short clock_idle, unsigned short transmit_edge);

Returns

Nothing.

Description

Configures and initializes SPI. SPIx_Init or SPIx_Init_Advanced needs to be called before using other functions of SPI Library.

Parameters mode, data_sample and clock_idle configure the SPI module, and can have the following values:

Description	Predefined library const
SPI work mode:
`Master clock = Fosc/4`	`_SPI_MASTER_OSC_DIV4`
`Master clock = Fosc/16`	`_SPI_MASTER_OSC_DIV16`
`Master clock = Fosc/64`	`_SPI_MASTER_OSC_DIV64`
`Master clock source TMR2`	`_SPI_MASTER_TMR2`
`Slave select enabled`	`_SPI_SLAVE_SS_ENABLE`
`Slave select disabled`	`_SPI_SLAVE_SS_DIS`
Data sampling interval:
`Input data sampled in middle of interval`	`_SPI_DATA_SAMPLE_MIDDLE`
`Input data sampled at the end of interval`	`_SPI_DATA_SAMPLE_END`
SPI clock idle state:
`Clock idle HIGH`	`_SPI_CLK_IDLE_HIGH`
`Clock idle LOW`	`_SPI_CLK_IDLE_LOW`
Transmit edge:
`Data transmit on low to high edge`	`_SPI_LOW_2_HIGH`
`Data transmit on high to low edge`	`_SPI_HIGH_2_LOW`

Requires

You need PIC MCU with hardware integrated SPI.

Example

// Set SPI1 module to master mode, clock = Fosc/4, data sampled at the middle of interval, clock idle state low and data transmitted at low to high edge:
SPI1_Init_Advanced(_SPI_MASTER_OSC_DIV4, _SPI_DATA_SAMPLE_MIDDLE, _SPI_CLK_IDLE_LOW, _SPI_LOW_2_HIGH);

SPIx_Read

Prototype	unsigned short SPIx_Read(unsigned short buffer);
Returns	Returns the received data.
Description	Reads one byte from the SPI bus. Parameters : `buffer:` dummy data for clock generation (see device Datasheet for SPI modules implementation details)
Requires	You need PIC MCU with hardware integrated SPI. SPI must be initialized and communication established before using this function. See SPIx_Init_Advanced or SPIx_Init.
Example	short take, buffer; ... take = SPI1_Read(buffer);

SPIx_Write

Prototype	void SPIx_Write(unsigned short data_);
Returns	Nothing.
Description	Writes byte via the SPI bus. Parameters : `wrdata:` data to be sent
Requires	You need PIC MCU with hardware integrated SPI. SPI must be initialized and communication established before using this function. See SPIx_Init_Advanced or SPIx_Init.
Example	// write a byte to the SPI bus char buffer; ... SPI1_Write(buffer);

SPI_Set_Active

Prototype	void SPI_Set_Active(char (read_ptr)(char), void(write_ptr)(char))
Returns	Nothing.
Description	Sets the active SPI module which will be used by the SPI routines. Parameters : `read_ptr:` SPIx_Read handler `write_ptr:` SPIx_Write handler
Requires	Routine is available only for MCUs with two SPI modules. Used SPI module must be initialized before using this function. See the SPIx_Init, SPIx_Init_Advanced
Example	SPI_Set_Active(&SPI2_Read, &SPI2_Write); // Sets the SPI2 module active

SPI_Read

Prototype	unsigned short SPI_Read(unsigned short buffer);
Returns	Returns the received data.
Description	Reads one byte from the SPI bus. This is a generic routine which uses the active SPI module previously activated by the SPI_Set_Active routine. Parameters : `buffer:` dummy data for clock generation (see device Datasheet for SPI modules implementation details)
Requires	You need PIC MCU with hardware integrated SPI. SPI must be initialized and communication established before using this function. See SPIx_Init_Advanced or SPIx_Init.
Example	short take, buffer; ... take = SPI_Read(buffer);

SPI_Write

Prototype	void SPI_Write(unsigned short data_);
Returns	Nothing.
Description	Writes byte via the SPI bus. This is a generic routine which uses the active SPI module previously activated by the SPI_Set_Active routine. Parameters : `wrdata:` data to be sent
Requires	You need PIC MCU with hardware integrated SPI. SPI must be initialized and communication established before using this function. See SPIx_Init_Advanced or SPIx_Init.
Example	// write a byte to the SPI bus char buffer; ... SPI_Write(buffer);

Library Example

The code demonstrates how to use SPI library functions for communication between SPI module of the MCU and Microchip's MCP4921 12-bit D/A converter

Copy Code To Clipboard

// DAC module connections
sbit Chip_Select at RC0_bit;
sbit Chip_Select_Direction at TRISC0_bit;
// End DAC module connections

unsigned int value;                     

void InitMain() {
  TRISA0_bit = 1;                        // Set RA0 pin as input
  TRISA1_bit = 1;                        // Set RA1 pin as input
  Chip_Select = 1;                       // Deselect DAC
  Chip_Select_Direction = 0;             // Set CS# pin as Output
  SPI1_Init();                           // Initialize SPI module
}

// DAC increments (0..4095) --> output voltage (0..Vref)
void DAC_Output(unsigned int valueDAC) {
  char temp;
 
  Chip_Select = 0;                       // Select DAC chip
  
  // Send High Byte                                         
  temp = (valueDAC >> 8) & 0x0F;         // Store valueDAC[11..8] to temp[3..0]
  temp |= 0x30;                          // Define DAC setting, see MCP4921 datasheet
  SPI1_Write(temp);                      // Send high byte via SPI
  
  // Send Low Byte
  temp = valueDAC;                       // Store valueDAC[7..0] to temp[7..0]
  SPI1_Write(temp);                      // Send low byte via SPI
  
  Chip_Select = 1;                       // Deselect DAC chip
}

void main() {
  ANSEL = 0;
  ANSELH = 0;
  InitMain();                            // Perform main initialization

  value = 2048;                          // When program starts, DAC gives
                                         //   the output in the mid-range
                                          
 while (1) {                             // Endless loop

    if ((RA0_bit) && (value < 4095)) {   // If RA0 button is pressed
      value++;                           //   increment value
      }
    else {
      if ((RA1_bit) && (value > 0)) {    // If RA1 button is pressed
        value--;                         //   decrement value
        }
      }
    DAC_Output(value);                   // Send value to DAC chip
    Delay_ms(1);                         // Slow down key repeat pace
  }
}

HW Connection

SPI connection

SPI HW connection

Want more examples and libraries?
Find them on