Lcd Display 16X2 Arduino Code | Code Màn Hình Lcd 16×2 Arduino

Code màn hình LCD 16×2 Arduino

// include the library code: #include // Creates an LCD object. Parameters: (rs, enable, d4, d5, d6, d7) LiquidCrystal lcd(12, 11, 5, 4, 3, 2); void setup() { // set up the LCD’s number of columns and rows: lcd.begin(16, 2); // Clears the LCD screen lcd.clear(); } void loop() { // Print a message to the LCD. lcd.print(” Hello world!”); // set the cursor to column 0, line 1 // (note: line 1 is the second row, since counting begins with 0): lcd.setCursor(0, 1); // Print a message to the LCD. lcd.print(” LCD Tutorial”); }

Giải thích code

// include the library code: #include

Khai báo để sử dụng thư viện LiquidCrystal, cho phép tương tác với màn hình LCD 16×2.

// Creates an LCD object. Parameters: (rs, enable, d4, d5, d6, d7) LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
khởi tạo đối tượng lcd từ lớp LiquidCrystal. Các tham số truyền vào định nghĩa các chân kết nối giữa Arduino và màn hình LCD. Cụ thể, chân RS (Register Select) của LCD được kết nối với chân 12 của Arduino, chân Enable được kết nối với chân 11, các chân dữ liệu D4 đến D7 được kết nối tương ứng với chân 5, 4, 3, 2 của Arduino.

// set up the LCD’s number of columns and rows: lcd.begin(16, 2); // Clears the LCD screen lcd.clear();

lcd.begin(16, 2);
Thiết lập số cột và số hàng của màn hình LCD 16×2. Trong trường hợp này, màn hình LCD có 16 cột và 2 hàng.

lcd.clear();
Xóa nội dung trên màn hình LCD Arduino.

// Print a message to the LCD. lcd.print(” Hello world!”);

lcd.print(" Hello world!");
Hiển thị chuỗi “Hello world!” lên màn hình LCD 1602. Chuỗi này sẽ được hiển thị trên dòng 0 (hàng đầu tiên) và từ cột 0 trở đi.

// set the cursor to column 0, line 1 // (note: line 1 is the second row, since counting begins with 0): lcd.setCursor(0, 1);

lcd.setCursor(0, 1);
Đặt vị trí con trỏ của LCD 16×2 tới cột 0, dòng 1 (hàng thứ hai).

Các chức năng chính của thư viện LiquidCrystal

Dưới đây là một số chức năng hữu ích mà bạn có thể sử dụng với đối tượng LiquidCrystal:

lcd.home()
: Định vị con trỏ ở góc trên bên trái của màn hình LCD 16×2 mà không xóa nội dung hiện tại trên màn hình.

lcd.blink()
: Hiển thị một khối nhấp nháy 5×8 pixel tại vị trí mà ký tự tiếp theo sẽ được viết.

lcd.noBlink()
: Tắt chế độ nhấp nháy của con trỏ trên LCD 1602.

lcd.cursor()
: Hiển thị một dấu gạch dưới (dòng) tại vị trí mà ký tự tiếp theo sẽ được viết.

lcd.noCursor()
: Ẩn con trỏ trên LCD Arduino.

lcd.scrollDisplayRight()
: Cuộn nội dung của màn hình sang phải một khoảng trống. Nếu bạn muốn văn bản cuộn liên tục, bạn có thể sử dụng chức năng này trong một vòng lặp.

lcd.scrollDisplayLeft()
: Cuộn nội dung của màn hình sang trái một khoảng trống. Tương tự như chức năng trên, bạn có thể sử dụng chức năng này trong một vòng lặp để cuộn liên tục.

lcd.noDisplay()
: Tắt màn hình LCD 16×2 mà không làm mất nội dung hiện đang hiển thị trên đó.

lcd.display()
: Bật màn hình LCD Arduino sau khi nó đã được tắt bằng noDisplay(). Thao tác này sẽ khôi phục hiển thị nội dung (và con trỏ) trên màn hình.

In this digital age, we come across LCDs all around us from simple calculators to smartphones, computers and television sets, etc. The LCDs use liquid crystals to produce images or texts and are divided into different categories based on different criteria like type of manufacturing, monochrome or colour, and weather Graphical or character LCD. In this tutorial, we will be talking about the 16X2 character LCD Modules.

The 16×2 LCDs are very popular among the DIY community. Not only that, but you can also find them in many laboratory and industrial equipment. It can display up to 32 characters at a time. Each character segment is made up of 40 pixels that are arranged in a 5×8 matrix. We can create alphanumeric characters and custom characters by activating the corresponding pixels. Here is a vector representation of a 16×2 LCD, in which you can see those individual pixels.

As the name indicates, these character segments are arranged in 2 lines with 16 characters on each line. Even though there are LCDs with different controllers are available, The most widely used ones are based on the famous HD44780 parallel interface LCD controller from Hitachi.

16×2 LCD Module Pinout

The 16×2 has a 16-pin connector. The module can be used either in 4-bit mode or in 8-bit mode. In 4-bit mode, 4 of the data pins are not used and in 8-bit mode, all the pins are used. And the connections are as follows:

And here are the pins and corresponding functions.

Ground Ground (0V)

VccSupply voltage; 5V (4.7V – 5.3V)

Vo / VEE Contrast adjustment; the best way is to use a variable resistor such as a potentiometer. The output of the potentiometer is connected to this pin. Rotate the potentiometer knob forward and backwards to adjust the LCD contrast.

RS Selects command register when low, and data register when high

Read/write Low to write to the register; High to read from the register

EnableSends data to data pins when a high to low pulse is given; Extra voltage push is required to execute the instruction and EN (enable) signal is used for this purpose. Usually, we set en=0, when we want to execute the instruction, we make it high en=1 for some milliseconds. After this we again make it ground that is, en=0.

DB0 – DB7 8-bit data pins

Led+LED Backlight VCC (5V)

Led-LED Backlight Ground (0V)

16×2 LCD Module – Parts

The 16×2 LCD modules are popular among the DIY community since they are cheap, easy to use and most importantly enable us to provide information very efficiently. With just 6 pins, we can display a lot of data on the display.

The module has 16 pins. Out of these 16 pins, two pins are for power, two pins are for backlight, and the remaining twelve pins are for controlling the LCD.

If you look at the backside of the module you can simply see that there are not many components. The main components are the two controller chips that are under the encapsulation. There is an onboard current limiting resistor for the backlight. This may vary from different modules from different manufacturers. The only remaining components are a few complimentary resistors for the LCD controller.

In the module PCB, you may have noticed some unpopulated footprints. These footprints are meant for charge pump circuits based on switched capacitor voltage converters like ICL7660 or MAX660. You can modify your LCD to work with 3.3V by populating this IC and two 10uF capacitors to C1 and C2 footprint, removing Jumper J1 and adding jumper J3. This modification will generate a negative contrast voltage of around 2.5V. This will enable us to use the LCD even with a VCC voltage of 3.3V.Another issue to be concerned about is the oscillator frequency, i.e. when the supply voltage is reduced, the built-in clock frequency will also get reduced. The Rosc should be changed to a suitable value if any timing issues or command execution issues occur. The typical value of the Rosc for 5V VCC is 91KOhms.

Commonly Asked Questions about 16×2 LCD

How do I know if my 16×2 LCD is working?

To test whether a 16×2 LCD works or not, connect the VDD, GND and backlight pins to 5v and GND. Connect the centre terminal of a 10K variable resistor to the VEE pin. Connect the other two terminals to VCC and GND. Simply rotate the variable resistor you will see that the contrast will be adjusted and small blocks are visible. If these rectangles are visible, and you were able to adjust the contrast, then the LCD is working

