A DIY TWI LCD Using PCF8574AP For Arduino

A character LCD with a 44780 LCD controller generally controlled by an MCU parallel port. Even the data transfer in-used is 4-bit mode, but it still require up to six MCU pins. 

A character LCD with PCF8574AP

PCF8574AP is an 8-bit general purpose digital I/O expanding. We can read and write digital data between this device and a master MCU, or even controlling a parallel LCD module. However using an I2C IC bridge the master MCU uses only two pins of its digital I/O to interface to the LCD.

In online market the PCF8574AP is built in module the a character LCD that cost a few Dollars. For an electronics hobbyist like me, I only bought a single DIP version of this chip. I can program it to read/write digital data before I decide to put it with a character LCD.

I decided to make my own I2C board module for my Arduino Uno board. This design follows the liquidCrystal_I2C LCD library from an author on GitHub. The overall design is not difference from the original one's but I made my own schematic and PCB design for my personal use.

I use Eagle CAD from Auto Desk software due to its richness of symbols and footprints library. The result yield with a small rectangular PCB module wired with PCF8574AP and a character LCD.

Schematic Diagram

PCB View

This design example is fully worked as I have tested it with Arduino Uno using its library.

A zip file of this design could be download here.

Connection Diagram

 

This Arduino sketch is from the library itself with some of my own modification.

#include <Wire.h>
#include <LiquidCrystal_I2C.h>

// set the LCD address to 0x38 for PCF8574A with A0 A1 A2 wired to GND
LiquidCrystal_I2C lcd(0x38,16,2); 
void setup()
{
  // initialize the lcd
  lcd.init();                     
  lcd.backlight();
  lcd.clear();
  Serial.begin(9600);
  lcd.setCursor(0,0);
  lcd.print("Serial Port LCD");
}

void loop()
{
  // when characters arrive over the serial port...
  if (Serial.available()) {
    // wait a bit for the entire message to arrive
    delay(100);
    // clear the screen
    lcd.clear();
    // read all the available characters
    while (Serial.available() > 0) {
      // display each character to the LCD
      lcd.write(Serial.read());
    }
  }
}

This sketch could be download here, or you can get from the library after the installation.

Interfacing PIC18F4550 to 74HC595 CCS PICC

A shift register chip is very useful for expanding the digital I/O. Getting more digital outputs, the 74HC595 is very popular due to its ease of use. It is called a serial in parallel out shift register IC. The 74XX prefix belong to the clue logic family of the digital IC.

74HC595 chips in DIP package

The communication interface between the MCU and this controller is quite simple. It basically use three pins as in the form of the Serial Peripheral Interface (SPI) which are,

• Serial Data
• Serial Clock
• Enable

This IC has an 8 bit output with an optional serial data out for a daisy-chain connection.

Pin diagram of this device

An SPI communication that used by the MCU to send the data to this chip could be an SPI peripheral inside the MCU, or a software bit-banging written by the programmer. The SPI peripheral usually has a fixed pins but using the software bit-banging the output pins are select-able by the programmer.

With the software bit-banging, the program need to spend more more time executing this SPI-like communication. In this case it doesn't provide a high speed SPI.

CCS PICC has a built-in driver allowing the PIC microcontroller to send a serial data to this chip. We need to set up some basic steps as shown below:

1. Select a serial data pin
2. Select a serial clock pin
3. Select a enable pin
4. Set the numbers of register
5. Send some bytes of data with a preset numbers of register

The 74595.c is ready to use in the CCS PICC compiler after the installation. The write_expanded_outputs(eo) function writes some bytes to this chip. The number of bytes is a preset number of register.

In this example, PIC18F4550 connects to a two-digit display driven by two distinct shift registers. The MCU counts the number of input up to 99 before it reset to 0.

Schematic Diagram

Source of this program is written using CCS PICC.

#include<18f4550.h>

/*Use high speed clock no PLL prescaler 

no system clock post scaler */

#fuses HS,PLL1,CPUDIV1,NOWDT

#use delay(clock=20M)

#define EXP_OUT_ENABLE  PIN_D0

#define EXP_OUT_CLOCK   PIN_D1

#define EXP_OUT_DO      PIN_D2

#define NUMBER_OF_74595 2

#include<74595.c>

 

 

void main(void){

unsigned char patterns[16]={0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,

 0x07,0x7F,0x6F,0x77,0x7C,0x39,0x5E,0x79,0x71};

   unsigned char cnt=0;

   unsigned char digits[2];

   //Clear PORTD

   output_D(0x00);

   //Set PORTD To Output

   set_tris_D(0x00);

   

      

   while(1){

      digits[0]=patterns[cnt/10];

      digits[1]=patterns[cnt%10];

      write_expanded_outputs(&digits);

      delay_ms(1000);

      cnt++;

      if(cnt>=100) cnt=0;

   }

}

Atmega32 Timer/Counter1 in Timer Mode

A Short Detail of Timer/Counter1

Timer/Counter1 module of Atmega32 is superior to Timer/Counter0. It has some advanced features over the previous one's:

• 16-bit wide made of two 8-bit registers
• Input capture mode
• Improved PWM mode
• Four interrupt source

It has two Timer/Counter registers working as a pair of two 8-bit low and high register - TCNT1H and TCNT1L. As a result the Timer/Counter registers is 16-bit in total.

Timer/Counter1 Register -TCNT1H and TCNT1L

There are more additional Timer/Counter control registers and interrupt flag. But we only list some in-use registers in this post.

Timer/Counter1 Control Register B (TCCR1B) contain functions setting of this module working in timer mode.

Timer/Counter1 Control Register B

Clock Select bit (CS12:10) of this register set the clock source of Timer/Counter1.

Timer/Counter1 Clock Select bit

Interrupt occurs at the maximum counting of this 16-bit Timer/Counter at 65536. Then the Timer/Counter1 overflow interrupt flag (TOV1) is set.

Timer/Counter Interrupt Flag Register - TIFR

Programming Timer/Counter1 in Timer Mode

In this Timer/Counter1 timer mode example, the program configure this module to make a timer tick of 262ms. This timer tick is a result of its interrupt at overflow. At the interrupt time PC2 of Port C toggles.

Schematic diagram of this example post

We have a calculation below.

Microcontroller instruction cycle with its 16MHz clock frequency is,

1/16000000 = 62.5ns

With a clock selection of Clk/64 we get,

64*62.5ns = 4us.

Sixteen bit Timer/Counter1 register counts up to 65536 value to generate the interrupt flag. The duration before the TOV1 is set is,

65536*4us = 262ms.

For every 262ms PC2 toggles an output LED.

/*
 * timer_1_example.c
 *
 * Created: 12/19/2020 8:57:35 PM
 * Author : aki-technical
 */ 
#include <avr/io.h>
int main(void)
{
    /*Select Timer Mode, CLK/64*/
TCCR1B=(1<<CS11)|(1<<CS10);
/*PC2 Output*/
DDRC=(1<<2);
/*Clear Timer Overflow Flag 1*/
TIFR=(1<<TOV1);
    while (1) 
    {
/*Check for overflow*/
if (TIFR&(1<<TOV1))
{
/*Clear this flag*/
TIFR=(1<<TOV1);
/*Toggle PB2*/
PORTC^=0x04;
}
    }
}

Let see the simulation result in software. 

Simulation result in Proteus

Click here to download this example file.