PIC16F57: Serial LCD and 4×4 Keypad Interface

📟 Serial LCD Display via 74ALS164

Function	PIC Output	Destination	Description
Serial Data	Data	Pin 1 (A) – 74ALS164	Shift register data input
Serial Clock	SCLK	Pin 2 (B) – 74ALS164	Clock input (rising edge)
RS	RS	Pin 4 – LCD	LOW = command, HIGH = character
E (Enable)	E	Pin 6 – LCD	Latch signal on falling edge

Note: LCD D0–D7 connect to QA–QH of the 74ALS164 (in order).

Use shift + latch approach to send bytes serially: shift 8 bits → toggle E → done.

This project demonstrates interfacing a PIC16F57 with a serial LCD using a 74164 shift register and scanning a 4×4 matrix keypad. Key presses are immediately printed to the LCD as ASCII characters.

Hardware Summary

• Microcontroller: PIC16F57 @ 4 MHz (XT crystal)
• LCD Interface: RA0 (E), RA1 (RS), RA2 (DATA), RA3 (CLK) to 74164
• Keypad: Rows on PORTB (RB0-RB3), Columns on PORTC (RC4-RC7)
• Keypad Pull-ups: External 4.7K resistors on rows

Program Features

• Program size: 447 bytes.
• SRAM usage: 16 bytes.
• Custom serial LCD output using 8-bit shift.
• Direct keypad-to-LCD display logic.

Main Code Snippet

void main(void) {
    lcdInit();
    keypad_init();
    char key;
    while(1) {
        key = getKey();
        if (key) {
            writeByte(key, 1);  // Display character
        }
    }
}

Keypad Mapping

The keypad layout (hex 0-F with * and #):

 1  2  3  A
 4  5  6  B
 7  8  9  C
 *  0  #  D

LCD Write Routine

Function: writeByte Description: Sends an 8-bit byte to an LCD using a shift register (e.g., 74ALS164). The data is clocked in one bit at a time on LCD_DATA, synchronized with LCD_CLK. The RS (Register Select) line is set based on the is_data flag to distinguish between command (0) and data (1) mode. After shifting in the byte, the LCD_E line is pulsed to latch the data into the LCD controller. Includes required timing delays for reliable operation.

void writeByte(unsigned char byte, unsigned char is_data) {
    LCD_RS = is_data & 0x01;
    for (char i = 0; i < 8; i++) {
        if (byte & 0x80)
            LCD_DATA = 1;
        else
            LCD_DATA = 0;
        LCD_CLK = 1;
        __delay_us(10);
        LCD_CLK = 0;
        __delay_us(10);
        byte <<= 1;
    }
    __delay_ms(2);
    // pulseE();
    LCD_E = 1;
    __delay_us(10);
    LCD_E = 0;
    __delay_us(50);
    LCD_DATA = 0;
    LCD_CLK = 0;
}

🔢 Beginner-Friendly `getKey()` Function for 4×4 Keypad

This function scans a 4×4 keypad connected to a PIC microcontroller. It works by:

• Setting one row LOW at a time (RC4 to RC7).
• Reading the column inputs (RB0 to RB3) to see if a button was pressed.
• Returning the corresponding character from the key_map[row][col] lookup table.

✅ Clean Version of getKey():

char getKey(void) {
    char row, col;

    for (row = 0; row < 4; row++) {
        // Set RC4, RC5, RC6, RC7 (rows) all HIGH
        PORTC = PORTC | 0b11110000;

        // Set one row LOW at a time
        PORTC = PORTC & ~(1 << (4 + row));

        __delay_us(50);  // Wait for signals to settle

        // Now check the 4 column input pins RB0 to RB3
        for (col = 0; col < 4; col++) {
            // If a key is pressed, the column goes LOW
            if ((PORTB & (1 << col)) == 0) {
                // Wait for the key to be released
                while ((PORTB & (1 << col)) == 0);
                __delay_ms(10);  // Debounce delay

                return key_map[row][col];  // Return corresponding key
            }
        }
    }

    return 0;  // No key pressed
}

🧠 Key Concepts for Beginners

• PORTC (RC4–RC7): Output pins that control rows.
• PORTB (RB0–RB3): Input pins that read columns.
• Bitwise operations:
  • PORTC | 0b11110000: Set all rows HIGH.
  • ~(1 << (4 + row)): Clear one row (set it LOW).
  • PORTB & (1 << col): Check if a column is LOW (key press).
• Debounce: A delay to ensure only one keypress is registered.

💡 You can display the returned character on an LCD or send it over serial to verify key input.

🔢 4×4 Keypad Wiring Reference – PIC16F57

Keypad Line	PIC16F57 Pin	Port Bit	Direction	Notes
X1 (Row 1)	23	RC4	Output	Drive LOW to scan
X2 (Row 2)	24	RC5	Output
X3 (Row 3)	25	RC6	Output
X4 (Row 4)	26	RC7	Output
Y1 (Col 1)	10	RB0	Input	10 kΩ pull-up to +5V
Y2 (Col 2)	11	RB1	Input	10 kΩ pull-up to +5V
Y3 (Col 3)	12	RB2	Input	10 kΩ pull-up to +5V
Y4 (Col 4)	13	RB3	Input	10 kΩ pull-up to +5V

Scan Method: Set all row outputs HIGH, then set one LOW at a time. Read the column inputs (active LOW) to detect key presses.

Debounce: After detecting a key press, wait for release and add ~10 ms delay.

Below is a C program for interfacing a 4x4 keypad and an LCD display with a PIC microcontroller. The code configures the microcontroller, initializes the keypad and LCD, and displays pressed keys on the LCD. It includes configuration bits, pin definitions, and functions for keypad scanning and LCD communication.

#include <xc.h>

// Configuration bits
#pragma config WDT = OFF   // Watchdog Timer disabled
#pragma config CP = OFF     // Code protection off
#pragma config OSC = XT     // XT Oscillator (use 4 MHz crystal)

#define _XTAL_FREQ 4000000UL

#define LCD_E  RA0 // blue
#define LCD_RS RA1 // green
#define LCD_DATA RA2 // orange
#define LCD_CLK  RA3 // yellow

#define MSG1 "Hello World!"
#define LINE0 0x80 
#define LINE1 0xC0

const char key_map[4][4] = {
    {'1', '2', '3', 'A'},
    {'4', '5', '6', 'B'},
    {'7', '8', '9', 'C'},
    {'*', '0', '#', 'D'}
};

// Set columns (RC4-RC7) high initially
void keypad_init(void) {
    TRISB = 0x0F;  // RB0-RB3 inputs (rows)
    TRISC = 0x0F;  // RC4-RC7 outputs (columns)
    PORTC |= 0xF0; // Ensure RC4-RC7 are high (inactive)
}

char getKey(void) {
    for (char row = 0; row < 4; row++) {
        // Set all RC4-RC7 high
        PORTC |= 0xF0;
        // Drive one row low at a time (RC4 = bit 4)
        PORTC &= ~(1 << (4 + row));
        __delay_us(50);  // Allow lines to settle

        // Check each column input (RB0-RB3)
        for (char col = 0; col < 4; col++) {
            if (!(PORTB & (1 << col))) {  // If key is pressed (active low)
                while (!(PORTB & (1 << col)));  // Wait for release (blocking)
                __delay_ms(10);  // Basic debounce
                return key_map[row][col];
            }
        }
    }
    return 0;  // No key pressed
}

void writeByte(unsigned char byte, unsigned char is_data) {
    LCD_RS = is_data & 0x01;
    for (char i = 0; i < 8; i++) {
        if (byte & 0x80)
            LCD_DATA = 1;
        else
            LCD_DATA = 0;
        LCD_CLK = 1;
        __delay_us(10);
        LCD_CLK = 0;
        __delay_us(10);
        byte <<= 1;
    }
    __delay_ms(2);
    // pulseE();
    LCD_E = 1;
    __delay_us(10);
    LCD_E = 0;
    __delay_us(50);
    LCD_DATA = 0;
    LCD_CLK = 0;
}

void lcdInit(void) {
    // Clear output ports
    PORTA = 0x00;
    PORTB = 0x00;
    PORTC = 0x00;
    // TRIS settings
    TRISA = 0x00; // Lower 4 bits output
    TRISB = 0xFF; // All input
    TRISC = 0xFF; // All input
    // lcd_init();
    LCD_E = 0;
    LCD_RS = 0;
    LCD_DATA = 0;
    LCD_CLK = 0;

    __delay_ms(20);
    writeByte(0x38, 0);
    writeByte(0x0C, 0);
    writeByte(0x06, 0);
    writeByte(0x01, 0);
    __delay_ms(2);
}

void lcd_print(const char *str) {
    while (*str) {
        writeByte(*str++, 1);
    }
}

void main(void) {
    
    lcdInit();
    keypad_init();
    writeByte(0x80, 0); // top line
    lcdPrint(MSG1);
    writeByte(0xC0, 0); // 2nd line
    char key;
    //writeByte('H', 1); // test display
    
    while(1) {
    key = getKey();
    if (key) {
        writeByte(key, 1);  // print character to LCD
    // __delay_ms(20);
    }
} 
     // lcd_print("Hello World!");
  
}

• Electronics Projects Homepage
• Electronics and Reason: Empowering the Hobbyist
• The Decline of Scientific Integrity and the Enduring Value of Applied Science
• Crookes Tube Science Fair Project (1977)
• General Science for Everyone – Practical Biology, Chemistry, and Earth Science
• Variable-Frequency Oscillator Using 74C14 / 74HC14
• Misc. topics Macros, code examples, etc.
• Overview Vacuum Tube TV and Radio Parts Schematics

PIC16F57 projects.

• PIC16F57 LCD Counter – Real Hardware Binary and Decimal Display
• PIC16F57 using TMR0 with External 60Hz or 120Hz Clock
• 8-Bit LCD Interface with PIC16F57: Binary and Decimal Counter in C (XC8)
• PIC16F57 Serial LCD and 4x4 Keypad Demo
• Simulate PLC Ladder Logic with PIC16F57 Microcontroller – Simple C Example

The next three pages focuses on Timer0 and interrupts in the PIC16F84A

• PIC16F84A – TMR0 with External 60Hz Timebase on RA4 (Pin 3)
• PIC16F84A Interrupt Examples – RB0 and RB4–RB6 with LED Toggling
• Comparing PORTB Pull-Ups and Interrupts: PIC16F84A vs. PIC16F628A

• Using Timer1 on the PIC16F628A as a Pulse and Frequency Counter
• PIC16F628A Interrupt-on-Change Debounced Button Input on RB4
• PIC16F628A – Interrupt-Driven 1Hz Square Wave from 60Hz Input
• Using a 32.768 kHz Crystal with Timer1 on the PIC16F628A
• Interfacing HD44780 LCD with PIC16F628A in 4-Bit Mode
• PIC16F628A: Displaying Decimal Numbers on LCD 4-Bit Mode
• PIC16F628A PWM Output with Fade Example – 1 kHz LED Control

Electronics and Science

• Electronics and Technology Built at Home Mainpage
• Grade Tampering Hides Low Achievement in Public Schools

Six Parts:

• Applied versus Theoretical Science Relation to Electronics
• How does applied science differ from theoretical science?
• Is electronics an applied science?
• What is the difference between electronics and electrical technicians?
• What does "academic ability" really mean in practical terms?
• How does an electronics technician differ from an engineer?

• Why Chemistry is Useful for Learning Electronics
• Electrochemistry and Battery Charger Chemistry
• Brief Overview of Vacuum Tubes and Circuits
• How Selenium Rectifiers and Photocells Operate
• What is Electrochlorination and Electrolysis?
• Electroplating One Gram of Copper Working Example
• Why Modern Semiconductor Abstractions Are Full of Holes

The following has information on ferrite materials, SCRs, Neon sign colors.

• Basic Review Operation GaAs Photodiodes and their History
• Cesium Photo Detectors, Zinc Photocells, and Bandgap Explained
• Cesium Photoelectric Cells
• Is Zinc Photovoltaic?
• Bandgap versus Work Function Key Differences