How to display "big" numbers on a character LCD

Other Hardware Displays
1

Hey there!

For a digital speedometer in a car I want to use a simple 2 or 4 line character LCD. I got a WINSTAR WH1602B, and I set it up using the LiquidCrystal library. Everything fine!

Now the project:
The numbers displayed on the LCD are very small, of course. I thought, however, that if I use two lines and two columns (2x2 fields) on the display for each number digit to be displayed, the numbers will be big enough to be easily readable for the car driver.

So I understood that if I want to display custom made glyphs on the LCD, I can use the createChar function. I also understood that the display cannot save more than 8 glyphs.

I thought: if my numbers to be displayed have only 3 digits maximum, and I display only numbers in a range between 0 and, let's say, 207 - there should be a way to create a "font" for the LCD which avoids using more than 8 glyphs at the same time (!) when displaying a number in that range.

That means, I created a number font where each number takes the space of 2x2 fields.
I counted the glyphs that are needed to display all these numbers: there are 12.
I can only save 8 glyphs to the LCD memory, but I made sure that whatever number I display (even if it has 3 digits), I do not have to use more than 8 glyphs to display it correctly.
So, every time a new number has to be displayed, the lcd.createChar function is called again to "prepare" all necessary glyphs and save them to the LCD memory.
When I want to display the new number on the LCD, I have to make sure that the correct glyph char is printed out to the correct field.

Maybe you can imagine that this creates quite an amount of code, as some arrays and a lot of for and while loops have to be used.
In the last 3 days, I wrote all my code, now the display is basically doing what it should, and I even like the style of my numbers. 8)

But I have two problems: :~

  1. When the number updates, apparently it takes too long between the saving of the new chars (lcd.createChar function) and the actual output of the new number (because many for and while loops), so the digits change in a weird way. Of course, I can clear the display right before I create a new char, but the flickering is not much nicer than the weird transitions...

  2. The code is long, and probably "slow", and I would really appreciate if someone more advanced could take a look what can be improved. On my Arduino Diecimila, it takes already almost 90% just to drive the display with this code.

Anyway, I guess that it's quite a common need to display large numbers on an LCD, and I guess that my code is basically useful for most people already. But I'd like to improve it and make it more efficient, if possible.

I'll post the complete code here. I apologize for the length...
In this example, a number (initially 0) is incremented approx. after every second and being displayed on the LCD. After it reaches 207, it is resetted to 0.

2

Because code is too long, I'll split it.
Here part1:

#include <LiquidCrystal.h>
#include <Scheduler.h>

// Connections:
// rs (LCD pin 4) to Arduino pin 12
// rw (LCD pin 5) to Arduino pin 11
// enable (LCD pin 6) to Arduino pin 10
// LCD pin 15 to Arduino pin 13
// LCD pins d4, d5, d6, d7 to Arduino pins 5, 4, 3, 2
LiquidCrystal lcd(12, 11, 10, 5, 4, 3, 2);
Scheduler scheduler1 = Scheduler();      //create a scheduler


int backLight = 13;    // pin 13 will control the backlight

int numberdigits[4]={};
int zehnerstelle;
int speednr = 0;
int digitsamount = 0;
char* segments[9] = {}; 
char* added;
int currentindex = 0;
boolean ignorethis = false;
int charsused = 0;
int xpos = 0;
int ypos = 0;
int digitround = 0;

byte glyph_a[9] = {
  B11000,
  B11000,
  B11000,
  B11000,
  B11000,
  B11000,
  B11000,
  B11000
};

byte glyph_b[9] = {
  B11111,
  B11111,
  B00000,
  B00000,
  B00000,
  B00000,
  B00000,
  B00000
};

byte glyph_c[9] = {
  B11111,
  B11111,
  B00011,
  B00011,
  B00011,
  B00011,
  B11111,
  B11111
};

byte glyph_d[9] = {
  B00011,
  B00011,
  B00011,
  B00011,
  B00011,
  B00011,
  B11111,
  B11111
};

byte glyph_e[9] = {
  B11000,
  B11000,
  B11000,
  B11000,
  B11000,
  B11000,
  B11111,
  B11111
};

byte glyph_f[9] = {
  B11111,
  B11111,
  B11000,
  B11000,
  B11000,
  B11000,
  B11111,
  B11111
};

byte glyph_g[9] = {
  B11111,
  B11111,
  B00000,
  B00000,
  B00000,
  B00000,
  B11111,
  B11111
};

byte glyph_h[9] = {
  B00000,
  B00000,
  B00000,
  B00000,
  B00000,
  B00000,
  B11111,
  B11111
};

byte glyph_i[9] = {
  B00011,
  B00011,
  B00110,
  B00110,
  B01100,
  B01100,
  B11111,
  B11111  
};

byte glyph_j[9] = {
  B11111,
  B11111,
  B00110,
  B00110,
  B01100,
  B01100,
  B11000,
  B11000  
};

byte glyph_k[9] = {
  B00011,
  B00011,
  B00110,
  B00110,
  B01100,
  B01100,
  B11000,
  B11000  
};

