blue backlight lcd module 24064 free sample

NHD-24064WG-ATMI-VZ# | Monochrome Graphic Module | 240x64 Pixels | Transmissive LCD | Side White Backlight | STN (-) Negative Blue Display | Built-in Negative Voltage Supply

Newhaven 240x64 graphic Liquid Crystal Display module shows white pixels on a blue background. This transmissive LCD Display requires a backlight for visibility and offers a wide operating temperature range from -20 to 70 degrees Celsius. This NHD-24064WG-ATMI-VZ# display includes built-in negative voltage supply It has an optimal view of 6:00, operates at 5V supply voltage and is RoHS compliant.

* It can be customized for monochrome LCD, backlight, FPC and PCB Board with a little tooling charge, and customized shape is suitable for customer"s mechanical design.

* LED backlights are available in various colors including yellow/green, white, blue, and Backlight with different brightness is customized according to your request.

Extensive rangeProviding complete solution from Mono to Color LCD module, Optical bonding between display to cover glass as well as cover glass to touch screen

GLK SeriesGLK24064-25 Display4.02.92MiBManual for PCB revision 4.0 of the GLK24064-25, GLK24064-25-422, and GLK24064-25-USB displays including the LPC17xx processor.

GLT SeriesGLT24064 Display1.01.81MiBManual for PCB revision 1.0 of the GLK24064-25, GLK24064-25-422, GLK24064-25-USB, GLT24064, GLT24064-422, and GLT24064-USB displays released as a new board in 2010.

GLK SeriesGLK24064R-25-1U Display1.0176.94KiBAutocad .dwg style drawing of the Standard GLK24064R-25-1U, GLK24064R-25-1U-422, and GLK24064R-25-1U-USB displays.

GLK SeriesGLK24064R-25-1U Display1.0167.98KiBAutocad .dwg style drawing of the USB/RS422 GLK24064R-25-1U, GLK24064R-25-1U-422, and GLK24064R-25-1U-USB displays.

GLK SeriesGLK24064-25 Display1.01.81MiBManual for PCB revision 1.0 of the GLK24064-25, GLK24064-25-422, GLK24064-25-USB, GLT24064, GLT24064-422, and GLT24064-USB displays released as a new board in 2010.

GLT SeriesGLT24064 Display2.92MiBManual for PCB revision 4.0 of the GLT24064, GLT24064-422, and GLT24064-USB displays including the LPC17xx processor.

DocumentsEnd Of Life Notice99.03KiBEnd of Life of the 20x2 Character LCD FFSTN Yellow (-FY) Colour - All Products - February 8, 2010Products Affected:MOP-AL202C-BFTY

DocumentsEnd Of Life Notice99.69KiBEnd of Life of the 240x64 1U Graphic LCD Tricolour (-TC) Display - All Products - February 8, 2010Products Affected:MOP-GL24064R-BSST

DocumentsEnd Of Life Notice47.63KiBEnd of Life of the GLC24064 (PCB Rev2.0) - All Options - March 3, 2010Products Affected:GLC24064 (PCB Rev2.0) - All Colours

DocumentsEnd Of Life Notice225.11KiBEnd of Life of the GLK24064-16-1U (PCB Rev1.1) Series - All Options - February 8, 2013Products Affected:GLK24064-16-1U (PCB Rev1.1)

DocumentsEnd Of Life Notice107.37KiBEnd of Life of the GLK24064-25 (PCB Rev2.0) - All Options - August 31, 2010Products Affected:GLK24064-25 (PCB Rev2.0) - All Colours

DocumentsEnd Of Life Notice104.97KiBEnd of Life of the GLT24064 (PCB Rev3.0) Series - All Options - October 8, 2010Products Affected:GLT24064 (PCB Rev3.0)

* It can be customized for monochrome LCD, backlight, FPC and PCB Board with a little tooling charge, and customized shape is suitable for customer"s mechanical design.

* LED backlights are available in various colors including yellow/green, white, blue, and Backlight with different brightness is customized according to your request.

Extensive rangeProviding complete solution from Mono to Color LCD module, Optical bonding between display to cover glass as well as cover glass to touch screen

Except for the two decimal point LED"s, each segment is made up of three blue, high brightness LED"s in parallel. As there were only three LED"s for each segment I figured that would be better than putting them in series which would require a higher voltage and possibly complicate the controller circuit.

Each of the blue LED"s has a forward voltage drop of 3.2V and draws about 15mA so a single segment (that isn"t a decimal point) draws around 45mA and we would expect a total current draw of something like 630mA if all the main segments were on. To lower the current requirement we could use a higher limiting resistor at the cost of loss of brightness.

