ARQUITECTURA DE COMPUTADORAS

Prcticas de Laboratorio

Laboratorio N 07

7 VISUALIZACIN DE CARACTERES EN
UNA MATRIZ DE LEDs DE 8x8

FIGURA 7-1: Arduino MEGA 2560 y Matriz de LEDs de 8x8.

7.1 OBJETIVOS

Mostrar caracteres en una matriz de LEDs de 8x8.

Mostrar mensajes en una matriz de LEDs de 8x8.

Realizar la programacin en Arduino.

7.2 LISTA DE HERRAMIENTAS Y MATERIALES

Herramientas y Materiales para el desarrollo de la prctica de laboratorio
Herramientas

Descripcin

(1) Multmetro FLUKE 28 II

(1) Arduino Mega 2560

(2) Protoboard

Ing. Bady Elder Cruz Daz

76Laboratorio N 07
Materiales

Descripcin

Cables con terminales Macho Macho en sus extremos (Jumpers)

(8) Resistencia de 120 . (si la Matriz de LEDs de 8x8 es de iluminacin ROJO)

(8) Resistencia de 82 . (si la Matriz de LEDs de 8x8 es de iluminacin VERDE o
AZUL)

(1) Matriz de LEDs de 8x8.

TABLA 7-1: Lista de Herramientas y Materiales.

7.3 CREACIN DE CARACTERES EN UNA MATRIZ DE LEDs DE 8X8

Se cuenta con una matriz de LEDs de 8x8 y, se quiere disear caracteres (nmeros, letras, smbolos.
caracteres especiales). Para esto, tenemos que conocer que las filas y columnas tienen distintos
significados. Es decir, por las filas vamos a enviar los datos para formar los caracteres, y por las columnas
vamos a controlar el barrido para mostrar los caracteres.
Ahora, cada carcter a mostrar tiene una determinada cantidad de bit a encender en la matriz. Por
ejemplo: El nmero 0, se mapea segn se muestra en la figura 7-2:

F
I
L
A
S

X
X
X

128
X

64

32

16

1
1

COLUMNAS
Mapa de
Bits

124 138 146 162 124

FIGURA 7-2: Mapa de bits (BitMap)

Pesos
Binarios

Visualizacin de caracteres en una matriz

de LEDs de 8x877

Observamos que para dibujar el nmero 0 iniciamos en la columna 3 y finalizamos en la columna 7,

las columnas 0, 1 y 8 no se utilizan para mostrar datos. Utilizaremos 5 columnas (2, 3, 4, 5 y 6) y siete filas
(B, C, D, E, F, G y H) para mapear los nmeros decimales (0, 1, 2, 3, 4, 5, 6, 7, 8, 9).
Los bits correspondientes a cada columna para el nmero 0 son: 0, 0, 124, 138, 146, 162, 124, 0.

MATRIZ DE
LEDs DE 8x8

COLUMNAS
1

124

138

146

162

124

TABLA 7-2: Mapa de Bits para todos los nmeros decimales.

78Laboratorio N 07

7.4 PRCTICA DE LABORATORIO

Para desarrollar esta sexta prctica de laboratorio, realizaremos los siguientes pasos:

Qu se va a hacer?

Diseando el circuito para nuestro laboratorio.

Programando.

7.4.1 Qu se va a hacer?
En ste stima prctica de laboratorio, se realizar las siguientes aplicaciones:

Mostraremos un solo carcter en la matriz de LEDs de 8x8.

Mostraremos un desplazamiento de los nmeros decimales.

7.4.2 Diseando el circuito para nuestro laboratorio.

F G H I J
G

E
1

60

55

50

45

40

35

30

25

20

15

10

F G H I J
1
G

Se muestra el circuito que controla a la matriz de LEDs de 8x8.

A B C D E

F
C
60

55

50

45

40

35

30

25

20

10

15

FIGURA 7-3: Montaje para la experiencia de laboratorio.

3
2

A B C D E

F G H I J
G

60

55

50

B
D
1

60

55

45
45

50

40
40

8
7

30

25

20

15

10

6
5

A
B

A B C D E

F G H I J
1
G

4
3

C
D

30

25

20

15

10

2
1

E
F

35

G
H

35

A B C D E

(8) 120

Visualizacin de caracteres en una matriz

de LEDs de 8x879

7.4.3 Programando
Primera experiencia:
Aprenderemos a mostrar un carcter en la matriz de LEDs de 8x8. Por ejemplo el nmero 0, el cual
se hall su mapa de bits anteriormente.
H
G
F
E
FILAS
D
C
B
A
1

