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 : 

1. laisser tomber une première goutte dans un récipient rempli d’eau
2. attendre juste le temps nécessaire
3. laisser tomber la seconde goutte
4. déclencher l’appareil photo dans un temps de pause suffisamment grand
5. 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).

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.

Schéma de branchement de l’électro-vanne

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).

 

Petit plus : Pour économiser des piles, j’ai branché un transformateur aux bornes dans le compartiment des piles, les fils étant maintenus au fond par un morceau de polystyrène découpé pour prendre tout l’espace du compartiment.

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

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 flashs

Permet de définir les variables utiliser dans le reste du programme

La partie d’initialisation

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

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

// 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 :

 

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 ici ou là.

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