The Motivation
The Deliverable
Credits
Limitations
Character Cell Addressing
How It Works
Too Much Information
Configuration
SNAFU's along the way
Next Steps.

Published September 7, 2022 © LGPL

HD44780 LCD Driver: 20x4 and 16x2 - parallel (8 or 4 bit)

A clean implementation should have been trivial with the existing information on the web, but it wasn't. Feel free to cut-and-paste..

IntermediateFull instructions provided2 hours2,560

HD44780 LCD Driver: 20x4 and 16x2 - parallel (8 or 4 bit)

Things used in this project

Hardware components

Arduino UNO

HD44780 LCD (20x4)

Single Turn Potentiometer- 10k ohms

Software apps and online services

Arduino IDE

Story

The Motivation

These LCDs are so common and have been around for so long that simple reliable drivers for them should be a solved problem. It isn't.

For example, inserting delays into your driver to wait for the LCD to finish an instruction is just hinky when the device comes with a perfectly reliable interface to ask it if it is still busy or not.

My end goal is a stable, clean and simple driver in Z80 assembler but it is just so much easier to prototype the LCD communication in the comfort of Arduino-land.

The Deliverable

I've arrived at a point where I have a super stable implementation in Arduino-land. The code is deliberately verbose with the intent that it should be obvious to see what it does and cut-and-paste it into your own solution. Even so, the whole things is still only ~350 lines long.

Credits

A while back I built Ben Eater's 6502 breadboard computer and he has a great video series where he works incrementally through building a driver for these LCDs in 6502 assembler. This is where I first saw the folly of peppering the code with delays rather than just reading the LCDs busy flag.

When searching for some C source in Arduino-land that was reasonably small and consumable, I strayed into Hans-Christoph Steiner's driver from back in 2010. What my code ended up being is a variation on this but without all the "delayMicroseconds(..)" calls which I replaced by reading the LCD busy flag.

Limitations

There is no avoiding inserting delays in the initialization process for either 8 or 4 bit mode. The flow charts in figures 23 and 24 of the Hitachi data sheet are explicit about this (their initialization sequence, in a nutshell, is: "beat it with a rock")
Initialization for cold boot (initial power up) for both 8 and 4 bit mode are super stable. A warm boot when in 4 bit mode is a bit dodgy. I have yet to get this 100% stable (open to ideas..)

Character Cell Addressing

These devices date back to long before the big flood in the Old Testament. At that point they had the foresight to offer a 1 line and a 2 line mode in the interface. More than 2 lines was obviously not a thing they had in mind.

This has resulted in quite peculiar internal addressing for the consecutive lines in the more "recent" models (like the 20x4 LCD).

Another issue I have with most existing implementations is the idea of clearing the screen and then just writing characters and letting them flow. Because of the peculiar line addresses, text will not simply flow from line to line in the 4 line LCDs. Also, when you run off the end of the last line of the LCD (any model), it has this nifty "feature" of wrapping back around to the start.

I far prefer absolute addressing:

no scrolling
no assumptions about where I want to go on wrap or overflow

Make it the developer's problem to ask how many rows there are, how many columns there are, and then write characters to specific coordinates. Yes, I still have a simple API to write a single character to the next position but:

it works correctly when it comes to the end of one line and the start of the next
if you write off the end of the LCD, no wrap: your characters just go in the bin

I used another "read" function of the LCD's to ask it what the current position was after each character write and this allowed me to reverse engineer the start position of each row in the 20x4. I left that code around so it can be used to figure out positions on some future model again if needed.

20x4 in all its glory

My public API is:

LCDInitialize(); // // coordinates are 0-basedLCDSetCursorPosition(byte col, byte row); // // write a character in the current pos, then increment posLCDCharacter(char c); // // same as calling both of previous 2 but in 1 stepLCDCharacter(char c, byte col, byte row);

I should probably add a clear screen API. Easy to cut and paste it from LCDInitialize: simply the last 2 lines on that function.

How It Works

I won't discuss the wiring for the contrast potentiometer (V0) or the backlight (A and K). There's not much mystery in those. I'll discuss the part that took me a while to trawl through and figure out:

The device interface consists of 2 "registers":

instruction register
data register

The sole function of the RS pin is to select between the instruction register or the data register: low for instruction register, high for data register.

Instruction register is mostly written in my driver. Data register can be read and written. We write data to display a character or set the address (cursor position). We read data to get the busy flag or the current address (cursor position). The RW pin is used to distinguish between these reads (high) and these writes (low). So, stating the obvious, for instructions the RW pin is mostly low (with the exception of reading the Busy flag).

