Pages: 1 2 [3] 4   Go Down
Author Topic: Large Alphanumeric on LCD  (Read 29833 times)
0 Members and 1 Guest are viewing this topic.
North Yorkshire, UK
Offline Offline
Faraday Member
**
Karma: 104
Posts: 5531
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Quote
It's looking good, digimike!
Agreed.

I will take a more detailed look tomorrow smiley

Mowcius
Logged

NE Wisconsin
Offline Offline
Full Member
***
Karma: 0
Posts: 195
Arduino is the Better Stamp!
View Profile
WWW
 Bigger Bigger  Smaller Smaller  Reset Reset

How easy would this be to use on a 4x20 LCD?
I don't have a 2x16...
What would need to be changed so you could print on 2 big lines(2 lines each)?

 :-?
Logged

North Yorkshire, UK
Offline Offline
Faraday Member
**
Karma: 104
Posts: 5531
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

You may want to look at:
http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1245352653

There are more. Just g**gle it smiley

Mowcius
Logged

MD, USA
Offline Offline
God Member
*****
Karma: 2
Posts: 663
A jack of all trades and a master of none!
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Your not limited to a 16x2 display. As it is the code will just use the top 2 lines of your display. On a 20x4 display you could have 2 lines of large characters. Your own personal code using the segments i have defined will have to designate when to set the cursor to line 3 for the next row.

In the sections that define the layout of each character you'll want to change it from this.
Code:
void custom2()
{
  lcd.setCursor(x,0);
  lcd.write(6);
  lcd.write(6);
  lcd.write(2);
  lcd.setCursor(x, 1);
  lcd.write(3);
  lcd.write(7);
  lcd.write(7);
}


To this:
Code:
void custom2()
{
  lcd.setCursor(x,y);
  lcd.write(6);
  lcd.write(6);
  lcd.write(2);
  lcd.setCursor(x, y+1);
  lcd.write(3);
  lcd.write(7);
  lcd.write(7);
}


The second setCursor() across all of them will have to be...
Code:
lcd.setCursor(x, y+2);
This way the bottom half of the letter will be in the right position.

If you wanted to have a character take up all 4 lines then you would need to redefine all the characters. Which wouldn't be all that hard to do. The custom segments all stay the same they just get laid out a bit differently. It would look funny but it can be done.
« Last Edit: February 12, 2010, 06:12:32 pm by digimike » Logged

USA
Offline Offline
Full Member
***
Karma: 2
Posts: 213
Arduino rocks
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Mike
I have taken your font and made it table driven. I am sure to some this might seem more complicated, but it is table driven, and uses no ram. The definitions are  in PROGMEM.

The function DrawBigChar takes x and y so it can work 4x20 screens
Now I have to incorporate it into my drivers.

Total code and tables take 640 bytes.

Thank you very much for sharing your large fonts.

Mark

Code:
//************************************************************************
//*      A set of custom made large numbers for a 16x2 LCD using the
//*      LiquidCrystal librabry. Works with displays compatible with the
//*      Hitachi HD44780 driver.
//*      
//*      orginal developed  by Michael Pilcher  2/9/2010
//*      there are 8 entries, 8 bytes per entry
//*      these are the building blocks to make the numbers


//*      The LL, LT, UB, ect... are rust abreviations to help me designate which segment was which when referencing the large '0'.
//*      LT= left top
//*      UB= upper bar
//*      RT= right top
//*      LL= lower left
//*      LB= lower bar
//*      LR= lower right
//*      UMB= upper middle bars(upper middle section of the '8')
//*      LMB= lower middle bars(lower middle section of the '8')

uint8_t      gBigFontShapeTable[] PROGMEM      =      {
//*      LT[8] =
  B00111,
  B01111,
  B11111,
  B11111,
  B11111,
  B11111,
  B11111,
  B11111,
//*      UB[8] =
  B11111,
  B11111,
  B11111,
  B00000,
  B00000,
  B00000,
  B00000,
  B00000,
//*      RT[8] =
  B11100,
  B11110,
  B11111,
  B11111,
  B11111,
  B11111,
  B11111,
  B11111,
//*      LL[8] =
  B11111,
  B11111,
  B11111,
  B11111,
  B11111,
  B11111,
  B01111,
  B00111,
//*      LB[8] =
  B00000,
  B00000,
  B00000,
  B00000,
  B00000,
  B11111,
  B11111,
  B11111,
//*      LR[8] =
  B11111,
  B11111,
  B11111,
  B11111,
  B11111,
  B11111,
  B11110,
  B11100,
//*      UMB[8] =
  B11111,
  B11111,
  B11111,
  B00000,
  B00000,
  B00000,
  B11111,
  B11111,
//*      LMB[8] =
  B11111,
  B00000,
  B00000,
  B00000,
  B00000,
  B11111,
  B11111,
  B11111


};


