Some links in this post may be affiliate links. We may get paid if you buy something or take an action after clicking one of these, but without addictional costs for you compared to direct buying.
How to Use 1602 LCD with Raspberry PI: Controlling a Display
The Liquid Cristal Display (LCD) device includes a variable number of text lines and columns. When you power on the display, you can see the text “boxes”, each allowing you to show a single character. This display model is common for DIY projects as it lets you show any text with a low-cost device.
There are different versions of this display in the market, but most of them are based on the Hitachi HD44780. You can find the producer datasheet at the following link: hitachi-hd44780-datasheet.pdf. This display comes with the characters already saved in their memory, so you don’t have to create the main characters from a binary array. Nevertheless, the HD44780 also allows you to create your custom characters and save them into a specific memory area (up to 8 custom characters).
The base version has 16 PINs and you must connect these ports (quite all) to your Raspberry PI to control them. These PINS are in the top-right side of the picture shown below:
This model requires to manage the timing and the data to transmit as described in the datasheet.
With time, many producers started to add a chip on the back of this display to make it simpler to interface and control them from an I2C interface. Adafruit, for example, added the MCP23008 chip that we’ll identify in the next paragraphs as it shows you a 0x20 i2c address. Other 1602 display versions are based on the MCP23017, which shows you a 0x27 i2c address. Moreover, the backpack added to the display usually brings you a potentiometer to adjust the screen contrast with a screwdriver. These LCD models appear on the back side as shown in the following picture:
This tutorial will show you how to use the version with the I2C backpack.
What We Need
As usual, I suggest adding from now to your favourite e-commerce shopping cart all the needed hardware, so that at the end you will be able to evaluate overall costs and decide if to continue with the project or remove them from the shopping cart. So, hardware will be only:
Please connect the 1602 i2c display to the Raspberry PI as shown in the following picture, according to the Raspberry PI Pinout:
Please find below some pictures from my lab. I used an i2c 1602 LCD display with connectors for a base shield, but I wired them with 4 Dupont wires to show you how to arrange the connections:
Prepare the Raspberry PI Operating System
The first step is installing the Raspberry PI OS Lite (I suggest the 64-bit version, for boards supporting it) to get a fast and light operating system (headless). If you need a desktop environment, you can also use the Raspberry PI OS Desktop, in this case working from its terminal app. Please find the differences between the 2 OS versions in my Raspberry PI OS Lite vs Desktop article.
Please make sure that your OS is up to date. From your terminal, use the following command::
We also need to enable the I2C interface in our Raspberry PI from the raspi-config tool. Please use the following command to enter in it:
sudo raspi-config
From the raspi-config home page, please select the “Interface Options” selection:
The identify and select the “I2C” option:
Move the cursor to “YES” to enable the interface:
In the following screen, please confirm the interface enabled message:
Finally, back to the raspi-config home screen, please select “Finish”:
At the end, I suggest to reboot your Raspberry PI to have the I2C interface enabled:
sudo reboot
With the i2cdetect command, we can check that everything is running correctly. In the following command, the -y disables interactive mode and the 1 specifies the I2C bus.
Please note the detected address: “20”, which means 0x20 (binary number expressed in decimals). Please note that this tutorial could not work if you find a different address.
Install the Adafruit Charlcd Package
With the latest Python versions, we must use virtual environments with Raspberry PI to install external libraries (please refer to the link for a complete guide). So, let’s create our virtual environment (I named it “my_project, but you can give it whatever name:
python3 -m venv my_project --system-site-packages
Let’s activate the virtual environment:
source ./my_project/bin/activate
Please note that you must activate the environment every time you use the libraries installed in it if you deactivate the environment and/or reboot your Raspberry PI.
Let’s install the Adafruit library needed to manage our LCD display:
pip3 install adafruit-circuitpython-charlcd
Test the 1602 LCD with Raspberry PI
Please note that you must have the virtual environment active before running these tests.
Let’s prepare our first test, a simple “Hello world” message from peppe8o. You can download the script from my download area in your Raspberry PI:
Looking at this code, we find the initial lines which import the required libraries:
import board
import busio
import adafruit_character_lcd.character_lcd_i2c as character_lcd
Then the LCD initialization comes. Here, the code initializes the i2c communication object. Then the code sets the number of columns and rows according to the LCD model. If you have more columns and rows in your display, please set it here.
Then script creates the “lcd” object that we’ll use to control the display:
The previous part should be included in every script. The following part will show you some usage examples and will vary in the following examples.
In this example, we’ll use the following LCD commands:
lcd.message = “text”: this command will print on the display any character text you will put in the brackets;
lcd.cursor_position(column,row) [“column” and “row” are integer numbers]: this command will position the cursor at the specified coordinates. Please note that both row and column numbering start from 0;
lcd.clear(): it clears the display, cleaning all the previously printed text;
lcd.backlight = False [or True]: this command disables or enables the display backlight.
In the “try” section, the script will print a “Hello world by peppe8o.com!” message divided into 2 lines. Here we’re manually positioning the cursor on the second line with the “lcd.cursor_position” command. Anyway, please note that the display will automatically split the message at the end of the first line.
Another way to move to a new line is by using the special character “\n” in your text string. This character (with the “\” escape symbol) equals to a carriage return.
The final “except” section will manage any occurring interrupt (CTRL+C) from the user, closing the program with a cleaning of the display and powering off the backlight.
You can run this example with the following command:
python3 i2c-lcd-test-01-hello-world.py
The following picture shows the result:
Test 2: Blinking the Cursor
In this test we’ll add the following command:
lcd.blink = True [or False]: this command will make the cursor blinking
For this test, you can download the following script:
The last test in this tutorial will show you how to create custom characters. As said at the beginning of this tutorial, the LCD Display allows us to create custom characters and save them into 8 memory positions (with the ID from 0 to 7).
Our new command is:
lcd.create_char(mem_id, char_array) [where “mem_id” is an integer number between 0 and 7, and “char_array” is a list object with hexadecimal values]: this command allows you to create and save custom characters in the display memory
Before starting to see the code, please note that every “text box” of our display is a combination of 5 x 8 light points. By using the https://www.quinapalus.com/hd44780udg.html web page, once you are sure that you selected the 5 by 8 character selection, you can compose any image clicking one by one the single points or choosing the available templates. It will return the related value in hex:
So, for the selected hourglass image the related array to use for displaying in the LCD is [0x1f,0x11,0xa,0x4,0xe,0x1f,0x1f,0x0].
Finally, you can show them by using the lcd.message command with the “\x” escape string, followed by the memory position of your custom character. The example in my script shows you how to print all of my custom characters:
lcd.message = "\x00 \x01 \x02 \x03 "
Please run the script with the following command:
python3 i2c-lcd-test-06-custom.py
And you will have the following result:
What’s Next
Want to know more about cool projects to do with Raspberry PI computer boards? In this case, the right resource for you is my Raspberry PI tutorials pages.
Enjoy the 1602 LCD with Raspberry PI!
How useful was this post?
Click on a star to rate it anonymously!
Average rating 0 / 5. Vote count: 0
No votes so far! Be the first to rate this post.
We are sorry that this post was not useful for you!
