Requires one element in initializer?????

Trying to compile some scrolling text code from
http://www.stefanomanni.it/arduino/2009/03/27/visualize-letters-symbols-and-numbers-no-scroll-with-a-5x7-led-matrix/

Trouble is i keep getting this error message:

/Applications/Arduino.app/Contents/Resources/Java/hardware/libraries/Pattern/Pattern.h:63: error: scalar object 'PATTERN_A' requires one element in initializer

As per the code, I have put Pattern.h in my libraries folder.

Here is the full code

/* 29 mar 09 */
/* Text scrolling with a 5x7 led matrix.
/* ATTENTION: Copy Pattern.h file in ./hardware/libraries/Pattern/ directory */

#include <avr/pgmspace.h>
#include <Pattern.h>
#define DELAY 100

int dataIn = 2;
int load = 4;
int clock = 3;

int matrix[7][5]={{0,0,0,0,0},{0,0,0,0,0},{0,0,0,0,0},{0,0,0,0,0},{0,0,0,0,0},{0,0,0,0,0},{0,0,0,0,0},};

int e = 0;     // just a varialble

// define max7219 registers
byte max7219_reg_noop        = 0x00;
byte max7219_reg_digit0      = 0x01;
byte max7219_reg_digit1      = 0x02;
byte max7219_reg_digit2      = 0x03;
byte max7219_reg_digit3      = 0x04;
byte max7219_reg_digit4      = 0x05;
byte max7219_reg_digit5      = 0x06;
byte max7219_reg_digit6      = 0x07;
byte max7219_reg_digit7      = 0x08;
byte max7219_reg_decodeMode  = 0x09;
byte max7219_reg_intensity   = 0x0a;
byte max7219_reg_scanLimit   = 0x0b;
byte max7219_reg_shutdown    = 0x0c;
byte max7219_reg_displayTest = 0x0f;

void putByte(byte data) {
  byte i = 8;
  byte mask;
  while(i > 0) {
    mask = 0x01 << (i - 1);      // get bitmask
    digitalWrite( clock, LOW);   // tick
    if (data & mask){            // choose bit
      digitalWrite(dataIn, HIGH);// send 1
    }else{
      digitalWrite(dataIn, LOW); // send 0
    }
    digitalWrite(clock, HIGH);   // tock
    --i;                         // move to lesser bit
  }
}


void sendToMax( byte reg, byte value) {    
  digitalWrite(load, LOW);       // begin     
  putByte(reg);                  // specify register
  putByte(value);
  digitalWrite(load, LOW);       // and load da shit
  digitalWrite(load,HIGH); 
}


void setup () {
  //wired up to max7219
  pinMode(dataIn, OUTPUT);
  pinMode(clock,  OUTPUT);
  pinMode(load,   OUTPUT);
  
  //initiation of the max 7219
  sendToMax(max7219_reg_decodeMode, 0x00);  // not using  digits
  sendToMax(max7219_reg_scanLimit, 0x06); //scan rows 1 2 3 4 5 6 7 
  sendToMax(max7219_reg_shutdown, 0x01);    // not in shutdown mode
  sendToMax(max7219_reg_displayTest, 0x00); // no display test
  sendToMax(max7219_reg_intensity, 0xf);     // range: 0x00 to 0x0f
  
  for (e=1; e<=7; e++) {    // empty registers, turn all LEDs off
  sendToMax(e,0);
  }
}  

//I don't know why pow function doesn't work correctly.
//So i prefer to write my personal version of this.
int power(int base, int ex){
int i=1;
int tot=1;
if(i==0) return(1);
else{
      while(i<=ex){
      tot=tot*base;
      i++;
      }
      return(tot);
}
}

void lightOn(){
int i,j,k;

   //light on matrix
     for(i=0;i<7;i++){
     k=0;
     for(j=0;j<5;j++){
    
     if(matrix[i][j]==1) k=k+power(2,j); 
     }
     sendToMax(i+1,k);
     }
}


void scrollChar(const int pattern[7][5]){

    int i,j,k=0;

while(k<5)    //column of pattern
{
    //shift rigidly columns from right to left
    for(j=0;j<4;j++){  //column
      for(i=0;i<7;i++){  //row
      matrix[i][j]= matrix[i][j+1];
    }
    }
    
    //queue k-th column of pattern
    for(i=0;i<7;i++){  //row
       matrix[i][4]=pgm_read_byte(&((pattern)[i][k]));     
    }
    
    lightOn();
    delay(DELAY);    
    k++;   
}//end while

insertSpace();
}


