LETRERO LED PROGRAMABLE

Descripción

Un letrero led hecho con matrices Es un tipo de letrero que vemos mucho en establecimientos comerciales dado a que son muy llamativos debido a su luminosidad  y son muy faciles de hacer Con los letreros LED tienes la posibilidad de comunicar información de impacto de tu empresa, venta de productos o servicios, tales como descuentos, nuevos productos, ofertas, y mucho más. Además, por su alta luminosidad, los letreros LED se visualizan perfectamente tanto de día como de noche, oscuridad y a largas distancias. Los letreros LED utilizan programaciones pueden ser dinámicas, que se ejecutan a través de un software extremadamente fácil de utilizar








Como Funciona

Este proyecto funciona mediante la conexión de 5 matrices led de 8x8  cada una cuenta con 64 bombillos pequeños led y este gracias a su driver Max7219 permite que no necesitemos tantas entradas sino en realidad tres Que son ( Din, Clk, Cs) Y Vcc que se conecta al 5v y gnd que se conecta al tierra, Din ingresan las señales de control del arduino UNO, CS con el cual selecionamos la matriz y decidimos que matriz encenderemos Clk que es el cual controlamos el scrolling y gracias a una multiplexacion logramos que de 16 patas que tiene la matriz y con ayuda del driver solo utilizaremos 3 entradas. 
estas matrices las podemos conectar en cascada si conectamos las matrices paralelamente es decir (vcc-vcc . Gnd-Gnd. Cs-Cs. Clk- Clk. Din-Din) y los textos se transmiten gracias a que los definimos cada letra del alfabeto tanto MAYÚSCULAS y minúsculas mediante codigos binarios que cunado esta en 1 enciende el led y cuando esta en 0 se mantiene apagado .
Y en nuestro caso necesitamos una fuente de alimentación y lo trabajaremos desde un dispositivo móvil con la aplicación arduino droid  y el código nos permite efectuar la luminosidad de los leds, también cuantas matrices queramos utilizar la velocidad del desplazamiento y escribir el mensaje manualmente o mediante bluetooth que en este caso es el Hc-06

B01111110, B00010001, B00010001, B01111110, B00000000, // A Por ejemplo esta parte del código que define la letra A asi que si nosotros ingresamos una letra que no este diseñada binariamente no aparecerá









Materiales

(1) Arduino Uno R3
(1) Bluetooth HC-06
(5) Matriz 8×8
(1) Protoboar 830
(10) Cables jumper Macho – Macho
(25) cables Jumper Hembra – Macho




ARDUINO UNO y CABLE OTG




  JUMPER MACHO MACHO Y MACHO HEMBRA

    


BLUETOOTH HC-06
   CODIGO ARDUINO EN CELULAR

       

Bluetooth HC-06



              MATRIZ LED 8X8 CON DRIVER 
 MAX7219

       


PROTOBOARD




PARA QUE SIRVE

Este proyecto tiene como objetivo demostrar lo efectivos y llamativos que son estos tipos de carteles programables y demostrar que no es muy difícil programar uno de estos solo necesitamos diseñar cada de las posibles letras así obtendremos un texto que queramos y sirve para negocios como de celulares para hacer propaganda para dar información como números de teléfono direcciones etc.

CODIGO


/* Matriz de Desplazamiento LED 8x8

Usando Arduino UNO y el Controlador MAX7219

Libreria: MaxMatrix
Autor: Marcelo Moraes (Brazil)
Por: http://elprofegarcia.com/
Tienda: http://dinastiatecnologica.com/

Conexiones del Arduino al Modulo MAX7219:
ARDUINIO    MAX7219
10          CLK
9           CS
8           DIN
GND         GND
5V          VCC

Conexion  de la cascada de MAX7219(1)  al MAX7219(2)
MAX7219(1)   MAX7219(2) 
  CLK          CLK
  CS           CS
  DOUT         DIN
  GND          GND
  VCC          VCC
La cascada se hace conectano de los pines Superiores a los inferiores del modulo MAX7219
y los modulos se instalan de derecha a izquierda
*/

#include <MaxMatrix.h>
#include <avr/pgmspace.h>

PROGMEM unsigned char const CH[] = {
3, 8, B00000000, B00000000, B00000000, B00000000, B00000000, // space
1, 8, B01011111, B00000000, B00000000, B00000000, B00000000, // !
3, 8, B00000011, B00000000, B00000011, B00000000, B00000000, // "
5, 8, B00010100, B00111110, B00010100, B00111110, B00010100, // #
4, 8, B00100100, B01101010, B00101011, B00010010, B00000000, // $
5, 8, B01100011, B00010011, B00001000, B01100100, B01100011, // %
5, 8, B00110110, B01001001, B01010110, B00100000, B01010000, // &
1, 8, B00000011, B00000000, B00000000, B00000000, B00000000, // '
3, 8, B00011100, B00100010, B01000001, B00000000, B00000000, // (
3, 8, B01000001, B00100010, B00011100, B00000000, B00000000, // )
5, 8, B00101000, B00011000, B00001110, B00011000, B00101000, // *
5, 8, B00001000, B00001000, B00111110, B00001000, B00001000, // +
2, 8, B10110000, B01110000, B00000000, B00000000, B00000000, // ,
4, 8, B00001000, B00001000, B00001000, B00001000, B00000000, // -
2, 8, B01100000, B01100000, B00000000, B00000000, B00000000, // .
4, 8, B01100000, B00011000, B00000110, B00000001, B00000000, // /
4, 8, B00111110, B01000001, B01000001, B00111110, B00000000, // 0
3, 8, B01000010, B01111111, B01000000, B00000000, B00000000, // 1
4, 8, B01100010, B01010001, B01001001, B01000110, B00000000, // 2
4, 8, B00100010, B01000001, B01001001, B00110110, B00000000, // 3
4, 8, B00011000, B00010100, B00010010, B01111111, B00000000, // 4
4, 8, B00100111, B01000101, B01000101, B00111001, B00000000, // 5
4, 8, B00111110, B01001001, B01001001, B00110000, B00000000, // 6
4, 8, B01100001, B00010001, B00001001, B00000111, B00000000, // 7
4, 8, B00110110, B01001001, B01001001, B00110110, B00000000, // 8
4, 8, B00000110, B01001001, B01001001, B00111110, B00000000, // 9
2, 8, B01010000, B00000000, B00000000, B00000000, B00000000, // :
2, 8, B10000000, B01010000, B00000000, B00000000, B00000000, // ;
3, 8, B00010000, B00101000, B01000100, B00000000, B00000000, // <
3, 8, B00010100, B00010100, B00010100, B00000000, B00000000, // =
3, 8, B01000100, B00101000, B00010000, B00000000, B00000000, // >
4, 8, B00000010, B01011001, B00001001, B00000110, B00000000, // ?
5, 8, B00111110, B01001001, B01010101, B01011101, B00001110, // @
4, 8, B01111110, B00010001, B00010001, B01111110, B00000000, // A
4, 8, B01111111, B01001001, B01001001, B00110110, B00000000, // B
4, 8, B00111110, B01000001, B01000001, B00100010, B00000000, // C
4, 8, B01111111, B01000001, B01000001, B00111110, B00000000, // D
4, 8, B01111111, B01001001, B01001001, B01000001, B00000000, // E
4, 8, B01111111, B00001001, B00001001, B00000001, B00000000, // F
4, 8, B00111110, B01000001, B01001001, B01111010, B00000000, // G
4, 8, B01111111, B00001000, B00001000, B01111111, B00000000, // H
3, 8, B01000001, B01111111, B01000001, B00000000, B00000000, // I
4, 8, B00110000, B01000000, B01000001, B00111111, B00000000, // J
4, 8, B01111111, B00001000, B00010100, B01100011, B00000000, // K
4, 8, B01111111, B01000000, B01000000, B01000000, B00000000, // L
5, 8, B01111111, B00000010, B00001100, B00000010, B01111111, // M
5, 8, B01111111, B00000100, B00001000, B00010000, B01111111, // N
4, 8, B00111110, B01000001, B01000001, B00111110, B00000000, // O
4, 8, B01111111, B00001001, B00001001, B00000110, B00000000, // P
4, 8, B00111110, B01000001, B01000001, B10111110, B00000000, // Q
4, 8, B01111111, B00001001, B00001001, B01110110, B00000000, // R
4, 8, B01000110, B01001001, B01001001, B00110010, B00000000, // S
5, 8, B00000001, B00000001, B01111111, B00000001, B00000001, // T
4, 8, B00111111, B01000000, B01000000, B00111111, B00000000, // U
5, 8, B00001111, B00110000, B01000000, B00110000, B00001111, // V
5, 8, B00111111, B01000000, B00111000, B01000000, B00111111, // W
5, 8, B01100011, B00010100, B00001000, B00010100, B01100011, // X
5, 8, B00000111, B00001000, B01110000, B00001000, B00000111, // Y
4, 8, B01100001, B01010001, B01001001, B01000111, B00000000, // Z
2, 8, B01111111, B01000001, B00000000, B00000000, B00000000, // [
4, 8, B00000001, B00000110, B00011000, B01100000, B00000000, // \ backslash
2, 8, B01000001, B01111111, B00000000, B00000000, B00000000, // ]
3, 8, B00000010, B00000001, B00000010, B00000000, B00000000, // hat
4, 8, B01000000, B01000000, B01000000, B01000000, B00000000, // _
2, 8, B00000001, B00000010, B00000000, B00000000, B00000000, // `
4, 8, B00100000, B01010100, B01010100, B01111000, B00000000, // a
4, 8, B01111111, B01000100, B01000100, B00111000, B00000000, // b
4, 8, B00111000, B01000100, B01000100, B00101000, B00000000, // c
4, 8, B00111000, B01000100, B01000100, B01111111, B00000000, // d
4, 8, B00111000, B01010100, B01010100, B00011000, B00000000, // e
3, 8, B00000100, B01111110, B00000101, B00000000, B00000000, // f
4, 8, B10011000, B10100100, B10100100, B01111000, B00000000, // g
4, 8, B01111111, B00000100, B00000100, B01111000, B00000000, // h
3, 8, B01000100, B01111101, B01000000, B00000000, B00000000, // i
4, 8, B01000000, B10000000, B10000100, B01111101, B00000000, // j
4, 8, B01111111, B00010000, B00101000, B01000100, B00000000, // k
3, 8, B01000001, B01111111, B01000000, B00000000, B00000000, // l
5, 8, B01111100, B00000100, B01111100, B00000100, B01111000, // m
4, 8, B01111100, B00000100, B00000100, B01111000, B00000000, // n
4, 8, B00111000, B01000100, B01000100, B00111000, B00000000, // o
4, 8, B11111100, B00100100, B00100100, B00011000, B00000000, // p
4, 8, B00011000, B00100100, B00100100, B11111100, B00000000, // q
4, 8, B01111100, B00001000, B00000100, B00000100, B00000000, // r
4, 8, B01001000, B01010100, B01010100, B00100100, B00000000, // s
3, 8, B00000100, B00111111, B01000100, B00000000, B00000000, // t
4, 8, B00111100, B01000000, B01000000, B01111100, B00000000, // u
5, 8, B00011100, B00100000, B01000000, B00100000, B00011100, // v
5, 8, B00111100, B01000000, B00111100, B01000000, B00111100, // w
5, 8, B01000100, B00101000, B00010000, B00101000, B01000100, // x
4, 8, B10011100, B10100000, B10100000, B01111100, B00000000, // y
3, 8, B01100100, B01010100, B01001100, B00000000, B00000000, // z
3, 8, B00001000, B00110110, B01000001, B00000000, B00000000, // {
1, 8, B01111111, B00000000, B00000000, B00000000, B00000000, // |
3, 8, B01000001, B00110110, B00001000, B00000000, B00000000, // }
4, 8, B00001000, B00000100, B00001000, B00000100, B00000000, // ~
};

