Lesson 8: LCD 16x2 Display

Overview

VUMBUA SYNAPSE KIT

LCD 16x2 DISPLAY

I2C ADDRESS: 0x21

LESSON 8: ACTIVE

The 16x2 LCD (Liquid Crystal Display) is your gateway to creating sophisticated user interfaces for your Vumbua Synapse Kit projects. With 16 characters across 2 rows, you can display text, numbers, custom symbols, and real-time data.

Using I2C communication at address 0x21, the LCD connects with just 4 wires, making it incredibly easy to integrate into your projects while freeing up valuable digital pins on your ATmega328P.

Real-World Applications

16x2 LCDs are used in:

Information displays for weather stations
Menu systems for embedded devices
Real-time data monitoring (temperature, humidity, etc.)
Digital clocks and timers
Device status indicators
Calculator and measurement displays
Interactive project interfaces

Prerequisites

Before starting, make sure you have completed:

Completed Lessons

Lesson 1: Blinking LED (Basic Output)
Lesson 4: Potentiometer (Analog Input)
Lesson 5: Light Sensor (I2C Basics)
Lesson 6: Temperature & Humidity
Understanding of Serial Monitor

Hardware Requirements

Vumbua Synapse Kit with 16x2 LCD
USB Type-C cable
Computer with Arduino IDE
LiquidCrystal_I2C library installed

On Vumbua Synapse Kit

The 16x2 LCD is pre-connected to the Vumbua board via I2C at address 0x21. You can start displaying text immediately - no additional wiring needed!

Learning Objectives

By the end of this lesson, you will be able to:

Understand I2C communication protocol
Work with LCD at I2C address 0x21
Install and use LiquidCrystal_I2C library
Display text, numbers, and variables on LCD
Format text (position, clear, cursor control)
Create custom characters (icons, symbols)
Implement scrolling text animations
Display real-time sensor data on LCD
Build a digital clock with LCD
Create interactive menu systems
Troubleshoot common LCD issues

What is a 16x2 LCD?

Display Specifications

The 16x2 LCD consists of:

16 Columns: Horizontal character positions
2 Rows: Vertical lines of text
Character Size: 5x8 pixel matrix per character
Total Characters: 32 (16 × 2)
Built-in Controller: HD44780 compatible
Backlight: Blue with white text (adjustable)

Character Representation

Each character is made from a 5×8 pixel grid. The LCD controller stores:

Standard Characters: ASCII set (letters, numbers, symbols)
Japanese Characters: Katakana symbols
Custom Characters: 8 user-definable characters
Character Codes: 0-255 (some reserved)

Memory Organization

The LCD has two types of memory:

DDRAM: Display Data RAM (stores characters to display)
CGRAM: Character Generator RAM (stores custom characters)
CGROM: Character Generator ROM (built-in character set)
Address Counter: Tracks cursor position

DDRAM addresses: Row 1: 0x00-0x0F, Row 2: 0x40-0x4F

I2C Communication Protocol

I2C (Inter-Integrated Circuit) is a two-wire serial communication protocol that allows multiple devices to communicate with a microcontroller using just two pins.

I2C Bus Architecture

ATmega328P

Master Controller

↔

SDA (Serial Data)

Pin A4 on Arduino

↔

SCL (Serial Clock)

Pin A5 on Arduino

16x2 LCD

Address: 0x21

I2C Advantages:

Only 2 wires needed for multiple devices
Addressable devices (up to 128 with 7-bit addressing)
Built-in pull-up resistors on Vumbua board
Standardized protocol widely supported
Clock synchronization for reliable communication

I2C Communication Process

When the ATmega328P communicates with the LCD:

Master (ATmega328P) sends START condition
Master sends device address (0x21) with write bit
LCD acknowledges address match
Master sends command or data byte
LCD acknowledges receipt
Master sends STOP condition to end transmission

I2C Address 0x21 Explained

The LCD on your Vumbua Synapse Kit has a fixed I2C address of 0x21 (hexadecimal).

LCD I2C Address

0x21

0 1 0 0 0 0 1

Binary: 0100001 (7-bit address)

With R/W bit: 01000010 = 0x42 (Write)

With R/W bit: 01000011 = 0x43 (Read)

How Address is Set

