SPI Library

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

Library Routines

SPI1_Init
SPI1_Init_Advanced
SPI1_Read
SPI1_Write
SPI_Set_Active

Generic Routines

SPI_Read
SPI_Write

SPI1_Init

Prototype	void SPI1_Init(); // for XMEGA family of MCUs void SPIx_Init();
Returns	Nothing.
Description	This routine configures and enables SPI module with the following settings: master mode 8 bit data transfer most significant bit sent first serial clock low when idle data sampled on leading edge serial clock = fosc/4 For XMEGA family of MCUs change the X in the routine prototype with C, D, E or F. Note : Bear in mind when using MCU's with alternate SPI ports, that this routine will activate standard SPI port. Please, consult the appropriate datasheet.
Requires	MCU must have SPI module.
Example	// Initialize the SPI1 module with default settings SPI1_Init();

SPI1_Init_Advanced

Prototype

// for MCUs without alternate SPI ports

void SPI1_Init_Advanced(char mode, char fcy_div, char clock_and_edge);

// for MCUs with alternate SPI ports

void SPI1_Init_Advanced(char mode, char fcy_div, char clock_and_edge, char alt_pinout);

// for XMEGA family of MCUs

void SPIx_Init_Advanced(char mode, char fcy_div, char clock_and_edge);

Returns

Nothing.

Description

Configures and initializes SPI. SPI1_Init_Advanced or SPI1_Init needs to be called before using other functions of SPI Library.
For XMEGA family of MCUs change the X in the routine prototype with C, D, E or F.
Parameters mode, fcy_div, clock_and_edge and alt_port determine the work mode for SPI, and can have the following values:

Description	Predefined library const
SPI mode constants:
`Master mode`	`_SPI_MASTER`
`Slave mode`	`_SPI_SLAVE`
Clock rate select constants:
`Sck = Fosc/4, Master mode`	`_SPI_FCY_DIV4`
`Sck = Fosc/16, Master mode`	`_SPI_FCY_DIV16`
`Sck = Fosc/64, Master mode`	`_SPI_FCY_DIV64`
`Sck = Fosc/128, Master mode`	`_SPI_FCY_DIV128`
`Sck = Fosc/2, Master mode`	`_SPI_FCY_DIV2`
`Sck = Fosc/8, Master mode`	`_SPI_FCY_DIV8`
`Sck = Fosc/32, Master mode`	`_SPI_FCY_DIV32`
SPI clock polarity and phase constants:
`Clock idle level is low, sample on rising edge`	`_SPI_CLK_LO_LEADING`
`Clock idle level is low, sample on falling edge`	`_SPI_CLK_LO_TRAILING`
`Clock idle level is high, sample on rising edge`	`_SPI_CLK_HI_LEADING`
`Clock idle level is high, sample on falling edge`	`_SPI_CLK_HI_TRAILING`
Alternate SPI port settings:
`Set standard SPI port as active`	`_SPI_STD_PINOUT`
`Set alternate SPI port as active`	`_SPI_ALT_PINOUT`

Note :

Some SPI clock speeds are not supported by all AVR MCUs and these are: Fosc/2, Fosc/8, Fosc/32. Please consult appropriate datasheet.
For alternate SPI port function and use, please consult appropriate datasheet.

Requires

MCU must have SPI module.

Example

// Set SPI to the Master Mode, clock = Fosc/32 , clock idle level is high, data sampled on falling edge:
SPI1_Init_Advanced(_SPI_MASTER, _SPI_FCY_DIV32, _SPI_CLK_HI_TRAILING);

// Set SPI to the Master Mode, clock = Fosc/4 , clock idle level is low, data sampled on rising edge, alternate SPI port selected:
SPI1_Init_Advanced(_SPI_MASTER, _SPI_FCY_DIV4, _SPI_CLK_LO_LEADING, _SPI_ALT_PINOUT);

SPI1_Read

Prototype	unsigned short SPI1_Read(unsigned short buffer); // for XMEGA family of MCUs 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) For XMEGA family of MCUs change the X in the routine prototype with C, D, E or F.
Requires	SPI module must be initialized before using this function. See SPI1_Init and SPI1_Init_Advanced routines.
Example	// read a byte from the SPI bus char take, dummy1; ... take = SPI1_Read(dummy1);

SPI1_Write

Prototype	void SPI1_Write(unsigned short data_); // for XMEGA family of MCUs void SPIx_Write(unsigned short data_);
Returns	Nothing.
Description	Writes byte via the SPI bus. Parameters : `data_:` data to be sent For XMEGA family of MCUs change the X in the routine prototype with C, D, E or F.
Requires	SPI module must be initialized before using this function. See SPI1_Init and SPI1_Init_Advanced routines.
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:` SPI1_Read handler `write_ptr:` SPI1_Write handler
Requires	Routine is available only for MCUs with multiple SPI modules. Used SPI module must be initialized before using this function. See the SPI1_Init, SPI1_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	SPI module must be initialized before using this function. See SPI1_Init and SPI1_Init_Advanced routines.
Example	// read a byte from the SPI bus char take, dummy1; ... take = SPI_Read(dummy1);

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 : `data_:` data to be sent
Requires	SPI module must be initialized before using this function. See SPI1_Init and SPI1_Init_Advanced routines.
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 PORTB0_bit;
sbit Chip_Select_Direction at DDB0_bit;
// End DAC module connections

unsigned int value;                     

void InitMain() {
  DDA0_bit = 0;                           // Set PA0 pin as input
  DDA1_bit = 0;                           // Set PA1 pin as input
  Chip_Select = 1;                        // Deselect DAC
  Chip_Select_Direction = 1;              // Set CS# pin as Output
  SPI1_Init();                            // Initialize SPI1 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() {

  InitMain();                             // Perform main initialization

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

    if ((PINA0_bit) && (value < 4095)) {  // If PA0 button is pressed
      value++;                            //   increment value
      }
    else {
      if ((PINA1_bit) && (value > 0)) {   // If PA1 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