Fibonacci encubierto

Como nunca logré entender como controlar cada conjunto de 4 leds como un pixel, experimenté con el sketch de otro manera.

 Cambié todos los valores de 0 por los valores de la serie de Fibonacci para ver como se comportaba la animación que originalmente se veía así: Después de agregar la numeración hasta 1597 la animación se detuvo y sólo obtuve una imagen fija: Pero cada que agregaba una cifra de la serie iba probando y estos fueron los resultados:

un mar y unas estrellas

prueba de imagen sin movimiento y papel de arroz para difuminar. 

Este círculo se supone que sería amarillo, necesito un acrílico para que los colores se unan. Ahora que ya se como "dibujar" en la placa, me enfocaré en los movimientos.



Esta es una imagen que use para trazar unas montañas (su tamaño esta aumentado 100%) Originalmente la imagen es de 24 x 24 pixeles

Peggy 2 es un ojo

El tablero va a funcionar como un ojo, para esto tengo que convertir la imagen en reconocible a través de los tres colores luz primarios.
El primer paso es encontrar la manera de convertir estas formas que me interesan en tres canales de color.


En el sketch que me permite hacer animación las imágenes están en código hexadecimal. Este código funciona con 14 dígitos 0 1 2 3 4 5 6 7 8 9 A B C D E.  Pero sólo convierte imágenes a un canal, ósea en blanco y negro.  Necesito encontrar una forma de convertir imagen en código hex separando los 3 canales (r,g, b) e indicar la posición en la placa.


unsigned int frames = 3;

prog_uint32_t datastore[] PROGMEM  = {
 0 , 0 , 0 , 0 , 0 , 0 , 53248 , 36800 , 33824 , 32776 , 
 16386 , 0 , 1 , 0 , 8192 , 0 , 0 , 0 , 4098 , 8 , 
 1056 , 576 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 
 0 , 0 , 0 , 0 , 0 , 114688 , 16384 , 24576 , 8256 , 4160 , 
 8064 , 4096 , 4096 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 
 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 
 0 , 57344 , 130048 , 24320 , 256 , 8192 , 8192 , 0 , 4096 , 0 , 
 4096 , 4096 , 0 , 0 , 0
};


En este código están codificados 3 frames, cada 25 cifras es uno de ellos. Son 25 filas de información porque la imagen tiene 25 x 25 pixeles. La información que se carga en la placa esta acomodada por arrays.

Ya que en mi tablero tengo,
 blanco - rojo -blanco -roj
verde- azull - verde -azul
Una solución sería guardar la misma imagen de ( 12 x 12 ) dos veces, una con el canal rojo solamente y otra con la info de los canales verde y azul. Acomodarlos alternando estos códigos. Esto parece lógico pero aun tengo que intentarlo, de cualquier forma sería una solución muy rústica y no se aprovecharían otras posibilidades como hacer degradados.

Para conseguir el código hexadecimal de una imagen estoy utilizando la terminal de ubuntu

sudo od -x /file.bmp 

 tamaño original 12 x 12 pixeles

Hex data del canal rojo:

0000000 4d42 01cc 0000 0000 0000 001a 0000 000c

0000020 0000 000c 000c 0001 0018 0000 0000 0000
0000040 d2d2 ffd2 ffff ffff ffff ffff ffff ffff
0000060 ffff ffff ffff ffff d2d2 00d2 0000 0000
0000100 0000 0000 fafa fffa ffff ffff ffff ffff
0000120 ffff ffff ffff ffff ffff ffff f9f9 00f9
0000140 0000 0000 0000 0000 d2d2 ffd2 ffff ffff
0000160 ffff ffff ffff ffff ffff ffff ffff ffff
0000200 d2d2 00d2 0000 0000 0000 0000 9090 ff90
0000220 ffff ffff ffff ffff ffff ffff ffff ffff
0000240 ffff ffff 9191 0091 0000 0000 0000 0000
0000260 2e2e b62e b6b6 ffff ffff ffff ffff ffff
0000300 ffff ffff b6ff b6b6 2d2d 002d 0000 0000
0000320 0000 0000 0000 2e00 2e2e 9191 d291 d2d2
0000340 fafa d2fa d2d2 9191 2e91 2e2e 0000 0000
0000360 0000 0000 0000 0000 0000 0000 0000 0000
*
0000700 0000 0000 0000 0000 0000 0000
0000714

