lcd.c Source File

00001 /*! \file lcd.c \brief Character LCD driver for HD44780/SED1278 displays. */
00002 //*****************************************************************************
00003 //
00004 // File Name    : 'lcd.c'
00005 // Title        : Character LCD driver for HD44780/SED1278 displays
00006 //                  (usable in mem-mapped, or I/O mode)
00007 // Author       : Pascal Stang
00008 // Created      : 11/22/2000
00009 // Revised      : 4/30/2002
00010 // Version      : 1.1
00011 // Target MCU   : Atmel AVR series
00012 // Editor Tabs  : 4
00013 //
00014 // This code is distributed under the GNU Public License
00015 //      which can be found at http://www.gnu.org/licenses/gpl.txt
00016 //
00017 //*****************************************************************************
00018 
00019 #include <avr/io.h>
00020 #include <avr/pgmspace.h>
00021 
00022 #include "global.h"
00023 #include "timer.h"
00024 
00025 #include "lcd.h"
00026 
00027 // custom LCD characters
00028 static unsigned char __attribute__ ((progmem)) LcdCustomChar[] =
00029 {
00030     0x00, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x1F, 0x00, // 0. 0/5 full progress block
00031     0x00, 0x1F, 0x10, 0x10, 0x10, 0x10, 0x1F, 0x00, // 1. 1/5 full progress block
00032     0x00, 0x1F, 0x18, 0x18, 0x18, 0x18, 0x1F, 0x00, // 2. 2/5 full progress block
00033     0x00, 0x1F, 0x1C, 0x1C, 0x1C, 0x1C, 0x1F, 0x00, // 3. 3/5 full progress block
00034     0x00, 0x1F, 0x1E, 0x1E, 0x1E, 0x1E, 0x1F, 0x00, // 4. 4/5 full progress block
00035     0x00, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x00, // 5. 5/5 full progress block
00036     0x03, 0x07, 0x0F, 0x1F, 0x0F, 0x07, 0x03, 0x00, // 6. rewind arrow
00037     0x00, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x00, // 7. stop block
00038     0x1B, 0x1B, 0x1B, 0x1B, 0x1B, 0x1B, 0x1B, 0x00, // 8. pause bars
00039     0x18, 0x1C, 0x1E, 0x1F, 0x1E, 0x1C, 0x18, 0x00, // 9. fast-forward arrow
00040     0x00, 0x04, 0x04, 0x0E, 0x0E, 0x1F, 0x1F, 0x00, // 10. scroll up arrow
00041     0x00, 0x1F, 0x1F, 0x0E, 0x0E, 0x04, 0x04, 0x00, // 11. scroll down arrow
00042     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 12. blank character
00043     0x00, 0x0E, 0x19, 0x15, 0x13, 0x0E, 0x00, 0x00, // 13. animated play icon frame 0
00044     0x00, 0x0E, 0x15, 0x15, 0x15, 0x0E, 0x00, 0x00, // 14. animated play icon frame 1
00045     0x00, 0x0E, 0x13, 0x15, 0x19, 0x0E, 0x00, 0x00, // 15. animated play icon frame 2
00046     0x00, 0x0E, 0x11, 0x1F, 0x11, 0x0E, 0x00, 0x00, // 16. animated play icon frame 3
00047 };
00048 
00049 /*************************************************************/
00050 /********************** LOCAL FUNCTIONS **********************/
00051 /*************************************************************/
00052 
00053 void lcdInitHW(void)
00054 {
00055     // initialize I/O ports
00056     // if I/O interface is in use
00057 #ifdef LCD_PORT_INTERFACE
00058     // initialize LCD control lines
00059     cbi(LCD_CTRL_PORT, LCD_CTRL_RS);
00060     cbi(LCD_CTRL_PORT, LCD_CTRL_RW);
00061     cbi(LCD_CTRL_PORT, LCD_CTRL_E);
00062     // initialize LCD control lines to output
00063     sbi(LCD_CTRL_DDR, LCD_CTRL_RS);
00064     sbi(LCD_CTRL_DDR, LCD_CTRL_RW);
00065     sbi(LCD_CTRL_DDR, LCD_CTRL_E);
00066     // initialize LCD data port to input
00067     // initialize LCD data lines to pull-up
00068     #ifdef LCD_DATA_4BIT
00069         outb(LCD_DATA_DDR, inb(LCD_DATA_DDR)&0x0F);     // set data I/O lines to input (4bit)
00070         outb(LCD_DATA_POUT, inb(LCD_DATA_POUT)|0xF0);   // set pull-ups to on (4bit)
00071     #else
00072         outb(LCD_DATA_DDR, 0x00);                       // set data I/O lines to input (8bit)
00073         outb(LCD_DATA_POUT, 0xFF);                      // set pull-ups to on (8bit)
00074     #endif
00075 #endif
00076 }
00077 
00078 void lcdBusyWait(void)
00079 {
00080     // wait until LCD busy bit goes to zero
00081     // do a read from control register
00082 #ifdef LCD_PORT_INTERFACE
00083     cbi(LCD_CTRL_PORT, LCD_CTRL_RS);                // set RS to "control"
00084     #ifdef LCD_DATA_4BIT
00085         outb(LCD_DATA_DDR, inb(LCD_DATA_DDR)&0x0F); // set data I/O lines to input (4bit)
00086         outb(LCD_DATA_POUT, inb(LCD_DATA_POUT)|0xF0);   // set pull-ups to on (4bit)
00087     #else
00088         outb(LCD_DATA_DDR, 0x00);                   // set data I/O lines to input (8bit)
00089         outb(LCD_DATA_POUT, 0xFF);                  // set pull-ups to on (8bit)
00090     #endif
00091     sbi(LCD_CTRL_PORT, LCD_CTRL_RW);                // set R/W to "read"
00092     sbi(LCD_CTRL_PORT, LCD_CTRL_E);                 // set "E" line
00093     LCD_DELAY;                              // wait
00094     while(inp(LCD_DATA_PIN) & 1<<LCD_BUSY)
00095     {
00096         cbi(LCD_CTRL_PORT, LCD_CTRL_E);     // clear "E" line
00097         LCD_DELAY;                                  // wait
00098         LCD_DELAY;                                  // wait
00099         sbi(LCD_CTRL_PORT, LCD_CTRL_E);     // set "E" line
00100         LCD_DELAY;                                  // wait
00101         LCD_DELAY;                                  // wait
00102         #ifdef LCD_DATA_4BIT                        // do an extra clock for 4 bit reads
00103             cbi(LCD_CTRL_PORT, LCD_CTRL_E); // clear "E" line
00104             LCD_DELAY;                              // wait
00105             LCD_DELAY;                              // wait
00106             sbi(LCD_CTRL_PORT, LCD_CTRL_E); // set "E" line
00107             LCD_DELAY;                              // wait
00108             LCD_DELAY;                              // wait
00109         #endif
00110     }
00111     cbi(LCD_CTRL_PORT, LCD_CTRL_E);         // clear "E" line
00112     //  leave data lines in input mode so they can be most easily used for other purposes
00113 #else
00114     // memory bus read
00115     // sbi(MCUCR, SRW);         // enable RAM waitstate
00116     // wait until LCD busy bit goes to zero
00117     while( (*((volatile unsigned char *) (LCD_CTRL_ADDR))) & (1<<LCD_BUSY) );
00118     // cbi(MCUCR, SRW);         // disable RAM waitstate
00119 #endif
00120 }
00121 
00122 void lcdControlWrite(u08 data) 
00123 {
00124 // write the control byte to the display controller
00125 #ifdef LCD_PORT_INTERFACE
00126     lcdBusyWait();                          // wait until LCD not busy
00127     cbi(LCD_CTRL_PORT, LCD_CTRL_RS);            // set RS to "control"
00128     cbi(LCD_CTRL_PORT, LCD_CTRL_RW);            // set R/W to "write"
00129     #ifdef LCD_DATA_4BIT
00130         // 4 bit write
00131         sbi(LCD_CTRL_PORT, LCD_CTRL_E); // set "E" line
00132         outb(LCD_DATA_DDR, inb(LCD_DATA_DDR)|0xF0); // set data I/O lines to output (4bit)
00133         outb(LCD_DATA_POUT, (inb(LCD_DATA_POUT)&0x0F) | (data&0xF0) );  // output data, high 4 bits
00134         LCD_DELAY;                              // wait
00135         LCD_DELAY;                              // wait
00136         cbi(LCD_CTRL_PORT, LCD_CTRL_E); // clear "E" line
00137         LCD_DELAY;                              // wait
00138         LCD_DELAY;                              // wait
00139         sbi(LCD_CTRL_PORT, LCD_CTRL_E); // set "E" line
00140         outb(LCD_DATA_POUT, (inb(LCD_DATA_POUT)&0x0F) | (data<<4) );    // output data, low 4 bits
00141         LCD_DELAY;                              // wait
00142         LCD_DELAY;                              // wait
00143         cbi(LCD_CTRL_PORT, LCD_CTRL_E); // clear "E" line
00144     #else
00145         // 8 bit write
00146         sbi(LCD_CTRL_PORT, LCD_CTRL_E); // set "E" line
00147         outb(LCD_DATA_DDR, 0xFF);               // set data I/O lines to output (8bit)
00148         outb(LCD_DATA_POUT, data);              // output data, 8bits
00149         LCD_DELAY;                              // wait
00150         LCD_DELAY;                              // wait
00151         cbi(LCD_CTRL_PORT, LCD_CTRL_E); // clear "E" line
00152     #endif
00153     //  leave data lines in input mode so they can be most easily used for other purposes
00154     #ifdef LCD_DATA_4BIT
00155         outb(LCD_DATA_DDR, inb(LCD_DATA_DDR)&0x0F);     // set data I/O lines to input (4bit)
00156         outb(LCD_DATA_POUT, inb(LCD_DATA_POUT)|0xF0);   // set pull-ups to on (4bit)
00157     #else
00158         outb(LCD_DATA_DDR, 0x00);           // set data I/O lines to input (8bit)
00159         outb(LCD_DATA_POUT, 0xFF);          // set pull-ups to on (8bit)
00160     #endif
00161 #else
00162     // memory bus write
00163     //sbi(MCUCR, SRW);          // enable RAM waitstate
00164     lcdBusyWait();              // wait until LCD not busy
00165     *((volatile unsigned char *) (LCD_CTRL_ADDR)) = data;
00166     //cbi(MCUCR, SRW);          // disable RAM waitstate
00167 #endif
00168 }
00169 
00170 u08 lcdControlRead(void)
00171 {
00172 // read the control byte from the display controller
00173     register u08 data;
00174 #ifdef LCD_PORT_INTERFACE
00175     lcdBusyWait();              // wait until LCD not busy
00176     #ifdef LCD_DATA_4BIT
00177         outb(LCD_DATA_DDR, inb(LCD_DATA_DDR)&0x0F);     // set data I/O lines to input (4bit)
00178         outb(LCD_DATA_POUT, inb(LCD_DATA_POUT)|0xF0);   // set pull-ups to on (4bit)
00179     #else
00180         outb(LCD_DATA_DDR, 0x00);           // set data I/O lines to input (8bit)
00181         outb(LCD_DATA_POUT, 0xFF);          // set pull-ups to on (8bit)
00182     #endif
00183     cbi(LCD_CTRL_PORT, LCD_CTRL_RS);        // set RS to "control"
00184     sbi(LCD_CTRL_PORT, LCD_CTRL_RW);        // set R/W to "read"
00185     #ifdef LCD_DATA_4BIT
00186         // 4 bit read
00187         sbi(LCD_CTRL_PORT, LCD_CTRL_E); // set "E" line
00188         LCD_DELAY;                      // wait
00189         LCD_DELAY;                      // wait
00190         data = inb(LCD_DATA_PIN)&0xF0;  // input data, high 4 bits
00191         cbi(LCD_CTRL_PORT, LCD_CTRL_E); // clear "E" line
00192         LCD_DELAY;                      // wait
00193         LCD_DELAY;                      // wait
00194         sbi(LCD_CTRL_PORT, LCD_CTRL_E); // set "E" line
00195         LCD_DELAY;                      // wait
00196         LCD_DELAY;                      // wait
00197         data |= inb(LCD_DATA_PIN)>>4;   // input data, low 4 bits
00198         cbi(LCD_CTRL_PORT, LCD_CTRL_E); // clear "E" line
00199     #else
00200         // 8 bit read
00201         sbi(LCD_CTRL_PORT, LCD_CTRL_E); // set "E" line
00202         LCD_DELAY;                      // wait
00203         LCD_DELAY;                      // wait
00204         data = inb(LCD_DATA_PIN);       // input data, 8bits
00205         cbi(LCD_CTRL_PORT, LCD_CTRL_E); // clear "E" line
00206     #endif
00207     //  leave data lines in input mode so they can be most easily used for other purposes
00208 #else
00209     //sbi(MCUCR, SRW);          // enable RAM waitstate
00210     lcdBusyWait();              // wait until LCD not busy
00211     data = *((volatile unsigned char *) (LCD_CTRL_ADDR));
00212     //cbi(MCUCR, SRW);          // disable RAM waitstate
00213 #endif
00214     return data;
00215 }
00216 
00217 void lcdDataWrite(u08 data) 
00218 {
00219 // write a data byte to the display
00220 #ifdef LCD_PORT_INTERFACE
00221     lcdBusyWait();                          // wait until LCD not busy
00222     sbi(LCD_CTRL_PORT, LCD_CTRL_RS);        // set RS to "data"
00223     cbi(LCD_CTRL_PORT, LCD_CTRL_RW);        // set R/W to "write"
00224     #ifdef LCD_DATA_4BIT
00225         // 4 bit write
00226         sbi(LCD_CTRL_PORT, LCD_CTRL_E); // set "E" line
00227         outb(LCD_DATA_DDR, inb(LCD_DATA_DDR)|0xF0); // set data I/O lines to output (4bit)
00228         outb(LCD_DATA_POUT, (inb(LCD_DATA_POUT)&0x0F) | (data&0xF0) );  // output data, high 4 bits
00229         LCD_DELAY;                              // wait
00230         LCD_DELAY;                              // wait
00231         cbi(LCD_CTRL_PORT, LCD_CTRL_E); // clear "E" line
00232         LCD_DELAY;                              // wait
00233         LCD_DELAY;                              // wait
00234         sbi(LCD_CTRL_PORT, LCD_CTRL_E); // set "E" line
00235         outb(LCD_DATA_POUT, (inb(LCD_DATA_POUT)&0x0F) | (data<<4) );    // output data, low 4 bits
00236         LCD_DELAY;                              // wait
00237         LCD_DELAY;                              // wait
00238         cbi(LCD_CTRL_PORT, LCD_CTRL_E); // clear "E" line
00239     #else
00240         // 8 bit write
00241         sbi(LCD_CTRL_PORT, LCD_CTRL_E); // set "E" line
00242         outb(LCD_DATA_DDR, 0xFF);           // set data I/O lines to output (8bit)
00243         outb(LCD_DATA_POUT, data);          // output data, 8bits
00244         LCD_DELAY;                              // wait
00245         LCD_DELAY;                              // wait
00246         cbi(LCD_CTRL_PORT, LCD_CTRL_E); // clear "E" line
00247     #endif
00248     //  leave data lines in input mode so they can be most easily used for other purposes
00249     #ifdef LCD_DATA_4BIT
00250         outb(LCD_DATA_DDR, inb(LCD_DATA_DDR)&0x0F);     // set data I/O lines to input (4bit)
00251         outb(LCD_DATA_POUT, inb(LCD_DATA_POUT)|0xF0);   // set pull-ups to on (4bit)
00252     #else
00253         outb(LCD_DATA_DDR, 0x00);           // set data I/O lines to input (8bit)
00254         outb(LCD_DATA_POUT, 0xFF);          // set pull-ups to on (8bit)
00255     #endif
00256 #else
00257     // memory bus write
00258     //sbi(MCUCR, SRW);          // enable RAM waitstate
00259     lcdBusyWait();              // wait until LCD not busy
00260     *((volatile unsigned char *) (LCD_DATA_ADDR)) = data;
00261     //cbi(MCUCR, SRW);          // disable RAM waitstate
00262 #endif
00263 }
00264 
00265 u08 lcdDataRead(void)
00266 {
00267 // read a data byte from the display
00268     register u08 data;
00269 #ifdef LCD_PORT_INTERFACE
00270     lcdBusyWait();              // wait until LCD not busy
00271     #ifdef LCD_DATA_4BIT
00272         outb(LCD_DATA_DDR, inb(LCD_DATA_DDR)&0x0F);     // set data I/O lines to input (4bit)
00273         outb(LCD_DATA_POUT, inb(LCD_DATA_POUT)|0xF0);   // set pull-ups to on (4bit)
00274     #else
00275         outb(LCD_DATA_DDR, 0x00);           // set data I/O lines to input (8bit)
00276         outb(LCD_DATA_POUT, 0xFF);          // set pull-ups to on (8bit)
00277     #endif
00278     sbi(LCD_CTRL_PORT, LCD_CTRL_RS);        // set RS to "data"
00279     sbi(LCD_CTRL_PORT, LCD_CTRL_RW);        // set R/W to "read"
00280     #ifdef LCD_DATA_4BIT
00281         // 4 bit read
00282         sbi(LCD_CTRL_PORT, LCD_CTRL_E); // set "E" line
00283         LCD_DELAY;                              // wait
00284         LCD_DELAY;                              // wait
00285         data = inb(LCD_DATA_PIN)&0xF0;  // input data, high 4 bits
00286         cbi(LCD_CTRL_PORT, LCD_CTRL_E); // clear "E" line
00287         LCD_DELAY;                              // wait
00288         LCD_DELAY;                              // wait
00289         sbi(LCD_CTRL_PORT, LCD_CTRL_E); // set "E" line
00290         LCD_DELAY;                              // wait
00291         LCD_DELAY;                              // wait
00292         data |= inb(LCD_DATA_PIN)>>4;           // input data, low 4 bits
00293         cbi(LCD_CTRL_PORT, LCD_CTRL_E); // clear "E" line
00294     #else
00295         // 8 bit read
00296         sbi(LCD_CTRL_PORT, LCD_CTRL_E); // set "E" line
00297         LCD_DELAY;                              // wait
00298         LCD_DELAY;                              // wait
00299         data = inb(LCD_DATA_PIN);           // input data, 8bits
00300         cbi(LCD_CTRL_PORT, LCD_CTRL_E); // clear "E" line
00301     #endif
00302     //  leave data lines in input mode so they can be most easily used for other purposes
00303 #else
00304     // memory bus read
00305     //sbi(MCUCR, SRW);          // enable RAM waitstate
00306     lcdBusyWait();              // wait until LCD not busy
00307     data = *((volatile unsigned char *) (LCD_DATA_ADDR));
00308     //cbi(MCUCR, SRW);          // disable RAM waitstate
00309 #endif
00310     return data;
00311 }
00312 
00313 
00314 
00315 /*************************************************************/
00316 /********************* PUBLIC FUNCTIONS **********************/
00317 /*************************************************************/
00318 
00319 void lcdInit()
00320 {
00321     // initialize hardware
00322     lcdInitHW();
00323     // LCD function set
00324     lcdControlWrite(LCD_FUNCTION_DEFAULT);
00325     // clear LCD
00326     lcdControlWrite(1<<LCD_CLR);
00327     delay(60000);   // wait 60ms
00328     // set entry mode
00329     lcdControlWrite(1<<LCD_ENTRY_MODE | 1<<LCD_ENTRY_INC);
00330     // set display to on
00331     //lcdControlWrite(1<<LCD_ON_CTRL | 1<<LCD_ON_DISPLAY | 1<<LCD_ON_BLINK);
00332     lcdControlWrite(1<<LCD_ON_CTRL | 1<<LCD_ON_DISPLAY );
00333     // move cursor to home
00334     lcdControlWrite(1<<LCD_HOME);
00335     // set data address to 0
00336     lcdControlWrite(1<<LCD_DDRAM | 0x00);
00337 
00338     // load the first 8 custom characters
00339     lcdLoadCustomChar((u08*)LcdCustomChar,0,0);
00340     lcdLoadCustomChar((u08*)LcdCustomChar,1,1);
00341     lcdLoadCustomChar((u08*)LcdCustomChar,2,2);
00342     lcdLoadCustomChar((u08*)LcdCustomChar,3,3);
00343     lcdLoadCustomChar((u08*)LcdCustomChar,4,4);
00344     lcdLoadCustomChar((u08*)LcdCustomChar,5,5);
00345     lcdLoadCustomChar((u08*)LcdCustomChar,6,6);
00346     lcdLoadCustomChar((u08*)LcdCustomChar,7,7);
00347 }
00348 
00349 void lcdHome(void)
00350 {
00351     // move cursor to home
00352     lcdControlWrite(1<<LCD_HOME);
00353 }
00354 
00355 void lcdClear(void)
00356 {
00357     // clear LCD
00358     lcdControlWrite(1<<LCD_CLR);
00359 }
00360 
00361 void lcdGotoXY(u08 x, u08 y)
00362 {
00363     register u08 DDRAMAddr;
00364 
00365     // remap lines into proper order
00366     switch(y)
00367     {
00368     case 0: DDRAMAddr = LCD_LINE0_DDRAMADDR+x; break;
00369     case 1: DDRAMAddr = LCD_LINE1_DDRAMADDR+x; break;
00370     case 2: DDRAMAddr = LCD_LINE2_DDRAMADDR+x; break;
00371     case 3: DDRAMAddr = LCD_LINE3_DDRAMADDR+x; break;
00372     default: DDRAMAddr = LCD_LINE0_DDRAMADDR+x;
00373     }
00374 
00375     // set data address
00376     lcdControlWrite(1<<LCD_DDRAM | DDRAMAddr);
00377 }
00378 
00379 void lcdLoadCustomChar(u08* lcdCustomCharArray, u08 romCharNum, u08 lcdCharNum)
00380 {
00381     register u08 i;
00382     u08 saveDDRAMAddr;
00383 
00384     // backup the current cursor position
00385     saveDDRAMAddr = lcdControlRead() & 0x7F;
00386 
00387     // multiply the character index by 8
00388     lcdCharNum = (lcdCharNum<<3);   // each character occupies 8 bytes
00389     romCharNum = (romCharNum<<3);   // each character occupies 8 bytes
00390 
00391     // copy the 8 bytes into CG (character generator) RAM
00392     for(i=0; i<8; i++)
00393     {
00394         // set CG RAM address
00395         lcdControlWrite((1<<LCD_CGRAM) | (lcdCharNum+i));
00396         // write character data
00397         lcdDataWrite( PRG_RDB(lcdCustomCharArray+romCharNum+i) );
00398     }
00399 
00400     // restore the previous cursor position
00401     lcdControlWrite(1<<LCD_DDRAM | saveDDRAMAddr);
00402 
00403 }
00404 
00405 void lcdPrintData(char* data, u08 nBytes)
00406 {
00407     register u08 i;
00408 
00409     // check to make sure we have a good pointer
00410     if (!data) return;
00411 
00412     // print data
00413     for(i=0; i<nBytes; i++)
00414     {
00415         lcdDataWrite(data[i]);
00416     }
00417 }
00418 
00419 void lcdProgressBar(u16 progress, u16 maxprogress, u08 length)
00420 {
00421     u08 i;
00422     u32 pixelprogress;
00423     u08 c;
00424 
00425     // draw a progress bar displaying (progress / maxprogress)
00426     // starting from the current cursor position
00427     // with a total length of "length" characters
00428     // ***note, LCD chars 0-5 must be programmed as the bar characters
00429     // char 0 = empty ... char 5 = full
00430 
00431     // total pixel length of bargraph equals length*PROGRESSPIXELS_PER_CHAR;
00432     // pixel length of bar itself is
00433     pixelprogress = ((progress*(length*PROGRESSPIXELS_PER_CHAR))/maxprogress);
00434     
00435     // print exactly "length" characters
00436     for(i=0; i<length; i++)
00437     {
00438         // check if this is a full block, or partial or empty
00439         // (u16) cast is needed to avoid sign comparison warning
00440         if( ((i*(u16)PROGRESSPIXELS_PER_CHAR)+5) > pixelprogress )
00441         {
00442             // this is a partial or empty block
00443             if( ((i*(u16)PROGRESSPIXELS_PER_CHAR)) > pixelprogress )
00444             {
00445                 // this is an empty block
00446                 // use space character?
00447                 c = 0;
00448             }
00449             else
00450             {
00451                 // this is a partial block
00452                 c = pixelprogress % PROGRESSPIXELS_PER_CHAR;
00453             }
00454         }
00455         else
00456         {
00457             // this is a full block
00458             c = 5;
00459         }
00460         
00461         // write character to display
00462         lcdDataWrite(c);
00463     }
00464 
00465 }
00466