byte glyph_l[9] = {
  B11000,
  B11000,
  B01100,
  B01100,
  B00110,
  B00110,
  B00011,
  B00011  
};





char* array_0[5] = {"K","L","L","K"};
char* array_1[5] = {"Z","A","Z","A"};
char* array_2[5] = {"B","C","I","H"};
char* array_3[5] = {"B","C","H","D"};
char* array_4[5] = {"I","E","Z","A"};
char* array_5[5] = {"I","G","H","D"};
char* array_6[5] = {"I","H","E","K"};
char* array_7[5] = {"B","J","K","Z"};
char* array_8[5] = {"F","C","E","D"};
char* array_9[5] = {"I","C","Z","K"};



void setup()
{
  Serial.begin(4800);
  pinMode(backLight, OUTPUT);
  digitalWrite(backLight, HIGH); // turn backlight on. Replace 'HIGH' with 'LOW' to turn it off.
  lcd.begin(16,2);              // columns, rows.  use 16,2 for a 16x2 LCD, etc.
  lcd.clear();                  // start with a blank screen
    
  // if you have a 4 row LCD, uncomment these lines to write to the bottom rows
  // and change the lcd.begin() statement above.
  //lcd.setCursor(0,2);         // set cursor to column 0, row 2
  //lcd.print("Row 3");
  //lcd.setCursor(0,3);         // set cursor to column 0, row 3
  //lcd.print("Row 4");
  
  createNumber_0();
}

void loop()
{
  scheduler1.update(); 
}

void createNumber_0() {  // analyze numbers (I)

  memset(numberdigits,0,sizeof(numberdigits));  // empty numberdigits array
  if(speednr > 199) {               // numberdigits is always 3 numbers long, even if it starts with 0    
    numberdigits[0] = 2;
    zehnerstelle = speednr-200;
    digitsamount = 3;
    createNumber_1();
  } else if(speednr > 99) {
    numberdigits[0] = 1;    
    zehnerstelle = speednr-100;
    digitsamount = 3;
    createNumber_1();
  } else if(speednr > 9) {
    numberdigits[0] = 0;
    digitsamount = 2;
    zehnerstelle = speednr; 
    createNumber_1();   
  } else {
    numberdigits[0] = 0;
    digitsamount = 1;
    zehnerstelle = 0; 
    createNumber_1();    
  }
}

void createNumber_1() {  // analyze numbers (II) and fill array numberdigits[]
  digitround = 0;
  if(zehnerstelle > 89) {
    numberdigits[1] = 9;
    numberdigits[2] = zehnerstelle - 90;
    Serial.println("1. Digits Array created for this number.");
    Serial.print("   ");Serial.print(numberdigits[0]);Serial.print(numberdigits[1]);Serial.println(numberdigits[2]);
    createNumber_2();
  } else if(zehnerstelle > 79) {
    numberdigits[1] = 8;
    numberdigits[2] = zehnerstelle - 80;
    Serial.println("1. Digits Array created for this number.");
    Serial.print("   ");Serial.print(numberdigits[0]);Serial.print(numberdigits[1]);Serial.println(numberdigits[2]);
    createNumber_2();
  } else if(zehnerstelle > 69) {
    numberdigits[1] = 7;
    numberdigits[2] = zehnerstelle - 70;
    Serial.println("1. Digits Array created for this number.");
    Serial.print("   ");Serial.print(numberdigits[0]);Serial.print(numberdigits[1]);Serial.println(numberdigits[2]);
    createNumber_2();
  } else if(zehnerstelle > 59) {
    numberdigits[1] = 6;
    numberdigits[2] = zehnerstelle - 60;
    Serial.println("1. Digits Array created for this number.");
    Serial.print("   ");Serial.print(numberdigits[0]);Serial.print(numberdigits[1]);Serial.println(numberdigits[2]);
    createNumber_2();
  } else if(zehnerstelle > 49) {
    numberdigits[1] = 5;
    numberdigits[2] = zehnerstelle - 50;
    Serial.println("1. Digits Array created for this number.");
    Serial.print("   ");Serial.print(numberdigits[0]);Serial.print(numberdigits[1]);Serial.println(numberdigits[2]);
    createNumber_2();
  } else if(zehnerstelle > 39) {
    numberdigits[1] = 4;
    numberdigits[2] = zehnerstelle - 40;
    Serial.println("1. Digits Array created for this number.");
    Serial.print("   ");Serial.print(numberdigits[0]);Serial.print(numberdigits[1]);Serial.println(numberdigits[2]);
    createNumber_2();
  } else if(zehnerstelle > 29) {
    numberdigits[1] = 3;
    numberdigits[2] = zehnerstelle - 30;
    Serial.println("1. Digits Array created for this number.");
    Serial.print("   ");Serial.print(numberdigits[0]);Serial.print(numberdigits[1]);Serial.println(numberdigits[2]);
    createNumber_2();
  } else if(zehnerstelle > 19) {
    numberdigits[1] = 2;
    numberdigits[2] = zehnerstelle - 20;
    Serial.println("1. Digits Array created for this number.");
    Serial.print("   ");Serial.print(numberdigits[0]);Serial.print(numberdigits[1]);Serial.println(numberdigits[2]);
    createNumber_2();
  } else if(zehnerstelle > 9) {
    numberdigits[1] = 1;
    numberdigits[2] = zehnerstelle - 10;
    Serial.println("1. Digits Array created for this number.");
    Serial.print("   ");Serial.print(numberdigits[0]);Serial.print(numberdigits[1]);Serial.println(numberdigits[2]);
    createNumber_2();
  } else {
    numberdigits[1] = 0;
    if(speednr < 10) {
      numberdigits[2] = speednr;
    } else if(speednr > 199) {
      numberdigits[2] = speednr-200;
    } else if(speednr > 99) {
      numberdigits[2] = speednr-100;
    }
    Serial.println("1. Digits Array created for this number.");
    Serial.print("   ");Serial.print(numberdigits[0]);Serial.print(numberdigits[1]);Serial.println(numberdigits[2]);
    createNumber_2();
  }

}
3