COLUMNAS

FIGURA 7-4: Se muestra el nmero 0 en la matriz de LEDs de 8x8.

/*
ARQCO_L07a_UnCaracter:
Este programa aprenderemos a mostrar un carcter de manera permanente en una Matriz de LEDs
de 8x8 (64 LEDs).
*/
// REA DE DEFINICIN DE VARIABLES UTILIZADAS EN EL PROGRAMA
// Variables Estticas:
const int filasMatriz[8] = {2,3,4,5,6,7,8,9}; // A los PINES 2, 3, 4, 5, 6, 7, 8 y 9 se los
declara como constantes enteras.
const int columnasMatriz[8] = {14,15,16,17,18,19,20,21}; // A los PINES 14, 15, 16, 17, 18,
19, 20 y 21 se los declara como constantes enteras.
// Necesitaremos especificar la posicin de cada caracter en el array letras[][] declarado ms
abajo. Comenzamos por los nmeros decimales.
const int cero = 0;
// A la palabra cero se le asigna la posicin 0 en el array.
const int uno = 1;
// A la palabra uno se le asigna la posicin 1 en el array.
const int dos = 2;
// A la palabra dos se le asigna la posicin 2 en el array.
const int tres = 3;
// A la palabra tres se le asigna la posicin 3 en el array.
const int cuatro = 4; // A la palabra cuatro se le asigna la posicin 4 en el array.
const int cinco = 5;
// A la palabra cinco se le asigna la posicin 5 en el array.
const int seis = 6;
// A la palabra seis se le asigna la posicin 6 en el array.
const int siete = 7;
// A la palabra siete se le asigna la posicin 7 en el array.
const int ocho = 8;
// A la palabra ocho se le asigna la posicin 8 en el array.
const int nueve = 9;
// A la palabra nueve se le asigna la posicin 9 en el array.
// Este array almacenar los 8 nmeros (de 8 cifras cada uno) que configuran las 8 columnas
mostradas en cada "pantallazo".
byte datos[8] = {0,0,0,0,0,0,0,0};
// Construiremos los bitmap (8x8) de cada caracter, siendo 1 = ON y 0 = OFF.
// Primero los nmeros (el _ ser para distinguir a los bitmaps de los posicionadores
const int _cero[] = {0,0,124,138,146,162,124,0};
// Mapa de bits para cero.
const int _uno[] = {0,0,0,66,254,2,0,0};
// Mapa de bits para uno.
const int _dos[] = {0,0,66,134,138,146,98,0};
// Mapa de bits para dos.
const int _tres[] = {0,0,68,130,146,146,108,0};
// Mapa de bits para tres.
const int _cuatro[] = {0,0,56,200,8,8,254,0};
// Mapa de bits para cuatro.
const int _cinco[] = {0,0,244,146,146,146,140,0}; // Mapa de bits para cinco.
const int _seis[] = {0,0,124,146,146,146,76,0};
// Mapa de bits para seis.
const int _siete[] = {0,0,192,128,142,144,224,0}; // Mapa de bits para siete.
const int _ocho[] = {0,0,108,146,146,146,108,0};
// Mapa de bits para ocho.
const int _nueve[] = {0,0,100,146,146,146,124,0}; // Mapa de bits para nueve.
char fraseDinamica[] = "0123456789";

