El Famoso CUBO LED Descripción del proyecto :

El Famoso CUBO LED
Nombre 1
Nombre 2
Descripción del proyecto :
Controlar 64 ledes del cubo con tan solo 20 pines de la placa de arduino,
utilizando una técnica denominada multiplexación, y crear un espectáculo de
luces, para ello rompemos el cubo en cuatro capas separadas, por lo que sólo
necesitamos pines de control para 16 ledes, de modo que para encender un led
especí fico, debemos activar tanto la capa y el pin de control , que nos da una
necesidad total de 16 +4 pines.
Cada capa tiene un cátodo común, la parte negativa del circuito así que todas
las patas negativas se unen entre sí , y se conecta a un solo pin para esa capa .
Antecedentes
El primer Led.
Nick Holonyak inventó el led en 1962 mientras trabajaba como cientí fico en un
laboratorio de General Electric en Syracuse (Nueva York). Un led (del acrónimo
inglés LED, light-emitting diode: ‘diodo emisor de luz’; el plural aceptado por la
RAE es ledes) es un componente opto electrónico pasivo y más concretamente,
un diodo que emite luz.
Arte Led
Es una forma de arte con luz construida a partir de diodos, los ledes son muy
baratos y se han convertido en una nueva forma de hacer arte en la calle, y son
utilizados en instalaciones de arte, piezas escultóricas y obras de arte
interactivas. Las ventajas de los ledes es que presentan muchas ventajas sobre
las fuentes de luz incandescente y fluorescente, principalmente por el bajo
consumo de energía, mayor tiempo de vida, tamaño reducido, durabilidad,
resistencia a las vibraciones, reducen la emisión de calor, no contienen mercurio
(el cual al exponerse en el medio ambiente es altamente venenoso), en
comparación con la tecnología fluorescente no crean campos magnéticos altos
como la tecnología de inducción magnética, con los cuales se crea mayor
radiación residual hacia el ser humano; cuentan con mejor índice de producción
cromática que otros tipos de luminarias, reducen ruidos en las líneas eléctricas,
son especiales para utilizarse con sistemas fotovoltaicos (paneles solares), en
comparación con cualquier otra tecnología actual, no les afecta el encendido
intermitente, (es decir pueden funcionar como luces estroboscópicas) y esto no
reduce su vida promedio, son especiales para sistemas antiexplosión ya que
cuentan con un material resistente, y en la mayoría de los colores (a excepción
de los ledes azules), cuentan con un alto nivel de fiabilidad y duración.
CODIGO ARDUINO:
Fuente del codigo: Tecnosalva.com
#include <avr/pgmspace.h> // allows use of PROGMEM to store patterns in flash
#de fine CUBESIZE 4
#de fine PLANESIZE CUBESIZE*CUBESIZE
#de fine PLANETIME 3333 // time each plane is displayed in us -> 100 Hz refresh
#de fine TIMECONST 20 // multiplies DisplayTime to get ms - why not =100?
// LED Pattern Table in PROGMEM - last column is display time in 100ms units //
TODO this could be a lot more compact but not with binary pattern
representation prog_uchar PROGMEM PatternTable[] = { // blink on and off
B0001,B0000,B0000,B0000,B0001,B0000,B0000,B0000,B0000,B0000,B0000,B
0000,B0000,B0 000,B0000,B0000,10,
B0011,B0000,B0000,B0000,B0011,B0000,B0000,B0000,B0000,B0000,B0000,B
0000,B0000,B0 000,B0000,B0000,10,
B0011,B0010,B0000,B0000,B0011,B0010,B0000,B0000,B0000,B0000,B0000,B
0000,B0000,B0 000,B0000,B0000,10....
// this is a dummy element for end of table (duration=0) aka !!!DO NOT TOUCH!!!
B0000, B0000, B0000, B0000, B0000, B0000, B0000, B0000, B0000, B0000,
B0000, B0000, B0000, B0000, B0000, B0000, 0 };
/* ** De fining pins in array makes it easier to rearrange how cube is wired **
Adjust numbers here until LEDs flash in order - L to R, T to B ** Note that analog
inputs 0-5 are also digital outputs 14-19! ** Pin DigitalOut0 (serial RX) and
AnalogIn5 are left open for future apps */
int LEDPin[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}; int PlanePin[] =
{16, 17, 18, 19};
// initialization void setup() { int pin; // loop counter // set up LED pins as output
(active HIGH) for (pin=0; pin<PLANESIZE; pin++) { pinMode( LEDPin[pin],
OUTPUT ); } // set up plane pins as outputs (active LOW) for (pin=0;
pin<CUBESIZE; pin++) { pinMode( PlanePin[pin], OUTPUT ); } }
// display pattern in table until DisplayTime is zero (then repeat) void loop() { //
declare variables byte PatternBuf[PLANESIZE]; // saves current pattern from
PatternTable int PatternIdx; byte DisplayTime; // time*100ms to display pattern
unsigned long EndTime; int plane; // loop counter for cube refresh
int patbu fidx; // indexes which byte from pattern buffer int ledrow; // counts LEDs
in refresh loop int ledcol; // counts LEDs in refresh loop int ledpin; // counts LEDs
in refresh loop
// Initialize PatternIdx to beginning of pattern table PatternIdx = 0; // loop over
entries in pattern table - while DisplayTime>0 do { // read pattern from
PROGMEM and save in array memcpy_P( PatternBuf, PatternTable+PatternIdx,
PLANESIZE ); PatternIdx += PLANESIZE; // read DisplayTime from PROGMEM
and increment index DisplayTime = pgm_read_byte_near( PatternTable +
PatternIdx++ ); // compute EndTime from current time (ms) and DisplayTime
EndTime = millis() + ((unsigned long) DisplayTime) * TIMECONST;
// loop while DisplayTime>0 and current time < EndTime while ( millis() <
EndTime ) { patbu fidx = 0; // reset index counter to beginning of buffer // loop
over planes for (plane=0; plane<CUBESIZE; plane++) { // turn previous plane off
if (plane==0) { digitalWrite( PlanePin[CUBESIZE-1], HIGH ); } else
{ digitalWrite( PlanePin[plane-1], HIGH ); }
// load current plane pattern data into ports ledpin = 0; for (ledrow=0;
ledrow<CUBESIZE; ledrow++) { for (ledcol=0; ledcol<CUBESIZE; ledcol++)
{ digitalWrite( LEDPin[ledpin++], PatternBuf[patbu fidx] & (1 << ledcol) ); }
patbu fidx++; }
// turn current plane on digitalWrite( PlanePin[plane], LOW ); // delay
PLANETIME us delayMicroseconds( PLANETIME ); } // for plane } // while
<EndTime } while (DisplayTime > 0); // read patterns until time=0 which signals
end }
Comunicando Arduino con Processing;
controlando cubo de led .
Al no ser posible la aleatoriedad porque los pines Rx y Tx los está utilizando
para comunicarse Processing con arduino, lo hemos resuelto de la siguiente
forma: conectando la señal de dos pines en otros dos, así la probabilidad de que
cada uno de los ledes brille ya no es uniforme y el efecto es muy similar. Para
realizarlo hemos conectando el ejemplo de la biblioteca Standard Firmata, que
es un protocolo genérico para comunicarse con los microcontroladores , y el
siguiente archivo que he creado en processing .
FALSA ALEATORIEDAD
Processing
import org. firmata.*;
import cc.arduino.*;
import processing.serial.*;
import cc.arduino.*;
Arduino arduino;
void setup()
{
size(470, 200);
println(Arduino.list());
arduino = new Arduino(this, Arduino.list()[2], 57600);
int pin;
for(pin=2;pin<16; pin++)
{
arduino.pinMode(pin,arduino.OUTPUT);
arduino.digitalWrite(pin,arduino.LOW);
}
for(pin=16;pin<20;pin++)
{
arduino.pinMode(pin,arduino.OUTPUT);
arduino.digitalWrite(pin,arduino.HIGH);
}
}
void draw()
{
int pin = int(random(2,16));
int altura = int(random(16,20));
arduino.digitalWrite(pin,arduino.HIGH);
arduino.digitalWrite(altura,arduino.LOW);
delay(30);
arduino.digitalWrite(pin,arduino.LOW);
arduino.digitalWrite(altura,arduino.HIGH);
}
Tareas y Objetivos:
El objetivo de este proyecto ha sido familiarizarnos con los medios electrónicos,
su construcción, entendimiento físico y el funcionamiento de sus distintos
componentes electrónicos y su interconexión, e investigar como trabajar con
universos led para lanzar vídeo, desde programas de mezcla de vídeo en
tiempo real que solemos utilizar para nuestro trabajo : Madmapper 1.6, Modul8
2.7, Resolume Arena, entre otros, utilizando protocolos , DMX y Art-net.
El objetivo era tener una primera toma de contacto combinando un circuito
electrónico con ledes, que es controlado por un software especí fico , en este
caso con Processing.