Here part 2:

void createNumber_2() {  // create an array of required glyphs, where no glyph appears more than once          
  memset(segments,0,sizeof(segments));// empty segments array
  currentindex = 0;  // go to pos 0 in the segments array
  added = "Z";       // reset "added" var
  for(int i=1; i<=3; i++) {
    //Serial.print("Adding glyph for digit ");Serial.print(i);Serial.print(" of 3: ");Serial.println(numberdigits[i-1]);        
    switch (numberdigits[i-1]) {
      case 0:
      if( ((digitsamount == 3) && (i == 2)) || (i == 3) ) {  // Ignore 0 in the beginning, and ignore 0 as second digit, if there are not 3 digits in total. Never ignore 0 as third digit.
        for(int j=0; j<=3; j++) {
          if(array_0[j] != "Z") {   // if not an empty entry
            int currentlength = currentindex;          
            for(int k=0; k<=currentlength; k++) {                     // traverse the array ...
              if((segments[k] == array_0[j]) || (array_0[j] == added)) {   // search if element already exists or has been added just a momemt ago in the course of the current for loop. 
                ignorethis = true;                
              }
              if(k>=currentlength) {
                if(ignorethis == false) {
                  segments[currentindex] = array_0[j];                       // if not: element must be added at current position in the segments array
                  //Serial.print("Added 1 element for no. 0 to segments array: ");Serial.println(array_0[j]);
                  added = array_0[j];                                        //         write the char into the added variable
                  currentindex++;                                            //         increment position integer
                }
                ignorethis = false;
                
                if((i==3)&&(j==3)) {
                  Serial.println("2. Glyphs for this number saved to array.");      
                  createNumber_3();
                }
              }                  
            }                                            
          } else if((i==3)&&(j==3)) {
            Serial.println("2. Glyphs for this number saved to array.");      
            createNumber_3();
          }
        }                
      } 
      break;
      case 1:
      for(int j=0; j<=3; j++) {
        if(array_1[j] != "Z") {
          int currentlength = currentindex;
          for(int k=0; k<=currentlength; k++) {
            if((segments[k] == array_1[j]) || (array_1[j] == added)) {
              ignorethis = true;                
            }
            if(k>=currentlength) {
              if(ignorethis == false) {
                segments[currentindex] = array_1[j];                       // if not: element must be added at current position in the segments array
                //Serial.print("Added 1 element for no. 1 to segments array: ");Serial.println(array_1[j]);
                added = array_1[j];                                        //         write the char into the added variable
                currentindex++;
              }
              ignorethis = false;
              
              if((i==3)&&(j==3)) {
                  Serial.println("2. Glyphs for this number saved to array.");      
                  createNumber_3();
              }      
            }
          }
        } else if((i==3)&&(j==3)) {
          Serial.println("2. Glyphs for this number saved to array.");      
          createNumber_3();
        }
      }
      break;
      case 2:
      for(int j=0; j<=3; j++) {
        if(array_2[j] != "Z") {
          int currentlength = currentindex;
          for(int k=0; k<=currentlength; k++) {
            if((segments[k] == array_2[j]) || (array_2[j] == added)) {
              ignorethis = true;                
            }
            if(k>=currentlength) {
              if(ignorethis == false) {
                segments[currentindex] = array_2[j];                       // if not: element must be added at current position in the segments array
                //Serial.print("Added 1 element for no. 2 to segments array: ");Serial.println(array_2[j]);
                added = array_2[j];                                        //         write the char into the added variable
                currentindex++;
              }
              ignorethis = false;
              
              if((i==3)&&(j==3)) {
                  Serial.println("2. Glyphs for this number saved to array.");      
                  createNumber_3();
              }
            }
          }
        } else if((i==3)&&(j==3)) {
          Serial.println("2. Glyphs for this number saved to array.");      
          createNumber_3();
        }
      }
      break;
      case 3:
      for(int j=0; j<=3; j++) {
        if(array_3[j] != "Z") {
          int currentlength = currentindex;
          for(int k=0; k<=currentlength; k++) {
            if((segments[k] == array_3[j]) || (array_3[j] == added)) {
              ignorethis = true;                
            }
            if(k>=currentlength) {
              if(ignorethis == false) {
                segments[currentindex] = array_3[j];                       // if not: element must be added at current position in the segments array
                //Serial.print("Added 1 element for no. 3 to segments array: ");Serial.println(array_3[j]);
                added = array_3[j];                                        //         write the char into the added variable
                currentindex++;
              }
              ignorethis = false;
              
              if((i==3)&&(j==3)) {
                  Serial.println("2. Glyphs for this number saved to array.");      
                  createNumber_3();
              }
            }
          }
        } else if((i==3)&&(j==3)) {
          Serial.println("2. Glyphs for this number saved to array.");      
          createNumber_3();
        }
      }
      break;
      case 4:
      for(int j=0; j<=3; j++) {
        if(array_4[j] != "Z") {
          int currentlength = currentindex;
          for(int k=0; k<=currentlength; k++) {
            if((segments[k] == array_4[j]) || (array_4[j] == added)) {
              ignorethis = true;                
            }
            if(k>=currentlength) {
              if(ignorethis == false) {
                segments[currentindex] = array_4[j];                       // if not: element must be added at current position in the segments array
                //Serial.print("Added 1 element for no. 4 to segments array: ");Serial.println(array_4[j]);
                added = array_4[j];                                        //         write the char into the added variable
                currentindex++;
              }
              ignorethis = false;
              
              if((i==3)&&(j==3)) {
                  Serial.println("2. Glyphs for this number saved to array.");      
                  createNumber_3();
              }
            }
          }
        } else if((i==3)&&(j==3)) {
          Serial.println("2. Glyphs for this number saved to array.");      
          createNumber_3();
        }
      }
      break;
      case 5:
      for(int j=0; j<=3; j++) {
        if(array_5[j] != "Z") {
          int currentlength = currentindex;
          for(int k=0; k<=currentlength; k++) {
            if((segments[k] == array_5[j]) || (array_5[j] == added)) {
              ignorethis = true;                
            }
            if(k>=currentlength) {
              if(ignorethis == false) {
                segments[currentindex] = array_5[j];                       // if not: element must be added at current position in the segments array
                //Serial.print("Added 1 element for no. 5 to segments array: ");Serial.println(array_5[j]);
                added = array_5[j];                                        //         write the char into the added variable
                currentindex++;
              }
              ignorethis = false;
              
              if((i==3)&&(j==3)) {
                  Serial.println("2. Glyphs for this number saved to array.");      
                  createNumber_3();
              }
            }
          }
        } else if((i==3)&&(j==3)) {
          Serial.println("2. Glyphs for this number saved to array.");      
          createNumber_3();
        }
      }
      break;
4

Here part 3:

      case 6:
      for(int j=0; j<=3; j++) {
        if(array_6[j] != "Z") {
          int currentlength = currentindex;
          for(int k=0; k<=currentlength; k++) {
            if((segments[k] == array_6[j]) || (array_6[j] == added)) {
              ignorethis = true;                
            }
            if(k>=currentlength) {
              if(ignorethis == false) {
                segments[currentindex] = array_6[j];                       // if not: element must be added at current position in the segments array
                //Serial.print("Added 1 element for no. 6 to segments array: ");Serial.println(array_6[j]);
                added = array_6[j];                                        //         write the char into the added variable
                currentindex++;
              }
              ignorethis = false;
              
              if((i==3)&&(j==3)) {
                  Serial.println("2. Glyphs for this number saved to array.");      
                  createNumber_3();
              }
            }
          }
        } else if((i==3)&&(j==3)) {
          Serial.println("2. Glyphs for this number saved to array.");      
          createNumber_3();
        }
      }
      break;
      case 7:
      for(int j=0; j<=3; j++) {
        if(array_7[j] != "Z") {
          int currentlength = currentindex;
          for(int k=0; k<=currentlength; k++) {
            if((segments[k] == array_7[j]) || (array_7[j] == added)) {
              ignorethis = true;                
            }
            if(k>=currentlength) {
              if(ignorethis == false) {
                segments[currentindex] = array_7[j];                       // if not: element must be added at current position in the segments array
                //Serial.print("Added 1 element for no. 7 to segments array: ");Serial.println(array_7[j]);
                added = array_7[j];                                        //         write the char into the added variable
                currentindex++;
              }
              ignorethis = false;
              
              if((i==3)&&(j==3)) {
                  Serial.println("2. Glyphs for this number saved to array.");      
                  createNumber_3();
              }
            }
          }
        } else if((i==3)&&(j==3)) {
          Serial.println("2. Glyphs for this number saved to array.");      
          createNumber_3();
        }
      }
      break;
      case 8:
      for(int j=0; j<=3; j++) {
        if(array_8[j] != "Z") {
          int currentlength = currentindex;
          for(int k=0; k<=currentlength; k++) {
            if((segments[k] == array_8[j]) || (array_8[j] == added)) {
              ignorethis = true;                
            }
            if(k>=currentlength) {
              if(ignorethis == false) {
                segments[currentindex] = array_8[j];                       // if not: element must be added at current position in the segments array
                //Serial.print("Added 1 element for no. 8 to segments array: ");Serial.println(array_8[j]);
                added = array_8[j];                                        //         write the char into the added variable
                currentindex++;
              }
              ignorethis = false;
              
              if((i==3)&&(j==3)) {
                  Serial.println("2. Glyphs for this number saved to array.");      
                  createNumber_3();
              }
            }
          }
        } else if((i==3)&&(j==3)) {
          Serial.println("2. Glyphs for this number saved to array.");      
          createNumber_3();
        }
      }
      break;
      case 9:
      for(int j=0; j<=3; j++) {
        if(array_9[j] != "Z") {
          int currentlength = currentindex;
          for(int k=0; k<=currentlength; k++) {
            if((segments[k] == array_9[j]) || (array_9[j] == added)) {
              ignorethis = true;                
            }
            if(k>=currentlength) {
              if(ignorethis == false) {
                segments[currentindex] = array_9[j];                       // if not: element must be added at current position in the segments array
                //Serial.print("Added 1 element for no. 9 to segments array: ");Serial.println(array_9[j]);
                added = array_9[j];                                        //         write the char into the added variable
                currentindex++;
              }
              ignorethis = false;
              
              if((i==3)&&(j==3)) {
                  Serial.println("2. Glyphs for this number saved to array.");      
                  createNumber_3();
              }
            }
          }
        } else if((i==3)&&(j==3)) {
          Serial.println("2. Glyphs for this number saved to array.");      
          createNumber_3();
        }
      }
      break;
    }
  }    
}
5

