Para ligar uma matrix é preciso:

Uma alimentação de 5 v;

Arduíno Uno ou equivalente;

Protoboard;

CI 4017;

O pin 3 do Arduíno vai ligar ao pin 15 do IC 4017 (RST)

O pin 13 do Arduíno vai ligar ao pin 14 do IC 4017 (CLK)

Código do Arduíno – exemplo:

#include <string.h>

// 0 1 2 3 4 5 6 7
int aux[8][8]= {0,0,0,0,0,0,0,0, //0 //poderia ter usado dois laços um para colunas outro para linhas pra fazer o mesmo
/* k m */ 0,0,0,0,0,0,0,0, //1 //mas assim parece mais didatico
0,0,0,0,0,0,0,0, // k linha m columa
0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0};

int aux2[8][8]; // cada byte corresponde a uma linha da letra de cima para baixo
// linha 1 2 3 4 5 6 7 8
byte A[8] = {B0001000, B0010100, B0100010, B1000001, B1111111, B1000001, B1000001, B0000000};
byte B[8] = {B1111110, B0100001, B0100001, B0111110, B0100001, B0100001, B1111110, B0000000};
byte C[8] = {B0011111, B0100000, B1000000, B1000000, B1000000, B0100000, B0011111, B0000000};
byte D[8] = {B1111100, B0100010, B0100001, B0100001,B0100001, B0100010, B1111100, B0000000};
byte E[8] = {B1111111, B1000000, B1000000, B1111100,B1000000, B1000000, B1111111, B0000000};
byte F[8] = {B1111111, B1000000, B1000000, B1111100, B1000000,B1000000, B1000000, B0000000};
byte G[8] = {B0011111, B0100000, B1000000, B1001111, B1000001,B0100001, B0011111, B0000000};
byte H[8] = {B1000001, B1000001, B1000001, B1111111, B1000001,B1000001, B1000001, B0000000};
byte I[8] = {B1111111, B0001000, B0001000, B0001000, B0001000, B0001000,B1111111, B0000000};
byte J[8] = {B0001111, B0000001, B0000001, B0000001, B0000001, B1000001, B0111110, B0000000};
byte K[8] = {B1000011, B1000100, B1001000, B1110000,B1001000,B1000100, B1000011, B0000000};
byte L[8] = {B1000000, B1000000, B1000000, B1000000, B1000000, B1000000,B1111111, B0000000};
byte M[8] = {B1110110, B1001001, B1001001,B1001001, B1001001, B1001001, B1001001, B0000000};
byte N[8] = {B1000001, B1100001, B1010001,B1001001, B1000101,B1000011,B1000001, B0000000};
byte O[8] = {B0011100, B0100010, B1000001,B1001001,B1000001, B0100010,B0011100,B0000000};
byte P[8] = {B1111110, B0100001, B0100001,B0111110, B0100000,B0100000,B0100000,B0000000};
byte Q[8] = {B0011100, B0100010, B1000001,B1000001,B1000101,B0100010, B0011101,B0000000};
byte R[8] = {B1111110, B0100001, B0100001, B0101110, B0100100,B0100010,B0100001,B0000000};
byte S[8] = {B0111111, B1000000, B1000000, B0111110, B0000001,B0000001,B1111110, B0000000};
byte T[8] = {B1111111, B0001000, B0001000, B0001000, B0001000,B0001000,B0001000, B0000000};
byte U[8] = {B1000001, B1000001, B1000001, B1000001, B1000001, B1000001,B0111110, B0000000};
byte V[8] = {B1000001, B1000001, B1000001, B1000001, B0100010,B0010100, B0001000, B0000000};
byte W[8] = {B1000001, B1001001, B1001001, B1001001, B1001001,B1001001, B0110110, B0000000};
byte X[8] = {B1000001, B0100010, B0010100, B0001000, B0010100, B0100010, B1000001,B0000000};
byte Y[8] = {B1000001, B0100010, B0010100, B0001000, B0001000, B0001000, B0001000, B0000000};
byte Z[8] = {B1111111, B0000010, B0000100, B0111110, B0010000,B0100000, B1111111, B0000000};
byte CHECK[8] = {B10101010, B01010101, B10101010, B01010101, B10101010, B01010101, B10101010, B01010101};
byte espaco[8] = {B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000};
byte smiley[8] = {B00000000,B10001000, B00000000,B00000000,B10001000, B01110000,B00000000,B00000000};

int cont = 0;