//************************************************************************
//*      6 numbers for each character
//*      9 means BLANK
uint8_t      gBigFontAsciiTable[] PROGMEM      =      {

      0,      1,      2,      3,      4,      5,            //      0x30      0
      1,      2,      32,      32,      5,      32,            //      0x31      1
      6,      6,      2,      3,      7,      7,            //      0x32      2
      6,      6,      2,      7,      7,      5,            //      0x33      3
      3,      4,      2,      32,      32,      5,            //      0x34      4
      0,      6,      6,      7,      7,      5,            //      0x35      5
      0,      6,      6,      3,      7,      5,            //      0x36      6
      1,      1,      2,      32,      0,      32,            //      0x37      7
      0,      6,      2,      3,      7,      5,            //      0x38      8
      0,      6,      2,      32,      32,      5,            //      0x39      9
      32,      32,      32,      32,      32,      32,            //      0x3A      
      32,      32,      32,      32,      32,      32,            //      0x3B
      32,      32,      32,      32,      32,      32,            //      0x3C
      32,      32,      32,      32,      32,      32,            //      0x3D
      32,      32,      32,      32,      32,      32,            //      0x3E
      1,      6,      2,      254,7,      32,            //      0x3F      ?

      32,      32,      32,      32,      32,      32,            //      0x40      @
      0,      6,      2,      255,254,255,      //      0x41      A
      255,6,      5,      255,7,      2,            //      0x42      B
      0,      1,      1,      3,      4,      4,            //      0x43      C
      255,1,      2,      255,4,      5,            //      0x44      D
      255,6,      6,      255,7,      7,            //      0x45      E
      255,6,      6,      255,32,      32,            //      0x46      F
      
      0,      1,      1,      3,      4,      2,            //      0x47      G
      255,4,      255,255,254,255,      //      0x48      H
      1,      255,1,      4,      255,4,            //      0x49      I
      32,      32,      255,4,      4,      5,            //      0x4A      J
      255,4,      5,      255,254,2,            //      0x4B      K
      255,32,      32,      255,4,      4,            //      0x4C      L
      32,      32,      32,      32,      32,      32,            //      0x4D      M      place holder
      32,      32,      32,      32,      32,      32,            //      0x4E      N      place holder
      0,      1,      2,      3,      4,      5,            //      0x4F      O      (same as zero)

      0,      6,      2,      3,      32,      32,            //      0x50      P
      32,      32,      32,      32,      32,      32,            //      0x51      Q
      0,      6,      5,      3,      32,      2,            //      0x52      R
      0,      6,      6,      7,      7,      5,            //      0x35      S      (same as 5)
      1,      2,      1,      32,      5,      32,            //      0x54      T
      2,      32,      2,      3,      4,      5,            //      0x55      U
      32,      32,      32,      32,      32,      32,            //      0x56      V      place holder
      32,      32,      32,      32,      32,      32,            //      0x57      W      place holder
      3,      4,      5,      0,      32,      2,            //      0x58      X
      3,      4,      5,      32,      5,      32,            //      0x59      Y
      1,      6,      5,      0,      7,      4,            //      0x5A      Z
      0

};

//*      we have a seperate table for the wide routines
uint8_t      gBigFontAsciiTableWide[] PROGMEM      =      {
//*      this table is 10 bytes, 2 rows of 5
//      ---top------------|
      0,      1,      3,      1,      2,      3,      32,      32,      32,      5,            //      0x4D      M            5-wide
      0,      3,      32,      2,      32,      3,      32,      2,      5,      32,            //      0x4E      N            4-wide
      0,      1,      2,      32,      32,      3,      4,      3,      4,      32,            //      0x51      Q            4-wide
      3,      32,      32,      5,      32,      32,      3,      5,      32,      32,            //      0x56      V            4-wide
      0,      32,      32,      32,      2,      3,      4,      0,      4,      5,            //      0x57      W            5-wide
      0
};


