|
|
| PICAXE LCD Interfacing | |
|
|
|
| LCD's are often one of the most useful
interfaces which can be added to a microcontroller, either as part of a
self-contained project, or as a sub-system of a larger project.
Connecting an LCD to a PICAXE provides a simple and easy mechanism to provide a low-cost serially driven LCD display which can be connected to other PICAXE's, microcontrollers and even PC's and PDA's. The code detailed here has been specifically written
for LCD's which use the Hitachi HD44780 driver chips, which is by far the
great majority of LCD's which I have encountered.
All LCD's I have tested, in a variety of display size
formats ( from 1 x 8 to 4 x 20 ), from
a number of different manufacturers, which all use the HD44780 chip have
worked with the code and 100% compatible driver chips should also work,
but the code is not guaranteed to work with all HD44780-based devices, or
those which do not use the genuine Hitachi chip.
Note that the code will not work with 4 x 40 LCD's because
they are internally constructed from two 2 x 20 controllers and
require an additional control line.
The program code has been highly optimised, requiring just two
dedicated byte variables and uses just 51 bytes of program code space.
Important Notes
Hardware Interface
Software
LCD Control
PICAXE Documentation Errors It should also be noted that there is an error in the instructions
on how an LCD should be connected to the PICAXE in the Electronics
Interfacing Circuits datasheet as provided with the Programming Editor
software version 4.1.16 and earlier.
On some pages the connection instructions indicate that DB4 of the LCD
is connected to Output Pin 7 of the PICAXE, and correspondingly through to
DB7 being connected to Output Pin 4.
This is not correct. The connections described result in a 'swapped
nibble' which will prevent the LCD from working as expected. The correct
connections should be DB4 to Output Pin 4 through to DB7 to Output Pin 7.
The wiring connections on this page are, and always have been, correct in
this respect.
The instructions provided in the Electronics Interfacing
Circuits datasheet also indicate that the unused DB0 through DB4 lines
"should be" connected to 0V. This may not be necessary for all models of
LCD, and most datasheets for devices using the HD44780 driver indicate
that the unused lines can be left unconnected, or 'floating', as they are
in the circuits given later.
It is recommended that you consult your LCD datasheet to check the
requirements for connecting DB0 through DB3 in 4-bit mode, but conncting
them directly to 0V via low value resistors should not do any harm, nor
should connecting them directly to 0v providing that the LCD R/W
line is always connected to 0v.
Additionally, as recommended by Revolution Education Limited, the
connections to the LCD, DB4 to DB7, RS and E, can be made through 660R
resistors.
LCD Pin Numbering Note that the pin numbering shown for the LCD in the diagrams in this
document is that which is usually found on HD44780-based LCD modules, but
it is not the only scheme used.
Most LCD modules will have a single 14-way connector, and 16-way if
backlit, and are normally numbered as shown, with Pin 1 being
0V ( or "Vdd" ). The numbering can however be reversed, and
some modules are fitted with 2x7 and 2x8-way connectors, again with
varying pin numbering schemes.
Although not common, some LCD modules may have entirely different
pinouts to those shown.
You must determine the correct pinout and numbering scheme and the
connections required by the LCD from the user manual or other
documentation provided with the LCD before connecting the LCD, as
incorrect connection may cause permanent damage to the LCD, PICAXE or
both.
The connection information is provided as is and I cannot be
held repsonsible for the consequences arising from any incorrect
connection of an LCD.
Circuit Changes The information on this page was changed in May 2004 and the wiring
configuration and software is different to that used before then. The
earlier software will not work with the current wiring specified, and the
latest software will not work with the earlier wiring configuration.
The modification necessary to the old wiring configuration to be
compatible with the latest software is very simple to implement, involving
the swapping of two connection signals.
It came to my attention that the wiring configuration I was using was
different to that used in the Electronics Interfacing Circuit
datasheet ( AXE001_pic_electronics.pdf ) provided by
Revolution Education Limited - the connections for RS and E were
swapped - which meant that hardware had to be changed to use my own
code in place of Revolution Education Limited's.
In order to allow my code to simply replace theirs, I have rewritten my
software to be compatible and have changed my wiring configuration to
match this.
If you have previously used the information on this page to create an
LCD interface, it is recommended that you rewire your interface, swapping
RS with E, and modify your software accordingly.
Note that in this, and the following circuits, the Serial In line is
permanently connected to 0V. This is to simplify the circuit diagram; you
would normally include a Program Download interface for Serial In and
Serial Out connections.
The LCD is likely to be irreparably damaged by voltages which exceed 5V
by any considerable amount and especially when operated from a 6V power
supply, such as when using a 4 x 1.5V battery supply.
The LCD, although probably avoiding damage, may fail to operate
correctly ( and the display may appear blank or very
faint ) when the supply is much less than 5V, and problems may be
observed when operated from a 4.5V power supply, such as when using a
3 x 1.5V battery supply.
It is recommended that all LCD's are powered through a regulated 5V
power supply, preferably the same supply which is used to power the
PICAXE, but it may also be powered by a separate supply. When operating
with a separate supply, special consideration should be given to the
PICAXE power supply voltage as this will affect the voltages delivered on
the PICAXE Output Pins; if the voltage is too low, the PICAXE may not be
able to control the LCD correctly.
Take care not to inadvertently connect reverse power to the LCD as this
will almost certainly destroy the device.
You may therefore find that the LCD contrast is acceptable when the
'Vo' pin is wired directly to 0V or through a low value resistor; this
makes the LCD even simpler to wire-up and uses the minimum amount of board
space.
Note that some LCD's may be permanently damaged if 'Vo' is taken up to
5V or close to it, so check the datasheet and start with the contrast pot
set to provide 0V. If the contrast is externally adjustable, it would be a
wise precuation to put an additional resistor ( probably
2K2 ) between the top of the 10K potentiometer and the +5V supply to
limit 'Vo'.
Note that the 'get' variable is only used within the 'InitialiseLcd'
routine and therefore 'b11' can be re-used with your own program after the
LCD has been initialised.
The 'byte' variable is only used in the 'InitialiseLcd' routine and to
specify the data which is to be sent using the 'SendDataByte' and
'SendCommandByte' routines, and therefore 'b12' can be re-used within your
own program, although it will have its value changed when any of these
routines are called.
The 'rsbit' variable must be preserved intact during the operation of
the program and so 'b13' ( and consequently 'w6' ) must not
be used by your own code unless placed somewhere else and restored after
use.
The 'InitialiseLcd' routine must be called once, at the start of the
program.
The 'SendDataByte' and 'SendCmdByte' routines are used to send data
bytes to the LCD data and command registers respectively. This allows data
to be displayed on the LCD and the cursor and other attributes of the LCD
and its display to be altered. Before calling either of the two routines,
the data byte to be sent must be placed in the 'byte' variable. The value
put into the 'byte' variable is not changed when the routines are called.
Examples
As can be seen, the three routines are tightly integrated, which is the
key to the compactness of the program code.
The 'rsbit' variable is used to keep track of which register will be
written to next; the LCD Command or Data Register, and must be preserved
between calls to the 'SendDataByte:' routine. The 'SendCmdByte:' routine
simply sets the 'rsbit' varaible so the data written goes to the LCD
Command Register. The 'SendDataByte:' routine relies upon 'rsbit' being
set correctly when it is called, and always sets the 'rsbit' variable so a
subsequent call to the routine will send further data bytes to the LCD
Data Register.
The 'SendInitCmdByte:' routine is used solely to send nibble and byte
commands to the LCD Control Register during initialisation of the LCD. The
initialisation routines for an LCD are very clearly defined, and those
familiar with them will observe that the initialisation used in this code
does not conform entirely to the sequence and timing specified.
This has not been shown to be a problem in practice, and all HD44780-based
LCD's which I have tested have initialised and worked fine with the code,
although it may not work with all HD44780-based devices or non-Hitachi
chipsets, even those which claim to be 100% compatible.
In most LCD initialisation code, you will see a variety of delays used
which decrease as initialisation progresses. This code uses a fixed delay
of 15mS between each byte sent ( and very little delay between
the two nibbles of each byte ). Although this adds unneccessary delay
to initialisation, it amounts to less than 100mS overall, and is a price
worth paying for the huge reduction in program code it achieves.
The 'PAUSE 15' delay is fine at 4MHz, but will usually need to be
extended to 'PAUSE 30' when operating at 8MHz and to 'PAUSE 60' at 16MHz.
The two 'PULSOUT E,1' statements are suitable for any speed operation.
The routines rely upon their own execution times to ensure that data is
not sent before the LCD is ready for the next data sent, which is fine for
all but two commands sent to the LCD Command Register - Clear
Display ($01) and Return Home ($02 and $03). The speed of PICAXE
execution should mean that there is no problem with these commands at even
16MHz operation, but should any problems be encountered using these
commands, it may be necessary to add a 2mS delay after they are issued. It
is worthwhile trying your code without the delays first, as it is unlikely
you will have a program which causes a problem. The Return Home command
can usually be replaced by a command which explicitly sets the next
character position to be written to - Set DDRAM Address
0 ($80) - which requires no delay after execution. The only time
this may not be possible is if you are deliberately shifting or scrolling
the display under program control to achieve some desired effect.
If it is not desirable to have these two bits cleared while interacting
with the LCD, the rouines can be modified as follows ...
The trick used is to recover the contents of SFR at location $30 which
is a copy of the current output pin levels. This allows the levels of
Output Pins 0 and 1 to be recovered and then set as they were previously
when the 'pins =' assignments are performed.
The routines require slightly more code space than the best optimised
versions, but it is no longer necessary to preserve the 'rsbit' variable
between calls to the 'SendCmdByte:' and 'SendDataByte:' routines. This
variable can be used outside the routines but it will be corrupted
whenever the routines are called.
For the program to work correctly, the LCD must be attached to the
PICAXE as shown in the diagrams at the top of the page.
 The commonest commands that will be sent to the LCD are as follows - Clearing the display ... byte = $01 : GOSUB SendCmdByte ; Clear Display
