Pour photographier deux goutes d’eau rentrant en collision dans de bonnes conditions, il est nécessaire de provoquer un peu les choses, de forcer le hasard.
Nous allons voir ici comment faire tomber deux gouttes d’eau dans le même axe, dans un intervalle de temps suffisamment précis pour déclencher la prise de vue au moment où elles entreront en collision. L’ensemble se base sur des techniques de photographie haute vitesse et sur une machine à produire des gouttes (la synchronisation entre les gouttes est très difficilement réalisable manuellement).
Le principe général est le suivant :
- laisser tomber une première goutte dans un récipient rempli d’eau
attendre juste le temps nécessaire
laisser tomber la seconde goutte
déclencher l’appareil photo dans un temps de pause suffisamment grand
déclencher le ou les flash au moment précis ou la seconde goutte entre en collision avec la première du haut de son rebond.
Les différentes parties de l'article vont tenter de décrire précisément la machine à goutte (son câblage, sa programmation) et la partie prise de vue (qui n'est pas forcément la plus simple).
Les différentes parties de l’article vont tenter de décrire précisément la machine à goutte (son câblage, sa programmation) et la partie prise de vue (qui n’est pas forcément la plus simple).
La machine Ă percuter des gouttes
schéma général (réalisé avec fritzing)
Le chef d'orchestre
Pour pouvoir réaliser le prince général énoncé plus haut, nous avons besoin d'un chef d'orchestre, un module capable de déclencher les différents éléments au bon moment, de les synchroniser.
Dans ce rôle, une carte micro contrôleur Arduino Uno dont le principe est de fournir un module programmable pouvant interagir avec des périphériques que nous brancherons sur ses ports entrées / sortie (merci à Moisirus de m'avoir fait découvrir cette carte).
Nous réaliserons le code informatique qui va exécuter les différentes séquence du scénario mais dans un premier temps concentrons-nous sur l’interfaçage des périphériques.
Piloter les périphérique via la carte de micro contrôleur va demander de réaliser des montages électroniques très simples que l’on peut câbler sans aucune soudure via une platine d’essai. Cela facilite nettement les opérations et permet de recycler les composants très simplement.
Electro-vanne
Pour réaliser des gouttes à la demande, nous utiliserons une électro-vanne, que l’on peut voir comme un robinet avec commande électrique qui sera commandé par la sortie digitale 5 (par exemple) de l’Arduino. Ce principe nous permet de nous affranchir de la barrière infra-rouge, inutile de détecter le passage d’une goutte puisque nous décidons du moment de leur formation.
J'ai utilisé ce modèle bon marché qui fonctionne sous une tension de 12V continu. Le principe en est simple, en alimentant les deux bornes, l’électro-vanne laisse passer l’eau, sans alimentation, l’eau ne passe plus. L’électro-vanne est fournie avec un schéma de montage pour l’Arduino.
Je l’ai réalisé avec les composants suivants :
- - Un transistor TIP122 (Q1)
- Une diode 1N4004 (D1)
- Une résistance de 100k (R1)
- Un transformateur 12V
Pour essayer de comprendre un peu: au moment où il sera demander de produire une goutte, l’Arduino enverra un “1” = +5V sur sa patte 5 qui est reliée à l’émetteur du transistor(Q1). Le transistor ainsi alimenté fait office d’interrupteur à qui l’on a mis à ses bornes les 12V de l’électro-vanne qui s’ouvre et laisse passer l’eau (nous verrons l’alimentation en eau un peu plus loin). Quelque millisecondes plus tard (temps que nous paramétrons en programmation pour avoir une goutte), la patte 5 de l’Arduino retombe à 0 et l’électro-vanne se referme. Pour simplifier, nous dirons que la diode et la résistance nécessaires dans le schéma sont des éléments de protections.
Petit plus : Pour égayer le tout j’ai ajouté une led entre la résistance et la base du transistor pour visualiser la commande de l’électro-vanne par le micro-contrôleur.
L’appareil photo
Le principe de câblage de l’APN est sensiblement le même que celui que nous venons de voir mais simplifié. Il ne s’agit plus ici de faire circuler du 12V mais de créer un contact aux bornes de la prise télécommande de l’APN. L’Arduino délivre un “1” : +5V (ici sur la patte de sortie 3) qui va commander un optocoupleur qui ainsi alimenté fera contact entre deux fils branché aux bornes de la prise de télécommande.
Le système de déclenchement du Reflex Sony Alpha 700 (je parle de celui que je connais) ne nécessite que deux simples contacteurs, un pour la mise au point et l'autre pour le déclenchement. Un connecteur peut être fait simplement avec un connecteur de carte audio pour Pc ou un câble audio de lecteur CD dont il faudra couper un bout (de 4 broches il faut passer à 3).
Le matériel nécessaire pour brancher l’APN :
- - Un optocoupleur (4N28 ou 4N35)
- Une résistance 1kh
- Un connecteur carte audio de PC
- J’ai ajouté une led rouge pour visualiser la commande passée par l’Arduino
Les flashs
Au moins un flash est indispensable pour figer l’instant de la collision des gouttes. Le schéma que je vous propose permet d’en brancher deux. Il suffit de reprendre le schéma de branchement de l’appareil photo et de le multiplier par le nombre de flash à connecter. Cependant, une seule commande (patte 4 de l’Arduino) pour déclencher tous les flashs au même moment).
Le matériel nécessaire pour brancher deux flash :
- - 2 optocoupleurs (4N28 ou 4N35)
-2 résistances de 1Kh
- J’ai ajouté une led jaune pour visualiser la commande envoyée aux flashs par l’Arduino
Du côté des flash pour connecter les câbles deux solutions :
- Soit votre flash possède une prise pour un branchement externe et avec des connecteurs à deux broches que l’on trouve dans les pc on arrive à faire un branchement simple.
- Soit votre flash n’a pas de prise et il est nécessaire de relier deux contacts, celui du centre et celui du sabot (la masse).Les boutons de commande
Il est indispensable de prévoir un bouton poussoir pour lancer le cycle de prise de vue (utilisation de l’entrée numérique 2 de la carte Arduino). Ce bouton doit être protéger par deux résistances. Il faut donc ajouter à la liste :
- - Un bouton poussoir
- Une résistance de 10kh
- Un résistance de 100h
La vitesse d’une goutte dépendant de nombreux facteur (la pression, la température, la résistance à l’air, sa masse, son rayon, etc…) j’ai préféré utiliser la méthode empirique de “essai-erreur” pour déterminer le temps à configurer entre deux gouttes.
J’ai opté par l’utilisation d’un potentiomètre pour régler le temps entre deux gouttes, afin d’éviter de modifier sans cesse le programme et d’avoir à le recharger dans la carte. Le potentiomètre de 10kh est branché sur l’alimentation en 5v de la carte et sur une entrée (A0) analogique. Je peux ainsi créer une variable d’entrée que je peux faire varier de 0 à 1023 lisible en continu.La programmation
Les éléments raccordés nous pouvons passer à la partie programmation. L’écriture du programme se fait depuis un PC via le logiciel Arduino, espace de développement intégré gratuit qui permet de compiler et de charger le programme sur la carte.
Le langage utilisé est spécifique à l’Arduino mais reste très proche du langage C.
Un programme reste structuré de la sorte :
- -Partie déclarative globale
- Partie d’initialisation
- Boucle infinie
- Fonctions
La partie déclarative
Code : Tout sélectionner
boolean modeDebug=false; // Affichage des données à l'ordinateur ou pas
// Bouton de commande
int switchPin = 2; // Bouton poussoire sur l'entrée 2
int buttonState; // variable pour l'Ă©tat du bouton
// entree valeurs
int intPotentiometre = A0; // Entrée analogie que potentiomètre
int valeurLue = 0; // Valeur lue au potentiometre
int ancienneValeurLue = 0;
// Goutte
int delayGoutte = 200; // Temps necessaire pour une goutte
int delayEntreGoutte = 600; // Delai entre deux gouttes
int outValve = 5; // sortie 5 pour la commande de la valve
// Photo
int delayAvantPhoto=60; // temps d’attente après la deuxième goutte
int delayPhoto = 100; // temps de pause
int outPhoto = 3; // Sortie 3 pour la commande de l'APN
int outFlashs = 4 // Sortie 4 pour la sortie des flashsPermet de définir les variables utiliser dans le reste du programme
La partie d’initialisation
Code : Tout sélectionner
void setup() {
pinMode(outPhoto, OUTPUT); // l'APN en sortie
pinMode(outFlashs, OUTPUT); // les flash en sortie
pinMode(outValve, OUTPUT); // la valve en sortie
pinMode(switchPin, INPUT); // le bouton poussoir en entrée
if (modeDebug)
Serial.begin(9600); // Set up serial communication at 9600bps
buttonState = digitalRead(switchPin); // read the initial state
}Les premières lignes exécutées par le microcontrolleur. Définie les entrées sortie. Le mode débug permet d’initialiser une communication avec l’ordinateur et notamment avec la console pour afficher des informations.
La partie boucle
Code : Tout sélectionner
void loop(){
// lecture de la valeur du potentiometre
ancienneValeurLue = valeurLue;
valeurLue = analogRead( intPotentiometre );
if (modeDebug && valeurLue != ancienneValeurLue)
Serial.println(valeurLue, DEC);
// Valeur entre 0 et 1023
// Initialiser la valeur à déterminer avec celle du potentiometre
delayEntreGoutte = valeurLue;
buttonState = digitalRead(switchPin); // Ă©tat du bouton poussoir
if (buttonState == LOW) { // bouton activé
if (modeDebug)
{
Serial.println("*** DEMARRAGE ****");
Serial.print("Valeur retenue : ");
Serial.println(valeurLue, DEC);
}
// Première goutte
piloterValve();
delay(delayEntreGoutte);
// Deuxième goutte
piloterValve();
// Prendre photo
delay(delayAvantPhoto);
prendrePhoto();
}
}On retrouve ici les étapes de notre principe général :
- Lecture de la valeur du potentiomètre qui va déterminer le temps entre deux gouttes
en mode débug : Affichage de cette valeur (on vérifie que l’on peut lire le potentiomètre
Dés que l’on presse le bouton poussoir :
en mode débug : Afficher un message de départ avec la valeur du potentiomètre
Actionner la valvle pour la première goutte
Attendre le temps demandé (valeur potentiomètre)
Actionner la valve pour la deuxième goutte
Attendre le temps paramétré
DĂ©clencher APN et flash.
Les fonctions
Code : Tout sélectionner
// Piloter APN et flash
void prendrePhoto() {
digitalWrite(outPhoto, HIGH);
delay(delayPhoto);
// DĂ©clenchement des flash
digitalWrite(outFlashs, HIGH);
delay(delayPhoto);
digitalWrite(outFlashs, LOW);
// Fin photo
digitalWrite(outPhoto, LOW);
}
// Piloter valve
void piloterValve() {
digitalWrite(outValve, HIGH); // turn Valve #1 on
delay(delayGoutte);
digitalWrite(outValve, LOW); // turn Valve #1 on
}- Dans ces calculs faire attention, les actions sont séquentielles et se cumulent. Ne pas oublier que c’est le flash qui doit être synchrone avec la percussion des gouttes.
Pour informations, voici quelques chiffres que j’avais notés :
Hauteur 44cm -> ouverture électro-vanne (première goutte) 20 ms -> Temps avant le rebond de la première goutte 290ms -> Ouverture électro-vanne seconde goutte 20ms -> Délai déduis avant la seconde goutte 120 ms
La prise de vue
Maintenant que nous avons les moyens de provoquer des collisions de gouttes, il nous faut nous intéresser à la manière de les photographier. Je n’ai pas de recette miracle pour réaliser les plus belles gouttes. Les variables d’ajustement sont nombreuses (éclairage, couleur et type de liquide, décors, axe de prise de vue) ce qui rend aussi la chose intéressante. Il faut ne pas hésiter à tester, à changer les récipients, les positions des flash, à utiliser ce que l’on a sous la main pour diffuser et réfléchir la lumière, faire tenir les flashs au plus près de l’eau. On peut commencer par s’inspirer des setups que l’on peut trouver sur le web (via le mots clés drop collision par exemple).
Entre chaque série de photos, il faudra :
- - Remplir et installer en hauteur un réservoir de liquide qui alimentera l’électro vanne,
- Remplir un récipient qui fera office de réceptacle des gouttes et le placer sous l’électro vanne,
- Placer les flash, des panneaux de couleurs (qui se reflèteront dans les gouttes) autour de la scène , les diffuseurs,
- Placer et régler la hauteur de l’appareil photo,
- Brancher l’appareil à notre machine à collision,
- Définir la mise au point (en manuel en entrée, à l’aide d’une règle par exemple placée entre la bouche de l’électro vanne et le centre du réceptacle)
- Se mettre dans le noir,
- et enfin appuyer sur le bouton poussoir qui va commander notre carte Arduino.
Le réservoir
A l’entrée de l’électro vanne j’ai relié par via un tuyau, un siphon mariotte : simple bouteille avec plongeur (le bouchon percé et traversé par une paille), qu’il suffit de mettre en hauteur pour avoir de la pression. La bouteille est remplie d’eau (c’est bien pour débuter, ensuite on pourra s’amuser avec des liquides, plus gras, plus denses, avec des colorants (attention tout de même aux sirops trop sucrés qui risquent de coller et de boucher l’électo-vanne)).
Le récipient
Le choix du récipient est important pour :
- - Sa matière et sa couleur qui va se refléter dans les gouttes
- Sa profondeur qui va déterminer la hauteur du rebond de la première goutte
- Sa taille pour les Ă©claboussures.
On pourra le remplir d’eau également pour débuter et on peut même y ajouter juste UNE PETITE goutte de liquide vaisselle pour rendre l’ensemble plus dense (attention au fur et à mesure que le gouttes vont tomber dans le récipient, le liquide vaisselle risque de mousser ce qui n’est pas très esthétique). Le récipient doit être rempli à raz bord afin que l’on puisse cadrer au niveau de l’eau sans faire apparaitre le récipient.
Les Flashs
La qualité de la photo va principalement dépendre du soin que l’on aura pris pour l’éclairage de la scène et c’est me semble t’il le point le plus délicat.
Il faut des flashs rapides (capables de déclencher au moins à 1/32), placés pour éclairer sur les côtés ou derrière mais toujours en plongé.
Il faut jouer ensuite avec les diffuseurs pour éviter les forts éclats se réfléchissant sur les gouttes. Mon flash (5400 HS) est réglé en mode M 1/32.
L’appareil photo
L’appareil photo doit être monté sur un pied stable. Personnellement j’utilise mon Sigma 105mm macro 2.8 qui me permet de rester assez éloigné pour éviter les éclaboussure.
Plus le récipient est grand, plus il sera facile de cadrer en plongée sans voir apparaitre ses bords à l’image.
Le paramétrage de l’appareil : f16, iso 100 pour une vitesse pouvant varier de 1/20 à 1/200 (il ne faut pas oublier que c’est le flash qui va figer l’instant).
Voilà , j’ai sans doute oublié des choses et c’est ce qui arrive quand on laisse passer trop de temps entre l’expérience et l’écriture.
Axes d’amélioration :
- Multiplier les électro-vannes, multiplier les flash, etc…
- Tester différents liquides
Voilà , j'espère que cela pourra servir.
je réalise à l'instant et après avoir lu tout ça que je n'y arriverai jamais à faire d'aussi beaux clichés 