Liquid Crystal Displays (LCDs) have many advantages over other forms of display, for one thing they use very little current and because of that they have found themselves in many portable devices. That said, LCDs often require back lights and can be more difficult to read than other display technology such as LEDs.

It"s just as well that Intelligent LCDs were invented, which can use either a parallel or serial interface, and are designed to help out the programmer with displaying information on an LCD. The text only intelligent displays usually have a built-in character generator (that is, a ROM containing the graphical information of each character) and accept a limited amount of commands to display characters, scroll the display, move to a set position, and so on. This "intelligence" is thanks to one or more controller chips that are part of the LCD module, handling both input from the "outside world" and updating the LCD.

I had acquired 2 Novametrix 515C pulse oximeter units that were slightly different versions but both contained a graphic LCD module which has the identification "DMF-50427N" on them and is made by Optrex. The DMF-50427N displays 128 x 64 pixels with each pixel being black and the interface is a parallel type ideal to be connected to a simple CPU or microcontroller although the LCD module only understands a few commands. You can read more about the oximeter at:

The LCD module uses 2 hd61202 column (segment) drivers designed for dot matrix displays and for interfacing with a microcontroller or something similar. For the datasheet please click here:

I used an Arduino Uno to test the LCD and the sketch I wrote you can find for download at the bottom of this page as "Novametrix_515C_LCD_Test.ino". Download it, write the sketch to your Uno and then with the power off connect it to the LCD as follows (LCD pins numbers are included):

I have not used the LED backlight but to use it you will need to connect LED+ (19) to 5V via suitable limiting resistor (datasheet specifies maximum LED current of 60mA and forward voltage of 4.1V @ 30mA) and LED- (20) to GND. What you must do is supply the LCD contrast voltage to LCD VLC pin 3 which can be from approx. -7V to -9V, the voltage of which will adjust the LCD contrast. To generate the negative voltage you can use my power supply circuit from:

When you power the Arduino you should see on the LCD 4 rectangles of different sizes, if not, double check your connections and try adjusting the contrast voltage.