//insert a space (two column filled with zeros) beetween two chars
void insertSpace(){
 int i,j,k=0;

while(k<2)    //queue two column of zero
{
    //shift rigidly columns from right to left
    for(j=0;j<4;j++){  //column
      for(i=0;i<7;i++){  //row
      matrix[i][j]= matrix[i][j+1];
    }
    }
    
    //queue two column filled with zeros
    for(i=0;i<7;i++){  //row
       matrix[i][4]=0;     
    }
    
    lightOn();
    delay(DELAY);    
    k++;   
}//end while
}


void scrollString(char * s){
int i=0;
   while (s[i])
  {  
    //symbols and letters
    if(s[i]==' ')
      scrollChar(PATTERN_BLANK);
    if(s[i]=='A')
      scrollChar(PATTERN_A);
    if(s[i]=='B')
      scrollChar(PATTERN_B);
    if(s[i]=='C')
      scrollChar(PATTERN_C);
    if(s[i]=='D')
      scrollChar(PATTERN_D);
    if(s[i]=='E')
      scrollChar(PATTERN_E);
    if(s[i]=='F')
      scrollChar(PATTERN_F);
    if(s[i]=='G')
      scrollChar(PATTERN_G);
    if(s[i]=='H')
      scrollChar(PATTERN_H);
    if(s[i]=='I')
      scrollChar(PATTERN_I);
    if(s[i]=='J')
      scrollChar(PATTERN_J);
    if(s[i]=='K')
      scrollChar(PATTERN_K);
    if(s[i]=='L')
      scrollChar(PATTERN_L);
    if(s[i]=='M')
      scrollChar(PATTERN_M);
    if(s[i]=='N')
      scrollChar(PATTERN_N);
    if(s[i]=='O')
      scrollChar(PATTERN_O);
    if(s[i]=='P')
      scrollChar(PATTERN_P);
    if(s[i]=='Q')
      scrollChar(PATTERN_Q);
    if(s[i]=='R')
      scrollChar(PATTERN_R);
    if(s[i]=='S')
      scrollChar(PATTERN_S);
    if(s[i]=='T')
      scrollChar(PATTERN_T);
    if(s[i]=='U')
      scrollChar(PATTERN_U);
    if(s[i]=='V')
      scrollChar(PATTERN_V);
    if(s[i]=='W')
      scrollChar(PATTERN_W);
    if(s[i]=='X')
      scrollChar(PATTERN_X);
    if(s[i]=='Y')
      scrollChar(PATTERN_Y);
    if(s[i]=='Z')
      scrollChar(PATTERN_Z);

    //numbers
    if(s[i]=='1')
      scrollChar(PATTERN_1);
    if(s[i]=='2')
      scrollChar(PATTERN_2);
    if(s[i]=='3')
      scrollChar(PATTERN_3);
    if(s[i]=='4')
      scrollChar(PATTERN_4);
    if(s[i]=='5')
      scrollChar(PATTERN_5);
    if(s[i]=='6')
      scrollChar(PATTERN_6);
    if(s[i]=='7')
      scrollChar(PATTERN_7);
    if(s[i]=='8')
      scrollChar(PATTERN_8);
    if(s[i]=='9')
      scrollChar(PATTERN_9);
    if(s[i]=='0')
      scrollChar(PATTERN_0);

 i++;
}//end while
}


void loop () {
    scrollString("ABCDEFGHIJKLMNOPQRSTUVWXYZ 0123456789");   //use capital letters         
  }

If the problem is with PATTERN_A, how is it declared?
I don't see PATTERN_A anywhere, apart from where you reference it in "scrollString".
The error message implies that PATTERN_A is described as a simple data type (scalar), not an array.
did you miss out the "[]" brackets in the declaration?

Hi AWOL,

I can only see it in scrollString too.

I just downoaded the code from the website above, and have not adjusted it at all.

could it be a error with the Pattern.h code

/* Source: http://ericlathrop.com/electronics/LedGrid.php */

/*SYMBOLS*/
const int PATTERN_BLANK [7][5] PROGMEM = {
  { 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0 },
};

