IDN by Physalia
Entropía, medida del desorden termodinámico e incertidumbre existente ante un conjunto de mensajes. Entropía es muerte térmica, e inevitable declive y degenaración social. En un sistema cerrado, entropía es una medida del caos.
2000 fotografías componen esta pieza; es decir, 2000 gotas de agua perfectas sobre un fondo animado cuadro a cuadro. Gotas que se parecen de manera inquietante en la fase de menor entropía, y que se vuelven más y más desordenadas al salpicar.
Cuando recibimos la propuesta de IdN para crear una formación exclusiva de logo pensamos, como de costumbre, que nos gustaría desarrollar y probar un nuevo sistema. Esto nos llevó a pensar en la forma de una pieza de estas características: corta, con algún tipo de animación para la formación del logo. Quisimos encontrar un vehículo para este tipo de formato que lo respetase pero que, a la vez, lo tratase de forma distinta.
Aunque el fondo proyectado cuadro a cuadro en las gotas que caen sea una animación de fluidos en 3D, el resultado final de la pieza que acabas de ver no tiene ningún tipo de imagen generada por ordenador, y fue fotografiada cuadro a cuadro para permitirnos proyectar dentro de la gota la formación de logo, previamente animada en 3D e impresa en papel, que fuimos subsituyendo a medida que la gota caía. Hay 320 impresiones en la pieza, y el vídeo final lo componen alrededor de 2000 fotografías, lo que quiere decir que cada gota que ves nunca es la misma, son 2000 gotas distintas. Para poder fotografiar cada gota en el lugar exacto y llegar a ver una caída fluida, creamos un sistema basado en Arduino en el que, tras cruzar cada gota el haz de luz de un puntero láser, supiésemos con precisión el momento en el que disparar los flashes para captarla en el momento deseado. Trabajamos muy duro para sincronizar este mecanismo con nuestra Motion Control, y el resultado final es fruto de tres semanas de pruebas en las que rodamos 45 caídas con más de 20000 fotos tomadas, todo antes de llegar al resultado final.
Inspiración y referencias
Hacía tiempo que conocíamos algunos experimentos con luz estroboscópica y gotas de agua que nos parecieron muy interesantes. Hay multitud de ejercicios de este tipo en youtube y vimeo. Una de las etiquetas con las que podemos encontrarlos es buscando “time fountain”:
Su funcionamiento es muy fácil de entender: una luz parpadea a una determinada frecuencia que, al coincidir con la cadencia de un goteo constante de cualquier fluido, da la sensación de que la gota está suspendida en el aire. En realidad lo que está pasando es que a cada parpadeo de la luz percibimos una gota de agua distinta, pero en la misma posición. Estos parpadeos son casi imperceptibles puesto que el ojo humano no es lo suficientemente rápido como para detectar que entre parpadeo y parpadeo hay un espacio de tiempo a oscuras lo suficientemente largo como para que la segunda gota se desplace hasta el lugar adecuado. Este efecto de captar una determinada frecuencia de imágenes y percibirlas con continuidad es ampliamente conocido y estudiado, y se conoce como persistencia retiniana. Gracias a él, existen el cine y la televisión.
En todos los montajes de este tipo, las gotas caen y se comportan con normalidad. Lo que decidimos, utilizando una luz estroboscópica controlada, es qué momentos ver y cuáles no. Otras tantas instalaciones similares son capaces de regular este parpadeo con lo que podemos crear la ilusión de que la gota asciende lentamente, se frena o avanza a cámara lenta. Por otro lado, también encontramos una referencia importantísima para nuestra pieza. Descubrimos al fotógrafo alemán, Markus Reugels, y su excelente trabajo sobre la fotografía de fluidos fue una clarísima inspiración para nuestro video.
Water drop by Markus Reugels
El ejemplo anterior no es sólo una foto técnicamente brillante, sino que combina a mi entender dos elementos artísticos muy interesantes. Por un lado la propia naturaleza caótica, delicada y esférica de la gota de agua en contraste con los patrones blancos y negros de corte geométrico, que permiten apreciar la distorsión en la refracción del fondo. A su vez, el patrón de ajedrez-damas (también llamado checkerboard) es un elemento muy común y fácilmente asociable al mundo del 3d ya que se utiliza para comprobar los defectos del texturizado de un objeto tridimensional.
En definitiva, si fuésemos capaces de crear un sistema electrónico capaz de detectar el paso de una gota de agua con precisión, podríamos reproducir su caída combinando fotos consecutivas de gotas de agua distintas. Sin necesidad de sistemas carísimos ni cámaras especiales de alta velocidad, obtendríamos el mismo efecto con una simple cámara digital réflex y un par de flashes. Sólo tendríamos que realizar fotos incrementales a las gotas de agua y esperar que se comportasen de manera similar.
Cómo no, fieles a nuestros experimentos, había que rizar el rizo:
¿Y si el fondo refractado en la gota no fuese estático, sino una secuencia de imágenes animadas impresas?
¿Seguimos a una gota de agua mientras cae y a su vez vemos una animación refractada en su interior?
Lo tenemos!
Planteamiento
Necesitamos un sistema capaz de disparar una cámara en función del paso de una gota de agua. A su vez, debería ser capaz de coordinar el movimiento de cámara, el enfoque del objetivo y permitir disparar fotos con incrementos tan pequeños como unas decenas de microsegundos.
1. Medir el paso de la gota: el láser-fotodiodo
Existen varias maneras de detectar una gota pasando por un sensor. Barreras infrarrojas, láser… En nuestro caso, optamos por utilizar un puntero láser al que añadimos un pequeño interruptor para hacer más fácil el encenderlo o apagarlo.
Fotodiodo y láser
A su vez, investigamos el componente electrónico más rápido para medir la interrupción de una barrera láser. Entre células LDR, fototransistores y otros componentes capaces de medir variaciones de luz, optamos por utilizar un fotodiodo. Después de hacer algunas pruebas, le añadimos algunas resistencias en paralelo para que no fuera tan sensible y sólo le afectara la interrupción del láser, y no las variaciones de luz ambiental. Este pequeñísimo circuito es suficiente para que el fotodiodo se comporte como un interruptor digital devolviendo 5 voltios al estar el láser incidiendo sobre el fotorreceptor y 0 voltios al pasar una gota que interrumpe la luz. A su vez, colocamos un trozo de cinefoil (una especie de papel de aluminio color negro mate utilizado en fotografía) perforado con una aguja para hacer aún más pequeño el haz láser que impacta sobre el fotodiodo y, por tanto, más preciso al paso de una gota de agua.
2. Disparando los flashes
Llevamos años disparando cámaras de fotos digitales utilizando optoacopladores. Sin pensarlo, conectamos un flash (algo antiguo) a la salida de un optoacoplador (4n28) y probamos a dispararlo con el Arduino… Flash!, funciona! Y al siguiente disparo, NO. Decidimos cambiar el chip: flash! Funcionaaa! A la segunda, ya no. Así una y otra y otra hasta que nos quedamos sin optoacopladores (mejor dicho, hasta quemarlos todos). Al investigar el error, nos enteramos de que algunos flashes, sobre todo los antiguos, son capaces de generar picos de tensión de 300v o más. Por esto, decidimos utilizar el circuito que se detalla en el esquemático del *Photoduino*, y funcionó sin problemas a la primera.
Disparador flashes
El problema entonces fue que, con sólo dos flashes, nos resultaba realmente complicado iluminar el recorrido de la gota. O se sobreexponían las primeras fotos y el impacto salía oscuro, o al revés. Fue por esto por lo que decidimos alquilar dos flashes más para intentar reiluminar la escena. La primera foto que tomamos con los cuatro flashes reveló un error que no pudimos resolver. Al tratarse de flashes distintos, sus circuitos internos tenían también un retardo distinto. Encontramos que los dos flashes más modernos eran unos milisegundos más lentos que los que ya teníamos.
Doble exposición causada por la falta de sincronismo entre flashes
Aunque intentamos programar un pequeño retraso para compensar el problema, no solventamos la doble exposición de la foto. Quizás ajustando los microsegundos hubiéramos podido arreglarlo, pero decidimos seguir adelante con sólo dos flashes. Utilizamos reflectores, cajas de cartón blancas para rebotar los flashes, cartulinas… Finalmente, dimos con una configuración con la que nos conformamos. Esta limitación, sumada a la falta de espacio y la incomodidad de iluminar en nuestro “lightbox” comprometió en gran medida el resultado final de la pieza.
Nuestro “LightBox”
3. Disparar la cámara (cualquier DSLR o cámara con cable de disparo remoto)
Utilizamos la fórmula de siempre: un optoacoplador 4n28. Su propio nombre parece mucho más complicado de lo que hace. Básicamente es un chip de 6 patas que funciona como un interruptor. En su interior tiene un pequeño led que se ilumina cuando recibe voltaje y al otro lado (también internamente) un fotorreceptor que reacciona cerrando el circuito. En definitiva, un interruptor que puede activar o desactivar aquello que conectemos a su salida con la seguridad añadida de que la entrada y la salida están aisladas eléctricamente. Si tenéis la suerte de contar con una réflex digital o cualquier cámara compacta que tenga opción de conectarle un mando para dispararla de manera remota, podéis utilizar este chip para dispararla por menos de 2€. Si a su vez la cámara tiene un conector estándar de audio para esta función, se hace todavía más fácil. En el caso de que la cámara tenga un conector propio o distinto de los convencionales (como es el caso de la Canon 7D) haría falta que comprásemos cualquier disparador remoto (el más barato que encontremos) y cortar el cable. Al pelarlo, distinguiremos 3 terminales: un común y dos más. Al tocar el común con el primero la cámara enfoca y con el segundo dispara.
Esquema de disparo para cualquier cámara Dslr o digital con disparador por cable
Hablando del ejercicio concreto de fotografiar una gota de agua, hay que tener en cuenta que aunque la cámara es capaz de disparar muy rápido, es muchísimo más fácil trabajar en completa oscuridad y dejar la cámara obturando en “B” para que sea el disparo del flash el que capture la gota en el aire. Para minimizar problemas de sincronismo, lo programamos de tal manera que la cámara empieza a obturar cuando pasa una primera gota y dispara los flashes cuando la segunda está en la posición deseada. De esta manera, también logramos igualar tiempos de obturación entre foto y foto al hacerla coincidir con la frecuencia de goteo.
4. El circuito de agua
En un principio, utilizamos una pequeña bomba que toma agua de una bandeja plástica y la bombea directamente hasta un gotero de hospital regulable. Esta conexión directa hacía que la gota al caer temblase por la vibración y la presión irregular del propio motor. Para solucionarlo, utilizamos un recipiente intermedio que se llena hasta un determinado punto y deja fluir el agua por el gotero por simple acción de la gravedad. De esta forma, minimizamos la vibración y la presión se mantiene constante. El agua sobrante vuelve a la bandeja por un tubo de retorno manteniendo así el circuito cerrado.
Circuito de agua
5. Seguir la gota mientras cae. La Motion Control
Para lograr seguir la caída de la gota, necesitabamos dos controles fundamentales: el eje vertical (tilt) y el control del foco del objetivo macro (follow-focus). Aunque teníamos la motion configurada de otra manera, hicimos unas modificaciones para reconvertir el eje horizontal en control del enfoque. Aunque no quedó muy estético y el motor era demasiado grande para esta labor, conseguimos que funcionase sin problemas. La falta de potencia de los flashes nos impedía cerrar el diafragma y la ya reducidísima profundidad de campo del objetivo macro hubiese hecho imposible mantener la gota a foco en todo su recorrido sin esta modificación.
Follow-focus motorizado
6. Comunicación con la Motion Control.
Dado que necesitábamos sincronizar la caída de la gota con el movimiento de cámara, intentamos hacer que el Arduino se comunicase con nuestro software de control de la motion control. Intentamos enviar comandos serie (serial prints) para que el software aackeys los convirtiese en pulsaciones de teclado. En un pincipio todo funcionó según lo esperado, pero al cabo de algunas fotos se reiniciaba el arduino y perdíamos el movimiento. Después de revisar todos los componentes, cambiar la programación y volvernos completamente locos, decidimos atacar el problema de la manera más salvaje y fea, pero funcional. Si queremos que el arduino simule la pulsación de una tecla y tenemos problemas de comunicación serie, ¿por qué no pulsar la tecla físicamente con un pequeño motor servo? Nos recordó al momento a un capítulo de los Simpsons.
Homer y su pájaro pulsador
Nuestra propia versión: el robot pulsador.
El servo va pulsado la tecla espacio cada foto, con lo que la motion se mueve en pequeños incrementos siguiendo la gota a la vez que corrige el foco del objetivo. Hablaremos de nuestra motion control en otra ocasión, pero hacer un pequeño rig de dos ejes (tilt y foco) para que siga el movimiento de la gota y corrija el foco, no es tan difícil. La red está plagada de información al respecto y hay librerías como la AccelStepper para Arduino que facilitan muchísimo las cosas. Básicamente necesitaríamos dos motores paso a paso, dos drivers, fuente de alimentación y un Arduino. Sólo quedaría construir una estructura que permita mover la cámara de la manera que deseemos.
7. La programación del Arduino
Aunque me gustaría muchísimo, no soy programador y me hubiese costado demasiado empezar a tener resultados decentes. Para acelerar el proceso, hablamos con nuestro colega Jordi Planas. Lo que nos hubiera costado días, él fue capaz de programarlo en una sola mañana. Empezamos por un pequeño sketch de Arduino para controlar el flash y la cámara en función de la interrupción de la gota sobre la luz del fotodiodo y la pulsación de un botón. También decidimos instalar un potenciómetro que permitiera modificar en tiempo real el tiempo entre el paso de la gota y los flashes, sin tener que reprogramar el Arduino. Apuntamos la cámara sobre la superficie del agua, hicimos foco y empezamos a probar con distintos tiempos en milisegundos: 100, 120, 190… pero la gota no aparecía por ningún lado. Seguimos incrementando la espera y a los 200-210 milisegundos:
¡Nuestra primera foto!
Para probar que la teoría funcionaba, disparamos una serie de fotos con la misma espera y resultaron realmente parecidas entre ellas. Observamos también que al quitar el potenciómetro y cualquier tipo de comunicación con el ordenador, las fotos eran cada vez más parecidas entre sí. Entre los dos, limpiamos el código y añadimos algunas ideas para hacer más fiable el sistema: disparar la cámara a la segunda gota, una pequeña operación matemática para que cada 1000 microsegundos se sumara un milisegundo (y así evitar que el Arduino se atragantara manejando más de 4 cifras de microsegundos) y algunas cosas más.
// "Entropy Machine" for IDN Magazine by Physalia. Coded by Jordi Planas & Pablo Barquin
#include <Servo.h>
int flash1 = 9; // Pin del Flash 1 pin 9
int flash2 = 12; // Pin del Flash 2 pin 11
int laser= 2; //Pin del fotodiodo
int camara = 3; //Pin del optoacoplador donde se conecta la camara
int boton1= 7; //Boton de disparo de foto
int boton2= 13; //Boton de repeticion de foto (no incrementar)
boolean clic1= false; //Buleano para el boton 1
boolean clic2= false; //Buleano para el boton 2
boolean laserState= false; //Buleano del laser
int i=1; //Variable que cuenta las gotas (primera o segunda)
Servo servo1; // Crea un Objeto servo
//int f=0; //Numero de fotos para DEBUG
////////////////////////// TIEMPOS //////////////////////////////////////////////////////////////////////////////
int delai= 0; //Espera en milisegundos para la primera foto
int delaim= 0; //Delay inicial al que se le suma el incremento
int incremento= 250; //Incremento en microsegundos
int guardarfoto= 4000; //Espera de la camara para guardar la foto
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void setup(){
//Serial.begin(9600); //Activar para hacer DEBUG
pinMode(flash1, OUTPUT);
pinMode(flash2, OUTPUT);
pinMode(laser, INPUT);
pinMode(camara, OUTPUT);
pinMode(boton1,INPUT);
pinMode(boton2,INPUT);
servo1.attach(6);
servo1.write(0); //Posicion inicial del servo
}
void loop(){
botones();
if (clic1 == true) { //Si el boton esta pulsado
lecturalaser(); //Ejecutamos la funcion lecturalaser
}
{ //Si el boton NO esta pulsado
} //No ocurre nada
}
void lecturalaser(){
laserState = digitalRead(laser);
if (laserState == HIGH) { //Si el laser no esta interrumpido
} //No ocurre nada
else { //Si el laser se interrumpe (LOW)
foto(); //Se ejecuta la funcion foto
}
}
void botones(){
int dclic1 = digitalRead(boton1);
int dclic2 = digitalRead(boton2);
if(dclic1==HIGH){
clic1=true;
}
if(dclic2==HIGH){
clic2=true;
}
}
void foto(){
if (i == 1){ //Si solo ha pasado una gota por el laser
delay(20); //Debounce del laser
digitalWrite(camara, HIGH); //Empezamos a obturar con la camara
i = i++; //Sumamos 1 a i para que dispare a la segunda gota
}
else { //Si i = 2
disparo(); //Ejecutamos la funcion disparo
i = 1; //i vuelver a valer 1
}
}
void disparo(){
if (clic2 == true){ //Si el boton 2 ha sido pulsado
delay(delai); //Esperamos "delai"
delayMicroseconds(delaim); //Esperamos el incremento en Microsegundos
flasheo(); //Ejecutamos flasheo
}
else { //Si el boton 2 NO ha sido pulsado
incrementar(); //Incrementamos la espera ejecutando la funcion incrementar
delay(delai); //Esperamos "delai"
delayMicroseconds(delaim); //Esperamos el incremento en Microsegundos
flasheo(); //Ejecutamos flasheo
motion(); //Movemos la motion
}
}
void flasheo(){
digitalWrite(flash1, HIGH); //Disparamos el flash 1
digitalWrite(flash2, HIGH); //Disparamos el flash 2
delay(10); //Le damos tiempo al flash mientras recibe un impulso
digitalWrite(camara, LOW);
digitalWrite(flash1, LOW); //Apagamos el flash 1
digitalWrite(flash2, LOW);
clic1=false; //Quitar si queremos las gotas automaticas
clic2=false;
/*f = f++;
Serial.println("Delay Inicial:"); //DEBUG
Serial.println(delai);
Serial.println("Delay Microsegundos:");
Serial.println(delaim);
Serial.println("Numero de fotos:");
Serial.println(f); */
}
void motion(){
delay(300);
servo1.write(90);
delay(100);
servo1.write(0);
/*
Serial.println("Motion"); //DEBUG
Serial.println("Esperando");
delay(guardarfoto); //Esperamos a que la camara guarde la foto
Serial.println("LISTO!!!!!!!"); */
}
void incrementar(){
delaim+=incremento;
if (delaim > 1000){
delaim = delaim -1000;
delai = delai++;
}
}
8. El esquema electrónico
Finalmente el esquema quedó así:
Diagrama electrónico
El botón1 hace que tomemos una foto y sumemos el incremento definido a la siguiente pulsación. Usando el switch1, podemos tirar varias fotos incrementales seguidas sin necesidad de presionar una a una. El botón2 hace que la siguiente foto sea igual que la anterior (sin sumar el incremento) y así poder repetirla si algo ha salido mal. El componente BPW41N es el pequeño fotodiodo en el que incide el láser. Los circuitos de flashes (flash1 y flash2) están extraídos del esquema del *Photoduino* y terminan en dos minijack stéreo. EL 4n35 (o 4n28) es el optoacoplador que dispara la cámara y, por último, un pequeño servo alimentado por el propio Arduino que pulsaba la tecla espacio para sincronizar las gotas con la Motion Control.
9. La animación del interior de la gota
Después de buscar algunas referencias y hablar sobre la estética que buscábamos, decidimos hacer una simulación de fluidos que, aunque se mueva de manera orgánica y caótica, va transformándose en formas geométricas muy simples.
Después de renderizada, imprimimos todos los fotogramas para sustituirlos cuadro a cuadro detrás de la gota. Finalmente, fueron 320 fotogramas impresos en A3 y colocados al revés para que la refracción saliera al derecho.
Fotogramas impresos de la animación
10. Primeros Tests
Frames finales
Entropy – IdN Magazine v20n2 by Physalia
Créditos
Entropy – Idn Magazine v20n2
Direction and Production: Physalia
Comissioned by IdN Magazine
Audio: CypherAudio
Programming: Jordi Planas & Physalia
Making Of Pictures: Albert Treblah
En nuestra lista negra
Aclam (Alquiler de material fotográfico, Barcelona): Les alquilamos un objetivo y al sacarlo de la caja vimos que tenía un golpe en la pequeña tapa transparente que indica la distancia focal. Sin darle ningún tipo de importancia y suponiendo que conocen el estado de su propio equipo (error!!!), rodamos el experimento y cómo no… nos robaron la fianza. Al parecer esa tapa plástica cuesta más de 300€ y no tienen ningún tipo de control sobre las condiciones de su propio material. Ojito, que te hacen pagar el pato!
————————————————————————————————————————————–
Si quieres ver otros proyectos nuestros estamos en www.physaliastudio.com, facebook, nuestro canal de vimeo y twitter.
Seguid al tanto, seguiremos publicando y explicando muchos otros proyectos!
Physalia Love
Physalia Blog 