Now looking at the Arduino sketch if you go to the setup function you will see that the I/O is set up for communicating with the LCD; because the LCD is always in write mode (R/W is connected to GND) we never have to change the direction of the data pins (D0 to D7) but it is useful to be able to read information from the LCD such as whether it is busy executing an instruction (because of the use of digitalWrite() and its slowness it is not necessary to check if the LCD is still executing an instruction). After we have set up the I/O and set the default state we call LCD_rst() which simply takes RST low for 1ms and then returns it high, waiting another 1ms before exiting (which isn"t really necessary).

Back to setup() and we call LCD_send_command() twice to turn on both displays as after reset the LCD is in the off state. LCD_send_command() takes as inputs the instruction value to write to the LCD and the Arduino pin number of the LCD chip select I/O pin and then calls LCD_send_data() passing the input values and "false" so that LCD_send_data() knows that an instruction is being sent rather than display data. Function LCD_send_data() first sets LCD D/I to instruction mode (low) then sets D2 to D9 to the instruction value by writing to the Arduino ports directly so that we don"t need to use individual digitalWrite() to set each bit. Lastly, E (enable) goes low, the relevant driver chip is enabled by taking the input low and then both E and the chip select inputs go back high.

Returning to setup() again the next function we call is LCD_clr_disp() which clears the display by writing zeros to the entire display memory but the routine simply calls function LCD_write_all_disp() and passes zero as its input. Function LCD_write_all_disp() sets up a loop from 0 to 7 (LCD_max_X = 8) and at the start of the loop we set the X address for both driver chips. Horizontally we can access each pixel across by setting the Y address (which should really be called "X") and with each write to display memory Y will increase by 1 but vertically the X address (would be better called "Y") must be set which selects from 1 of 8 pages (using values 0 to 7). Each page is 64 x 8 pixels and writing a byte will set 8 pixels vertically. I"ll show it visually as the first page only:

In LCD_write_all_disp() we set the Y address to 0 before setting up another loop which goes from 0 to 63 so we can write to all 64 pixels horizontally for both driver chips (which will cover the 128 pixels across in total) by calling LCD_send_disp_data() which calls LCD_send_data() but tells it we want to write to display data by passing "true" for the second parameter.

Also in setup(), after LCD_clr_disp(), is the commented out call to function LCD_fill_disp() (un-comment to enable) which like LCD_clr_disp() calls LCD_write_all_disp() but gives it the value 0xFF so all pixels are written to. Toward the end of setup() there are 4 calls to LCD_draw_rect() to draw rectangles of different sizes and in turn LCD_draw_rect() calls LCD_draw_horiz_line() and LCD_draw_vert_line() to draw the 4 sides of the rectangle. Not that I"ve included the horizontal length (horiz_len) and vertical length (vert_len) with the starting pixel (top-left point) rather than the length being added on resulting in an extra pixel as I"ve seen with saw drawing routines. In LCD_draw_horiz_line() we first do some basic checks to make sure the X, Y and len values are valid and then we calculate LCD_disp_value so we can effectively move the line vertically into 1 of the 8 "slots". To get the X address it is just a matter of dividing the Y value by 8 and then we can set that for both driver chips regardless of which one will actually be used. Next, we test to see if the line starts on the left side of the display (chip 1) or the right side (chip 2) by comparing the X start value (X) and then remembering the result by updating variable update_LCD_left. With that out of the way we create a loop to count from 0 to length (len) - 1 so that we can write each pixel of the line horizontally. However, before we update the display we must check if we have moved from the left side of the display to the write by checking if the current coordinate X position (X_pos) if 64 or higher and if so then update_LCD_left is updated. Then we can call LCD_send_disp_data() for the appropriate driver chip with the previously calculated display value in LCD_disp_value.

On to function LCD_draw_vert_line() in which we check X, Y and len are valid and then determine whether we need to update the left or right side of the display and set variable update_LCD_left accordingly. We do a simple calculation to set x_count_limit to the number of line segments, that is, the number of X pages to update. Next we go into a loop to update each X page and at the beginning of the loop we calculate the current Y coordinate value (the pixel at the top of the X page) and then set the X page address value to the coordinate Y position/8 for whichever driver chip we are updating. To actually draw the line we set LCD_disp_value to 0xFF which is then shifted left or right to form the start or end of the line or if it"s a middle segment then 0xFF is outputted untouched as the line segment will be a completed 8 bits. The last thing to do is set the Y address as each display write will increase Y by 1 yet we are drawing a vertical line whose X coordinate value will not change, and we also send the display data by calling LCD_send_disp_data().

A big issue with the line and rectangle drawing routines is that they will overwrite any other display data close by and if a rectangle is drawn with horizontal or vertical length of 8 or less then likely it won"t display correctly as one of the lines drawn will be in the same X page. A workaround to fix the problem would either be to modify the circuit so that the LCD"s display memory can be read or to maintain a display buffer on the Arduino, so that new writes to the display can be combined with whatever is already in display memory. The sketch is only test code and it could do we more boundary checking but at least it shows off a little of what the display can do.

The "HD44780" and compatible intelligent LCD modules are able to display characters only and are very commonly used in a wide range of electronic devices such as in printers, vending machines and much more. These parallel intelligent LCDs are easy to use to the point that for testing purposes you can get one to display characters by using just switches! They are usually used in either 4 or 8-bit mode with the 4-bit mode requiring that both halves of the 8-bit data be sent one after another but having the advantage that fewer connections are needed. This is especially useful when, for e.g., you are interfacing an LCD module to a microcontroller that has few I/O.

You can get HD44780 LCD modules that can display only a few characters, and others that can show as many as eighty, either on one or more lines; these display modules all use a standard 14 connection pinout with one or two additional connections if there is a backlight (usually an LED). There are HD44780 LCD modules that can display more than eighty characters, however, they actually use more than one controller chip and have a different 16 (or more) connection pinout.

There are two basic modes for using an HD44780 LCD module: instruction mode and data mode. Instruction mode is used when you want to send the LCD module commands such as to clear the display or to turn the display on or off. The data mode is used to display characters on the LCD by sending it ASCII values representing the characters. A single input connection to the LCD module called RS (Register Select) selects whether the value on the data bus is to be interpreted as character data or an instruction.

It should be noted that not all characters in the ASCII standard are available as some are replaced with special symbols such as an arrow or the Yen character. That at least makes it more appealing to use worldwide but it you really need the missing characters you can create them yourself and then send them to the LCD module. There is only room for 8 custom characters, a limitation which it seems is due to the fixed length instructions. The custom characters are stored in RAM as part of the LCD module so they will remain as long as power is connected to the LCD module (and the custom characters start up in a random state when the LCD module first gets power). A unique feature concerning the custom characters is that if you modify them while one or more of them is being displayed, they will be updated immediately, making possible simple animations.

There are a couple of things to watch out for that you should be aware of when using these LCD modules. Firstly, HD44780 LCD modules normally initialize themselves when powered up with the display turned off. However, under certain conditions the LCD modules"s initialization may fail so it"s always best to manually initialize the LCD module using its built-in instructions. It"s a good idea to turn on the flashing cursor as a simple test to make sure the LCD module is working.

Another thing to watch out for is that the LCD module can be powered through a computer or microcontroller"s I/O without power connected to the LCD module"s power supply connections. Not only can this harm the LCD module but it also causes the LCD module to retain its current state (for e.g., what it is displaying). If you want to remove power from the LCD module while keeping the I/O connected then set the I/O to logic 0 before removing the power. The reason you may want to do this is to reset the LCD without turning off the computer or microcontroller.

The Raspberry Pi is a great little computer which can be connected to a HD44780 compatible LCD module using its GPIO as a way of outputting useful information, such as the date and time or the current temperature. In this example project I"ve used the LCD module in 4-bit mode so that only 6 GPIO signal connections are needed. The code initialises the LCD module and displays "Hello world!" on the first line along with the flashing cursor and has been tested on a Raspberry Pi B+ (but should work on other models).

It"s a good idea if possible to put the LCD module into breadboard along with the other components and then connect the Raspberry Pi GPIO pins to the breadboard using cables.

The Python code for this project can be found at the bottom of this page and is called gpio_hd44780_test.py. Since it uses GPIO it must be run from the terminal using the command sudo python gpio_hd44780_test.py. In about a second "Hello world!" should appear on the LCD along with the flashing cursor, if not check your connections and try adjusting the LCD contrast using the variable resistor.

Normally when interfacing with an LCD module such as the HD44780 we have to wait some time (well, seconds perhaps) for the LCD to start up. But since we are using the Raspberry Pi by the time the computer boots the LCD module would have started up and be ready to use. In addition, as Python is quite slow (as it uses an interpreter) we can get away with having less delays. In fact, the only delays in the program are when toggling the LCD enable pin.

In case the LCD"s built-in initialisation failed the Python code issues a function set command twice and then write further settings such as to put the LCD module to 4 bit mode. The function LCD_send_instr() is what writes a command to the LCD taking an 8-bit value as input before calling function LCD_send_data() which sends the byte as two lots of 4-bit data. Similar, function LCD_send_char() displays a single character on the LCD module but internally calls LCD_send_data(). The only difference is that LCD_send_instr() takes RS low to put the LCD into instruction mode whereas LCD_send_char() takes RS high to put the LCD into character mode. Lastly, function LCD_send_str() takes a string as input and outputs each character in turn by calling LCD_send_char().

At the very end of the program all GPIO are taken low so that it is safe to remove the LCD module from the 5V supply should you need to such as to reset the LCD. If one of the GPIO pins were high and you disconnected the 5V line from the LCD module it will still be powered by the GPIO which could harm the LCD and will prevent it from being reset.

This is great for testing out a so-called intelligent LCD which is nothing more than an LCD and dedicated controller chip on board, but does a lot of the hard work of working an LCD, especially one which is capable of at least limited graphics. This means you can interface the LCD module to a PC"s parallel port with not too much difficulty and once you have the software done, I"m sure you"ll find many uses for it. There are other options, such as using an USB connection, however, only the parallel port will be covered here as for most people it"s the easiest to program and use (if your computer has a parallel port).

Intelligent LCD modules can be divided into two main types and they are those which can display only characters with very limited graphics (by creating your own characters) and the ones that can display graphics as well as text which can be of different sizes and styles. I"ll be discussing the character only type below as they are the simplest to start with yet have many uses.

The LCD module that I used for this project came from a chucked out fax machine, and was made by Sharp with the code F2631XH-44 written on the circuit board. It uses the SEC C748B chip, compatible with the industry standard HD44780 so I was able to use it without any trouble. It is made up of two lines that are each eight characters long but instead of one line below the other they are side by side. In other words, when the two line mode is enabled for this LCD module it is actually a single line with 16 characters.

Another suitable intelligent LCD, which came from a security alarm (that was not needed!), is a Winstar WH1602B and has 16 connections, the extra two (15 and 16) are for the LED backlight. This LCD module has two lines that are 16 characters wide, one below the other. Obviously the more characters that can be displayed at once the better but the software will have to be adjusted accordingly. It can be a little tricky to use both lines as you have to tell the cursor to move to the start of the next line at a certain position and before that you have to enable two line mode (as already explained may be just an extension of the single line).

Although these LCD modules have an 8-bit interface which is ideal for your average CPU, microprocessor and parallel port the LCD can be be forced into 4-bit mode. In "nibble" mode you have to send one half of the byte after another which may seem a pain but the advantage is that you only need four connections (not including the other signals) instead of eight.