un détecteurs d'éclaire

Bonjour

en attendant la résection d’une commande pour finir un autre projet je me suis lancé dans la réalisation d’un détecteur de flash pour déclencher un appareil photo et pour faire des jolis photos d’orages

je suis donc partie de ce programme

#include <MsTimer2.h>                //MsTimer2 library allows using timer2 interrupts easily and avoids using delay() function 


/* 


 created June 2015 
 modified October 2015 
 by Florent Pin 

 */ 


const int triggerPIN=12;                //Digital pin 12 connected to an optocoupler that will trigger the camera shutter 
const int prefocusPIN=11;               //Digital pin 11 connected to an optocoupler that will trigger the camera prefocusPINed mode 
const int photoTPIN=7;                  //phototransistor connected (with a resistor) to Analog input A0 
const int blinkerPIN=9;                //Blinking green led on pin 10 (Power ON LED) 
const int SatLedPIN=8;                  //Saturation & triggerPIN indicator (red LED) 

int sensorValue = 0;                   //value read from the photoTPINransistor 
int prevSensorValue = 0;               //value read from the photoTPINransistor at the previous iteration 

int j; 
volatile boolean blinker = LOW;        //State of the blinking green LED 


void setup() {  
  pinMode(triggerPIN,OUTPUT); 
  pinMode(prefocusPIN,OUTPUT); 
  pinMode(SatLedPIN,OUTPUT);          
  pinMode(blinkerPIN,OUTPUT); 
  
  digitalWrite(triggerPIN,LOW); 
  digitalWrite(prefocusPIN,HIGH);    //Camera prefocued mode enable permanently 
  digitalWrite(SatLedPIN,LOW); 
  digitalWrite(blinkerPIN,LOW); 
  
  MsTimer2::set(2000, flash);        //ISR flash launched after 2000ms 
  MsTimer2::start();                 //Enable Timer2 interrupts 
} 


void loop() { 
  sensorValue = analogRead(photoTPIN);                        // read voltage from phototransistor 

  if(sensorValue>950){                                        //switch on a red LED if detector is almost saturated 
    digitalWrite(SatLedPIN,1);} 
  else{ 
    digitalWrite(SatLedPIN,0);}  
    
  if(sensorValue-prevSensorValue>5){                          //detection threshold 
    digitalWrite(SatLedPIN,1);                                //switch on a red LED when the shutter is triggered 
    digitalWrite(triggerPIN,HIGH);                            //trigger the camera shutter 
    delay(100); 
    digitalWrite(SatLedPIN,0);                                //switch off red LEd 
    digitalWrite(triggerPIN,LOW);    
  } 
  prevSensorValue=sensorValue;                                //save sensor value for comparison with the next measurement 
} 


void flash(){                                                //Interrupt Service Routine triggered by Timer2 
  blinker= !blinker;                                         //Toggle blinking LED state 
  digitalWrite(blinkerPIN,blinker);                          
  if(blinker){                                               //change next LED state toggle delay for getting  1/100 duty cycle 
    MsTimer2::set(20, flash); 
    MsTimer2::start(); 
  } 
  else{ 
    MsTimer2::set(2000, flash); 
    MsTimer2::start(); 
  } 
}

au quelle j’ai retiré certaine ligne que je trouvais inutile pour mon utilisation
ce qui ma donné ce programme

#include <MsTimer2.h>                //MsTimer2 library allows using timer2 interrupts easily and avoids using delay() function 


/* 


 created June 2015 
 modified October 2015 
 by Florent Pin 

 */ 


const int triggerPIN=12;                //Digital pin 12 connected to an optocoupler that will trigger the camera shutter 
              //Digital pin 11 connected to an optocoupler that will trigger the camera prefocusPINed mode 
const int photoTPIN=7;                  //phototransistor connected (with a resistor) to Analog input A7 
             
const int SatLedPIN=7;                  //Saturation & triggerPIN indicator (red LED) 

int sensorValue = 0;                   //value read from the photoTPINransistor 
int prevSensorValue = 0;               //value read from the photoTPINransistor at the previous iteration 

int j; 
volatile boolean blinker = LOW;        //State of the blinking green LED 


void setup() {  
  pinMode(triggerPIN,OUTPUT); 
 
  pinMode(SatLedPIN,OUTPUT);          
   
  
  digitalWrite(triggerPIN,LOW); 
      //Camera prefocued mode enable permanently 
  digitalWrite(SatLedPIN,LOW); 
   
  
                 //Enable Timer2 interrupts 
} 


