Controlar una matriz barriendo filas y barriendo columnas (74HC595)

 En los dos casos es la misma matriz. La he generado con el ArduinoFrameAnimator.jar y no se parece en nada. Además, genera una matriz de 64 elementos. Tal vez genere las filas y las columnas. Lo pongo aquí por si algún día estoy inspirado y consigo verlo.
código generado por ArduinoFrameAnimator.jar:
int animationFrames = 1;

int animationDelays[] = { 200 };

// Animation is designed for 16x16 pixels
uint8_t animation[][64] = {
  { 0x3, 0x0, 0x0, 0xc0, 0xc, 0x0, 0x0, 0xc0, 0x30, 0x0, 0x0, 0xc0, 0xc0, 0x0, 0x0, 0xc0, 0x0, 0x3, 0x0, 0xc0, 0x0, 0xc, 0x0, 0xc0, 0x0, 0x30, 0x0, 0xc0, 0x0, 0xc0, 0x0, 0xc0, 0x0, 0x0, 0x3, 0xc0, 0x0, 0x0, 0xc, 0xc0, 0x0, 0x0, 0x30, 0xc0, 0x0, 0x0, 0xc0, 0xc0, 0x0, 0x0, 0x0, 0xc3, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x0, 0x0, 0xc0 }
};

CONCLUSION:

Sale mejor barriendo filas porque el led que corresponda a la columna que se enciende lo hará con la máxima intensidad.
Eso tiene la desventaja de que es más dificil escribir la matriz. En este caso la he escrito en positivo y después la he invertido mediante una operación OR EXclusivo a cada uno de los elementos de la matriz.
Pongo primero el código de barrido de columnas por ser más intuitivo. Además, así se puede apreciar el cambio de luminosidad de la última columna.
Para hacer un barrido rápido y continuo basta con comentar la línea delay.

Barriendo columnas

Se muestra el contenido de la matriz que se muestra haciendo un barrido por columnas.

código:
//salidas que se van a utilizar
byte latchPin = 8;
byte clockPin = 12;
byte dataPin = 11;
//array en el que se va a contener toda la informacion de filas
byte dato[32] = {0, 0, 0, 0, 0, 0, 0, 0, 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0xFF, 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01, 0, 0, 0, 0, 0, 0, 0, 0xff };//informacion de las filas

/*       --
  X00000000000000X
  0X0000000000000X
  00X000000000000X
  000X00000000000X
  0000X0000000000X
  00000X000000000X
  000000X00000000X
- 0000000X0000000X-
- 00000000X000000X-
  000000000X00000X
  0000000000X0000X
  00000000000X000X
  000000000000X00X
  0000000000000X0X
  00000000000000XX
  000000000000000X
         --
*/
byte i;
byte co_L, co_H;

void setup() {
  pinMode(latchPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
}

void loop() {
  muestra (dato);
}

void muestra (byte *matriz) {
  co_L=0xFE;
  co_H=0xFF;
  for (i=0;i<16;i++) {
    digitalWrite(latchPin, 0);
    shiftOut(dataPin, clockPin, MSBFIRST, matriz[i+16]);
    shiftOut(dataPin, clockPin, MSBFIRST, matriz[i]);
    shiftOut(dataPin, clockPin, MSBFIRST, co_H);
    shiftOut(dataPin, clockPin, MSBFIRST, co_L);
    digitalWrite(latchPin, 1);
    if (i<8){
      co_L<<=1;
      bitSet(co_L,0);
    }
    else{
      co_H<<=1;
      bitSet(co_H,0);
    }
    if (i==7){
      co_L=0xFF;
      co_H=0xFE;
    }
    delay(250);
  }
}

Barriendo filas

Mismo programa, misma matriz barriendo filas en vez de columnas. Como la columna de la derecha brillaba menos, deduzco que las resistencias de control están en los cátodos. Barriendo por filas se hace que todas brillen igual. Sigo sin ver como se pasa del arduinoframeanimator.jar a una matriz similar a estas que me salen.

código:
//salidas que se van a utilizar
byte latchPin = 8;
byte clockPin = 12;
byte dataPin = 11;
//array en el que se va a contener toda la informacin de filas
byte dato[32] = {
  0x80, 1, 0x40, 1, 0x20, 1, 0x10, 1, 0x08, 1, 0x04, 1, 0x02, 1, 1, 1, 0, 0x81, 0, 0x41, 0, 0x21, 0, 0x11, 0, 0x09, 0, 0x05, 0, 0x3, 0, 1};//informacion de las columnas

/*       --
 X00000000000000X
 0X0000000000000X
 00X000000000000X
 000X00000000000X
 0000X0000000000X
 00000X000000000X
 000000X00000000X
 - 0000000X0000000X-
 - 00000000X000000X-
 000000000X00000X
 0000000000X0000X
 00000000000X000X
 000000000000X00X
 0000000000000X0X
 00000000000000XX
 000000000000000X
 --
 */
byte i;
byte fi_L, fi_H;

void setup() {
  pinMode(latchPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
  for (i=0;i<32;i++) {
    dato[i]^=0xFF;
  }//invierto todos los bits porque las columnas van a los cátodos.
}

void loop() {
  muestra (dato);
}

void muestra (byte *matriz) {
  fi_L=0x01;
  fi_H=0x00;
  for (i=0;i<32;i+=2) {
    digitalWrite(latchPin, 0);
    shiftOut(dataPin, clockPin, LSBFIRST, fi_L);
    shiftOut(dataPin, clockPin, LSBFIRST, fi_H);
    shiftOut(dataPin, clockPin, LSBFIRST, matriz[i+1]);
    shiftOut(dataPin, clockPin, LSBFIRST, matriz[i]);
    digitalWrite(latchPin, 1);
    if (i<14){
      fi_L<<=1;
      bitClear(fi_L,0);
    }
    else if (i==14){
      fi_L=0x00;
      fi_H=0x01;
    }
    else{
      fi_H<<=1;
      bitClear(fi_H,0);
    }
    delay(250);
  }
}