PIC16F887 SPI MCP23S17 and Character LCD XC8 Example

In previous post I use the SPI interface of PIC16F887 to communicate with the MCP23S17 to read and write data from its I/O ports. The I/O port of MCP23S17 could be used for many input output purposes, relays driving, input sensor reading, etc.

Program Simulation in Proteus

In this example, I use GPIOA of MCP23S17 to control an HD44780 based character LCD module using its 4-bit data transfer mode. The MCP23S17 just need to write the 8-bit command or data to the LCD without concerning about reading the data back.

MCP23S17 DIP-28

The 8-bit LCD data will transfer the LCD controller twice. The higher nibble is sent first and then the lower nibble of the data byte. So the data byte must be latched into the LCD controller twice. Data latching is activated at falling edge of Enable (E) pin of the LCD.

I use the internal RC oscillator of PIC16F887 of 8MHz. The SPI clock frequency is Fosc/4. So the transfer rate is slower compare to direct I/O port driving. However we can use the external 20MHz crystal to get a higher frequency.

/*
 * File:   main.c
 * Author: Admin
 *
 * Created on February 9, 2024, 3:47 PM
 */
 
#include <xc.h>
#include "config.h"
#include "mcp23S17.h"
 
#define _XTAL_FREQ  8000000UL
 
#define RS  0
#define EN  2
 
void lcd_command(uint8_t command){
    uint8_t data;
    data=command&0xF0;
    mcp23S17_send(OLATA, data|(1<<EN));
    __delay_us(50);
    mcp23S17_send(OLATA, data);
    __delay_us(50);
 
    data=command<<4;
    mcp23S17_send(OLATA, data|(1<<EN));
    __delay_us(50);
    mcp23S17_send(OLATA, data);
    __delay_us(50);
}
 
void lcd_data(uint8_t myChar){
    uint8_t data;
    data=myChar&0xF0;
    mcp23S17_send(OLATA, data|(1<<RS)|(1<<EN));
    __delay_us(50);
    mcp23S17_send(OLATA, data);
    __delay_us(50);
 
    data=myChar<<4;
    mcp23S17_send(OLATA, data|(1<<RS)|(1<<EN));
    __delay_us(50);
    mcp23S17_send(OLATA, data|(1<<RS));
    __delay_us(50);
}
 
void lcd_xy(uint8_t x, uint8_t y){
    /*20x4 Character LCD*/
    uint8_t tbe[]={0x80,0xC0,0x94,0xD4};
    lcd_command(tbe[y-1]+x-1);
}
 
void lcd_text(uint8_t *txt){
    while(*txt) lcd_data(*txt++);
}
 
void lcd_init(void){
    spi_init();
    nCS=1;
    mcp23S17_send(IODIRA,0x00);
    mcp23S17_send(OLATA,0x00);
 
    lcd_command(0x33);
    lcd_command(0x32);
    lcd_command(0x28);
    lcd_command(0x0F);
    lcd_command(0x01);
    __delay_ms(5);
    lcd_command(0x06);
}
 
void main(void) {
    OSCCONbits.IRCF=7;
    lcd_init();
    lcd_xy(2,1);
    lcd_text("PIC16F887 MCP23S17");
    lcd_xy(2,2);
    lcd_text("SPI GPIO Extender");
    lcd_xy(2,3);
    lcd_text("Example With MPLABX");
    lcd_xy(1,4);
    lcd_text("And XC8 C Compiler..");
 
    while(1){
 
    }
    return;
}
 

I putted the SPI driver in separated files. 

• The spi.h header file

/* 
 * File:   spi.h
 * Author: Admin
 *
 * Created on February 9, 2024, 9:13 AM
 */
 
#include <xc.h>
 
#define nCS     RC2
 
void spi_init(void);
void spi_send(uint8_t data);
uint8_t spi_receive(void);
 
 

• The spi.c source file

 
#include "spi.h"
 
void spi_init(void){
    /*SPI Mode Clock Low To High*/
    SSPCONbits.CKP=0;
    SSPSTATbits.CKE=1;
    SSPSTATbits.SMP=0;
    /*SPI Master Mode Clock = Fosc/4*/
    SSPCONbits.SSPM=0;
    /*Turn On The Module*/
    SSPCONbits.SSPEN=1;
    SSPSTATbits.BF=1;
    PORTC=0;
    TRISC=0;
    /*SPI SDI Pin Input*/
    TRISC4=1;
}
 
