Accueil > NodeMCU > NodeMCU : TimeLapse pour appareil photo Canon

NodeMCU : TimeLapse pour appareil photo Canon

J’avais déjà créé une télécommande pour mes appareils photos Canon Powershot G5 et EOS 400D à l’aide d’un ATtiny85 pour effectuer des prises de vue à intervalle régulier. Je ne l’ai jamais publié sur mon Blog par manque de temps.

Je vais vous proposer dans cet article de pouvoir effectuer une prise de vue à intervalle régulier à partir de ma platine de test NodeMCU.
J’avais passé beaucoup de temps sur internet pour trouver le fonctionnement des télécommandes Canon RC-5 et WL DC100 car elles n’utilisent pas la même fréquence que les télécommandes de télévision à savoir du 32.7 KHz au lieu de 38 KHz.
Bref à partir du programme vous pouvez vous connecter au NodeMCU à l’aide d’un navigateur internet et piloter la prise de vue à intervalle régulier.
Pour cela il suffit de taper l’adresse IP de votre NodeMCU qui est affiché sur l’écran OLED et de choisir les différentes options :

Lorsque vous cliquer sur le bouton ‘Start‘, le NodeMCU pilotera votre appareil photo en fonction du choix concernant le délai de prise de vue :
On peut arrêter la prise de vue en cliquant sur le bouton ‘Stop‘ ou en accédant à la page HTML par défaut.
Pour effectuer du Timelapse, il est nécessaire de retenir les informations suivantes :
– Le nombre de photos permet de déterminer la durée du film : 30 secondes de vidéo = 30s x 24 images/s = 720 photos.
– Concernant la fréquence de prise de vue, il faut essayer de respecter ces quelques règles :
– Nuages, océan (marée) –> 1 photo toutes les 10 à 15 secondes.
– Construction de bâtiment –> 1 photo par heure.
– Voiture, personne en déplacement –> 1 photo toutes les 2 à 5 secondes.
– Concernant le réglage de l’apareil photo :
– Appareil en mode manuel.
– Mesure évaluative.
– Débrayer l’autofocus.
– Ouverture diaphragme 5.6-6.3.
Allez c’est fini pour les conseils, voici le programme :
// **********************************************************************
// Télécommande Canon RC-5 et WL-DC100
// Permet de piloter les appareils photo Canon Powershot G5 et EOS 400D
// L’émission IR s’effectue à partir d’une page WEB qui permet d’effectuer
// des prises photo à intervalle régulier
//
// Matériel :
//       NODEMCU V1.0 DEV Kit
//       OLED SSD1306
//       1 LED IR
// **********************************************************************
// Ajout librairie gestion OLED, I2C, Infrarouge,WIFI et WEB
#include <Wire.h>
#include « SSD1306.h »
#include <ESP8266WiFi.h>
#include <ESP8266WebServer.h>
// Déclaration de l’afficheur OLED via I2C
// D1 -> SDA
// D2 -> SCL
SSD1306  display(0x3c, D1, D2);
// Déclaration WIFI
const char* ssid     = « SFR_A070 »;
const char* password = « gowmyofjilnedjaccuj9 »;
const char* ssid_apmode = « Fabrice »;
const char* password_apmode = «  »;
// Déclaration Infrarouge
#define IRledPin 12 // LED IR GPIO pin 12 –> D6
// Création d’une instance serveur
ESP8266WebServer server(80); // port d’écoute 80
// Création de la page HTML
static const char *indexhtml = « <html>\n »
« <fieldset> <legend>T&eacutel&eacutecommande IR Canon Powershot G5 et EOS400D</legend>\n »
  « <form action=\ »/timelapse\ » method=\ »POST\ »>\n »
    « TimeLapse &nbsp&nbsp: <input type=\ »radio\ » name=\ »timelapse\ » value=\ »10\ » checked=\ »checked\ »> 10s\n »
    « <input type=\ »radio\ » name=\ »timelapse\ » value=\ »30\ »> 30s\n »
    « <input type=\ »radio\ » name=\ »timelapse\ » value=\ »60\ »> 60s\n »
    « <input type=\ »radio\ » name=\ »timelapse\ » value=\ »300\ »> 5mn\n »
    « <input type=\ »radio\ » name=\ »timelapse\ » value=\ »1800\ »> 30mn\n »
    « </br>Mod&egravele &nbsp&nbsp&nbsp&nbsp&nbsp: <input type=\ »radio\ » name=\ »modele\ » value=\ »canong5\ » checked=\ »checked\ »> Canon G5\n »
    « <input type=\ »radio\ » name=\ »modele\ » value=\ »canoneos400\ »> Canon EOS 400D\n »
    « </br><input type=\ »submit\ » name=\ »start\ » value=\ »Start\ »>\n »
  « </form>\n »
