Arduino I2C Lcd Connection | Arduino Code

Wiring Diagram

This image is created using Fritzing. Click to enlarge image

LCD I2C	Arduino Uno, Nano	Arduino Mega
Vin	5V	5V
GND	GND	GND
SDA	A4	20
SCL	A5	21

How To Program For LCD I2C

Thanks to the LiquidCrystal_I2C library, the using LCD is a piece of cake.

• Include the library:

• Declare a LiquidCrystal_I2C object with I2C address, the number of columns, the number of rows:

• Initialize the LCD.

• Move cursor to the desired position (column_index, row_index)

• Print a message to the LCD.

There are many things more that we can do with LCD (see Do More with LCD part)

※ NOTE THAT:

The I2C address of LCD can vary according to the manufacturers. In the code, we used 0x27 that is specified by DIYables manufacturer

Giao tiếp I2C LCD Arduino

Module I2C LCD 16×2	Arduino UNO
GND	GND
VCC	5V
SDA	A4/SDA
SCL	A5/SCL

Sơ đồ đấu nối

Các linh kiện cần thiết cho dự án:

Tên linh kiện	Số lượng	Shopee
Arduino UNO R3	Mua ngay
Dây cáp nạp	Mua ngay
Màn hình LCD 16×2	Mua ngay
Module I2C LCD 16×2	Mua ngay
Dây cắm (Đực – Cái)	Mua ngay

Bạn sẽ học được gì

• Có kiến thức cơ bản về Robotics

• Chế tạo Robot dò đường thông minh

• Đánh thức nhà khoa học bên trong bạn

• Tìm hiểu thêm về Robotics, các thuật toán Robot tự động

• Kiến thức nền tảng để chế tạo các máy móc tự động phục vụ đời sống sinh hoạt, lao động sản xuất

• Kiến thức để chế tạo sản phẩm, tham gia các cuộc thi khoa học công nghệ trong nước và quốc tế

I2C LCD Custom Character

As you see in the above section the character in a Liquid crystal display is built using a grid of 5×8 small pixels. You can individually turn on and off any pixel and make your own custom character. The custom character data is stored in the CGRAM of the display.

CGROM and CGROM

Displays that use the Hitachi HD44780 controller have two types of memories – CGROM and CGRAM (Character Generator ROM & RAM). CGROM is non-volatile means it can’t be modified whereas CGRAM is volatile so it can be modified at any time.

CGROM stored all permanent fonts that can be displayed by using their ASCII code. For example, the character ‘A’ can be written using write(65) or write(0x41).

CGRAM is used for storing user-defined characters. The Hitachi HD44780 controller has a CGROM of 64 bytes. So for a 5×8 pixel-based LCD, up to 8 user-defined characters can be stored in the CGRAM. And for a 5×10 pixel-based LCD, only 4 user-defined characters can be stored.

To print a custom character, you need to make the byte code for that character first. Creating a byte code for a custom character is very simple. You need to go through row-wise and write “1” if you need to turn on a pixel and write “0” if you need to turn off a pixel. Then go to the next row and do the same. Do it for all eight rows.

So for example, If I want to create a custom character for a smiley like below –

When you go through row-wise and follow the above instructions you will get numbers like this –


00000, 10001, 00000, 00000, 10001, 01110, 00000, 00000,


Now simply place a “B” before every row and this would be the byte code for that character.


B00000, B10001, B00000, B00000, B10001, B01110, B00000, B00000,


You can store that data in an array like this –


byte smiley[] = {B00000, B10001, B00000, B00000, B10001, B01110, B00000, B00000}


You can convert the binary value to hexadecimal and use it like this –


byte smiley[] = {0x0, 0x11, 0x0 , 0x0, 0x11, 0xE, 0x0, 0x0}


There are some online and offline tools available to visually draw the custom character and it will automatically generate the byte code for you. I suggest you use the online LCD Character Creator tools.

Now in the below sketch, I will use that bite code to print the custom character on the LCD. Upload the below code to your Arduino board and see what the display looks like.

PS:- Don’t forget to change the I2C address and dimension of the display in the below sketch.

Arduino Code


#include // Set the LCD address and dimension LiquidCrystal_I2C lcd(0x27, 16, 2); // Create a custom character: byte smiley[] = { B00000, B10001, B00000, B00000, B10001, B01110, B00000, B00000, }; void setup() { lcd.init(); lcd.clear(); lcd.backlight(); // Turns on backlight // Create a new characters: lcd.createChar(0, smiley); } void loop() { // Print all the custom characters: lcd.setCursor(0, 0); lcd.write(0); }

Explaining the Code