The I2C backpack on the LCD has address selection pins (A0, A1, A2):

Each pin can be HIGH (1) or LOW (0)
Base address: 0x20 (0100000 in binary)
A0=0, A1=0, A2=1 → 0x21
Address = 0x20 + (A2<<2 | A1<<1 | A0)

On Vumbua: A0=LOW, A1=LOW, A2=HIGH = 0x21

Finding LCD Address

If you need to verify or find the address:

#include <Wire.h>

void setup() {
  Wire.begin();
  Serial.begin(9600);
  Serial.println("Scanning I2C devices...");
}

void loop() {
  byte error, address;
  int devices = 0;
  
  for(address = 1; address < 127; address++ ) {
    Wire.beginTransmission(address);
    error = Wire.endTransmission();
    
    if (error == 0) {
      Serial.print("Device found at 0x");
      if (address < 16) Serial.print("0");
      Serial.println(address, HEX);
      devices++;
    }
  }
  
  if (devices == 0) Serial.println("No devices found");
  delay(5000);
}

LiquidCrystal_I2C Library

The LiquidCrystal_I2C library simplifies LCD control by handling all the low-level I2C communication.

Installation

Install the library through Arduino IDE:

Open Arduino IDE
Go to Sketch → Include Library → Manage Libraries
Search for "LiquidCrystal I2C"
Install "LiquidCrystal I2C by Frank de Brabander"
Version 1.1.2 or newer recommended

Library Structure

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

// Initialize LCD object
// Parameters: (address, columns, rows)
LiquidCrystal_I2C lcd(0x21, 16, 2);

void setup() {
  lcd.init();          // Initialize LCD
  lcd.backlight();     // Turn on backlight
  lcd.print("Hello!"); // Display text
}

void loop() {
  // Your code here
}

Key Functions

lcd.begin(cols, rows) - Initialize display
lcd.clear() - Clear entire screen
lcd.setCursor(col, row) - Position cursor
lcd.print(data) - Display text/variables
lcd.write(data) - Display character
lcd.createChar(num, data) - Create custom character
lcd.backlight() / lcd.noBacklight()
lcd.blink() / lcd.noBlink()
lcd.cursor() / lcd.noCursor()

Basic Text Display

Let's start with a simple "Hello World" program for the LCD:

lcd_hello_world.ino

/*
  Vumbua Synapse Kit - Lesson 8: LCD Hello World
  Basic text display on 16x2 LCD at address 0x21
*/

// Include necessary libraries
#include <Wire.h>
#include <LiquidCrystal_I2C.h>

// Initialize LCD: (I2C address, columns, rows)
LiquidCrystal_I2C lcd(0x21, 16, 2);

void setup() {
  // Initialize Serial for debugging
  Serial.begin(9600);
  Serial.println("LCD Hello World Program Started");
  
  // Initialize the LCD
  lcd.init();
  
  // Turn on the backlight
  lcd.backlight();
  
  // Display startup message
  lcd.setCursor(0, 0);  // Column 0, Row 0 (top row)
  lcd.print("Vumbua Synapse Kit");
  
  lcd.setCursor(0, 1);  // Column 0, Row 1 (bottom row)
  lcd.print("LCD 16x2 Ready!");
  
  Serial.println("LCD initialized successfully");
}

void loop() {
  // Nothing in loop for basic example
  // LCD will continue displaying the setup message
  delay(100);
}

Testing the Program

1. Upload the Code

Upload to your Vumbua Synapse Kit. The LCD should immediately display the text.

2. Verify LCD Operation

Check that:

Backlight is ON (blue light)
Text is clear and readable
Both rows display correctly
No garbled characters

3. Troubleshoot if Needed

If LCD doesn't work:

Check I2C address (should be 0x21)
Verify library installation
Check contrast potentiometer on LCD (if available)
Ensure backlight is enabled in code

Vumbua Synapse Kit

LCD 16x2 Ready!

Text Formatting & Control

Learn to control cursor position, clear screen, and create dynamic displays:

lcd_formatting.ino

/*
  Vumbua Synapse Kit - Lesson 8: LCD Formatting Demo
  Demonstrates cursor control, clearing, and special features
*/

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

LiquidCrystal_I2C lcd(0x21, 16, 2);