How many pins are there in LCD?

There are 16 pins on the display module. Two of them are for power (VCC, GND), one for adjusting the contrast (VEE), three are control lines (RS, EN, R/W), eight pins are data lines(D0-D7) and the last two pins are for the backlight (A, K).

How does a 16×2 LCD screen work?

The 16×2 LCD has 32 character areas, which are made up of a 5×8 matrix of pixels. By turning on or off these pixels we can create different characters. We can display up to 32 characters in two rows.

Can we display custom characters on 16×2 LCD?

Yes, we can. We can store up to eight custom characters in the CGRAM (64 bytes in size) area. We can create load the matrix data for these characters and can recall when they need to be displayed.

How to Control 16×2 LCD Module

Controlling the LCD module is pretty simple. Let’s walk through those steps. To adjust the contrast of the LCD, the Vo/ VEE pin is connected to a variable resistor. By adjusting the variable resistor, we can change the LCD contrast.

The RS or registry select pin helps the LCD controller to know whether the incoming signal is a control signal or a data signal. When this pin is high, the controller will treat the signal as a command instruction and if it’s low, it will be treated as data. The R/W or Read/Write pin is used either to write data to the LCD or to read data from the LCD. When it’s low, the LCD module will be in write mode and when it’s high, the module will be in reading mode.

The Enable pin is used to control the LCD data execution. By default, this pin is pulled low. To execute a command or data which is provided to the LCD data line, we will just pull the Enable pin to high for a few milliseconds.

How to Test the 16X2 LCD Module

To test the LCD module, connect the VDD, GND, and backlight pins to 5v and GND. Connect the center terminal of a 10K variable resistor to the VEE pin. Connect the other two terminals to VCC and GND as per the below connection diagram-

Simply rotate the variable resistor you will see that the contrast will be adjusted and small blocks are visible. If these rectangles are visible, and you were able to adjust the contrast, then the LCD is working.

Interfacing 16×2 LCD with Arduino

Let’s see how to connect the LCD module to Arduino. For that first, connect the VSS to the GND and VDD to the 5V. To use the LCD backlight, connect the backlight Anode to the 5V and connect the backlight cathode to the GND through a 220Ωresistor. Since we are not using the read function connect the LCD R/W pin to the GND too. To adjust the contrast, connect the centre pin of a 10KΩ trimmer resistor to the VEE pin and connect the side pins to the VCC and GND. Now connect the registry select pin to D12 and Enable pin to D11.

Now let’s connect the data pins. The LCD module can work in two modes, 8-bit and 4-bit. 8-bit mode is faster but it will need 8 pins for data transfer. In 4-bit mode, we only need four pins for data. But it is slower since the data is sent one nibble at a time. 4-bit mode is often used to save I/O pins, while the 8-bit mode is used when speed is necessary. For this tutorial, we will be using the 4-bit mode. For that connect the D4, D5, D6 and D7 pins from the LCD to the D5, D4, D3 and D2 pins of the Arduino.

Here is the actual circuit. It is built as per the connection diagram provided. All the connections are made using standard male to male jumper wires.

Arduino Code to Interface 16×2 LCD

The following Arduino 16×2 LCD code will print Hello, World! on the first line of the display and the time the Arduino was running in seconds on the second line.

// include the library code: #include // initialize the library by associating any needed LCD interface pin // with the arduino pin number it is connected to const int rs = 12, en = 11, d4 = 2, d5 = 3, d6 = 4, d7 = 5; LiquidCrystal lcd(rs, en, d4, d5, d6, d7); void setup() { // set up the LCD’s number of columns and rows: lcd.begin(16, 2); // Print a message to the LCD. lcd.print(” Circuit Digest!”); delay(2000); for (int positionCounter = 0; positionCounter < 16; positionCounter++) { // scroll one position right: lcd.scrollDisplayRight(); // wait a bit: delay(150); } lcd.clear(); lcd.setCursor(6, 0); lcd.print(“Count!”); // print the number of seconds since reset: } void loop() { for (int i = 0; i < 10; i ++) { lcd.setCursor(8, 1); // print the number of seconds since reset: lcd.print(i); delay(1000); } }

Now let’s discuss the code. As usual, the sketch starts by including the necessary libraries. For this tutorial, we will be including the LiquidCrystal library from Arduino. This library is compatible with LCDs based on the Hitachi HD44780, or any compatible chipset. You can find more details about this library on the Arduino website.

// include the library code: #include

Let’s create an object to use with the LiquidCrystal library. The following line of code will create an object called lcd. We will be using this object in the entire code to access the library functions. The object is initialized with the pin numbers.

// initialize the library by associating any needed LCD interface pin // with the Arduino pin number it is connected to const int rs = 12, en = 11, d4 = 2, d5 = 3, d6 = 4, d7 = 5; LiquidCrystal lcd(rs, en, d4, d5, d6, d7);

Now let’s look at the setup() function. The lcd.begin function is used to initialize the LCD module. This function will send all the initialization commands. The parameters used while calling this function are the number of columns and the number of rows. And the next function is lcd.print. with this function, we have printed the word Circuit Digest! to the LCD. Since the LCD cursor is set to home position within the lcd.begin, we don’t need to set any cursor position. This text will stay there for two seconds. After that, the text will scroll from left to right until the entire text is out of the display. To scroll the display to the right, we have used the function lcd.scrollDisplayRight. After that, to clear display, we used lcd.clear, this will clear any characters on the display.

Next, the cursor is set to the sixth position on the first row, and the counting number is printed to the LCD.

