Matriz de LED con Arduino, Deco 74HC138 y Shift Register 74HC595

INTRODUCCIÓN

Una matriz de LED's está compuesta por una serie de diodos LED comunes y corrientes, sin embargo vienen en una sola pieza, puede ser utilizada para representaciones de figuras básicas, o para cualquier otro circuito que necesite dar una indicación visual, vienen de diferentes tamaños y colores, en este caso por medio del decodificador 74HC138 y el Shift Register 74HC595, vamos a controlar la figura que nos representará la matriz de acuerdo al código que realicemos previamente en Arduino.

La figura que vamos a mostrar es la siguiente.

OBJETIVOS

● Implementar el uso de las matrices de LED's

● Programar un código en Arduino para controlar la matriz.

Dispositivos utilizados

Matriz de Led 7x5

Shift Register 75HC595

Decodificador 74HC138

Montaje

Se realizó el montaje de la matriz de LED's teniendo en cuenta los transistores que debían implementarse (PNP para el decodificador y NPN para el shift register), adicional a esto, se llevó un orden adecuado debido a que el circuito se hacía un poco extenso por tantos transistores que debíamos utilizar.

Con base a el datasheet de la matriz de LED's y al esquemático presentado en la guía se realizó el correspondiente montaje:

Debes tener en cuenta que con el decodificador se van a controlar las filas y con el shift register las filas. La configuración para cada una es la siguiente. 

Donde dice GND es la salida del decodificador, ya que sus salidas son con lógica inversa (salidas en estado bajo) y donde dice Vcc son las salidas del shift register debido a que sus salidas son en estado alto.

Al final quedaría el siguiente montaje

Cómo se calcula la resistencia para el LED

Tenemos una malla que cumple la ley de Kirchooff para los voltajes. El voltaje cuando el transistor está en saturación es 0.2V, el voltaje en la resistencia es IR (con I = 15mA) y el voltaje del LED lo ponemos en 1.7V. Por lo tanto tenemos:

5V - 0.2V - 1.7V - I R - 0.2 V = 2.9V - (15mA) R = 0

Despejando R

R = 2.9V15mA = 193.3 Ω

Se escogió una resistencia de 220 Ω

Para calcular la resistencia en la base del transistor

Primero debemos hallar la corriente de la base

Ic=  β Ib -> Ib=Ic/ β

Se escoge un de 100 forzado para que el transistor se sature

Ib = (4*Ic) /  β 

Ib = ( 4* 15mA) / 100

Ib = 0.6 mA

Ahora para hallar la resistencia de base por, teniendo en cuenta que el voltaje en la base es de 0.6V.

Rb = (5V - 0.6V) / (0.6mA) = 7.3KΩ

Utilizando una resistencia de 1K garantizamos que el transistor siga en saturación aunque la corriente en la base aumente un poco.

Código

/*
 *    FIGURA A MOSTRAR
 *     0 0 0 0 0
 *     1 1 1 1 1
 *     0 1 0 1 0
 *     0 1 0 1 0
 *     0 1 0 1 0
 *     0 0 0 0 0
 */

const int latchPin = 8;  // Pin conectado al Pin 12 del 74HC595 (Latch)
const int dataPin  = 9;  // Pin conectado al Pin 14 del 74HC595 (Data)
const int clockPin = 10; // Pin conectado al Pin 11 del 74HC595 (Clock)
const int cPin = 2; //Pin conectado al Pin 3 del 74HC138 (Selección C)
const int bPin = 3; //Pin conectado al Pin 2 del 74HC138 (Seleccoón B)
const int aPin = 4; //Pin conectado al Pin 1 del 74HC138 (Seleccoón A)
int i = 0;

/*Datos a cargar*/
byte f1 = 0b00000000;
byte f2 = 0b00011111;
byte f3 = 0b00001010;
 
void setup() {
  /*Configuración de pines*/
  pinMode(latchPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
  pinMode(cPin, OUTPUT);
  pinMode(bPin, OUTPUT);
  pinMode(aPin, OUTPUT); 

}

void loop() {
  
  switch(i){
    case 0: 
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin, MSBFIRST, f1); //Carga datos al shift register
      /*Selector del decodificdor*/
      digitalWrite(cPin, LOW);  
      digitalWrite(bPin, LOW);
      digitalWrite(aPin, LOW);
      digitalWrite(latchPin, HIGH);
      i++;
    break;
    case 1: 
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin, MSBFIRST, f2);//Carga datos al shift register
      /*Selector del decodificdor*/
      digitalWrite(cPin, LOW);
      digitalWrite(bPin, LOW);
      digitalWrite(aPin, HIGH);
      digitalWrite(latchPin, HIGH);
      i++;
    break;
    case 2: 
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin, MSBFIRST, f3);//Carga datos al shift register
      /*Selector del decodificdor*/
      digitalWrite(cPin, LOW);
      digitalWrite(bPin, HIGH);
      digitalWrite(aPin, LOW);
      digitalWrite(latchPin, HIGH);
      i++;
    break;   
    case 3: 
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin, MSBFIRST, f3);//Carga datos al shift register
      /*Selector del decodificdor*/
      digitalWrite(cPin, LOW);
      digitalWrite(bPin, HIGH);
      digitalWrite(aPin, HIGH);
      digitalWrite(latchPin, HIGH);
      i++;
    break;
    case 4: 
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin, MSBFIRST, f3);//Carga datos al shift register
      /*Selector del decodificdor*/
      digitalWrite(cPin, HIGH);
      digitalWrite(bPin, LOW);
      digitalWrite(aPin, LOW);
      digitalWrite(latchPin, HIGH);
      i++;
    break;
    case 5: 
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin, MSBFIRST, f3);//Carga datos al shift register
      /*Selector del decodificdor*/
      digitalWrite(cPin, HIGH);
      digitalWrite(bPin, LOW);
      digitalWrite(aPin, HIGH);
      digitalWrite(latchPin, HIGH);
      i++;
    break;
    case 6: 
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin, MSBFIRST, f1);//Carga datos al shift register
      /*Selector del decodificdor*/
      digitalWrite(cPin, HIGH);
      digitalWrite(bPin, HIGH);
      digitalWrite(aPin, LOW);
      digitalWrite(latchPin, HIGH);
      i = 0;
    break;    
  }
  delay(1);
}