LCD Keypad Shield Library for Proteus V1.0 (16x2 + 5 Buttons)

Hello friends, I hope you all are doing great. Today, I am going to share the new LCD Keypad Shield Library for Proteus V1.0. The LCD keypad shield is one of the most popular first boards for the Arduino UNO: a 16x2 LCD, five buttons and a contrast trimmer on one board that simply plugs onto the UNO. No wiring, no breadboard, and your project has a display and a small keyboard. With this LCD Keypad Shield Library for Proteus, you get the same shield in your simulation: the LCD shows what your sketch prints, and you press the buttons with the mouse.

The shield runs on our own HD44780 model from the LCD 16x2 Library for Proteus V3.0, and the five buttons are modelled the way the real board does it: a resistor ladder that puts a different voltage on A0 for every button, so analogRead(A0) in your sketch reads what a real shield gives. We modelled the two real versions of the shield, and the famous D10 backlight flaw of the common one. You get four devices (blue and yellow-green LCD, each as Simple with a live STATUS panel and as Advance with a pop-up window and four test tools), and the demo runs on our new Arduino UNO V4.0 with its built-in serial monitor.

NOTICE: This library is very special to our team. A keypad shield looks simple, but the details are where projects fail: two shield versions with different button values, a backlight pin that can overload your Arduino, keys that bounce. We modelled all of that, tested it with the real Arduino libraries on a PC and in Proteus, and redrew the shield so every part is clear on the black board. It took our team a lot of hard work and many test runs. Your feedback is the fuel that keeps us going, so please tell us what you think in the comments below or in the LCD Library board of our forum. And if our free libraries help you, you can buy us a coffee. So, let's get started with the LCD Keypad Shield Library for Proteus V1.0:

What is an LCD Keypad Shield?

An LCD keypad shield is an Arduino UNO shield with a 16x2 character LCD (the common 1602 with the HD44780 controller and a backlight), five buttons (SELECT, LEFT, UP, DOWN, RIGHT), a RST button for the Arduino and a blue contrast trimmer. The original is DFRobot's DFR0009; today most shields are its clones, usually on a black board. The shield plugs onto the UNO's headers, so every connection is made by the board itself.

The LCD uses Arduino's LiquidCrystal library in 4-bit mode on six pins, and the backlight hangs on D10. The buttons are the clever part: instead of five pins, they share one analog pin, A0. If you are new to the LCD itself, start with our Introduction to 16x2 LCD Module. For a 4x4 matrix keypad on digital pins, see our Arduino Keypad Interfacing.

The LCD Keypad Shield at a Glance

How Five Buttons Share One Analog Pin

A0 is held at 5 V by a 2k pull-up resistor. Each button connects A0 to GND through a different part of a resistor ladder: RIGHT shorts A0 straight to GND, UP goes through the first resistor, DOWN through the first two, and so on. Every button makes a different voltage divider, so every button gives a different voltage on A0, and analogRead(A0) tells you which one is held. With no button, A0 reads 1023.

There are two versions of the shield with different ladders, and our library models both (the SHIELD property). These are the values the sketch read in Proteus, at 5.00 V:

Tables online often give 329, 505 and 741 for V1.0: one count less, because real ADCs and resistors differ by a count or two. That is why a sketch should never compare against exact values. It should use limits half way between the buttons. Our demo's limits, 70 / 268 / 457 / 683 / 923, read both versions.

The D10 Backlight Flaw

The backlight is switched by a transistor whose base hangs on D10. On the V1.0 shield (most clones), a 4.7k resistor pulls the base up, but there is no resistor between D10 and the base. If a sketch makes D10 an OUTPUT and writes it HIGH, the pin drives the transistor's base directly, and real shields have been measured at over 100 mA on D10, while the ATmega328P's limit is 40 mA per pin. The same happens with analogWrite(10, ...). The safe way works on every shield: write D10 LOW once, then pinMode(10, INPUT) turns the backlight on (the shield's pull-up) and pinMode(10, OUTPUT) turns it off. The V2.0 shield adds a 10k base resistor, so HIGH and PWM are safe there. Our model knows which version it is and warns you, as you will see below.

What's New in LCD Keypad Shield Library for Proteus V1.0

Here is what the first version brings:

• The LCD keypad shield on our own HD44780 model in TEPLCD.DLL, the same model as our LCD 16x2 V3.0, wired as on the shield (D4 - D9).
• Five buttons on A0 as a real analog voltage: hold a button with the mouse, the sketch's analogRead(A0) reads it.
• Both shield versions: V1.0 (most clones) and V2.0 (DFR0374), with their own ladders and backlight circuits.
• The D10 overload warning: a red banner, a TEP LED and a log line when a sketch drives D10 HIGH on a V1.0 shield.
• A clickable contrast trimmer and a working RST button.
• A real shield on the schematic: the black board with our green LCD 16x2 board on top, the six buttons in their real places and silver switch bodies that stand out on the black board.
• Four devices in TEPLCDKEYPAD.LIB: blue and yellow-green LCD, each Simple and Advance.
• Four test tools on the Advance: Init check, Keypad (with buttons that press a key for you), Backlight D10 and Timing.
• A two-UNO demo on our Arduino UNO V4.0: one V1.0 and one V2.0 shield, a key tester, a menu, a counter and a stopwatch, and Serial commands.
• A compact package: about 1.37 MB, without the C++ source code.

The model file TEPLCD.DLL is shared with our other LCD libraries and runs their devices too (we re-ran their five demos on it). If you have them, keep this newer DLL. The keypad shield has its own LIB file, so our LCD Library for Proteus V3.0 stays as it is.

LCD Keypad Shield Simple vs LCD Keypad Shield Advance

All four devices share one model and the same shield. They differ in the LCD colour and in where you see the extras:

Pick a Simple shield when you want the key, the A0 value and the backlight state right on the schematic. Pick an Advance shield when the schematic is crowded, or when you want the bus log and the tools. Every device takes the SHIELD property: V1.0 or V2.0.

Download LCD Keypad Shield Library for Proteus

Click the button below to download LCD-Keypad-Shield-Library-for-Proteus-v1.0.zip (about 1.37 MB, without the C++ source code):

• README.txt: a detailed guide to the files, the wiring, the two versions, the test tools and real hardware.
• Proteus Library Files: TEPLCDKEYPAD.LIB (all four devices) and our Arduino library V4.0, ArduinoV4TEP.LIB, with the Arduino UNO V4.0 of the demo.
• Proteus Model Files: TEPLCD.DLL and TEPARDUINO.DLL.
• Proteus Simulation: LCD-Keypad-Shield-ArduinoUnoV4.pdsprj, LCD_Keypad_Demo.hex (both UNOs run it) and copies of both DLLs.
• Arduino Code: LCD_Keypad_Demo.ino, the demo sketch. It needs only Arduino's LiquidCrystal library, which comes with the Arduino IDE.

The Arduino files are the ones of our Arduino Library for Proteus V4.0, so if you have it installed, they are the same. No Proteus yet? Read How to Download and Install Proteus 7 and 8. New to libraries? Follow How to Install a New Library in Proteus.

How to Install LCD Keypad Shield Library for Proteus

1. Close Proteus and extract the whole zip file to a normal folder, for example your Desktop.
2. Copy the two files from Proteus Library Files into the LIBRARY folder, usually C:\Program Files (x86)\Labcenter Electronics\Proteus 8 Professional\LIBRARY (on some PCs C:\ProgramData\Labcenter Electronics\Proteus 8 Professional\LIBRARY; use the folder that already holds Proteus's own .LIB files).
3. Copy TEPLCD.DLL and TEPARDUINO.DLL from Proteus Model Files into the MODELS folder.
4. Delete TEPLCDKEYPAD.IDX from the LIBRARY folder if there is one; Proteus makes a new index.
5. Start Proteus, press P and search for LCDKEYPAD. You get the four devices.

Tip: the demo project needs the .hex file and the two DLLs beside it, so keep the Proteus Simulation folder together. The library was tested in Proteus 8.5; Proteus 7 is not supported.

The LCD Keypad Shield in Proteus

The part looks like the real shield: the black board, our green LCD 16x2 board on top, the blue trimmer in the top-left corner, the UNO's header rows at their real places and the six buttons in their two staggered rows. The Proteus pins sit where the real shield uses a pin: D4 - D10 on the top edge, RST, 5V, GND and A0 on the bottom edge. Here is LCD1, the blue Simple shield (a V1.0 shield), with UP held:

Pinout

The Board Up Close

Everything you see is drawn live by the model while the simulation runs: the glass with its backlight, the trimmer's slot turning with the contrast, the pressed button and the LEDs. The real shield has no LEDs; the PWR, CMD and DATA LEDs on the LCD and the KEY and D10 LEDs on the shield are our additions to help you see what happens.

LEDs and Indicators

Component Properties

Pressing the Buttons

Hold a button with the mouse: it stays pressed while the mouse button is down. The model puts that button's voltage on A0 within 10 ms, the switch gets a yellow ring, and the KEY LED lights. Let go, and A0 goes back to 5 V. Here is LEFT on the V1.0 shield:

The sketch shows the shield version it guesses from the values (UP 145 is a V1.0 shield, UP 208 a V2.0). The RST button works too: it holds the Arduino in reset while you hold it, and the UNO starts again when you let go.

The D10 Trap Made Visible

Our demo has a command to make the mistake on purpose: LIGHT HIGH makes D10 an OUTPUT and writes it HIGH. On LCD1, a V1.0 shield, the model reacts at once:

The simulation log gets a warning line too. Type LIGHT ON and the sketch switches the backlight the safe way again. On the V2.0 shield the same command is safe, and the Backlight D10 tool says so.

The Contrast Trimmer

Click the trimmer's left half (-) to turn the contrast down or its right half (+) to turn it up, 5 % a click; the voltage V0 is shown beside it. Too far one way and dark blocks appear behind the text, too far the other way and the text fades. Here it is at V0 0.00 V:

This is exactly what you see on a real shield when the trimmer is wrong, and it is the first thing to check when a real LCD stays blank.

LCD Keypad Shield Simple: The STATUS Panel

Under the Simple shield sits the STATUS panel (see the pictures above):

The red X in the panel's header closes it, and PANEL on the board opens it again.

LCD Keypad Shield Advance: The Pop-Up Window

The Advance shield keeps only the shield on the schematic. In the demo, LCD2 is a yellow-green Advance shield, the V2.0 version. Hold SELECT for a second and the demo opens its menu:

At Run, the "TEP LCD Keypad Shield Advance" pop-up opens with the look of our TEP Serial Monitor: move it by its header, resize or minimise it, and reopen it with OPEN PANEL. The header has the Display, Bus log and Tests tabs and the theme, Settings and Help icons.

The Display Page

The Display page shows a big copy of the glass, the controller's state, DDRAM and CGRAM, a card with 5V, the contrast, the backlight and the key, and the latest transfers. Its toolbar overrides the backlight (D10, On, Off) and the contrast (Trimmer, Auto).

The Bus Log Page

Every byte the LCD took, with the time, the gap to the previous byte, CMD or DATA, the meaning and the margin to the controller's busy time. Filters, Pause and Clear help you catch one moment.

The Tests Page: Four Test Tools

The tools read the model's own state while the simulation runs. Each has a bold "Good for:" line and a verdict per row: green is fine, amber means check, red means wrong. All the results below come from LCD2 in Proteus 8.5.

1. Init Check: Is the Start-Up Right?

Good for: "an LCD that stays blank or shows a row of blocks - is the sketch's lcd.begin() right?" The tool compares the start-up with the HD44780 datasheet: 66.3 ms after power-on, the wake-up function sets, 4-bit, 2 lines, display on, clear and entry mode, with no byte lost.

2. Keypad: Which Value Does Each Button Give?

Good for: "a key that reads wrong - each button's A0 value on this shield, and limits that work." The Press buttons hold a key for 0.3 s and Hold keeps it down until you click again, so you can test a sketch without the mouse on the board.

3. Backlight D10: Is the Backlight Switched Safely?

Good for: "a backlight that will not switch, or a V1.0 shield whose D10 is overloaded." On a V1.0 shield, OUTPUT HIGH and PWM are flagged as an overload. Under the rows, the tool shows the safe code that works on every version, and the D10 changes with their times.

4. Timing: Is the Sketch Too Fast for the LCD?

Good for: "lost characters or commands - every byte must wait for the previous one's busy time." The demo sent 18,681 bytes without one lost: LiquidCrystal waits long enough.

LCD Keypad Shield with Arduino in Proteus

Open LCD-Keypad-Shield-ArduinoUnoV4.pdsprj from the Proteus Simulation folder, with LCD_Keypad_Demo.hex and both DLLs beside it. The demo runs on two of our Arduino UNO V4.0 boards from the Arduino UNO Library for Proteus V4.0: working ON / L / TX / RX LEDs, a RESET button and a serial monitor built into the board. Both UNOs run the same HEX file:

• NODE 1 - SIMPLE: ARD1 with LCD1 (blue, Simple, SHIELD V1.0 - a clone).
• NODE 2 - ADVANCE: ARD2 with LCD2 (yellow-green, Advance, SHIELD V2.0 - DFR0374).

Wiring

On a real UNO the shield simply plugs in. In Proteus the shield is a part next to the UNO, and every pin reaches the UNO through a net label: terminals with the same name are connected. D4_1 at the shield meets D4_1 at ARD1's D4 pin, and node 2 has its own labels, so the two circuits stay apart. 5V goes to the VCC label and GND to the ground symbol, Proteus's power rails.

The serial monitor needs no wires: it is built into the UNO V4.0 on D0 / D1, like the USB chip of a real UNO (see our Introduction to Arduino UNO).

The Arduino Code

The demo sketch, LCD_Keypad_Demo V1.0, uses only Arduino's LiquidCrystal library. The LCD is created with the shield's pins:

LiquidCrystal lcd(8, 9, 4, 5, 6, 7);   // RS, E, D4, D5, D6, D7
const byte BACKLIGHT_PIN = 10;

The keys are read with limits half way between the values, so the same sketch reads both shield versions:

const int LIMIT[5] = {70, 268, 457, 683, 923};

Key readKey() {
  adc = analogRead(A0);
  for (byte k = 0; k < 5; k++)
    if (adc < LIMIT[k]) return (Key)k;
  return KEY_NONE;
}

Real buttons bounce, so the loop scans the keys every 5 ms and a new reading must hold for 30 ms before it counts:

  if (now - lastScan < 5) return;
  lastScan = now;
  Key k = readKey();
  if (k != lastRead) { lastRead = k; readSince = now; }
  if (k != stableKey && now - readSince >= 30) {

Holding SELECT for one second opens the menu:

    if (screen == HOME && stableKey == KEY_SELECT && !longDone && now - pressedAt >= 1000) { longDone = true; go(MENU); }

And the backlight is switched the safe way, on every shield version:

void setLight(bool on) {
  lightOn = on;
  digitalWrite(BACKLIGHT_PIN, LOW);
  pinMode(BACKLIGHT_PIN, on ? INPUT : OUTPUT);
}

Only the LIGHT HIGH command does it the wrong way, to show the warning:

      pinMode(BACKLIGHT_PIN, OUTPUT);
      digitalWrite(BACKLIGHT_PIN, HIGH);

The sketch also guesses the shield version from the values the keys gave:

    if (abs(seen[k] - V1[k]) < abs(seen[k] - V2[k])) v1++; else v2++;

To change the sketch, export a new HEX file and load it into both UNOs; see How to get the HEX file from Arduino. New to Arduino? Start with our Arduino Tutorial for Beginners.

The Demo Screens and Commands

How to Run the Demo

1. Press Run. Both UNOs' monitor windows and LCD2's pop-up open; move them aside. The LCDs show "LCD Keypad V1.0", then the key tester.
2. Hold the buttons of LCD1 with the mouse and watch the values (V1.0); press LCD2's keys from its Keypad tool (V2.0).
3. Hold SELECT for a second for the menu; try the counter and the stopwatch.
4. Type LIGHT HIGH in ARD1's monitor to see the D10 warning, then LIGHT ON.
5. Click the trimmer halves, the panel's buttons and RST.

LCD Keypad Shield Proteus Simulation Results

Each Arduino UNO V4.0 carries its own copy of our TEP Serial Monitor Advance. Its window, "TEP Arduino UNO - ARD1", opens at Run, and a click on the board's USB port opens it again. The screenshots show its Simple interface (Ctrl+Shift+U, or the monitor's ... menu; Esc goes back to the full view). Read all about the monitor in TEP Serial Monitor Advance for Proteus.

ARD1: The V1.0 Shield

Key RIGHT (A0 = 0)
Key DOWN (A0 = 330)
Key LEFT (A0 = 506)
Key SELECT (A0 = 742)
Key UP (A0 = 145)
KEYS
RIGHT: 0
UP: 145
DOWN: 330
LEFT: 506
SELECT: 742
Shield: V1.0

ARD2: The V2.0 Shield

Key SELECT (A0 = 824)
KEYS
RIGHT: 0
UP: 208
DOWN: 409
LEFT: 625
SELECT: 824
Shield: V2.0
Key LEFT (A0 = 625)

The Backlight Commands

LIGHT HIGH
D10 = OUTPUT HIGH - over 100 mA on a real V1.0 shield!
Type LIGHT ON to switch it the safe way
LIGHT OFF
OK - backlight off (D10 = OUTPUT LOW)
LIGHT ON
OK - backlight on (D10 = INPUT)

Troubleshooting

• A key reads as another key: the sketch's limits do not fit the shield. Look at the Keypad tool or the panel's A0 readout and use limits half way between the values.
• No key works: A0 is not wired, or 5V / GND. With no key the panel's A0 readout says 5.00 V = 1023.
• D10 OVERLOAD: the sketch drives D10 HIGH or uses analogWrite on a V1.0 shield. Switch the backlight with pinMode() instead.
• The backlight never goes off: D10 must be an OUTPUT written LOW; INPUT means on.
• A row of blocks: the LCD was not initialised. Check LiquidCrystal lcd(8, 9, 4, 5, 6, 7) and the D4 - D9 labels.
• Faint characters or dark blocks: the contrast. Click the trimmer, or set CONTRAST AUTO.
• The part or the UNO is not simulated, or no monitor window: TEPLCD.DLL or TEPARDUINO.DLL is missing from MODELS and the project folder; a closed monitor opens again with a click on the UNO's USB port.
• The Advance pop-up does not appear: click OPEN PANEL on the shield, or turn "Open the panel at Run" back on in Settings.

Things to Know Before Using a Real LCD Keypad Shield

The demo sketch uses only LiquidCrystal and Serial, so it runs on a real UNO and shield too. Keep in mind:

• Never drive D10 HIGH on a clone: most shields are V1.0. Use the pinMode() way, or add a 470 ohm resistor in series with the transistor's base.
• Read your own values: run the demo's key tester, or a sketch that prints analogRead(A0), and use limits between the values.
• Debounce: scan the keys every few milliseconds and wait for a steady reading.
• The pins are taken: D4 - D10 and A0 belong to the shield; A1 - A5, D0 - D3 and D11 - D13 stay free.
• Contrast first: a blank LCD is usually the trimmer.

Limitations of the Simulation

• Not modelled: the overload's real current or damage (the model warns, the pin does not fail), switch bounce (the buttons are clean, but a sketch should still debounce), two keys at once, the 5x10 font on the glass and the shield's pass-through pins.
• The board is drawn 61 mm tall instead of 58 mm so the parts get room; the LEDs, the yellow ring and the V0 readout are TEP additions.
• The model is our own implementation, written from the HD44780 datasheet and the shields' published schematics. This library is not made or endorsed by DFRobot, Hitachi, Arduino or Labcenter.
• Licences: the demo sketch uses Arduino's LiquidCrystal 1.0.7; the HEX file contains it and the Arduino AVR core 1.8.6, which include LGPL-licensed code; their source code is on GitHub.
• Tested in Proteus 8.5 in October 2026 (the demo as shipped on two Arduino UNO V4.0 boards: every key with the mouse and from the pop-up, both versions, the menu, the D10 warning, the trimmer, the panel, RST, the pop-up and the four tools; about 0.63 x real time with the pop-up and both monitors open; our five earlier LCD demos re-run on the same DLL) and with automatic PC checks, 0 failed: 55 with the real demo sketch and Arduino's LiquidCrystal against the model, 7,202 on the HD44780 controller, 47 on the pop-up pages and the demo project read back from disk. Proteus 7 is not supported.

So, that was all about the LCD Keypad Shield Library for Proteus V1.0. I hope the buttons on A0, the two shield versions and the D10 warning make the keypad shield easy to understand, so your sketch works the first time you plug in a real one. If you use the LCD Keypad Shield Library for Proteus in a project, please share your feedback in the comments or in our forum, and if you have any questions, ask in the comments and I will help you out. Till the next tutorial, take care and have fun!