Here you can see that I include the

LiquidCrystal_I2C

library first. Then I create a

LiquidCrystal_I2C

variable for my LCD using the I2C address and dimension of my LCD. I am using an array

smiley[]

to store the bit data for the custom character.

In the setup section, I create a custom character from that byte array using the

createChar()

function. It needs two parameters – a number between 0 – 7 to reserve a space in the CGRAM for the custom character and the name of the byte array.

Then in the loop section, I use the

write()

function to display custom characters. This function needs the character number as an argument.

In the below example, I will print eight different custom characters on the LCD.


#include LiquidCrystal_I2C lcd = LiquidCrystal_I2C(0x27, 16, 2); // Make custom characters: byte smiley[8] = {B00000, B10001, B00000, B00000, B10001, B01110, B00000, B00000}; byte man[8] = {B00000, B01110, B10001, B01110, B00100, B11111, B00100, B11011}; byte music[8] = {B00001, B00011, B00101, B01001, B01001, B01011, B11011, B11000}; byte heart[8] = {B00000, B01010, B11111, B11111, B01110, B00100, B00000, B00000}; byte speaker[8] = {B00001, B00011, B01111, B01111, B01111, B00011, B00001, B00000}; byte bell[8] = {0x00, 0x04, 0x0E, 0x0E, 0x0E, 0x1F, 0x04, 0x00}; byte pie[8] = {0x00, 0x1F, 0x0A, 0x0A, 0x0A, 0x13, 0x00, 0x00}; byte ohm[8] = {0x00, 0x0E, 0x11, 0x11, 0x0A, 0x1B, 0x00, 0x00}; void setup() { lcd.init(); lcd.backlight(); // Create a new characters: lcd.createChar(0, smiley); lcd.createChar(1, man); lcd.createChar(2, music); lcd.createChar(3, heart); lcd.createChar(4, speaker); lcd.createChar(5, bell); lcd.createChar(6, pie); lcd.createChar(7, ohm); // Clears the LCD screen: lcd.clear(); lcd.setCursor(0, 0); lcd.print("Custom Caracter"); } void loop() { // Print all the custom characters: lcd.setCursor(0, 1); lcd.write(byte(0)); lcd.setCursor(2, 1); lcd.write(byte(1)); lcd.setCursor(4, 1); lcd.write(byte(2)); lcd.setCursor(6, 1); lcd.write(byte(3)); lcd.setCursor(8, 1); lcd.write(byte(4)); lcd.setCursor(10, 1); lcd.write(byte(5)); lcd.setCursor(12, 1); lcd.write(byte(6)); lcd.setCursor(14, 1); lcd.write(byte(7)); }

Arduino – LCD I2C

In this Arduino LCD I2C tutorial, we will learn how to connect an LCD I2C (Liquid Crystal Display) to the Arduino board. LCDs are very popular and widely used in electronics projects for displaying information. There are many types of LCD. This tutorial takes LCD 16×2 (16 columns and 2 rows) as an example. The other LCDs are similar.

Wiring an I2C LCD Display to an Arduino

Connecting an I2C LCD is much simpler than connecting a standard LCD. You only need to connect four pins.

Begin by connecting the VCC pin to the Arduino’s 5V output and the GND pin to ground.

Now we are left with the pins that are used for I2C communication. Note that each Arduino board has different I2C pins that must be connected correctly. On Arduino boards with the R3 layout, the SDA (data line) and SCL (clock line) are on the pin headers close to the AREF pin. They are also referred to as A5 (SCL) and A4 (SDA).

The following table lists the pin connections:

I2C LCD	Arduino
VCC	5V
GND	GND
SCL	SCL or A5
SDA	SDA or A4

The diagram below shows how to connect everything.

Do More with LCD

Custom Character

lcd.print() function supports only ASCII characters. If you want to display a special character or symbol (e.g. heart, angry bird), you need to use the below character generator.

LCD 16×2 can display 32 characters (2 rows and 16 columns). Each character is composed of 40 pixels (8 rows and 5 columns).

The character generator represents a character (40 pixels). You just need to do the following steps:

Result on LCD:

Multiple custom characters

We can create up to 8 custom characters (indexed 0 to 7). The below example creates and displays three characters.

Result on LCD:

Summary: how to use custom character on LCD

• Use the above character generator to create binary code for the custom character.
• Declare the binary code for the custom character (copy from above step)

• Create custom character and assign to an index value (from 0 to 7) in setup() function

• Print the custom character in LCD anytime, anywhere (in setup() or loop() function)

Other functions

Add the below functions into loop() function one by one. And add delay(5000) after each function

• Clear LCD screen

