lcd module can be initialized by made in china

The ST7290 allows you to define up to four 16x16 bitmaps. These bitmaps can be shown in any 16-bit location in the DDRAM, occupying the place of two individual characters.

At startup, we can now load our bitmaps into one or more of the CGRAM locations. Let"s make outselves some Space Invader aliens!void load_custom_bitmaps() {

We write 1"s where we want a pixel lit up, and 0 where we want it dark. If you stand far away from your monitor, you may be able to make out the pictures embedded in the binary strings!

The 1.14inch LCD uses the PH2.0 8PIN interface, which can be connected to the Raspberry Pi according to the above table: (Please connect according to the pin definition table. The color of the wiring in the picture is for reference only, and the actual color shall prevail.)

The built-in controller used in this LCD is ST7789VW, which is an LCD controller with 240 x RGB x 320 pixels, while the pixels of this LCD itself is 135(H)RGB x 240(V). There are two types of horizontal and vertical screens, so the internal RAM of the LCD is not fully used.

The LCD supports 12-bit, 16-bit, and 18-bit input color formats per pixel, namely RGB444, RGB565, and RGB666 three color formats, this demo uses RGB565 color format, which is also a commonly used RGB format

Framebuffer uses a video output device to drive a video display device from a memory buffer containing complete frame data. Simply put, a memory area is used to store the display content, and the display content can be changed by changing the data in the memory.

We have carried out the low-level encapsulation, if you need to know the internal implementation can go to the corresponding directory to check, for the reason that the hardware platform and the internal implementation are different

2.We use Dev libraries by default. If you need to change to BCM2835 or WiringPi libraries ,please open RaspberryPi\c\Makefile and modify lines 13-15 as follows:

If you need to draw pictures, or display Chinese and English characters, we provide some basic functions here about some graphics processing in the directory RaspberryPi\c\lib\GUI\GUI_Paint.c(.h).

Select image buffer: The purpose of the selection is that you can create multiple image attributes, there can be multiple images buffer, you can select each image you create.

Draw rectangle: In the image buffer, draw a rectangle from (Xstart, Ystart) to (Xend, Yend), you can choose the color, the width of the line, whether to fill the inside of the rectangle.

Draw circle: In the image buffer, draw a circle of Radius with (X_Center Y_Center) as the center. You can choose the color, the width of the line, and whether to fill the inside of the circle.

Write Ascii character: In the image buffer, use (Xstart Ystart) as the left vertex, write an Ascii character, you can select Ascii visual character library, font foreground color, font background color.

Write English string: In the image buffer, use (Xstart Ystart) as the left vertex, write a string of English characters, you can choose Ascii visual character library, font foreground color, font background color.

Write Chinese string: in the image buffer, use (Xstart Ystart) as the left vertex, write a string of Chinese characters, you can choose character font, font foreground color, font background color of the GB2312 encoding

Write numbers: In the image buffer,use (Xstart Ystart) as the left vertex, write a string of numbers, you can choose Ascii visual character library, font foreground color, font background color.

Display time: in the image buffer,use (Xstart Ystart) as the left vertex, display time,you can choose Ascii visual character font, font foreground color, font background color.;

2. The module_init() function is automatically called in the INIT () initializer on the LCD, but the module_exit() function needs to be called by itself

Python has an image library PIL official library link, it do not need to write code from the logical layer like C, can directly call to the image library for image processing. The following will take 1.54inch LCD as an example, we provide a brief description for the demo.

Draw an inscribed circle in the square, the first parameter is a tuple of 4 elements, with (150, 15) as the upper left corner vertex of the square, (190, 55) as the lower right corner vertex of the square, specifying the level median line of the rectangular frame is the angle of 0 degrees, the second parameter indicates the starting angle, the third parameter indicates the ending angle, and fill = 0 indicates that the the color of the line is white.

The first parameter is the coordination of the enclosing rectangle. The second and third parameters are the beginning and end degrees of the circle. The fourth parameter is the fill color of the circle.

Note: Each character library contains different characters; If some characters cannot be displayed, it is recommended that you can refer to the encoding set ro used.