//************************************************************************
static void      BigNumber_SendCustomChars(void)
{
uint8_t      customCharDef[10];
uint8_t      ii;
int            jj;

      for (ii=0; ii<8; ii++)
      {
            for (jj=0; jj<8; jj++)
            {
                  customCharDef[jj]      =      pgm_read_byte_near(gBigFontShapeTable + (ii * 8) + jj);
            }
            gLCD.createChar(ii, customCharDef);
      }
}

//************************************************************************
//*      returns the width of the character
static int      DrawBigChar(int xLocation, int yLocation, char theChar)
{
int            offset;
int            ii;
char      theByte;
boolean      specialCase;
int            specialIndex;
int            charWidth;

      if (theChar >= 'A')
      {
            theChar      =      theChar & 0x5F;      //*      force to upper case
      }
      specialCase      =      true;
      switch (theChar)
      {
            case 'M':      charWidth      =      5;      specialIndex      =      0;      break;
            case 'N':      charWidth      =      4;      specialIndex      =      1;      break;
            case 'Q':      charWidth      =      4;      specialIndex      =      2;      break;
            case 'V':      charWidth      =      4;      specialIndex      =      3;      break;
            case 'W':      charWidth      =      5;      specialIndex      =      4;      break;
                  
            
            default:
                  charWidth      =      3;
                  specialCase      =      false;
                  offset            =      6 * (theChar - 0x30);
                  gLCD.setCursor(xLocation, yLocation);
                  for (ii=0; ii<3; ii++)
                  {
                        theByte      =      pgm_read_byte_near(gBigFontAsciiTable + offset + ii);
                        gLCD.write(theByte);
                  }

                  gLCD.setCursor(xLocation, yLocation + 1);
                  offset      +=      3;
                  for (ii=0; ii<3; ii++)
                  {
                        theByte      =      pgm_read_byte_near(gBigFontAsciiTable + offset + ii);
                        gLCD.write(theByte);
                  }
                  break;
      }
      if (specialCase)
      {
            //*
            offset            =      10 * specialIndex;
            gLCD.setCursor(xLocation, yLocation);
            for (ii=0; ii<charWidth; ii++)
            {
                  theByte      =      pgm_read_byte_near(gBigFontAsciiTableWide + offset + ii);
                  gLCD.write(theByte);
            }

            gLCD.setCursor(xLocation, yLocation + 1);
            offset      +=      5;
            for (ii=0; ii<charWidth; ii++)
            {
                  theByte      =      pgm_read_byte_near(gBigFontAsciiTableWide + offset + ii);
                  gLCD.write(theByte);
            }
      }
      return(charWidth);
}
« Last Edit: February 12, 2010, 07:59:02 pm by msproul » Logged

MD, USA
Offline Offline
God Member
*****
Karma: 2
Posts: 663
A jack of all trades and a master of none!
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

More complex to start with and understand but goes a long way into making it usable.

One thing to note. The '5' and 'S' are now different. The 'S' stays the same but one segment of the '5' has changed. So it should look like this.
Code:
 255,       6,      6,      7,      7,      5,            //      0x35      5

Logged

USA
Offline Offline
Full Member
***
Karma: 2
Posts: 213
Arduino rocks
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Mike

Thanks, I made the change, I also added the punctuation chars, only exclamation and . (period) I wanted period because this will primarily be used for numeric display.
      32,      0,      32,      32,      4,      32,            //      0x21      !
      32,      32,      32,      32,      4,      32,            //      0x2E      . (period)

If you want to define more of the punctuation please do.

Mark
Logged

MD, USA
Offline Offline
God Member
*****
Karma: 2
Posts: 663
A jack of all trades and a master of none!
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

OK. I had the '!' but used 7 for the bottom rather then 4.

Code:
void customsm()  // sm= !
{
  lcd.setCursor(x,0);
  lcd.write(255);
  lcd.setCursor(x, 1);
  lcd.write(7);
}

most other punctuation won't be possible with the custom segments as they are defined.
Logged

0
Offline Offline
Newbie
*
Karma: 0
Posts: 31
Arduino rocks
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

hey guys, great thanks for this custom numbers development. I would like to make use of this special font for my digital clock display.any idea how to call this custom(); for example for seconds.

