Custom characters on LCD in Arduino - Deep Dive

Overview - Custom characters on LCD

What is it?

Custom characters on an LCD allow you to create and display your own symbols or shapes beyond the standard letters and numbers. This is done by defining a pattern of pixels that form the character you want. These characters can then be shown on the LCD screen just like normal text. It helps make your display more informative and visually interesting.

Why it matters

Without custom characters, you are limited to the built-in letters, numbers, and symbols on the LCD. This restricts how you can communicate information visually. Custom characters let you add icons, arrows, smileys, or any shape you need, making your device easier to understand and more user-friendly. This is especially useful in small screens where space is limited.

Where it fits

Before learning custom characters, you should understand how to connect and display basic text on an LCD using Arduino. After mastering custom characters, you can explore animations on LCDs or advanced graphical displays like OLEDs or TFT screens.

Mental Model

Core Idea

Custom characters on an LCD are created by turning pixels on or off in a small grid to form any shape you want, which the LCD then treats like a letter.

Think of it like...

It's like creating a tiny stamp by carving out a pattern on a rubber block, then pressing it onto paper to make your own symbol.

┌───────────────┐
│ Custom Char   │
│ 5x8 Pixels   │
│ ┌─┬─┬─┬─┬─┐ │
│ │█│ │█│ │ │ │
│ ├─┼─┼─┼─┼─┤ │
│ │ │█│ │█│ │ │ │
│ └─┴─┴─┴─┴─┘ │
└───────────────┘
Each row is a byte controlling 5 pixels horizontally.

Build-Up - 7 Steps

1

Foundation

Understanding LCD Pixel Grid

Concept: Learn how LCD characters are made of a grid of pixels.

A typical character on a 16x2 LCD is made from a 5x8 pixel grid. Each character is a small box with 5 pixels across and 8 pixels down. Turning pixels on or off creates letters or symbols. The LCD controller uses this grid to show characters.

Result

You know the LCD screen is like a tiny dot matrix where each character is a 5x8 pixel box.

Understanding the pixel grid is key to designing your own characters because you control which pixels light up.

2

Foundation

Basics of LCD Character Display with Arduino

Concept: How to show text on an LCD using Arduino code.

Using the LiquidCrystal library, you can connect an LCD to Arduino and display text with commands like lcd.print("Hello"). The LCD shows built-in characters by default. This sets the stage for adding custom characters later.

Result

You can display any standard text on the LCD screen using simple Arduino commands.

Knowing how to display text is the foundation before customizing characters.

3

Intermediate

Creating Custom Character Bitmaps

🤔Before reading on: do you think each custom character can have more than 8 rows of pixels? Commit to your answer.

Concept: Define your own character by creating an array of bytes representing pixel rows.

Each custom character is defined by 8 bytes, one for each row of pixels. Each byte uses only the lower 5 bits to turn pixels on (1) or off (0). For example, 0b00100 turns on the middle pixel in that row. You create an array of 8 bytes to form your shape.

Result

You can create any shape within the 5x8 pixel limit by setting bits in each byte.

Knowing how to map pixels to bits lets you design any symbol within the LCD's constraints.

4

Intermediate

Loading Custom Characters into LCD Memory

🤔Before reading on: do you think you can create unlimited custom characters at once? Commit to your answer.

Concept: Use Arduino's createChar() function to store your custom character in the LCD's special memory.

The LCD has space for up to 8 custom characters at a time, stored in CGRAM (Character Generator RAM). You use lcd.createChar(index, byteArray) to load your character bitmap into one of these 8 slots. Then you can display it by printing the index as a character.

Result

Your custom character appears on the LCD when you print its index.

Understanding the 8-character limit helps you plan which symbols to load and when.

5

Intermediate

Displaying and Using Custom Characters

Concept: How to show your custom characters on the LCD screen.

After loading a custom character at index 0-7, you display it by printing the byte value of that index, e.g., lcd.write(0). This prints your custom symbol instead of a normal letter. You can mix custom and normal characters freely.

Result

Your custom symbols appear on the screen alongside normal text.

Knowing how to print custom characters lets you enhance your display creatively.

6

Advanced

Animating Custom Characters on LCD

🤔Before reading on: do you think you can animate by changing pixels directly on the LCD? Commit to your answer.

Concept: Create simple animations by rapidly changing custom characters in CGRAM and refreshing the display.

You can redefine a custom character multiple times per second with createChar(), then print it repeatedly to simulate movement or change. This works because the LCD redraws characters from CGRAM each time. For example, a blinking arrow or a progress bar can be made this way.

Result

You can create simple animations on a character-based LCD despite its limitations.

Knowing that CGRAM updates reflect immediately enables creative animations on simple hardware.

7

Expert

Memory and Timing Limits of Custom Characters

🤔Before reading on: do you think updating custom characters too fast can cause display glitches? Commit to your answer.

Concept: Understand the hardware limits of CGRAM size and LCD refresh timing to avoid flicker or corruption.

The LCD controller has only 64 bytes of CGRAM, enough for 8 characters of 8 bytes each. Updating CGRAM too frequently or during LCD busy times can cause flicker or missed updates. Also, switching custom characters rapidly requires careful timing and sometimes delays to avoid glitches.

Result

You learn to balance update speed and stability for smooth custom character use.

Knowing hardware limits prevents common bugs and helps write robust LCD code.

Under the Hood

