Here is a more complex program using the LCD display. Just watch the video to see what the program does:
Here is the python code:
As you can see, the Times Square Scroll program asks the user to input text. That text enters at the right end of the LCD display, on the top line, and scrolls to the left. Once the entire text has gone to the display, it starts over on the bottom line. Once all of the text has appeared on the bottom line it repeats to the top line. This continues until the user pushes the switch and stops the process.
There is not a great deal of additional code to make the Times Square Scroll program work. The shortness of the code, however, belies the fact that it is somewhat complex and requires a pretty good understanding of the 44780 display controller. Remember that all of the code from the file LCD_2X16.py is imported into this program.
The display controller has two internal memories. One is the character memory that converts an ASCII character to a pattern of dots that correspond to the letter, number, or symbol you see on the display. It is the other memory, however, that concerns us. This memory, called the Display Data RAM, contains 80 memory locations (80 eight bit bytes). When you send a character to the display controller, it goes into this RAM.
The first 40 memory locations are devoted to the top line of the display, and they correspond to memory addresses 00h to 2Fh. The bottom line's 40 memory locations are found at addresses 40h to 67h. The data sheet for the display controller uses Hexadecimal notation for memory addresses, so, I will be using Hexadecomal notation too. While there are 80 memory locations, only a maximum of 32 characters appear on the display. Obviously, characters in some some of the memory are visible, and some are not. To make it easier to determine what is visible, we can define a window corresponding to the visible portion of the memory. Let's call that the Visible Memory window. Take a look at Fig. 1, below. It is a graphical representation of Display Data RAM. I have indicated the Visible Memory window with a red rectangle. It is important to know that this window can be moved to display characters in different memory locations, but it will always be the same size.
I am going to talk about sending characters to the memory. Actually, we will be writing the ASCII equivalent of the characters to the memory. For example, if we want a space, 20h, or 32 decimal will be written. We'll keep it simple and say we are sending a space to the memory.
If you want a simple display project, like in my previous blog, you would not need to concern yourself with the Display Data RAM and my Visible Memory window. Figure 1, shows how the memory was utilized in the previous blog. The Visible Memory window stayed put and there were never any characters placed in the memory locations that were not visible. The Times Square Scroll, however, makes plenty use of the Visible Memory window.
There are two other important memory elements within the 44780 controller chip. The first is the instruction register. The commands (as opposed to characters) you write to the controller go there. Pages 23 through 29 of the controller's data sheet explain the commands quite well. That other important element is the address counter. The address counter contains the memory location that will receive the next character. You can write to the address counter if you wish to change where the next character will go - the code does this frequently. It is important to know that once you write a character into a memory location, the controller will increment (or decremen) the contents of the address counter. In this way you don't have to keep changing the address counter yourself. As a matter of fact, you can't stop the address counter from incrementing or decrementing.
Before we look at the code for this two line version of the Times Square Scroll, I have a simpler version that uses the top line only. The code fragment, below, replaces lines 49 through 75 above. It's a little easier to understand.
Let's assume the user has asked to send "Now is the time for all good men to come to the aid of their party" to the display. Recall that I said you can change the contents of address counter, and that is what I do in line 3 and 6. I set it to the position just to the right of the Visible Memory window and upload it to the display controller. In line 1, I commanded the controller to make a left shift after I upload each character. Line 1 also says to increment the address counter after uploading each character. If I had been writing in a language that reads from right to left, Hebrew, for example, I would have told it to decrement the address counter. When I start to upload characters, the first character "N" goes to position 10h. See Figure 2.
After uploading the "N", the display does a left shift. Hitachi considers the shift direction from the point of view of the character. From my point of view, the Visible Window moves one position to the right. In effect, it moves the "N" one position to the left. The "N" is now within the Visible Window, so it appears on the display. See Figure 3.
When the "o" is uploaded, the address counter has been incremented to 11h (by the controller), which again, is one position to the right of the Visible Window. Once uploaded, the "o" becomes visible because the controller shifts the Visible Window. See Figure 4. This process continues as each character is added to the display.
What happens once the address counter has gotten to the end of the memory space of the top line (address 27h)? Lines 12 to 15 of the code handle that situation. If those lines of code were not there, the address counter would move to the beginning of the bottom line. As more characters are added, characters that were previously uploaded to the top line, and still in memory, would also start to be visible. Old characters would be seen on the top line while new characters are seen on the bottom line. Eventually, old and new characters would be seen on both lines and you get a mess like in figure 5.
Code lines 12 to 15 along with line 3 address that problem. We keep track of the address counter, and when it reaches the memory address beyond the end of the top tine (28h), we simply set it to the beginning address of the top line, 00h. Note that the Visible Window will now split in two parts. See Figures 6 and 7.
I could have avoided the problem in another way. I could have told the display controller that I had a one line display. I could have written:
By saying I had a one line display, I could have dispensed with code lines 12 to 15. However, I knew the one line display was going to be a precursor to my ultimate two line Times Square Scroll. The two line version, also has code similar to lines 12 to 15.
That's enough to absorb for now. I'm going to save the rest of the discussion of the Times Square Scroll for the next blog entry.
No comments:
Post a Comment