lundi 20 mai 2013

Behind the magic !

Bon, après ce titre un peu pompeux, voici les éléments mis en place pour réaliser ces clichés.

Tout d'abord le côté électronique :

On y voit, l'écran LCD permettant d'afficher les valeurs des 3 potentiomètres. Le bouton poussoir sous l'écran servira à vidanger l'électro-vanne. L'autre bouton poussoir, sert à déclencher le système. Les trois potentiomètres serviront à faire varier, la durée d'ouverture de l'électro-vanne pour faire une goutte, le délai entre deux gouttes, et le délai jusqu'au flash qui va figer la photo.

Les fils jaune et orange sont reliés au flash, et les gris et blanc à l'appareil photo.

Pour l'électro-vanne, il n'y a bien que deux fils qui sont reliés au circuit, mais je n'ai pas modélisé ici son alimentation externe. L'électro-vanne a trois bornes, notées DC, R et GND. Voici le schéma livré avec l'électro-vanne, incluant le nom des bornes :

La diode n'est pas sur le schéma électronique car je l'ai directement connectée aux bornes de l'électro-vanne.

Passons à la partie programmation. Voici le programme utilisé pour faire une photo :

#include <LiquidCrystal.h>

// Instanciation de l'écran LCD
LiquidCrystal lcd(2, 3, 4, 5, 6, 7);

// Connexions des trois potentionmètres et du bouton poussoir
const int p1Pin = A2;
const int p2Pin = A1;
const int p3Pin = A0;
const int purgePin = 12;

const int vannePin = 8;
const int apnPin = 9;
const int flashPin = 10;

const int photoPin = 11;

const int pausePostFlash = 100;

void setup() {
  // Initialisation de l'écran (16 caractères sur 2 lignes)
  lcd.begin(16, 2);

  // La purge est une entrée
  pinMode(purgePin, INPUT);
  // La vanne est une sortie
  pinMode(vannePin, OUTPUT);
  // L'appareil photo est une sortie
  pinMode(apnPin, OUTPUT);
  // Le flash est une sortie
  pinMode(flashPin, OUTPUT);
  // La photo est une entrée
  pinMode(photoPin, INPUT);
}

void goutte(int dureeGoutte) {
  // On ouvre la vanne
  digitalWrite(vannePin, HIGH);
  // On attend
  delay(dureeGoutte);
  // On ferme la vanne
  digitalWrite(vannePin, LOW);
}

void takePhoto(int dureeGoutte, int intervalle, int delaiFlash) {
  // Ouverture
  digitalWrite(apnPin, HIGH);

  // Première goutte
  goutte(dureeGoutte);

  // Intervalle
  delay(intervalle);

  // Deuxième goutte
  goutte(dureeGoutte);

  // Attente jusqu'au flash
  delay(delaiFlash-intervalle);

  // Flash
  digitalWrite(flashPin, HIGH);
  // On attend
  delay(1);
  // On ferme la vanne
  digitalWrite(flashPin, LOW);

  // Attente jusqu'à la fermeture
  delay(pausePostFlash);

  // Fermeture
  digitalWrite(apnPin, LOW);  
}

void loop() {
  // On lit les valeurs des trois potentiomètres
  int p1 = analogRead(p1Pin);
  int p2 = analogRead(p2Pin);
  int p3 = analogRead(p3Pin);

  p1 = map(p1, 0, 1023, 0, 100);
  p2 = map(p2, 0, 1023, 0, 100);
  p3 = map(p3, 0, 1023, 100, 500);

  // Si la photo est prise
  if (digitalRead(photoPin) == HIGH) {
    takePhoto(p1, p2, p3);
  }
  else {
    // On efface l'écran
    lcd.clear();

    // Affichage des valeurs des trois potentiomètres
    lcd.setCursor(0, 0);
    lcd.print("P1:");
    lcd.print(p1);

    lcd.setCursor(8, 0);
    lcd.print("P2:");
    lcd.print(p2);

    lcd.setCursor(0, 1);
    lcd.print("P3:");
    lcd.print(p3);

    // Affichage de l'état du bouton poussoir
    lcd.setCursor(8, 1);
    if (digitalRead(purgePin) == HIGH) {
      lcd.print("ON");
      digitalWrite(vannePin, HIGH);
    }
    else {
      lcd.print("OFF");
      digitalWrite(vannePin, LOW);
    }

    // Petite pause
    delay(50);
  }
}