80Laboratorio N 07
// Se declaran los caracteres como un array con los arrays de los bitmap de los distintos
carateres que se va a mostrar en la matriz.
// Como los elementos del array con cadenas de caracteres se utiliza int*
const int* letras[] = {_cero, _uno, _dos, _tres, _cuatro, _cinco, _seis, _siete, _ocho,
_nueve};
// La funcin SETUP se utiliza para inicializar los modos de trabajo de los pines, o el puerto
serie:
void setup()
{
for (int i=0; i<=7; i++)
{
pinMode(filasMatriz[i], OUTPUT); // Los PINES 2, 3, 4, 5, 6, 7, 8 y 9 como salidas para
controlar las filas de la matriz de LEDs de 8x8.
pinMode(columnasMatriz[i], OUTPUT); // Los PINES 14, 15, 16, 17, 18, 19, 20 y 21 como
salidas para controlar las columnas de la matriz de LEDs de 8x8.
}
// Se inicializa la matriz apagada.
for (int j=0; j<=7; j++)
{
digitalWrite(filasMatriz[j], LOW); // Las filas se activan con UNO's (HIGHs).
digitalWrite(columnasMatriz[j], HIGH); // Las columnas se activan con CERO's (LOWs)
}
}
// La funcin LOOP se ejecuta continuamente respondiendo a los eventos que se produzcan en la
placa:
void loop()
{
actualizaMatriz();
}
void actualizaMatriz()
{
construyePantalla();
muestraPantalla();
}
// Se utilizar el siguiente array con potencias de 2 para manejar los bits de cada bitmap.
const int potencias[8] = {1,2,4,8,16,32,64,128};
// Cada nmero corresponde, en binario, a 00000001, 00000010, 00000100, 00001000, 00010000,
00100000, 01000000, 1000000.
void construyePantalla() // Carga el estado actual en el array datos[].
{
int caracterActual = cogeCaracter(fraseDinamica[5]);
for (int fila=0; fila<=7; fila++)
{
datos[fila] = 0;
// Se resetea a 0 la fila que estoy considerando.
for (int columna=0; columna<=7; columna++) // Se realiza un barrido por la columna.
{
// Se construir un nmero decimal a base de sumas de tal forma que tenga UNOs en los
lugares donde quiero que se encienda el LED.
datos[fila] = datos[fila] + (potencias[columna] & (letras[caracterActual][fila])); //
Se muestra el caracter actual.
}
}
}
void muestraPantalla()
{
for (int columna=0; columna<=7; columna++) // Se har el barrido de la matriz columna por
columna.
{
for (int i=0; i<=7; i++) digitalWrite(filasMatriz[i], LOW); // Se pone a LOW todos los
pines de control de filas.
for (int j=0; j<=7; j++) // Solo se pondr en LOW el pin de la columna que estamos
considerando.
{
if (j==columna) digitalWrite(columnasMatriz[j], LOW);
else digitalWrite(columnasMatriz[j], HIGH); // El resto de pines se pone a HIGH (se
apaga el resto de columnas de LEDs).
}
for (int fila=0; fila<=7; fila++) // Se realiza el barrido, dentro de la columna activa,
por la fila.
{
int Bit=(datos[columna] >> fila) & 1; // Se detecta los "1" de las fila si al
multiplicarlo por 1 da 1.

Visualizacin de caracteres en una matriz

de LEDs de 8x881

if (Bit==1) digitalWrite(filasMatriz[fila], HIGH); // Si el bit en el array datos[] es

un 1, encender el LED.
}
delayMicroseconds(500); // Es el tiempo que cada columna est encendida.
}
}
// Veamos como asociamos cada caracter de la cadena con su bitmap
int cogeCaracter(char caracter)
{
int returnValue;
switch(caracter)
{
case '0': returnValue = cero;
break;
case '1': returnValue = uno;
break;
case '2': returnValue = dos;
break;
case '3': returnValue = tres;
break;
case '4': returnValue = cuatro;
break;
case '5': returnValue = cinco;
break;
case '6': returnValue = seis;
break;
case '7': returnValue = siete;
break;
case '8': returnValue = ocho;
break;
case '9': returnValue = nueve;
break;
}
return returnValue;
}

Segunda experiencia:
Aprenderemos a realizar un desplazamiento de caracteres en la matriz de LEDs de 8x8. Este
desplazamiento ser de abajo hacia arriba. En esta aplicacin se desplazaran los nmeros decimales.

FIGURA 7-5: Desplazamiento binario de un bit (LED).

/*
ARQCO_L07b_DesplazamientoDeCaracteres:
Este programa muestra el desplazamiento de caracteres de abajo hacia arriba en la Matriz de
LEDs de 8x8 (64 LEDs).
*/

82Laboratorio N 07
// REA DE DEFINICIN DE VARIABLES UTILIZADAS EN EL PROGRAMA
// Variables Estticas:
int numeroPantallas = 20;
un lugar.

// Nmero de veces que repite una "pantalla" antes de desplazarla

// Evidentemente este parmetro decidir tambin la velocidad de