The first parameter is a tuple of 2 elements, with (40, 50) as the left vertex, the font is Font2, and the fill is the font color. You can directly make fill = "WHITE", because the regular color value is already defined Well, of course, you can also use fill = (128,255,128), the parentheses correspond to the values of the three RGB colors so that you can precisely control the color you want. The second sentence shows Micro Snow Electronics, using Font3, the font color is white.

Interfacing of 5V LCD with a 3.3V Controller like LPC1768 is little tricky to handle. This is the Article to explain how a 16x2 LCD is interfaced with LPC1768 in 4-bit mode. LCD in 4 bit, which means we are going to use 4 lines instead of 8 line which save 4 GPIOs which can be used for other purposes. For setting up the Environment for the development of ARM cortex M3 is well discussed in this article.

The LPC 1768 is ARM Cortex- M3 based Microcontrollers for embedded application features in low power consumption and a high level of integration. The ARM Cortex M3 is designed in a such way to enhance debug features and a higher level of system integration. It clocks at a CPU frequency of 100 MHz, and incorporates a 3-stage pipeline and uses a Harvard architecture with separate local instruction and data buses for third bus peripherals. The ARM Cortex- M3 CPU have an internal pre-fetch unit to support speculative branching. The peripheral components include 512KB of flash memory, 64kb of data memory, Ethernet MAC, USB OTG, 4 UART’s, 8-channel general purpose DMA controller, 2 SSP Controllers, 10-bit DAC, Quadrature encoder interface, SPI interface, 3 I2C bus interface, 2 input plus 2 outputs I2S bus interface, 4 general purpose timers, ultra-low power Real-Time Clock (RTC) with separate battery supply, and up to 70 general purpose I/O pins, 6-output general purpose PWM. The LPC1768/66/65/64 are pin-compatible with the 100-pin LPC236x ARM7-based Microcontroller series.

The Chinese LCD used here is JHD162A. It has a KS0066U/ HD44780U controller. It has a 16 pin interface device which consists of 2 rows with 16 characters each. The operating voltage is 5V. Also, it has an LED backlight. There are 2 modes of operation:

Once you have verified all the connections from MCU to HFC4050 to LCD Module, we can go ahead to display text on the LCD. But first, the LCD needs to be initialized properly. (According to the Datasheet) Before initializing the LCD, you will need to wait for a minimum time of about 15 milliseconds after the input voltage supply is stable and greater than 4.5 Volts.

The first step is to make sure that the RS and Enable are held LOW. Next is to input some commands to the LCD using the Data pins. These commands will not be executed until a pulse is supplied to the Enable pin. After supplying the command with a pulse, Enable has to be made High and then Low after a short delay. Then, the command is executed.

The LCD can be configured in 4-bit mode by sending the appropriate command which is called “Function set” to it. The Function set is a hexadecimal command of the LCD MPU unit, which selects working modes of the LCD. The “Function Set” is mentioned in following table:

According to the table, the value of Function Set for 4 –bit mode will be 0010 0000(0x20) because DL=0. The value “Function Set” for the LCD configuration 2 line (N=1), 5X7 dots (F=0) and 4-bit (DL=0) mode will be 0010 1000(0x28).

When the power supply is given to the LCD, it remains in 8-bit mode. Now, if 0x20 is sent, lower nibble will not be received by LCD because four data lines (D4-D7) are connected, so 0x02 is sent instead of 0x20. For more details about the LCD interfacing refer these Links.

In this section, we will start creating a project in Keil MDK we have already installed Keil µVision and Co-MDK Plug-in + CoLinkEx Drivers required for the CoLinkEx programming adapter. You can start by downloading the project files and kick start your practical experiment.

Connecting an LCD to your Raspberry Pi will spice up almost any project, but what if your pins are tied up with connections to other modules? No problem, just connect your LCD with I2C, it only uses two pins (well, four if you count the ground and power).

In this tutorial, I’ll show you everything you need to set up an LCD using I2C, but if you want to learn more about I2C and the details of how it works, check out our article Basics of the I2C Communication Protocol.

BONUS: I made a quick start guide for this tutorial that you can download and go back to later if you can’t set this up right now. It covers all of the steps, diagrams, and code you need to get started.

There are a couple ways to use I2C to connect an LCD to the Raspberry Pi. The simplest is to get an LCD with an I2C backpack. But the hardcore DIY way is to use a standard HD44780 LCD and connect it to the Pi via a chip called the PCF8574.