thanks smiley

Logged

MD, USA
Offline Offline
God Member
*****
Karma: 2
Posts: 663
A jack of all trades and a master of none!
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

I'm sure trying to use these custom numbers will cause a clock to have some timing issues. You may not be able to get seconds to stay accurate. Personally i would use the large fonts to display the hours and minutes and leave the seconds on the normal fonts.
Logged

North Yorkshire, UK
Offline Offline
Faraday Member
**
Karma: 104
Posts: 5531
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Quote
I'm sure trying to use these custom numbers will cause a clock to have some timing issues. You may not be able to get seconds to stay accurate. Personally i would use the large fonts to display the hours and minutes and leave the seconds on the normal fonts.
Hmm, maybe. I think that seconds would look good smaller too as it would then be easy to distinguish them from the rest.

Mowcius
Logged

0
Offline Offline
Jr. Member
**
Karma: 0
Posts: 65
Arduino rocks
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

I am trying to output my DS1307 in large format!!

here is my basic code:
Code:
// include the library
#include <LiquidCrystal.h>
#include <Wire.h>
#include <RTClib.h>
// initialize the interface pins
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);


RTC_DS1307 RTC;



void setup()
{
Wire.begin();
    RTC.begin();

  // sets the LCD's rows and colums:
  lcd.begin(16, 2);

}

void loop(){
  DateTime now = RTC.now();
  lcd.setCursor(0, 0);
  lcd.print(now.day(), DEC);
    lcd.print('/');
    lcd.print(now.month(), DEC);
    lcd.print('/');
    lcd.print(now.year(), DEC);
    lcd.print(' ');
    
    lcd.setCursor(0, 1);
    lcd.print(now.hour(), DEC);
    lcd.print(':');
    lcd.print(now.minute(), DEC);
    lcd.print(':');
    lcd.print(now.second(), DEC);
    //lcd.println();
}

How can I use the output of the RTC  to the large font?

Thanks in advance!
Logged

USA
Offline Offline
Full Member
***
Karma: 2
Posts: 213
Arduino rocks
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

DARRELL

The standard LCD library does not support the large fonts. These are an ad on done by digimike and I did some work on the code as well.

This extra code works by using the user defined character capabilities of the LCD display and then sending the right combination to create the character. The large character library takes care of this.

Go back through the post and you should be able to find the code. If not, I have a version of it that uses table driven lookup tables from program memory, much more efficent.

Mark
« Last Edit: June 18, 2010, 10:12:05 am by msproul » Logged

0
Offline Offline
Jr. Member
**
Karma: 0
Posts: 65
Arduino rocks
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Thanks for the Response.

I like the sound of the table version.

I have been trying to figure out how to display double numbers. I was thinking of using case statements but that is too long winded.

would it be possible to post your code?

Thanks Again.
Logged

USA
Offline Offline
Full Member
***
Karma: 2
Posts: 213
Arduino rocks
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Here is what I have. It uses program memory and a table for entry for each character

Code:

//************************************************************************
//*      A set of custom made large numbers for a 16x2 LCD using the
//*      LiquidCrystal librabry. Works with displays compatible with the
//*      Hitachi HD44780 driver.
//*      
//*      orginal developed  by Michael Pilcher  2/9/2010
//*      there are 8 entries, 8 bytes per entry
//*      these are the building blocks to make the numbers
//*      
//*      http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1265696343
//************************************************************************


//*      The LL, LT, UB, ect... are rust abreviations to help me designate which segment was which when referencing the large '0'.
//*      LT= left top
//*      UB= upper bar
//*      RT= right top
//*      LL= lower left
//*      LB= lower bar
//*      LR= lower right
//*      UMB= upper middle bars(upper middle section of the '8')
//*      LMB= lower middle bars(lower middle section of the '8')