int ckPin = 13; // clock para o contador
int displayPin[8] = {12,11,10,9,8,7,6,5,};// pinos de dados
int rstPin = 3; // reset contador

void setup()
{
int i;

pinMode(ckPin, OUTPUT);
pinMode(rstPin, OUTPUT);

for(i=0;i<8;i++)
pinMode(displayPin[i], OUTPUT); // pinos com saida

}
char *frase ={“—“}; // texto a ser mostrado {“AABBCC”};
int t =0;
void loop() //inicio programa principal n

{
t =0;
while(t < strlen(frase))
{ // envia letra por letra da frase para funcao escreve
escreve(frase[t], 1, 150); // caracte, modo 0 apenas mostra 1 desloca, tempo

apaga_coluna(0); // espaco entre letras passa quantidade de colunas
t++;
}
apaga_coluna(8);

} //fim da funcao principal

//////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////

void escreve(char letra, int modo, int tmp){
int k;
byte *Lt;

switch(letra) // compara a letra e armazena o vetor correspondente em Lt
{
case ‘A’:
Lt=A;
break;

case ‘B’:
Lt=B;
break;

case ‘C’:
Lt=C;
break;

case ‘D’:
Lt=D;
break;

case ‘E’:
Lt=E;
break;

case ‘F’:
Lt=F;
break;

case ‘G’:
Lt=G;
break;

case ‘H’:
Lt=H;
break;

case ‘I’:
Lt=I;
break;

case ‘J’:
Lt=J;
break;

case ‘K’:
Lt=K;
break;

case ‘L’:
Lt=L;
break;

case ‘M’:
Lt=M;
break;

case ‘N’:
Lt=N;
break;

case ‘O’:
Lt=O;
break;

case ‘P’:
Lt=P;
break;

case ‘Q’:
Lt=Q;
break;

case ‘R’:
Lt=R;
break;

case ‘S’:
Lt=S;
break;

case ‘T’:
Lt=T;
break;

case ‘U’:
Lt=U;
break;

case ‘V’:
Lt=V;
break;

case ‘X’:
Lt=X;
break;

case ‘Z’:
Lt=Z;
break;

case ‘ ‘:
Lt=espaco;
break;

case ‘-‘:
Lt=smiley;
break;

}

//copia o caracter para aux
// bit por bit é armazenado na matriz aux
for(int i=0; i<8;i++)
{
for(int j=0; j<8;j++)
{
if(modo == 0)
aux[i][j] = bitRead(Lt[i], 7-j);
else
aux2[i][j] = bitRead(Lt[i], 7-j);
}
}

if ( modo == 0) // mostra ccaracter
{
imprime(tmp);
}
else if( modo == 1) // modo 1 desloca caracter anterior
{

cont = 0;

for (int passo =0; passo <8; passo++)
{

for(k=0; k<8; k++) // linhas
{

for(int m=0; m < 7; m++)
{

aux[k][m] = aux[k][m+1];

}
aux[k][7] = aux2[k][cont]; // ultima coluna de aux recebe a primeira coluna de E
}

cont ++;

imprime(tmp); // mostra no display

} //fim da contagem de passos
} // fim de escreve letra

}

//////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////

void apaga_coluna(int qtd)
{
int k;

for (int passo =0; passo <qtd; passo++)
{

for(k=0; k<8; k++) // linhas
{

for(int m=0; m < 7; m++)
{

aux[k][m] = aux[k][m+1];

}
aux[k][7] = 0; // ultima coluna de aux recebe a primeira coluna de E
}

cont ++;

imprime(100); // mostra no display

} //fim da contagem de passos

} //fim apaga coluna

//////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////

void imprime(int tmp)
{
// int tmp = 100;

for(int a=0; a < tmp; a++) // tmp representa a quantidades de vezes que cada caracter é exibido
{
digitalWrite(rstPin, LOW); // prepara para reset do contador

for(int i =0; i<8; i++) // linhas
{
digitalWrite(ckPin, LOW); // como a mudança ocorre na descida do clock esta linha so faz sentido no segund ciclo

for(int j=0;j<8;j++) // colunas
{
if(aux[i][j] == 1)
{
digitalWrite(displayPin[j], LOW);
}
else
{
digitalWrite(displayPin[j], HIGH);
}
}

delay (0.5); // entre linhas

for(int i=0;i<8;i++) // apaga a linha
digitalWrite(displayPin[i], HIGH);

digitalWrite(ckPin, HIGH);

}

digitalWrite(rstPin, HIGH); // reset do contador

}
}