Here part 4:

void createNumber_3() {  // save the necessary glyph chars in the lcd display memory
  lcd.setCursor(0,0);
  lcd.print("      ");
  lcd.setCursor(0,1);
  lcd.print("      ");
  Serial.print("   Segments: ");  
  for(int s=0; s<=7; s++) {    
    Serial.print(segments[s]);Serial.print(", ");
    if(segments[s] == "A") {
      lcd.createChar(s, glyph_a);
      if(s==7) {
        Serial.println();
        Serial.println("3. LCD Chars saved for this number.");      
        scheduler1.schedule(createNumber_4,50);
      }
    } else if(segments[s] == "B") {
      lcd.createChar(s, glyph_b);
      if(s==7) {
        Serial.println();
        Serial.println("3. LCD Chars saved for this number.");      
        scheduler1.schedule(createNumber_4,50);
      }
    } else if(segments[s] == "C") {
      lcd.createChar(s, glyph_c);
      if(s==7) {
        Serial.println();
        Serial.println("3. LCD Chars saved for this number.");      
        scheduler1.schedule(createNumber_4,50);
      }
    } else if(segments[s] == "D") {
      lcd.createChar(s, glyph_d);
      if(s==7) {
        Serial.println();
        Serial.println("3. LCD Chars saved for this number.");      
        scheduler1.schedule(createNumber_4,50);
      }
    } else if(segments[s] == "E") {
      lcd.createChar(s, glyph_e);
      if(s==7) {
        Serial.println();
        Serial.println("3. LCD Chars saved for this number.");      
        scheduler1.schedule(createNumber_4,50);
      }
    } else if(segments[s] == "F") {
      lcd.createChar(s, glyph_f);
      if(s==7) {
        Serial.println();
        Serial.println("3. LCD Chars saved for this number.");      
        scheduler1.schedule(createNumber_4,50);
      }
    } else if(segments[s] == "G") {
      lcd.createChar(s, glyph_g);
      if(s==7) {
        Serial.println();
        Serial.println("3. LCD Chars saved for this number.");      
        scheduler1.schedule(createNumber_4,50);
      }
    } else if(segments[s] == "H") {
      lcd.createChar(s, glyph_h);
      if(s==7) {
        Serial.println();
        Serial.println("3. LCD Chars saved for this number.");      
        scheduler1.schedule(createNumber_4,50);
      }
    } else if(segments[s] == "I") {
      lcd.createChar(s, glyph_i);
      if(s==7) {
        Serial.println();
        Serial.println("3. LCD Chars saved for this number.");      
        scheduler1.schedule(createNumber_4,50);
      }
    } else if(segments[s] == "J") {
      lcd.createChar(s, glyph_j);
      if(s==7) {
        Serial.println();
        Serial.println("3. LCD Chars saved for this number.");      
        scheduler1.schedule(createNumber_4,50);
      }
    } else if(segments[s] == "K") {
      lcd.createChar(s, glyph_k);
      if(s==7) {
        Serial.println();
        Serial.println("3. LCD Chars saved for this number.");      
        scheduler1.schedule(createNumber_4,50);
      }
    } else if(segments[s] == "L") {
      lcd.createChar(s, glyph_l); 
      if(s==7) {
        Serial.println();
        Serial.println("3. LCD Chars saved for this number.");      
        scheduler1.schedule(createNumber_4,50);
      }     
    } else if(segments[s] == 0) {
      if(s==7) {
        Serial.println();
        Serial.println("3. LCD Chars saved for this number.");      
        scheduler1.schedule(createNumber_4,50);       
      }
    }
    
  }
}
6

