Newbies' guide to parallel HD44780 LCDs and Winstar OLEDs / AXE133 as a project board

nick12ab

Senior Member
#1
Everyone's probably noticed by now that I think parallel LCDs are better than serial LCDs. The most common issues with serial LCDs are that they are slow and the serout command can cause conflicts with interrups, background hardware serial, i2c slave mode and the timer. Additional disadvantages include the extra power consumption of the additional microcontroller, the bulk added by the serial backpack and the potential for errors to happen if the oscillator in either microcontroller drifts too much.

Newbies are often scared off by the idea of using a parallel LCD or OLED particularly when reading in the HD44780 or WS0010 datasheet stuff about 4/8-bit mode and 'initialization sequences' plus there are a lot of pins to connect. There is no need to be scared - LCD serial controllers don't actually do much more than send whatever you send it over the serial connection to the parallel LCD using the parallel interface plus if you're worried about connecting to the PICAXE to the LCD incorrectly then you can use the AXE133 as this has a PICAXE-18M2 which you can reprogram on it. The PICAXE-18M2 on the AXE133 has some spare pins so you can use the AXE133 as an entire project board! See the AXE133 pdf for a circuit.

Hopefully this 'tutorial' will help users new to LCDs finish a project involving i2c slave mode/the timer/background hardware serial which they would have given up on had they continued to use a serial LCD, plus they will get to experience the additional benefits of the parallel LCD which include:
  • Lower cost - parallel LCDs are practically given away on eBay.
  • More compact project - use of a parallel LCD eliminates the need for a bulky serial backpack or (if using the AXE133 as a project board) the need for an additional project board.
  • Lower power consumption - serial displays use an additional microcontroller and this consumes power.
  • The ability to read data from the LCD - AFAIK there is no serial LCD on the market that lets you do this but then again very few people actually need to do this! But it's still an advantage to have it if you want it.
  • Faster - the parallel interface is faster than any serial display and this is particularly true for an LCD at 2400 baud. Most serial LCDs (including the AXE033) consist of a parallel LCD and microcontroller to convert the serial data to parallel so from that you can see that it is impossible for a serial LCD to be as fast as a parallel LCD. An example of how you can exploit this extra speed is to have a 'firmware update' screen where about twice a second the PICAXE writes the string 'Updating...' to the screen; issues the disconnect command; issues the reconnect command; writes the string 'Ready' or similar to the screen, and when no attempt is being made to program the PICAXE the screen will just say 'Ready' but as soon as the download is started it will change to 'Updating'.
A disadvantage is that a parallel LCD requires more pins, but since PICAXEs in many different sizes are available you can use a larger PICAXE. This tutorial will use a PICAXE-18M2 like the AXE133.
[HR][/HR]On a HD44780-compatible parallel LCD or Winstar OLED, when used in 8-bit mode, there is an 8-bit data bus, a register select (rs) pin, an enable pin and a read/write (r/w) pin. Since very few people need to read from the display we don't need the r/w pin so the LCD can be put in write mode by connecting this pin to 0V. That leaves 10 pins. The 8-bit data bus should ideally be connected to a single port and the other two pins can be connected to any other output pin. On the AXE133, the data bus is connected to pinsB, the rs pin to C.7 and the enable pin to C.6.

When the rs pin is low, the LCD is in instruction mode and when the rs pin is high, the LCD is in data mode. When the enable pin is pulsed, the LCD 'grabs' the data from the data bus and what it does with the data depends on whether the rs pin is high or low.

'Sending data to the LCD': This term will refer to putting the data or instruction on the data bus (e.g. by using let pinsB = x) and pulsing the enable pin.