int data = 8;    // DIN pin del modulo MAX7219
int load = 9;    // CS pin del modulo MAX7219
int clock = 10;  // CLK pin del modulo MAX7219

int maxInUse = 5;    //Cambie este valor dependiendo del numero de matrices que use

MaxMatrix m(data, load, clock, maxInUse); // Define el modulo

byte buffer[10];


char mensaje1[] = " Electronica "; //Escriba el mensaje a desplegar
char mensaje2[] = " ... ";

void setup(){
  pinMode(8,OUTPUT);       //Conexion a DIN
  pinMode(9,OUTPUT);       //Conexion a CS
  pinMode(10,OUTPUT);      //Conexion a CLK
  m.init();               // inicializa el modulo
  m.setIntensity(2);      // intencidad de los puntos de la matriz, entre 1-5
  Serial.begin(9600);     // inicializa el puerto serial
}

void loop(){
  byte c;
                                  // Lee el mensaje que llega por el puerto serial
  while (Serial.available() > 0){
    byte c = Serial.read();
    Serial.println(c, DEC);
    printCharWithShift(c, 100);
  }
  delay(100);                 // Tiempo de inicio de un nuevo Ciclo de mensajes
  m.shiftLeft(false, true);
 
 
  // Despliega los mensajes almacenados en las variables

  printStringWithShift(mensaje1, 40);       // El ultimo termino se usa para la velocidad del mensaje
  printStringWithShift(mensaje2, 40);

}

void printCharWithShift(char c, int shift_speed){    // Imprime caracteres
  if (c < 32) return;
  c -= 32;
  memcpy_P(buffer, CH + 7*c, 7);
  m.writeSprite(maxInUse*8, 0, buffer);
  m.setColumn(maxInUse*8 + buffer[0], 0);
 
  for (int i=0; i<buffer[0]+1; i++)
  {
    delay(shift_speed);
    m.shiftLeft(false, false);
  }
}

void printStringWithShift(char* s, int shift_speed){        // Imprime cadena de caracteres
  while (*s != 0){
    printCharWithShift(*s, shift_speed);
    s++;
  }
}

void printString(char* s)                            // Imprime cadena
{
  int col = 0;

  {
    if (*s < 32) continue;
    char c = *s - 32;
    memcpy_P(buffer, CH + 7*c, 7);
    m.writeSprite(col, 0, buffer);
    m.setColumn(col + buffer[0], 0);
    col += buffer[0] + 1;
    s++;

  while (*s != 0)

DIAGRAMA
JHOAN SEBASTIÁN YEPES TAPIA 
ANDRES FELIPE CASTAÑEDA  
MANUEL STIVEN PICO ALMANZA

Comentarios