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);
}
}