• Move the cursor to the upper-left of the LCD

• Move the cursor to the a position (column, row)

• Display the LCD cursor

• Hides the LCD cursor.

• Display the blinking LCD cursor

• Turns off the blinking LCD cursor.

• And more at LiquidCrystal Library Reference

Arduino I2C LCD – Print a Simple Text

Printing text on the LCD is very simple. The below sketch will print some text on the display. But before uploading this sketch you need to make some minor changes according to your display size and address.

In the second line, I created a

LiquidCrystal_I2C

variable. It requires three variables – the I2C address of the LCD and the dimension of the LCD (columns and rows of the display). The I2C address of my display is

0x27

and it has 16 columns and 2 rows. So I will use –

LiquidCrystal_I2C lcd(0x27,16,2)

. If you have a different LCD display change the I2C address and dimension accordingly.

Now the sketch is ready for your display. Upload it to your Arduino board and see the output.

Code to Print a Simple Text


#include LiquidCrystal_I2C lcd(0x27,16,2); void setup() { lcd.init(); lcd.clear(); lcd.backlight(); lcd.setCursor(2,0); lcd.print("Hello world!"); lcd.setCursor(2,1); lcd.print("LCD Tutorial"); } void loop() {}

Explaining the Code

The sketch is very simple. It begins with including the

LiquidCrystal_I2C

header file –

#include LiquidCrystal_I2C.h>

Then you need to define a

LiquidCrystal_I2C

variable for your LCD. It requires three variables – the I2C address of the LCD and the dimension of the LCD (columns and rows of the display).

Then in the setup section, you have to initialize the display using the

init()

function. The

clear()

function will clear the display buffer. It is good to clear the display buffer before printing anything on the display so that it does not display anything that was previously stored in the display buffer.


backlight()

– this will turn on the display backlight.


setCursor(col, row)

– this will set the cursor to a position from where the text and characters will print. This function requires two variables – columns, and rows.One thing to note here is that columns and rows counting start from the top left corner and it starts with (0, 0).


print()

– this will print text and characters on the display.

Now you can understand that first I set the cursor to the third column of the first row and printed some text there.


lcd.setCursor(2,0); lcd.print("Hello world!");


Then I set the cursor to the third column of the second row and print some text there.


lcd.setCursor(2,1); lcd.print("LCD Tutorial");


For this example, we don’t have to use the loop section, so leave it blank.

Lời kết

Qua bài hôm nay các bạn biết cách làm thế nào để hiển thị các ký tự và chuỗi ký tự lên LCD 16×2 và biết cách giao tiếp I2C.

Để nhận được nhiều kiến thức mới các bạn Đăng ký để nhận được thông báo sớm nhất.

Tham gia Cộng đồng Arduino KIT để cùng nhau thảo luận và chia sẽ kiến thức về lập trình Arduino.

Nếu các bạn thấy bài viết bổ ích nhớ Like và Share cho mọi người cùng đọc nhé.

Chúc các bạn thành công.

Trân trọng.

Giới thiệu LCD 16×2

Thông số kỹ thuật LCD 16×2

LCD 16×2 được sử dụng để hiển thị trạng thái hoặc các thông số.

• LCD 16×2 có 16 chân trong đó 8 chân dữ liệu (D0 – D7) và 3 chân điều khiển (RS, RW, EN).
• 5 chân còn lại dùng để cấp nguồn và đèn nền cho LCD 16×2.
• Các chân điều khiển giúp ta dễ dàng cấu hình LCD ở chế độ lệnh hoặc chế độ dữ liệu.
• Chúng còn giúp ta cấu hình ở chế độ đọc hoặc ghi.

LCD 16×2 có thể sử dụng ở chế độ 4 bit hoặc 8 bit tùy theo ứng dụng ta đang làm.

Step 5: Complete Video Tutorial

If you want to learn C Programming you can easily learn at codingtute. It will enhance your arduino programming skills.

Don’t forget subscribe my YouTube Channel

Check out my website Electronics Projects Hub

Step 6: Print characters in LCD.

• Here is the example code to display characters in LCD display.

Arduino code:

Hardware Overview

A typical I2C LCD display consists of an HD44780-based character LCD display and an I2C LCD adapter. Let’s learn more about them.

Character LCD Display

As the name suggests, these LCDs are ideal for displaying only characters. A 16×2 character LCD, for example, can display 32 ASCII characters across two rows.

If you look closely, you can see tiny rectangles for each character on the screen as well as the pixels that make up a character. Each of these rectangles is a grid of 5×8 pixels.

Please refer to our in-depth guide for more information about character LCD displays.

