arduino direct 8x8 led matrix

#include <avr/pgmspace.h>
#include <FrequencyTimer2.h>

#define SPACE { \
        0b00000000, \
        0b00000000, \
        0b00000000, \
        0b00000000, \
        0b00000000, \
        0b00000000, \
        0b00000000  \
}

#define ZERO { \
        0b00000000, \
        0b01111110, \
        0b01000010, \
        0b01000110, \
        0b01101010, \
        0b01110010, \
        0b01100010, \
        0b01111110  \
}

#define ONE { \
        0b00000000, \
        0b00111000, \
        0b00001000, \
        0b00001000, \
        0b00011000, \
        0b00011000, \
        0b00011000, \
        0b00111100  \
}

#define TWO { \
        0b00000000, \
        0b01111110, \
        0b01000010, \
        0b00000010, \
        0b01111110, \
        0b01100000, \
        0b01100000, \
        0b01111110  \
}

#define THREE { \
        0b00000000, \
        0b00111110, \
        0b00000010, \
        0b00000010, \
        0b00011110, \
        0b00000110, \
        0b00000110, \
        0b01111110  \
}

#define FOUR { \
        0b00000000, \
        0b01000000, \
        0b01000000, \
        0b01000100, \
        0b01000100, \
        0b01111110, \
        0b00001100, \
        0b00001100  \
}

#define FIVE { \
        0b00000000, \
        0b00111110, \
        0b00100000, \
        0b00100000, \
        0b00111110, \
        0b00000110, \
        0b01000110, \
        0b01111110  \
}

#define SIX { \
        0b00000000, \
        0b01111110, \
        0b01000000, \
        0b01000000, \
        0b01111110, \
        0b01100010, \
        0b01100010, \
        0b01111110  \
}

#define SEVEN { \
        0b00000000, \
        0b01111110, \
        0b01000010, \
        0b00000100, \
        0b00001000, \
        0b00011000, \
        0b00011000, \
        0b00011000  \
}

#define EIGHT { \
        0b00000000, \
        0b00111100, \
        0b00100100, \
        0b00100100, \
        0b01111110, \
        0b01100010, \
        0b01100010, \
        0b01111110  \
}

#define NINE { \
        0b00000000, \
        0b01111110, \
        0b01000010, \
        0b01000010, \
        0b01111110, \
        0b00000110, \
        0b00000110, \
        0b01111110  \
}

#define A { \
        0b00000000, \
        0b00111100, \
        0b00100100, \
        0b01111110, \
        0b01100010, \
        0b01100010, \
        0b01100010, \
        0b01100010  \
}

#define B { \
        0b00000000, \
        0b01111100, \
        0b00100100, \
        0b00111100, \
        0b00110010, \
        0b00110010, \
        0b00110010, \
        0b01111110  \
}

#define C { \
        0b00000000, \
        0b01111110, \
        0b01000010, \
        0b01000000, \
        0b01100000, \
        0b01100000, \
        0b01100010, \
        0b01111110  \
}

#define D { \
        0b00000000, \
        0b01111110, \
        0b01000010, \
        0b01000010, \
        0b01100010, \
        0b01100010, \
        0b01100010, \
        0b01111110  \
}

#define E { \
        0b00000000, \
        0b01111110, \
        0b01000000, \
        0b01000000, \
        0b01111000, \
        0b01100000, \
        0b01100000, \
        0b01111110  \
}

#define F { \
        0b00000000, \
        0b01111110, \
        0b01000000, \
        0b01000000, \
        0b01111000, \
        0b01100000, \
        0b01100000, \
        0b01100000  \
}

#define G { \
        0b00000000, \
        0b01111110, \
        0b01000010, \
        0b01000000, \
        0b01101110, \
        0b01100010, \
        0b01100010, \
        0b01111110  \
}

#define H { \
        0b00000000, \
        0b01000010, \
        0b01000010, \
        0b01000010, \
        0b01111110, \
        0b01100010, \
        0b01100010, \
        0b01100010  \
}

#define I { \
        0b00000000, \
        0b00010000, \
        0b00010000, \
        0b00010000, \
        0b00011000, \
        0b00011000, \
        0b00011000, \
        0b00011000  \
}

#define J { \
        0b00000000, \
        0b00000010, \
        0b00000010, \
        0b00000010, \
        0b00000110, \
        0b00000110, \
        0b01000110, \
        0b00111110  \
}

#define K { \
        0b00000000, \
        0b01000010, \
        0b01000100, \
        0b01001000, \
        0b01111110, \
        0b01100010, \
        0b01100010, \
        0b01100010  \
}

#define L { \
        0b00000000, \
        0b01000000, \
        0b01000000, \
        0b01000000, \
        0b01100000, \
        0b01100000, \
        0b01100000, \
        0b01111110  \
}

#define M { \
        0b00000000, \
        0b01110110, \
        0b01011010, \
        0b01000010, \
        0b01100010, \
        0b01100010, \
        0b01100010, \
        0b01100010  \
}

#define N { \
        0b00000000, \
        0b01110010, \
        0b01001010, \
        0b01001010, \
        0b01101010, \
        0b01101010, \
        0b01101010, \
        0b01100110  \
}

