martes, 29 de octubre de 2013

LABORATORIO NUMERO 12

En este laboratorio se usara una matriz de 8x8 de cátodo común para reemplazar la que se usaría en este laboratorio, la cual era una matriz de 8x5 de cátodo común. para controlar esta  matrix de LEDs de 8x8 se cableara a través de un IC Maxim MAX7219, para mostrar un mensaje letra por letra, desplazándose de derecha a izquierda, y así poder ahorra puertos de salida en en sistema embebido arduino.





Matriz de leds mono color (esquema).

MATRIZ DE LEDS BICOLOR (esquema).


este es un ejempo de muestreo de desplazamiento de leds encendido en secuencia para mostrar la letra W.


MAX 7219


 (esquema)



Es un multiplexor el cual utilizaremos para controlar la matriz de leds la cual recibirá la señales multiplezadas desde el IC, señal proveniente desde el arduino que estará conectado al computador, el cual trasmitira el texto a mostrar.

El MAX7219 impulsa ocho LEDs a la vez, y por los bancos con rapidez de conmutación de ocho ojos no ven los cambios. Cableado de una matriz es muy simple - si tiene una matriz común con el siguiente esquema:

conectar los pines con la etiqueta MAX7219 DP, A F ~ a los pines de las columnas que serán los cátodos de la matriz, respectivamente, y los MAX7219 pines etiquetados DIG0 ~ 7 para los ánodos de las columnas, respectivamente.

El circuito es muy sencillo, excepto que tenemos una resistencia entre 5V y MAX7219 pin 18. El MAX7219 es un controlador de LED de corriente constante, y el valor de la resistencia se utiliza para establecer el flujo de corriente a los LEDs.

MATERIALES
  1. 1 arduino mega adk
  2. matriz de leds 8x8 catodo comun
  3. computador
  4.  MAX7219
DIAGRAMA DE MONTAJE EN PROTOBOARD


DIAGRAMA ESQUEMÁTICO


 DIAGRAMA PARA MONTAJE EN TARJETA PERFORADA


 
FOTOS

foto 1


foto 2

foto 3

foto 4

 foto 5

 foto 6

 foto 7

foto 8


foto 9

CÓDIGO ARDUINO

#include <Sprite.h>  
#include <Matrix.h>
 
int count = 0;
 
int x = 8;
int letra1 = 0;
int letra2 = 0;
 
int tiempoEspera = 0;
 
const int numChips = 1;
int DIN  = 6;
int CLK  = 7;
int LOAD = 8;
                     //DIN, CLK, LOAD, #chips
Matrix matrix = Matrix(DIN, CLK, LOAD, numChips);
 
void setup() {
  pinMode(6,OUTPUT);
  pinMode(7,OUTPUT);
  pinMode(8,OUTPUT);
  tiempoEspera = 150;
  Serial.begin(9600);
}
 
void loop() {
  if(Serial.available() > 0){
     byte dato = Serial.read();
     //si el dato esta entre A-Z o a-z
     if((64 < dato && dato < 91) || (96 < dato && dato < 123)){
        //pasamos a mayuscula el caracter
        byte caracterMayuscula = toUpperCase(dato);  
        letra1 = caracterMayuscula-65;
        mover();      
     }else {
       //si hay espacio
       if(dato == 32){
         letra1 = 26;
         mover();
        }        
     }
  }else{    
    letra1 = 26;
    mover();
  }    
}
 
void mover(){
  do{
    delay(tiempoEspera);    
    count--;
    x--;
    pintar();
  }while(x >= 0);
  x = 8;
  count = 6;
  letra2 = letra1;  
}
 