void loop() { 
  sensorValue = analogRead(photoTPIN);                        // read voltage from phototransistor 

  if(sensorValue>950){                                        //switch on a red LED if detector is almost saturated 
    digitalWrite(SatLedPIN,1);} 
  else{ 
    digitalWrite(SatLedPIN,0);}  
    
  if(sensorValue-prevSensorValue>5){                          //detection threshold 
    digitalWrite(SatLedPIN,1);                                //switch on a red LED when the shutter is triggered 
    digitalWrite(triggerPIN,HIGH);                            //trigger the camera shutter 
    delay(100); 
    digitalWrite(SatLedPIN,0);                                //switch off red LEd 
    digitalWrite(triggerPIN,LOW);    
  } 
  prevSensorValue=sensorValue;                                //save sensor value for comparison with the next measurement 
}

mais le programme n’est pas encore accès rapide
j’entend par la qu’il déclenche l’optocoupler un peut trop tard du coup je n’ai pas forcément l’éclaire sur ma photo

pour l’améliorer je pensais intégré une boucle while
mais je sais pas trop

qu’en pensez vous ?

cordialement
alexis

Hello

tu fais tes tests avec un flash photo ?

un éclair est beaucoup plus long qu'un flash.

tes tests sont faussés.

oui j'ai fait mes test avec un flash d'appareil photo je suis d'accord qu'un flash est beaucoup plus rapide mais je pense que l'on peut optimisé encore le programme pour qu'il soit encore plus rapide

Je ne comprends pas le fonctionnement de ton code donc je peux difficilement t'aider. Quel est le principe ? À quoi correspond satled ?

Pour ce que je comprends, le code mesure le niveau donné par une photodiode. Si le niveau est supérieur à un seuil de 950 il allume cette satled... C'est quoi ? Le seuil de 950 est choisi comment ? Une valeur plus basse donnerait elle un meilleur résultat ?

Ensuite, si le niveau de la photodiode a augmenté de 5 par rapport au niveau précédemment mesuré, il déclenche le trigger. Pourquoi 5 et pourquoi ce délai de 100 ms ? Un délai plus court est il possible ?

Enfin as tu cherché sur internet ou sur le forum d'autres projets de ce genre ? Ça doit déjà exister à mon humble avis et peut être être déjà optimisé...

hello le sept
je suppose qu’il manque un potar pour régler un seuil par rapport à la lumière ambiante.
seuil qu’ils ont probablement baptisé “de saturation”

Oui, mais comme je n'y connais rien en photographie...

Par contre j'ai trouvé ce lien qui explique comment jouer avec les options de compilation pour optimiser en vitesse.

Une autre solution serait d'utiliser un processeur plus rapide, grâce à un esp8266 ou un esp32

lesept

le principe est que si un grand écart de tension a lieu a l'enté analogique l'appareil photo est déclencher

satled est la led de saturation elle sallume quand l'entré analogique dépasse 950 (valeur un peut aléatoire on pourrait mettre moins) et aussi quand l'appareil est déclencher

pourquoi 5 c'est une bonne question :D moi même je ne sais pas

ensuite le délai c'est pour être sur que l'appareil soit bien déclencher

et justement ce programme ne viens pas de moi je l'ai juste simplifier (site d'origine : http://foudre.chasseurs-orages.com/viewtopic.php?t=6243 )

normalement les déclencheur d'appareil photo ne sont pas basé sur l'arduino pour évité que le traitement des information prenne trop de temps

j'ai oublié de précisé le programme sera envoyer sur un arduino pro mini 16 MGz

Ok Il y a peut être un peu à gagner du côté de cette led de saturation. Tu l'allumes si le niveau est supérieur au seuil et tu la rallumes si le niveau augmente. Je pense que ce n'est pas nécessaire de le faire une seconde fois. Tu peux supposer que l'appareil se déclenche lorsque la luminosité est assez forte à cause de la détection de l'éclair,donc que le led est delà allumée.

Je crois que l'esp32 a une horloge qui tourne à 80 MHz

lesept: Je crois que l'esp32 a une horloge qui tourne à 80 MHz

Ou 160 suivant comment tu le configures.

Par contre, c'est étonnant de passé par le convertisseur AN : pourquoi ne pas le faire en analogique et arrivé avec un signal tout ou rien, ca n'irait pas plus vite ?

Et comment on le configure en 80 ou en 160 ?

Ca se passe par la fonction du sdk nommée system_update_cpu_freq()