That leaves the EN (Enable) pin: this is essentially the clock signal for communicating with the LCD. Normally you have this line low and then to send a clock pulse you cycle it from low to high and then back to low again.

Sending a "clock" pulse on the EN pin for a write

What this does is tells the LCD: "I'm done setting up what I want on pins D0..D7, please go ahead and execute". Writing is the easy version. Reading is a little less obvious:

Sending a "clock" pulse on the EN pin for a read

In this case it is the device's responsibility to set the values on pins D0..D7 and it does this during the clock pulse. I've found that you need to read these lines while the EN line is still high. Once it goes low, they are no longer stable.

I've illustrated using the 8 bit operations : they are simpler. But the 4 bit operations are just the same thing twice in each case.

Too Much Information

There are 9 instruction register instructions. My descriptions are abbreviated. I've attached the Hitachi datasheet for more detail.

Clear Display: clears display and sets address 0 in address counter.
Return Home: sets address 0 in address counter.
Entry Mode: sets left-to-right or right-to left incrementing of the address
Display On/Off: you guessed it, also hide/show cursor, cursor blink on/off
Cursor/Display Shift: essentially scrolling : not useful to me
Function Set: initialization of 4/8 bit interface, # of lines, font size
CGRAM Address: set Character Generator address (for making own fonts)
DDRAM Address: can be used to set current address ("Display Data")
Read Busy Flag and Address: check the busy flag and get last address

There are 2 data register instructions (overuse of the word "instruction"?!)

Write Data to CGRAM or DDRAM: uses address set above, increments after write
Read Data to CGRAM or DDRAM: uses address set above, increments after read

My driver only makes use of:

Function Set - initialization
Display On/Off - initialization
Cursor/Display Shift - initialization (just to turn it off)
Clear Display - initialization (should be its own API)
Read Busy Flagand Address - to wait for LCD to finish current operation
DDRAM Address - to set cursor position

Write Data to CGRAM or DDRAM - to write a character

Configuration

There's a fundamental difference between the 8 and the 4 bit interface. The 4 bit interface has merit if you are low on GPIO pins. To switch between these two I have a preprocessor define at the top of the code (LCD_8_BITS). Comment it out for the 4 bit version.

Note: the 4 bit interface uses pins D4..D7, not D0..D3 on the device.

I have some global variables that need to be manually configured in LCDInitialize() but at least that's only one place in the code. I have the settings for my 16x2 and my 20x4. Share any others with me as added and I'll update the code and this image.

Custom Configuration per Device

Configured for 16x2

Reasonable output for 20x4 misconfigured as 16x2

SNAFU's along the way

I chose the Uno because it is so common and because it doesn't have the limited number of GPIO pins as my usual favourite (the Lolin D1 Mini from Wemos).

I don't use the Uno much but Port D's pins are in a nice little 0..7 set that works so cleanly with an 8 bit ribbon cable to connect the data lines directly across to the LCD.

TX / RX had to go somewhere ..

The meaning of the TX and RX were lost on me until I started attempting to upload code while the LCD was on. These two pins are shared by the serial connection which makes them useless for anything else in a development scenario.

I was already on a roll though so I just shifted across 2 pins. This may explain my peculiar pin choices and verbose code (digitalRead / digitalWrite rather than direct port access using PORTB and PINB).

Next Steps..

Moving on to the Z80 version..

Code

HD4478U LCD Parallel Driver (4 or 8 bit)

//#define SERIAL_DIAGNOSTICS
#define LCD_8_BITS

#define REGISTER_SELECT_PIN 10      // device pin 4  0-Command, 1-Data
#define READ_WRITE_PIN 11           // device pin 5  0-Write, 1-Read
#define ENABLE_PIN 12               // device pin 6

#ifdef LCD_8_BITS
#define DATA_0 2
#define DATA_1 3
#define DATA_2 4
#define DATA_3 5
#endif
#define DATA_4 6
#define DATA_5 7
#define DATA_6 8
#define DATA_7 9

byte lcdColumns;
byte lcdRows;
byte currentCol;
byte currentRow;
byte lcdRowStart[4]; // see LCDInstruction(byte data)

// I referenced this for ideas:
// https://github.com/arduino-libraries/LiquidCrystal
// but got rid of all the delays's (except Hitachi's startup madness) 
// and read the LCD "Busy" flag instead

void LCDDataAsOutput()
{
#ifdef LCD_8_BITS
  pinMode(DATA_0, OUTPUT);
  pinMode(DATA_1, OUTPUT);
  pinMode(DATA_2, OUTPUT);
  pinMode(DATA_3, OUTPUT);
#endif
  pinMode(DATA_4, OUTPUT);
  pinMode(DATA_5, OUTPUT);
  pinMode(DATA_6, OUTPUT);
  pinMode(DATA_7, OUTPUT);
}
void LCDDataAsInput()
{
#ifdef LCD_8_BITS
  pinMode(DATA_0, INPUT);
  pinMode(DATA_1, INPUT);
  pinMode(DATA_2, INPUT);
  pinMode(DATA_3, INPUT);
#endif
  pinMode(DATA_4, INPUT);
  pinMode(DATA_5, INPUT);
  pinMode(DATA_6, INPUT);
  pinMode(DATA_7, INPUT);
}

#ifdef LCD_8_BITS 
void LCDWriteData8(byte data)
{
  digitalWrite(DATA_0, ((data & 0b00000001) != 0) ? HIGH : LOW);
  digitalWrite(DATA_1, ((data & 0b00000010) != 0) ? HIGH : LOW);
  digitalWrite(DATA_2, ((data & 0b00000100) != 0) ? HIGH : LOW);
  digitalWrite(DATA_3, ((data & 0b00001000) != 0) ? HIGH : LOW);
  digitalWrite(DATA_4, ((data & 0b00010000) != 0) ? HIGH : LOW);
  digitalWrite(DATA_5, ((data & 0b00100000) != 0) ? HIGH : LOW);
  digitalWrite(DATA_6, ((data & 0b01000000) != 0) ? HIGH : LOW);
  digitalWrite(DATA_7, ((data & 0b10000000) != 0) ? HIGH : LOW);
}
#else
void LCDWriteData4(byte data)
{
  digitalWrite(DATA_4, ((data & 0b00000001) != 0) ? HIGH : LOW);
  digitalWrite(DATA_5, ((data & 0b00000010) != 0) ? HIGH : LOW);
  digitalWrite(DATA_6, ((data & 0b00000100) != 0) ? HIGH : LOW);
  digitalWrite(DATA_7, ((data & 0b00001000) != 0) ? HIGH : LOW);
}
#endif
void LCDWriteData(byte data)
{
#ifdef LCD_8_BITS  
  LCDWriteData8(data);
  // pulse ENABLE_PIN
  digitalWrite(ENABLE_PIN, LOW);
  digitalWrite(ENABLE_PIN, HIGH);
  digitalWrite(ENABLE_PIN, LOW);
#else
  LCDWriteData4(data >> 4);
  // pulse ENABLE_PIN
  digitalWrite(ENABLE_PIN, LOW);
  digitalWrite(ENABLE_PIN, HIGH);
  digitalWrite(ENABLE_PIN, LOW);
  LCDWriteData4(data &0x0F);
  // pulse ENABLE_PIN
  digitalWrite(ENABLE_PIN, LOW);
  digitalWrite(ENABLE_PIN, HIGH);
  digitalWrite(ENABLE_PIN, LOW);
#endif  
}
#ifdef LCD_8_BITS  
byte LCDReadData8()
{
  byte data = 0;
  data |= ((digitalRead(DATA_0) == HIGH) ? 0b00000001 : 0b00000000);
  data |= ((digitalRead(DATA_1) == HIGH) ? 0b00000010 : 0b00000000);
  data |= ((digitalRead(DATA_2) == HIGH) ? 0b00000100 : 0b00000000);
  data |= ((digitalRead(DATA_3) == HIGH) ? 0b00001000 : 0b00000000);
  data |= ((digitalRead(DATA_4) == HIGH) ? 0b00010000 : 0b00000000);
  data |= ((digitalRead(DATA_5) == HIGH) ? 0b00100000 : 0b00000000);
  data |= ((digitalRead(DATA_6) == HIGH) ? 0b01000000 : 0b00000000);
  data |= ((digitalRead(DATA_7) == HIGH) ? 0b10000000 : 0b00000000);
  return data;
}
#else
byte LCDReadData4()
{
  byte data = 0;
  data |= ((digitalRead(DATA_4) == HIGH) ? 0b00000001 : 0b00000000);
  data |= ((digitalRead(DATA_5) == HIGH) ? 0b00000010 : 0b00000000);
  data |= ((digitalRead(DATA_6) == HIGH) ? 0b00000100 : 0b00000000);
  data |= ((digitalRead(DATA_7) == HIGH) ? 0b00001000 : 0b00000000);
  return data;
}
#endif
byte LCDReadData()
{
  byte data = 0;

#ifdef LCD_8_BITS  
  // pulse ENABLE_PIN
  digitalWrite(ENABLE_PIN, LOW);
  digitalWrite(ENABLE_PIN, HIGH);
  data = LCDReadData8();
  digitalWrite(ENABLE_PIN, LOW);
#else
  // pulse ENABLE_PIN
  digitalWrite(ENABLE_PIN, LOW);
  digitalWrite(ENABLE_PIN, HIGH);
  data = LCDReadData4() << 4;
  digitalWrite(ENABLE_PIN, LOW);
  // pulse ENABLE_PIN
  digitalWrite(ENABLE_PIN, LOW);
  digitalWrite(ENABLE_PIN, HIGH);
  data = data | LCDReadData4();
  digitalWrite(ENABLE_PIN, LOW);
#endif
  return data;
}

void LCDWait()
{
  LCDDataAsInput();
  digitalWrite(REGISTER_SELECT_PIN, LOW);
  digitalWrite(READ_WRITE_PIN, HIGH);
  for (;;)
  {
    byte data = LCDReadData();
#ifdef SERIAL_DIAGNOSTICS    
    char buffer[20];
    sprintf(buffer, "Busy 0x%02X", data);
    Serial.println(buffer);
#endif
    if ((data & 0x80) == 0) // busy?
    {
      break;
    }
  }
  LCDDataAsOutput();
}
byte LCDGetCurrentAddress()
{
  LCDWait();
  LCDDataAsInput();
  digitalWrite(REGISTER_SELECT_PIN, LOW);
  digitalWrite(READ_WRITE_PIN, HIGH);
  byte data = LCDReadData();
  LCDDataAsOutput();
  return data;
}
void LCDInstruction(byte data)
{
  LCDWait();
  digitalWrite(REGISTER_SELECT_PIN, LOW);
  digitalWrite(READ_WRITE_PIN, LOW);
  LCDWriteData(data);
}
void LCDSetCursorPosition(byte col, byte row)
{
  byte address = lcdRowStart[row] + col;
#ifdef SERIAL_DIAGNOSTICS  
  char buffer[40];
  sprintf(buffer, "SetCursorPosition: %d,%d 0x%02X", col, row, address);
  Serial.println(buffer);
#endif
  if (currentRow < lcdRows) // don't wrap around if (col,row) out of range (less confusion)
  {
    byte instruction = 0b10000000 | address;
    LCDInstruction(instruction); // Set DDRAM address
  }
  currentCol = col;
  currentRow = row;
}
void LCDCharacter(byte c)
{
  LCDSetCursorPosition(currentCol, currentRow);
  if (currentRow < lcdRows) // don't wrap around if (col,row) out of range (less confusion)
  {
    LCDWait();
    digitalWrite(REGISTER_SELECT_PIN, HIGH);
    digitalWrite(READ_WRITE_PIN, LOW);
    LCDWriteData(c);
  }
  currentCol++;
  if (currentCol == lcdColumns)
  {
    currentCol = 0;
    currentRow++;
  }
}