void setup() {
  lcd.init();
  lcd.backlight();
  
  Serial.begin(9600);
  Serial.println("LCD Formatting Demo Started");
}

void loop() {
  // Demo 1: Basic positioning
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Left aligned");
  lcd.setCursor(0, 1);
  lcd.print("text");
  delay(2000);
  
  // Demo 2: Right aligned text
  lcd.clear();
  lcd.setCursor(16-strlen("Right aligned"), 0);
  lcd.print("Right aligned");
  lcd.setCursor(16-strlen("text"), 1);
  lcd.print("text");
  delay(2000);
  
  // Demo 3: Centered text
  lcd.clear();
  String text1 = "Center text";
  String text2 = "demo";
  lcd.setCursor((16 - text1.length()) / 2, 0);
  lcd.print(text1);
  lcd.setCursor((16 - text2.length()) / 2, 1);
  lcd.print(text2);
  delay(2000);
  
  // Demo 4: Cursor and blink effects
  lcd.clear();
  lcd.print("Cursor: ON ");
  lcd.cursor();
  delay(2000);
  
  lcd.clear();
  lcd.print("Cursor: OFF");
  lcd.noCursor();
  delay(2000);
  
  lcd.clear();
  lcd.print("Blink: ON  ");
  lcd.blink();
  delay(2000);
  
  lcd.clear();
  lcd.print("Blink: OFF ");
  lcd.noBlink();
  delay(2000);
  
  // Demo 5: Display numbers and variables
  for (int counter = 0; counter <= 10; counter++) {
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("Counter:");
    lcd.setCursor(9, 0);
    lcd.print(counter);  // Display integer
    
    lcd.setCursor(0, 1);
    lcd.print("Float:");
    float piValue = 3.14159;
    lcd.setCursor(7, 1);
    lcd.print(piValue, 4);  // 4 decimal places
    
    delay(500);
  }
  
  // Demo 6: Backlight control
  lcd.clear();
  lcd.print("Backlight OFF");
  lcd.noBacklight();
  delay(2000);
  
  lcd.clear();
  lcd.print("Backlight ON ");
  lcd.backlight();
  delay(2000);
}

Important LCD Functions

Cursor Positioning: setCursor(column, row) - Both are 0-indexed

Clearing: clear() also homes cursor to (0,0)

Printing Numbers: print(number, decimals) for floating point

Special Characters: Use escape sequences like \n doesn't work, use setCursor() instead for new lines

Custom Characters

Create your own icons and symbols using the 8 custom character slots:

Custom Character Creator

Click cells to create your own 5x8 character:

custom_characters.ino

/*
  Vumbua Synapse Kit - Lesson 8: Custom Characters
  Create and display custom icons on LCD
*/

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

LiquidCrystal_I2C lcd(0x21, 16, 2);

// Create custom characters (5x8 pixels each)
// Each byte represents one row (8 rows total)
byte heart[8] = {
  0b00000,
  0b01010,
  0b11111,
  0b11111,
  0b01110,
  0b00100,
  0b00000,
  0b00000
};

byte smiley[8] = {
  0b00000,
  0b00000,
  0b01010,
  0b00000,
  0b00000,
  0b10001,
  0b01110,
  0b00000
};

byte arrow[8] = {
  0b00100,
  0b00110,
  0b11111,
  0b00110,
  0b00100,
  0b00000,
  0b00000,
  0b00000
};

byte battery[8] = {
  0b01110,
  0b11011,
  0b10001,
  0b10001,
  0b10001,
  0b10001,
  0b10001,
  0b11111
};

byte thermometer[8] = {
  0b00100,
  0b01010,
  0b01010,
  0b01010,
  0b01010,
  0b10001,
  0b10001,
  0b01110
};

byte degree[8] = {
  0b01100,
  0b10010,
  0b10010,
  0b01100,
  0b00000,
  0b00000,
  0b00000,
  0b00000
};