Here part 5:

void createNumber_4() {  //for each digit, set the cursor to the correct position, and decide if something has to be written, or not 
  //lcd.clear();                  // start with a blank screen
  
  if(digitround==0) { // we're dealing with the first digit...
    Serial.print("4. ");  
    xpos=0;
    ypos=0;
    lcd.setCursor(xpos,ypos);
    /*
    lcd.print("  ");
    lcd.setCursor(0,1);
    lcd.print("  ");
    lcd.setCursor(xpos,ypos);
    */
    if(numberdigits[0] != 0) { // digit no. 1 is not a 0, so write it!      
      createNumber_5();
    } else {
      Serial.print("Writing digit no. ");Serial.println(digitround+1);
      lcd.print("  ");
      lcd.setCursor(0,1);
      lcd.print("  ");
      digitround = 1;
      createNumber_4();
    }
      
  } else if(digitround==1) { // we're dealing with the second digit...
    xpos=2;
    ypos=0;
    lcd.setCursor(xpos,ypos);
    /*
    lcd.print("  ");
    lcd.setCursor(2,1);
    lcd.print("  ");
    lcd.setCursor(xpos,ypos);
    */
    if( ((numberdigits[1] == 0) && (digitsamount==3)) || (numberdigits[1] != 0) ) {  //if second digit is 0, it will be written only if number has 3 digits altogether. if it's not 0, it will be writen at any case.        
        createNumber_5();
    } else {
      Serial.print("   Writing digit no. ");Serial.println(digitround+1);
      lcd.print("  ");
      lcd.setCursor(2,1);
      lcd.print("  ");
      digitround = 2;
      createNumber_4();
    }
  } else if(digitround==2) { // we're dealing with the third digit... it will be written at any case, even if it's 0.
    xpos=4;
    ypos=0;
    lcd.setCursor(xpos,ypos);
    /*
    lcd.print("  ");
    lcd.setCursor(4,1);
    lcd.print("  ");
    lcd.setCursor(xpos,ypos);  
    */  
    createNumber_5();
  }     
}