Hex data del canal verde:

0000000 4d42 01cc 0000 0000 0000 001a 0000 000c

0000020 0000 000c 000c 0001 0018 f3f3 f3f3 f3f3
0000040 fcfc fffc ffff ffff ffff ffff ffff ffff
0000060 ffff ffff ffff ffff fdfd f3fd f3f3 f3f3
0000100 f3f3 f3f3 ffff ffff ffff ffff ffff ffff
0000120 ffff ffff ffff ffff ffff ffff ffff f4ff
0000140 f4f4 f3f3 f3f3 f3f3 fcfc fffc ffff ffff
0000160 ffff ffff ffff ffff ffff ffff ffff ffff
0000200 fdfd f4fd f4f4 f4f4 f4f4 f4f4 f9f9 fff9
0000220 ffff ffff ffff ffff ffff ffff ffff ffff
0000240 ffff ffff f8f8 f3f8 f3f3 f3f3 f4f3 f4f4
0000260 f5f5 fbf5 fbfb ffff ffff ffff ffff ffff
0000300 ffff ffff fbff fbfb f5f5 f4f5 f4f4 f3f3
0000320 f3f3 f3f3 f3f3 f5f3 f5f5 f9f9 fdf9 fdfd
0000340 ffff fdff fdfd f9f9 f5f9 f5f5 f3f3 f4f3
0000360 f4f4 f4f4 f4f4 f4f4 f4f4 f3f4 f3f3 f3f3
0000400 f3f3 f3f3 f3f3 f4f3 f4f4 f3f3 f3f3 f3f3
0000420 f4f4 f4f4 f4f4 f3f3 f3f3 f3f3 f3f3 f3f3
0000440 f3f3 f3f3 f3f3 f3f3 f3f3 f4f3 f4f4 f4f4
0000460 f3f4 f3f3 f4f4 f3f4 f3f3 f4f4 f4f4 f4f4
0000500 f4f4 f4f4 f4f4 f3f3 f3f3 f3f3 f4f4 f3f4
0000520 f3f3 f4f4 f3f4 f3f3 f3f3 f4f3 f4f4 f4f4
0000540 f3f4 f3f3 f3f3 f4f3 f4f4 f4f4 f4f4 f4f4
0000560 f3f3 f4f3 f4f4 f4f4 f4f4 f4f4 f4f4 f3f4
0000600 f3f3 f3f3 f3f3 f3f3 f4f4 f4f4 f4f4 f3f3
0000620 f4f3 f4f4 f4f4 f3f4 f3f3 f3f3 f3f3 f3f3
0000640 f3f3 f4f3 f4f4 f3f3 f3f3 f3f3 f4f4 f3f4
0000660 f3f3 f3f3 f3f3 f3f3 f3f3 f3f3 f3f3 f3f3
0000700 f4f3 f4f4 f4f4 f3f4 f3f3 0000
0000714

Hex data del canal azul:

0000000 4d42 01cc 0000 0000 0000 001a 0000 000c

0000020 0000 000c 000c 0001 0018 ffff ffff ffff
0000040 4d4d 004d 0000 0000 0000 0000 0000 0000
0000060 0000 0000 0000 0000 4d4d ff4d ffff ffff
0000100 ffff ffff 0707 0007 0000 0000 0000 0000
0000120 0000 0000 0000 0000 0000 0000 0707 ff07
0000140 ffff ffff ffff ffff 4d4d 004d 0000 0000
0000160 0000 0000 0000 0000 0000 0000 0000 0000
0000200 4d4d ff4d ffff ffff ffff ffff 9999 0099
0000220 0000 0000 0000 0000 0000 0000 0000 0000
0000240 0000 0000 9999 ff99 ffff ffff ffff ffff
0000260 e7e7 70e7 7070 0000 0000 0000 0000 0000
0000300 0000 0000 7100 7171 e6e6 ffe6 ffff ffff
0000320 ffff ffff ffff e6ff e6e6 9999 4d99 4d4d
0000340 0606 4c06 4c4c 9999 e799 e7e7 ffff ffff
0000360 ffff ffff ffff ffff ffff ffff ffff ffff
*
0000700 ffff ffff ffff ffff ffff 0000
0000714