« </fielset>\n »
« <p>\n »
« </html>\n »;
static const char *timelapsehtml = « <html>\n »
« <fieldset> <legend>T&eacutel&eacutecommande IR Canon Powershot G5 et EOS400D</legend>\n »
  « <form action=\ »/\ » method=\ »POST\ »>\n »
  « Timelapse en cours…\n »
  « </br></br><input type=\ »submit\ » name=\ »stop\ » value=\ »Stop\ »>\n »
« </fielset>\n »
« </html>\n »;
// IR code télécommande WL-DC100 (Canon G5)
int g5_header[] = {9200,4400};  // {on, off} en microseconds, on = pwm à 32.7kHz
int g5_zero[]   = { 640, 460};  // {on, off} séquence pour créer un « 0 »
int g5_one[]    = { 640,1620};  // {on, off} séquence pour créer un « 1 »
int g5_code[]   = {0,1,0,1,0,0,1,1,1,0,0,0,1,1,0,1, 1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1, 1};  // code pour déclencher
// IR code télécommande Canon RC-5 (Canon EOS400D)
int rc5_zero[]  = {490,7330};   // Code pour une prise photo immédiate
int rc5_one[]   = {490,5250};   // Code pour une prise photo avec un délai de 2 secondes (non utilisé)
int timelapse; // durée entre 2 prises de vue
boolean stop_timelapse = true;
String appareil_photo;
void setup()
{
  int x = 0;
  char adr_ip[20];
  char adr_ip_apmode[20];
  IPAddress ip;
  String ipStr;
  Serial.begin(115200);
  display.init(); // initialise l’afficheur
  display.flipScreenVertically(); // inverse l’affichage
  display.setFont(ArialMT_Plain_10);
  WiFi.begin(ssid, password);
  display.clear(); // efface l’affichage
  display.drawString(10, 0, « Connexion WIFI en cours »);
  display.display(); // affichage
  while (WiFi.status() != WL_CONNECTED)
  {
    delay(500);
    display.drawString(x, 10, « . »);
    display.display();
    x = x+5;
  }
  ip = WiFi.localIP();
  ipStr = String(ip[0]) + ‘.’ + String(ip[1]) + ‘.’ + String(ip[2]) + ‘.’ + String(ip[3]);
  ipStr.toCharArray(adr_ip, 20);
  WiFi.softAP(ssid_apmode, password_apmode, 10);
  ip = WiFi.softAPIP();
  ipStr = String(ip[0]) + ‘.’ + String(ip[1]) + ‘.’ + String(ip[2]) + ‘.’ + String(ip[3]);
  ipStr.toCharArray(adr_ip_apmode, 20);
  display.clear(); // efface l’affichage
  display.drawString(20, 0, « WIFI connecté »);
  display.drawString(0, 10, « IP mode Station : »);
  display.drawString(40, 20, (adr_ip));
  display.drawString(0, 30, « IP mode AP : »);
  display.drawString(40, 40, (adr_ip_apmode));
  display.display();
  server.on(« / », page_html); // page par défaut, on associe la fonction à traiter
  server.on(« /timelapse », page_html_timelapse); // page timelapse
  server.onNotFound(page_html_non_trouve); // page non trouvée, on associe la fonction à traiter
  server.begin(); // démarre le serveur HTTP
  pinMode(IRledPin, OUTPUT); // GPI12–D6
  digitalWrite(IRledPin, LOW); // éteint la LED
}
void page_html()
{
  stop_timelapse = true; // interdit le Timelapse
  server.send(200, « text/html », indexhtml); // affiche la page HTML
}
void page_html_timelapse()
{
  stop_timelapse = false; // autorise le Timelapse
  appareil_photo = server.arg(« modele »);
  server.send(200, « text/html », timelapsehtml); // affiche la page HTML
  timelapse = strtol(server.arg(« timelapse »).c_str(), NULL, 0); // transforme la chaine de caractères en nombre
}
void page_html_non_trouve()
{
  server.send(200, « text/html », « page introuvable »);
}
void temporisation(int tempo)
{
  for (int i=0; i<=tempo; i++)
  {
    server.handleClient(); // regarde si requête HTTP
    if (stop_timelapse) { return; }
    delay(1000); // 1s
  }
}
void pulseIR(long microsecs)
{
  // Envoie un signal modulé à 30 µs = 32.7kHz
  noInterrupts(); // Désactive les interruptions
  while (microsecs > 0)
  {  // on attaque directement le registre qui gère les GPIO et notamment le GPIO 12
     // car l’instruction digitalWrite prend trop de temps
     GPO = GPO | 0x00001000; // correspond à digitalWrite(IRledPin, HIGH), prend moins 1µs
     delayMicroseconds(14);  // attente 14 microsecondes
     GPO = GPO & 0xFFFFEFFF; // correspond à digitalWrite(IRledPin, LOW), prend moins 1µs
     delayMicroseconds(14);  // attente 14 microseconds
     microsecs -= 30;
  }
  interrupts(); // autorise les interruptions
}
void CanonWLDC100_IRCode()
{
  int ms;
  pulseIR(g5_header[0]); // on envoie un signal modulé 32.7 Khz pendant 9200 µs
  ms = g5_header[1]/1000;
  delay(ms); // on attend pendant 4 ms
  delayMicroseconds(g5_header[1]-ms*1000); // on attend pendant 400 µs
  for (int i=0; i<33; i++) // 33 codes à envoyé
  {
    if (g5_code[i]==1)
    {
      pulseIR(g5_one[0]); // on envoie un signal modulé 32.7 Khz pendant 640 µs
      delay(1); // on attend 1 ms
      delayMicroseconds(g5_one[1]-1000); // on attend 620 µs
    }
    else
    {
      pulseIR(g5_zero[0]); // on envoie un signal modulé 32.7 Khz pendant 640 µs
      delayMicroseconds(g5_zero[1]); // on attend 460 µs
    }
  }
}
void CanonRC5_IRCode()
{
  int ms;
  pulseIR(rc5_zero[0]); // on envoie un signal modulé 32.7 Khz pendant 490 µs
  ms = rc5_zero[1]/1000; // on traite la durée d’attente
  delay(ms); // on attend 7 ms
  delayMicroseconds(rc5_zero[1]-ms*1000); // on attend 330 µs
  pulseIR(rc5_zero[0]); // on envoie un signal modulé 32.7 Khz pendant 490 µs
}
void loop()
{
  server.handleClient(); // regarde si requête HTTP
  if (!stop_timelapse) // si le TimeLapse est autorisée
  {
    if (appareil_photo == « canong5 ») { CanonWLDC100_IRCode(); } // télécommande Canon WLDC100
    if (appareil_photo == « canoneos400 ») { CanonRC5_IRCode(); } // télécommande Canon RC5
    temporisation(timelapse); // on attend en fonction du temps sélectionné
  }
}
Je vous souhaite de bonnes prises de vue avec votre appareil photo préféré…….

 

Publicités
Catégories :NodeMCU Étiquettes : , , ,
  1. Aucun commentaire pour l’instant.
  1. No trackbacks yet.

Laisser un commentaire

Entrez vos coordonnées ci-dessous ou cliquez sur une icône pour vous connecter:

Logo WordPress.com

Vous commentez à l'aide de votre compte WordPress.com. Déconnexion / Changer )

Image Twitter

Vous commentez à l'aide de votre compte Twitter. Déconnexion / Changer )

Photo Facebook

Vous commentez à l'aide de votre compte Facebook. Déconnexion / Changer )

Photo Google+

Vous commentez à l'aide de votre compte Google+. Déconnexion / Changer )

Connexion à %s

%d blogueurs aiment cette page :