Sprite letras(int valor){
  //creamos los sprite con 5 pixeles de ancho y 5 pixelex de alto  
  int _width = 5;
  int _height = 5;
  switch(valor){
    case 0:
       //A
       return Sprite(_width, _height,
        B10001, B10001, B11111, B10001, B11111
      );
      break;
    case 1:
      //B
      return Sprite(5, 5,
        B11110, B10001, B11110, B10001, B11110
      );
      break;
    case 2:
      //C
      return Sprite(5, 5,
        B11111, B10000, B10000, B10000, B11111
      );
      break;
    case 3:
      //D
      return Sprite(5, 5,
        B11110, B10001, B10001, B10001, B11110
      );
      break;
    case 4:
      //E
      return Sprite(5, 5,
        B11111, B10000, B11111, B10000, B11111
      );
      break;
    case 5:
      //F
      return Sprite(5, 5,
        B10000, B10000, B11110, B10000, B11110
      );
      break;
    case 6:
      //G
      return Sprite(5, 5,
        B11111, B10001, B11111, B10000, B11111
      );
      break;  
    case 7:
      //H
      return Sprite(5, 5,
        B10001, B10001, B11111, B10001, B10001
      );
      break;
    case 8:
      //I
      return Sprite(5, 5,
        B11111, B00100, B00100, B00100, B11111
      );
      break;
    case 9:
      //J
      return Sprite(5, 5,
        B11100, B00100, B00100, B00100, B11111
      );
      break;
    case 10:
      //K
      return Sprite(5, 5,
        B10001, B10010, B11100, B10010, B10001
      );
      break;
    case 11:
      //L
      return Sprite(5, 5,
        B11111, B10000, B10000, B10000, B10000
      );
      break;
    case 12:
      //M
      return Sprite(5, 5,
        B10001, B10001, B10001, B10101, B11011
      );
      break;  
    case 13:
      //N
      return Sprite(5, 5,
        B10001, B10011, B10101, B11001, B10001
      );
      break;
    case 14:
      //O
      return Sprite(5, 5,
        B11111, B10001, B10001, B10001, B11111
      );
      break;
    case 15:
      //P
      return Sprite(5, 5,
        B10000, B10000, B11110, B10001, B11110
      );
      break;    
     case 16:
      //Q
      return Sprite(5, 5,
        B11111, B10011, B10001, B10001, B11111
      );
      break;
    case 17:
      //R
      return Sprite(5, 5,
        B10001, B10010, B11110, B10001, B11110
      );
      break;
    case 18:
      //S
      return Sprite(5, 5,
        B11110, B00001, B01110, B10000,B01110
      );
      break;
    case 19:
      //T
      return Sprite(5, 5,
        B00100, B00100, B00100, B00100, B11111
      );
      break;
    case 20:
      //U
      return Sprite(5, 5,
        B11111, B10001, B10001, B10001, B10001
      );
      break;
    case 21:
      //V
      return Sprite(5, 5,
        B00100, B01010, B10001, B10001, B10001
      );
      break;  
    case 22:
      //W
      return Sprite(5, 5,
        B10001, B11011, B10101, B10001, B10001
      );
      break;  
    case 23:
      //X
      return Sprite(5, 5,
        B10001, B01010, B00100, B01010, B10001
      );
      break;
    case 24:
      //Y
      return Sprite(5, 5,
        B00100, B00100, B01110, B10001, B10001
      );
      break;
    case 25:
      //Z
      return Sprite(5, 5,
        B11111, B01000, B00100, B00010, B11111
      );
      break;
    case 26:
      //Blanco
      return Sprite(5, 5,
        B00000, B00000, B00000, B00000, B00000
      );
      break;    
  }
}
 
void pintar(){  
  matrix.clear();
  //se coloca el Sprite en pantalla
  matrix.write(x, 0, letras(letra1));
  if(count >= 0){
    matrix.write(x - 8, 0, letras(letra2));
  }
}

CÓDIGO PROCESSING

//se carga la libreria ControlP5
import controlP5.*;
//se carga la libreria Serial
import processing.serial.*;
// definir la variable cp5 del tipo ControlP5
ControlP5 cp5;
// definir la variable puerto del tipo Serial
Serial puerto;
// definir la variable text del tipo Textfield
Textfield text;
 
void setup(){
  //tamaño de la ventana
   size(250,160);
 
   //se crea el objeto controlP5
   cp5 = new ControlP5(this);
 
   text = cp5.addTextfield("text")
             .setPosition(20,30)
             .setSize(200,40)
             .setFont(createFont("arial",20))
             .setAutoClear(false);
 
          cp5.addButton("Enviar")
              .setValue(1)
              .setPosition(20,100)
              .setSize(40,30)
              .setId(2);
           
   String COM = Serial.list()[0];
   //comunicacion serial a 9600bps
   puerto = new Serial(this, COM, 9600);
}
 
