LABORATORIO #11

DESCRIPCIÓN

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.

MATERIALES DEL LABORATORIO 

-Computador con el IDE de Arduino y el driver de nuestra placa

- Arduino Uno
- Protoboard

- Matriz LED MAX7219

- Cables Macho - Macho

MATERIALES DEL LABORATORIO 

DIAGRAMAS

PROTOBOARD

FOTOS MATERIALES Y MONTAJE

CÓDIGO

ARDUINO

1. /*
2. ********** Arduino **********
3. */
5. #include <LedControl.h>
6. //array matrix que contiene la informacion para pintar los caracteres validos en la matrix led
7. byte letras [][5] = {{B01111100, B00010010, B00010001, B00010010, B01111100},//A
8.                     {B01000001, B01111111, B01001001, B01001001, B00110110},//B
9.                     {B00111110, B01000001, B01000001, B01000001, B00100010},//C
10.                     {B01000001, B01111111, B01000001, B01000001, B00111110},//D
11.                     {B01111111, B01001001, B01001001, B01001001, B01000001},//E
12.                     {B01111111, B00001001, B00001001, B00000001, B00000001},//F
13.                     {B00111110, B01000001, B01001001, B01001001, B00111010},//G
14.                     {B01111111, B00001000, B00001000, B00001000, B01111111},//H
15.                     {B01000001, B01000001, B01111111, B01000001, B01000001},//I
16.                     {B00100000, B01000000, B01000000, B00111111, B00000001},//J
17.                     {B01111111, B00001000, B00010100, B00100010, B01000001},//K
18.                     {B01111111, B01000000, B01000000, B01000000, B01000000},//L
19.                     {B01111111, B00000010, B00000100, B00000010, B01111111},//M
20.                     {B01111111, B00000010, B00000100, B00001000, B01111111},//N
21.                     {B01111110, B00000101, B00001001, B00010001, B01111110},//Ñ
22.                     {B00111110, B01000001, B01000001, B01000001, B00111110},//O
23.                     {B01111111, B00001001, B00001001, B00001001, B00000110},//P
24.                     {B00111110, B01000001, B01010001, B00100001, B01011110},//Q
25.                     {B01111111, B00001001, B00011001, B00101001, B01000110},//R
26.                     {B00100110, B01001001, B01001001, B01001001, B00110010},//S
27.                     {B00000001, B00000001, B01111111, B00000001, B00000001},//T
28.                     {B00111111, B01000000, B01000000, B01000000, B00111111},//U
29.                     {B00000111, B00011000, B01100000, B00011000, B00000111},//V
30.                     {B01111111, B00100000, B00011000, B00100000, B01111111},//W
31.                     {B01100011, B00010100, B00001000, B00010100, B01100011},//X
32.                     {B00000111, B00001000, B01110000, B00001000, B00000111},//Y
33.                     {B01000001, B01100001, B01010001, B01001001, B01000111},//Z
34.                     {0x00, 0x82, 0xff, 0x80, 0x00},//1
35.                     {0xc2, 0xa1, 0x91, 0x89, 0x86},//2
36.                     {0x81, 0x81, 0x85, 0x8b, 0x71},//3
37.                     {0x18, 0x14, 0x12, 0xff, 0x00},//4
38.                     {0x8f, 0x89, 0x89, 0x89, 0x71},//5
39.                     {0x7c, 0x8a, 0x89, 0x89, 0x70},//6
40.                     {0x01, 0xf1, 0x09, 0x05, 0x03},//7
41.                     {0x76, 0x89, 0x89, 0x89, 0x76},//8
42.                     {0x06, 0x89, 0x89, 0x89, 0x7e },//9
43.                     {B01111110, B11100001, B10011001, B10000111, B01111110}//O
44.                     };
45. //------------------------------------------------------------------------------------------------
46. //Se inicializa la varialbe que controla la matrix led
47. LedControl matrix = LedControl(12,11,10,1);
48. //variable que tendra la palabra a mostrar
49. String palabra = "";
50. //array que contiene los caracteres valido a mostrar
51. char caracteres [] = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'ñ', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
52.                       'w', 'x', 'y', 'z', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0'};
54. void setup() {
55.   // put your setup code here, to run once:
56. //se inicializa el puerto serial
57.   Serial.begin(9600);
58. //se enciende los leds
59.   matrix.shutdown(0, false);
60. //se asigna la intencidad de los leds
61.   matrix.setIntensity(0, 1);
62. //se borra cualquier cosa que haya estado pintada previamente
63.   matrix.clearDisplay(0);      
64. }
66. void loop() {
67.   // put your main code here, to run repeatedly:
68.   obtenerCaracter();
69. }
71. //metodo que lee las palabras enviadas por el serial
72. void obtenerCaracter(){
73. //se valida si hay informacion en el Serial
74.   if(Serial.available()){
75. //se lee toda la cada de caracteres enviada
76.     palabra = Serial.readString();
77.   }
78.   for(int i = 0; i < palabra.length(); i++){
79.     for(int j = 0; j < sizeof(caracteres); j++){
80. //se lee cada caracter y se valida para su impresion en la matrix led
81.       if(palabra.charAt(i) == caracteres[j]){
82.           imprimirCaracter(letras[j]);
83.       }
84.     }
85.   }
86. }
87. //metodo que imprime la matrix led el caracter enviado por parametro
88. void imprimirCaracter(byte elemento[]){
89.   for(int j = 8; j > -8; j--){
90.     for(int i = 0; i < 5; i++){
91. //se encienden los led que corresponde al caracter solicitado
92. //moviendolo de izquierda a derecha
93.       matrix.setRow(0, j+i, elemento[i]);
94.       delay(15);
95. //se apagan los led's de la fila anterior
96. //para generar el efecto de movimiento
97.       matrix.setRow(0, j+6, 0x00);
98.     }
99.   }
100. }

PROCESSING

1. /*
2. ********** Arduino **********
3. */
4. import controlP5.*;
5. import processing.serial.*;
7. Serial puerto;
8. ControlP5 ventana;
9. String alerta = "";
10. //Array con los caracteres validos
11. char caracteres [] = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'ñ', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
12.                       'w', 'x', 'y', 'z', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', ' '};
14. void setup(){
15.   //variable que se usa para configurar el campo de texto
16.   PFont fuente = createFont("arial", 25);
17.   //se define el tamaño de la ventana
18.   size(500, 300);
19.   //se valida si es posible crear una instancia del puerto serial
20.   //y configura la variable que controlara el puerto
21.   try{
22.     //String portName = Serial.list()[0];
23.     String portName = Serial.list()[1];
24.     puerto = new Serial(this, portName, 9600);
25.   }
26.   catch(Exception e){
27.     //si hay un error se muestra una lista de los puertos disponibles
28.    //println(Serial.list());
29.    //printArray(Serial.list());
30.   }
31.   //se inicliza la variable acargo del contenido de la ventana
32.   ventana = new ControlP5(this);
33.   //se agrega un campo de texto
34.   ventana.addTextfield("", 50, 25, 400, 40)
35.          .setColor(color(255))
36.          .setFont(fuente)
37.          .setFocus(true);
38.    //se define la fuente para los mensajes de la ventana
39.   textFont(fuente);
40. }
42. void draw(){
43.   //se asigna un color de fondo negro
44.   background(147);
45.   //se muestra un texto de alerta (si hay alguna)
46.   fill(255,0,4);
47.   text(alerta, 50, 180);
48.   fill(255);
49.   text("Digite la palabra o la cadena de\npalabras sin espacios",50,100);
50. }
52. void controlEvent(ControlEvent e){
53.   //se obtiene el valor del campo de texto
54.   String palabra = e.getStringValue();
55.   //se valida que el evento se haya detonado por un elemento
56.   //de la ventana
57.   if(e.isController()){
58.     //se verifica que la palabra no tenga ningun caracter invalido
59.     if(validarPalabra(palabra)){
60.       //se envia la palabra en minusculas por el puerto serial
61.         puerto.write(palabra.toLowerCase());
62.         //se borra el mensaje de alerta (si lo hay)
63.         alerta = "Envió: '"+palabra+"'";
64.     }
65.     else{
66.       //se muestra el mensaje de alerta con la palabra invalida
67.       alerta = "'" + palabra + "' \nNo es un válido\nRevise si los caracteres son validos.";
68.     }
69.   }
70. }
71. //metodo que se encarga de validar la palabra digitada
72. boolean validarPalabra(String palabra){
73.   //variable que cuenta la cantidad de caracteres validos
74.   int validacion = 0;
75.   //se eliminan los espacios al inicio y al fin de la palabra Y se combierte a minuscula
76.   palabra = palabra.trim().toLowerCase();
78.   //se recorre la palabra digitada caracter por caracter
79.   for(int i = 0; i < palabra.length(); i++){
80.     //se recorre el array de caracteres validos
81.     for(int j = 0; j < caracteres.length; j++){
82.       //se valida un caracter de la palabra digitada es igual a un caracter valido
83.       if(palabra.charAt(i) == caracteres[j]){
84.         //se cuenta un caracter valido
85.           validacion++;
86.       }
87.       //se valida si hay espacios vacios dentro de la palabra digitada
88.       if(palabra.charAt(i) == ' ')
89.           validacion++;
90.     }
91.   }
92.   print(validacion);
93.   print("-");
94.   println(palabra.length());
95.   //se valida si la cantidad de caracteres validos es igual a la cantidad
96.   //de caracteres de la palabra digitada
97.   if(validacion != palabra.length())
98.     return false;
99.   else
100.     return true;
101. }