#define O { \
        0b00000000, \
        0b01111110, \
        0b01000010, \
        0b01000010, \
        0b01100010, \
        0b01100010, \
        0b01100010, \
        0b01111110  \
}

#define P { \
        0b00000000, \
        0b01111110, \
        0b01000010, \
        0b01000010, \
        0b01111110, \
        0b01100000, \
        0b01100000, \
        0b01100000  \
}

#define Q { \
        0b00000000, \
        0b01111110, \
        0b01000010, \
        0b01000010, \
        0b01100010, \
        0b01101010, \
        0b01100100, \
        0b01111010  \
}

#define R { \
        0b00000000, \
        0b01111110, \
        0b01000010, \
        0b01000010, \
        0b01111110, \
        0b01100100, \
        0b01100010, \
        0b01100010  \
}

#define S { \
        0b00000000, \
        0b01111110, \
        0b01000010, \
        0b01000000, \
        0b01111110, \
        0b00000110, \
        0b00000110, \
        0b01111110  \
}

#define T { \
        0b00000000, \
        0b01111110, \
        0b00010000, \
        0b00010000, \
        0b00011000, \
        0b00011000, \
        0b00011000, \
        0b00011000  \
}

#define U { \
        0b00000000, \
        0b01000010, \
        0b01000010, \
        0b01000010, \
        0b01100010, \
        0b01100010, \
        0b01100010, \
        0b01111110  \
}

#define V { \
        0b00000000, \
        0b01000010, \
        0b01000010, \
        0b01000010, \
        0b00100100, \
        0b00100100, \
        0b00011000, \
        0b00011000  \
}

#define W { \
        0b00000000, \
        0b01100010, \
        0b01100010, \
        0b01100010, \
        0b01100010, \
        0b01000010, \
        0b01011010, \
        0b01100110  \
}

#define X { \
        0b00000000, \
        0b01000010, \
        0b00100100, \
        0b00011000, \
        0b01111100, \
        0b01100010, \
        0b01100010, \
        0b01100010  \
}

#define Y { \
        0b00000000, \
        0b01000010, \
        0b01000010, \
        0b01000010, \
        0b00111100, \
        0b00011000, \
        0b00011000, \
        0b00011000  \
}

#define Z { \
        0b00000000, \
        0b01111100, \
        0b00000010, \
        0b00011100, \
        0b01100000, \
        0b01100000, \
        0b01100000, \
        0b01111110  \
}

byte col = 0;
byte leds[8];

// pin[xx] on led matrix connected to nn on Arduino (-1 is dummy to make array start at pos 1)
int pins[17]= {-1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17};

// col[xx] of leds = pin yy on led matrix
int cols[8] = {pins[1], pins[2], pins[3], pins[4], pins[5], pins[6], pins[7], pins[8]};

// row[xx] of leds = pin yy on led matrix
int rows[8] = {pins[9], pins[10], pins[11], pins[12], pins[13], pins[14], pins[15], pins[16]};


byte patterns[][8] PROGMEM = {
    SPACE,ZERO,ONE,TWO,THREE,FOUR,FIVE,SIX,SEVEN,EIGHT,NINE,
    A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z
};

#define numPatterns (sizeof(patterns)/sizeof(patterns[0]))

int pattern = 0;

void setup() {
    // sets the pins as output
    for (int i = 1; i <= 16; i++) {
        pinMode(pins[i], OUTPUT);
    }

    // set up cols and rows
    for (int i = 1; i <= 8; i++) {
        digitalWrite(cols[i - 1], LOW);
    }

    for (int i = 1; i <= 8; i++) {
        digitalWrite(rows[i - 1], LOW);
    }

    clearLeds();

    // Turn off toggling of pin 11
    FrequencyTimer2::disable();
    // Set refresh rate (interrupt timeout period)
    FrequencyTimer2::setPeriod(2000);
    // Set interrupt routine to be called
    FrequencyTimer2::setOnOverflow(display);

    setPattern(pattern);
}

void loop() {
    pattern = ++pattern % numPatterns;
    slidePattern(pattern, 150);
}

void clearLeds() {
    // Clear display array
    for (int i = 0; i < 8; i++) {
            leds[i] = 0;
    }
}

void setPattern(int pattern) {
    for (int i = 0; i < 8; i++) {
            leds[i] = pgm_read_byte_near(&patterns[pattern][i]);
    }
}

void slidePattern(int pattern, int del) {
    for (int l = 0; l < 8; l++) {
        for (int i = 0; i < 8; i++) {
                byte acol = pgm_read_byte_near(&patterns[pattern][i]);
                leds[i] = (acol << l) | (acol >> (8 - l));
        }
        delay(del);
    }
}

// Interrupt routine
void display() {
    digitalWrite(cols[col], LOW);  // Turn whole previous column off
    col++;
    if (col == 8) {
        col = 0;
    }
    for (int row = 0; row < 8; row++) {
        if ((leds[col] >> row) & 0x1) {
            digitalWrite(rows[row], LOW);  // Turn on this led
        }
        else {
            digitalWrite(rows[row], HIGH); // Turn off this led
        }
    }
    digitalWrite(cols[col], HIGH); // Turn whole column on at once (for equal lighting times)
}