Comme indiqué dans mon message de présentation, j'ai fait un détecteur de foudre maison à base de microcontrôleur (plateforme arduino) et j'écris donc ce post pour partager cela.
L'idée était de faire quelque chose de simple, accessible techniquement et bas coût pour qui a déjà un minimum de matériel (fer à souder, pinces etc.) mais sans être franchement équipé pour l’électronique (ce qui est mon cas). On trouve dans le commerce des appareils qui vont entre 70 et 200€ d'après ce que j'ai vu (s'il y a moins cher, n'hésitez pas à me le dire ^^ ). Ce montage revient à une vingtaine d'euro de composants uniquement (ça peut vite grimper bien sûr si on a besoin d'équipement) en s'arrangeant pour optimiser les frais de port en commandant sur ebay ou aliexpress par exemple.
Techniquement le principe est très simple, un montage détecteur est réalisé avec un phototransistor et une résistance. Plus le phototransistor reçoit de lumière, plus il produit de courant. Ce courant traversant une résistance, il en augmente la tension à ses bornes. On utilise alors un microcontrôleur qui vient inspecter en permanence la tension aux bornes de cette résistance. Si un changement de tension brusque est détecté, alors le microcontrôleur déclenche l'appareil.
Le déclenchement de l'appareil est réalisé par un optocoupleur qui est une sorte d'interrupteur commandé et qui permet une isolation électrique complète entre 2 parties d'un circuit. Cela permet de protéger l'appareil photo contre un quelconque problème électrique.
Voici une vue du montage sur breadboard et le circuit complet :
(cliquer dessus pour une version plus large)
En terme de performance, cela fonctionne très bien et la commande de déclenchement se fait en environ 1ms, ce qui est faible devant le temps de latence de l'appareil photo.
La résistance en série avec le phototransistor détermine la sensibilité. J'ai donc mis 2 résistances l'une de faible valeur pour le jour et une résistance plus importante pour la nuit. L'interrupteur permet de choisir la sensibilité. Un potentiomètre aurait été plus flexible mais je voulais un boitier compact sans protubérances. Donc j'ai préféré un petit interrupteur sur la tranche qu'un gros bouton sur le dessus. Et finalement, ça marche très bien comme cela
Afin de contrôler le bon fonctionnement du déclencheur j'ai ajouté 2 leds. Une verte qui flashe toutes les 2 secondes lorsque l'appareil est en marche. Une rouge qui s'allume brièvement au déclenchement de l'appareil photo mais également lorsque le détecteur est saturé (il faut alors changer de sensibilité).
Voila à quoi ça ressemble un fois intégré :
D'un point de vue plus général, l'utilisation d'un microcontrôleur n'est pas optimale, on pend un char d'assaut pour écraser une mouche, mais cela simplifie le montage le rend accessible à un plus large public et plus ludique également grâce à la souplesse qu'apporte la programmation. Le microcontrôleur est bon à tout faire mais ne le fait pas forcément de la meilleure façon. Ainsi un montage à base d'électronique analogique à base de filtre passe-bas et comparateur sera plus réactif et beaucoup plus économe en énergie. J'en arrive donc au principal défaut de ce montage : la consommation !
J'utilise une pile 9V pour l'alimenter et j'estime l'autonomie à environ 10h, ce qui n'est pas top du tout ^^ (entre 2 à 5 sorties ??)J'avais initié ce bricolage sans penser à la consommation, mais heureusement il y a de nombreuses pistes à explorer pour la réduire car rien n'est optimisé dans ce sens. Utiliser une carte arduino plus économe voire un microcontrôleur seul, utiliser des modes de veille dans la programmation, désactiver des composants inutiles de la carte et du microcontrôleur, adapter la source de tension pour éviter le gaspillage d'énergie dans le régulateur qui fourni du 5V à la carte. Avec tout ça, j'ai bon espoir de multiplier l'autonomie par 10 ou 20 dans une prochaine version.
Voici un lien vers le fichier fritzing d'où sont issus les 2 premiers schémas et qui contient également le code : https://drive.google.com/uc?export=down ... WJRVUo0WDg
Le code utilisé pour prodrammer l'arduino se trouve en bas de ce message, il est complètement annoté pour une meilleur compréhension et assez simple.
Si vous avez des questions ou des remarques n'hésitez pas. Les critiques, même négatives sont les bienvenues
Le fichier fritzing peut bien sur être réutilisé et modifié à votre convenance.
Code : Tout sélectionner
#include <MsTimer2.h> //MsTimer2 library allows using timer2 interrupts easily and avoids using delay() function
/*
created June 2015
modified
by Florent Pin
*/
const int triggerPIN=12; //Digital pin 12 connected to an optocoupler that will triggerPIN the camera shutter
const int prefocusPIN=11; //Digital pin 11 connected to an optocoupler that will triggerPIN the camera prefocusPINed mode
const int photoTPIN=7; //photoTPINransistor 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>990){ //switch on a red LED if detector is almost saturated
digitalWrite(SatLedPIN,1);}
else{
digitalWrite(SatLedPIN,0);}
if(sensorValue-prevSensorValue>3){ //detection threshold
digitalWrite(SatLedPIN,1); //switch on a red LED when the shutter is triggered
digitalWrite(triggerPIN,HIGH); //trigger the camera shutter
delay(300);
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();
}
}