void setup() {
  lcd.init();
  lcd.backlight();
  
  // Load custom characters into CGRAM
  // Parameters: (character_number, byte_array)
  lcd.createChar(0, heart);
  lcd.createChar(1, smiley);
  lcd.createChar(2, arrow);
  lcd.createChar(3, battery);
  lcd.createChar(4, thermometer);
  lcd.createChar(5, degree);
  
  // Display custom characters
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.write(0);  // Display heart
  lcd.print(" Vumbua ");
  lcd.write(1);  // Display smiley
  
  lcd.setCursor(0, 1);
  lcd.write(2);  // Display arrow
  lcd.print("LCD Demo");
  lcd.write(2);  // Display arrow
  
  delay(3000);
  
  // Example: Temperature display with custom icons
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.write(4);  // Thermometer
  lcd.print("Temp: 25");
  lcd.write(5);  // Degree symbol
  lcd.print("C");
  
  lcd.setCursor(0, 1);
  lcd.write(3);  // Battery
  lcd.print("Batt: 85%");
}

void loop() {
  // Custom characters remain in memory
  // You can use them anytime with lcd.write(0) to lcd.write(7)
  delay(100);
}

Custom Character Limitations

Only 8 slots: You can create only 8 custom characters (0-7) at a time

5×8 pixels: Each character is 5 pixels wide, 8 pixels tall

Volatile memory: Custom characters are lost when power is removed

Use lcd.write(): To display custom characters, use lcd.write(0) not lcd.print()

Scrolling Text Effects

Create dynamic scrolling text for announcements or long messages:

lcd_scrolling.ino

/*
  Vumbua Synapse Kit - Lesson 8: Scrolling Text
  Create left, right, and bounce scrolling effects
*/

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

LiquidCrystal_I2C lcd(0x21, 16, 2);

String longMessage = "Welcome to Vumbua Synapse Kit - Master STEM with Hands-on Projects! ";
int messageLength;
int position = 0;

void setup() {
  lcd.init();
  lcd.backlight();
  
  messageLength = longMessage.length();
  
  Serial.begin(9600);
  Serial.println("LCD Scrolling Demo Started");
}

void loop() {
  // Demo 1: Left Scroll (Marquee Effect)
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Left Scroll Demo");
  
  for (int i = 0; i < messageLength - 15; i++) {
    lcd.setCursor(0, 1);
    lcd.print(longMessage.substring(i, i + 16));
    delay(300);
  }
  delay(1000);
  
  // Demo 2: Right Scroll
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Right Scroll Demo");
  
  for (int i = messageLength - 16; i >= 0; i--) {
    lcd.setCursor(0, 1);
    lcd.print(longMessage.substring(i, i + 16));
    delay(300);
  }
  delay(1000);
  
  // Demo 3: Bounce Effect
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Bounce Effect");
  
  String shortMsg = "VUMBUA";
  bool movingRight = true;
  int bouncePos = 0;
  
  for (int bounce = 0; bounce < 30; bounce++) {
    lcd.setCursor(bouncePos, 1);
    lcd.print(shortMsg);
    
    delay(200);
    
    // Clear previous position
    lcd.setCursor(bouncePos, 1);
    lcd.print("      ");  // 6 spaces for "VUMBUA"
    
    // Update position
    if (movingRight) {
      bouncePos++;
      if (bouncePos > 16 - shortMsg.length()) {
        movingRight = false;
      }
    } else {
      bouncePos--;
      if (bouncePos < 0) {
        movingRight = true;
      }
    }
  }
  
  delay(1000);
  
  // Demo 4: Typewriter Effect
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Typewriter Effect");
  
  String typeText = "Hello World!";
  lcd.setCursor(0, 1);
  
  for (int i = 0; i < typeText.length(); i++) {
    lcd.print(typeText[i]);
    delay(150);
  }
  
  delay(2000);
}

Displaying Sensor Data

Combine LCD with sensors to create real-time monitoring displays:

sensor_display.ino

/*
  Vumbua Synapse Kit - Lesson 8: Sensor Data Display
  Display potentiometer and simulated sensor data on LCD
*/

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

LiquidCrystal_I2C lcd(0x21, 16, 2);

// Pin definitions
const int potPin = A0;      // Potentiometer for analog input
const int tempPin = A1;     // Simulated temperature sensor

// Variables for sensor readings
int potValue = 0;
int tempValue = 0;
float voltage = 0;
float temperature = 0;

// Custom degree symbol
byte degreeSymbol[8] = {
  0b01100,
  0b10010,
  0b10010,
  0b01100,
  0b00000,
  0b00000,
  0b00000,
  0b00000
};

void setup() {
  // Initialize Serial
  Serial.begin(9600);
  
  // Initialize LCD
  lcd.init();
  lcd.backlight();
  
  // Create custom degree symbol
  lcd.createChar(0, degreeSymbol);
  
  // Display startup message
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Sensor Monitor");
  lcd.setCursor(0, 1);
  lcd.print("Initializing...");
  
  delay(2000);
  
  Serial.println("Sensor Display System Ready");
}

void loop() {
  // Read sensor values
  potValue = analogRead(potPin);
  tempValue = analogRead(tempPin);
  
  // Convert to meaningful units
  voltage = potValue * (5.0 / 1023.0);
  temperature = map(tempValue, 0, 1023, 0, 50);  // Simulated temp
  
  // Display on LCD
  lcd.clear();
  
  // Row 1: Potentiometer data
  lcd.setCursor(0, 0);
  lcd.print("Pot:");
  lcd.setCursor(5, 0);
  lcd.print(potValue);
  lcd.print(" (");
  lcd.print(voltage, 2);  // 2 decimal places
  lcd.print("V)");
  
  // Row 2: Temperature data
  lcd.setCursor(0, 1);
  lcd.print("Temp:");
  lcd.setCursor(6, 1);
  
  // Format temperature display
  if (temperature < 10) {
    lcd.print(" ");  // Add space for alignment
  }
  
  lcd.print(temperature, 1);  // 1 decimal place
  lcd.write(0);  // Degree symbol
  lcd.print("C");
  
  // Also print to Serial for debugging
  Serial.print("Potentiometer: ");
  Serial.print(potValue);
  Serial.print(" (");
  Serial.print(voltage, 2);
  Serial.print("V), Temperature: ");
  Serial.print(temperature, 1);
  Serial.println("°C");
  
  // Update display every second
  delay(1000);
}

Pot: 512 (2.50V)

Temp: 25.5°C

Digital Clock Project

Build a complete digital clock with time display and custom formatting:

digital_clock.ino

/*
  Vumbua Synapse Kit - Lesson 8: Digital Clock
  Create a digital clock with hours, minutes, seconds
  Uses millis() for timing (no RTC required for demo)
*/

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

LiquidCrystal_I2C lcd(0x21, 16, 2);

// Time variables
unsigned long previousMillis = 0;
const long interval = 1000;  // 1 second interval

int hours = 12;
int minutes = 0;
int seconds = 0;
bool isPM = false;

// Custom characters for clock face
byte colon[8] = {
  0b00000,
  0b00000,
  0b01010,
  0b00000,
  0b00000,
  0b01010,
  0b00000,
  0b00000
};

void setup() {
  // Initialize LCD
  lcd.init();
  lcd.backlight();
  
  // Create custom colon character
  lcd.createChar(0, colon);
  
  // Display startup animation
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Vumbua Digital");
  lcd.setCursor(0, 1);
  lcd.print("Clock v1.0");
  
  delay(2000);
  
  // Initialize time display
  updateDisplay();
}

void loop() {
  unsigned long currentMillis = millis();
  
  if (currentMillis - previousMillis >= interval) {
    previousMillis = currentMillis;
    
    // Update seconds
    seconds++;
    
    // Update minutes
    if (seconds >= 60) {
      seconds = 0;
      minutes++;
      
      // Update hours
      if (minutes >= 60) {
        minutes = 0;
        hours++;
        
        // Switch AM/PM at noon and midnight
        if (hours == 12) {
          isPM = !isPM;
        }
        
        // Reset to 1 after 12 (12-hour format)
        if (hours > 12) {
          hours = 1;
        }
      }
    }
    
    // Update display
    updateDisplay();
  }
}

void updateDisplay() {
  // Clear display
  lcd.clear();
  
  // Row 1: Title
  lcd.setCursor(0, 0);
  lcd.print("Digital Clock");
  
  // Row 2: Time display
  lcd.setCursor(0, 1);
  
  // Format hours with leading zero if needed
  if (hours < 10) {
    lcd.print("0");
  }
  lcd.print(hours);
  
  // Custom colon character
  lcd.write(0);
  
  // Format minutes with leading zero
  if (minutes < 10) {
    lcd.print("0");
  }
  lcd.print(minutes);
  
  // Custom colon character
  lcd.write(0);
  
  // Format seconds with leading zero
  if (seconds < 10) {
    lcd.print("0");
  }
  lcd.print(seconds);
  
  // AM/PM indicator
  lcd.print(isPM ? " PM" : " AM");
}

Enhancing the Digital Clock

For a real-world clock, consider adding:

Real-Time Clock (RTC) module for accurate timekeeping
Buttons for time setting
Date display (day, month, year)
Alarm functionality with buzzer
Temperature display integrated
Backlight control with light sensor

Interactive Menu System

Create a menu system with navigation using buttons and LCD display:

menu_system.ino

/*
  Vumbua Synapse Kit - Lesson 8: Interactive Menu
  Create a menu system with navigation buttons
  Simulates button input with serial commands
*/

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

LiquidCrystal_I2C lcd(0x21, 16, 2);

// Menu structure
const int MENU_ITEMS = 4;
String menuItems[MENU_ITEMS] = {
  "View Sensors",
  "Set Time",
  "System Info",
  "Settings"
};

// Navigation variables
int currentMenu = 0;       // Current selected item
int currentPage = 0;       // Current page in multi-page menus
bool inSubMenu = false;    // Whether in sub-menu

// Button simulation via Serial
char serialCommand = ' ';

void setup() {
  // Initialize Serial for button simulation
  Serial.begin(9600);
  
  // Initialize LCD
  lcd.init();
  lcd.backlight();
  
  // Display welcome message
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Vumbua Menu Sys");
  lcd.setCursor(0, 1);
  lcd.print("Press: U/D/OK/BACK");
  
  delay(2000);
  
  // Show menu instructions
  Serial.println("=== Vumbua Menu System ===");
  Serial.println("Send commands via Serial:");
  Serial.println("U - Move Up");
  Serial.println("D - Move Down");
  Serial.println("O - OK/Select");
  Serial.println("B - Back");
  Serial.println("=========================");
  
  // Display main menu
  displayMenu();
}

void loop() {
  // Check for serial commands (simulating buttons)
  if (Serial.available() > 0) {
    serialCommand = Serial.read();
    
    if (!inSubMenu) {
      // Main menu navigation
      switch (serialCommand) {
        case 'U':  // Up
        case 'u':
          currentMenu = (currentMenu - 1 + MENU_ITEMS) % MENU_ITEMS;
          displayMenu();
          break;
          
        case 'D':  // Down
        case 'd':
          currentMenu = (currentMenu + 1) % MENU_ITEMS;
          displayMenu();
          break;
          
        case 'O':  // OK/Select
        case 'o':
          selectMenuItem();
          break;
          
        case 'B':  // Back (does nothing in main menu)
        case 'b':
          Serial.println("Already in main menu");
          break;
      }
    } else {
      // In sub-menu, only back command works
      if (serialCommand == 'B' || serialCommand == 'b') {
        inSubMenu = false;
        displayMenu();
      }
    }
  }
  
  delay(100);  // Small delay for stability
}

void displayMenu() {
  lcd.clear();
  
  // Display menu title
  lcd.setCursor(0, 0);
  lcd.print("Main Menu>");
  
  // Display selected item with cursor
  lcd.setCursor(0, 1);
  lcd.print(">");  // Cursor indicator
  lcd.print(menuItems[currentMenu]);
  
  // Print to Serial for feedback
  Serial.print("Selected: ");
  Serial.println(menuItems[currentMenu]);
}

void selectMenuItem() {
  inSubMenu = true;
  
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Selected:");
  lcd.setCursor(0, 1);
  lcd.print(menuItems[currentMenu]);
  
  delay(1000);
  
  // Display sub-menu content based on selection
  switch (currentMenu) {
    case 0:  // View Sensors
      displaySensorInfo();
      break;
      
    case 1:  // Set Time
      displayTimeSetting();
      break;
      
    case 2:  // System Info
      displaySystemInfo();
      break;
      
    case 3:  // Settings
      displaySettings();
      break;
  }
}