The PCF8574 converts the I2C signal sent from the Pi into a parallel signal that can be used by the LCD. Most I2C LCDs use the PCF8574 anyway. I’ll explain how to connect it both ways in a minute.

I’ll also show you how to program the LCD using Python, and provide examples for how to print and position the text, clear the screen, scroll text, print data from a sensor, print the date and time, and print the IP address of your Pi.

Connecting an LCD with an I2C backpack is pretty self-explanatory. Connect the SDA pin on the Pi to the SDA pin on the LCD, and the SCL pin on the Pi to the SCL pin on the LCD. The ground and Vcc pins will also need to be connected. Most LCDs can operate with 3.3V, but they’re meant to be run on 5V, so connect it to the 5V pin of the Pi if possible.

If you have an LCD without I2C and have a PCF8574 chip lying around, you can use it to connect your LCD with a little extra wiring. The PCF8574 is an 8 bit I/O expander which converts a parallel signal into I2C and vice-versa. The Raspberry Pi sends data to the PCF8574 via I2C. The PCF8574 then converts the I2C signal into a 4 bit parallel signal, which is relayed to the LCD.

Before we get into the programming, we need to make sure the I2C module is enabled on the Pi and install a couple tools that will make it easier to use I2C.

Now we need to install a program called I2C-tools, which will tell us the I2C address of the LCD when it’s connected to the Pi. So at the command prompt, enter sudo apt-get install i2c-tools.

Now reboot the Pi and log in again. With your LCD connected, enter i2cdetect -y 1 at the command prompt. This will show you a table of addresses for each I2C device connected to your Pi:

We’ll be using Python to program the LCD, so if this is your first time writing/running a Python program, you may want to check out How to Write and Run a Python Program on the Raspberry Pi before proceeding.

I found a Python I2C library that has a good set of functions and works pretty well. This library was originally posted here, then expanded and improved by GitHub user DenisFromHR.

There are a couple things you may need to change in the code above, depending on your set up. On line 19 there is a function that defines the port for the I2C bus (I2CBUS = 0). Older Raspberry Pi’s used port 0, but newer models use port 1. So depending on which RPi model you have, you might need to change this from 0 to 1.

The function mylcd.lcd_display_string() prints text to the screen and also lets you chose where to position it. The function is used as mylcd.lcd_display_string("TEXT TO PRINT", ROW, COLUMN). For example, the following code prints “Hello World!” to row 2, column 3:

On a 16×2 LCD, the rows are numbered 1 – 2, while the columns are numbered 0 – 15. So to print “Hello World!” at the first column of the top row, you would use mylcd.lcd_display_string("Hello World!", 1, 0).

You can use the time.sleep() function on line 7 to change the time (in seconds) the text stays on. The time the text stays off can be changed in the time.sleep() function on line 9. To end the program, press Ctrl-C.

You can create any pattern you want and print it to the display as a custom character. Each character is an array of 5 x 8 pixels. Up to 8 custom characters can be defined and stored in the LCD’s memory. This custom character generator will help you create the bit array needed to define the characters in the LCD memory.

The code below will display data from a DHT11 temperature and humidity sensor. Follow this tutorial for instructions on how to set up the DHT11 on the Raspberry Pi. The DHT11 signal pin is connected to BCM pin 4 (physical pin 7 of the RPi).

By inserting the variable from your sensor into the mylcd.lcd_display_string() function (line 22 in the code above) you can print the sensor data just like any other text string.

These programs are just basic examples of ways you can control text on your LCD. Try changing things around and combining the code to get some interesting effects. For example, you can make some fun animations by scrolling with custom characters. Don’t have enough screen space to output all of your sensor data? Just print and clear each reading for a couple seconds in a loop.

We know that December is often a planning and logistics heavy month. We want to let you know what to expect from your display supplier in the coming months. Chinese New Year Every year at this time, we at Crystalfontz are in mid-swing planning for Chinese New Year. Unfortunately for us but luckily for you, … Read more Display Supply Chain: What to Expect in 2021