const int PATTERN_SOLID [7][5] PROGMEM = {
  { 1, 1, 1, 1, 1 },
  { 1, 1, 1, 1, 1 },
  { 1, 1, 1, 1, 1 },
  { 1, 1, 1, 1, 1 },
  { 1, 1, 1, 1, 1 },
  { 1, 1, 1, 1, 1 },
  { 1, 1, 1, 1, 1 },
};

const int PATTERN_DARWINIAN [7][5] PROGMEM = {
  { 0, 0, 1, 0, 0 },
  { 1, 1, 1, 1, 1 },
  { 0, 0, 1, 0, 0 },
  { 0, 0, 1, 0, 0 },
  { 0, 1, 1, 1, 0 },
  { 0, 1, 0, 1, 0 },
  { 0, 1, 0, 1, 0 },
};

const int PATTERN_HEART [7][5] PROGMEM = {
  { 0, 0, 0, 0, 0 },
  { 0, 1, 0, 1, 0 },
  { 1, 1, 1, 1, 1 },
  { 1, 1, 1, 1, 1 },
  { 0, 1, 1, 1, 0 },
  { 0, 1, 1, 1, 0 },
  { 0, 0, 1, 0, 0 },
};

const int PATTERN_EXCLAMATION [7][5] PROGMEM = {
  { 1, 1, 0, 1, 1 },
  { 1, 1, 0, 1, 1 },
  { 1, 1, 0, 1, 1 },
  { 1, 1, 0, 1, 1 },
  { 0, 0, 0, 0, 0 },
  { 1, 1, 0, 1, 1 },
  { 1, 1, 0, 1, 1 },
};

/*LETTERS*/
const int * PATTERN_A PROGMEM = {
  { 0, 0, 1, 0, 0 },
  { 0, 1, 0, 1, 0 },
  { 1, 0, 0, 0, 1 },
  { 1, 0, 0, 0, 1 },
  { 1, 1, 1, 1, 1 },
  { 1, 0, 0, 0, 1 },
  { 1, 0, 0, 0, 1 },
};

const int PATTERN_B [7][5] PROGMEM = {
  { 1, 1, 1, 1, 0 },
  { 1, 0, 0, 0, 1 },
  { 1, 0, 0, 0, 1 },
  { 1, 1, 1, 1, 0 },
  { 1, 0, 0, 0, 1 },
  { 1, 0, 0, 0, 1 },
  { 1, 1, 1, 1, 0 },
};

const int PATTERN_C [7][5] PROGMEM = {
  { 0, 1, 1, 1, 0 },
  { 1, 0, 0, 0, 1 },
  { 1, 0, 0, 0, 0 },
  { 1, 0, 0, 0, 0 },
  { 1, 0, 0, 0, 0 },
  { 1, 0, 0, 0, 1 },
  { 0, 1, 1, 1, 0 },
};

const int PATTERN_D [7][5] PROGMEM = {
  { 1, 1, 1, 0, 0 },
  { 1, 0, 0, 1, 0 },
  { 1, 0, 0, 0, 1 },
  { 1, 0, 0, 0, 1 },
  { 1, 0, 0, 0, 1 },
  { 1, 0, 0, 1, 0 },
  { 1, 1, 1, 0, 0 },
};

const int PATTERN_E [7][5] PROGMEM = {
  { 1, 1, 1, 1, 1 },
  { 1, 0, 0, 0, 0 },
  { 1, 0, 0, 0, 0 },
  { 1, 1, 1, 0, 0 },
  { 1, 0, 0, 0, 0 },
  { 1, 0, 0, 0, 0 },
  { 1, 1, 1, 1, 1 }
};

const int PATTERN_F [7][5] PROGMEM = {
  { 1, 1, 1, 1, 1 },
  { 1, 0, 0, 0, 0 },
  { 1, 0, 0, 0, 0 },
  { 1, 1, 1, 0, 0 },
  { 1, 0, 0, 0, 0 },
  { 1, 0, 0, 0, 0 },
  { 1, 0, 0, 0, 0 },
};

const int PATTERN_G [7][5] PROGMEM = {
  { 0, 1, 1, 1, 1 },
  { 1, 0, 0, 0, 0 },
  { 1, 0, 0, 0, 0 },
  { 1, 0, 0, 1, 1 },
  { 1, 0, 0, 0, 1 },
  { 1, 0, 0, 0, 1 },
  { 0, 1, 1, 1, 1 },
};