void draw(){
   background(#000000);
}
 
void controlEvent(ControlEvent theEvent){  
  if(theEvent.isAssignableFrom(Button.class)){  
   //se envia cada caracter de la cadena
    for(int i = 0; i < text.getText().length(); i++){  
       char dato = text.getText().charAt(i);    
       puerto.write(dato);
    }
  }
}




sábado, 26 de octubre de 2013

LABORATORIO NUMERO 11

En este laboratorio se usara una matriz de 8x8 de catodo comun para reemplazar la que se usaría en este laboratorio, la cual era una matriz de 8x5 de cátodo comun.


hay dos formas de mostrar letras o caracteres en las matrices de leds. el metodo show y el metodo como frecuencytimmer.

METODO SHOW

En este metodo se mostrara el manejo por completo de la matriz de 8x8 de catodo comun, lo cual nos permitira mostrar el mensaje letra por letra, pero sin un desplazamiento.

METODO FRECUENCY TIMER
Usaramos la libreria FrequencyTimer2 para hacer un mejor manejo de los tiempos de aparicion y recorrido de las letras al igual del encendido de los mismos leds.

Los Métodos

todos los métodos son estáticos, los llaman con un FrequencyTimer2: frente.
  1. setPeriod (microsegundos largos sin signo): Establezca el período para el número especificado de microsegundos. El límite inferior es 1, el límite superior es una función de la velocidad de reloj, 2 ^ 18 relojes. Se resuelve a cerca de 30 Hz en un reloj de 16MHz. Si usted piensa en hercios, y luego pasar 1000000L/hertz.
  2. unsigned long getPeriod(): Devuelva el período real. Esto puede ser diferente, ya que pidió a uno de los límites, o el código tenía que utilizar un divisor de reloj para mantener el contador en el rango. A menos que usted salió de los límites que usted debe esperar que se trata de menos de 0,5% de su valor solicitado.
  3. enable (); Comience moviendo el pin de salida. Usted todavía tiene que hacer un pinMode (11, OUTPUT) si desea sacar activamente, de lo contrario, sólo tiene que utilizar la resistencia de pull-up.
  4. disable(:): Detener moviendo el pin de salida. Lleve la unidad a un uso general. (No PWM.)
  5. setOnOverflow (void (* func) ()): Ajuste la función de desbordamiento. Esto se llama al final de cada ciclo. . Ajuste en 0 para desactivar la alarma Nota bien: si el período es demasiado rápido se bloqueará sólo el manejo de las interrupciones. Un simple incrementor contador se bloquea en algún lugar bajo 15US. gcc se ve obligado a generar una gran cantidad de registro se mueve para apoyar las funciones de C y C + + como manejador de interrupciones. Funciones más complicadas tendrán períodos de fracaso más altas. Recuerde estas palabras cuando el boceto se bloquea.
    Ventajas

    -Usted recibe una señal de salida estable, sin fluctuaciones.
    -No hay limitaciones de tiempo en su código.
    -Usted puede conectar fácilmente el código en una interrupción periódica con un intervalo de tiempo  de su elección.

    Desventajas

    -Te cuesta Timer2 y sus salidas PWM asociados, 11 y 3 (sobre un ATmega168).
     tamaño
    -La biblioteca es de aproximadamente 600 bytes más 4 bytes de SRAM.

    MATERIALES
    1. 1 arduino mega adk
    2. matriz de leds 8x8 catodo comun
    3. computador
DIAGRAMA DE MONTAJE EN PROTOBOARD

DIAGRAMA ESQUEMÁTICO



 DIAGRAMA PARA MONTAJE EN TARJETA PERFORADA

FOTOS

foto 1

foto 2


foto 3

foto 4

CÓDIGO ARDUINO MÉTODO SHOW

byte A[]={

B00111100,
B01000010,
B10000001,
B10000001,
B11111111,
B10000001,
B10000001,
B10000001};


byte I[]={
B01111100,
B00010000,
B00010000,
B00010000,
B00010000,
B00010000,
B00010000,
B01111100};

byte J[]={
B01111100,
B00010000,
B00010000,
B00010000,
B00010000,
B10010000,
B10010000,
B01100000};


byte  L[]={ 
B10000000,
B10000000,
B10000000,
B10000000,
B10000000,
B10000000,
B10000001,
B11111111};


byte  N[]={ 
B10000001,
B11000001, 
B10100001, 
B10010001, 
B10001001, 
B10000101, 
B10000011, 
B10000001};


byte U[]={
B10000001, 
B10000001, 
B10000001, 
B10000001, 
B10000001, 
B10000001, 
B01000010, 
B00111100};


byte   blanco[]={
B00000000, 
B00000000, 
B00000000, 
B00000000, 
B00000000, 
B00000000, 
B00000000, 
B00000000};
byte smiley[] = {
B00111100, 
B01000010,
B10010101,
B10100001,
B10100001,
B10010101,
B01000010,
B00111100};

const int columnPins[] = { 2, 3, 4, 5, 6, 7, 8, 9};
const int rowPins[] = { 22,23,24,25,26,27,28,29};
void setup() {
for (int i = 0; i < 8; i++)
{
pinMode(rowPins[i], OUTPUT); // make all the LED pins outputs
pinMode(columnPins[i], OUTPUT);
digitalWrite(columnPins[i], HIGH); // disconnect column pins from Ground
}
}

void loop() {

int pulseDelay = 800 ; // milliseconds to wait between beats
show(J, 1000); // show the small heart image for 100 ms
show(U, 1000); // followed by the big heart for 200ms
show(L, 1000); // show the small heart image for 100 ms
show(I, 1000); // followed by the big heart for 200ms
show(A, 1000); // show the small heart image for 100 ms
show(N, 1000); // followed by the big heart for 200ms
show(smiley, 1000); // followed by the big heart for 200ms
delay(pulseDelay); // show nothing between beats

}

// routine to show a frame of an image stored in the array pointed to by the
// image parameter.
// the frame is repeated for the given duration in milliseconds
void show( byte * image, unsigned long duration)
{
unsigned long start = millis(); // begin timing the animation
while (start + duration > millis()) // loop until the duration period has passed
{

for(int row = 0; row < 8; row++)
{
digitalWrite(rowPins[row], HIGH); // connect row to +5 volts
for(int column = 0; column < 8; column++)
{
boolean pixel = bitRead(image[row],column);

if(pixel == 1)
{

digitalWrite(columnPins[column], LOW); // connect column to Gnd
}

delayMicroseconds(300); // a small delay for each LED
digitalWrite(columnPins[column], HIGH); // disconnect column from Gnd
}

digitalWrite(rowPins[row], LOW); // disconnect LEDs
}
}
}

CÓDIGO ARDUINO MÉTODO TIMMER FRECUENCY

//Se incluye la libreria FrequencyTimer2
#include <FrequencyTimer2.h>

//matrix 5x5
//se declara la variable temCol de tipo entero inicializada en 5
int temCol = 5;
//se declara la variable temFil de tipo entero inicializada en 5
int temFil = 5;

//se definen las matrices de letras [A-Z]
#define A { \
{1, 1, 1, 1, 1}, \
{1, 0, 0, 0, 1}, \
{1, 1, 1, 1, 1}, \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1} \
}