Después de realizar experimentos con la información hexadecimal,  me estoy dando cuenta que este método no funciona  porque tengo los focos azules y verdes en la fila. 

----------------------------------------------------------------------------------------------------------------------

Un array es un medio de guardar un conjunto de objetos de la misma clase.

Percepción - FORMAS SIMPLICIDAD , mente

Los paneles de leds rgb son muy conocidos, últimamente podemos verlos con publicidad por toda la ciudad. Éstos son bastante grandes y tienen una muy buena resolución pues son de miles de pixeles por cada lado. Aunque podría parecer que me estoy complicando en vano, el punto de este proyecto es hacer un uso sencillo de estas herramientas. Es importante mantener la simplicidad en la técnica, estoy tratando con formas y colores  "básicos" para comprender mejor el proceso perceptivo.

Electrónica lista

La siguiente fase fue agregar los LEDS restantes. Con los leds de los cuatro colores ensamblados,  pude hacer una tercera prueba de funcionamiento.

               

Los LEDS no están soldados al tablero por lo que puedo moverlos de lugar cuantas veces necesite. Los sockets comunican a los LEDS con la electrónica impresa del tablero. El tablero tiene entrada para 625 leds. 

Estoy utilizando 150 LEDS de cada color aproximadamente. Blanco, rojo, azul y verde

     
                 
                




Esta son algunas pruebas realizadas antes de completar el tablero.

Para representar cada punto como un pixel, planeaba utilizar LEDS RGB. Estos leds están compuestos de leds de colores primarios: rojo (red), verde (green) y azul (blue), el variar la intensidad de cada led permite producir toda la gama de colores hasta el blanco que es la suma de estos tres. Este tipo de led necesita 4 entradas para poder controlarlos. En este caso sólo puedo utilizar leds sencillos ya que la entrada del tablero es sólo de dos orificios. Esto quiere decir que cada punto del tablero sería de un color fijo.

La solución para crear un pixel que pueda cambiar de color es programar 4 LEDS (r,g,b,w) como una unidad. El resultado será tablero de 12 x 12 pixeles con 576 LEDS en total.

   Sencillo circuito para probar leds por                     separado.

 Una posibilidad para generar más espectros de color es agregando una pantalla de acrílico sobre los LEDS.

       



 

Segunda prueba de programación

Para programar este tablero existen métodos que combinan Processing, que funciona como interfaz gráfica y Arduino, que permite cargar la programación en el microcontrolador. Varios desarrolladores han creado librerías para controlar este dispositivo. Todos estos recursos son abiertos y modificables.

En la segunda prueba utilicé una librería llamada PeggyDraw2. Ésta es una aplicación de Processing que permite hacer animaciones sencillas dibujando sobre una cuadrícula de 25 x 25 puntos. La animación se guarda automáticamente como programa de Arduino listo para cargar en el tablero. Esta herramienta me permitió experimentar con formas simples en movimiento.

 -------------------------------------------------------------------------------------------------------------

Processing es un software libre creado por Casey Reas y Ben Fry que utiliza un lenguaje de programación orientado a creadores audiovisuales basado en Java.

PeggyDraw 2. Es una librería construida en Processing, open source y adaptabe creada por Windell H Oskay de Evil Mad Scientist Laboratories, y Matt Mets, de http://cibomahto.com.

Todos las librerías para controlar Peggy2 se encuentran en el depositorio de los creadores: https://code.google.com/p/peggy/downloads/list

Primera prueba de programación

En la primera prueba de programación experimenté con BMP2PEG. La aplicación permite convertir imágenes bitmap (formato .bmp) a un formato de sketch para  Arduino. La imagen utilizada no puede superar los 25 x 25 pixeles ya que es el espacio disponible físicamente en el tablero, aquí cada LED representa un pixel. Para ejecutarlo se corre el programa desde la terminal y se le administran los datos de la dirección donde se encuentra la imagen (input) y la dirección de salida (output) donde se creará el nuevo documento listo para guardar en la placa.
Con esta aplicación hice pruebas con formas geométricas básicas sin movimiento.  

 

Esta aplicación me funciona a medias pues me interesa generar movimiento, además el mapa de bits que crea no tiene definición de colores. La idea es que se reproduzcan figuras geométricas en movimiento y a color, como pequeños fragmentos a detalle de una composición. 