void displaySensorInfo() {
  // Simulated sensor readings
  int potValue = analogRead(A0);
  float voltage = potValue * (5.0 / 1023.0);
  
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Sensor Readings:");
  
  lcd.setCursor(0, 1);
  lcd.print("Pot:");
  lcd.print(potValue);
  lcd.print(" ");
  lcd.print(voltage, 2);
  lcd.print("V");
  
  Serial.println("Displaying sensor information");
}

void displayTimeSetting() {
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Set Time Menu");
  lcd.setCursor(0, 1);
  lcd.print("(Not implemented)");
  
  Serial.println("Displaying time setting menu");
}

void displaySystemInfo() {
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("System Info");
  lcd.setCursor(0, 1);
  lcd.print("Vumbua v1.0");
  
  Serial.println("Displaying system information");
}

void displaySettings() {
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Settings Menu");
  lcd.setCursor(0, 1);
  lcd.print("Backlight: ON");
  
  Serial.println("Displaying settings menu");
}

Troubleshooting Common LCD Issues

Common LCD Problems & Solutions

1. No Display/Blank Screen

Check I2C address: Verify it's 0x21 in your code
Verify connections: Ensure I2C cables are secure
Check contrast: Adjust contrast potentiometer on LCD module
Backlight: Ensure lcd.backlight() is called
Power: Ensure Vumbua board is powered via USB

2. Garbled Characters

Baud rate mismatch: Ensure proper initialization
Library issue: Try reinstalling LiquidCrystal_I2C library
Timing issue: Add delay(100) after lcd.init()
Corrupted CGRAM: Call lcd.clear() before displaying
Power fluctuations: Ensure stable 5V power supply

3. LCD Not Responding to Commands

I2C address scan: Run I2C scanner to confirm address
Library compatibility: Try different LiquidCrystal_I2C versions
Wire library: Ensure #include <Wire.h> is first
Multiple I2C devices: Check for address conflicts
Reset Arduino: Sometimes a hard reset helps

Advanced I2C Debugging

// Advanced debugging for I2C communication
#include <Wire.h>

void scanI2C() {
  byte error, address;
  int devices = 0;
  
  Serial.println("Scanning I2C bus...");
  
  for(address = 1; address < 127; address++) {
    Wire.beginTransmission(address);
    error = Wire.endTransmission();
    
    if (error == 0) {
      Serial.print("Device found at 0x");
      if (address < 16) Serial.print("0");
      Serial.print(address, HEX);
      Serial.print(" (");
      Serial.print(address);
      Serial.println(")");
      devices++;
    }
  }
  
  if (devices == 0) {
    Serial.println("No I2C devices found");
    Serial.println("Check connections and power");
  } else {
    Serial.print("Found ");
    Serial.print(devices);
    Serial.println(" device(s)");
  }
}

void setup() {
  Wire.begin();
  Serial.begin(9600);
  while(!Serial);
  
  Serial.println("I2C Debugger Started");
  scanI2C();
}

void loop() {
  // Can rescan periodically if needed
  delay(10000);
  scanI2C();
}

Video Demonstration

VIDEO TUTORIAL

COMING SOON!

Video Tutorial Coming Soon!

We're preparing a detailed video walkthrough for LCD 16x2 display.

Subscribe to our YouTube channel to be notified when it's available.

Subscribe to OLSPACE

What's Next?

Congratulations! You've mastered the 16x2 LCD display. Here's what you've accomplished:

✓ Learned I2C communication protocol
✓ Worked with LCD at I2C address 0x21
✓ Mastered LiquidCrystal_I2C library
✓ Displayed text, numbers, and variables
✓ Created custom characters and icons
✓ Implemented scrolling text effects
✓ Built sensor data displays
✓ Created a digital clock project
✓ Built interactive menu systems
✓ Learned troubleshooting techniques

In the next lesson, you'll explore servo motor control:

Lesson 9: Servo Motor Control

Learn to control servo motors for precise angular positioning. Create robotics projects, camera gimbals, automated systems, and mechanical controls using PWM signals from your Vumbua Synapse Kit.

Resources & Downloads

Download Complete Code

Get all the code files for this lesson:

Hello World LCD Text Formatting Custom Characters Scrolling Text Sensor Display Digital Clock Menu System