#define B { \
{1, 1, 1, 1, 0}, \
{1, 0, 0, 0, 1}, \
{1, 1, 1, 1, 0}, \
{1, 0, 0, 0, 1}, \
{1, 1, 1, 1, 0} \
}

#define C { \
{1, 1, 1, 1, 1}, \
{1, 0, 0, 0, 0}, \
{1, 0, 0, 0, 0}, \
{1, 0, 0, 0, 0}, \
{1, 1, 1, 1, 1} \
}

#define D { \
{1, 1, 1, 1, 0}, \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{1, 1, 1, 1, 0} \
}

#define E { \
{1, 1, 1, 1, 1}, \
{1, 0, 0, 0, 0}, \
{1, 1, 1, 1, 1}, \
{1, 0, 0, 0, 0}, \
{1, 1, 1, 1, 1} \
}

#define F { \
{1, 1, 1, 1, 1}, \
{1, 0, 0, 0, 0}, \
{1, 1, 1, 1, 0}, \
{1, 0, 0, 0, 0}, \
{1, 0, 0, 0, 0} \
}

#define G { \
{1, 0, 1, 1, 1}, \
{1, 0, 0, 0, 0}, \
{1, 1, 1, 1, 1}, \
{1, 0, 0, 0, 1}, \
{1, 1, 1, 1, 1} \
}