const int PATTERN_H [7][5]  PROGMEM = {
  { 1, 0, 0, 0, 1 },
  { 1, 0, 0, 0, 1 },
  { 1, 0, 0, 0, 1 },
  { 1, 1, 1, 1, 1 },
  { 1, 0, 0, 0, 1 },
  { 1, 0, 0, 0, 1 },
  { 1, 0, 0, 0, 1 }
};

const int PATTERN_I [7][5]  PROGMEM = {
  { 1, 1, 1, 1, 1 },
  { 0, 0, 1, 0, 0 },
  { 0, 0, 1, 0, 0 },
  { 0, 0, 1, 0, 0 },
  { 0, 0, 1, 0, 0 },
  { 0, 0, 1, 0, 0 },
  { 1, 1, 1, 1, 1 }
};

const int PATTERN_J [7][5]  PROGMEM = {
  { 1, 1, 1, 1, 1 },
  { 0, 0, 0, 1, 0 },
  { 0, 0, 0, 1, 0 },
  { 0, 0, 0, 1, 0 },
  { 0, 0, 0, 1, 0 },
  { 1, 0, 0, 1, 0 },
  { 0, 1, 1, 0, 0 },
};

const int PATTERN_K [7][5]  PROGMEM = {
  { 1, 0, 0, 0, 1 },
  { 1, 0, 0, 1, 0 },
  { 1, 0, 1, 0, 0 },
  { 1, 1, 0, 0, 0 },
  { 1, 0, 1, 0, 0 },
  { 1, 0, 0, 1, 0 },
  { 1, 0, 0, 0, 1 },
};

const int PATTERN_L [7][5]  PROGMEM = {
  { 1, 0, 0, 0, 0 },
  { 1, 0, 0, 0, 0 },
  { 1, 0, 0, 0, 0 },
  { 1, 0, 0, 0, 0 },
  { 1, 0, 0, 0, 0 },
  { 1, 0, 0, 0, 0 },
  { 1, 1, 1, 1, 1 }
};

const int PATTERN_M [7][5]  PROGMEM = {
  { 1, 0, 0, 0, 1 },
  { 1, 1, 0, 1, 1 },
  { 1, 0, 1, 0, 1 },
  { 1, 0, 0, 0, 1 },
  { 1, 0, 0, 0, 1 },
  { 1, 0, 0, 0, 1 },
  { 1, 0, 0, 0, 1 },
};

const int PATTERN_N [7][5]  PROGMEM = {
  { 1, 0, 0, 0, 1 },
  { 1, 1, 0, 0, 1 },
  { 1, 0, 1, 0, 1 },
  { 1, 0, 1, 0, 1 },
  { 1, 0, 1, 0, 1 },
  { 1, 0, 0, 1, 1 },
  { 1, 0, 0, 0, 1 },
};

const int PATTERN_O [7][5]  PROGMEM = {
  { 0, 1, 1, 1, 0 },
  { 1, 0, 0, 0, 1 },
  { 1, 0, 0, 0, 1 },
  { 1, 0, 0, 0, 1 },
  { 1, 0, 0, 0, 1 },
  { 1, 0, 0, 0, 1 },
  { 0, 1, 1, 1, 0 }
};

const int PATTERN_P [7][5]  PROGMEM = {
  { 1, 1, 1, 1, 0 },
  { 1, 0, 0, 0, 1 },
  { 1, 0, 0, 0, 1 },
  { 1, 1, 1, 1, 0 },
  { 1, 0, 0, 0, 0 },
  { 1, 0, 0, 0, 0 },
  { 1, 0, 0, 0, 0 },
};

const int PATTERN_Q [7][5]  PROGMEM = {
  { 0, 1, 1, 1, 0 },
  { 1, 0, 0, 0, 1 },
  { 1, 0, 0, 0, 1 },
  { 1, 0, 0, 0, 1 },
  { 1, 0, 0, 0, 1 },
  { 0, 1, 1, 1, 0 },
  { 0, 0, 0, 1, 1 },
};

const int PATTERN_R [7][5]  PROGMEM = {
  { 1, 1, 1, 1, 0 },
  { 1, 0, 0, 0, 1 },
  { 1, 0, 0, 0, 1 },
  { 1, 1, 1, 1, 0 },
  { 1, 0, 0, 0, 1 },
  { 1, 0, 0, 0, 1 },
  { 1, 0, 0, 0, 1 },
};

const int PATTERN_S [7][5]  PROGMEM = {
  { 0, 1, 1, 1, 0 },
  { 1, 0, 0, 0, 1 },
  { 1, 0, 0, 0, 0 },
  { 0, 1, 1, 1, 0 },
  { 0, 0, 0, 0, 1 },
  { 1, 0, 0, 0, 1 },
  { 0, 1, 1, 1, 0 },
};

const int PATTERN_T [7][5]  PROGMEM = {
  { 1, 1, 1, 1, 1 },
  { 0, 0, 1, 0, 0 },
  { 0, 0, 1, 0, 0 },
  { 0, 0, 1, 0, 0 },
  { 0, 0, 1, 0, 0 },
  { 0, 0, 1, 0, 0 },
  { 0, 0, 1, 0, 0 },
};

const int PATTERN_U [7][5]  PROGMEM = {
  { 1, 0, 0, 0, 1 },
  { 1, 0, 0, 0, 1 },
  { 1, 0, 0, 0, 1 },
  { 1, 0, 0, 0, 1 },
  { 1, 0, 0, 0, 1 },
  { 1, 0, 0, 0, 1 },
  { 0, 1, 1, 1, 0 }
};

const int PATTERN_V [7][5]  PROGMEM = {
  { 1, 0, 0, 0, 1 },
  { 1, 0, 0, 0, 1 },
  { 1, 0, 0, 0, 1 },
  { 1, 0, 0, 0, 1 },
  { 0, 1, 0, 1, 0 },
  { 0, 1, 0, 1, 0 },
  { 0, 0, 1, 0, 0 }
};

const int PATTERN_W [7][5]  PROGMEM = {
  { 1, 0, 0, 0, 1 },
  { 1, 0, 0, 0, 1 },
  { 1, 0, 0, 0, 1 },
  { 1, 0, 1, 0, 1 },
  { 1, 0, 1, 0, 1 },
  { 1, 0, 1, 0, 1 },
  { 0, 1, 0, 1, 0 },
};

const int PATTERN_X [7][5]  PROGMEM = {
  { 1, 0, 0, 0, 1 },
  { 1, 0, 0, 0, 1 },
  { 0, 1, 0, 1, 0 },
  { 0, 0, 1, 0, 0 },
  { 0, 1, 0, 1, 0 },
  { 1, 0, 0, 0, 1 },
  { 1, 0, 0, 0, 1 }
};

const int PATTERN_Y [7][5]  PROGMEM = {
  { 1, 0, 0, 0, 1 },
  { 1, 0, 0, 0, 1 },
  { 0, 1, 0, 1, 0 },
  { 0, 0, 1, 0, 0 },
  { 0, 0, 1, 0, 0 },
  { 0, 0, 1, 0, 0 },
  { 0, 0, 1, 0, 0 }
};

const int PATTERN_Z [7][5]  PROGMEM = {
  { 1, 1, 1, 1, 1 },
  { 0, 0, 0, 0, 1 },
  { 0, 0, 0, 1, 0 },
  { 0, 0, 1, 0, 0 },
  { 0, 1, 0, 0, 0 },
  { 1, 0, 0, 0, 0 },
  { 1, 1, 1, 1, 1 }
};

const int PATTERN_1 [7][5]  PROGMEM = {
  { 0, 0, 1, 0, 0 },
  { 1, 1, 1, 0, 0 },
  { 0, 0, 1, 0, 0 },
  { 0, 0, 1, 0, 0 },
  { 0, 0, 1, 0, 0 },
  { 0, 0, 1, 0, 0 },
  { 1, 1, 1, 1, 1 },
};

const int PATTERN_2 [7][5]  PROGMEM = {
  { 0, 1, 1, 1, 0 },
  { 1, 0, 0, 0, 1 },
  { 0, 0, 0, 0, 1 },
  { 0, 0, 1, 1, 0 },
  { 0, 1, 0, 0, 0 },
  { 1, 0, 0, 0, 0 },
  { 1, 1, 1, 1, 1 },
};

