Proyectos!

Bici-Luces

Tiempo de desarrollo: 40 Minutos
Iluminación | 2017

¿Quieres iluminar tu paso mientras manejas por la ciudad? ¿Deseas aumentar tu visibilidad y tu seguridad? ¡Dale un toque personal a tu bicicleta con imágenes formadas por luces en tus llantas! Haz tus propios diseños, escoge un mensaje o adapta dibujos que ya tengas.

Descripción:


Este proyecto utiliza la frecuencia de encendido y apagado de los LEDs en la cinta de LEDs para crear una imagen cuando las llantas de la bicicleta se encuentran en movimiento. Funciona con un principio llamado persistencia de la visión. Para esto, usaremos un programa que convierte tus imágenes en los datos que tu tarjeta Arduino necesita para hacer funcionar la cinta de LEDs.


Galería:



Ingredientes:


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

  • 1 x Kit Smoothie 08

  • - 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
  • 1 x Cinta de LEDs RGB direccionable
  • 5 x amarraderas plásticas (incluidas si compras el kit completo).

  • Herramientas:


  • Computador con puerto USB
  • Programa gratuito para computador IDE Arduino (ver tutorial de instalación)

  • Prepara tu Smoothie siguiendo el video:


    Prepara tu Smoothie siguiendo los pasos escritos:


    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. Asegúrate de 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.

    Inicia un proyecto nuevo y haz click en ”Sketch”, ”Include library” y ”Manage Libraries...” como se muestra en la siguiente imagen:


    En la pantalla que aparece, escribe la palabra “neopixel” en el buscador y haz click sobre la opción que se llama “Adafruit NeoPixel by Adafruit” (en la imagen aparece como la segunda opción, pero puede estar ubicada en otro orden. Asegúrate de estar seleccionando la correcta). Finalmente haz click en instalar ("install") como se muestra en la siguiente imagen:


    Cuando la barra de progreso desaparezca, haz click en “close” y continúa al siguiente paso.

    3

    Selección de la imagen


    Para que el sistema funcione, es necesario transformar la imagen que vas a mostrar en las llantas de tu bicicleta, en datos que se encuentren en el lenguaje de tu tarjeta Arduino. Para esto, te brindamos un programa para computador que puedes descargar del siguiente link.

    Descomprime la carpeta que descargaste (click derecho en la carpeta convImagenes.zip y click en la opción de "extraer"). Dentro de la carpeta descomprimida, encontrarás los siguientes archivos:


    Haz doble click sobre el archivo que se llama “convert.bat”. Al hacer doble click, es posible que salga una advertencia de seguridad de tu computador. ¡No te preocupes! Nuestro programa es totalmente seguro. Para poder evitar las advertencias, haz lo que se muestra en las siguientes imágenes:


    Después de hacer click en "Más información", te aparecerá el botón de "correr de todas formas":


    Al correr el programa, verás como una pantalla negra aparece con texto de color blanco. Cuando todo se encuentre quieto, presiona cualquier tecla de tu teclado para que la pantalla negra se cierre:


    Una vez desaparece, se ha creado el archivo para utilizar por tu tarjeta Arduino. Si tienes problemas corriendo el programa, consulta nuestra sección de preguntas frecuentes o contacta a nuestro servicio técnico con tu número de orden y te ayudaremos.

    Asegúrate de mantener la carpeta donde se encuentra el programa de convertir imágenes abierta en tu computador a lo largo del siguiente paso.

    4

    Cargar el código


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

    #include <Arduino.h>
    #include <Adafruit_NeoPixel.h>
    typedef uint16_t line_t;
    #include "graphics.h"
    
    #define PINLED  6
    // Parameter 1 = number of pixels in strip
    // Parameter 2 = pin number (most are valid)
    // Parameter 3 = pixel type flags, add together as needed:
    //   NEO_KHZ800  800 KHz bitstream (most NeoPixel products w/WS2812 LEDs)
    //   NEO_KHZ400  400 KHz (classic 'v1' (not v2) FLORA pixels, WS2811 drivers)
    //   NEO_GRB     Pixels are wired for GRB bitstream (most NeoPixel products)
    //   NEO_RGB     Pixels are wired for RGB bitstream (v1 FLORA pixels, not v2)
    
    Adafruit_NeoPixel strip = Adafruit_NeoPixel(60, PINLED, NEO_GRB + NEO_KHZ800);
    
    
    uint32_t lastImageTime = 0L; // Time of last image change
    #ifdef MOTION_PIN
    uint32_t prev          = 0L; // Used for sleep timing
    #endif
    uint8_t  imageNumber   = 0,  // Current image being displayed
             imageType,          // Image type: PALETTE[1,4,8] or TRUECOLOR
            *imagePalette,       // -> palette data in PROGMEM
            *imagePixels,        // -> pixel data in PROGMEM
             palette[16][3];     // RAM-based color table for 1- or 4-bit images
    line_t   imageLines,         // Number of lines in active image
             imageLine;          // Current line number in image
    #ifdef SELECT_PIN
    uint8_t  debounce      = 0;  // Debounce counter for image select pin
    #endif
    
    void imageInit() { // Initialize global image state for current imageNumber
      imageType    = pgm_read_byte(&images[imageNumber].type);
    #ifdef __AVR_ATtiny85__
      imageLines   = pgm_read_byte(&images[imageNumber].lines);
    #else
      imageLines   = pgm_read_word(&images[imageNumber].lines);
    #endif
      imageLine    = 0;
      imagePalette = (uint8_t *)pgm_read_word(&images[imageNumber].palette);
      imagePixels  = (uint8_t *)pgm_read_word(&images[imageNumber].pixels);
      // 1- and 4-bit images have their color palette loaded into RAM both for
      // faster access and to allow dynamic color changing.  Not done w/8-bit
      // because that would require inordinate RAM (328P could handle it, but
      // I'd rather keep the RAM free for other features in the future).
      if(imageType == PALETTE1)      memcpy_P(palette, imagePalette,  2 * 3);
      else if(imageType == PALETTE4) memcpy_P(palette, imagePalette, 16 * 3);
      lastImageTime = millis(); // Save time of image init for next auto-cycle
    }
    
    
    void nextImage(void) {
      if(++imageNumber >= NUM_IMAGES) imageNumber = 0;
      imageInit();
    }
    
    long millisAnt=0;
    
    void setup() {
      // put your setup code here, to run once:
      strip.begin();
      strip.show(); // Initialize all pixels to 'off'
      strip.setBrightness(100);
      strip.setPixelColor(2, 50, 0, 0);
      strip.show();
      imageInit();
    }
    
    void loop() {
      // put your main code here, to run repeatedly:
      
      if(millis()>millisAnt+4000)
      {
        millisAnt=millis();
        nextImage();
      }
      
    
      switch(imageType) {
    
        case PALETTE1: { // 1-bit (2 color) palette-based image
          uint8_t  pixelNum = 0, byteNum, bitNum, pixels, idx,
                  *ptr = (uint8_t *)&imagePixels[imageLine * NUM_LEDS / 8];
          for(byteNum = NUM_LEDS/8; byteNum--; ) { // Always padded to next byte
            pixels = pgm_read_byte(ptr++);  // 8 pixels of data (pixel 0 = LSB)
            for(bitNum = 8; bitNum--; pixels >>= 1) {
              idx = pixels & 1; // Color table index for pixel (0 or 1)
              strip.setPixelColor(pixelNum++,
                palette[idx][0], palette[idx][1], palette[idx][2]);
            }
          }
          break;
        }
    
        case PALETTE4: { // 4-bit (16 color) palette-based image
          uint8_t  pixelNum, p1, p2,
                  *ptr = (uint8_t *)&imagePixels[imageLine * NUM_LEDS / 2];
          for(pixelNum = 0; pixelNum < NUM_LEDS; ) {
            p2  = pgm_read_byte(ptr++); // Data for two pixels...
            p1  = p2 >> 4;              // Shift down 4 bits for first pixel
            p2 &= 0x0F;                 // Mask out low 4 bits for second pixel
            strip.setPixelColor(pixelNum++,
              palette[p1][0], palette[p1][1], palette[p1][2]);
            strip.setPixelColor(pixelNum++,
              palette[p2][0], palette[p2][1], palette[p2][2]);
          }
          break;
        }
    
        case PALETTE8: { // 8-bit (256 color) PROGMEM-palette-based image
          uint16_t  o;
          uint8_t   pixelNum,
                   *ptr = (uint8_t *)&imagePixels[imageLine * NUM_LEDS];
          for(pixelNum = 0; pixelNum < NUM_LEDS; pixelNum++) {
            o = pgm_read_byte(ptr++) * 3; // Offset into imagePalette
            strip.setPixelColor(pixelNum,
              pgm_read_byte(&imagePalette[o]),
              pgm_read_byte(&imagePalette[o + 1]),
              pgm_read_byte(&imagePalette[o + 2]));
          }
          break;
        }
    
        case TRUECOLOR: { // 24-bit ('truecolor') image (no palette)
          uint8_t  pixelNum, r, g, b,
                  *ptr = (uint8_t *)&imagePixels[imageLine * NUM_LEDS * 3];
          for(pixelNum = 0; pixelNum < NUM_LEDS; pixelNum++) {
            r = pgm_read_byte(ptr++);
            g = pgm_read_byte(ptr++);
            b = pgm_read_byte(ptr++);
            strip.setPixelColor(pixelNum, r, g, b);
          }
          break;
        }
      }
    
      strip.show(); // Refresh LEDs
    
      if(++imageLine >= imageLines) imageLine = 0; // Next scanline, wrap around
    } 
    Copiar todo

    Este código analiza los datos correspondientes a la imagen que deseas proyectar y los envía a la cinta de LEDs. Para que la imagen se vea, la tarjeta Arduino hace que los LEDs se prendan y se apaguen rápidamente, de forma que la imagen se cree cuando la bicicleta se encuentre en movimiento.

    Abre la carpeta donde se encuentran los proyectos del programa IDE de Arduino. Usualmente, estos se encuentran dentro de una carpeta llamada “Arduino” dentro de la carpeta correspondiente a “Mis documentos” como se puede ver en la siguiente imagen:


    Crea una carpeta con el nombre “Bicicleta”. Es importante que la primera letra del nombre se encuentre en mayúscula como se muestra en la siguiente imagen:


    En el programa IDE de Arduino, guarda el archivo con el código dentro de la carpeta que creaste:


    Asegúrate de que el archivo que estás guardando tiene el mismo nombre de la carpeta (acuérdate de las letras mayúsculas y minúsculas que utilizaste en el nombre de la carpeta).


    Vuelve a la ventana que dejaste abierta en el paso anterior y busca el archivo que se llama “graphics.h”. Haz click derecho sobre el archivo y escoge la opción de "copiar" como se muestra en la siguiente imagen:


    Pega el archivo dentro de la carpeta donde se encuentra tu código. La carpeta debe verse como se muestra en la siguiente imagen:


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

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

    5

    Conexión de los elementos


    Desconecta la tarjeta Arduino del computador y conecta los elementos como se muestra en la siguiente imagen. Asegúrate de verificar que todo esté bien conectado para evitar que algo no funcione. Ten en cuenta que los colores de los cables en la imagen son representativos. Los cables jumpers de la cinta de LEDs vienen unidos, pero puedes separarlos entre ellos para que la conexión sea más sencilla.


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

  • El pin Vcc de la cinta de LEDs debe estar conectado al pin de 5V de la tarjeta Arduino.
  • El pin GND de la cinta de LEDs debe estar conectado a uno de los pines GND de la tarjeta Arduino
  • El pin Dout de la cinta de LEDs debe estar conectado al pin D6 de la 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 la cinta de LEDs comienza a titilar. Verifica que la cinta de LEDs se comporte de forma similar a como se muestra en el siguiente video:

    Si tu cinta de LEDs se comporta de forma similar al video, estás listo para pasar al siguiente paso, de lo contrario, consulta la siguiente sección de preguntas frecuentes o contacta a nuestro soporte técnico con tu número de orden y te ayudaremos.

    Preguntas Frecuentes:
    Cuando intento correr el programa para convertir imágenes, Windows me advierte de problemas de seguridad:

    Los problemas de seguridad que arroja Windows al intentar correr el programa para convertir imágenes se deben a que Windows no puede detectar al creador de la aplicación. Sin embargo, te aseguramos que todos los programas que desarrollamos en Smoothie se encuentran libres de virus y no representan un riesgo para tu computador. Para correr el programa de convertir imágenes a pesar de las restricciones de Windows, haz click en “más información” y selecciona la opción de “Correr de todas formas”. Si tienes dudas sobre los aspectos de seguridad de nuestro programa, no dudes en contactar a nuestro soporte técnico con tu número de orden y te ayudaremos.

    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 la tarjeta Arduino directamente a un puerto USB del computador. Si tu tarjeta Arduino enciende al conectarla directamente, 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 aparece en mi tarjeta Arduino, pero mi cinta de LEDs no se enciende.

    Si tu cinta de LEDs no enciende, es posible que haya un error en las conexiones entre tu tarjeta Arduino y la cinta de LEDs. Verifica que el pin Vcc de la cinta de LEDs se encuentre conectado al pin de 5V de la tarjeta Arduino, que el pin GND de la cinta de LEDs se encuentre conectado a uno de los pines GND de la tarjeta Arduino, y que el pin Dout de la cinta de LEDs se encuentre conectado al pin D6 de la tarjeta Arduino. Si esto no soluciona tu problema, es posible que el código haya quedado mal cargado a tu tarjeta Arduino. Repite los pasos anteriores del proyecto para verificar que hayas hecho todo correctamente. Si esto no soluciona tu problema, 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

    Cambia las imágenes por las tuyas


    El programa para convertir imágenes viene con dos imágenes predeterminadas: un Nyan cat y una flor de colores. Si deseas cambiar las imágenes, sigue este paso. De lo contrario, puedes pasar al siguiente paso.

    Las imágenes que puedes poner en las llantas de tu bicicleta deben tener una altura predeterminada de 20 pixeles, pero pueden ser tan anchas como quieras (el ancho de la imagen define la velocidad a la que debes andar en la bicicleta para que se vea bien. Más ancha implica una velocidad menor). Tambien deben venir en formato ".gif".

    Las imágenes en tu bicicleta se formarán de acuerdo a la velocidad a la que te muevas y a la velocidad de parpadeo de los LEDs de tu cinta de LEDs. Sin embargo, las imágenes se estarán formando gracias a un movimiento circular, y por tanto, es necesario que transformes cualquier imagen rectangular para compensar las deformaciones provenientes del movimiento circular. En este paso, te mostraremos cómo hacer esto, tomando como ejemplo la imagen del Nyan Cat.

    Comienza por crear un documento nuevo en Paint que sea de 20 pixeles de alto y 240 pixeles de ancho. Este será el documento en el que pongas el resultado de la transformación. puedes ajustar el tamaño de tu imagen en paint haciendo click derecho sobre el fondo, como se muestra en la siguiente imagen:


    Ahora, selecciona la imagen que desees utilizar para pintar en tus llantas. Abre un documento en PowerPoint y ubica tu imagen junto con la plantilla que puedes descargar en el siguiente link. Deberás obtener algo similar a lo que se muestra en la siguiente imagen:


    Es importante que la totalidad de la imagen se encuentre por dentro del círculo más grande, pues éste representará el rin de tu bicicleta. Regresa al documento de Paint y habilita la opción de ver la cuadrícula. Deberá verse de la siguiente forma:


    En el documento de Paint, la fila superior corresponderá al centro de tu imagen, y la línea inferior al exterior de tu imagen. Cada uno de los 20 pixeles que hay en vertical, corresponderán a los 20 espacios que hay entre los círculos, y cada 10 píxeles en horizontal corresponderán a los 24 trozos de la cuadrícula circular. Por ejemplo, en el caso del Nyan Cat, los primeros 10 píxeles del documento en Paint deben ser de color rosado debido al color del primer trozo del círculo más pequeño, como se muestra en la siguiente imagen:


    Los siguientes 10 pixeles hacia la derecha corresponderán al segundo trozo del círculo más pequeño, como se muestra en la siguiente imagen:


    Sigue repitiendo el proceso, y poco a poco ve llenando todos los cuadros. Por ejemplo, estos son los primeros del nyan-cat:


    Continúa haciendo esto hasta que hayas terminado la transformación. En el caso del Nyan Cat, deberá verse similar a la siguiente imagen:


    Puedes realizar este proceso con tus propias creaciones. Usa tu creatividad! Existen millones de posibilidades para que crees diseños propios y únicos.

    Cuando termines, selecciona en paint "Guardar como", y guarda tu imagen como una "Imagen GIF". Este formato es requerido para que todo funcione correctamente. Los pasos se muestran en la siguiente imagen:


    Recuerda, puedes modificar el ancho del rectángulo como quieras (para ajustarlo a la velocidad de tu bicicleta), pero no puedes variar la altura. Una vez hayas finalizado tu diseño, guárdalo en la carpeta que se llama “imagenes” en formato ".gif" que se encuentra dentro de la carpeta principal del programa para convertir imágenes como se muestra en la siguiente imagen:


    En la carpeta de “imagenes" puedes poner todas las imágenes que quieras que se muestren en las llantas de tu bicicleta. Éstas se mostrarán una detrás de la otra. Repite los pasos 3 y 4 de este proyecto para actualizar las imágenes en tu tarjeta Arduino.

    Ten cuidado de no cambiar el alto de la imagen a algo distinto a 20 pixeles. También asegúrate de que el formato de la imagen sea ".gif" o el programa no podrá convertir la imagen.

    7

    Arma el sistema


    Escoge la llanta en la que quieras ubicar tu sistema de luces (te sugerimos la llanta delantera, por facilidad). Empieza por adherir el extremo de la cinta de LEDs que no tiene cables a la zona más lejana de tu llanta con ayuda de las amarraderas plásticas. Asegúrate de que queda bien fija y se vea como se muestra en la siguiente imagen:


    Continúa fijando la cinta de LEDs hacia el centro de la bicicleta con ayuda de las amarraderas plásticas. Debes dejar al menos 2 amarraderas plásticas para el resto del sistema. Amarra los cables entre ellos para que no se enreden o desconecten y adhiérelos a la llanta de la bicicleta. Ubica la tarjeta Arduino y el powerbank por detrás de la cinta de LEDs y ajústalos a la llanta de la bicicleta haciendo uso de las amarraderas plásticas. Al terminar, tu llanta deberá verse similar a la siguiente imagen:


    Cuando estés ubicando los elementos al interior de tu llanta, ten en cuenta que la posición de los elementos no puede impedir la rotación de la misma.

    Si quieres usar las luces en días lluviosos, te recomendamos ubicar los componentes dentro de una bolsa resellable para evitar que entren en contacto con el agua. Recuerda que todo excepto la cinta de LEDs (que ya es impermeable) debe quedar dentro de la bolsa. Sin embargo, ten en cuenta que si el sistema completo no queda bien sellado, se pueden ocasionar daños en los componentes. Puedes hacer algo similar a lo que se muestra en la siguiente imagen:


    Termina de ubicar todo al interior y recuerda ubicar los componentes uno cerca de otros. Cuando termines, puedes salir a estrenar tu nuevo proyecto.


    Disfruta tu nueva bicicleta modificada.