#define H { \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{1, 1, 1, 1, 1}, \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1} \
}

#define I { \
{1, 1, 1, 1, 1}, \
{0, 0, 1, 0, 0}, \
{0, 0, 1, 0, 0}, \
{0, 0, 1, 0, 0}, \
{1, 1, 1, 1, 1} \
}

#define J { \
{1, 1, 1, 1, 1}, \
{1, 0, 1, 0, 0}, \
{0, 0, 1, 0, 0}, \
{0, 0, 1, 0, 0}, \
{1, 1, 1, 0, 0} \
}

#define K { \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 1, 0}, \
{1, 1, 1, 0, 0}, \
{1, 0, 0, 1, 0}, \
{1, 0, 0, 0, 1} \
}

#define L { \
{1, 0, 0, 0, 0}, \
{1, 0, 0, 0, 0}, \
{1, 0, 0, 0, 0}, \
{1, 0, 0, 0, 0}, \
{1, 1, 1, 1, 1} \
}

#define M { \
{1, 1, 0, 1, 1}, \
{1, 0, 1, 0, 1}, \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1} \
}

#define N { \
{1, 0, 0, 0, 1}, \
{1, 1, 0, 0, 1}, \
{1, 0, 1, 0, 1}, \
{1, 0, 0, 1, 1}, \
{1, 0, 0, 0, 1} \
}

#define O { \
{0, 1, 1, 1, 0}, \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{0, 1, 1, 1, 0} \
}

#define P { \
{1, 1, 1, 1, 1}, \
{1, 0, 0, 0, 1}, \
{1, 1, 1, 1, 1}, \
{1, 0, 0, 0, 0}, \
{1, 0, 0, 0, 0} \
}

#define Q { \
{1, 1, 1, 1, 1}, \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 1, 1}, \
{1, 1, 1, 1, 1} \
}

#define R { \
{1, 1, 1, 1, 0}, \
{1, 0, 0, 0, 1}, \
{1, 1, 1, 1, 0}, \
{1, 0, 0, 1, 0}, \
{1, 0, 0, 0, 1} \
}

#define S { \
{0, 1, 1, 1, 1}, \
{1, 0, 0, 0, 0}, \
{0, 1, 1, 1, 0}, \
{0, 0, 0, 0, 1}, \
{1, 1, 1, 1, 0} \
}

#define T { \
{1, 1, 1, 1, 1}, \
{0, 0, 1, 0, 0}, \
{0, 0, 1, 0, 0}, \
{0, 0, 1, 0, 0}, \
{0, 0, 1, 0, 0} \
}

#define U { \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{1, 1, 1, 1, 1} \
}

#define V { \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{0, 1, 0, 1, 0}, \
{0, 0, 1, 0, 0} \
}

#define W { \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{1, 0, 1, 0, 1}, \
{1, 1, 0, 1, 1}, \
{1, 0, 0, 0, 1} \
}

#define X { \
{1, 0, 0, 0, 1}, \
{0, 1, 0, 1, 0}, \
{0, 0, 1, 0, 0}, \
{0, 1, 0, 1, 0}, \
{1, 0, 0, 0, 1} \
}

#define Y { \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{0, 1, 1, 1, 0}, \
{0, 0, 1, 0, 0}, \
{0, 0, 1, 0, 0} \
}

#define Z { \
{1, 1, 1, 1, 1}, \
{1, 0, 0, 1, 0}, \
{0, 0, 1, 0, 0}, \
{0, 1, 0, 0, 1}, \
{1, 1, 1, 1, 1} \
}