I2C LCD Adapter

At the heart of the adapter is an 8-bit I/O expander chip – PCF8574. This chip converts the I2C data from an Arduino into the parallel data required for an LCD display.

The board also includes a tiny trimpot for making precise adjustments to the display’s contrast.

There is a jumper on the board that provides power to the backlight. To control the intensity of the backlight, you can remove the jumper and apply external voltage to the header pin labeled ‘LED’.

I2C LCD Overview

An I2C LCD display consists of a classic parallel LCD and an I2C LCD adapter. The I2C LCD adapter is soldered from the back of the LCD.

If you already have an LCD you can only purchase the I2C LCD adapter and solder it by yourself.

Now let’s have a look at the LCD display and the I2C LCD adapter in detail.

Liquid Crystal Display (LCD)

Commonly available LCD displays with I2C LCD adapters are 16×2 and 20×4 character LCD displays. They both have a total of 16 pins including 8 parallel data pins. So if you don’t use an I2C LCD you will need at least 6 digital I/O pins on the Arduino to display something.

If you look closely you will find that the characters of the LCD are built using a grid of 5×8 pixels. Later in this tutorial, you will learn how to turn on and off any individual pixels to make custom characters.

You can read more about the LCD display in my Arduino LCD tutorial.

I2C LCD Adapter Overview

At the center of this adapter, there is an 8-bit I/O expander chip – PCF8574. It takes the I2C data from the MCU (Arduino) and converts it into serial data required for an LCD display. On one side the I2C LCD adapter has four pins that can be connected to Arduino or any microcontroller that supports the I2C communication protocol. On another side, it has 16 pins that are connected to the LCD display.

There are two header pins to control the backlight of the LCD display. One pin supplies a 5v power and another pin is for the backlight LED. These two pins are connected together by default. So the backlight will be always on. You can remove the jumper to turn off the backlight LED or you can use a potentiometer in between these two pins to control the intensity of the backlight LED.

The I2C LCD adapter also has a small trim pot to adjust the contrast of the display.

How to Change the Default I2C Address

Some I2C LCD adapters come with PCF8574, while others use PCF8574A chips. Each of these chips has its own I2C address. The PCF8574 chip from NXP Semiconductor uses 0x27 while the PCF8574A chip uses 0x3F.

Sometimes you need to change this default I2C address for a project where you use multiple I2C devices on the same I2C bus So that it does not conflict with other I2C devices.

If you use multiple I2C devices on the same I2C bus, sometimes you need to change this default I2C address to avoid conflict with other I2C devices.

To change the default address it has address selection pads – A0, A1, and A2.

Each of these pads has a ground connection above it. By default, each of these pins is connected to VDD or a positive power supply. You can change the address by connecting any pin to the ground pin above it. You can make any possible combination and you will get a different address. From three address pins, you can get 23 different combinations means 8 different addresses.

If you go through the datasheet of PCF8574 by NXP, you will find that PCF8574 and PCF8574A use a 7-bit I2C address. The first four-bit is fixed and the last three-bit is hardware selectable.

As you read above A0, A2, and A3 are connected to the positive power supply by default. So the default address of PCF8574 is 0100111 in binary or 0x27 in hex. If you connect the A0 pin to the ground pin it will become logic LOW. The address will change to 0100110 in binary or 0x26 in hex.

See the illustration below to find all the possible connections and the hex addresses.

In the same way, you can change the address of a PCF8575A chip. But keep in mind that the first four bits of the PCF8575 are 0100 and the first four bits of the PCF8575A are 0111. Calculate the address according to it.

I2C Address of LCD

If you have multiple devices on the same I2C bus, you may need to set a different I2C address for the LCD adapter to avoid conflicting with another I2C device.

For this purpose, the adapter comes with three solder jumpers/pads (A0, A1, and A2). The address is set when a jumper is shorted with a blob of solder.

An important point to note here is that several companies, including Texas Instruments and NXP Semiconductors, manufacture the same PCF8574 chip. And the I2C address of your LCD depends on the chip manufacturer.

If your LCD has Texas Instruments’ PCF8574 chip:

According to the Texas Instruments’ datasheet, the three address selection bits (A0, A1, and A2) are located at the end of the 7-bit I2C address register.

Because there are three address inputs that can take on two states, either HIGH or LOW, eight (2^3) different combinations (addresses) are possible.

All three address inputs are pulled HIGH using onboard pullups. This gives the PCF8574 a default I2C address of 0x27.

When you short a solder jumper, you pull that address input LOW. If you were to short all three jumpers, the address would be 0x20. So the range of all possible addresses spans from 0x20 to 0x27.