Serial LCD users will be aware that to reposition the cursor you send 254 then the cursor position and to display text you simply send the text in the serout command. If you look at this part of the AXE133 code, you will see that when 254 is sent to the serial driver, the rs pin is made low (to put the LCD in instruction mode); the driver waits for another byte and this is 'sent to the LCD' (the second byte is put on pinsB unprocessed and enable is pulsed); finally the rs pin is made high again. When you send serial data to the driver without preceding it with 254, the rs pin is left high so the LCD is in data mode and the received bytes are sent unprocessed to the LCD.
Code:
main:

	serin RX,baud,b1			; wait for the next byte

	; NB keep character mode test as first item in this list to optimise speed
	if b1 < 253 then
		let pinsB = b1 		; output the data
		pulsout enable,1  	; pulse the enable pin to send data.
		goto main			; quickly loop back to top
	else if b1 = 254 then
		low rs 	     		; change to command mode for next character
		serin RX,baud,b1		; wait for the command byte
		let pinsB = b1 		; output the data
		pulsout enable,1  	; pulse the enable pin to send data.
		high rs			; back to character mode
		goto main			; quickly loop back to top
	else if b1 = 253 then
		serin RX,baud,b1		; wait for the next byte
		gosub msg			; do the 16 character message
		goto main			; back to top
	else ; must be 255
		serin RX,baud,b1		; wait for the next byte
		let pinsC = b1 & %00000111 | %10000000
						; output the data on C.0 to C.1, keep RS high
		goto main			; back to top
	end if
So to summarize, on a parallel display to do the equivalent of sending 254,x you make rs low when sending the data to the display and to do the equivalent of simply sending x you make rs high when sending the data to the display. Got that? Make sure you've understood this before moving on.
[HR][/HR]Getting Started

You should define rs and enable as pin constants and lcddata as a name for pinsB at the very top of your program. You should also use the picaxe directive to state which PICAXE you are using:
Code:
#picaxe 18m2
symbol lcddata = pinsB
symbol rs = C.7
symbol enable = C.6
Note: All this code here will be downloaded onto the AXE133 PICAXE, not whatever PICAXE you have connected to the AXE133 using the serial connection.

You also need to set all the data bus pins as outputs, as well as enable and rs:
Code:
start:
	dirsB = 255											'Set pinsB as outputs
	low rs											'instruction mode
	output enable										'set enable pin as output