void setup() { // set up the LCD’s number of columns and rows: lcd.begin(16, 2); // Print a message to the LCD. lcd.print(” Circuit Digest!”); delay(2000); for (int positionCounter = 0; positionCounter < 16; positionCounter++) { // scroll one position right: lcd.scrollDisplayRight(); // wait a bit: delay(150); } lcd.clear(); lcd.setCursor(6, 0); lcd.print(“Count!”); // print the number of seconds since reset: }

Now let’s look at the loop function. The for loop will count from 0 to 9, and when it reaches 9, it will reset the count and repeat the process all over again. lcd.setCursor is used to set the cursor position. lcd.setCursor(8, 1) will set the LCD cursor to the eighth position in the second row. In the LCD, the first row is addressed as 0 and the second row is addressed as 1. And the lcd.print(i) will print the count value stored in the variable i to the display.

void loop() { for (int i = 0; i < 10; i ++) { lcd.setCursor(8, 1); // print the number of seconds since reset: lcd.print(i); delay(1000); } }

16×2 LCD Module Problems and Troubleshooting Steps

Wrong characters are displayed: This problem occurs usually when the LCD is not getting the correct data. Make sure you are sending the correct ASCII value. If you are sending the correct ASCII characters, but still showing the wrong one on the LCD, check your connections for loose contact or short circuits.
Display shows Black boxes or does not show anything: First thing to do in these situations is to adjust the contrast voltage by rotating the variable resistor. This will correct the contrast value and will give you a visible readout.
Contrast is Ok, but still no display: Make sure to provide a sufficient time delay in between sending each character. Because if you don’t give enough time to process the data the display will malfunction.
Contrast and delay are ok, but still no display: Make sure you are powering the LCD from a 5V source. By default, these displays won’t work with a supply voltage below 5V. So if you are using the display with a 3.3V microcontroller make sure to power the display from 5V and use level shifters in between the display and the microcontroller.

Projects Using 16×2 LCD Display Module

There are some interesting projects done with the 16×2 LCD. If you want to know more about those topics, links are given below.

In this tutorial, we will see how to interface a 16×2 LCD with ARM7-LPC2148 microcontroller and display a simple welcome message.

In this tutorial, we will learn how to interface a LCD with STM8 Microcontroller. We have provided Circuit Diagram, Code, and Step-by-step guide.

In this project we will provide the input voice using Google Voice Keyboard via a Android App (BlueTerm) and print the text on 16×2 LCD using Raspberry Pi.

In this tutorial we are interfacing a Liquid Crystal Display (LCD) module with the Raspberry Pi Pico using Micropython to display strings, and characters on the LCD.

We used some Python scripts to find the local IP address of your Raspberry Pi on the network and display it on the 16×2 LCD Screen. We also added the script in the Crontab so that it can be run on every 10 minutes and we will have the updated IP address every time.

Supporting Files

// include the library code:

#include

// initialize the library by associating any needed LCD interface pin

// with the arduino pin number it is connected to

const int rs = 12, en = 11, d4 = 2, d5 = 3, d6 = 4, d7 = 5;

LiquidCrystal lcd(rs, en, d4, d5, d6, d7);

void setup() {

// set up the LCD’s number of columns and rows:

lcd.begin(16, 2);

// Print a message to the LCD.

lcd.print(” Circuit Digest!”);

delay(2000);

for (int positionCounter = 0; positionCounter < 16; positionCounter++) {

// scroll one position right:

lcd.scrollDisplayRight();

// wait a bit:

delay(150);

lcd.clear();

lcd.setCursor(6, 0);

lcd.print(“Count!”);

// print the number of seconds since reset:

void loop() {

for (int i = 0; i < 10; i ++)

lcd.setCursor(8, 1);

// print the number of seconds since reset:

lcd.print(i);

delay(1000);

Components and supplies

RGB Backlight LCD – 16×2

Resistor 220 ohm

Arduino UNO

Single Turn Potentiometer- 10k ohms

Jumper wires (generic)

Breadboard (generic)

Apps and platforms

Arduino IDE

Project description

Code

arduino

This code is the same as the example code in the LCD library. It can be found in the Arduino IDE here: File > Examples > LiquidCrystal > HelloWorld

Downloadable files

Schematic

The schematic is created using Tinkercad

Schematic

Comments

Only logged in users can leave comments

shreyas_arbatti

0 Followers

•

0 Projects

Table of contents

Intro

How to Use I2C LCD with Arduino | Very Easy Arduino LCD I2C Tutorial | Arduino 16x2 LCD I2C Tutorial — How to Use I2C LCD with Arduino | Very Easy Arduino LCD I2C Tutorial | Arduino 16×2 LCD I2C Tutorial

Schematic

Hello World Example

This example sketch prints

to the LCD and shows the time in seconds since the Arduino was reset.
Hello World!

1/*2 LiquidCrystal Library – Hello World34 Demonstrates the use a 16×2 LCD display. The LiquidCrystal5 library works with all LCD displays that are compatible with the6 Hitachi HD44780 driver. There are many of them out there, and you7 can usually tell them by the 16-pin interface.89 This sketch prints “Hello World!” to the LCD10 and shows the time.1112 The circuit:13 * LCD RS pin to digital pin 1214 * LCD Enable pin to digital pin 1115 * LCD D4 pin to digital pin 516 * LCD D5 pin to digital pin 417 * LCD D6 pin to digital pin 318 * LCD D7 pin to digital pin 219 * LCD R/W pin to ground20 * LCD VSS pin to ground21 * LCD VCC pin to 5V22 * 10K resistor:23 * ends to +5V and ground24 * wiper to LCD VO pin (pin 3)2526 Library originally added 18 Apr 200827 by David A. Mellis28 library modified 5 Jul 200929 by Limor Fried (http://www.ladyada.net)30 example added 9 Jul 200931 by Tom Igoe32 modified 22 Nov 201033 by Tom Igoe34 modified 7 Nov 201635 by Arturo Guadalupi3637 This example code is in the public domain.3839 https://docs.arduino.cc/learn/electronics/lcd-displays4041*/4243// include the library code:44#include 4546// initialize the library by associating any needed LCD interface pin47// with the arduino pin number it is connected to48const int rs = 12, en = 11, d4 = 5, d5 = 4, d6 = 3, d7 = 2;49LiquidCrystal lcd(rs, en, d4, d5, d6, d7);5051void setup() {52 // set up the LCD’s number of columns and rows:53 lcd.begin(16, 2);54 // Print a message to the LCD.55 lcd.print(“hello, world!”);56}5758void loop() {59 // set the cursor to column 0, line 160 // (note: line 1 is the second row, since counting begins with 0):61 lcd.setCursor(0, 1);62 // print the number of seconds since reset:63 lcd.print(millis() / 1000);64}

Autoscroll Example

This example sketch shows how to use the

and
autoscroll()

methods to move all the text on the display left or right.
noAutoscroll()

moves all the text one space to the left each time a letter is added

autoscroll()
turns scrolling off

noAutoscroll()

This sketch prints the characters

to

with autoscroll off, then moves the cursor to the bottom right, turns autoscroll on, and prints them again.

1/*23 LiquidCrystal Library – Autoscroll45 Demonstrates the use a 16×2 LCD display. The LiquidCrystal67 library works with all LCD displays that are compatible with the89 Hitachi HD44780 driver. There are many of them out there, and you1011 can usually tell them by the 16-pin interface.1213 This sketch demonstrates the use of the autoscroll()1415 and noAutoscroll() functions to make new text scroll or not.1617 The circuit:1819 * LCD RS pin to digital pin 122021 * LCD Enable pin to digital pin 112223 * LCD D4 pin to digital pin 52425 * LCD D5 pin to digital pin 42627 * LCD D6 pin to digital pin 32829 * LCD D7 pin to digital pin 23031 * LCD R/W pin to ground3233 * 10K resistor:3435 * ends to +5V and ground3637 * wiper to LCD VO pin (pin 3)3839 Library originally added 18 Apr 20084041 by David A. Mellis4243 library modified 5 Jul 20094445 by Limor Fried (http://www.ladyada.net)4647 example added 9 Jul 20094849 by Tom Igoe5051 modified 22 Nov 20105253 by Tom Igoe5455 modified 7 Nov 20165657 by Arturo Guadalupi5859 This example code is in the public domain.6061 http://www.arduino.cc/en/Tutorial/LiquidCrystalAutoscroll6263*/6465// include the library code:66#include 6768// initialize the library by associating any needed LCD interface pin69// with the arduino pin number it is connected to7071const int rs = 12, en = 11, d4 = 5, d5 = 4, d6 = 3, d7 = 2;7273LiquidCrystal lcd(rs, en, d4, d5, d6, d7);7475void setup() {7677 // set up the LCD’s number of columns and rows:7879 lcd.begin(16, 2);80}8182void loop() {8384 // set the cursor to (0,0):8586 lcd.setCursor(0, 0);8788 // print from 0 to 9:8990 for (int thisChar = 0; thisChar < 10; thisChar++) {9192 lcd.print(thisChar);9394 delay(500);9596 }9798 // set the cursor to (16,1):99100 lcd.setCursor(16, 1);101102 // set the display to automatically scroll:103104 lcd.autoscroll();105106 // print from 0 to 9:107108 for (int thisChar = 0; thisChar < 10; thisChar++) {109110 lcd.print(thisChar);111112 delay(500);113114 }115116 // turn off automatic scrolling117118 lcd.noAutoscroll();119120 // clear screen for the next loop:121122 lcd.clear();123}

Blink Example

This example sketch shows how to use the

and
blink()

methods to blink a block-style cursor.
noBlink()

1/*23 LiquidCrystal Library – Blink45 Demonstrates the use a 16×2 LCD display. The LiquidCrystal67 library works with all LCD displays that are compatible with the89 Hitachi HD44780 driver. There are many of them out there, and you1011 can usually tell them by the 16-pin interface.1213 This sketch prints “Hello World!” to the LCD and makes the1415 cursor block blink.1617 The circuit:1819 * LCD RS pin to digital pin 122021 * LCD Enable pin to digital pin 112223 * LCD D4 pin to digital pin 52425 * LCD D5 pin to digital pin 42627 * LCD D6 pin to digital pin 32829 * LCD D7 pin to digital pin 23031 * LCD R/W pin to ground3233 * 10K resistor:3435 * ends to +5V and ground3637 * wiper to LCD VO pin (pin 3)3839 Library originally added 18 Apr 20084041 by David A. Mellis4243 library modified 5 Jul 20094445 by Limor Fried (http://www.ladyada.net)4647 example added 9 Jul 20094849 by Tom Igoe5051 modified 22 Nov 20105253 by Tom Igoe5455 modified 7 Nov 20165657 by Arturo Guadalupi5859 This example code is in the public domain.6061 http://www.arduino.cc/en/Tutorial/LiquidCrystalBlink6263*/6465// include the library code:66#include 6768// initialize the library by associating any needed LCD interface pin69// with the arduino pin number it is connected to7071const int rs = 12, en = 11, d4 = 5, d5 = 4, d6 = 3, d7 = 2;7273LiquidCrystal lcd(rs, en, d4, d5, d6, d7);7475void setup() {7677 // set up the LCD’s number of columns and rows:7879 lcd.begin(16, 2);8081 // Print a message to the LCD.8283 lcd.print(“hello, world!”);84}8586void loop() {8788 // Turn off the blinking cursor:8990 lcd.noBlink();9192 delay(3000);9394 // Turn on the blinking cursor:9596 lcd.blink();9798 delay(3000);99}

Cursor

This example sketch shows how to use the

and
cursor()

methods to control an underscore-style cursor.
noCursor()

1/*23 LiquidCrystal Library – Cursor45 Demonstrates the use a 16×2 LCD display. The LiquidCrystal67 library works with all LCD displays that are compatible with the89 Hitachi HD44780 driver. There are many of them out there, and you1011 can usually tell them by the 16-pin interface.1213 This sketch prints “Hello World!” to the LCD and1415 uses the cursor() and noCursor() methods to turn1617 on and off the cursor.1819 The circuit:2021 * LCD RS pin to digital pin 122223 * LCD Enable pin to digital pin 112425 * LCD D4 pin to digital pin 52627 * LCD D5 pin to digital pin 42829 * LCD D6 pin to digital pin 33031 * LCD D7 pin to digital pin 23233 * LCD R/W pin to ground3435 * 10K resistor:3637 * ends to +5V and ground3839 * wiper to LCD VO pin (pin 3)4041 Library originally added 18 Apr 20084243 by David A. Mellis4445 library modified 5 Jul 20094647 by Limor Fried (http://www.ladyada.net)4849 example added 9 Jul 20095051 by Tom Igoe5253 modified 22 Nov 20105455 by Tom Igoe5657 modified 7 Nov 20165859 by Arturo Guadalupi6061 This example code is in the public domain.6263 http://www.arduino.cc/en/Tutorial/LiquidCrystalCursor6465*/6667// include the library code:68#include 6970// initialize the library by associating any needed LCD interface pin71// with the arduino pin number it is connected to7273const int rs = 12, en = 11, d4 = 5, d5 = 4, d6 = 3, d7 = 2;7475LiquidCrystal lcd(rs, en, d4, d5, d6, d7);7677void setup() {7879 // set up the LCD’s number of columns and rows:8081 lcd.begin(16, 2);8283 // Print a message to the LCD.8485 lcd.print(“hello, world!”);86}8788void loop() {8990 // Turn off the cursor:9192 lcd.noCursor();9394 delay(500);9596 // Turn on the cursor:9798 lcd.cursor();99100 delay(500);101}

Display Example

This example sketch shows how to use the

and
display()

methods to turn on and off the display. The text to be displayed will still be preserved when you use noDisplay() so it’s a quick way to blank the display without losing everything on it.
noDisplay()

1/*2 LiquidCrystal Library – display() and noDisplay()34 Demonstrates the use a 16×2 LCD display. The LiquidCrystal5 library works with all LCD displays that are compatible with the6 Hitachi HD44780 driver. There are many of them out there, and you7 can usually tell them by the 16-pin interface.89 This sketch prints “Hello World!” to the LCD and uses the10 display() and noDisplay() functions to turn on and off11 the display.1213 The circuit:14 * LCD RS pin to digital pin 1215 * LCD Enable pin to digital pin 1116 * LCD D4 pin to digital pin 517 * LCD D5 pin to digital pin 418 * LCD D6 pin to digital pin 319 * LCD D7 pin to digital pin 220 * LCD R/W pin to ground21 * 10K resistor:22 * ends to +5V and ground23 * wiper to LCD VO pin (pin 3)2425 Library originally added 18 Apr 200826 by David A. Mellis27 library modified 5 Jul 200928 by Limor Fried (http://www.ladyada.net)29 example added 9 Jul 200930 by Tom Igoe31 modified 22 Nov 201032 by Tom Igoe33 modified 7 Nov 201634 by Arturo Guadalupi3536 This example code is in the public domain.3738 http://www.arduino.cc/en/Tutorial/LiquidCrystalDisplay3940*/4142// include the library code:43#include 4445// initialize the library by associating any needed LCD interface pin46// with the arduino pin number it is connected to47const int rs = 12, en = 11, d4 = 5, d5 = 4, d6 = 3, d7 = 2;48LiquidCrystal lcd(rs, en, d4, d5, d6, d7);4950void setup() {51 // set up the LCD’s number of columns and rows:52 lcd.begin(16, 2);53 // Print a message to the LCD.54 lcd.print(“hello, world!”);55}5657void loop() {58 // Turn off the display:59 lcd.noDisplay();60 delay(500);61 // Turn on the display:62 lcd.display();63 delay(500);64}

Scroll Example

This example sketch shows how to use the

and
scrollDisplayLeft()

methods to reverse the direction the text is flowing. It prints “Hello World!”, scrolls it offscreen to the left, then offscreen to the right, then back to home.
scrollDisplayRight()

1/*2 LiquidCrystal Library – scrollDisplayLeft() and scrollDisplayRight()34 Demonstrates the use a 16×2 LCD display. The LiquidCrystal5 library works with all LCD displays that are compatible with the6 Hitachi HD44780 driver. There are many of them out there, and you7 can usually tell them by the 16-pin interface.89 This sketch prints “Hello World!” to the LCD and uses the10 scrollDisplayLeft() and scrollDisplayRight() methods to scroll11 the text.1213 The circuit:14 * LCD RS pin to digital pin 1215 * LCD Enable pin to digital pin 1116 * LCD D4 pin to digital pin 517 * LCD D5 pin to digital pin 418 * LCD D6 pin to digital pin 319 * LCD D7 pin to digital pin 220 * LCD R/W pin to ground21 * 10K resistor:22 * ends to +5V and ground23 * wiper to LCD VO pin (pin 3)2425 Library originally added 18 Apr 200826 by David A. Mellis27 library modified 5 Jul 200928 by Limor Fried (http://www.ladyada.net)29 example added 9 Jul 200930 by Tom Igoe31 modified 22 Nov 201032 by Tom Igoe33 modified 7 Nov 201634 by Arturo Guadalupi3536 This example code is in the public domain.3738 http://www.arduino.cc/en/Tutorial/LiquidCrystalScroll3940*/4142// include the library code:43#include 4445// initialize the library by associating any needed LCD interface pin46// with the arduino pin number it is connected to47const int rs = 12, en = 11, d4 = 5, d5 = 4, d6 = 3, d7 = 2;48LiquidCrystal lcd(rs, en, d4, d5, d6, d7);4950void setup() {51 // set up the LCD’s number of columns and rows:52 lcd.begin(16, 2);53 // Print a message to the LCD.54 lcd.print(“hello, world!”);55 delay(1000);56}5758void loop() {59 // scroll 13 positions (string length) to the left60 // to move it offscreen left:61 for (int positionCounter = 0; positionCounter < 13; positionCounter++) {62 // scroll one position left:63 lcd.scrollDisplayLeft();64 // wait a bit:65 delay(150);66 }6768 // scroll 29 positions (string length + display length) to the right69 // to move it offscreen right:70 for (int positionCounter = 0; positionCounter < 29; positionCounter++) {71 // scroll one position right:72 lcd.scrollDisplayRight();73 // wait a bit:74 delay(150);75 }7677 // scroll 16 positions (display length + string length) to the left78 // to move it back to center:79 for (int positionCounter = 0; positionCounter < 16; positionCounter++) {80 // scroll one position left:81 lcd.scrollDisplayLeft();82 // wait a bit:83 delay(150);84 }8586 // delay at the end of the full loop:87 delay(1000);8889}

Serial to Display Example

This example sketch accepts serial input from a host computer and displays it on the LCD. To use it, upload the sketch, then open the Serial Monitor and type some characters and click Send. The text will appear on your LCD.

1/*2 LiquidCrystal Library – Serial Input34 Demonstrates the use a 16×2 LCD display. The LiquidCrystal5 library works with all LCD displays that are compatible with the6 Hitachi HD44780 driver. There are many of them out there, and you7 can usually tell them by the 16-pin interface.89 This sketch displays text sent over the serial port10 (e.g. from the Serial Monitor) on an attached LCD.1112 The circuit:13 * LCD RS pin to digital pin 1214 * LCD Enable pin to digital pin 1115 * LCD D4 pin to digital pin 516 * LCD D5 pin to digital pin 417 * LCD D6 pin to digital pin 318 * LCD D7 pin to digital pin 219 * LCD R/W pin to ground20 * 10K resistor:21 * ends to +5V and ground22 * wiper to LCD VO pin (pin 3)2324 Library originally added 18 Apr 200825 by David A. Mellis26 library modified 5 Jul 200927 by Limor Fried (http://www.ladyada.net)28 example added 9 Jul 200929 by Tom Igoe30 modified 22 Nov 201031 by Tom Igoe32 modified 7 Nov 201633 by Arturo Guadalupi3435 This example code is in the public domain.3637 http://www.arduino.cc/en/Tutorial/LiquidCrystalSerialDisplay3839*/4041// include the library code:42#include 4344// initialize the library by associating any needed LCD interface pin45// with the arduino pin number it is connected to46const int rs = 12, en = 11, d4 = 5, d5 = 4, d6 = 3, d7 = 2;47LiquidCrystal lcd(rs, en, d4, d5, d6, d7);4849void setup() {50 // set up the LCD’s number of columns and rows:51 lcd.begin(16, 2);52 // initialize the serial communications:53 Serial.begin(9600);54}5556void loop() {57 // when characters arrive over the serial port…58 if (Serial.available()) {59 // wait a bit for the entire message to arrive60 delay(100);61 // clear the screen62 lcd.clear();63 // read all the available characters64 while (Serial.available() > 0) {65 // display each character to the LCD66 lcd.write(Serial.read());67 }68 }69}

Set Cursor Example

This example sketch shows how to use the

method to reposition the cursor. To move the cursor, just call
setCursor()

with a row and column position. For example, for a 2×16 display:
setCursor()

1lcd.setCursor(0, 0); // top left2lcd.setCursor(15, 0); // top right3lcd.setCursor(0, 1); // bottom left4lcd.setCursor(15, 1); // bottom right

Here is the full example:

1/*23 LiquidCrystal Library – setCursor45 Demonstrates the use a 16×2 LCD display. The LiquidCrystal67 library works with all LCD displays that are compatible with the89 Hitachi HD44780 driver. There are many of them out there, and you1011 can usually tell them by the 16-pin interface.1213 This sketch prints to all the positions of the LCD using the1415 setCursor() method:1617 The circuit:1819 * LCD RS pin to digital pin 122021 * LCD Enable pin to digital pin 112223 * LCD D4 pin to digital pin 52425 * LCD D5 pin to digital pin 42627 * LCD D6 pin to digital pin 32829 * LCD D7 pin to digital pin 23031 * LCD R/W pin to ground3233 * 10K resistor:3435 * ends to +5V and ground3637 * wiper to LCD VO pin (pin 3)3839 Library originally added 18 Apr 20084041 by David A. Mellis4243 library modified 5 Jul 20094445 by Limor Fried (http://www.ladyada.net)4647 example added 9 Jul 20094849 by Tom Igoe5051 modified 22 Nov 20105253 by Tom Igoe5455 modified 7 Nov 20165657 by Arturo Guadalupi5859 This example code is in the public domain.6061 http://www.arduino.cc/en/Tutorial/LiquidCrystalSetCursor6263*/6465// include the library code:66#include 6768// initialize the library by associating any needed LCD interface pin69// with the arduino pin number it is connected to7071const int rs = 12, en = 11, d4 = 5, d5 = 4, d6 = 3, d7 = 2;7273LiquidCrystal lcd(rs, en, d4, d5, d6, d7);7475// these constants won’t change. But you can change the size of76// your LCD using them:7778const int numRows = 2;7980const int numCols = 16;8182void setup() {8384 // set up the LCD’s number of columns and rows:8586 lcd.begin(numCols, numRows);87}8889void loop() {9091 // loop from ASCII ‘a’ to ASCII ‘z’:9293 for (int thisLetter = ‘a’; thisLetter <= ‘z’; thisLetter++) {9495 // loop over the columns:9697 for (int thisRow = 0; thisRow < numRows; thisRow++) {9899 // loop over the rows:100101 for (int thisCol = 0; thisCol < numCols; thisCol++) {102103 // set the cursor position:104105 lcd.setCursor(thisCol, thisRow);106107 // print the letter:108109 lcd.write(thisLetter);110111 delay(200);112113 }114115 }116117 }118}

Text Direction Example

This example sketch shows how to use the

and
leftToRight()

methods. These methods control which way text flows from the cursor.
rightToLeft()

causes text to flow to the left from the cursor, as if the display is right-justified.

rightToLeft()
causes text to flow to the right from the cursor, as if the display is left-justified.

leftToRight()

This sketch prints

through

right to left, then

through

left to right, then

through

right to left again.

1/*23 LiquidCrystal Library – TextDirection45 Demonstrates the use a 16×2 LCD display. The LiquidCrystal67 library works with all LCD displays that are compatible with the89 Hitachi HD44780 driver. There are many of them out there, and you1011 can usually tell them by the 16-pin interface.1213 This sketch demonstrates how to use leftToRight() and rightToLeft()1415 to move the cursor.1617 The circuit:1819 * LCD RS pin to digital pin 122021 * LCD Enable pin to digital pin 112223 * LCD D4 pin to digital pin 52425 * LCD D5 pin to digital pin 42627 * LCD D6 pin to digital pin 32829 * LCD D7 pin to digital pin 23031 * LCD R/W pin to ground3233 * 10K resistor:3435 * ends to +5V and ground3637 * wiper to LCD VO pin (pin 3)3839 Library originally added 18 Apr 20084041 by David A. Mellis4243 library modified 5 Jul 20094445 by Limor Fried (http://www.ladyada.net)4647 example added 9 Jul 20094849 by Tom Igoe5051 modified 22 Nov 20105253 by Tom Igoe5455 modified 7 Nov 20165657 by Arturo Guadalupi5859 This example code is in the public domain.6061 http://www.arduino.cc/en/Tutorial/LiquidCrystalTextDirection6263*/6465// include the library code:66#include 6768// initialize the library by associating any needed LCD interface pin69// with the arduino pin number it is connected to7071const int rs = 12, en = 11, d4 = 5, d5 = 4, d6 = 3, d7 = 2;7273LiquidCrystal lcd(rs, en, d4, d5, d6, d7);7475int thisChar = ‘a’;7677void setup() {7879 // set up the LCD’s number of columns and rows:8081 lcd.begin(16, 2);8283 // turn on the cursor:8485 lcd.cursor();86}8788void loop() {8990 // reverse directions at ‘m’:9192 if (thisChar == ‘m’) {9394 // go right for the next letter9596 lcd.rightToLeft();9798 }99100 // reverse again at ‘s’:101102 if (thisChar == ‘s’) {103104 // go left for the next letter105106 lcd.leftToRight();107108 }109110 // reset at ‘z’:111112 if (thisChar > ‘z’) {113114 // go to (0,0):115116 lcd.home();117118 // start again at 0119120 thisChar = ‘a’;121122 }123124 // print the character125126 lcd.write(thisChar);127128 // wait a second:129130 delay(1000);131132 // increment the letter:133134 thisChar++;135}

Custom Character

This example demonstrates how to add custom characters on an LCD display.

Note that this example requires an additional potentiometer:

Outer pins connected to 5V and GND.
Inner pin (wiper) connected to A0.

This potentiometer controls the

variable.
delayTime

1/*2 LiquidCrystal Library – Custom Characters34 Demonstrates how to add custom characters on an LCD display.5 The LiquidCrystal library works with all LCD displays that are6 compatible with the Hitachi HD44780 driver. There are many of7 them out there, and you can usually tell them by the 16-pin interface.89 This sketch prints “I

Arduino!” and a little dancing man10 to the LCD.1112 The circuit:13 * LCD RS pin to digital pin 1214 * LCD Enable pin to digital pin 1115 * LCD D4 pin to digital pin 516 * LCD D5 pin to digital pin 417 * LCD D6 pin to digital pin 318 * LCD D7 pin to digital pin 219 * LCD R/W pin to ground20 * 10K potentiometer:21 * ends to +5V and ground22 * wiper to LCD VO pin (pin 3)23 * 10K poterntiometer on pin A02425 created 21 Mar 201126 by Tom Igoe27 modified 11 Nov 201328 by Scott Fitzgerald29 modified 7 Nov 201630 by Arturo Guadalupi3132 Based on Adafruit’s example at33 https://github.com/adafruit/SPI_VFD/blob/master/examples/createChar/createChar.pde3435 This example code is in the public domain.36 https://docs.arduino.cc/learn/electronics/lcd-displays#custom-character3738 Also useful:39 http://icontexto.com/charactercreator/4041*/4243// include the library code:44#include 4546// initialize the library by associating any needed LCD interface pin47// with the arduino pin number it is connected to48const int rs = 12, en = 11, d4 = 5, d5 = 4, d6 = 3, d7 = 2;49LiquidCrystal lcd(rs, en, d4, d5, d6, d7);5051// make some custom characters:52byte heart[8] = {53 0b00000,54 0b01010,55 0b11111,56 0b11111,57 0b11111,58 0b01110,59 0b00100,60 0b0000061};6263byte smiley[8] = {64 0b00000,65 0b00000,66 0b01010,67 0b00000,68 0b00000,69 0b10001,70 0b01110,71 0b0000072};7374byte frownie[8] = {75 0b00000,76 0b00000,77 0b01010,78 0b00000,79 0b00000,80 0b00000,81 0b01110,82 0b1000183};8485byte armsDown[8] = {86 0b00100,87 0b01010,88 0b00100,89 0b00100,90 0b01110,91 0b10101,92 0b00100,93 0b0101094};9596byte armsUp[8] = {97 0b00100,98 0b01010,99 0b00100,100 0b10101,101 0b01110,102 0b00100,103 0b00100,104 0b01010105};106107void setup() {108 // initialize LCD and set up the number of columns and rows:109 lcd.begin(16, 2);110111 // create a new character112 lcd.createChar(0, heart);113 // create a new character114 lcd.createChar(1, smiley);115 // create a new character116 lcd.createChar(2, frownie);117 // create a new character118 lcd.createChar(3, armsDown);119 // create a new character120 lcd.createChar(4, armsUp);121122 // set the cursor to the top left123 lcd.setCursor(0, 0);124125 // Print a message to the lcd.126 lcd.print(“I “);127 lcd.write(byte(0)); // when calling lcd.write() ‘0’ must be cast as a byte128 lcd.print(” Arduino! “);129 lcd.write((byte)1);130131}132133void loop() {134 // read the potentiometer on A0:135 int sensorReading = analogRead(A0);136 // map the result to 200 – 1000:137 int delayTime = map(sensorReading, 0, 1023, 200, 1000);138 // set the cursor to the bottom row, 5th position:139 lcd.setCursor(4, 1);140 // draw the little man, arms down:141 lcd.write(3);142 delay(delayTime);143 lcd.setCursor(4, 1);144 // draw him arms up:145 lcd.write(4);146 delay(delayTime);147}

Suggested changes

The content on docs.arduino.cc is facilitated through a public GitHub repository. You can read more on how to contribute in the contribution policy.

License

The Arduino documentation is licensed under the Creative Commons Attribution-Share Alike 4.0 license.

Xin chào các bạn!

Nay mình xin share ít bộ code để tạo các hiệu ứng mới cho LCD 16X2 với Arduino Uno

Các bạn cắm mạch kết nối giữa Arduino với LCD16x2 như phía dưới hình .

Code mẫu

#include

#include LiquidCrystal_I2C lcd(0x3F,16,2); void setup() { lcd.init(); lcd.backlight(); lcd.setCursor(2,0); lcd.print(“Arduinokit.vn”); lcd.setCursor(0,1); lcd.print(“Xin chao cac ban”); } void loop() { }

Giải thích code

LiquidCrystal_I2C lcd(0x3F,16,2);

Đặt địa chỉ LCD là 0x3F cho màn hình LCD 16×2.
16 là số cột của màn hình (nếu dùng loại màn hình 20×4) thì thay bằng 20.
2 là số dòng của màn hình (nếu dùng loại màn hình 20×4) thì thay bằng 4.

lcd.init();

Khởi động màn hình LCD, bắt đầu cho phép Arduino sử dụng màn hình.

lcd.backlight();

Bật đèn nền LCD 16×2.

lcd.setCursor(2,0);

Đưa con trỏ tới hàng 1, cột 3.

Lưu ý: giá trị hàng và cột bắt đầu từ số 0 có nghĩa 0 là hàng(cột) 1.

lcd.print(“Arduinokit.vn”);

Xuất ra dòng chữ Arduinokit.vn tại vị trí con trỏ ở hàng 1, cột 3.

lcd.setCursor(0,1); lcd.print(“Xin chao cac ban”);

Đoạn code này thì tương tự như trên, xuất ra dòng chữ “Xin chao cac ban” tại vị trí con trỏ ở hàng 2, cột 1.

Bây giờ thì các bạn upload chương trình và xem kết quả nhé.

(16x2) LCD display with Arduino || without I2C module || Simple tutorial — (16×2) LCD display with Arduino || without I2C module || Simple tutorial

I.Một số bộ code

1.1.Blink

Nhấp nháy chữ trên LCD:

//Thêm thư viện LiquidCrystal – nó có sẵn vì vậy bạn không cần cài thêm gì cả #include //Khởi tạo với các chân LiquidCrystal lcd(12, 11, 5, 4, 3, 2); void setup() { lcd.begin(16, 2);//Thông báo đây là LCD 1602 lcd.print(“Hello World!”);//In ra dòng chữ, bạn có thể chỉnh chữ lại tuỳ ý lcd.setCursor(0 , 1); lcd.print(“arduino.vn”); } void loop() { lcd.noDisplay();//Xoá màn hình hiển thị delay(500);//chờ 0,5 giây lcd.Display();//Hiển thị trở lại delay(500); }

Kết quả:

1.2.Tự động cuộn chữ

Chương trình tự dịch chuyển chữ ở dòng thứ 1 trên LCD khi bắt đầu có kí tự ở dòng thứ 2:

// Thêm thư viện #include //Khai báo các chân LCD LiquidCrystal lcd(12, 11, 5, 4, 3, 2); void setup() { // Cấu hình hàng và cột LCD lcd.begin(16, 2); } void loop() { // Đưa con trỏ về vị trí (0,0): lcd.setCursor(0, 0); // In ra giá trị từ 0 – 9: for (int thisChar = 0; thisChar < 10; thisChar++) { lcd.print(thisChar); delay(500); } // Đặt con trỏ tới vị trí (16,1): lcd.setCursor(16, 1); // Cấu hình hiển thị tự cuộn chữ: lcd.autoscroll(); //IN giá trị từ 0 – 9: for (int thisChar = 0; thisChar < 10; thisChar++) { lcd.print(thisChar); delay(500); } // Tắt chức năng tự động cuộn lcd.noAutoscroll(); // Xóa màn hình cho vòng lặp kế tiếp lcd.clear(); }

Kết quả:

1.3.Blink con trỏ

Chương trình chớp tắt con trỏ cuối dòng:

// Thêm thư viện #include //Khai báo các chân LCD LiquidCrystal lcd(12, 11, 5, 4, 3, 2); void setup() { // Cấu hình hàng và cột: lcd.begin(16, 2); // In thông báo hello ra LCD. lcd.print(“hello, world!”); } void loop() { // Tắt blink con trỏ lcd.noBlink(); delay(3000); // Bật blink con trỏ lcd.blink(); delay(3000); }

Kết quả:

1.4.Blink con trỏ dưới dạng dấu gạch nối

Chương trình chớp tắt con trỏ cuối dòng dưới dạng gạch nối:

// Thêm thư viện #include //Khai báo các chân LCD LiquidCrystal lcd(12, 11, 5, 4, 3, 2); void setup() { // Khởi tạo LCD: lcd.begin(16, 2); // In thông báo trên LCD. lcd.print(“hello, world!”); } void loop() { // Tắt con trỏ: lcd.noCursor(); delay(500); // Hiện con trỏ: lcd.cursor(); delay(500); }

Kết quả:

1.5.Chạy chữ

Cho tất cả chữ chạy từ trái sang phải và ngược lại.

// Thêm thư viện #include //Khai báo các chân LCD LiquidCrystal lcd(12, 11, 5, 4, 3, 2); void setup() { // Cấu hình LCD lcd.begin(16, 2); // In hello ra LCD. lcd.print(“hello, world!”); delay(1000); } void loop() { // Cuộn 13 vị trí sang trái for (int positionCounter = 0; positionCounter < 13; positionCounter++) { // Cuộn 1 vị trí sang trái: lcd.scrollDisplayLeft(); // delay: delay(150); } // Cuộn 29 vị trí sang phải: for (int positionCounter = 0; positionCounter < 29; positionCounter++) { // Cuộn 1 vị trí sang phải: lcd.scrollDisplayRight(); // wdelay: delay(150); } // Cuộn 16 vị trí sang trái for (int positionCounter = 0; positionCounter < 16; positionCounter++) { // Cuộn 1 vị trí sang trái: lcd.scrollDisplayLeft(); // delay: delay(150); } // delay: delay(1000); }

Kết quả:

1.6.In chữ và tự xuống dòng

Chương trình tự xuống dòng khi vượt quá số ký tự trong 1 dòng:

// Thêm thư viện #include // Khai báo 2 biến lưu hàng và cột LCD const int numRows = 2; const int numCols = 16; //Khai báo các chân LCD LiquidCrystal lcd(12, 11, 5, 4, 3, 2); void setup() { // Cấu hình LCD: lcd.begin(numCols, numRows); } void loop() { // Hiển thị ký tự từ a – z: for (int thisLetter = ‘a’; thisLetter <= ‘z’; thisLetter++) { // Lặp lại trên cột: for (int thisRow = 0; thisRow < numRows; thisRow++) { // lặp lại trên hàng: for (int thisCol = 0; thisCol < numCols; thisCol++) { // Đặt giá trị con trỏ hiện tại: lcd.setCursor(thisCol, thisRow); // In các ký tự lên LCD: lcd.write(thisLetter); delay(200); } } } }

Kết quả :

1.7.Text Direction

Kiểm soát vị trí con trỏ, ví dụ này phù hợp cho các ứng dụng điều khiển chọn menu dùng nút bấm:

// Thêm thư viện #include //Khai báo các chân LCD LiquidCrystal lcd(12, 11, 5, 4, 3, 2); int thisChar = ‘a’; void setup() { // Cấu hình LCD: lcd.begin(16, 2); // Bật con trỏ: lcd.cursor(); } void loop() { // Đảo chiều tại ‘m’: if (thisChar == ‘m’) { // Dịch phải cho ký tự kế tiếp lcd.rightToLeft(); } // Đảo chiều tiếp tục tại ‘s’: if (thisChar == ‘s’) { // Dịch trái cho ký tự kế tiếp lcd.leftToRight(); } // reset tại ‘z’: if (thisChar > ‘z’) { // Tới vị trí (0,0): lcd.home(); // Bắt đầu in a tại 0 thisChar = ‘a’; } // In ký tự lcd.write(thisChar); // delay: delay(1000); // Tăng ký tự tiếp theo: thisChar++; }

Kết quả:

Mình đã chỉ các bạn cách sử dụng các hiệu ứng khác nhau, cơ bản nhất của Text LCD 16×2.Chúc các bạn may mắn với các hiệu ứng này và ứng dụng được vào nhiều project hay hơn.

Tổng quan LCD 16×2 và giao tiếp I2C LCD sử dụng Arduino

Circuit

Note that this circuit was originally designed for the Arduino UNO. As the Arduino is communicating with the display using SPI, pin 11 & 12 will change depending on what board you are using. For example, on a MKR WiFi 1010, the SPI bus is attached to pin 8 & 11.

Before wiring the LCD screen to your Arduino board we suggest to solder a pin header strip to the 14 (or 16) pin count connector of the LCD screen, as you can see in the image further up.

To wire your LCD screen to your board, connect the following pins:

LCD RS pin to digital pin 12
LCD Enable pin to digital pin 11
LCD D4 pin to digital pin 5
LCD D5 pin to digital pin 4
LCD D6 pin to digital pin 3
LCD D7 pin to digital pin 2
LCD R/W pin to GND
LCD VSS pin to GND
LCD VCC pin to 5V
LCD LED+ to 5V through a 220 ohm resistor
LCD LED- to GND

Additionally, wire a 10k potentiometer to +5V and GND, with it’s wiper (output) to LCD screens VO pin (pin3).

How to use 16x2 LCD with Arduino : Tutorial 54 — How to use 16×2 LCD with Arduino : Tutorial 54

Tổng quan về màn hình LCD 16×2

Màn hình LCD 16×2 là một loại màn hình ký tự thông dụng trong các dự án điện tử. Nó có khả năng hiển thị 16 cột và 2 hàng của các ký tự.

Màn hình này sử dụng công nghệ hiển thị Liquid Crystal Display (LCD) để hiển thị thông tin. Nó có thể hiển thị các ký tự từ bảng mã ASCII và có thể hiển thị các ký tự chữ cái, chữ số, ký tự đặc biệt và các biểu tượng khác.

Màn hình LCD 16×2 có một lưới pixel 5×8 cho mỗi ký tự. Điều này có nghĩa là mỗi ký tự được hiển thị bằng một ma trận 5×8 điểm ảnh. Nó cũng có thể hiển thị các ký tự tiếng Việt nhưng có giới hạn một số ký tự đặc biệt.

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.

Testing a CHEAP LCD Display! #engineering #arduino #electronics

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.

- Tổng tiền thanh toán:

Code test cơ bản

#include

void loop()

Code Đếm số 0 đến 9 LCD 16×2 I2C

#include

void loop()

Code test cơ bản

#include

void loop()

Code Đếm số 0 đến 9 LCD 16×2 I2C

#include

void loop()

Hướng dẫn sử dụng màn hình LCD 16×2 với Arduino

Trong hướng dẫn này, các bạn sẽ tìm hiểu cách sử dụng màn hình LCD 16×2 với Arduino, bằng cách sử dụng thư viện LiquidCrystal để điều khiển màn hình.

Qua đó sẽ khám phá các chức năng cơ bản của màn hình LCD 1602 như hiển thị văn bản, di chuyển con trỏ, xóa màn hình và điều chỉnh độ sáng. Bên cạnh đó, các bạn sẽ tìm hiểu cách tạo các ký tự tùy chỉnh trên màn hình LCD arduino.

Để tạo động lực cho Team Arduino KIT ra nhiều bài viết chất lượng hơn, các bạn có thể ủng hộ mình bằng cách Donate qua MoMo, Ngân hàng, Paypal…Nhấn vào link bên dưới nhé.

Liquid Crystal Displays (LCD) with Arduino

Find out how to wire an LCD to an Arduino, and how to use the LiquidCrystal library through a set of useful examples.

This article was revised on 2021/11/18 by Karl Söderby.

The LiquidCrystal library allows you to control LCD displays that are compatible with the Hitachi HD44780 driver. There are many of them out there, and you can usually tell them by the 16-pin interface.

The LCDs have a parallel interface, meaning that the microcontroller has to manipulate several interface pins at once to control the display. The interface consists of the following pins:

A register select (RS) pin that controls where in the LCD’s memory you’re writing data to. You can select either the data register, which holds what goes on the screen, or an instruction register, which is where the LCD’s controller looks for instructions on what to do next.
A Read/Write (R/W) pin that selects reading mode or writing mode
An Enable pin that enables writing to the registers
8 data pins (D0 -D7). The states of these pins (high or low) are the bits that you’re writing to a register when you write, or the values you’re reading when you read.

There’s also a display contrast pin (Vo), power supply pins (+5V and GND) and LED Backlight (Bklt+ and BKlt-) pins that you can use to power the LCD, control the display contrast, and turn on and off the LED backlight, respectively.

The process of controlling the display involves putting the data that form the image of what you want to display into the data registers, then putting instructions in the instruction register. The LiquidCrystal Library simplifies this for you so you don’t need to know the low-level instructions.

The Hitachi-compatible LCDs can be controlled in two modes: 4-bit or 8-bit. The 4-bit mode requires seven I/O pins from the Arduino, while the 8-bit mode requires 11 pins. For displaying text on the screen, you can do most everything in 4-bit mode, so example shows how to control a 16×2 LCD in 4-bit mode.

Arduino LCD I2C - Tutorial with Arduino Uno — Arduino LCD I2C – Tutorial with Arduino Uno

Linh kiện cần thiết cho dự án

TÊN LINH KIỆN	SỐ LƯỢNG	NƠI BÁN
Arduino Uno R3	Shopee \| Cytron
Màn hình LCD 16×2	Shopee \| Cytron
Biến trở vuông 10K	Shopee \| Cytron
Điện trở 220R	Shopee \| Cytron
Dây cắm	10-20	Shopee \| Cytron
Breadboard	Shopee \| Cytron

Module I2C Arduino

LCD có quá nhiều nhiều chân gây khó khăn trong quá trình đấu nối và chiếm dụng nhiều chân trên vi điều khiển.

Module I2C LCD ra đời và giải quyết vấn để này cho bạn.

Thay vì phải mất 6 chân vi điều khiển để kết nối với LCD 16×2 (RS, EN, D7, D6, D5 và D4) thì module IC2 bạn chỉ cần tốn 2 chân (SCL, SDA) để kết nối.

Module I2C hỗ trợ các loại LCD sử dụng driver HD44780(LCD 16×2, LCD 20×4, …) và tương thích với hầu hết các vi điều khiển hiện nay.

Ưu điểm

Tiết kiệm chân cho vi điều khiển.
Dễ dàng kết nối với LCD.

Thông số kĩ thuật

Điện áp hoạt động: 2.5-6V DC.
Hỗ trợ màn hình: LCD1602,1604,2004 (driver HD44780).
Giao tiếp: I2C.
Địa chỉ mặc định: 0X27 (có thể điều chỉnh bằng ngắn mạch chân A0/A1/A2).
Tích hợp Jump chốt để cung cấp đèn cho LCD hoặc ngắt.
Tích hợp biến trở xoay điều chỉnh độ tương phản cho LCD.

Để sử dụng màn hình LCD giao tiếp I2C sử dụng Arduino thì ta cần cài đặt thư viện Liquidcrystal_I2C. Tại đây

how to use 16x2 lcd display with arduino | arduino project with code — how to use 16×2 lcd display with arduino | arduino project with code

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.

Hướng dẫn kiểm tra màn hình LCD Arduino

Tiếp theo của bài viết mình sẽ hướng cho các bạn cách thực hiện bước kiểm tra màn hình LCD 16×2 với các bước sau:

Bước 1: Kết nối chân nguồn

Kết nối chân 5V của Arduino với đường nguồn dương (+) trên breadboard.
Kết nối chân GND của Arduino với đường nguồn âm (-) trên breadboard.
Cắm màn hình LCD vào breadboard.

Bước 2: Kết nối nguồn cho LCD

Kết nối chân 1 và 16 của LCD 16×2 với đường nguồn âm (-) trên breadboard.
Kết nối chân 2 và 15 của LCD 16×2 với đường nguồn dương (+) trên breadboard.

Bước 3: Thêm điện trở hạn dòng cho đèn nền (nếu cần)

Nếu màn hình LCD 1602 có điện trở hạn dòng cho đèn nền, hãy kiểm tra mặt sau của màn hình gần chân 15.
Nếu không có điện trở, hoặc các bạn không chắc chắn, hãy thêm một điện trở 220 ohm giữa chân 15 và đường nguồn dương (+).

Bước 4: Kết nối biến trở để điều chỉnh độ tương phản:

Kết nối một bên của biến trở 10K vào đường nguồn dương (+) trên breadboard.
Kết nối bên còn lại của biến trở vào đường nguồn âm (-) trên breadboard.
Kết nối nối giữa chân wiper của biến trở với chân 3 của màn hình LCD 16×2.

Bước 5: Bật Arduino và kiểm tra:

Bật Arduino để cấp nguồn cho màn hình LCD arduino.
Bạn sẽ thấy đèn nền của màn hình sáng lên.
Xoay núm biến trở, bạn sẽ thấy các hình chữ nhật đầu tiên xuất hiện.
Nếu bạn đã làm theo các bước trên và màn hình LCD hiển thị đúng, chúc mừng! Màn hình LCD 1602 của bạn hoạt động bình thường.

Displaying any name in LCD display using arduino uno |full code explained in hindi... — Displaying any name in LCD display using arduino uno |full code explained in hindi…

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