Laboratorio 11

Laboratorio 11.
Descripción del Laboratorio

El objetivo del siguiente laboratorio es el de Enviar desde una interfaz en Processing; el mensaje que deseamos para que se visualice en una matriz LED 8x8 (desplazándose de izquierda a derecha) a través del integrado IC MAX7219 y el control se dará a través de arduino.

Lista de los Elementos utilizados

Computador con el IDE de Arduino y Processing

Tarjeta Arduino

Cable USB; COM5

Protoboard

Cables macho-macho

IC MAX 7219

Matriz LED 8x8

Diagrama del Montaje en la Protoboard

Diagrama Esquemático del Circuito

Proceso del Montaje paso a paso (Fotos)

Código Fuente en Arduino (con comentarios)

/********** Proyecto **********
 * Universidad Santiago de Cali
 * Angelica maria campo
 * Laboratorio 11: Envio de mensajes utilizando processing y se visualiza en Matriz LED
 * Descripcion: Mostrar un mensaje desplazándose de izquierda
 * a derecha en una matriz LED 8x8 a través de IC MAX7219 enviado
 * desde un Arduino, usando una interfaz en Processing.*/

 /********** Librerías **********/
 #include <LedControl.h>



/********** Variables **********/
// se nombran las variables y sus respectivos pines

//se inicializa la variable data_in en el PIN 9
int data_in = 9;
 //se inicializa la variable clock en el PIN 7
int clock = 7;
//se inicializa la variable CS en el PIN 8
int cs = 8;  

String texto = "ABCDE abcde 01234 ";

/********** Objetos **********/

//se instacia un objeto de ledControl para utilizar los PINES
LedControl lc = LedControl(data_in, clock, cs, 1);  

// Tiempo que esperamos entre las actualizaciones del display * /

 unsigned long delaytime = 100;

/********** Configuración **********/
 void setup() {
//comunicacion serial sera a 9600 baudios y pines inicializados con sus estados
  Serial.begin(9600);

 //El MAX72XX está en modo de ahorro de energía en el arranque,
   //tenemos que llamadarlo para encenderlo  */

  lc.shutdown(0, false);
  // se Establece e brillo del display.
  lc.setIntensity(0, 8);

//Se encarga de limpiar el Display/
  lc.clearDisplay(0);
}
// Se crea el arreglo necesario para las letras en mayuscula, minusculas y números.

byte letras[63][5] = { {B11111110, B00010001, B00010001, B00010001, B11111110}, //A

  {0xFF, 0x89, 0x89, 0x89, 0x76},//B

  {B01111110, B10000001, B10000001, B10000001, B01000110}, //C

  {0xff, 0x81, 0x81, 0x81, 0x7e},//D
  {0x7e, 0x89, 0x89, 0x89, 0x89},//E
  {0xff, 0x09, 0x09, 0x09, 0x01},//F
  {0x7e, 0x89, 0x89, 0x89, 0xf2},//G
  {0xFF, 0x18, 0x18, 0x18, 0xff}, //H

  {B00000000, B10000100, B11111101, B10000000, B00000000}, //I

  {0x71, 0x81, 0x7f, 0x01, 0x01},//J
  {0xff, 0x10, 0x2c, 0x42, 0x81},//K
  {0x7f, 0xc0, 0x80, 0x80, 0x80}, //L
  {0xff, 0x06, 0x0c, 0x06, 0xff},//M

  {B11111111, B00000100, B00001000, B00010000, B11111111}, //N
  {B01111110, B10000001, B10000001, B10000001, B01111110}, //O

  {0xff, 0x09, 0x09, 0x09, 0x06},//P
  {0xbe, 0x41, 0xA1, 0x81, 0x7e}, //Q

  {B11111111, B00010001, B00110001, B01010001, B10001110}, //R

  {0x86, 0x89, 0x89, 0x89, 0x71},//S
  {0x01, 0x01, 0xff, 0x01, 0x01},//T

  {B01111111, B11000000, B11000000, B11000000, B01111111}, //U

  {0x3f, 0x40, 0x80, 0x40, 0x3f},//V
  {0x7f, 0x80, 0x70, 0x80, 0x7f},//W
  {0xe3, 0x14, 0x08, 0x14, 0xe3},//X
  {0x03, 0x04, 0xf8, 0x04, 0x03},//Y
  {0xe1, 0x91, 0x89, 0x85, 0x83},//Z
  {0xd68, 0xd94, 0xd94, 0xd78, 0xd80},//a
  {0xdfc, 0xd60, 0xd90, 0xd90, 0xd60},//b
  {0xd78, 0xd84, 0xd84, 0xd84, 0x48},//c
  {0xd60, 0xd90, 0xd90, 0xd60, 0xdfc},//d
  {0x78, 0x94, 0x94, 0x94, 0x58},//e

   {B11111100, B00100100, B00100100, B00000100, B00000100},//f
  {B00001000, B10010100, B10010100, B10110100, B01001000},//g
  {B11111100, B00100000, B00010000, B00010000, B11100000},//h
  {B00000000, B00000000, B11110100, B00000000, B00000000},//i
  {B10000000, B10000000, B01110100, B00000000, B00000000},//j
  {B11111100, B00100000, B01010000, B10001000, B00000000},//k
  {B00000000, B00000000, B11111100, B10000000, B00000000},//l
  {B11111100, B00001000, B11110000, B00001000, B11110000},//m

  {0x78, 0x94, 0x94, 0x94, 0x58},//n
  {0x78, 0x94, 0x94, 0x94, 0x58},//o
  {0x78, 0x94, 0x94, 0x94, 0x58},//p
  {0x78, 0x94, 0x94, 0x94, 0x58},//q
  {0x78, 0x94, 0x94, 0x94, 0x58},//r
  {0x78, 0x94, 0x94, 0x94, 0x58},//s
  {0x78, 0x94, 0x94, 0x94, 0x58},//t
  {0x78, 0x94, 0x94, 0x94, 0x58},//u
  {0x78, 0x94, 0x94, 0x94, 0x58},//v
  {0x78, 0x94, 0x94, 0x94, 0x58},//w
  {0x78, 0x94, 0x94, 0x94, 0x58},//x
  {0x78, 0x94, 0x94, 0x94, 0x58},//y
  {0x78, 0x94, 0x94, 0x94, 0x58},//z

  {B01111110, B11100001, B10011001, B10000111, B01111110}, //O

  {0x00, 0x82, 0xff, 0x80, 0x00}, //1
  {0xc2, 0xa1, 0x91, 0x89, 0x86},//2
  {0x81, 0x81, 0x85, 0x8b, 0x71}, //3
  {0x18, 0x14, 0x12, 0xff, 0x00}, //4
  {0x8f, 0x89, 0x89, 0x89, 0x71},//5
  {0x7c, 0x8a, 0x89, 0x89, 0x70},//6
  {0x01, 0xf1, 0x09, 0x05, 0x03}, //7
  {0x76, 0x89, 0x89, 0x89, 0x76},//8
  {0x06, 0x89, 0x89, 0x89, 0x7e }, //9

  {0x80, 0x00, 0x80, 0x00, 0x80 } // tres puntos
};

/********** Ciclo Principal **********/

 // Este método mostrará los caracteres para el
 //palabra que enviemos uno tras otro en la matriz.*//

void writeArduinoOnMatrix(String mensajea)
{
 // se escriben los datos de los caracteres//

  for (int j = 0; j < mensajea.length(); j++) {
    int pos = 0;
    char ch = mensajea.charAt(j);
 
    if (ch >= 'A' && ch <= 'Z') pos = ch - 'A';
    else if (ch >= 'a' && ch <= 'z') pos = ch - 'a' + 26;
    else if (ch >= '0' && ch <= '9') pos = ch - '0' + 52;
    else pos = 62;
 
    palabras(letras[pos]);
  }
}

void palabras(byte listd[])
{   for (int j = 7; j > -4; j--)
{    for (int i = 4; i > -1; i--) { lc.setRow(0, j + i, listd[i]); }
 
    delay(delaytime);
 
    for (int o = 0; o < 8 ; o++) {
      lc.setRow(0, o, 0);
    }
  }
}
//Método que recibe la cadena de texto y la escribe en la matriz.

void loop() {  writeArduinoOnMatrix(texto);}

/********** Funciones **********/

//método  que se encuentra pendiente de las instrucciones que vienen del processing.

void serialEvent() {
while (Serial.available()) {
texto = Serial.readString();
  }
}

/********** Fin ***********/

Código Fuente en Processing (con comentarios)


/********** Proyecto **********
 * Universidad santiago de cali
 * Angelica maria campo mancilla.
 * Laboratorio 11: Enviar desde una interfaz en Processing un mensaje a una matriz LED 8x8
 (desplazándose de izquierda a derecha) a través de IC MAX7219.*/

/************* Librerias *********/

// Importamos las librerías de ControlP5 y Serial

import processing.serial.*;  // Importamos la librería Serial

import controlP5.*;   // Importamos librería ControlP5

//********* Objetos ********//

// Se Definen las variables necesarias

ControlP5 cp5;                  // Creamos la variable para ControlP5
Serial serial;                  // Creamos la variable para el puerto Serial

String texto = "";              // se inicializa string para leer
                                // del Textfield

//**** variables*****//

 // Areglos para las variables necesarias//
                               
int colorDeFondo = color (300,200,400); // Da el color que deseamos al Fondo de la interfase

//***********configuracion*********************//
// Solo se ejecuta una vez, al iniciar el Sketch//


void setup() {                  // Inicio config

  size(300, 150);               // Tamaño de la Ventana
  PFont font =
    createFont("comic sans",25);     // Fuente usada en la ventana

  cp5 = new ControlP5(this);    // Creamos el objeto de ControlP5

  Textfield field =             // Creamos los objetos Textfield...
     cp5.addTextfield("input")  // determinando sus propiedades...
     .setPosition(25,50)        // posicion
     .setSize(250,40)           // tamaño
     .setFont(font)             // fuente
     .setFocus(true)            // foco
     .setColor(color(294,0,100))// Color de fondo
     ;
   
  // Creamos el objeto del puerto Serial
  serial =                
     new Serial(this, Serial.list()[0], 9600);}

// se dibujar cada frame de escritura y se asigna el color de fondo

void draw()
{  {background(colorDeFondo);}

  String s = "Ingrese el texto"; // se escribe un mensaje para la
                                 // parte superior de la caja de texto
  fill(100);                     // este es el color del texto
  text(s, 95, 20, 250, 100);     // se determina el texto escrito y posicion
}
// actua cuando ocurra un evento, es decir cuando se escriba alguna palabra.

void controlEvent(ControlEvent evento) {
                                 // Cuando ocurra un evento, aquí lo procesamos
                                 // Obtenemos el string escrito dentro
                               
  String mensaje = evento.getController().getStringValue();
  serial.write(mensaje);         // enviamos el String via serial
  println(mensaje);              // //Imprimimos en la consola, para ver que todo va Ok
}



//********** Fin *************//

Video del Funcionamiento