void createNumber_5() {  //output the segments to the display
  if(digitround==0) {
    Serial.print("Writing digit no. ");Serial.println(digitround+1);
  } else {
    Serial.print("   Writing digit no. ");Serial.println(digitround+1);
  }
  digitround++;
  
  switch(numberdigits[digitround-1]) {
    case 0:
    for(int s=0; s<=3; s++) {
      if(s==1) {
        lcd.setCursor(xpos+1,ypos);
      } else if(s==2) {
        lcd.setCursor(xpos,1);   
      } else if(s==3) {
        lcd.setCursor(xpos+1,1);
      }
      int t=0;     
      if(array_0[s] == "K") {
        while(t<=7) {
          if(segments[t]=="K") {
            lcd.write(byte(t));
            if((digitround==3) && (s==3)) {              
              createNumber_6();
            } else if(s==3) {
              createNumber_4();
            }
            break;            
          } else {
            t++;
          }
        }
      } else if(array_0[s] == "L") {
        while(t<=7) {
          if(segments[t]=="L") {
            lcd.write(byte(t));
            break;
          } else {
            t++;
          }
        }
      } 
    }
    break; 
    case 1:
    for(int s=0; s<=3; s++) {
      if(s==1) {
        lcd.setCursor(xpos+1,ypos);
      } else if(s==2) {
        lcd.setCursor(xpos,1);   
      } else if(s==3) {
        lcd.setCursor(xpos+1,1);
      }
      int t=0;     
      if(array_1[s] == "A") {
        while(t<=7) {
          if(segments[t]=="A") {
            lcd.write(byte(t));
            if((digitround==3) && (s==3)) {             
              createNumber_6();
            } else if(s==3) {
              createNumber_4();
            }
            break;
          } else {
            t++;
          }
        }
      } else if(array_1[s] == "Z") {        
         lcd.print(" ");
      }
    }
    break; 
    case 2:
    for(int s=0; s<=3; s++) {
      if(s==1) {
        lcd.setCursor(xpos+1,ypos);
      } else if(s==2) {
        lcd.setCursor(xpos,1);   
      } else if(s==3) {
        lcd.setCursor(xpos+1,1);
      }
      int t=0;     
      if(array_2[s] == "B") {
        while(t<=7) {
          if(segments[t]=="B") {
            lcd.write(byte(t));
            break;                
          } else {
            t++;
          }
        }
      } else if(array_2[s] == "C") {
        while(t<=7) {
          if(segments[t]=="C") {
            lcd.write(byte(t));
            break;
          } else {
            t++;
          }
        }
      } else if(array_2[s] == "H") {
        while(t<=7) {
          if(segments[t]=="H") {
            lcd.write(byte(t));
            if((digitround==3) && (s==3)) {              
              createNumber_6();
            } else if(s==3) {
              createNumber_4();
            }
            break;
          } else {
            t++;
          }
        }
      } else if(array_2[s] == "I") {
        while(t<=7) {
          if(segments[t]=="I") {
            lcd.write(byte(t));
            break;
          } else {
            t++;
          }
        }
      } 
    }
    break;
7

Here part 6:

    case 3:
    for(int s=0; s<=3; s++) {
      if(s==1) {
        lcd.setCursor(xpos+1,ypos);
      } else if(s==2) {
        lcd.setCursor(xpos,1);   
      } else if(s==3) {
        lcd.setCursor(xpos+1,1);
      }
      int t=0;     
      if(array_3[s] == "B") {
        while(t<=7) {
          if(segments[t]=="B") {
            lcd.write(byte(t));
            break;                
          } else {
            t++;
          }
        }
      } else if(array_3[s] == "C") {
        while(t<=7) {
          if(segments[t]=="C") {
            lcd.write(byte(t));
            break;
          } else {
            t++;
          }
        }
      } else if(array_3[s] == "D") {
        while(t<=7) {
          if(segments[t]=="D") {
            lcd.write(byte(t));
            if((digitround==3) && (s==3)) {             
              createNumber_6();
            } else if(s==3) {
              createNumber_4();
            }
            break;
          } else {
            t++;
          }
        }
      } else if(array_3[s] == "H") {
        while(t<=7) {
          if(segments[t]=="H") {
            lcd.write(byte(t));
            break;
          } else {
            t++;
          }
        }
      } 
    }
    break; 
    case 4:
    for(int s=0; s<=3; s++) {
      if(s==1) {
        lcd.setCursor(xpos+1,ypos);
      } else if(s==2) {
        lcd.setCursor(xpos,1);   
      } else if(s==3) {
        lcd.setCursor(xpos+1,1);
      }
      int t=0;     
      if(array_4[s] == "A") {
        while(t<=7) {
          if(segments[t]=="A") {
            lcd.write(byte(t));
            if((digitround==3) && (s==3)) {             
              createNumber_6();
            } else if(s==3) {
              createNumber_4();
            }
            break;
          } else {
            t++;
          }
        }
      } else if(array_4[s] == "E") {
        while(t<=7) {
          if(segments[t]=="E") {
            lcd.write(byte(t));
            break;                
          } else {
            t++;
          }
        }
      } else if(array_4[s] == "I") {
        while(t<=7) {
          if(segments[t]=="I") {
            lcd.write(byte(t));
            break;
          } else {
            t++;
          }
        }
      } else if(array_4[s] == "Z") {        
         lcd.print(" ");
      }
    }
    break;
8

Here part 7:

    case 5:
    for(int s=0; s<=3; s++) {
      if(s==1) {
        lcd.setCursor(xpos+1,ypos);
      } else if(s==2) {
        lcd.setCursor(xpos,1);   
      } else if(s==3) {
        lcd.setCursor(xpos+1,1);
      }
      int t=0;     
      if(array_5[s] == "I") {
        while(t<=7) {
          if(segments[t]=="I") {
            lcd.write(byte(t));
            break;
          } else {
            t++;
          }
        }
      } else if(array_5[s] == "G") {
        while(t<=7) {
          if(segments[t]=="G") {
            lcd.write(byte(t));
            break;                
          } else {
            t++;
          }
        }
      } else if(array_5[s] == "H") {
        while(t<=7) {
          if(segments[t]=="H") {
            lcd.write(byte(t));
            break;
          } else {
            t++;
          }
        }
      } else if(array_5[s] == "D") {
        while(t<=7) {
          if(segments[t]=="D") {
            lcd.write(byte(t));
            if((digitround==3) && (s==3)) {             
              createNumber_6();
            } else if(s==3) {
              createNumber_4();
            }
            break;
          } else {
            t++;
          }
        }
      } 
    }
    break;  
    case 6:
    for(int s=0; s<=3; s++) {
      if(s==1) {
        lcd.setCursor(xpos+1,ypos);
      } else if(s==2) {
        lcd.setCursor(xpos,1);   
      } else if(s==3) {
        lcd.setCursor(xpos+1,1);
      }
      int t=0;     
      if(array_6[s] == "E") {
        while(t<=7) {
          if(segments[t]=="E") {
            lcd.write(byte(t));
            break;
          } else {
            t++;
          }
        }
      } else if(array_6[s] == "H") {
        while(t<=7) {
          if(segments[t]=="H") {
            lcd.write(byte(t));
            break;                
          } else {
            t++;
          }
        }
      } else if(array_6[s] == "I") {
        while(t<=7) {
          if(segments[t]=="I") {
            lcd.write(byte(t));
            break;
          } else {
            t++;
          }
        }
      } else if(array_6[s] == "K") {
        while(t<=7) {
          if(segments[t]=="K") {
            lcd.write(byte(t));
            if((digitround==3) && (s==3)) {             
              createNumber_6();
            } else if(s==3) {
              createNumber_4();
            }
            break;
          } else {
            t++;
          }
        }
      } 
    }
    break;
9

Here part 8:

    case 7:
    for(int s=0; s<=3; s++) {
      if(s==1) {
        lcd.setCursor(xpos+1,ypos);
      } else if(s==2) {
        lcd.setCursor(xpos,1);   
      } else if(s==3) {
        lcd.setCursor(xpos+1,1);
      }
      int t=0;     
      if(array_7[s] == "B") {
        while(t<=7) {
          if(segments[t]=="B") {
            lcd.write(byte(t));
            break;
          } else {
            t++;
          }
        }
      } else if(array_7[s] == "J") {
        while(t<=7) {
          if(segments[t]=="J") {
            lcd.write(byte(t));
            break;                
          } else {
            t++;
          }
        }
      } else if(array_7[s] == "K") {
        while(t<=7) {
          if(segments[t]=="K") {
            lcd.write(byte(t));
            break;
          } else {
            t++;
          }
        }
      } else if(array_7[s] == "Z") {        
        lcd.print(" ");
        if((digitround==3) && (s==3)) {             
          createNumber_6();
        } else if(s==3) {
          createNumber_4();
        }
      }
    }
    break;  
    case 8:
    for(int s=0; s<=3; s++) {
      if(s==1) {
        lcd.setCursor(xpos+1,ypos);
      } else if(s==2) {
        lcd.setCursor(xpos,1);   
      } else if(s==3) {
        lcd.setCursor(xpos+1,1);
      }
      int t=0;     
      if(array_8[s] == "C") {
        while(t<=7) {
          if(segments[t]=="C") {
            lcd.write(byte(t));
            break;
          } else {
            t++;
          }
        }
      } else if(array_8[s] == "D") {
        while(t<=7) {
          if(segments[t]=="D") {
            lcd.write(byte(t));
            if((digitround==3) && (s==3)) {             
              createNumber_6();
            } else if(s==3) {
              createNumber_4();
            }
            break;                
          } else {
            t++;
          }
        }
      } else if(array_8[s] == "E") {
        while(t<=7) {
          if(segments[t]=="E") {
            lcd.write(byte(t));
            break;
          } else {
            t++;
          }
        }
      } else if(array_8[s] == "F") {
        while(t<=7) {
          if(segments[t]=="F") {
            lcd.write(byte(t));
            break;
          } else {
            t++;
          }
        }
      } 
    }
    break;
10

Here part 9:

    case 9:
    for(int s=0; s<=3; s++) {
      if(s==1) {
        lcd.setCursor(xpos+1,ypos);
      } else if(s==2) {
        lcd.setCursor(xpos,1);   
      } else if(s==3) {
        lcd.setCursor(xpos+1,1);
      }
      int t=0;     
      if(array_9[s] == "C") {
        while(t<=7) {
          if(segments[t]=="C") {
            lcd.write(byte(t));
            break;
          } else {
            t++;
          }
        }
      } else if(array_9[s] == "I") {
        while(t<=7) {
          if(segments[t]=="I") {
            lcd.write(byte(t));
            break;                
          } else {
            t++;
          }
        }
      } else if(array_9[s] == "K") {
        while(t<=7) {
          if(segments[t]=="K") {
            lcd.write(byte(t));
            if((digitround==3) && (s==3)) {             
              createNumber_6();
            } else if(s==3) {
              createNumber_4();
            }
            break;
          } else {
            t++;
          }
        }
      } else if(array_9[s] == "Z") {        
         lcd.print(" ");
      }
    }
    break;  
  } //switch close
  
}
11

Here part 10:

void createNumber_6() {
  Serial.println();
  Serial.println("----------------------------------------------");
  Serial.println();
  speednr++;
  if(speednr == 208) {
    speednr = 0;
  };
  Serial.print("-> Next Speednr: ");Serial.println(speednr);   
  scheduler1.schedule(createNumber_0,1000);
}
12

Surely you would be better off using LEDs for this?

13

Do you have any pictures of how the numbers should look? Check out this thread for a nice and large font: http://forum.arduino.cc/index.php/topic,44427.0.html

14

I have done soimething similar but I think my code is a bit more compact. See the link below for my repository if you are interested.

15

I did a quad size font by cheating a bit on the needed glyphs to prevent redefining them:
http://forum.arduino.cc/index.php?topic=150227.msg1128016#msg1128016

16

Thanks to all of you for your replies!

@semicolo:
Nice font. It's a good alternative to what I tried. Simple and good enough for most purposes

@TheCoolest:
Don't have any pictures yet. Will try to post some as soon as I find the time.
The large characters you suggest are a little big too big for some purposes; that's the main problem. But of course, they're beautiful and easy to use.

@marco_c:
Thanks for your code link. I'll check it out!