1.3 Getting Started with SPI

To generate this project using MPLAB® Code Configurator (MCC), follow the next steps:

1. Create a new MPLAB X IDE project for PIC18F47Q10.
2. Open the MCC from the toolbar. Information about how to install the MCC plug-in can be found here.
3. Go to Project Resources → System → System Module and do the following configuration:
   • Oscillator Select: HFINTOSC
   • HF Internal Clock: 64_MHz
   • Clock Divider: 1
   • In the Watchdog Timer Enable field in the WWDT tab, make sure WDT Disabled is selected.
   • In the Programming tab, make sure Low-Voltage Programming Enable is checked.
4. From the Device Resources window, add MSSP1 and do the following configuration:
   • Serial Protocol: SPI
   • Mode: Master
   • SPI Mode: SPI Mode 0
   • Input Data Sampled At: Middle
   • Clock Source Selection: F_OSC/4_SSPxADD
   • SPI Clock Frequency box: 8000000
5. Open Pin Manager → Grid View window, select UQFN40 in the Package field and do the following pin configurations:
   • Set Port C pin 6 (RC6) as output for Slave Select 1 (SS1)
   • Set Port C pin 7 (RC7) as output for Slave Select 2 (SS2)
   The SCK, SDO and SDI pins appear alongside the MSSP1 peripheral and have their direction preset.

   

6. Click Pin Module in the Project Resources tab and set custom names for the SS pins:
   • Rename RC6 to Slave1
   • Rename RC7 to Slave2
7. Click Generate in the Project Resources tab.
8. In the main.c file which has been generated by MCC, change or add the following code:
   • Control of slave devices
   • Data transmission

   uint8_t writeData = 1;          /* Data that will be transmitted */
   uint8_t receiveData;            /* Data that will be received */
   
   void main(void)
   {
       // Initialize the device
       SYSTEM_Initialize();
   
       while (1)
       {
           SPI1_Open(SPI1_DEFAULT);
           Slave1_SetLow();
           receiveData = SPI1_ExchangeByte(writeData);
           Slave1_SetHigh();
           SPI1_Close();
           
           SPI1_Open(SPI1_DEFAULT);
           Slave2_SetLow();
           receiveData = SPI1_ExchangeByte(writeData);
           Slave2_SetHigh();
           SPI1_Close();
       }
   }

To generate this project using Foundation Services Library, follow the next steps:

1. Create a new MPLAB X IDE project for PIC18F47Q10.
2. Open the MCC from the toolbar. Information on how to install the MCC plug-in can be found here.
3. Go to Project Resources → System → System Module and do the following configuration:
   • Oscillator Select: HFINTOSC
   • HF Internal Clock: 64_MHz
   • Clock Divider: 1
   • In the Watchdog Timer Enable field in the WWDT tab, make sure WDT Disabled is selected.
   • In the Programming tab, make sure Low-Voltage Programming Enable is checked.
4. From the Device Resources → Foundation Services window, add SPIMASTER and do the following configuration:
   • Name: MASTER0
   • SPI Mode: MODE0
   • SPI Data Input Sample: MIDDLE
   • Speed (kHz): 8000
   • SPI: MSSP1
5. Open Pin Manager → Grid View window, select UQFN40 in the Package field and do the following pin configurations:
   • Set Port C pin 6 (RC6) as output for Slave Select 1 (SS1)
   • Set Port C pin 7 (RC7) as output for Slave Select 2 (SS2)
   The SCK, SDO and SDI pins appear alongside the MSSP1 peripheral and have their direction preset.

   

6. Click Pin Module in the Project Resources tab and set custom names for the SS pins:
   • Rename RC6 to Slave1
   • Rename RC7 to Slave2
7. Click Generate in the Project Resources tab.
8. In the main.c file that has been generated using Foundation Services Library, add the following code:
   • Control of slave devices
   • Data transmission

   uint8_t writeData = 1;          /* Data that will be transmitted */
   uint8_t receiveData;            /* Data that will be received */
   
   void main(void)
   {
       // Initialize the device
       SYSTEM_Initialize();
       
       while (1)
       {       
           spi_master_open(MASTER0);
           Slave1_SetLow();
           receiveData = SPI1_ExchangeByte(writeData);
           Slave1_SetHigh();
           SPI1_Close();
           
           spi_master_open(MASTER0);
           Slave2_SetLow();
           receiveData = SPI1_ExchangeByte(writeData);
           Slave2_SetHigh();
           SPI1_Close();
       }
   }

The necessary code and functions to implement the presented example are analyzed in this section.

The first step will be to configure the microcontroller to disable the Watchdog Timer and to enable Low-Voltage Programming.

#pragma config WDTE = OFF
#pragma config LVP = ON  

The internal oscillator has to be set to the desired value. This example uses the HFINTOSC with a frequency of 64 MHz. This translates into the following function:

static void CLK_Initialize(void)
{
    OSCCON1bits.NOSC = 6;        /* HFINTOSC Oscillator */
    
    OSCFRQbits.HFFRQ = 8;        /* HFFRQ 64 MHz */
}

The SPI clock frequency is derived from the main clock of the microcontroller (OSCFRQ) and is reduced using a prescaler or a divider circuit present in the MSSP hardware.

Configure the MSSP in SPI Master mode, with the previous selected clock source. An 8 MHz frequency will result in configuring the device in SPI Master mode with SPI clock = F_OSC / (4*(SSP1ADD + 1)). This translates into the following code:

static void SPI1_Initialize(void)
{  
    SSP1ADD = 0x01;     /* SSP1ADD = 1 */
    
    SSP1CON1 = 0x2A;    /* Enable module, SPI Master Mode */    
}

Configuring the location of the pins is independent of the application purpose and the SPI mode. Each microcontroller has its own default physical pin position for peripherals, but the pin positions can be changed using the Peripheral Pin Select (PPS).

The SPI pins can be relocated using the SSPxCLKPPS, SSPxDATPPS and SSPxSSPPS registers for the input channels. Use the RxyPPS registers for the output channels.

The PPS configuration values can be found in the Peripheral Pin Select Module section of a device data sheet. For SPI1 in Master mode, only the SDI pin requires input and use it with its default location RC4. SCK was mapped to RC3 and SDO was mapped to RC5. This translates into the following code:

static void PPS_Initialize(void)
{
    RC3PPS = 0x0F;               /* SCK channel on RC3 */
 
    SSP1DATPPS = 0x14;           /* SDI channel on RC4 */
    
    RC5PPS = 0x10;               /* SDO channel on RC5 */
}

Since the master sends data to two slave devices, two SS pins are needed (SS1 and SS2) in this example. For both of them, a General Purpose Input/Output (GPIO) pin was used (RC6 for SS1 and RC7 for SS2).

Because the master devices control and initiate transmissions, the SDO, SCK and SS pins must be configured as output while the SDI channel will keep its default direction as input. The following example is based on the relocation of the SPI1 pins made above:

static void PORT_Initialize(void)
{
    /* SDI as input; SCK, SDO, SS1, SS2 as output */
    TRISC = 0x17;
    
    /* SCK, SDI, SDO, SS1, SS2 as digital pins */
    ANSELC = 0x07;
}

A master will control a slave by pulling the SS pin low. If the slave has set the direction of its SDO pin to output when the SS pin is low, the SPI driver of the slave will take control of the SDI pin of the master. This will shift data out from its Transmit Buffer register.

All slave devices can receive a message, but only those with the SS pin pulled low can send data back. It is not recommended to enable more than one slave in a typical connection since all of them will try to respond to the message. With the master having only one SDI channel, the transmission will result in a write collision.

Before sending data, the user must pull one of the configured SS signals low to let the correspondent slave device know it is the recipient of the message.

static void SPI1_slave1Select(void)
{
    LATCbits.LATC6 = 0;          /* Set SS1 pin value to LOW */
}

Once the user writes new data into the Buffer register, the hardware starts a new transfer. This will generate the clock on the line and shift out the bits. The bits are shifted out starting with the Most Significant bit (MSb).

When the hardware finishes shifting all the bits, it sets the Buffer Full Status bit. The user must check the state of the flag before writing new data into the register by constantly reading the value of the bit (polling). If polling is not done, a write collision will occur.

static uint8_t SPI1_exchangeByte(uint8_t data)
{
    SSP1BUF = data;
    
    while(!PIR3bits.SSP1IF)     /* Wait until data is exchanged */
    {
        ;
    }   
    PIR3bits.SSP1IF = 0;
    
    return SSP1BUF;
}

The user can pull the SS channel high if there is nothing left to transmit.

static void SPI1_slave1Deselect(void)
{
    LATCbits.LATC6 = 1;          /* Set SS1 pin value to HIGH */
}

The selection of the slave devices and the data transmission are done in the main function.

int main(void)
{
    CLK_Initialize();
    PPS_Initialize();
    PORT_Initialize();
    SPI1_Initialize();
    
    while(1)
    {
        SPI1_slave1Select();
        receiveData = SPI1_exchangeByte(writeData);
        SPI1_slave1Deselect();
        
        SPI1_slave2Select();
        receiveData = SPI1_exchangeByte(writeData);
        SPI1_slave2Deselect();
    }
}

To generate this project using MPLAB® Code Configurator (MCC), follow the next steps:

1. Create a new MPLAB X IDE project for PIC18F47Q10.
2. Open MCC from the toolbar. Information on how to install the MCC plug-in can be found here.
3. Go to Project Resources → System → System Module and do the following configuration:
   • Oscillator Select: HFINTOSC
   • HF Internal Clock: 64_MHz
   • Clock Divider: 1
   • In the Watchdog Timer Enable field in the WWDT tab, make sure WDT Disabled is selected.
   • In the Programming tab, make sure Low-Voltage Programming Enable is checked.
4. From the Device Resources window, add MSSP1 and do the following configuration:
   • Serial Protocol: SPI
   • Mode: Slave
   • SPI Mode: SPI Mode 0
   • Enable Slave Select: checked
5. Open Pin Manager → Grid View window and select UQFN40 in the Package field. The SCK, SDO, SDI and SS pins appear alongside the MSSP1 peripheral and have their direction preset.

   

6. Click Generate in the Project Resources tab.
7. In the main.c file which has been generated by MCC, change or add the following code:
   • Peripheral initialization
   • Data receiving

   uint8_t receiveData;        /* Data that will be received */
   uint8_t writeData = 1;      /* Data that will be transmitted */
   
   void main(void)
   {
       // Initialize the device
       SYSTEM_Initialize();
       
       SPI1_Open(SPI1_DEFAULT);
   
       while (1)
       {
           if(!RA5_GetValue())                /* SS line is LOW */
           {
               receiveData = SPI1_ExchangeByte(writeData);
           }
       }
   }

To generate this project using Foundation Services Library, follow the next steps:

1. Create a new MPLAB X IDE project for PIC18F47Q10.
2. Open MCC from the toolbar. Information about how to install the MCC plug-in can be found here.
3. Go to Project Resources → System → System Module and do the following configuration:
   • Oscillator Select: HFINTOSC
   • HF Internal Clock: 64_MHz
   • Clock Divider: 1
   • In the Watchdog Timer Enable field in the WWDT tab, make sure WDT Disabled is selected.
   • In the Programming tab, make sure Low-Voltage Programming Enable is checked.
4. From the Device Resources → Foundation Services window, add SPISLAVE and do the following configuration:
   • Name: SLAVE0
   • SPI Mode: MODE0
   • SPI: MSSP1
5. Go to Project Resources → System → Interrupt Module → Easy Setup and uncheck the box right next to Pin Module.
6. Open Pin Manager → Grid View window, select UQFN40 in the Package field and do the following pin configuration:
   • Set Port A pin 5 (RA5) as input for Slave Select (SS)
   The SCK, SDO and SDI pins appear alongside the MSSP1 peripheral and have their direction preset.

   

7. Click Generate in the Project Resources tab.
8. In the main.c file which has been generated using Foundation Services Library, add the following code:
   • Peripheral initialization
   • Data receiving

   uint8_t receiveData;        /* Data that will be received */
   uint8_t writeData = 1;      /* Data that will be transmitted */
   
   void main(void)
   {
       // Initialize the device
       SYSTEM_Initialize();
       
       spi1_open(SLAVE0_CONFIG);
       
       while (1)
       {
           if(!SS_GetValue())                /* SS line is LOW */
           {
               receiveData = spi1_exchangeByte(writeData);
           }
       }
   }

The necessary code and functions to implement the presented example are analyzed in this section.

The first step will be to configure the microcontroller to disable the Watchdog Timer and to enable Low-Voltage Programming.

#pragma config WDTE = OFF
#pragma config LVP = ON 

The internal oscillator has to be set to the desired value. This example uses the HFINTOSC with a frequency of 64 MHz, which translates into the following function:

static void CLK_Initialize(void)
{
    OSCCON1bits.NOSC = 6;        /* HFINTOSC Oscillator */
    
    OSCFRQbits.HFFRQ = 8;        /* HFFRQ 64 MHz */
}

Since the slave gets its clock signal from the master device, there is no point in changing the clock divider of the peripheral. This change will have no effect in SPI Slave mode. However, the hardware peripheral has to sample the data received on their SDI channel. For the data signal to be correctly reconstructed, the main clock frequency of the device must be at least double the frequency received on the SPI SCK channel.

Next is an example on how to configure the MSSP in SPI Slave mode.

static void SPI1_Initialize(void)
{
    /* Enable module, SPI Slave Mode */
    SSP1CON1 = 0x24;        
}

Configuring the location of the pins is independent of the application purpose and the SPI mode. Each microcontroller has its own default physical pin position for peripherals, but the pin positions can be changed using the Peripheral Pin Select (PPS).

The SPI pins can be relocated using the SSPxCLKPPS, SSPxDATPPS and SSPxSSPPS registers for the input channels. Use the RxyPPS registers for the output channels.

The PPS configuration values can be found in the Peripheral Pin Select Module section of a device data sheet. For SPI1 in Slave mode, the SDI and SS pins require input, so use them with their default locations (RC4 for SDI and RA5 for SS). SCK was mapped to RC3 and SDO was mapped to RC5 in this example. This translates into the following code:

static void PPS_Initialize(void)
{
    SSP1SSPPS = 0x05;             /* SS channel on RA5 */
    
    RC3PPS = 0x0F;                /* SCK channel on RC3 */
 
    SSP1DATPPS = 0x14;            /* SDI channel on RC4 */
    
    RC5PPS = 0x10;                /* SDO channel on RC5 */
}

Since the slave device receives the incoming transmissions, the SDI, SCK and SS will keep their default direction as input while the SDO channel must be configured as output. The following example is based on the relocation of the SPI1 pins made above:

static void PORT_Initialize(void)
{
    /* SDO as output; SDI, SCK as input */
    TRISC = 0xDF;
    
    /* SS as digital pin */
    ANSELA = 0xDF;  
    
    /* SCK, SDI, SDO as digital pins */
    ANSELC = 0xC7;         
}

All the slave devices connected to the SPI bus will receive the message sent on their SDI channel by the master device. A slave cannot respond to a message unless the SS channel is pulled low. When the master device pulls the SS pin low, the SPI peripheral of the slave device will take control of its SDO pin and will shift data out.

Checking the value of SS is done through the polling method.

if(!PORTAbits.RA5)              /* SS line is LOW */

The peripheral will signal the reception of a new data by activating the SSPxIF flag of the PIR3 register. The user has to check the value of the bit also through polling.

After the received data was processed as wanted, the flag needs to be cleared. This is done by writing a ‘1’ in the bit location.

static uint8_t SPI1_exchangeByte(uint8_t data)
{
    SSP1BUF = data;
    
    while(!PIR3bits.SSP1IF) /* Wait until data is exchanged */
    {
        ;
    }   
    PIR3bits.SSP1IF = 0;
    
    return SSP1BUF;
}

The checking of the SS line and the data receiving is done in the main function.

int main(void)
{
    CLK_Initialize();
    PPS_Initialize();
    PORT_Initialize();
    SPI1_Initialize();
    
    while(1)
    {
        if(!PORTAbits.RA5)              /* SS line is LOW */
        {
            receiveData = SPI1_exchangeByte(writeData);
        }
    }
}

To generate this project using MPLAB® Code Configurator (MCC), follow the next steps:

1. Create a new MPLAB X IDE project for PIC18F47Q10.
2. Open MCC from the toolbar. Information about how to install the MCC plug-in can be found here.
3. Go to Project Resources → System → System Module and do the following configuration:
   • Oscillator Select: HFINTOSC
   • HF Internal Clock: 64_MHz
   • Clock Divider: 1
   • In the Watchdog Timer Enable field in the WWDT tab, make sure WDT Disabled is selected.
   • In the Programming tab, make sure Low-Voltage Programming Enable is checked.
4. From the Device Resources window, add MSSP1 and do the following configuration:
   • Hardware Settings tab
     • Serial Protocol: SPI
     • Mode: Slave
     • SPI Mode: SPI Mode 0
     • Enable Slave Select: checked
   • Interrupt Settings tab
     • Enable SPI Interrupt: checked
5. Open Pin Manager → Grid View window and select UQFN40 in the Package field. The SCK, SDO, SDI and SS pins appear alongside the MSSP1 peripheral and have their direction preset.

   

6. Click Generate in the Project Resources tab.
7. In the main.c file which has been generated by MCC, change or add the following code:
   • Enable the global and peripheral interrupts
   • Add the MSSP1 interrupt function
   • Set the MSSP1 interrupt handler initialize

   static void MSSP1_interruptHandler(void);
   
   volatile uint8_t receiveData;        /* Data that will be received */
   volatile uint8_t writeData = 1;      /* Data that will be transmitted */
   
   static void MSSP1_interruptHandler(void)
   {
       receiveData = SPI1_ExchangeByte(writeData);
   }
   
   void main(void)
   {
       // Initialize the device
       SYSTEM_Initialize();
       
       SPI1_Open(SPI1_DEFAULT);
       
       SPI1_SetInterruptHandler(MSSP1_interruptHandler);
   
       // Enable the Global Interrupts
       INTERRUPT_GlobalInterruptEnable();
   
       // Disable the Global Interrupts
       //INTERRUPT_GlobalInterruptDisable();
   
       // Enable the Peripheral Interrupts
       INTERRUPT_PeripheralInterruptEnable();
   
       // Disable the Peripheral Interrupts
       //INTERRUPT_PeripheralInterruptDisable();
   
       while (1)
       {
           ;
       }
   }

To generate this project using Foundation Services Library, follow the next steps:

1. Create a new MPLAB X IDE project for PIC18F47Q10.
2. Open MCC from the toolbar. Information about how to install the MCC plug-in can be found here.
3. Go to Project Resources → System → System Module and do the following configuration:
   • Oscillator Select: HFINTOSC
   • HF Internal Clock: 64_MHz
   • Clock Divider: 1
   • In the Watchdog Timer Enable field in the WWDT tab, make sure WDT Disabled is selected.
   • In the Programming tab, make sure Low-Voltage Programming Enable is checked.
4. From the Device Resources → Foundation Services window, add SPISLAVE and do the following configuration:
   • Name: SLAVE0
   • SPI Mode: MODE0
   • SPI: MSSP1
5. Go to Project Resources → System → Interrupt Module → Easy Setup. Uncheck the box right next to Pin Module and check the box right next to MSSP1-SSPI.
6. Open Pin Manager → Grid View window, select UQFN40 in the Package field and do the following pin configuration:
   • Set Port A pin 5 (RA5) as input for Slave Select (SS)
   The SCK, SDO and SDI pins appear alongside the MSSP1 peripheral and have their direction preset

   

7. Click Generate in the Project Resources tab.
8. In the main.c file which has been generated using Foundation Services Library, add the following code:
   • Enable the global and peripheral interrupts
   • Add the MSSP1 interrupt function
   • Set the MSSP1 interrupt handler initialize

   static void MSSP1_interruptHandler(void);
   
   volatile uint8_t receiveData;        /* Data that will be received */
   volatile uint8_t writeData = 1;      /* Data that will be transmitted */
   
   static void MSSP1_interruptHandler(void)
   {
       receiveData = spi1_exchangeByte(writeData);
   }
   
   void main(void)
   {
       // Initialize the device
       SYSTEM_Initialize();
       
       spi_slave_init();
       
       spi1_setSpiISR(MSSP1_interruptHandler);
   
       // Enable the Global Interrupts
       INTERRUPT_GlobalInterruptEnable();
   
       // Disable the Global Interrupts
       //INTERRUPT_GlobalInterruptDisable();
   
       // Enable the Peripheral Interrupts
       INTERRUPT_PeripheralInterruptEnable();
   
       // Disable the Peripheral Interrupts
       //INTERRUPT_PeripheralInterruptDisable();
       
       while (1)
       {
           ;
       }
   }

The necessary code and functions to implement the presented example are analyzed in this section.

The first step will be to configure the microcontroller to disable the Watchdog Timer and to enable Low-Voltage Programming.

#pragma config WDTE = OFF
#pragma config LVP = ON 

The internal oscillator has to be set to the desired value. This example uses the HFINTOSC with a frequency of 64 MHz, which translates into the following function:

static void CLK_Initialize(void)
{
    OSCCON1bits.NOSC = 6;        /* HFINTOSC Oscillator */
    
    OSCFRQbits.HFFRQ = 8;        /* HFFRQ 64 MHz */
}

Since the slave gets its clock signal from the master device, there is no point in changing the clock divider of the peripheral. This change will have no effect in SPI Slave mode. However, the hardware peripheral has to sample the data received on their SDI channel. For the data signal to be correctly reconstructed, the main clock frequency of the device must be at least double the clock frequency received on the SPI SCK channel.

Configure the MSSP in SPI Slave mode. To receive data using interrupts, the Interrupt Enable bit (SSPxIE) of the PIE3 register must be set.

static void SPI1_Initialize(void)
{
    /* Enable module, SPI Slave Mode */
    SSP1CON1 = 0x24;        
    
    /* Enable MSSP interrupts */
    PIE3bits.SSP1IE = 1;               
}

This allows the SPI module to trigger an interrupt every time it has received data on its SDI pin.

Configuring the location of the pins is independent of the application purpose and the SPI mode. Each microcontroller has its own default physical pin position for peripherals, but the pin positions can be changed using the Peripheral Pin Select (PPS).

The SPI pins can be relocated by using the SSPxCLKPPS, SSPxDATPPS and SSPxSSPPS registers for the input channels. Use the RxyPPS registers for the output channels.

The PPS configuration values can be found in the Peripheral Pin Select Module section of a device data sheet. For SPI1 in Slave mode, the SDI and SS pins require input, so use them with their default location (RC4 for SDI and RA5 for SS). SCK was mapped to RC3 and SDO was mapped to RC5 in this example. This translates into the following code:

static void PPS_Initialize(void)
{
    SSP1SSPPS = 0x05;             /* SS channel on RA5 */
    
    RC3PPS = 0x0F;                /* SCK channel on RC3 */
 
    SSP1DATPPS = 0x14;            /* SDI channel on RC4 */
    
    RC5PPS = 0x10;                /* SDO channel on RC5 */
}

Since the slave device receives the incoming transmissions, the SDI, SCK and SS will keep their default direction as input while the SDO channel must be configured as output. The following example is based on the relocation of the SPI1 pins made above:

static void PORT_Initialize(void)
{
    /* SDO as output; SDI, SCK as input */
    TRISC = 0xDF;
    
    /* SS as digital pin */
    ANSELA = 0xDF;  
    
    /* SCK, SDI, SDO as digital pins */
    ANSELC = 0xC7;         
}

Before any transfer of data, the interrupts of the microcontroller must be activated. This is done by setting the Global Interrupt Enable (GIE) and the Peripheral Interrupt Enable (PIE) bits of the INTCON register.

static void INTERRUPT_Initialize(void)
{
    INTCONbits.GIE = 1;              /* Enable Global Interrupts */
    INTCONbits.PEIE = 1;             /* Enable Peripheral interrupts */
}

The code snippet below shows how to write to the Buffer register, clear the Interrupt flag and read the received data. The user can choose what to do with the received data and what to write back to the master:

static uint8_t SPI1_exchangeByte(uint8_t data)
{
    SSP1BUF = data;
    
    while(!PIR3bits.SSP1IF) /* Wait until data is exchanged */
    {
        ;
    }   
    PIR3bits.SSP1IF = 0;
    
    return SSP1BUF;  
}

This exchange function is integrated in the interrupt handler of the MSSP1.

static void MSSP1_interruptHandler(void)
{
    receiveData = SPI1_exchangeByte(writeData);
}

The interrupt handler is handled by the interrupt manager.

void __interrupt() INTERRUPT_InterruptManager(void)
{
    if(INTCONbits.PEIE == 1)
    {
        if(PIE3bits.BCL1IE == 1 && PIR3bits.BCL1IF == 1)
        {
            MSSP1_InterruptHandler();
        } 
        else if(PIE3bits.SSP1IE == 1 && PIR3bits.SSP1IF == 1)
        {
            MSSP1_InterruptHandler();
        } 
    }
}

To generate this project using MPLAB® Code Configurator (MCC), follow the next steps:

1. Create a new MPLAB X IDE project for PIC18F47Q10.
2. Open MCC from the toolbar. Information about how to install the MCC plug-in can be found here.
3. Go to Project Resources → System → System Module and do the following configuration:
   • Oscillator Select: HFINTOSC
   • HF Internal Clock: 64_MHz
   • Clock Divider: 1
   • In the Watchdog Timer Enable field in the WWDT tab, make sure WDT Disabled is selected.
   • In the Programming tab, make sure Low-Voltage Programming Enable is checked.
4. From the Device Resources window, add MSSP1 and do the following configuration:
   • Serial Protocol: SPI
   • Mode: Master
   • SPI Mode: SPI Mode 3
   • Input Data Sampled At: Middle
   • Clock Source Selection: FOSC/4_SSPxADD
   • SPI Clock Frequency box: 8000000
5. Open Pin Manager → Grid View window, select UQFN40 in the Package field and do the following pin configuration:
   • Set Port C pin 6 (RC6) as output for Slave Select (SS)
   The SCK, SDO and SDI pins appear alongside the MSSP1 peripheral and have their direction preset.

   

6. Click Pin Module in the Project Resources tab and set the custom name for the SS pin:
   • Rename RC6 to Slave
7. Click Generate in the Project Resources tab.
8. In the main.c file which has been generated by MCC, change or add the following code:
   • Control of slave device
   • Data transmission

   uint8_t writeData = 1;          /* Data that will be transmitted */
   uint8_t receiveData = 0;        /* Data that will be received */
   
   void main(void)
   {
       // Initialize the device
       SYSTEM_Initialize();
   
       while (1)
       {       
           SPI1_Open(SPI1_DEFAULT);
           Slave_SetLow();
           receiveData = SPI1_ExchangeByte(writeData);
           Slave_SetHigh();
           SPI1_Close();
       }
   }

To generate this project using Foundation Services Library, follow the next steps:

1. Create a new MPLAB X IDE project for PIC18F47Q10.
2. Open the MCC from the toolbar. Information about how to install the MCC plug-in can be found here.
3. Go to Project Resources → System → System Module and do the following configuration:
   • Oscillator Select: HFINTOSC
   • HF Internal Clock: 64_MHz
   • Clock Divider: 1
   • In the Watchdog Timer Enable field in the WWDT tab, make sure WDT Disabled is selected.
   • In the Programming tab, make sure Low-Voltage Programming Enable is checked.
4. From the Device Resources → Foundation Services window, add SPIMASTER and do the following configuration:
   • Name: MASTER0
   • SPI Mode: MODE3
   • SPI Data Input Sample: MIDDLE
   • Speed (kHz): 8000
   • SPI: MSSP1
5. Open Pin Manager → Grid View window, select UQFN40 in the Package field and do the following pin configuration:
   • Set Port C pin 6 (RC6) as output for Slave Select (SS)
   The SCK, SDO and SDI pins appear alongside the MSSP1 peripheral and have their direction preset.

   

6. Click Pin Module in the Project Resources tab and set the custom name for the SS pin:
   • Rename RC6 to Slave
7. Click Generate in the Project Resources tab.
8. In the main.c file which has been generated using Foundation Services Library, add the following code:
   • Control of slave device
   • Data transmission

   uint8_t writeData = 1;          /* Data that will be transmitted */
   uint8_t receiveData = 0;        /* Data that will be received */
   
   void main(void)
   {
       // Initialize the device
       SYSTEM_Initialize();
   
       while (1)
       {        
           spi_master_open(MASTER0);
           Slave_SetLow();
           receiveData = SPI1_ExchangeByte(writeData);
           Slave_SetHigh();
           SPI1_Close();
       }
   }

The necessary code and functions to implement the presented example are analyzed in this section.

The first step is to configure the microcontroller to disable the Watchdog Timer and to enable Low-Voltage Programming.

#pragma config WDTE = OFF
#pragma config LVP = ON 

The internal oscillator has to be set to the desired value. This example uses the HFINTOSC with a frequency of 64 MHz, which translates into the following function:

static void CLK_Initialize(void)
{
    OSCCON1bits.NOSC = 6;        /* HFINTOSC Oscillator */
    
    OSCFRQbits.HFFRQ = 8;        /* HFFRQ 64 MHz */
}

The SPI clock frequency is derived from the main clock of the microcontroller and is reduced using a prescaler or divider circuit present in the MSSP hardware.

The clock polarity can be changed by modifying the value of the SCK Release Control bit from the SSPxCON1 register. The bit is cleared by default, so the Idle state of the SCK is at low level. For the next example, the bit will be set, which results in the Idle state of SCK being at high level.

Similarly with clock polarity, the clock edge can be changed by modifying the value of the Clock Select bit from the SSPxSTAT register. The bit is cleared by default, so the transmission occurred on the transition from Idle to Active Clock state.

Configure the MSSP in SPI Master mode, with the previous selected clock source. The master will send data in Data Mode 3. An 8 MHz frequency will result in configuring the device in SPI Master mode with SPI clock = F_OSC / (4*(SSP1ADD + 1)).

This translates into the following code:

static void SPI1_Initialize(void)
{
    /* SSP1ADD = 1 */
    SSP1ADD = 0x01;       
    
    /* Enable module, MSSP in SPI Master mode, CKP = 1 */
    SSP1CON1 = 0x3A; 
}

Configuring the location of the pins is independent of the application purpose and the SPI mode. Each microcontroller has its own default physical pin position for peripherals, but the pin positions can be changed using the Peripheral Pin Select (PPS).

The SPI pins can be relocated using the SSPxCLKPPS, SSPxDATPPS and SSPxSSPPS registers for the input channels. Use the RxyPPS registers for output channels.

The PPS configuration values can be found in the Peripheral Pin Select Module section of a device data sheet. For SPI1 in Master mode, only the SDI pin requires input and use it with its default location RC4. SCK was mapped to RC3 and SDO was mapped to RC5 in this example. This translates into the following code:

static void PPS_Initialize(void)
{
    RC3PPS = 0x0F;               /* SCK channel on RC3 */
 
    SSP1DATPPS = 0x14;           /* SDI channel on RC4 */
    
    RC5PPS = 0x10;               /* SDO channel on RC5 */
}

This example has the master send to a slave device, so one SS pin is needed. A General Purpose Input/Output (GPIO) pin was used (RC6).

Since the master devices control and initiate transmissions, the SDO, SCK and SS pins must be configured as output while the SDI channel will keep its default direction as input. The following example is based on the relocation of the SPI1 pins made above.

static void PORT_Initialize(void)
{
    /* SDI as input; SCK, SDO, SS as output */
    TRISC = 0x97;
    
    /* SCK, SDI, SDO, SS as digital pins */
    ANSELC = 0x87;      
}

A master will control a slave by pulling the SS pin low. If the slave has set the direction of its SDO pin to output when the SS pin is low, the SPI driver of the slave will take control of the SDI pin of the master. This will shift data out from its Transmit Buffer register.

All slave devices can receive a message, but only those with the SS pin pulled low can send data back. It is not recommended to enable more than one slave in a typical connection since all of them will try to respond to the message. Since the master has only one SDI channel, the transmission will result in a write collision.

Before sending data, the user must pull one of the configured SS signals low to let the correspondent slave device know it is the recipient of the message.

static void SPI1_slaveSelect(void)
{
    LATCbits.LATC6 = 0;          /* Set SS1 pin value to LOW */
}

Once the user writes new data into the Buffer register, the hardware starts a new transfer. This will generate the clock on the line and shift out the bits. The bits are shifted out starting with the Most Significant bit (MSb).

When the hardware finishes shifting all the bits, it sets the Buffer Full Status bit. The user must check the state of the flag before writing new data into the register by constantly reading the value of the bit (polling). If not done, a write collision will occur.

static uint8_t SPI1_exchangeByte(uint8_t data)
{
    SSP1BUF = data;
    
    while(!PIR3bits.SSP1IF) /* Wait until data is exchanged */
    {
        ;
    }   
    PIR3bits.SSP1IF = 0;
    
    return SSP1BUF;
}

The user can pull the SS channel high if there is nothing left to transmit.

static void SPI1_slaveDeselect(void)
{
    LATCbits.LATC6 = 1;          /* Set SS1 pin value to HIGH */
}

The selection of the slave device and the data transmission are done in the main function.

int main(void)
{
    CLK_Initialize();
    PPS_Initialize();
    PORT_Initialize();
    SPI1_Initialize();
    
    while(1)
    {
        SPI1_slaveSelect();
        receiveData = SPI1_exchangeByte(writeData);
        SPI1_slaveDeselect();
    }
}