uint8_t      gBigFontShapeTable[] PROGMEM      =      {
//*      LT[8] =
  B00111,
  B01111,
  B11111,
  B11111,
  B11111,
  B11111,
  B11111,
  B11111,
//*      UB[8] =
  B11111,
  B11111,
  B11111,
  B00000,
  B00000,
  B00000,
  B00000,
  B00000,
//*      RT[8] =
  B11100,
  B11110,
  B11111,
  B11111,
  B11111,
  B11111,
  B11111,
  B11111,
//*      LL[8] =
  B11111,
  B11111,
  B11111,
  B11111,
  B11111,
  B11111,
  B01111,
  B00111,
//*      LB[8] =
  B00000,
  B00000,
  B00000,
  B00000,
  B00000,
  B11111,
  B11111,
  B11111,
//*      LR[8] =
  B11111,
  B11111,
  B11111,
  B11111,
  B11111,
  B11111,
  B11110,
  B11100,
//*      UMB[8] =
  B11111,
  B11111,
  B11111,
  B00000,
  B00000,
  B00000,
  B11111,
  B11111,
//*      LMB[8] =
  B11111,
  B00000,
  B00000,
  B00000,
  B00000,
  B11111,
  B11111,
  B11111


};


//************************************************************************
//*      6 numbers for each character
//*      9 means BLANK
uint8_t      gBigFontAsciiTable[] PROGMEM      =      {

      32,      32,      32,      32,      32,      32,            //      0x20      space
      32,      0,      32,      32,      4,      32,            //      0x21      !
      32,      32,      32,      32,      32,      32,            //      0x22      
      32,      32,      32,      32,      32,      32,            //      0x23      
      32,      32,      32,      32,      32,      32,            //      0x24      
      32,      32,      32,      32,      32,      32,            //      0x25      
      32,      32,      32,      32,      32,      32,            //      0x26      
      32,      32,      32,      32,      32,      32,            //      0x27      
      32,      32,      32,      32,      32,      32,            //      0x28      
      32,      32,      32,      32,      32,      32,            //      0x29      
      32,      32,      32,      32,      32,      32,            //      0x2A      
      32,      32,      32,      32,      32,      32,            //      0x2B      
      32,      32,      32,      32,      32,      32,            //      0x2C      
      32,      32,      32,      32,      32,      32,            //      0x2D
      32,      32,      32,      32,      4,      32,            //      0x2E      . (period)
      32,      32,      32,      32,      32,      32,            //      0x2F      


      0,      1,      2,      3,      4,      5,            //      0x30      0
      1,      2,      32,      32,      5,      32,            //      0x31      1
      6,      6,      2,      3,      7,      7,            //      0x32      2
      6,      6,      2,      7,      7,      5,            //      0x33      3
      3,      4,      2,      32,      32,      5,            //      0x34      4
      255,6,      6,      7,      7,      5,            //      0x35      5
//      0,      6,      6,      7,      7,      5,            //      0x35      5
      0,      6,      6,      3,      7,      5,            //      0x36      6
      1,      1,      2,      32,      0,      32,            //      0x37      7
      0,      6,      2,      3,      7,      5,            //      0x38      8
      0,      6,      2,      32,      32,      5,            //      0x39      9
      32,      32,      32,      32,      32,      32,            //      0x3A      
      32,      32,      32,      32,      32,      32,            //      0x3B
      32,      32,      32,      32,      32,      32,            //      0x3C
      32,      32,      32,      32,      32,      32,            //      0x3D
      32,      32,      32,      32,      32,      32,            //      0x3E
      1,      6,      2,      254,7,      32,            //      0x3F      ?

      32,      32,      32,      32,      32,      32,            //      0x40      @
      0,      6,      2,      255,254,255,      //      0x41      A
      255,6,      5,      255,7,      2,            //      0x42      B
      0,      1,      1,      3,      4,      4,            //      0x43      C
      255,1,      2,      255,4,      5,            //      0x44      D
      255,6,      6,      255,7,      7,            //      0x45      E
      255,6,      6,      255,32,      32,            //      0x46      F
      
      0,      1,      1,      3,      4,      2,            //      0x47      G
      255,4,      255,255,254,255,      //      0x48      H
      1,      255,1,      4,      255,4,            //      0x49      I
      32,      32,      255,4,      4,      5,            //      0x4A      J
      255,4,      5,      255,254,2,            //      0x4B      K
      255,32,      32,      255,4,      4,            //      0x4C      L
      32,      32,      32,      32,      32,      32,            //      0x4D      M      place holder
      32,      32,      32,      32,      32,      32,            //      0x4E      N      place holder
      0,      1,      2,      3,      4,      5,            //      0x4F      O      (same as zero)

      0,      6,      2,      3,      32,      32,            //      0x50      P
      32,      32,      32,      32,      32,      32,            //      0x51      Q
      0,      6,      5,      3,      32,      2,            //      0x52      R
      0,      6,      6,      7,      7,      5,            //      0x35      S      (same as 5)
      1,      2,      1,      32,      5,      32,            //      0x54      T
      2,      32,      2,      3,      4,      5,            //      0x55      U
      32,      32,      32,      32,      32,      32,            //      0x56      V      place holder
      32,      32,      32,      32,      32,      32,            //      0x57      W      place holder
      3,      4,      5,      0,      32,      2,            //      0x58      X
      3,      4,      5,      32,      5,      32,            //      0x59      Y
      1,      6,      5,      0,      7,      4,            //      0x5A      Z
      0

};

