need help on scrolling text (led display)

hi i am working on a (static) display (8x72) .

i am using 72 shift registers and they are on vertical. for example this is how they are conected: http://img717.imageshack.us/f/panelm.jpg/

now on code: //here are (some) patterns (on my language).just to know they are on vertical too.

define char_A_gr { B11111111,B11000000,B10111011,B10111011,B10111011,B10111011,B11000000,B11111111 }//0

define char_B_gr { B11111111,B10000000,B10110110,B10110110,B10110110,B10110110,B11001001,B11111111 }//1

define char_Gama_gr { B11111111,B10000000,B10111111,B10111111,B10111111,B10111111,B10111111,B11111111 }//2

define char_Delta_gr { B11110000,B11101110,B11011110,B10111110,B11011110,B11101110,B11110000,B11111111 }//3

define char_E_gr { B11111111,B10000000,B10110110,B10110110,B10110110,B10110110,B10111110,B11111111 }//4

define char_Z_gr { B11111111,B10111100,B10111010,B10110110,B10101110,B10011110,B10111110,B11111111 }//5

define char_H_gr { B11111111,B10000000,B11110111,B11110111,B11110111,B11110111,B10000000,B11111111 }//6

//here is the index of patterns byte small_index[7][8]= {char_A_gr,char_B_gr,char_Gama_gr,char_Delta_gr,char_E_gr,char_Z_gr,char_H_gr};

//for example if want to display pattern char_A_gr, becouse they are on vertical we need to shiftout these: // index[0][0],then index[0][1],then index[0][2],index[0][3],then index[0][4],index[0][5],then index[0][6],index[0][7]

how can i display scrolling text for example the first 3 chars? (A,B,Gama)?

becouse the led display is big lets suppose that display is small (8x16) so to scroll the patterns we need to shiftout this:(on index]: 0,0 0,1 0,2 0,3 0,4 0,5 0,6 0,7 (pattern A) 1,0 1,1 1,2 1,3 1,4 1,5 1,6 1,7 (pattern B)

delay(50); (some delay between frame)

then we need to scroll one bit: 0,1 0,2 0,3 0,4 0,5 0,6 0,7 1,0 (pattern A minus first bit + first bit from pattern B) 1,1 1,2 1,3 1,4 1,5 1,6 1,7 2,1 (7 bits from pattern B + first bit from pattern Gama)

and so on...

i was trying to make it with some loops with no success.

so i need a syntax that can shiftout these:

0,0 0,1 0,2 0,3 0,4 0,5 0,6 0,7 1,0 1,1 1,2 1,3 1,4 1,5 1,6 1,7 then 0,1 0,2 0,3 0,4 0,5 0,6 0,7 1,0 1,1 1,2 1,3 1,4 1,5 1,6 1,7 2,0 then 0,2 0,3 0,4 0,5 0,6 0,7 1,0 1,1 1,2 1,3 1,4 1,5 1,6 1,7 2,0 2,1 and so on...

i succed to do this with storing all patterns to a big variable array but it needs 200 bytes from ram....really bad code

Cool! If you shift just one byte in, I suppose it would end up in the rightmost pixel-column and the rest of the display would automatically scroll left one pixel? That would make scrolling very easy (as long as you always scroll to the left, otherwise you need to send all 72 bytes)

byte msg[] = {0,1,2};  // A,B,Gama
for (byte i=0; i<sizeof(msg); i++) {
    for(byte col=0; col<8; col++) {
        shiftout(small_index[i][col]);
    }
}

are you sure this is the right code?i think not,

Like this then.

byte msg[] = {0,1,2};  // A,B,Gama
for (byte i=0; i<sizeof(msg); i++) {
    for (byte col=0; col<8; col++) {
        shiftout(small_index[[glow]msg[[/glow]i[glow]][/glow]][col]);
    }
}

you will of course need to add delays and call the proper shiftout function.

This will just shiftout this 0,0 0,1 0,2 0,3 0,4 0,5 0,6 0,7 1,0 1,1 1,2 1,3 1,4 1,5 1,6 1,7 2,0 2,1 2,2 2,3 2,4 2,5 2,6 2,7 3,0 3,1 3,2 3,3 3,4 3,5 3,6 3,7 and so on

i need this 0,0 0,1 0,2 0,3 0,4 0,5 0,6 0,7 1,0 1,1 1,2 1,3 1,4 1,5 1,6 1,7 then 0,1 0,2 0,3 0,4 0,5 0,6 0,7 1,0 1,1 1,2 1,3 1,4 1,5 1,6 1,7 2,0 then 0,2 0,3 0,4 0,5 0,6 0,7 1,0 1,1 1,2 1,3 1,4 1,5 1,6 1,7 2,0 2,1

it needs good mathematics. please someone help

So you absolutely want to send data to all the shift registers every time something is to be updated?
Well, try a screen handling class:

class Screen {
  public:
    const word WIDTH=72;
    byte data[WIDTH+8];
    void clear {
        for (byte i=0; i<sizeof(data); i++)  data[i] = 0;
    }
    void refresh() {
        for (byte i=0; i<WIDTH; i++) {
            shiftout(data[i]);  // change to appropriate function
        }
    }
    void scroll_left() {
        for (byte i=0; i<sizeof(data)-1; ++i) {
            data[i] = data[i+1];
        }
    }
    void draw_char(byte charnum, byte x) {
        for (byte i=0; i<8; i++) {
            data[x+i] = small_index[charnum][i];
        }
    }
    Screen() { clear(); }
    void show(byte *msg, int len) {
        do {
            for (int i=0; i<len; i++) {
                draw_char(msg[i], WIDTH);
                for (byte j=0; j<8; j++) {
                    refresh();
                    scroll_left();
                    delay(50);
                }
            }
        } while(true);
    }
} screen;


byte msg[] = {0,1,2};  // A,B,Gama

screen.show(msg, sizeof(msg));

i dont undestand...damn

The idea is to store everything the shift registers hold in a memory buffer (data). It has 8 extra columns so we can print a new character just outside the display and then scroll it in. Using classes, it comes natural to write several small functions that does things, (which should be obvious from their names). The method "show" will then use the other methods to repeatedly draw a new character and scroll it in one pixel at a time.