One thing that a serial driver will do for you is to initialize the LCD (or OLED). When using the parallel display you have to do this yourself but this is a simple process. All you need to do is send a few instructions to the LCD. The instructions for initializing the display require a relatively long pulse (it's still quite short!) and I calculated the pulsout values in the code you'll soon see for a PICAXE running at 16Mhz based on the timings in the HD44780 datasheet. Don't forget that the PICAXE will automatically run at 16Mhz if you decide to use multitasking so it doesn't hurt to have the longer pulse lengths.

To initialize the display, you need to send four instructions to the display: Entry mode set; Display on/off control; Function Set; Clear Display. When testing, I found that it didn't matter which order this was done in but it's best to send the Clear Display instruction before the Display on/off control instruction because (in the case of the OLED) turning on the display before clearing it can cause random characters to be briefly displayed. The Winstar OLED datasheet suggests putting Entry Mode Set last so this is the order I will use (tested and working on both OLED and LCD): Function Set; Clear Display; Display on/off control; Entry mode set.

The Winstar OLED has the addition of font selection in the Function Set instruction and this is ignored by LCDs so you can choose to have any of the four founts available when using the OLED without it preventing a HD44780 LCD working if used instead of the OLED and all the code here will work on both OLEDs and LCDs. More details about the initialization instructions are available on page 24 of both the HD44780 and WS0010 datasheets.

Here is the code:
Code:
	lcddata = %00111011 : pulsout enable,16			'Function Set: 8-bit, 2 lines, font 11
	lcddata = %00000001 : pulsout enable,608			'Clear display
	lcddata = %00001100 : pulsout enable,608			'Display on/off control: Display on, cursor off, blink off
	lcddata = %00000110 : pulsout enable,16			'Entry mode set: Increment, cursor shift
That's it - all the 'hard stuff' done. This should be all the code you have so far:
Code:
#picaxe 18m2
symbol lcddata = pinsB
symbol rs = C.7
symbol enable = C.6

start:
	dirsB = 255								'Set pinsB as outputs
	low rs								'instruction mode
	output enable							'set enable pin as output
	
	lcddata = %00111011 : pulsout enable,16			'Function Set: 8-bit, 2 lines, font 11
	lcddata = %00000001 : pulsout enable,608			'Clear display
	lcddata = %00001100 : pulsout enable,608			'Display on/off control: Display on, cursor off, blink off
	lcddata = %00000110 : pulsout enable,16			'Entry mode set: Increment, cursor shift
(continued...)
 

nick12ab

Senior Member
#2
Displaying Something

All these examples go after the code from above.

Here is some example code to display a message:
Code:
main:
	low rs
	lcddata = 128 : pulsout enable,1
	high rs
	lcddata = "H" : pulsout enable,1
	lcddata = "E" : pulsout enable,1
	lcddata = "L" : pulsout enable,1
	lcddata = "L" : pulsout enable,1
	lcddata = "O" : pulsout enable,1
	do : loop
The example above will display "HELLO" on the LCD or OLED display. The first low rs isn't necessary as rs is already low from the initialization sequence but if this code is used elsewhere rs might not be low so that's why it's there for the example.

lcdtutorial2.JPG

"All that just to achieve this!"

There is no dedicated command on the PICAXE so you will have to use more than one command to display something, but if you have a long string to display, you can do it in a loop:
Code:
main:
	low rs
	lcddata = 128 : pulsout enable,1
	high rs
	for b4 = 0 to 15
		lookup b4,("LCD/OLED LINE 1 "),lcddata
		pulsout enable,1
	next
	do : loop
You can't use # to display a variable when using a parallel display like you can when using a serial display. So an alternative is to use the bintoascii command instead. This example will display the string "time w13" on the top line and display the value of time and w13 on the bottom line. w13 is a word variable that is incremented each time the loop is executed.
Code:
main:
	low rs
	lcddata = 128 : pulsout enable,1
	high rs
	for b4 = 0 to 15
		lookup b4,("time         w13"),lcddata
		pulsout enable,1
	next
	do
		low rs
		lcddata = 192 : pulsout enable,1
		high rs
		inc w13
		bintoascii time,b5,b6,b7,b8,b9
		bintoascii w13,b10,b11,b12,b13,b14
		for b4 = 0 to 15
			lookup b4,(b5,b6,b7,b8,b9,"      ",b10,b11,b12,b13,b14),lcddata
			pulsout enable,1
		next
	loop
You'll notice that there are leading zeros displayed. When using # with the serout command there are no leading zeros but there is also no leading space which often makes # inconvenient but sometimes it is useful. Leading spaces will be covered first. You need to check each ASCII digit to see if it a 0 or not and once a non-zero digit is found, stop checking, because you don't want any zero digits after non-zero digits to be blanked. Cascading IFs will do this:
Code:
main:
	low rs
	lcddata = 128 : pulsout enable,1
	high rs
	for b4 = 0 to 15
		lookup b4,("time         w13"),lcddata
		pulsout enable,1
	next
	do
		low rs
		lcddata = 192 : pulsout enable,1
		high rs
		inc w13
		bintoascii time,b5,b6,b7,b8,b9
		if b5 = "0" then
			b5 = " "
			if b6 = "0" then
				b6 = " "
				if b7 = "0" then
					b7 = " "
					if b8 = "0" then
						b8 = " "
					end if
				end if
			end if
		end if
		bintoascii w13,b10,b11,b12,b13,b14
		if b10 = "0" then
			b10 = " "
			if b11 = "0" then
				b11 = " "
				if b12 = "0" then
					b12 = " "
					if b13 = "0" then
						b13 = " "
					end if
				end if
			end if
		end if
		for b4 = 0 to 15
			lookup b4,(b5,b6,b7,b8,b9,"      ",b10,b11,b12,b13,b14),lcddata
			pulsout enable,1
		next
	loop
You'll notice that in both of the above examples w13 does not increment incredibly quickly although it is still quicker than a serial LCD. Lookup isn't a very fast command on PICAXE and the rapid display of numbers can be done more efficiently by doing it the same way as the string was displayed in the first example. Since the characters in the middle of the display don't need to be constantly overwritten, the cursor is repositioned with an instruction halfway through the code (by making rs low, sending 203 to the display and finally making rs high again for the data (characters) that follow.
Code:
main:
	low rs
	lcddata = 128 : pulsout enable,1
	high rs
	for b4 = 0 to 15
		lookup b4,("time         w13"),lcddata
		pulsout enable,1
	next
	do
		low rs
		lcddata = 192 : pulsout enable,1
		high rs
		inc w13
		bintoascii time,b5,b6,b7,b8,b9
		if b5 = "0" then
			b5 = " "
			if b6 = "0" then
				b6 = " "
				if b7 = "0" then
					b7 = " "
					if b8 = "0" then
						b8 = " "
					end if
				end if
			end if
		end if
		lcddata = b5 : pulsout enable,1
		lcddata = b6 : pulsout enable,1
		lcddata = b7 : pulsout enable,1
		lcddata = b8 : pulsout enable,1
		lcddata = b9 : pulsout enable,1
		low rs
		lcddata = 203 : pulsout enable,1
		high rs
		bintoascii w13,b5,b6,b7,b8,b9
		if b5 = "0" then
			b5 = " "
			if b6 = "0" then
				b6 = " "
				if b7 = "0" then
					b7 = " "
					if b8 = "0" then
						b8 = " "
					end if
				end if
			end if
		end if
		lcddata = b5 : pulsout enable,1
		lcddata = b6 : pulsout enable,1
		lcddata = b7 : pulsout enable,1
		lcddata = b8 : pulsout enable,1
		lcddata = b9 : pulsout enable,1
	loop
In these examples, it would look better if the time variable was displayed without the leading spaces. This is also achieved by using if statements. A digit is only sent to the display if itself or any preceding digits are non-zero.
Code:
main:
	low rs
	lcddata = 128 : pulsout enable,1
	high rs
	for b4 = 0 to 15
		lookup b4,("time         w13"),lcddata
		pulsout enable,1
	next
	do
		low rs
		lcddata = 192 : pulsout enable,1
		high rs
		inc w13
		bintoascii time,b5,b6,b7,b8,b9
		if b5 <> "0" then : lcddata = b5 : pulsout enable,1 : end if
		if b5 <> "0" or b6 <> "0" then : lcddata = b6 : pulsout enable,1 : end if
		if b5 <> "0" or b6 <> "0" or b7 <> "0" then : lcddata = b7 : pulsout enable,1 : end if
		if b5 <> "0" or b6 <> "0" or b7 <> "0" or b8 <> "0" then : lcddata = b8 : pulsout enable,1 : end if
		lcddata = b9 : pulsout enable,1
		low rs
		lcddata = 203 : pulsout enable,1
		high rs
		bintoascii w13,b5,b6,b7,b8,b9
		if b5 = "0" then
			b5 = " "
			if b6 = "0" then
				b6 = " "
				if b7 = "0" then
					b7 = " "
					if b8 = "0" then
						b8 = " "
					end if
				end if
			end if
		end if
		lcddata = b5 : pulsout enable,1
		lcddata = b6 : pulsout enable,1
		lcddata = b7 : pulsout enable,1
		lcddata = b8 : pulsout enable,1
		lcddata = b9 : pulsout enable,1
	loop
lcdtutorial1.JPG

This next example demonstrates use of the cursor and (importantly) the ability to turn it on and off. This example has the string "LCD/OLED LINE 1" displayed on the top line at all times but on the second line "LCD/OLED LINE 2" is written slowly to the display with the cursor enabled so that the the cursor is in the position that the next character will appear in. The written message is displayed for a few seconds with the cursor displayed, then the cursor is turned off and there is another delay. The Display on/off control command from the initialization sequence makes a reappearance here.
Code:
main:
	low rs
	lcddata = 128 : pulsout enable,1
	high rs
	for b4 = 0 to 14
		lookup b4,("LCD/OLED LINE 1"),lcddata
		pulsout enable,1
	next
	low rs								'Instruction mode
	lcddata = 192 : pulsout enable,1				'Move cursor to beginning of line 2
	lcddata = %00001110 : pulsout enable,1			'Display on/off control: Display on, cursor on, blink off
	high rs								'Data mode
	for b4 = 0 to 14
		lookup b4,("LCD/OLED LINE 2"),lcddata
		pulsout enable,1
		pause 1000
	next
	pause 15000
	low rs								'Instruction mode
	lcddata = 192 : pulsout enable,1				'Move cursor to beginning of line 2
	lcddata = %00001100 : pulsout enable,1			'Display on/off control: Display on, cursor off, blink off
	high rs								'Data mode
	pause 5000
	lcddata = " "							'Puts a blank space on the data bus
	for b4 = 0 to 15							'Loop next command 16 times
		pulsout enable,1						'Sends the data to the LCD
	next
	goto main
Using CGRAM

The next example demonstrates use of the CGRAM. There is a wizard in PICAXE Programming Editor to generate the serout command to set the CGRAM on a serial LCD. Since, as already mentioned, serial LCDs don't do any processing of the data itself before sending it to the parallel LCD, any serout command generated by the wizard can be converted for use with a parallel LCD.

This is an example of a generated serout command: serout B.7, N2400, (254, 64, 32, 32, 42, 32, 49, 46, 32, 32)

The number after 254 (64) is the RAM address and this is to be sent to the LCD when rs is low and the remaining bytes are data bytes which should be sent to the display when rs is high. In the example, all 8 CGRAM characters will be set so the RAM address only needs to be sent once then one long loop can send all the data bytes to the display. This data could be stored in a lookup command but you can also use table or eeprom. The table/eeprom command can go anywhere in the program because it only preloads the data when the program is downloaded and has no runtime function.
Code:
eeprom 0,(32, 32, 42, 32, 49, 46, 32, 32, 32, 32, 42, 32, 46, 49, 32, 32, 32, 32, 42, 32, 63, 49, 46, 32, 32, 32, 42, 32, 32, 63, 32, 32, 42, 53, 42, 53, 42, 53, 42, 32, 42, 32, 42, 32, 42, 32, 42, 32, 63, 32, 63, 32, 63, 32, 63, 32, 63, 42, 63, 42, 63, 42, 63, 32)
It is also possible to use table/eeprom for text strings.

This code will send the character patterns defined in eeprom to the display CGRAM and display the character patterns on the top line.
Code:
	low rs
	lcddata = 64 : pulsout enable,1
	high rs
	for b4 = 0 to 63
		read b4,lcddata
		pulsout enable,1
	next

	
main:
	low rs
	lcddata = 128 : pulsout enable,1
	high rs
	for lcddata = 0 to 15
		pulsout enable,1
	next
	do : loop
[hr][/hr]AXE133 PCB as a project board

C.0, C.1 and C.2 are on H3. C.5 is on H2. The Serial Out and Serial In programming pins are not on these headers so you will need to access them via the download circuit instead.
 

nick12ab

Senior Member
#3
When you want to use the i2c pins

On the PICAXE-18M2, PICAXE-20M2 and PICAXE-20X2 the one port where all pins can be outputs are also the hi2c pins. Unfortunately there is no other port where all the pins can be used as outputs but it is still possible to use an 8-bit parallel LCD.

There are a few slightly different ways of doing it but the one I'll use will involve the lcddata name being assigned to a byte variable instead of a port and replacing occurences of 'pulsout enable,1' with 'gosub dataout'. This gosub can contain the processing required to use different pins for some of the data bits. This example will use the PICAXE-18M2.

Use the symbol command to assign unused pin variables on portC with names 'D1' and 'D4' and connect DB1 and DB4 of the LCD data bus to these pins and don't forget to set these pins as outputs. 'lcddata' needs to be a byte variable where the bit variables are accessable - b2 will be used in this example.

Since the initialization bytes need longer enable pulses and are the only instructions that need the extra delay it's better just to repeat what will later be in the gosub for the four initialization commands. Like this:
Code:
	[B]pinsB[/B] = %00000110 : D1 = 1 : D4 = 0 : pulsout enable,16
Note the lcddata symbol is not used here.

This is the sub. bit17 and bit20 are used because those are the bits of b2 that contain the data for the pins that are separate. No bit masking for the 'pinsB = lcddata' line is required since the i2c pins are not affected by this when being used for i2c.
Code:
dataout:
	pinsB = lcddata
	D1 = bit17
	D4 = bit20
	pulsout enable,1
	return
Every other occurence of 'pulsout enable,1' in the code must then be replaced with 'gosub dataout' and no other changes will be required if you used the lcddata symbol throughout the code (except for the initialization sequence).
 

nick12ab

Senior Member
#4
Take advantage of the greater speed

  • Faster - the parallel interface is faster than any serial display and this is particularly true for an LCD at 2400 baud. Most serial LCDs (including the AXE033) consist of a parallel LCD and microcontroller to convert the serial data to parallel so from that you can see that it is impossible for a serial LCD to be as fast as a parallel LCD. An example of how you can exploit this extra speed is to have a 'firmware update' screen where about twice a second the PICAXE writes the string 'Updating...' to the screen; issues the disconnect command; issues the reconnect command; writes the string 'Ready' or similar to the screen, and when no attempt is being made to program the PICAXE the screen will just say 'Ready' but as soon as the download is started it will change to 'Updating'.
First - the firmware update screen mentioned above. This cannot be done on an OLED because the response time of an OLED is instant so the display will flash no matter how fast you do this, but an LCD has slower response time so it is possible to quickly flash a different message without the user seeing it. This is not possible with the serial interface but is possible on the parallel interface. Because PICAXE uses an interpreter it is slow so the PICAXE should ideally be set to run at its highest speed and there is also no time for the relatively slow lookup command so we'll need to go back to the very first example that displays stuff. It is only needed for the part that's in a loop and anything else can still use the lookup command.

This example will display 'Firmware Update' on the top line using a lookup (because it will only be sent to the LCD once - before the loop) then the 'Ready' message will be displayed on the bottom line. Regularly, 'Updating...' is sent to the LCD, the reconnect command is executed then the disconnect command is executed then 'Ready' is sent to the LCD again. Because this happens fast, the LCD appears to say 'Ready' continuously then displays 'Updating...' as soon as you attempt to program the PICAXE. Since the PICAXE is now operating at 32MHz and the calculated values for the Enable pulses in the initialization sequence are only adequate for 16Mhz, the values must be doubled or it won't work. Here is the complete code:
Code:
#picaxe 18m2
#no_data
symbol lcddata = pinsB
symbol rs = C.7
symbol enable = C.6

start:
	setfreq m32
	dirsB = 255								'Set pinsB as outputs
	low rs								'instruction mode
	output enable							'set enable pin as output
	
	lcddata = %00111011 : pulsout enable,32		'Function Set: 8-bit, 2 lines, font 11
	lcddata = %00000001 : pulsout enable,1216		'Clear display
	lcddata = %00001100 : pulsout enable,1216		'Display on/off control: Display on, cursor off, blink off
	lcddata = %00000110 : pulsout enable,32		'Entry mode set: Increment, cursor shift
main:
	low rs
	lcddata = 128 : pulsout enable,1
	high rs
	for b4 = 0 to 15
		lookup b4,("Firmware Update "),lcddata
		pulsout enable,1
	next
	do
		low rs
		lcddata = 194 : pulsout enable,1
		high rs
		lcddata = "U" : pulsout enable,1
		lcddata = "p" : pulsout enable,1
		lcddata = "d" : pulsout enable,1
		lcddata = "a" : pulsout enable,1
		lcddata = "t" : pulsout enable,1
		lcddata = "i" : pulsout enable,1
		lcddata = "n" : pulsout enable,1
		lcddata = "g" : pulsout enable,1
		lcddata = "." : pulsout enable,1
		pulsout enable,1
		pulsout enable,1
		reconnect
		disconnect
		low rs
		lcddata = 194 : pulsout enable,1
		high rs
		lcddata = 32 : pulsout enable,1
		pulsout enable,1
		pulsout enable,1
		lcddata = "R" : pulsout enable,1
		lcddata = "e" : pulsout enable,1
		lcddata = "a" : pulsout enable,1
		lcddata = "d" : pulsout enable,1
		lcddata = "y" : pulsout enable,1
		lcddata = 32 : pulsout enable,1
		pulsout enable,1
		pulsout enable,1
		pause 1000
	loop
The above code is, of course, an example, which can be integrated in to the rest of a project. In a project, if possible, it should be modified to use the timer (instead of the pause) so that if the user decides not to program the PICAXE exiting the firmware update screen will happen promptly instead of feeling 'sluggish' which is what can happen when pauses are used.
[HR][/HR]The more interesting application for the extra speed that using a parallel interface uses is a bargraph display! A good bargraph display needs to be responsive and a serial LCD just cannot do this very well so if using a serial display it will only update the bargraph display a handful of times a second and the bargraph will 'jump' if the potentiometer it is controlled by (etc.) is adjusted quickly. Using a parallel LCD will make the bargraph very responsive so I only recommend using a bargraph with a parallel display, but serial display examples are still available if you really must use one.

See: LCD/OLED analogue bargraph
 
#5
Superb guide, extremely useful, Thanks!

Could you also show how to use a 4-bit interface please? I'm assuming its sending two consecutive halves of the data byte, but I don't know how to set it up.

Much appreciated! :D
 

nick12ab

Senior Member
#8
some more examples can also be found here
Not very good ones. Why is this necessary?
Intialise:
FOR index = 0 to 9
READ index, senddata : pinsC = senddata :pULSOUT E,1 ' Initialise LCD
NEXT index : PAUSE 10
Your example is not terrible, but it's poorly explained.

For those who have come to this thread looking for 4-bit examples, wait for mine.
 
#9
Last edited:
Top