//*      we have a seperate table for the wide routines
uint8_t      gBigFontAsciiTableWide[] PROGMEM      =      {
//*      this table is 10 bytes, 2 rows of 5
//      ---top------------|
      0,      1,      3,      1,      2,      3,      32,      32,      32,      5,            //      0x4D      M            5-wide
      0,      3,      32,      2,      32,      3,      32,      2,      5,      32,            //      0x4E      N            4-wide
      0,      1,      2,      32,      32,      3,      4,      3,      4,      32,            //      0x51      Q            4-wide
      3,      32,      32,      5,      32,      32,      3,      5,      32,      32,            //      0x56      V            4-wide
      0,      32,      32,      32,      2,      3,      4,      0,      4,      5,            //      0x57      W            5-wide
      0
};


//************************************************************************
static void      BigNumber_SendCustomChars(void)
{
uint8_t      customCharDef[10];
uint8_t      ii;
int            jj;

      for (ii=0; ii<8; ii++)
      {
            for (jj=0; jj<8; jj++)
            {
                  customCharDef[jj]      =      pgm_read_byte_near(gBigFontShapeTable + (ii * 8) + jj);
            }
            gLCD.createChar(ii, customCharDef);
      }
}

//************************************************************************
//*      returns the width of the character
static int      DrawBigChar(int xLocation, int yLocation, char theChar)
{
int            offset;
int            ii;
char      theByte;
boolean      specialCase;
int            specialIndex;
int            charWidth;

      if (theChar == 0x20)
      {
            return(2);
      }
      else if (theChar < 0x20)
      {
            return(0);
      }

      if (theChar >= 'A')
      {
            theChar      =      theChar & 0x5F;      //*      force to upper case
      }
      specialCase      =      true;
      switch (theChar)
      {
            case 'M':      charWidth      =      5;      specialIndex      =      0;      break;
            case 'N':      charWidth      =      4;      specialIndex      =      1;      break;
            case 'Q':      charWidth      =      4;      specialIndex      =      2;      break;
            case 'V':      charWidth      =      4;      specialIndex      =      3;      break;
            case 'W':      charWidth      =      5;      specialIndex      =      4;      break;
                  
            
            default:
                  charWidth      =      3;
                  specialCase      =      false;
                  offset            =      6 * (theChar - 0x20);
                  gLCD.setCursor(xLocation, yLocation);
                  for (ii=0; ii<3; ii++)
                  {
                        theByte      =      pgm_read_byte_near(gBigFontAsciiTable + offset + ii);
                        gLCD.write(theByte);
                  }

                  gLCD.setCursor(xLocation, yLocation + 1);
                  offset      +=      3;
                  for (ii=0; ii<3; ii++)
                  {
                        theByte      =      pgm_read_byte_near(gBigFontAsciiTable + offset + ii);
                        gLCD.write(theByte);
                  }
                  break;
      }
      if (specialCase)
      {
            //*
            offset            =      10 * specialIndex;
            gLCD.setCursor(xLocation, yLocation);
            for (ii=0; ii<charWidth; ii++)
            {
                  theByte      =      pgm_read_byte_near(gBigFontAsciiTableWide + offset + ii);
                  gLCD.write(theByte);
            }

            gLCD.setCursor(xLocation, yLocation + 1);
            offset      +=      5;
            for (ii=0; ii<charWidth; ii++)
            {
                  theByte      =      pgm_read_byte_near(gBigFontAsciiTableWide + offset + ii);
                  gLCD.write(theByte);
            }
      }
      return(charWidth + 1);
}


Logged

Pages: 1 2 [3] 4   Go Up
Jump to: