sábado, 12 de noviembre de 2016

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

    PROCESSING


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

    No hay comentarios.:

    Publicar un comentario