void spi_send(uint8_t data){
    SSPSTATbits.BF==1;
    SSPBUF=data;
    while(SSPSTATbits.BF==0);
    SSPSTATbits.BF==1;
}
 
uint8_t spi_receive(void){
    uint8_t data;
    spi_send(0x00);
    data=SSPBUF;
    return data;
}

I wrote a driver for the MCP23S17 to send and received the data from this chip. It uses the SPI driver above.

• The MCP23S17.h header file

/* 
 * File:   mcp23S17.h
 * Author: Admin
 *
 * Created on February 9, 2024, 3:54 PM
 */
 
#include <xc.h>
#include "spi.h"
 
/*MCP23S17 Registers Definition*/
#define IODIRA      0x00
#define IODIRB      0x01
#define IPOLA       0x02
#define IPOLB       0x03
#define GPINTENA    0x04
#define GPINTENB    0x05
#define DEFVALA     0x06
#define DEFVALB     0x07
#define INTCONA     0x08
#define INTCONB     0x09
#define IOCONA      0x0A
#define IOCONB      0x0B
#define GPPUA       0x0C
#define GPPUB       0x0D
#define INTFA       0x0E
#define INTFB       0x0F
#define INTCAPA     0x10
#define INTCAPB     0x11
#define GPIOA       0x12
#define GPIOB       0x13
#define OLATA       0x14
#define OLATB       0x15
 
/*MCP23S17 Address*/
#define WRITE_ADDR  0x40
#define READ_ADDR   0x41
 
/*MCP23S17 Read and Write Functions*/
void mcp23S17_send(uint8_t address, uint8_t data);
uint8_t mcp23S17_receive(uint8_t address);
 
 

• The mcp23S17.c source file

 
#include "mcp23S17.h"
 
void mcp23S17_send(uint8_t address, uint8_t data){
    nCS=0;
    spi_send(WRITE_ADDR);
    spi_send(address);
    spi_send(data);
    nCS=1;
}
 
uint8_t mcp23S17_receive(uint8_t address){
    uint8_t data;
    nCS=0;
    spi_send(READ_ADDR);
    spi_send(address);
    data=spi_receive();
    nCS=1;  
    return data;
}

The MPLABX IDE version is v6.15 and the XC8 C compiler version is v2.36. You can use the latest version of C compiler as you prefer. Click here to download its source file.

PIC16F887 SPI and MCP23S17 XC8 Example

Overview

In previous post, I showed about the MSSP module of PIC16F887 with an SPI shift registers example. There are many SPI slave devices, a EEPROM memory, a GPIO extender chip, Flash memory, etc. 

Program Simulation in Proteus

Here I use a MCP23S17 SPI GPIO expanding chip. The Microchip MCP23X17 series has two options of communication interfaces, the MCP23017 (I2C) and the MCP23S17(SPI). Both of them are bi-directional in data data transaction. 

MCP23X17 Packaging Information

This chip has many package types including the Dual In Line Package (DIP-28) easing the prototyping for electronics hobbyists. I don't have the SPI communication interface of this chip. I have only one MCP23017 I2C one's.

MCP23017 I2C Type

This chip can be used for LEDs or relays driving, keypad scanning, LCD driving, etc.

Package Types

The SPI addressing mode is similar to the I2C mode. It uses a two-byte data package, device address, additional 3-bit addresses, and a read/write bit.

Functional Block Diagram

For SPI mode (MCP23S17) has the following I/O pins.

• Chip Select (CS) - Active low input signal latching data to its internal registers
• Serial Clock (SCK) - input synchronous clock signal up to 10MHz
• Serial Input (SI) - SPI serial data input (8-bit)
• Serial Output (SO) - SPI serial data output (8-bit)

It has an additional 3-bit addresses (A2:A0). These address could be ignored or enable by software setting. By setting bit 3 of IOCON register we can enable this feature. By default this feature is ignored (A2:A0=0x00) and the memory addressing locates at BANK0 of the registers map.

Reset input (RESET) is active low. This pin can be shared with the micro-controller reset circuit.

GPIOA Interrupt (INTA) and GPIOB Interrupt (INTB) are the output signal notifying the master SPI whenever the input interrupt at GPIOA and GPIOB occurs. However this feature must be enable in its interrupt registers setting.

GPIOA (GPA) and GPIOB (GPB) are digital bi-directional readable/writable ports. Its data direction registers can be selected using the IODIRA and IODIRB registers. These registers will be shown in its registers map.

In SPI mode the clock rate has a maximum frequency of 10MHz. 

SPI Addressing Registers

Its registers are divide into two banks, BANK0 and BANK1. By default BANK0 is active. So the programmer doesn't need to access BANK1 as it's not necessary. 

Register Addressed

For a full details of these registers you can see its device datasheet. Here I will use only some registers to work with.

• IODIRA - I/O DIRECTION REGISTER A (ADDR 0x00) : Clearing its bits for output direction, setting its bits for input direction.
• IODIRB - I/O DIRECTION REGISTER B (ADDR 0x01) : Clearing its bits for output direction, setting its bits for input direction.
• IOCONA - I/O EXPANDER CONFIGURATION REGISTER (ADDR 0x05)
  
• IOCONB - I/O EXPANDER CONFIGURATION REGISTER (ADDR 0x06)
• GPPUA -  GPIO PULL-UP RESISTOR REGISTER A(ADDR 0x0C)
• GPPUB -  GPIO PULL-UP RESISTOR REGISTER B(ADDR 0x0D)
• GPIOA -  GENERAL PURPOSE I/O PORT REGISTER A (ADDR 0x12)
  
• GPIOB -  GENERAL PURPOSE I/O PORT REGISTER B (ADDR 0x13)
  
• OLATA -  OUTPUT LATCH REGISTER A (ADDR 0x14)
  
• OLATB -  OUTPUT LATCH REGISTER B (ADDR 0x15)

In this example we use use these registers in the MPLABX IDE and XC8 compiler. 

PIC16F887 MPLABX IDE and XC8 Programming

I use the high speed SPI communication interface of the MSSP module to interface with this chip. The MCP23S17 SPI slave chip is writable and readable.

GPIOA is configured as digital input reading input data from a DIP switch. GPIOB is configured as digital output writing data to the output LED. I turned on the pull up resistors of GPIOA to raise it high by default.

/*
 * File:   main.c
 * Author: Admin
 *
 * Created on February 9, 2024, 9:10 AM
 */
 
#include <xc.h>
#include "config.h"
#include "spi.h"
 
#define _XTAL_FREQ  8000000UL
 
void mcp23S17_send(uint8_t address, uint8_t data){
    nCS=0;
    spi_send(WRITE_ADDR);
    spi_send(address);
    spi_send(data);
    nCS=1;
}
 
uint8_t mcp23S17_receive(uint8_t address){
    uint8_t data;
    nCS=0;
    spi_send(READ_ADDR);
    spi_send(address);
    data=spi_receive();
    nCS=1;  
    return data;
}
 
void mcp23S17_init(void){
    nCS=1;
    mcp23S17_send(0x0A,0x08);   // Enable Address Select
    mcp23S17_send(0x0B,0x08);   // Enable Address Select
    mcp23S17_send(0x00,0xFF);   // GPIOA AS INPUT
    mcp23S17_send(0x0C,0xFF);    // Enable All GPPUA
    mcp23S17_send(0x01,0x00);   // GPIOB AS OUTPUT
}
 
void main(void) {
    uint8_t data;
    OSCCONbits.IRCF=7;
    spi_init();
    mcp23S17_init();
    while(1){
        data=mcp23S17_receive(0x12);
        mcp23S17_send(0x15,data);
        __delay_ms(150);
    }
    return;
}
 

I created a separate SPI driver in this project.

The SPI.h file:

/* 
 * File:   spi.h
 * Author: Admin
 *
 * Created on February 9, 2024, 9:13 AM
 */
 
#include <xc.h>
 
#define WRITE_ADDR  0x40
#define READ_ADDR   0x41
 
#define nCS     RC2
 
void spi_init(void);
void spi_send(uint8_t data);
uint8_t spi_receive(void);
 
 

 The SPI.c file:

 
#include "spi.h"
 
void spi_init(void){
    /*SPI Mode Clock Low To High*/
    SSPCONbits.CKP=0;
    SSPSTATbits.CKE=1;
    SSPSTATbits.SMP=0;
    /*SPI Master Mode Clock = Fosc/64*/
    SSPCONbits.SSPM=2;
    /*Turn On The Module*/
    SSPCONbits.SSPEN=1;
    SSPSTATbits.BF=1;
    PORTC=0;
    TRISC=0;
    /*SPI SDI Pin Input*/
    TRISC4=1;
}
 
void spi_send(uint8_t data){
    SSPSTATbits.BF==1;
    SSPBUF=data;
    while(SSPSTATbits.BF==0);
    SSPSTATbits.BF==1;
}
 
uint8_t spi_receive(void){
    uint8_t data;
    spi_send(0x00);
    data=SSPBUF;
    return data;
}

Click here to download its source file.

SPI Waveform

I use a virtual digital oscilloscope to get its waveform.

PIC16F887 Serial Peripheral Interface Example

Overview

Serial Peripheral Interface (SPI) is a wired synchronous serial communication interface, commonly used in embedded electronics control system used for communication between controller and its peripheral devices. 

SPI Example with the SN74HC595N Shift Registers Chip

Typical applications include interfacing micro-controllers with peripheral chips for Secure Digital cards, liquid crystal displays, analog-to-digital and digital-to-analog converters, flash and EEPROM memory, and various communication chips.

SPI Master Multiple Slave Devices Diagram

One SPI master device able to connect to many slave devices. Additional slave device requires one chip select (CS) pin. Conventionally these SPI  defined as follow,

• SCK - Serial Clock
• MOSI - Master Out Slave In
• MISO - Master In Slave Out
• CS - Chip Select

These symbol commonly used for the AVR micro-controller from Microchip Technology. However the Microchip PIC micro-controllers use different symbols.

PIC16F887 Serial Peripheral Interface (SPI)

The PIC16F887 has a Master Synchronous Serial Port (MSSP) Module that contains the SPI and I2C module. The communication configuration depends on software setting in program.

The SPI pins locate at,

• RC3 - Serial Clock (SCK)
• RC4 - Serial Data In (SDI)
• RC5 - Serial Data Out (SDO)
• nSS - Slave Select (RA5)

The SPI operation could be configured as master or slave mode.

MSSP Block Diagram (SPI Mode)

 

To operate in master mode, the SCK, SDO and SS pin must configured as digital output pins. The SDI pin must be configured as digital input pin. The SPI operation relates to these SFR registers.

MSSP Registers

For more details about these registers you can read the datasheet of this device.

The SSPBUF is an 8-bit readable/writable register for data transmitting and receiving. The programmer must set the following configuration to operate the SPI master mode.

• Set serial clock polarity and data sample mode
• Set the SPI clock frequency
• Set the SPI I/O pins direction
• Enable the SPI module

In master mode we can select various SPI wave forms.

SPI Master Mode Wave Form

The commonly used wave form is a low to high clock transition. The slave select pin used for latching the data into the slave device. It could be a high to low transition, or vice versa depending on the target slave device specification. 

The SN74HC595N Shift Registers Interfacing Example

In this example, I use the SN74HC595N serial in parallel out shift registers to interface with the master SPI module of PIC1F887. The SN74HC595N operate as a SPI slave device receiving the data from the master.

SN74HC595N DIP-16

The clock transition is positive edge (low to high). The latch (slave select) pin is a high to low transition.

SPI Wave Form

We can serially connect these chips as much as possible. This chip is very popular in driving seven segment display or dot matrix display.

In this example, the PIC16F887 master SPI will send an 8-bit data to the SN74HC595N periodically. 

/*
 * File:   main.c
 * Author: Admin
 *
 * Created on February 6, 2024, 9:16 PM
 */
 
#include <xc.h>
#include "config.h"
 
#define _XTAL_FREQ  8000000UL
 
void spi_init(void){
    /*SPI Mode Clock Low To High*/
    SSPCONbits.CKP=0;
    SSPSTATbits.CKE=1;
    SSPSTATbits.SMP=0;
    /*SPI Master Mode Clock = Fosc/64*/
    SSPCONbits.SSPM=2;
    /*Turn On The Module*/
    SSPCONbits.SSPEN=1;
    SSPSTATbits.BF=1;
}
 
void main(void) {
    OSCCONbits.IRCF=7;
    spi_init();
    PORTC=0;
    TRISC=0;
    TRISC4=1;
    while(1){
        SSPBUF=0xF0;
        __delay_us(80);
        RC2=1;
        __delay_us(10);
        RC2=0;
        __delay_ms(1000);
 
        SSPBUF=0x0F;
         __delay_us(80);
        RC2=1;
        __delay_us(10);
        RC2=0;
        __delay_ms(1000);
 
        SSPBUF=0xAA;
         __delay_us(80);
        RC2=1;
        __delay_us(10);
        RC2=0;
        __delay_ms(1000);
    }
    return;
}
 

Click here to download this example.