The LCD controller stores character pixel patterns in two places: ROM for built-in characters and CGRAM for custom ones. When you call createChar(), Arduino sends the 8-byte pattern to CGRAM at a specific address. The LCD then uses this pattern whenever the corresponding character code is printed. The display refreshes by reading CGRAM and lighting pixels accordingly. Timing is controlled by the LCD's internal controller, which requires commands to be sent with proper delays.

Why designed this way?

The LCD controller was designed with limited memory and processing power to keep costs low. Allowing only 8 custom characters balances flexibility with hardware constraints. Using CGRAM lets users define symbols without changing the built-in font ROM. This design keeps the LCD simple and fast while still customizable.

┌───────────────┐
│ Arduino MCU   │
│  ┌─────────┐  │
│  │ createChar│─┐
│  └─────────┘  │
│       │       │
│       ▼       │
│  ┌─────────┐  │
│  │ LCD     │  │
│  │ Controller│ │
│  ├─────────┤  │
│  │ CGRAM   │◄─┘
│  └─────────┘  │
│       │       │
│       ▼       │
│  Pixels Light │
│  on Screen   │
└───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Can you create more than 8 custom characters on the LCD at the same time? Commit to yes or no.

Common Belief: You can create as many custom characters as you want and store them all on the LCD.

Reality: The LCD hardware only supports 8 custom characters at once due to CGRAM size limits.

Why it matters: Trying to load more than 8 causes overwriting and unexpected characters, leading to confusing displays.

Quick: Does changing a custom character affect all instances of it on the screen immediately? Commit to yes or no.

Common Belief: Once printed, a custom character is fixed and won't change if you redefine it later.

Reality: Redefining a custom character updates all its instances on the screen instantly because they reference the same CGRAM slot.

Why it matters: This can cause unexpected changes if you redefine characters without clearing or updating the display properly.

Quick: Can you create custom characters with more than 5 pixels width on a standard LCD? Commit to yes or no.

Common Belief: You can make custom characters wider than 5 pixels on a 16x2 LCD.

Reality: Each character cell is fixed at 5 pixels wide; you cannot exceed this limit on standard LCDs.

Why it matters: Expecting wider characters leads to design errors and wasted effort trying impossible shapes.

Quick: Does the Arduino library automatically handle timing when updating custom characters? Commit to yes or no.

Common Belief: The LiquidCrystal library manages all timing, so you can update custom characters as fast as you want without issues.

Reality: You must manage timing and delays yourself to avoid LCD busy states and flicker when updating CGRAM.

Why it matters: Ignoring timing causes display glitches, flickering, or missed updates in your custom characters.

Expert Zone

1

Custom characters share CGRAM slots, so reusing slots dynamically can save memory but requires careful management.

2

The LCD controller refreshes the display from CGRAM continuously, so changing a character updates all visible instances immediately.

3

Some LCD modules have slightly different CGRAM addressing or timing requirements, so code may need adjustment for compatibility.

When NOT to use

Custom characters are limited to 5x8 pixels and 8 slots, so for complex graphics or many icons, use graphical LCDs or OLED displays instead. Also, if you need color or high resolution, custom characters on standard LCDs are not suitable.

Production Patterns

In real devices, custom characters are used for icons like battery level, arrows, or smileys. Developers often preload a fixed set of icons at startup and avoid changing them dynamically to prevent flicker. For animations, they carefully time CGRAM updates and sometimes double-buffer data in Arduino memory.

Connections

Bitmap Fonts

Custom characters are a simple form of bitmap fonts used in many displays.

Understanding custom characters helps grasp how bitmap fonts store pixel data for each letter in many digital displays.

Memory Management in Embedded Systems

Managing limited CGRAM slots is a form of constrained memory management.

Knowing how to optimize use of scarce CGRAM slots parallels managing limited RAM or flash in embedded programming.

Pixel Art in Video Games

Designing custom characters is like creating pixel art sprites for games.

Skills in designing 5x8 pixel patterns translate to creating simple game sprites and understanding pixel-level graphics.

Common Pitfalls

#1 Trying to display a custom character without loading it first.

Wrong approach:

lcd.write(0); // prints custom char at index 0 without calling createChar() first

Correct approach:

byte smiley[8] = {0,10,0,0,17,14,0,0};
lcd.createChar(0, smiley);
lcd.write(0);

Root cause:

Not loading the character bitmap into CGRAM means the LCD shows garbage or a blank space.

#2 Defining more than 8 custom characters at once.

Wrong approach:

for (int i=0; i<10; i++) {
lcd.createChar(i, somePattern);
}

Correct approach:

Define only up to 8 custom characters due to CGRAM limit:
for (int i=0; i<8; i++) {
lcd.createChar(i, somePattern);
}

Root cause:

LCD hardware limits CGRAM to 8 slots; exceeding this overwrites previous characters.

#3 Updating custom characters too quickly without delays.

Wrong approach:

for (int i=0; i<100; i++) {
lcd.createChar(0, newPattern);
lcd.write(0);
}

Correct approach:

Add delays to allow LCD to process commands:
for (int i=0; i<100; i++) {
lcd.createChar(0, newPattern);
lcd.write(0);
delay(50);
}

Root cause:

LCD controller needs time to update CGRAM; too fast updates cause flicker or missed changes.

Key Takeaways

Custom characters let you create any symbol within a 5x8 pixel grid on an LCD, expanding display possibilities.

You can store up to 8 custom characters at once in the LCD's CGRAM memory and display them by printing their index.

Designing custom characters involves setting bits in bytes to turn pixels on or off row by row.

Updating custom characters affects all instances on screen immediately, so manage changes carefully to avoid flicker.

Understanding hardware limits and timing is essential for smooth and effective use of custom characters in real projects.