PIC16F887 PCF8574AP I2C LCD Example using XC8

The PCF8574 could be used for a HD44780 based character LCD controlling using the 4-bit data transfer mode. The popular one's is an Arduino TWI LCD driving using this chip.

A long hours running program

This chip has only 8 bits inputs/outputs. So it can interface with an 8-bit character LCD using the 4-bit data transfer mode. Using this method the micro-processor need to send the 8-bit command or data two time, first the higher nibble and then the lower nibble. For more information about using the PCF8574 please see this post.  If you are a beginner in micro-controller programming you can see this post about 4-bit LCD interfacing.

Program Testing on Prototype Board

 I use use my own DIY PCF8574AP character LCD module. Its schematic is shown below.

PCF8574AP Character LCD Module Schematic

Its slave address are 0x70 and 0x71.

DIY PCF8574AP Character LCD Module

DIY PCF8574AP Character LCD Module

You can use an Arduino PCF8574 LCD module with different address.

Arduino PCF8574 LCD module

Arduino PCF8574 LCD module

In this example, The micro-controller send a counter variable to the display. It updates for every 250ms. I use the I2C module of PIC16F887. The program written in C using MPLABX IDE and its XC8 C compiler. It's free to use.

/*
 * File:   main.c
 * Author: Admin
 *
 * Created on January 19, 2024, 3:36 PM
 */
 
#include <xc.h>
#include "config.h"
#include "pcf8574.h"
#include <stdio.h>
 
#define _XTAL_FREQ  8000000UL
 
#define RS  0
#define RW  1
#define EN  2
#define BL  3
 
__bit backLight=0;
 
void i2c_lcdCommand(uint8_t command){
    uint8_t data;
    data=command&0xF0;
    pcf8574Write(data|(backLight<<BL)|(1<<EN));
    __delay_us(10);
    pcf8574Write(data|(backLight<<BL));
    __delay_us(50);
 
    data=command<<4;
    pcf8574Write(data|(backLight<<BL)|(1<<EN));
    __delay_us(10);
    pcf8574Write(data|(backLight<<BL));
    __delay_us(50);
}
 
void i2c_lcdData(uint8_t command){
    uint8_t data;
    data=command&0xF0;
    pcf8574Write(data|(backLight<<BL)|(1<<EN)|(1<<RS));
    __delay_us(10);
    pcf8574Write(data|(backLight<<BL)|(1<<RS));
    __delay_us(50);
 
    data=command<<4;
    pcf8574Write(data|(backLight<<BL)|(1<<EN)|(1<<RS));
    __delay_us(10);
    pcf8574Write(data|(backLight<<BL)|(1<<RS));
    __delay_us(50);
}
 
void i2c_lcdXY(int8_t x, int8_t y){
    int8_t addr[]={0x80,0xC0};
    i2c_lcdCommand(addr[y-1]+x-1);
}
 
void i2c_lcdText(int8_t *txt){
    while(*txt) i2c_lcdData(*txt++);
}
 
void i2c_lcdClear(void){
    i2c_lcdCommand(0x01);
    __delay_ms(5);
}
 
void i2c_lcdInit(void){
    i2c_init(100000);
    __delay_us(10);
    pcf8574Write(0);
    __delay_ms(10);
    i2c_lcdCommand(0x33);
    __delay_us(10);
    i2c_lcdCommand(0x32);
    __delay_us(10);
    i2c_lcdCommand(0x28);
    __delay_us(10);
    i2c_lcdCommand(0x0F);
    __delay_us(10);
    i2c_lcdCommand(0x01);
    __delay_ms(5);
    i2c_lcdCommand(0x06);
    __delay_us(10);
}
 
void main(void) {
    OSCCONbits.IRCF=7;
    i2c_lcdInit();
    backLight=1;
    __delay_ms(1000);
    i2c_lcdText(" PIC16F887 I2C");
    i2c_lcdXY(1,2);
    i2c_lcdText(" PCF8574AP LCD");
    long counter=0;
    uint8_t msg[10];
    __delay_ms(2000);
    i2c_lcdClear();
    i2c_lcdCommand(0x0C);
    i2c_lcdText("Counter Variable");
    while(1){
        sprintf(msg,"%u",counter);
        i2c_lcdXY(1,2);
        i2c_lcdText(msg);
        counter++;
        __delay_ms(250);
    }
    return;
}
 

I use Proteus VSM to design and simulating this program before it will be tested on a prototype board.

Simulating Program in Proteus

Simulating Program in Proteus

Click here to download this example from GitHub.

PIC16F887 PCF8574AP I2C 4x4 KeyPad using XC8

The PCF8574 series is popular among Arduino users especially the character LCD driving. Its output port is 8-bit bi-directional. So we can use this chip to make a 4x4 matrix keypad. The microprocessor uses only two pins (SDA and SCL) via its I2C communication module to interface with this serial matrix keypad.

Hardware Experiment on PIC16F887 Prototype Board

I use a 4x4 membrane keypad module for Arduino. It's low cost that we doesn't need to make our own PCB.

16 Key Membrane Switch Keypad 4X4 3X4 Matrix Keyboard For Arduino Diy Kit

 

The I2C slave address of PCF8574AP (DIP-16) is 0x70 (write) and 0x71 (read) when A2...A0 are wired to GND.