#define blanco { \
{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} \
}

//se declara la variable col2 de tipo intero enicializada en 0
int col2 = 0;
//se declara la variable tiempoEspera de tipo entero inicializada en 150
int tiempoEspera = 150;
//se declara la variable numLetras de tipo entero inicializada en 27
const int numLetras = 27;
//se declara la variable letras de tipo matrix de entero
int letras [numLetras][5][5] = {
  A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,blanco
};

//matrix 5x8
//se declara la variable numCol de tipo entero inicializada en 5
const int numCol = 5;
//se declara la variable numFil de tipo entero inicializada en 8
const int numFil = 8;
//se declara la variable matrixLeds de tipo matrix de entero
int matrixLeds[numFil][numCol];

//filas
//se declara la variable constante fil de tipo vector de entero
const int fil[numFil] = {
  22,23,24,25,26,27,28,29};

//columnas
//se declara la variable constante col de tipo vector de entero inicializada en 5
const int col[numCol] = {
  2, 3, 4, 5, 6};

void setup(){  
  for(int i = 0; i < numFil; i++) {
    //pines de salida
    pinMode(fil[i], OUTPUT);
    //Se apaga el led,
    digitalWrite(fil[i],LOW);
  }

  for(int i = 0; i < numCol; i++) {
    //pines de salida
    pinMode(col[i], OUTPUT);
    //Se apaga el led,
    digitalWrite(col[i],LOW);  
  }
  //comunicacion serial a 9600bps
  Serial.begin(9600);  

  FrequencyTimer2::disable();
  FrequencyTimer2::setPeriod(2000);
  FrequencyTimer2::setOnOverflow(display);  
}

void loop(){  
   if(Serial.available() > 0) {
     byte dato = Serial.read();
     //si el dato esta entre A-Z o a-z
     if((64 < dato && dato < 91) || (96 < dato && dato < 123)){
       //pasamos a mayuscula el caracter
       byte caracterMayuscula = toUpperCase(dato);
       //cargamos el caracter en la matrix matrixLeds
       //y movemos cada pixel de posicion
       moveCharater(caracterMayuscula-65);      
     } else
       //si hay un espacio
       if(dato == 32){
         moveCharater(numLetras-1);
       }
   } else {
     moveCharater(numLetras-1);
   }  
}

void obtenerCaracter(int posicionCaracter){
   int posicion = numFil - temCol;  
   for(int j = 0; j < temFil; j++) {
     for(int i = 0; i < temCol; i++) {
       matrixLeds[i+posicion][temCol-1-j] = letras[posicionCaracter][j][i];      
     }    
  }
}

void siguinteCaracter(int posicionCaracter, int temFila){
  int matrixTem[temFil][temCol];

  for(int i = 0; i < temFil; i++) {
     for(int j = 0; j < temCol; j++) {
       matrixTem[j][4-i] = letras[posicionCaracter][i][j];
     }
  }

  for (int j = 0; j < numCol; j++){
    matrixLeds[numFil-1][j] = matrixTem[temFila][j];
  }
}

void moveCharater(int posicionCaracter){  
  int temFila = 0;

  do{      
    for(int i = 0; i < numCol; i++) {
      for(int j = 0; j < numFil-1; j++) {
        matrixLeds[j][i] = matrixLeds[j+1][i];
      }
    }    
    siguinteCaracter(posicionCaracter, temFila);    
    delay(tiempoEspera);    
   
    temFila++;    
  } while(temFila < numFil);  
}

void display(){  
   digitalWrite(col[col2], HIGH);
   col2++;
   
   if (col2 == 5) {
      col2 = 0;
   }
   for (int row2 = 0; row2 < 8; row2++) {
      if (matrixLeds[row2][col2] == 1) {
         digitalWrite(fil[row2], HIGH);
      }
      else {
         digitalWrite(fil[row2], LOW);
      }
   }
   digitalWrite(col[col2], LOW);
}


                  VÍDEO MÉTODO SHOW


                MÉTODO FRENCUENCY TIMMER