const int PATTERN_3 [7][5]  PROGMEM = {
  { 0, 1, 1, 1, 0 },
  { 1, 0, 0, 0, 1 },
  { 0, 0, 0, 0, 1 },
  { 0, 0, 1, 1, 0 },
  { 0, 0, 0, 0, 1 },
  { 1, 0, 0, 0, 1 },
  { 0, 1, 1, 1, 0 },
};

const int PATTERN_4 [7][5]  PROGMEM = {
  { 0, 0, 0, 1, 0 },
  { 0, 0, 1, 1, 0 },
  { 0, 1, 0, 1, 0 },
  { 1, 0, 0, 1, 0 },
  { 1, 1, 1, 1, 1 },
  { 0, 0, 0, 1, 0 },
  { 0, 0, 0, 1, 0 },
};

const int PATTERN_5 [7][5]  PROGMEM = {
  { 1, 1, 1, 1, 1 },
  { 1, 0, 0, 0, 0 },
  { 1, 0, 0, 0, 0 },
  { 1, 1, 1, 1, 0 },
  { 0, 0, 0, 0, 1 },
  { 1, 0, 0, 0, 1 },
  { 0, 1, 1, 1, 0 },
};

const int PATTERN_6 [7][5]  PROGMEM = {
  { 0, 1, 1, 1, 0 },
  { 1, 0, 0, 0, 1 },
  { 1, 0, 0, 0, 0 },
  { 1, 1, 1, 1, 0 },
  { 1, 0, 0, 0, 1 },
  { 1, 0, 0, 0, 1 },
  { 0, 1, 1, 1, 0 },
};

const int PATTERN_7 [7][5]  PROGMEM = {
  { 1, 1, 1, 1, 1 },
  { 0, 0, 0, 0, 1 },
  { 0, 0, 0, 1, 0 },
  { 0, 0, 1, 0, 0 },
  { 0, 0, 1, 0, 0 },
  { 0, 0, 1, 0, 0 },
  { 0, 0, 1, 0, 0 },
};

const int PATTERN_8 [7][5]  PROGMEM = {
  { 0, 1, 1, 1, 0 },
  { 1, 0, 0, 0, 1 },
  { 1, 0, 0, 0, 1 },
  { 0, 1, 1, 1, 0 },
  { 1, 0, 0, 0, 1 },
  { 1, 0, 0, 0, 1 },
  { 0, 1, 1, 1, 0 },
};

const int PATTERN_9 [7][5]  PROGMEM = {
  { 0, 1, 1, 1, 0 },
  { 1, 0, 0, 0, 1 },
  { 1, 0, 0, 0, 1 },
  { 0, 1, 1, 1, 1 },
  { 0, 0, 0, 0, 1 },
  { 1, 0, 0, 0, 1 },
  { 0, 1, 1, 1, 0 },
};

const int PATTERN_0 [7][5]  PROGMEM = {
  { 0, 1, 1, 1, 0 },
  { 1, 0, 0, 0, 1 },
  { 1, 0, 1, 0, 1 },
  { 1, 0, 1, 0, 1 },
  { 1, 0, 1, 0, 1 },
  { 1, 0, 0, 0, 1 },
  { 0, 1, 1, 1, 0 },
};

Much of programming is pattern recognition (no pun intended!). If you can recognize patterns that repeat, you can code repetitive things into loops and the like. Repetitive patterns are also important in data definitions.

n00b, since the error message is related to PATTERN_A, see if you can spot something different about its definition in Pattern.h. When you find what is different, try changing it to make it look similar to all the others (PATTERN_B, PATTERN_C, etc), then try to recompile.

Let us know what you find and if your change to the definition of PATTERN_A in Pattern.h solved the problem.

Nicely put, TBAr.

@ nOOb - You might also consider reducing your memory requirements by at least 50% - using an "int" to store a bit is very wasteful.

ooooooooh I see PATTERN_A has a rouge "*" symbol, and the "[7][5]" have been negated!

Have taken the * out and put the 7x5 LED range in, and the code complies :slight_smile: (donte have my Arduino here so will check it later tonight) thank you!

AWOL - What are the alternatives to using an "int" to store a bit. (sure now you have read enough of my posts to know my knowledge of the code side of thing is a little rubbish)

nOOb - the clue is in the "50%" :wink:

It probably isn't too much of a problem for you right now, but if your program grows, or you want to port to a processor with less program memory, you may find yourself running out.

Each character is currently using 7 x 5 x 2 = 70 bytes to store just 35 bits of information.