PCF8574AP 16-Pin DIP

I use the on-board TinSharp TC1604A-01 16x4 character LCD module I posses.

I use the 4-bit data transfer mode to save the I/O pins of micro-controller.

Using the MPLABX IDE and its XC8 C compiler is pretty easy. Generated firmware is light-weight comparable the Assembly language. This program keep scanning the key press. Key value will show on the character LCD. The display is auto make a new line when ever the character counts reach 16. The the display is full it will clear the display and return home.

/*
 * File:   main.c
 * Author: Admin
 *
 * Created on January 17, 2024, 9:07 PM
 */
 
#include <xc.h>
#include "config.h"
#include "lcd.h"
#include "pcf8574.h"
 
#define _XTAL_FREQ  8000000UL
 
uint8_t key_16[][4]={'1','2','3','A',
                     '4','5','6','B',
                     '7','8','9','C',
                     '*','0','#','D'};
 
uint8_t keyScan(void){
    char data=0,temp,key;
    for(uint8_t i=0;i<4;i++){
        data=0xFF;
        data&=~(1<<i);
        pcf8574Write(data);
        __delay_ms(5);
        data=pcf8574Read();
        data&=0xF0;
        if((data&0x10)==0)     {temp=key_16[i][0]; break;}
        else if((data&0x20)==0){temp=key_16[i][1]; break;}
        else if((data&0x40)==0){temp=key_16[i][2]; break;}
        else if((data&0x80)==0){temp=key_16[i][3]; break;}
        else temp=0;
        __delay_ms(10);
    }
    return temp;
}
 
void main(void) {
    OSCCONbits.IRCF=7;
    i2c_init(100000);
    lcdInit();
    __delay_ms(100);
    uint8_t temp,charCount=0,newLine=0,line=1;
    while(1){
        temp=keyScan();
        if(temp!=0){
            lcdData(temp);  
            charCount++;
            __delay_ms(250);
        }
        if(charCount>=16){
            newLine=1;
            charCount=0;
            line+=1;
        }
        if(newLine){
            newLine=0;
            if(line==2) lcdXY(1,2);
            else if(line==3) lcdXY(1,3);
            else if(line==4) lcdXY(1,4);
            else{
                lcdCommand(0x01);
                __delay_ms(5);
                line=1;
            }
        }
    }
    return;
}
 

Click here to download this example from GitHub. I use Proteus to draw its schematic.

Program Simulation

Proteus simulation will work at slow speed due to custom firmware simulation. Using the prototype board, the firmware operation works very well without error and slowness. 

This DIY PCB has a 20MHz crystal oscillator. But the PIC16F887 has an internal 8MHz RC oscillator. So I left the XTAL1 and XTAL2 pin unconnected.

Keypad scanning runs very flexible without error on this PIC DIY prototype board.

 

If you use the PCF8574 you need to change its I2C slave address.

PIC16F887 KeyPad and Character LCD Example using XC8

A keypad scanning program is common for most of micro-controller programming students. It usually done by the Assembly language programming in a micro-processor class in university. However using C compiler to program the keypad scanning process is very easy, and it's almost readable for most C programmers.

Simulating Program

Using a single 8-bit I/O port can make a 4x4 (16 keys) matrix keypad. It's divided into two nibbles, one nibble for output and another nibble for input data.

Arduino 4x4 Matrix Keypad Module

 

In this example, I use a PIC16F887 micro-controller to scan a 4x4 matrix keypad. Input key will show on a 16x2 character LCD. 

/*
 * File:   main.c
 * Author: Admin
 *
 * Created on January 16, 2024, 7:46 PM
 */
 
#include <xc.h>
#include "config.h"
#include "LCD4Bits.h"
 
#define _XTAL_FREQ  8000000UL
 
uint8_t key_16[][4]={'7','8','9','F',
                     '4','5','6','E',
                     '1','2','3','D',
                     'A','0','B','C'};
 
uint8_t scanKey(void){ 
    char data=0,temp;
    for(uint8_t i=0;i<4;i++){
        PORTB=1<<i;
        data=PORTB&0xF0;
        if(data&(1<<4))     {temp=key_16[i][0]; break;}
        else if(data&(1<<5)){temp=key_16[i][1]; break;}
        else if(data&(1<<6)){temp=key_16[i][2]; break;}
        else if(data&(1<<7)){temp=key_16[i][3]; break;}
        else temp=0;
        __delay_ms(10);
    }
    return temp;
}
 
void main(void) {
    OSCCONbits.IRCF=7;
    uint8_t temp,count=0,row=0;
    PORTB=0;
    TRISB=0xF0;
    ANSELH=0;
    lcdInit();
 
    while(1){
        temp=scanKey();
        if(temp!=0){          
            lcdData(temp);
             count++;
            __delay_ms(250);
        }                  
        if(count>16){count=0; lcdCommand(0xC0); row+=1;}
        if(row>=2) {
            count=0; 
            lcdXY(1,1); 
            lcdCommand(0x01); 
            __delay_ms(10);
            row=0;
        }
    }
    return;
}
 

After a 16 key-press count, a new line will start. After two lines, the display will clear, and it will return home.

Click here to download this example from GitHub. See also,

• ATMega32 interfaces to keypad and display
• ATMega32 LCD and Keypad Interfacing Example