Les valeurs pour les potentiomètres sont mappées pour que les deux premiers donnent une valeur entre 0 et 100 et le troisième entre 100 et 500. Il faut se méfier en modifiant ces valeurs, car pour simplifier mes tests je fais une pause entre la deuxième goutte et le flash d'une durée de delaiFlash-intervalle. Si cette valeur devient négative, le système paraîtra bloqué...

Voilà... C'est tout pour le moment. Je ne sais pas quand je recommencerais, mais je pense que les prochaines séances seront plus faciles à mettre en place !



samedi 11 mai 2013

Tadaaaa...


Bon et bien ça y est ! Après avoir scruté les 1263 impacts les plus jolis, je vous ai fait une petite sélection :
https://plus.google.com/photos/101915132272223832051/albums/5876786164498067985

Alors les premières sont à la grenadine, mais la coloration n'est pas suffisante à mon goût. Vous verrez qu'au fur et à mesure de l'avancement, l'objectif est de plus en plus sale, constellé par les gouttelettes. Ensuite, j'ai pris mon téléobjectif pour prendre de la distance, et j'ai mis du café qui donne cette teinte dorée.

Voilà, à bientôt pour le détail du montage et du programme de l'Arduino.

jeudi 9 mai 2013

Teaser

Allez ! A la demande générale, voici un aperçu de ce qui a été finalement obtenu :

Bon, là elle a été un peu retouchée, mais on peut dire que ça commence à le faire !

Voici l'originale, avec le souci des éclaboussures. Et oui, l'objectif étant un peu trop près des gouttes, il s'en est pris plein la calebasse ! Bonjour les jolis reflets !!!


Allez, promis la prochaine fois, c'est l'album complet ! Mais je ne sais pas quand !

Histoire de patienter...

Bon, j'ai refait deux séances, soit près de 4000 clichés (4014 pour être tout à fait précis), et j'ai enfin obtenu ce que pourquoi toute cette histoire a vu le jour...

Mais, comme la sélection est longue, voire très longue, car cette fois-ci beaucoup de photos sont réussies, en attendant, je vous propose une petite vidéo très courte, qui montre un impact. Ce qui est intéressant ici, c'est que l'on a 93 photos représentant chacune une goutte différente... Et oui, le 60D a beau être une bête de course, il ne sait pas prendre une vidéo à 1000 images secondes. Donc il s'agit bien de 93 impacts différents, chacun photographié à 1 milliseconde plus tard que la précédente...


Bon l'impact n'est pas aussi joli que ce que l'on pouvait espérer... Mais, promis, vous les verrez, ces jolies photos...

lundi 6 mai 2013

Premiers résultats !!!

Et bien voilà ! C'est fait !



La première séance a bien eu lieu dans la nuit du samedi 26 au 27 avril 2013 ! On a passé tout l'après midi à tout bien préparer : limer les pattes des potentiomètres pour que les contacts soient parfaits dans les plaques d'essai, démontage de mon vieux Canon argentique qui ne fonctionnait plus pour récupérer le socle du flash, faire une crise cardiaque quand on s'est aperçu que l'électro-vanne ne fonctionnait pas avec les opto-coupleurs, finir par comprendre comment brancher l'électro-vanne... Bref que du bonheur !

Bon on est loin du résultat attendu, mais on a quelques clichés sympas. Sur 1251 photos, 937 sont intéressantes, et j'en ai sélectionné 71 qui, à mon sens, valent le coup.

A vous de dire :
https://plus.google.com/photos/101915132272223832051/albums/5874849866597343793?banner=pwa

Bon les photos sont brutes non retouchées, hein...

A bientôt pour les montages et programmes de l'Arduino...

samedi 23 mars 2013

Préparation du système paramétrable

