Proyectos!

Gafas Mensajeras

Tiempo de desarrollo: 1 Hora
Accesorios | 2017

¿Quieres ser la mayor sensacion en las fiestas? ¿Deseas impresionar en reuniones? Haz tus propias gafas con mensajes personalizados para expresarte de una manera totalmente diferente.

Descripción:


Este proyecto consiste en un par de matrices de LEDs detrás de unas gafas de sol que muestran el mensaje o mensajes que quieras. El código que programaremos para tu tarjeta Arduino te permite poner cualquier tipo de texto. Antes de empezar, pon a cargar tu power bank para que se encuentre con batería en el momento de utilizarlo. NOTA: Las matrices de LEDs NO son translúcidas, lo que quiere decir que mientras tengas las gafas puestas solo podrás ver en los sitios alrededor de ellas.


Ingredientes:


- Puedes adquirir el kit completo que llegará a la puerta de tu casa:

  • 1 x Kit Smoothie 07

  • - O puedes adquirir cada uno de los componentes, que llegarán a la puerta de tu casa:

  • 1 x Arduino Nano
  • 1 x Power bank
  • 2 x Matriz de LEDs
  • 1 x Jumpers Hembra-Hembra extendido
  • 1 x Gafas de sol de lente grande, foamy (conocido como "fomi" o "papel espumado"), colbón, cartulina negra (incluidos si compras el kit completo).

  • Herramientas:


  • Cinta doble faz
  • Tijeras
  • Computador con puerto USB
  • Marcadores
  • Programa gratuito para computador IDE Arduino (ver tutorial de instalación)

  • Prepara tu Smoothie:


    1

    Consideraciones de seguridad


    Recuerda leer las consideraciones de seguridad antes de empezar cualquier proyecto: (leer)

    2

    Instalación de las librerías


    Antes de cargar un código para programar tu tarjeta Arduino, es necesario que instales las librerías para que éste funcione. Verifica que tienes instalado el programa IDE de Arduino en tu computador. Si no sabes cómo hacerlo, puedes revisar el tutorial de instalación en el siguiente link, que te va a enseñar a hacerlo, paso a paso.

    Para este proyecto, necesitas instalar la librería “MaxMatrix.h” la cual puedes descargar del siguiente link . Si no sabes cómo instalar una librería, sigue el tutorial que podrás encontrar en este link .

    3

    Cargar el código


    Abre el programa para computador IDE de Arduino e inicia un proyecto nuevo. Copia y pega el siguiente código:

    #include <MaxMatrix.h>
    #include <avr/pgmspace.h>
    
    #define maxDisplays 5 // Number of MAX7219's in use.
    
    byte Buf7219[7]; // "width,height,data[5]" single character buffer.
    const int data  = 11;     // DIN or MOSI
    const int load  = 10;     // CS
    const int clock = 13;     // SCK
      
    MaxMatrix m(data, load, clock, maxDisplays);
    // Data array is stored in program memory (see memcpy_P for access).
    // Parameters are width, height, character data...
    // There is a speed improvement for characters with height 8 bits see lib.
    
    PROGMEM const unsigned char CH[] = {
    3, 8, B0000000, B0000000, B0000000, B0000000, B0000000, // space
    1, 8, B1011111, B0000000, B0000000, B0000000, B0000000, // !
    3, 8, B0000011, B0000000, B0000011, B0000000, B0000000, // "
    5, 8, B0010100, B0111110, B0010100, B0111110, B0010100, // #
    4, 8, B0100100, B1101010, B0101011, B0010010, B0000000, // $
    5, 8, B1100011, B0010011, B0001000, B1100100, B1100011, // %
    5, 8, B0110110, B1001001, B1010110, B0100000, B1010000, // &
    1, 8, B0000011, B0000000, B0000000, B0000000, B0000000, // '
    3, 8, B0011100, B0100010, B1000001, B0000000, B0000000, // (
    3, 8, B1000001, B0100010, B0011100, B0000000, B0000000, // )
    5, 8, B0101000, B0011000, B0001110, B0011000, B0101000, // * 
    5, 8, B0001000, B0001000, B0111110, B0001000, B0001000, // +
    2, 8, B10110000, B1110000, B0000000, B0000000, B0000000, // ,
    4, 8, B0001000, B0001000, B0001000, B0001000, B0000000, // -
    2, 8, B1100000, B1100000, B0000000, B0000000, B0000000, // .
    4, 8, B1100000, B0011000, B0000110, B0000001, B0000000, // /
    4, 8, B0111110, B1000001, B1000001, B0111110, B0000000, // 0
    3, 8, B1000010, B1111111, B1000000, B0000000, B0000000, // 1
    4, 8, B1100010, B1010001, B1001001, B1000110, B0000000, // 2
    4, 8, B0100010, B1000001, B1001001, B0110110, B0000000, // 3
    4, 8, B0011000, B0010100, B0010010, B1111111, B0000000, // 4
    4, 8, B0100111, B1000101, B1000101, B0111001, B0000000, // 5
    4, 8, B0111110, B1001001, B1001001, B0110000, B0000000, // 6
    4, 8, B1100001, B0010001, B0001001, B0000111, B0000000, // 7
    4, 8, B0110110, B1001001, B1001001, B0110110, B0000000, // 8
    4, 8, B0000110, B1001001, B1001001, B0111110, B0000000, // 9
    2, 8, B01010000, B0000000, B0000000, B0000000, B0000000, // :
    2, 8, B10000000, B01010000, B0000000, B0000000, B0000000, // ;
    3, 8, B0010000, B0101000, B1000100, B0000000, B0000000, // <
    3, 8, B0010100, B0010100, B0010100, B0000000, B0000000, // =
    3, 8, B1000100, B0101000, B0010000, B0000000, B0000000, // >
    4, 8, B0000010, B1011001, B0001001, B0000110, B0000000, // ?
    5, 8, B0111110, B1001001, B1010101, B1011101, B0001110, // @
    4, 8, B1111110, B0010001, B0010001, B1111110, B0000000, // A
    4, 8, B1111111, B1001001, B1001001, B0110110, B0000000, // B
    4, 8, B0111110, B1000001, B1000001, B0100010, B0000000, // C
    4, 8, B1111111, B1000001, B1000001, B0111110, B0000000, // D
    4, 8, B1111111, B1001001, B1001001, B1000001, B0000000, // E
    4, 8, B1111111, B0001001, B0001001, B0000001, B0000000, // F
    4, 8, B0111110, B1000001, B1001001, B1111010, B0000000, // G
    4, 8, B1111111, B0001000, B0001000, B1111111, B0000000, // H
    3, 8, B1000001, B1111111, B1000001, B0000000, B0000000, // I
    4, 8, B0110000, B1000000, B1000001, B0111111, B0000000, // J
    4, 8, B1111111, B0001000, B0010100, B1100011, B0000000, // K
    4, 8, B1111111, B1000000, B1000000, B1000000, B0000000, // L
    5, 8, B1111111, B0000010, B0001100, B0000010, B1111111, // M
    5, 8, B1111111, B0000100, B0001000, B0010000, B1111111, // N
    4, 8, B0111110, B1000001, B1000001, B0111110, B0000000, // O
    4, 8, B1111111, B0001001, B0001001, B0000110, B0000000, // P
    4, 8, B0111110, B1000001, B1000001, B10111110, B0000000, // Q
    4, 8, B1111111, B0001001, B0001001, B1110110, B0000000, // R
    4, 8, B1000110, B1001001, B1001001, B0110010, B0000000, // S
    5, 8, B0000001, B0000001, B1111111, B0000001, B0000001, // T
    4, 8, B0111111, B1000000, B1000000, B0111111, B0000000, // U
    5, 8, B0001111, B0110000, B1000000, B0110000, B0001111, // V
    5, 8, B0111111, B1000000, B0111000, B1000000, B0111111, // W
    5, 8, B1100011, B0010100, B0001000, B0010100, B1100011, // X
    5, 8, B0000111, B0001000, B1110000, B0001000, B0000111, // Y
    4, 8, B1100001, B1010001, B1001001, B1000111, B0000000, // Z
    2, 8, B1111111, B1000001, B0000000, B0000000, B0000000, // [
    4, 8, B0000001, B0000110, B0011000, B1100000, B0000000, // backslash
    2, 8, B1000001, B1111111, B0000000, B0000000, B0000000, // ]
    3, 8, B0000010, B0000001, B0000010, B0000000, B0000000, // hat
    4, 8, B1000000, B1000000, B1000000, B1000000, B0000000, // _
    2, 8, B0000001, B0000010, B0000000, B0000000, B0000000, // `
    4, 8, B0100000, B1010100, B1010100, B1111000, B0000000, // a
    4, 8, B1111111, B1000100, B1000100, B0111000, B0000000, // b
    4, 8, B0111000, B1000100, B1000100, B0000000, B0000000, // c // JFM MOD.
    4, 8, B0111000, B1000100, B1000100, B1111111, B0000000, // d
    4, 8, B0111000, B1010100, B1010100, B0011000, B0000000, // e
    3, 8, B0000100, B1111110, B0000101, B0000000, B0000000, // f
    4, 8, B10011000, B10100100, B10100100, B01111000, B0000000, // g
    4, 8, B1111111, B0000100, B0000100, B1111000, B0000000, // h
    3, 8, B1000100, B1111101, B1000000, B0000000, B0000000, // i
    4, 8, B1000000, B10000000, B10000100, B1111101, B0000000, // j
    4, 8, B1111111, B0010000, B0101000, B1000100, B0000000, // k
    3, 8, B1000001, B1111111, B1000000, B0000000, B0000000, // l
    5, 8, B1111100, B0000100, B1111100, B0000100, B1111000, // m
    4, 8, B1111100, B0000100, B0000100, B1111000, B0000000, // n
    4, 8, B0111000, B1000100, B1000100, B0111000, B0000000, // o
    4, 8, B11111100, B0100100, B0100100, B0011000, B0000000, // p
    4, 8, B0011000, B0100100, B0100100, B11111100, B0000000, // q
    4, 8, B1111100, B0001000, B0000100, B0000100, B0000000, // r
    4, 8, B1001000, B1010100, B1010100, B0100100, B0000000, // s
    3, 8, B0000100, B0111111, B1000100, B0000000, B0000000, // t
    4, 8, B0111100, B1000000, B1000000, B1111100, B0000000, // u
    5, 8, B0011100, B0100000, B1000000, B0100000, B0011100, // v
    5, 8, B0111100, B1000000, B0111100, B1000000, B0111100, // w
    5, 8, B1000100, B0101000, B0010000, B0101000, B1000100, // x
    4, 8, B10011100, B10100000, B10100000, B1111100, B0000000, // y
    3, 8, B1100100, B1010100, B1001100, B0000000, B0000000, // z
    3, 8, B0001000, B0110110, B1000001, B0000000, B0000000, // {
    1, 8, B1111111, B0000000, B0000000, B0000000, B0000000, // |
    3, 8, B1000001, B0110110, B0001000, B0000000, B0000000, // }
    4, 8, B0001000, B0000100, B0001000, B0000100, B0000000, // ~
    };
    
    void setup()
    {
      m.init();
      m.setIntensity(4); //change brightness
    }
    
    // Scrolling Text
    char string[] = "Smoothie! "; //Texto que quieres mostrar ------
    
    void loop()        //Send text
    {      
      delay(1000);//delay between messages
      m.shiftLeft(false, true);
      printStringWithShift(string,50);   //number is message speed
    
    }
    
    
    // Put text on Display
    void printCharWithShift(char c, int shift_speed)
    {
      if (c < 32) return;
      c -= 32;
      memcpy_P(Buf7219, CH + 7*c, 7);
      m.writeSprite(maxDisplays*8, 0, Buf7219);
      m.setColumn(maxDisplays*8 + Buf7219[0], 0);
    
    
      for (int i=0; i<=Buf7219[0]; i++) 
      {
        delay(shift_speed);
        m.shiftLeft(false, false);
      }
    }
    
    void printStringWithShift(char* s, int shift_speed)
    {
      while (*s != 0)
      {
        printCharWithShift(*s, shift_speed);
        s++;
      }
    } 
    Copiar todo

    Este código guarda en la memoria de la tarjeta Arduino los mensajes que quieres que se muestren en las matrices de LEDs y los muestra en ellas, uno detrás del otro.

    Compila el código y verifica que no haya errores de compilación. Si algún error aparece, asegúrate de copiar el código exactamente como aparece. Conecta tu tarjeta Arduino al computador con el cable USB y sube el código como se explica en el siguiente link.

    Recuerda revisar en la consola del programa IDE de Arduino que no aparezcan errores. ¡Asegúrate de esto antes de avanzar en el proyecto!

    4

    Cambia el mensaje


    En este paso te enseñaremos cómo cambiar el mensaje de tus gafas. Por defecto, tus gafas dicen “Smoothie!”, pero a continuación te mostraremos la forma de cambiarlo.

    Abre la pantalla del programa IDE de Arduino en el que se encuentra el código del proyecto. Para editar el mensaje que trae por defecto tu código, es necesario que primero puedas ver el número de las líneas en el programa de computador IDE de Arduino. Esto te ayudará a encontrar más rápido la sección que debes editar. Para esto, haz click en el menú de “File” y “Preferences” dentro del programa IDE de Arduino, como se muestra en la siguiente imagen:


    Activa la opción de mostrar el número de líneas al seleccionar el recuadro que dice “Display line numbers” y presiona "OK":


    Ahora busca la línea número 121. Deberás encontrar la siguiente sección del código:


    En la línea que dice "char string[] = "Smoothie! ";" cambia la palabra "Smoothie! " por el mensaje que quieras que se muestre en tus gafas. Si quieres que haya más de un mensaje, escribe todos los mensajes separados por tres espacios entre ellos. Verifica que al final de la línea siga existiendo un ";". Compila y sube el programa como se explicó en el paso anterior.

    Cuando modifiques el código, ten cuidado de solo cambiar el pedazo de texto que mencionamos. Si haces otros cambios, ¡el proyecto puede dejar de funcionar!

    5

    Conexión de los elementos


    Lo primero que debes hacer es conectar las 2 matrices de LEDs entre ellas para que la comunicación entre la tarjeta Arduino y las matrices sea correcta. Para esto, debes conectar las matrices con ayuda de los cables jumper como se muestra en la siguiente imagen. Ten en cuenta que los colores de los cables en la imagen son solo un ejemplo. Puedes hacer las conexiones con los colores que desees. Los cables jumpers vienen unidos entre ellos, pero puedes separarlos para que la conexión sea más sencilla. No te asustes si te sobran cables jumpers, ya que algunas veces se incluyen repuestos.


    Si hiciste todo bien, tendrás una fila de dos matrices de LEDs con un inicio (izquierda) y un final (derecha), como se muestra en la anterior imagen. El inicio será el que conectarás a tu tarjeta Arduino.

    Desconecta la tarjeta Arduino del computador y conecta el inicio de tus matrices de LEDs como se muestra en la siguiente imagen utilizando el cable jumper extendido que viene en tu kit. Recuerda verificar los colores en ambos lados del cable cuando hagas las conexiones para evitar conectar algo mal. Ten en cuenta que los colores de los cables en la imagen son representativos. Puedes hacer las conexiones con los colores que desees.


    Antes de seguir, revisa que las conexiones que hiciste correspondan a las siguientes:

  • El pin Vcc de la matriz de LEDs debe estar conectado al pin de 5V de tu tarjeta Arduino.
  • El pin GND de la matriz de LEDs debe estar conectado a uno de los pines GND de tu tarjeta Arduino.
  • El pin DIN de la matriz de LEDs debe estar conectado al pin D11 de tu tarjeta Arduino.
  • El pin CS de la matriz de LEDs debe estar conectado al pin D10 de tu tarjeta Arduino.
  • El pin CLK de la matriz de LEDs debe estar conectado al pin D13 de tu tarjeta Arduino.

  • Si ya verificaste que todo se encuentra en su lugar, es hora de probar que las conexiones funcionen correctamente.

    Conecta el power bank a tu tarjeta Arduino utilizando el cable USB con el que conectaste la tarjeta Arduino a tu computador. Debes ver como una luz se ilumina en tu tarjeta Arduino y las matrices se encienden. Si puedes ver tu mensaje moverse de una matriz a la otra en el orden que deseas, estás listo para pasar al siguiente paso. Si tienes problemas haciendo que tu mensaje se muestre en las matrices de LEDs, consulta la siguiente sección de preguntas frecuentes para solucionar tu problema o contacta a nuestro soporte técnico con tu número de orden y te ayudaremos.

    Preguntas Frecuentes:
    Cuando conecto la tarjeta Arduino al power bank, ninguna luz aparece en mi tarjeta Arduino:

    Si la luz de tu tarjeta Arduino no se enciende, es posible que tengas un problema de alimentación de la tarjeta Arduino. Verifica que tu power bank esté cargado y que éste se encuentre bien conectado al puerto USB de tu tarjeta Arduino. Si esto no soluciona tu problema, intenta conectar directamente la tarjeta Arduino a un puerto USB de tu PC con el cable USB de la tarjeta Arduino. Si tu tarjeta Arduino enciende al conectarla, significa que tu power bank se encuentra descargado. Carga tu power bank para que alimente a tu tarjeta Arduino. Si tu tarjeta Arduino sigue sin encender, es posible que se haya dañado. Contáctanos con tu número de orden para ayudarte a solucionar tu problema.

    Cuando conecto la tarjeta Arduino al power bank, la luz se enciende en mi tarjeta Arduino, pero las matrices de LEDs permanecen apagadas:

    Si la luz de tu Arduino se enciende, pero las matrices de LEDs permanecen apagadas, es posible que tengas un error de conexión entre tu primera matriz de LEDs y la tarjeta Arduino. Verifica que el pin Vcc de tu primera matriz de LEDs se encuentre conectado al pin de 5V de tu tarjeta Arduino, y que el pin GND de la primera matriz de LEDs se encuentre conectado a uno de los pines GND de tu tarjeta Arduino. Revisa que los otros 3 cables se encuentren conectados correctamente. Si tus matrices siguen sin encender, contacta a nuestro soporte técnico con tu número de orden y te ayudaremos a solucionar tu problema.

    Cuando conecto la tarjeta Arduino al power bank, la luz se enciende en mi tarjeta Arduino, pero solo la primera de las matrices de LEDs se enciende.

    Si solo la primera de tus matrices de LEDs se enciende, es posible que las conexiones entre tus matrices se encuentren mal. Si la segunda matriz es la que no enciende, verifica que las conexiones entre tus matrices sean las correctas y que ambas se encuentren en la misma dirección. Verifica que el pin Vcc de la primera matriz de LEDs se encuentre conectado al pin de 5V de tu tarjeta Arduino, y que el pin GND de la primera matriz de LEDs se encuentre conectado a uno de los pines GND de tu tarjeta Arduino. Revisa principalmente las conexiones entre las dos matrices. Si una de tus matrices sigue sin encender, contacta a nuestro soporte técnico con tu número de orden y te ayudaremos a solucionar tu problema.

    Cuando conecto la tarjeta Arduino al power bank, las matrices de LEDs se encienden, pero no se muestra mi mensaje:

    Si las matrices de LEDs se encienden, pero no puedes ver tu mensaje, significa que hay un error en la comunicación de la tarjeta Arduino a tus matrices de LEDs. Verifica las conexiones de los pines DIN, CS y CLK de tus matrices de LEDs de acuerdo a las imágenes que se muestran en el paso de conexiones. Revisa que los cables entre las matrices se encuentren conectados correctamente. Si sigues sin ver tu mensaje, contacta a nuestro soporte técnico con tu número de orden y te ayudaremos a solucionar tu problema.

    Asegúrate de que todo lo que se menciona en este paso funcione antes de seguir con el siguiente. Si tienes dudas o problemas, recuerda que puedes contactarnos en cualquier momento.

    6

    Arma tus gafas


    Pon las gafas sobre la cartulina negra con el lente mirando hacia abajo. Utiliza un lápiz para dibujar el contorno de las gafas. Ésta será tu guía para hacer el diseño que cubra los cables. Alrededor del contorno de las gafas, dibuja dos vasos que sobresalgan por arriba y por abajo en cada uno de los lentes. Debes tener en cuenta de no afectar la zona que queda contra la nariz para que no sea incómodo ponerse las gafas. Recorta el contorno que diseñaste para obtener algo similar a lo que se muestra en la siguiente imagen:


    Utiliza un poco de colbón para adherir tu diseño al contorno de tus gafas. Fíjate que todo se encuentre bien alineado y utiliza pequeñas cantidades de pegamento para que no se dañe la cartulina. Deja que todo se seque muy bien antes de continuar (deja en reposo tus gafas por al menos 15 minutos).

    Mientras tus gafas se secan, recorta dos rectángulos de foamy del tamaño del dorso de las matrices de LEDs y pégalos a las matrices de LEDs con cinta adhesiva. Esto evitará que te hagas daño al momento de colocarte las gafas. Dale la vuelta a tus gafas y ubica las matrices de LEDs sobre los lentes. Asegúrate de que la matriz que se conecta a la tarjeta Arduino quede ubicada en el lente ubicado sobre tu ojo izquierdo, como se muestra en la siguiente imagen:


    Utiliza cinta para ajustar los cables al marco de las gafas de forma que estos no se vean y no te incomoden a la hora de usarlas. Al darle la vuelta a tus gafas, deberán verse similares a las de la siguiente imagen:


    La extensión de cables jumpers tiene como objetivo que puedas guardar la tarjeta Arduino y el power bank en tu bolsillo. Para que el cable no se vea, es necesario que lo adhieras a la pata izquierda de tus gafas, de forma que puedas después hacerlo bajar por tu espalda. Utiliza cinta para adherir el cable a la parte superior de la parte izquierda de tus gafas (si lo adhieres a la parte inferior, te será incómodo utilizar las gafas). Conecta la tarjeta Arduino al power bank con el cable USB y verifica que todo siga funcionando correctamente.

    Si todo sigue funcionando bien, puedes decorar tus gafas. Utiliza marcadores metalizados para repasar el contorno de los vasos y agregar detalles a los mismos. Puedes usar un poco de cartulina blanca para dibujar pitillos y adherirlos a la parte superior de tus gafas. Al terminar, tus gafas deberán verse similares a las de la siguiente imagen:


    Disfruta tus gafas modernas.