avance del texto por la matriz.
int tiempoBarridoColumna = 500; // Microsegundos en el que est activa cada una de las
columnas.
// Tardar 8*500 us en barrer toda la "pantalla"
char fraseDinamica[] = " 0 1 2 3 4 5 6 7 8 9 ";
int index = 1; // Ser la posicin del caracter de la cadena que est siendo mostrado.
int offset = 0; // Marcar el desplazamiento de las columnas.
const int filasMatriz[8] = {2,3,4,5,6,7,8,9}; // A los PINES 2, 3, 4, 5, 6, 7, 8 y 9 se los
declara como constantes enteras.
const int columnasMatriz[8] = {14,15,16,17,18,19,20,21}; // A los PINES 14, 15, 16, 17, 18,
19, 20 y 21 se los declara como constantes enteras.
// Necesitaremos especificar la posicin de cada caracter en el array letras[][] declarado ms
abajo. Comenzamos por los nmeros decimales.
const int cero = 0;
// A la palabra cero se le asigna la posicin 0 en el array.
const int uno = 1;
// A la palabra uno se le asigna la posicin 1 en el array.
const int dos = 2;
// A la palabra dos se le asigna la posicin 2 en el array.
const int tres = 3;
// A la palabra tres se le asigna la posicin 3 en el array.
const int cuatro = 4; // A la palabra cuatro se le asigna la posicin 4 en el array.
const int cinco = 5;
// A la palabra cinco se le asigna la posicin 5 en el array.
const int seis = 6;
// A la palabra seis se le asigna la posicin 6 en el array.
const int siete = 7;
// A la palabra siete se le asigna la posicin 7 en el array.
const int ocho = 8;
// A la palabra ocho se le asigna la posicin 8 en el array.
const int nueve = 9;
// A la palabra nueve se le asigna la posicin 9 en el array.
const int espacio = 10;
// A la palabra espacio se le asigna la posicin 10 en el array.
// Este array almacenar los 8 nmeros (de 8 cifras cada uno) que configuran las 8 columnas
mostradas en cada "pantallazo".
byte datos[8] = {0,0,0,0,0,0,0,0};
// Construiremos los bitmap (8x8) de cada caracter, siendo 1 = ON y 0 = OFF.
// Primero los nmeros (el _ ser para distinguir a los bitmaps de los posicionadores
const int _cero[] = {0,0,124,138,146,162,124,0};
// Mapa de bits para cero.
const int _uno[] = {0,0,0,66,254,2,0,0};
// Mapa de bits para uno.
const int _dos[] = {0,0,66,134,138,146,98,0};
// Mapa de bits para dos.
const int _tres[] = {0,0,68,130,146,146,108,0};
// Mapa de bits para tres.
const int _cuatro[] = {0,0,56,200,8,8,254,0};
// Mapa de bits para cuatro.
const int _cinco[] = {0,0,244,146,146,146,140,0}; // Mapa de bits para cinco.
const int _seis[] = {0,0,124,146,146,146,76,0};
// Mapa de bits para seis.
const int _siete[] = {0,0,192,128,142,144,224,0}; // Mapa de bits para siete.
const int _ocho[] = {0,0,108,146,146,146,108,0};
// Mapa de bits para ocho.
const int _nueve[] = {0,0,100,146,146,146,124,0}; // Mapa de bits para nueve.
const int _espacio[]= {0,0,0,0,0,0,0,0};
// Mapa de bits para espacio.
// Se declaran los caracteres como un array con los arrays de los bitmap de los distintos
carateres que se va a mostrar en la matriz.
// Como los elementos del array con cadenas de caracteres se utiliza int*
const int* letras[] = {_cero, _uno, _dos, _tres, _cuatro, _cinco, _seis, _siete, _ocho,
_nueve, _espacio};
// La funcin SETUP se utiliza para inicializar los modos de trabajo de los pines, o el puerto
serie:
void setup()
{
for (int i=0; i<=7; i++)
{
pinMode(filasMatriz[i], OUTPUT); // Los PINES 2, 3, 4, 5, 6, 7, 8 y 9 como salidas para
controlar las filas de la matriz de LEDs de 8x8.
pinMode(columnasMatriz[i], OUTPUT); // Los PINES 14, 15, 16, 17, 18, 19, 20 y 21 como
salidas para controlar las columnas de la matriz de LEDs de 8x8.
}
// Se inicializa la matriz apagada.
for (int j=0; j<=7; j++)
{
digitalWrite(filasMatriz[j], LOW); // Las filas se activan con UNO's (HIGHs).
digitalWrite(columnasMatriz[j], HIGH); // Las columnas se activan con CERO's (LOWs)
}
}

Visualizacin de caracteres en una matriz

de LEDs de 8x883

// La funcin LOOP se ejecuta continuamente respondiendo a los eventos que se produzcan en la

placa:
void loop()
{
actualizaMatriz();
}
void actualizaMatriz()
{
construyePantalla();
muestraPantalla(numeroPantallas);
}
// Se utilizar el siguiente array con potencias de 2 para manejar los bits de cada bitmap.
const int potencias[8] = {1,2,4,8,16,32,64,128};
// Cada nmero corresponde, en binario, a 00000001, 00000010, 00000100, 00001000, 00010000,
00100000, 01000000, 1000000.
void construyePantalla() // Carga el actual estado de desplazamiento al array datos[].
{
int caracterAnterior = cogeCaracter(fraseDinamica[index-1]); // Por esto empezamos en index
= 1
int caracterActual = cogeCaracter(fraseDinamica[index]);
int caracterPosterior = cogeCaracter(fraseDinamica[index+1]);
for (int fila=0; fila<=7; fila++)
{
datos[fila] = 0; // Reseteo a 0 la fila que estoy considerando.
for (int columna=0; columna<=7; columna++) //Hacemos un barrido por todas las columnas.
{
// Se construir un nmero decimal a base de sumas de tal forma que tenga UNOs en los
lugares donde quiero que se encienda el LED.
datos[fila] = datos[fila] + (potencias[columna] & (letras[caracterAnterior][fila] <<
(offset+8) ));
// Cuando se muestra un caracter en el borde derecho de la matriz (offset==0),
// se deberan mostrar en las dos columnas del borde izquierdo las dos ltimas columnas
del caracter anterior.
datos[fila] = datos[fila] + (potencias[columna] & (letras[caracterActual][fila] <<
offset));
// Se muestra el caracter actual, y se va desplazando a travs del offset hacia arriba.
datos[fila] = datos[fila] + (potencias[columna] & (letras[caracterPosterior][fila] >>
(8-offset) ));
// Cuando se desplaza el caracter actual, ir apareciendo por abajo las primeras
// filas del caracter posterior. Se ha puesto (offset+7) y (7-offset)
// porque los caracteres tienen una anchura de 5 columnas, y se quiere que entre
// caracter y caracter haya 2 columnas de separacin.
}
}
offset++; // Se ha terminado una fila, pasara a construir la siguiente.
if (offset==8) // Significara que se ha desplazado una letra entera.
{
offset=0; index++; // Se carga un caracter nuevo y se pone offset a cero.
if (index==sizeof(fraseDinamica)-2) index=1; // Si termina la frase, se reinicia.
}
}
void muestraPantalla(int repeticiones)
{
for (int n=0; n<repeticiones; n++) // Muestra en la pantalla actual un nmero de
repeticones.
{
for (int columna=0; columna<=7; columna++) // Se hace un barrido de la matriz columna por
columna.
{
for (int i=0; i<=7; i++) digitalWrite(filasMatriz[i], LOW); // Pone a LOW todos los
pines de control de filas.
for (int j=0; j<=7; j++) // Solo se pone en LOW el pin de la columna que estamos
considerando.
{
if (j==columna) digitalWrite(columnasMatriz[j], LOW);
else digitalWrite(columnasMatriz[j], HIGH); // El resto de pines se pone a HIGH (se
apaga el resto de columnas de LEDs).
}
for (int fila=0; fila<=7; fila++) // Se realiza el barrido, dentro de la columna
activa, por la fila.
{

84Laboratorio N 07
int Bit=(datos[columna] >> fila) & 1; // Se detecta los "1" de las fila si al
multiplicarlo por 1 da 1.
if (Bit==1) digitalWrite(filasMatriz[fila], HIGH); // Si el bit en el array datos[]
es un 1, encender el LED.
}
delayMicroseconds(tiempoBarridoColumna); // Es el tiempo que cada columna est
encendida.
}
}
}
// Veamos como asociamos cada caracter de la cadena con su bitmap
int cogeCaracter(char caracter)
{
int returnValue;
switch(caracter)
{
case '0': returnValue = cero;
break;
case '1': returnValue = uno;
break;
case '2': returnValue = dos;
break;
case '3': returnValue = tres;
break;
case '4': returnValue = cuatro;
break;
case '5': returnValue = cinco;
break;
case '6': returnValue = seis;
break;
case '7': returnValue = siete;
break;
case '8': returnValue = ocho;
break;
case '9': returnValue = nueve;
break;
case ' ': returnValue = espacio;
break;
}
return returnValue;
}

7.5 ANOTACIONES IMPORTANTES

_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________

Visualizacin de caracteres en una matriz

de LEDs de 8x885

_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________

Pginas WEBs de referencia:

Matriz de LEDs de 8x8:
http://playground.arduino.cc/Es/OSW06
http://www.sc.ehu.es/sbweb/fisica/cursoJava/numerico/matrices/matriz/matriz.htm
http://panamahitek.com/tipos-de-datos-arrays-en-arduino