You can set a different I2C address, according to the table below.

If your LCD has NXP’s PCF8574 chip:

According to the NXP Semiconductors’ datasheet, the three address selection bits (A0, A1, and A2) are located at the end of the 7-bit I2C address register. However, the remaining bits in the address register are different.

Because there are three address inputs that can take on two states, either HIGH or LOW, eight (2^3) different combinations (addresses) are possible.

All three address inputs are pulled HIGH using onboard pullups. This gives the PCF8574 a default I2C address of 0x3F.

When you short a solder jumper, you pull that address input LOW. If you were to short all three jumpers, the address would be 0x38. So the range of all possible addresses spans from 0x38 to 0x3F.

You can set a different I2C address, according to the table below.

So the I2C address of your LCD is most likely 0x27 or 0x3F. If you’re not sure what your LCD’s I2C address is, there’s an easy way to figure it out. You’ll learn about that later in this tutorial.

Các lỗi thường gặp khi sử dụng I2C LCD

• Hiển thị một dãy ô vuông.
• Màn hình chỉ in ra một ký tự đầu.
• Màn hình nhấp nháy.

Các lỗi này chủ yếu là do sai địa chỉ bus, để fix lỗi các bạn thay địa chỉ mặc định là “0x27” thành “0x3F.

Trong trường hợp vẫn không được các bạn fix lỗi bằng cách nạp code tìm địa chỉ bus của I2C.

Sau khi tìm xong các bạn thay địa chỉ vừa tìm được vào vị trí “0x27” là xong.

• Các bạn có thể tải code tìm địa chỉ bus ở đây. Tải ngay.

Determining the I2C Address

As previously stated, the I2C address of your LCD depends on the manufacturer. If your LCD has a PCF8574 chip from Texas Instruments, its I2C address is 0x27; if it has a PCF8574 chip from NXP Semiconductors, its I2C address is 0x3F.

If you’re not sure what your LCD’s I2C address is, you can run a simple I2C scanner sketch that scans your I2C bus and returns the address of each I2C device it finds.

You can find this sketch under File > Examples > Wire > i2c_scanner.

Load the i2c_scanner sketch into your Arduino IDE.


#include

void setup() { Wire.begin(); Serial.begin(9600); while (!Serial); // Leonardo: wait for serial monitor Serial.println("\nI2C Scanner"); } void loop() { int nDevices = 0; Serial.println("Scanning..."); for (byte address = 1; address < 127; ++address) { // The i2c_scanner uses the return value of // the Write.endTransmisstion to see if // a device did acknowledge to the address. Wire.beginTransmission(address); byte error = Wire.endTransmission(); if (error == 0) { Serial.print("I2C device found at address 0x"); if (address < 16) { Serial.print("0"); } Serial.print(address, HEX); Serial.println(" !"); ++nDevices; } else if (error == 4) { Serial.print("Unknown error at address 0x"); if (address < 16) { Serial.print("0"); } Serial.println(address, HEX); } } if (nDevices == 0) { Serial.println("No I2C devices found\n"); } else { Serial.println("done\n"); } delay(5000); // Wait 5 seconds for next scan }



After you’ve uploaded the sketch, launch the serial monitor at 9600 baud. You should see the I2C address of your I2C LCD display.

Please make a note of this address. You’ll need it in later examples.

Parts required for this Tutorial

SL.	Preview	Name	Link
Arduino Uno R3	Amazon | Aliexpress
I2C LCD	Amazon | Aliexpress
Jumper Wires	Amazon | Aliexpress

Adjusting The LCD Contrast

After wiring the LCD, you will need to adjust the contrast of the LCD. On the I2C module, there is a potentiometer that can be rotated with a small screwdriver.

Now, turn on the Arduino. You will see the backlight light up. As you turn the potentiometer knob, the first row of rectangles will appear. If you have made it this far, Congratulations! Your LCD is functioning properly.

Step 3: Code

We must require to include two libraries ,in order to work the code attached .

Download the libraries from the attachment LCD library .

Basic functions we use in code

lcd.begin(16,2); //Defining 16 columns and 2 rows of lcd display

lcd.backlight(); //To Power ON /OFF the back light

lcd.setCursor(0,0); //Defining positon to write from first row,first column .

lcd.setCursor(0,1); //Defining positon to write from second row,first column .

lcd.print(” write here to print”); //You can write 16 Characters per line within quotations.

lcd.clear(); //Clean the screen

Keywords searched by users: arduino i2c lcd connection

Categories: Khám phá 27 Arduino I2C Lcd Connection

See more here: kientrucannam.vn

See more: https://kientrucannam.vn/vn/