PAUSE 2 ; Delay may not be needed
Specifying where to write to .. byte = $80 : GOSUB SendCmdByte ; Start of Line 1
byte = $C0 : GOSUB SendCmdByte ; Start of Line 2
byte = $A0 : GOSUB SendCmdByte ; Start of Line 3
byte = $E0 : GOSUB SendCmdByte ; Start of Line 4
Programming User-Defined Charaters ... byte = $40 : GOSUB SendCmdByte ; User-Defined Character 0
byte = $48 : GOSUB SendCmdByte ; User-Defined Character 1
byte = $50 : GOSUB SendCmdByte ; User-Defined Character 2
byte = $58 : GOSUB SendCmdByte ; User-Defined Character 3
byte = $60 : GOSUB SendCmdByte ; User-Defined Character 4
byte = $68 : GOSUB SendCmdByte ; User-Defined Character 5
byte = $70 : GOSUB SendCmdByte ; User-Defined Character 6
byte = $78 : GOSUB SendCmdByte ; User-Defined Character 7
Character Addresses are sent to the LCD by using the following code ... byte = ... ; Set Character Address
GOSUB SendCmdByte
The value assigned to the 'byte' variable will determine the Character Address and will depend upon the character position where you wish to place the character and the size of the display ... 8 x 1 - 8 characters x 1 line
8 x 2 - 8 characters x 2 lines
Line 2 : $C0 .. $C7 16 x 1 - 16 characters x 1 line
Note that the 16 x 1 display is actually an 8 x 2 internally which is re-arranged to give the correct display. After writing the 7th character, the character address has to be changed to the start of Line 2 to write the 8th character. 16 x 2 - 16 characters x 2 lines
Line 2 : $C0 .. $CF 16 x 4 - 16 characters x 4 lines
Line 2 : $C0 .. $CF Line 3 : $A0 .. $AF Line 4 : $E0 .. $EF 20 x 1 - 20 characters x 1 line
20 x 2 - 20 characters x 2 lines
Line 2 : $C0 .. $D3 20 x 4 - 20 characters x 4 lines
Line 2 : $C0 .. $D3 Line 3 : $A0 .. $B3 Line 4 : $E0 .. $F3
User-Defined CharactersUser defined characters are exactly like other characters which can be displayed on the LCD but rather than have their 'image' defined in unchangeable Read Only Memory, the image is defined as a 'pixel bitmap' which is held in writeable memory.There are eight User-Defined Characters which can be displayed by simply telling the LCD to display the charcters $00 to $07 ... GOSUB InitialiseLcd ; Initialise the LCD
FOR b0 = $00 to $07 ; Display user defined characters
byte = b0
GOSUB SendDataByte
NEXT
If you run this program, you will most likely find that the display shows little but gibberish; this is because the character bitmaps have not been defined and have no meaningful values whenever the LCD is powered-up. Every User-Defined Character is made up from a 7x5 bitmap; seven lines of five bits, and these are held in eight consecutive bytes of memory within the LCD chip. Each byte of memory holds one line's worth of pixels; the three most significant bytes are zero, the remaining five bits per byte, left to right, make up that charcter's line display, also left to right, when displayed. The eigth byte of the image map should be set to zero. The data values to define a User-Defined Character have a bit set to represent where a pixel is on in the image, and a cleared (zero) bit when off. The following shows the data values to create a better looking 'g' that the one which is normally displayed .. Line 1 %00000 -----
Line 2 %00000 -----
Line 3 %01110 -###-
Line 4 %10001 #---#
Line 5 %01111 -####
Line 6 %00001 ----#
Line 7 %01110 -###-
Line 8 %00000 -----
To program the bitmap for a User-Defined Character into the LCD, a command must be sent to the LCD Command Register to indicate which User-Definded Character is to be programmed, followed by the bitmap which is sent to the LCD Data Register. The command needed to specify the character to program the bitmap for has the following format - %01ccc000 Where 'ccc' is the number of the User-Defined Character, 0 to 7. The value for the command can either be determined before writing the code or may be calculated at runtime. The following code demonstrates how to program the bitmap to be used as User-Defined Character number 3, and displays it on the LCD ... GOSUB InitialiseLcd ; Initialise the LCD
byte = 3 * 8 | $40 ; Program User Defined Character 3
GOSUB SendCmdByte
byte = %11111 : GOSUB SendDataByte ; #####
byte = %10001 : GOSUB SendDataByte ; # #
byte = %11111 : GOSUB SendDataByte ; #####
byte = %00100 : GOSUB SendDataByte ; #
byte = %10101 : GOSUB SendDataByte ; # # #
byte = %01110 : GOSUB SendDataByte ; ###
byte = %00100 : GOSUB SendDataByte ; #
byte = %00000 : GOSUB SendDataByte ;
byte = $80 ; Display at start of Line 1
GOSUB SendCmdByte
byte = $03 ; Display User Defined Character 3
GOSUB SendDataByte
An alternative, and less program code hungry solution to programming User-Defined Characters is to store the character definitions in Eeprom as follows ... GOSUB InitialiseLcd ; Initialise the LCD
EEPROM $40,(3) ; Program User Defined Character 3
EEPROM ( %11111 ) ; #####
EEPROM ( %10001 ) ; # #
EEPROM ( %11111 ) ; #####
EEPROM ( %00100 ) ; #
EEPROM ( %10101 ) ; # # #
EEPROM ( %01110 ) ; ###
EEPROM ( %00100 ) ; #
EEPROM ( $80 ) ;
get = $40 ; Point to Eeprom
GOSUB ProgramCgRam ; Define User-Define Character
byte = $80 ; Display at start of Line 1
GOSUB SendCmdByte
byte = $03 ; Display User Defined Character 3
GOSUB SendDataByte
END
ProgramCgRam:
READ get,byte
byte = byte * 8 | $40
GOSUB SendCmdByte
ProgramCgRamLine:
get = get + 1
READ get,byte
GOSUB SendDataByte
IF byte < $80 THEN ProgramCgRamLine
RETURN
Note that in both cases it is necessary to re-position the cursor before sending data for display to the screen having completed a User-Defined Character definition. For this reason, it is usually common to have User-Defined Character Definitions at the start of the program, immediately after initialisation, knowing that the cursor will be positioned before any data is written for display. One of the great uses for User-Defined Characters is in re-defining the displayed images for lower-case 'g', 'p' 'q' and 'y' characters. Because the bottom, eight, line of the character can be displayed, it is possible to create a 'true descender'. In some cases this may clash with the rest of the display's appearance, but the display can still often be improved. The following profgram will display five 'g' characters, the first, third and fith are the normal 'g', the second is the improved version ( using User-Defined Character 1 ) and the fourth with a true descender ( using User-Defined Character 2 ) ... GOSUB InitialiseLcd ; Initialise the LCD
EEPROM $40,(1) ; Program User Defined Character 1
EEPROM ( %00000 ) ;
EEPROM ( %00000 ) ;
EEPROM ( %01111 ) ; ####
EEPROM ( %10001 ) ; # #
EEPROM ( %01111 ) ; ####
EEPROM ( %00001 ) ; #
EEPROM ( %01110 ) ; ###
EEPROM ( $80 ) ;
EEPROM $50,(2) ; Program User Defined Character 2
EEPROM ( %00000 ) ;
EEPROM ( %00000 ) ;
EEPROM ( %01111 ) ; ####
EEPROM ( %10001 ) ; # #
EEPROM ( %10001 ) ; # #
EEPROM ( %01111 ) ; ####
EEPROM ( %00001 ) ; #
EEPROM ( $8E ) ; ###
get = $40 ; Point to Eeprom
GOSUB ProgramCgRam ; Define User-Define Character
get = $50 ; Point to Eeprom
GOSUB ProgramCgRam ; Define User-Define Character
byte = $80 ; Display at start of Line 1
GOSUB SendCmdByte
byte = "g" ; Display Default 'g'
GOSUB SendDataByte
byte = $01 ; Display User Defined Character 1
GOSUB SendDataByte
byte = "g" ; Display Default 'g'
GOSUB SendDataByte
byte = $02 ; Display User Defined Character 2
GOSUB SendDataByte
byte = "g" ; Display Default 'g'
GOSUB SendDataByte
PICAXE is a trademark of Revolution Education Ltd. PICmicro is a registered trademark of Microchip Inc. | ||||
| First
published on Wednesday the 3rd of December, 2003 at 18:09:58 Last upload was on Tuesday the 18th of January, 2005 at 01:49:59 |
