Control de una matriz led de 16x16 y por extensión a todas (74HC595)

Hay poca información en la web y esa poca cuesta aplicarla a un caso concreto.
El principal detalle es: 74hc595 driver.
Se trata de registros de desplazamiento. En este caso dos de 8 para las filas y 2 de 8 para las columnas.

Pongo códigos que es la forma más sencilla de entenderlos.
Código 1:
//salidas que se van a utilizar
int latchPin = 8;
int clockPin = 12;
int dataPin = 11;
//array en el que se va a contener toda la informacin de filas y columnas
byte dato[4];
//i va a variar de 0 a 7 por eso es suficiente con un byte
byte i;

void setup() {
  pinMode(latchPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
  dato[0]=0xFF;//columna mayor peso
  dato[1]=0xFF;//columna menor peso
  dato[2]=0x00;//fila mayor peso
  dato[3]=0x00;//fila menor peso
  envia_datos(dato);
}

/****************************************************************
 * bitWrite()
 * Descripción
 * Escribe un bit de una variable numérica.
 * Sintaxis
 * bitWrite(x, n, b)
 * Parámetros
 * x: la variable numérica en la que vamos a escribir
 * n: en cual de los bits vamos a escribir, empezando en el 0 para el bit menos significativo (el que está más a la derecha)
 * b: el valor a escribir en el bit (0 o 1)
 * 
 * bitRead()
 * Descripción
 * Lee un bit de un número.
 * Sintaxis
 * bitRead(x, n)
 * Parámetros
 * x: el número en el que queremos leer
 * n: cual de los bits queremos leer, empezando por el 0 para el bit menos significativo (el que está más a la derecha)
 * Devuelve
 * el valor del bit (0 o 1). 
 * 
 * bitSet()
 * Descripción
 * Pone a uno un bit de una variable numérica.
 * Sintaxis
 * bitSet(x, n)
 * Parámetros
 * x: la variable numérica en la que está el bit a poner a uno
 * n: cual de los bits queremos poner a uno, empezando en el 0 para el bit menos significativo (el que está más a la derecha) 
 * 
 * bitClear()
 * Descripción
 * Limpia (pone a cero) un bit de una variable numérica.
 * Sintaxis
 * bitClear(x, n)
 * Parámetros
 * x: la variable numérica con el bit a limpiar
 * n: cual de los bits queremos limpiar, empezando en el 0 por el bit menos significativo (el que está más a la derecha) 
 ***************************************************************/

void envia_datos(byte *matrix) {
  digitalWrite(latchPin, 0);
  for (byte i=4; i>2; i--) shiftOut(dataPin, clockPin, LSBFIRST, matrix[i-1]);
  for (byte i=2; i>0; i--) shiftOut(dataPin, clockPin, MSBFIRST, matrix[i-1]);
  digitalWrite(latchPin, 1);
  delay(500);
}

void loop() {
  for (i=0;i<8;i++) {
    dato[2]<<=1;
    bitSet(dato[2], 0);
    envia_datos(dato);

    dato[1]<<=1;
    bitClear(dato[1],0);
    envia_datos(dato);

    dato[3]>>=1;
    bitSet(dato[3],7);
    envia_datos(dato);

    dato[0]>>=1;
    bitClear(dato[0],7);
    envia_datos(dato);
  }//2130
  for (i=0;i<8;i++) {
    dato[2]>>=1;
    bitClear(dato[2],7);
    envia_datos(dato);

    dato[1]>>=1;
    bitSet(dato[1],7);
    envia_datos(dato);

    dato[3]<<=1;
    bitClear(dato[3], 0);
    envia_datos(dato);
    
    dato[0]<<=1;
    bitSet(dato[0],0);
    envia_datos(dato);
  }  

}
Código 2: Para ver cuales son las filas, las columnas, ánodos, cátodos, mayores y menores pesos.
//salidas que se van a utilizar
int latchPin = 8;
int clockPin = 12;
int dataPin = 11;
byte dato[4];
void setup() {
  pinMode(latchPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
}
void envia_datos(byte *matrix) {
  digitalWrite(latchPin, 0);
  for (byte i=4; i>2; i--) shiftOut(dataPin, clockPin, LSBFIRST, matrix[i-1]);
  for (byte i=2; i>0; i--) shiftOut(dataPin, clockPin, MSBFIRST, matrix[i-1]);
  digitalWrite(latchPin, 1);
}
void loop() {
  //FILAS
  dato[3]=0x01; //anodo menor peso
  dato[2]=0xA0; //anodo mayor peso
  //COLUMNAS
  dato[1]=0x0F; //catodo mayor peso
  dato[0]=0x73; //catodo menor peso
  envia_datos(dato); //fila (vertical)-anodo 1000 0000 - 0000 0101 + columna (vertical) catodo 11111 0000 - 1100 1110
  /*dato[1]  dato[0]
    F    0    3    7
  0000 1111 0011 0001
  0000 0000 0000 0000
  0000 1111 0011 0001 A
  0000 0000 0000 0000
                      dato[3]
  0000 0000 0000 0000
  0000 0000 0000 0000
  0000 0000 0000 0000 0
  0000 0000 0000 0000
  
  0000 0000 0000 0000
  0000 0000 0000 0000
  0000 0000 0000 0000 0
  0000 0000 0000 0000
                      dato[2]
  0000 0000 0000 0000
  0000 0000 0000 0000
  0000 0000 0000 0000 1
  0000 1111 0011 0001
  */
  delay(100000);//para no hacer uso innecesario de la CPU
}