void LCDCharacterAt(byte c, byte col, byte row)
{
  currentCol = col;
  currentRow = row;
  LCDCharacter(c);
}
#ifdef LCD_8_BITS 
void LCDInitialize8Bit(byte functionSet)
{
  // as per Figure 23 (page 45) of the Hitachi data sheet - yes, much like beating it with a rock!

  delay(50); // > 40ms for Vcc to rise above 2.7V

  LCDWriteData8(functionSet);
  // pulse ENABLE_PIN
  digitalWrite(ENABLE_PIN, LOW);
  digitalWrite(ENABLE_PIN, HIGH);
  digitalWrite(ENABLE_PIN, LOW);
  delayMicroseconds(4500);

  LCDWriteData8(functionSet);
  // pulse ENABLE_PIN
  digitalWrite(ENABLE_PIN, LOW);
  digitalWrite(ENABLE_PIN, HIGH);
  digitalWrite(ENABLE_PIN, LOW);
  delayMicroseconds(150);

  LCDWriteData8(functionSet);
  // pulse ENABLE_PIN
  digitalWrite(ENABLE_PIN, LOW);
  digitalWrite(ENABLE_PIN, HIGH);
  digitalWrite(ENABLE_PIN, LOW);

  LCDInstruction(functionSet);
}
#else
void LCDInitialize4Bit(byte functionSet)
{
  // as per Figure 24 (page 46) of the Hitachi data sheet - yes, much like beating it with a rock!

  delay(50); // > 40ms for Vcc to rise above 2.7V

  LCDWriteData4(0b0010);
  // pulse ENABLE_PIN
  digitalWrite(ENABLE_PIN, LOW);
  digitalWrite(ENABLE_PIN, HIGH);
  digitalWrite(ENABLE_PIN, LOW);
  delayMicroseconds(4500);

  LCDWriteData4(0b0010);
  // pulse ENABLE_PIN
  digitalWrite(ENABLE_PIN, LOW);
  digitalWrite(ENABLE_PIN, HIGH);
  digitalWrite(ENABLE_PIN, LOW);
  delayMicroseconds(150);

  LCDWriteData4(0b0010);
  // pulse ENABLE_PIN
  digitalWrite(ENABLE_PIN, LOW);
  digitalWrite(ENABLE_PIN, HIGH);
  digitalWrite(ENABLE_PIN, LOW);

  // This 4 bit initialization works well for cold reset (no power to the LCD) but not for resetting
  // an already initialized and powered up LCD (without power cycling).
  // More luck with warm reset with even number of 4 bit writes (in case LCD is already in 4 bit mode)
  LCDWriteData4(0b0010);
  // pulse ENABLE_PIN
  digitalWrite(ENABLE_PIN, LOW);
  digitalWrite(ENABLE_PIN, HIGH);
  digitalWrite(ENABLE_PIN, LOW);

  LCDInstruction(functionSet);
}
#endif
void LCDInitialize()
{
  // 20x4
  lcdRowStart[0] = 0x00;
  lcdRowStart[1] = 0x40;
  lcdRowStart[2] = 0x14;
  lcdRowStart[3] = 0x54;
  lcdColumns = 20;
  lcdRows = 4;

  // 16x2
  //lcdRowStart[0] = 0x00;
  //lcdRowStart[1] = 0x40;
  //lcdColumns = 16;
  //lcdRows = 2;

  currentCol = 0;
  currentRow = 0;
  
  pinMode(REGISTER_SELECT_PIN, OUTPUT);
  pinMode(READ_WRITE_PIN, OUTPUT);
  pinMode(ENABLE_PIN, OUTPUT);
  LCDDataAsOutput();
  digitalWrite(REGISTER_SELECT_PIN, LOW);
  digitalWrite(READ_WRITE_PIN, LOW);
  digitalWrite(ENABLE_PIN, LOW);

#ifdef LCD_8_BITS 
  LCDInitialize8Bit(0b00111000); // Set 8-bit mode; 2-line display; 5x8 font
#else
  LCDInitialize4Bit(0b00101000); // Set 4-bit mode; 2-line display; 5x8 font
#endif
  LCDInstruction(0b00001110); // Display on; cursor on; blink off
  LCDInstruction(0b00000110); // Increment and shift cursor; don't shift display
  LCDInstruction(0b00000001); // Clear screen
  LCDSetCursorPosition(0,0);
}

void setup() 
{
#ifdef SERIAL_DIAGNOSTICS    
  Serial.begin(115200);
#endif  
  // initialize digital pin LED_BUILTIN as an output.
  pinMode(LED_BUILTIN, OUTPUT);

  LCDInitialize();
  
  // 80 characters:
  const char * str = "I <3 my Witch! 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz@#$Extra";
  
  while (*str)
  {
    LCDCharacter(byte(*str)); // increments our cursor for each character
    
#ifdef SERIAL_DIAGNOSTICS      
    byte address = LCDGetCurrentAddress(); // get the LCD address
    char buffer[40];
    sprintf(buffer, "Character: '%c', Address: 0x%02X", *str, address);
    Serial.println(buffer);
#endif    
    str++;
  }
}

void loop() 
{
  // bottom right last 3 character cells: '+++'
  LCDSetCursorPosition(lcdColumns-3, lcdRows-1); 
  LCDCharacter('+');
  LCDCharacter('+');
  LCDCharacter('+');

  // using built-in LED as a heartbeat to show that I did not hang or crash in my code in setup()
  digitalWrite(LED_BUILTIN, HIGH);
  delay(500); 

  // bottom right last 3 character cells: '---'
  LCDSetCursorPosition(lcdColumns-3,lcdRows-1);
  LCDCharacter('-');
  LCDCharacter('-');
  LCDCharacter('-');

  digitalWrite(LED_BUILTIN, LOW);
  delay(500);
}

Credits

Michael Cartwright

21 projects • 14 followers

HD44780 LCD Driver: 20x4 and 16x2 - parallel (8 or 4 bit)