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 PCF8574 I2C Example using XC8

Overview

The PCF8574 is an 8-bit input/output (I/O) expander for the two-wire bidirectional bus (I2C), designed for 2.5V to 6V VCC operation. 

The PCF8574 device provides general-purpose remote I/O expansion for most micro-controller
families by way of the I2C interface [serial clock (SCL), serial data (SDA)]. 

Simulating Program

The device features an 8-bit quasi-bidirectional I/O port (P0–P7), including latched outputs with high current drive capability for directly driving LEDs. Each quasi-bidirectional I/O can be used as an input or output without the use of a data-direction control signal. At power on, the I/Os are high. In this mode, only a current source to VCC is active.

This chip is suitable for,

• Telecom Shelters: Filter Units
• Servers
• Routers (Telecom Switching Equipment)
• Personal Computers
• Personal Electronics
• Industrial Automation
• Products with GPIO-Limited Processors

PCF8574 Interfacing Diagram

PCF8574AP DIP-16

We can event use this chip for a 4x4 matrix keypad, or driving an HD44780-base character LCD.

Pin Configuration and Functions

This device has various package types. A PDIP-16 or a SOIC-16 are common for most of electronics hobbyists.

Simplified Block Diagram of Device

This device has an 8-bit customizable slave address with R/W bit.

PCF8574 Interface Definition

We can custom its optional slave address via A2...A0 bits. Its default write address when A2...A0 are wired to GND is 0x40.

Address Reference

The Master I2C device need to write device slave address followed by output port data twice.
 

PCF8574 Write Mode

To read from this I2C slave device, the microprocessor need to write device read address (eg. 0x41), followed by I2C in read mode.

PCF8574 Read Mode

We can use various I/O devices with this chip.

PCF8574 Typical Application

 Interrupt Output (INT) pin is optional.

PIC16F887 MPLABX IDE and XC8 Programming

The PIC16F887 micro-controller has a high speed Inter Integrated Circuit (I2C) module that can operate in both master and slave mode.

In this example, I set up its I2C module to operate in master mode at 100kHz serial clock frequency. The program keeps reading input data from PCF8574 I/O port, its 8-bit content will show on PORTD of PIC16F887. 

/*
 * File:   main.c
 * Author: Admin
 *
 * Created on January 15, 2024, 8:17 PM
 */
 
 
#include <xc.h>
#include "config.h"
#include "i2c.h"
 
#define _XTAL_FREQ  8000000UL
#define PCF8574_W   0x40
#define PCF8574_R   0x41
 
void pcf8574Write(uint8_t data){
    i2c_start();
    i2c_write(PCF8574_W);
    i2c_write(0x20);
    i2c_write(data);
    i2c_stop();
}
 
uint8_t pcf8574Read(){
    uint8_t data;
    pcf8574Write(0xFF);
 
    i2c_start();
    i2c_write(PCF8574_R);
    data=i2c_read(0);
    i2c_stop();
    return data;
}
void main(void) {
    OSCCONbits.IRCF=7;
    i2c_init(100000);
    PORTD=0;
    TRISD=0;
    while(1){
        PORTD=pcf8574Read();
        __delay_ms(200);
    }
    return;
}
 

Since A2...A0 pins of PCF8574 are logic 0. So its device write address is 0x40, and 0x41 for device read address.

Click here to download its source file. See Also,

• ATMega32 TWI interfaces to PCF8574A parallel port expanding
• Reading The Digital Input Output From PCF8574 Using PIC12F629