Le principe de la double goutte d'eau est le suivant :
  • On ouvre la vanne pour produire la première goutte
  • On fait une pause
  • On ouvre la vanne pour faire la seconde goutte
  • On refait une pause
  • On déclenche l'appareil photo
  • On déclenche le flash 
Voici un schéma rapide de la timeline :

Pour commencer, les deux gouttes feront la même taille, donc le temps d'ouverture de l'électrovanne sera le même : t1. Le temps séparant les deux gouttes est t2. La dernière pause, t3, va jusqu'au déclenchement du flash. Comme la prise de vue se fait dans le noir, on déclenchera l'appareil photo juste avant le flash, la vitesse d'obturation faisant durer la prise de vue jusqu'après le flash (sinon, ça ne servirait pas à grand chose...)

Plutôt que de faire des essais-erreurs et de réalimenter à chaque fois le micro-controller, je pense paramétrer le système avec trois potentiomètres pour régler les trois durées : t1, tet t3. Et pour pouvoir recréer les conditions, on va les afficher sur un écran LCD. Il nous faudra aussi deux boutons poussoir, un pour lancer le mécanisme, et un autre pour vidanger la vanne.

Vue que la taille de ma plaque de montage sans soudure est un peu petite, j'ai juste fait le montage avec trois potentiomètres et un seul interrupteur.

Voilà ce que ça donne :

J'ai réorganisé le câblage de l'écran LCD (par rapport aux tutoriaux Arduino) histoire de ne pas croiser les connexions inutilement. En outre pour éviter d'utiliser un potentiomètre pour le contraste, je l'ai remplacé par une resistance 1 kΩ, après avoir fait un test avec un potentiomètre. La deuxième resistance est une 220 Ω pour le rétro-éclairage de l'écran LCD. La résistance du bouton poussoir est une 10 kΩ.

Et voici le code qui affiche les valeurs des entrées analogiques et l'état du switch :

#include <LiquidCrystal.h>

// Instanciation de l'écran LCD
LiquidCrystal lcd(2, 3, 4, 5, 6, 7);

// Connexions des trois potentionmètres et du bouton poussoir
const int p1Pin = A2;
const int p2Pin = A1;
const int p3Pin = A0;
const int switchPin = 12;

void setup() {
  // Initialisation de l'écran (16 caractères sur 2 lignes)
  lcd.begin(16, 2);

  // Le switch est une entrée
  pinMode(switchPin, INPUT);
}

void loop() {
  // On lit les valeurs des trois potentiomètres
  int p1 = analogRead(p1Pin);
  int p2 = analogRead(p2Pin);
  int p3 = analogRead(p3Pin);

  // On efface l'écran
  lcd.clear();

  // Affichage des valeurs des trois potentiomètres
  lcd.setCursor(0, 0);
  lcd.print("P1:");
  lcd.print(p1);

  lcd.setCursor(8, 0);
  lcd.print("P2:");
  lcd.print(p2);

  lcd.setCursor(0, 1);
  lcd.print("P3:");
  lcd.print(p3);

  // Affichage de l'état du bouton poussoir
  lcd.setCursor(8, 1);
  if (digitalRead(switchPin) == HIGH) {
    lcd.print("ON");
  }
  else {
    lcd.print("OFF");
  }

  // Petite pause
  delay(10);
}



  

dimanche 17 mars 2013

Pilotage du Canon 60D

Il ne faut pas oublier que la première étape est de pouvoir prendre une photo quand même. Pour ce faire, il suffit d'une prise jack mâle stéréo 2.5 mm. Je l'ai reliée à trois fils téléphoniques, (pinaize ça faisait un bail que je ne m'étais pas servi d'un fer à souder...) il n'y a plus qu'à faire contact comme suit pour piloter le boîtier.


A priori ça fonctionne pour tous les boîtiers Canon.

Là où je suis plus embêté c'est pour le flash... Je sais bien quelles sont les bornes à connecter, mais je n'ai pas trouvé de prise façon sabot de flash... Sauf évidemment à acheter pour 80€ une rallonge de flash et la désosser, mais faut peut-être pas pousser mémé dans les orties...

Mais je vais bien trouver quelque chose.