The engineers at Crystalfontz are always working on new projects. Lately, the focus has been on tiny. How small? Recently they have evaluated using a part packaged in 0.4mm pitch 9-pin BGA, 1.3mm x 1.3mm: They are also looking at a 16-pin package that is 3mm x 3mm. The amount of power and complexity that … Read more Micro Tech

What is ISO Certification? ISO stands for International Organization for Standardization. It is an organization consisting of 161 national standards bodies based in Geneva, Switzerland. The purpose of ISO ensures an international standard of measuring and regulating products and services to ensure quality and safety at all points. From the ISO website: International Standards mean that consumers can have … Read more ISO 9001:2015 Certification for Crystalfontz

When working with a 20×4 character LCD, you might be surprised to see the controller set to 2-line mode: Write_To_LCD(COMMAND,0x38); //SET 2 LINE,5*8 FONT Why would a 4-line LCD’s controller be set to 2-line mode? It has to do with the way the LCD glass is laid out. Essentially the display is the right and … Read more FAQ: Why does the initialization code for a 20×4 LCD specify 2-line mode?

What is involved in ISO certification (and annual recertification) and what does it mean for a company to be ISO certified? This post takes a deeper look at everything involved in ISO certification for our LCD electronics-based company.

Confused about the differences between TFTs, LCDs, and OLEDs? What Do They Stand For? How Do They Work? TFT displays are also known as an “Active Matrix TFT LCD module” and have an array of thin film transistors fabricated on the glass that makes the LCD. There is one of these transistors for each pixel on the … Read more FAQ: What is the Difference Between a TFT, LCD, and OLED?

Sherman, set the wayback machine to 1985: We are going to take a look at the original HD44780 Data Sheet. Some time back, we wrote about the legendary HD44780 controller, to which the modern character LCD industry owes much of its existence. Having been in the business of designing embedded electronics for some time, we … Read more A Look Back in Tech History: The HD44780 Controller Data Sheet

Acronyms are easily recognizable and a quick shorthand when reading technical documents. But they can also be confusing when they are similar in appearance and what they represent. Memory and Character Generators New additions to the Crystalfontz Glossary: RAM, ROM, DDRAM, CGRAM, and CGROM. These glossary entries outline what these acronyms stand for and how … Read more RAM, ROM, GROM….What Do These Terms Mean?

Did you know that ePaper modules emulate ink used  for paper? Check out the meaning of the glossary term electrophoresis and how it relates to ePaper module displays. Need ePaper for Your Project? For assistance in determining what ePaper module is the best one for your application, please contact our knowledgeable and friendly support staff by email, phone, or … Read more A Quick ePaper Primer

Modern Character LCD display modules have been possible since 1987 when Hitachi introduced the HD44780 LCD controller. Since then, Hitachi no longer manufactures this integrated circuit (IC), but modern LCD controller ICs make it a point to be HD44780-compatible. Controller Compatibility The character LCD display modules offered by Crystalfontz America Inc. are no exception to … Read more The Legendary HD44780 Controller

Confused about the differences (and similarities) between OLEDs, PMOLEDs, and AMOLEDs? Quick Version: OLED stands for Organic Light Emitting Diode. PMOLED is Passive Matrix OLED — Passive Matrix Organic Light Emitting Diode. AMOLED is Active Matrix OLED. An Active Matrix OLED uses a TFT (Thin Film Transistor) transistor-per-pixel architecture. Learn More To find out more … Read more What is the Difference Between OLED, PMOLED, and AMOLED?

Most of the time I would agree with you, but not in this case. Since he is talking about "(LCD: 4 bit v. 8 bit)" he obviously is referring to the character mode LCDs driven by an HD44780 compatible controller. He verified this when he responded in reply #2. The answer is the same for all of them.

No and yes. The device actually starts up in 8-bit mode. Since it may actually be hooked up in a 4-bit system the first few instructions in the initialization sequence, the ones that are used to switch it out of the 8-bit mode if that is necessary, only require the use the of the upper four bits - the lower four bits are ignored even if they are hooked up.

The instructions used to perform the tasks of manipulating the data and pulsing the enable line each take some small multiple of 62.5nS. The time it takes to do these instructions in either mode is much less than the time that you have to wait until the LCD controller is ready for the next byte of data.

So, if you are simply sending a string of characters to the LCD it really doesn"t matter which mode you use. There are at least two ways you can speed things up: (1) by testing the busy flag to avoid having to wait the full 40 uS and (2) by doing something else while waiting for the 40 uS to elapse or for the busy flag to expire.

If you use either of these methods it may be possible to make the 8-bit interface perform better than the 4-bit interface, but don"t forget to make sure not to get it too fast since you cannot pulse the enable bit more often than every 500nS.

We have used Liquid Crystal Displays in the DroneBot Workshop many times before, but the one we are working with today has a bit of a twist – it’s a circle!  Perfect for creating electronic gauges and special effects.

LCD, or Liquid Crystal Displays, are great choices for many applications. They aren’t that power-hungry, they are available in monochrome or full-color models, and they are available in all shapes and sizes.

Waveshare actually has several round LCD modules, I chose the 1.28-inch model as it was readily available on Amazon. You could probably perform the same experiments using a different module, although you may require a different driver.

The above illustration shows the connections to the display.  The Waveshare display can be used with either 3.3 or 5-volt logic, the power supply voltage should match the logic level (although you CAN use a 5-volt supply with 3.3-volt logic).

Another difference is simply with the labeling on the display. There are two pins, one labeled SDA and the other labeled SCL. At a glance, you would assume that this is an I2C device, but it isn’t, it’s SPI just like the Waveshare device.

This display can be used for the experiments we will be doing with the ESP32, as that is a 3.3-volt logic microcontroller. You would need to use a voltage level converter if you wanted to use one of these with an Arduino Uno.

The Waveshare device comes with a cable for use with the display. Unfortunately, it only has female ends, which would be excellent for a Raspberry Pi (which is also supported) but not too handy for an Arduino Uno. I used short breadboard jumper wires to convert the ends into male ones suitable for the Arduino.

Once you have everything hooked up, you can start coding for the display. There are a few ways to do this, one of them is to grab the sample code thatWaveshare provides on their Wiki.

The Waveshare Wiki does provide some information about the display and a bit of sample code for a few common controllers. It’s a reasonable support page, unfortunately, it is the only support that Waveshare provides(I would have liked to see more examples and a tutorial, but I guess I’m spoiled by Adafruit and Sparkfun LOL).

Open the Arduino folder. Inside you’ll find quite a few folders, one for each display size that Waveshare supports. As I’m using the 1.28-inch model, I selected theLCD_1inch28folder.

Once you do that, you can open your Arduino IDE and then navigate to that folder. Inside the folder, there is a sketch file namedLCD_1inch28.inowhich you will want to open.

When you open the sketch, you’ll be greeted by an error message in your Arduino IDE. The error is that two of the files included in the sketch contain unrecognized characters. The IDE offers the suggestion of fixing these with the “Fix Encoder & Reload” function (in the Tools menu), but that won’t work.

The error just seems to be with a couple of the Chinese characters used in the comments of the sketch. You can just ignore the error, the sketch will compile correctly in spite of it.

The code is pretty basic, I’m not repeating all of it here, as it consists of several files.  But we can gather quite a bit of knowledge from the main file, as shown here.

You can see from the code that after loading some libraries we initialize the display, set its backlight level (you can use PWM on the BL pin to set the level), and paint a new image. We then proceed to draw lines and strings onto the display.

Unfortunately, Waveshare doesn’t offer documentation for this, but you can gather quite a bit of information by reading theLCD_Driver.cppfile, where the functions are somewhat documented.

After uploading the code, you will see the display show a fake “clock”. It’s a static display, but it does illustrate how you can use this with the Waveshare code.

This library is an extension of the Adafruit GFX library, which itself is one of the most popular display libraries around. Because of this, there isextensive documentation for this libraryavailable from Adafruit.  This makes the library an excellent choice for those who want to write their own applications.

The sketch finishes by printing some bizarre text on the display. The text is an excerpt from The Hitchhiker’s Guide to the Galaxy by Douglas Adams, and it’s a sample of Vogon poetry, which is considered to be the third-worst in the Galaxy!

Here is the hookup for the ESP32 and the GC9A01 display.  As with most ESP32 hookup diagrams, it is important to use the correct GPIO numbers instead of physical pins. The diagram shows the WROVER, so if you are using a different module you’ll need to consult its documentation to ensure that you hook it up properly.

The TFT_eSPI library is ideal for this, and several other, displays. You can install it through your Arduino IDE Library Manager, just search for “TFT_eSPI”.

There is a lot of demo code included with the library. Some of it is intended for other display sizes, but there are a few that you can use with your circular display.

To test out the display, you can use theColour_Test sketch, found inside the Test and Diagnostic menu item inside the library samples.  While this sketch was not made for this display, it is a good way to confirm that you have everything hooked up and configured properly.

A great demo code sample is theAnimated_dialsketch, which is found inside theSpritesmenu item.  This demonstration code will produce a “dial” indicator on the display, along with some simulated “data” (really just a random number generator).

In order to run this sketch, you’ll need to install another library. Install theTjpeg_DecoderLibrary from Library Manager. Once you do, the sketch will compile, and you can upload it to your ESP32.

You can also hook up some optional components to manually control the two “eyeballs”.  You’ll need an analog joystick and a couple of momentary contact, normally open pushbutton switches.

The Animated Eyes sketch can be found within the sample files for the TFT_eSPI library, under the “generic” folder.  Assuming that you have wired up the second GC9A01 display, you’ll want to use theAnimated_Eyes_2sketch.

The GC9A01 LCD module is a 1.28-inch round display that is useful for instrumentation and other similar projects. Today we will learn how to use this display with an Arduino Uno and an ESP32.

In the previous chapter, we have discussed how a character LCD is interfaced with a PIC microcontroller in 8-bit mode, where we used predefined characters stored in the LCD to display our data. In this article, we will learn more about the LCD and how we can create and use custom characters.

DDRAM or “Data Display Random Access Memory” is the working data buffer of the display. Each character on the display has a corresponding DDRAM location and the byte loaded in DDRAM controls which character is displayed.

CGROM or “Character Generation Read Only Memory” holds all the standard patterns for the 5 x 7 dot matrix characters. For instance, if you want to display character “A”, you would send ASCII code 65 (decimal) to the DDRAM. The display controller looks up the pattern of dots to display for this code in the CGROM and lights up the ones appropriate for “A”. The CGROM contents depend on the particular character set and model of display, US, Chinese etc. and cannot be changed.

CGRAM or “Character Generation Random Access Memory” allows the user to define special supplementary non-standard character types that are not in the CGROM. You can load your own dot pattern shapes and call these up for display.

For making custom patterns we need to write values to the CGRAM area defining which pixel to glow. These values are to be written in the CGRAM address starting from 0x40. CGRAM has a total of 64 Bytes. For LCD using 8×5 dots for each character, you can define a total of 8 user defined patterns (1 Byte for each row and 8 rows for each pattern).

To build a custom character we have to make a pixel-map of 8×5 and get the decimal value or hex value for each row. The bit value is 1 if the pixel is glowing and the bit value is 0 if the pixel is off. The final 8 values are loaded to the CGRAM one by one. The last row is usually left blank (0x00) for the cursor. If you are not using cursor then you can make use of that 8th row to get a bigger pattern.

We need to put these values in CGRAM. The CGRAM address starts from 0x40. We can store the data in any of the 8 available positions. To store this pattern in CGRAM we need to use a pointer containing the address of the pattern and the location at which we want to store the pattern.

Custom characters are assigned fixed display codes from 0 to 7 for pattern stored in the location pointed by CGRAM address 0x40, 0x48, 0x56… and so on. So, if the user wants to display second pattern (pattern stored at CGRAM address 0x48), simply call the data function with value 1 as an argument at a desired location in the LCD.

To display the sequence in the LCD, we need to specify the position on LCD and which pattern to display at the position. Provide adequate delay in between frames to observe the sequence distinctly.

Let’s interface LCD with LPC2148 ARM7 Microcontroller. In most of embedded systems applications, the need for a display is must. We can use display to represent text, numeric data or even graphics. JHD162A is a 16×2 character LCD module which is compatible to HD44780 drivers from Hitachi. The JHD162A has 16 pins and can be interfaced into 4-bit or 8-bit mode. We will get into that in a minute. In this tutorial we will be using 4-bit mode to interface LCD with LPC2148 Microcontroller.

NOTE: Procedure to interface LCD with LPC2148 ARM7 Microcontroller could be little bit different when compared to other 8-bit microcontrollers such as 8051, AVR and other chips which operates at 5V. Usually, LCD operates at 5V but LPC2148 operates at 3.3V. So we have to take care of this fact. Since, the board we will be using for our experiment have on board +5V so we don’t need to use any level shifter circuit. Otherwise, you may need to wire up additional circuitry. We’ll get into that later in circuit diagram.

The JHD162A has 16 Pins. This LCD controller can be operated in 4-bit or 8-bit mode. You can easily buy this cheap china made LCD in almost every supplier shop. Let’s first try to understand its pins and related functions. I recommend you to keep datasheet in-hand, to download click here: JHD162A LCD Datasheet

Before wiring up circuit between JHD162A LCD and LPC2148 Microcontroller. Let’s understand function of each pin provided on JHD162A LCD Module and are given as below:

PIN3 (VEE): This pin usually used to adjust a contrast. This is usually done by connecting 10K potentiometer to +5V and ground and then connecting slider pin to VEE of LCD Module. This voltage across VEE pin defines the contrast. In general case this voltage is between 0.4V to 0.9V.

PIN4 (RS): This pin referred as Register Select (RS). The JHD126A LCD has two registers called command register & data register. Logic HIGH (‘1’) at Pin RS selects data register and Logic LOW (‘0’) at Pin RS will select command register. When we make RS Pin HIGH and put data on data lines (DB0-DB7). It will be recognized as data. And if we make RS Pin LOW and put any value on data lines, then it will recognizes as a command.

PIN5(R/W): This Pin is used for selecting pin function between read and write mode. Logic HIGH (‘1’) at this pin activates read mode and Logic LOW at this pin activates write mode.

You might be wondering why we are using 4-bit and not 8-bit mode to Interface LCD with LPC2148 ARM7 Microcontroller. Here I have presented some differences.

4-bit data transfers also require a bit more code as, the lower nibble will need to be shifted into the upper nibble with each command and character transfer.

As we all aware that almost everything in this field is trade-off! We have to decide on an application by application basis, which is best approach to take.

To establish proper communication and interface between JHD162A LCD with LPC2148 Microcontroller. We need to supply commands in a given order to the data pins with small amount of delay in between to initialize LCD properly. These commands are listed in given table. We’ will use these commands in our program.

*This example project has been tested on STK2148-UltraLite Development Board.EXAMPLE PROJECT: Let’s display custom text on to LCD screen. Here we will interface JHD162A LCD with LPC2148 ARM7Microcontroller. The connection between LCD pins and LPC2148 into 4-bit mode has shown as below. We also have presented fully functioning program and free to download project.

This is how we can interface LCD with LPC2148 ARM7 Microcontroller to display text message on LCD screen. Since explanation of code is not in the scope of this tutorial, we will soon upload videos for code explanation. We will suggest you to play little bit around code to explore functionality of JHD162A LCD Module. We will use LCD in our future projects while displaying ADC data, Sensor output on LCD display. If you have any questions then feel free to leave a comment.

Today I am going to interface LCD to STM32 using an I2C device (PCF8574). PCF8574can be used as a port extender, to which LCD will be connected. If you haven’t read my previous post about I2C go check that out HERE.

The higher nibble of PCF8574address is 0100and this is fixed. But lower nibble can be modified according to our convenience.  The question you must be thinking is  why we need to modify lower nibble?

Well you generally don’t but as I mentioned in my previous article that we can connect up to 128 devices on the same I2C line and let’s say we want to connect two different LCDs on the same I2C line, than we can’t use two PCF8574 with same addresses and we need to modify one of them.

I want to point to one more thing here, the last bit of the address is kept 0 intentionally, because this bit is responsible for read(1)/ write(0) operation.

As shown in the figure above, first pin of the device is Vsswhich is pin 1 of LCD. So all you have to do is connect first pins of the LCD to Vssabove and rest will connect accordingly. Starting with Vss as first pin, connection is as follows:-

As according to the datasheet of the LCD 16×2, in order to initialize the LCD, we have to use some sequence of commands. The code is commented properly, so that you can understand it better