--------------------------------------------------------------------------------------------------------------

Un  mapa de bits o bitmap es una estructura que representa una rejilla rectangular de pixeles que se puede visualizar en un monitor u otro dispositivo de representación.

Ensamble PEGGY2

El primer paso para la realización de mi tablero de leds fue conseguir los componentes. Conseguí un kit para construir una placa que controla LEDS a través de una compañía de hardware abierto.  Evil Mad Scientist desarrollaron un proyecto open source llamado Peggy2.

Peggy2 es una placa emisora de luz que funciona a base de LEDS. Esta placa será el display donde reproduciré imágenes geométricas cargadas en un microcontrolador que manda funciones a los LEDS. El tablero puede ser alimentada por medio de baterias o corriente directa.

Una vez conseguidos los materiales, el primer paso fue soldar todos los componentes a la placa.

Los elementos que lo componen son: 

- Placa con circuito impreso de 28.8 x 37.8 cm

- Controlador ATmega328P

- Transistores y resistencias

- LED drivers

- Fuente de alimentación

 

Peggy2 puede ser programada a través de Arduino, ya que utiliza el mismo tipo de controlador que este software, a través de un cable FTDI USB-TTL.

Las posibilidades que ofrece esta placa van desde programar una imagen estática y colocar sólo los LEDS necesarios, reproducción de animaciones o convertirlo en un objeto interactivo.

Para soldar los componentes a la placa necesité:

1. Soldadura y un cautin

2. Pinzas para cortar

3. Masking tape para fijar los componentes

Una vez soldados todos los componentes, la placa terminó así:

LEDS y persistencia retiniana

Me gustaría hacer algo así en una peggy 2, que

es un board de leds como este:

¿Qué es un led?

The Peggy2 is technically a one color display (the color of the LEDs). However, it can display varying levels of brightness with a bit of programming. The Peggy2 hardware is limited to displaying 16 levels of brightness. It is possible to write a program that displays more than 16 levels, but it will result in an unstable display. The LEDs will shimmer and not appear to be steadily illuminated.
In an image file, or on a computer screen, shades of gray are colors just like any other color like red or blue. So, it is valid to refer to shades of gray as colors. An image file that contains only shades of gray is referred to as a grayscale image. The Peggy2 can display grayscale images. The shades of gray in the image file correspond to levels of brightness on the Peggy2. BMP2PEG automatically converts full-color images to grayscale.
The Peggy2 does not have an explicit brightness level, nor does it simply turn LEDs on or off. It actually sends a brief jolt of electricity to each LED and illuminates it for a fraction of a second. By repeating the jolts very quickly, the LEDs appear to be on. This phenomenon is called persistence of vision. By varying the frequency of jolts of electricity to an LED, the Peggy2 can vary the brightness. An LED that gets more jolts per second appears brighter than LEDs getting fewer jolts per second. In this way, each LED on the Peggy2 can be a different level of brightness.

Alternativas

Por ahora existen varias alternativas sobre como llevar acabo el proyecto antes mencionado. Mi idea original era mecanizar las perillas de la pantalla mágica 'etch a sketch' y darle como instrucción trazar la ecuación de la espiral logarítmica. Sin embargo, todo parece indicar que esta solución es la menos factible y lo menos adecuado en cuestiones estéticas dado el tamaño de la pantalla a modificar.

Así que una solución viable es sustituir la pantalla del juguete por una pantalla digital. Estas son algunas opciones contempladas:

Eink: La tinta electrónica es una tecnología que permite crear pantallas planas delgadas como papel y que tienen flexibilidad. Actualmente se utilizan en lectores de e-books y el desarrollo de esta tinta se debe a razones ecologistas.

Las pantallas están formadas por tres capas, una con microtransmisores eléctricos, otra con el polímero y la tercera con una lámina protectora. En el polímero encontramos una matriz de millones de cápsulas que están flotando en un gel que permite que sean estimuladas electromagnéticamente. Mediante esta estimulación cada cápsula pasa a mostrar su cara blanca o negra, de manera que en la pantalla se representa un texto o gráfico.

Kindle, el lector ebooks de amazon utiliza esta tecnología controlada por drivers EPSON

Tablet Archos: