Télécommande pour ruban de LED et annonce nouveau gros projet.

Télécommande pour ruban de LED: FAIL!

Je n’ai plus écrit d’article depuis un certain temps mais entre mon boulot à temps plein, mes cours du soir, les stages, les travaux dans l’appartement et accessoirement un peu de vie privée, j’ai manqué un peu de temps 🙂

J’ai profité de mon dernier jour de congé pour enfin assembler ma carte qui doit contrôler des rubans de LEDs.

Et bein cela ne marche pas! Mon proto fonctionnait bien et à force de vouloir le simplifier, j’ai fait pis que mieux! En gros, les MOSFETs à canal P fonctionne à l’inverse des N: il est passant quand Vgs vaut 0 et bloquant quand Vgs vaut…la tension la plus haute admissible (voir datasheet).

En gros, pour piloter « simplement » un MOSFET P à l’aide d’un microcontrôleur, on peut utiliser le montage suivant:

driving_p-channel_mosfet

J’ai regardé la datasheet et pensé que 5V était suffisant pour pouvoir commuter proprement, hé ben non!

Je vais donc recommencer avec des MOSFET à canal N ( probablement des IRF8313, beaucoup plus facile à commander (une résistance du pull-up ou pull-down suffit!)

C’est en faisant des erreurs qu’on apprend et surtout, le mieux est l’ennemi du bien!

Annonce nouveau projet

J’ai commandé une nouvelle voiture. Je sais qu’il y a une période de rodage à respecter et je comptait m’aider de l’électronique pour fabriquer un petit boitier qui m’indiquerait que je suis trop haut dans les tours. On utilise pour se faire le port OBD2 (prise diag) sur laquelle on peut retirer une volée d’informations. Et c’est grâce à cela que j’ai découvert le bus CAN!

Ce protocole fiable et facile à implémenter va être la base de mon nouveau gros projet: une domotique à base de bus CAN.

Je sais qu’il existe des solution commerciales ou non déjà faite et bien avancées mais j’aime apprendre et faire les choses par moi-meme.

Bien que je consacrerai un petit article sur l’aide au rodage, l’essentiel de mes prochains articles portera sur le projet domotique.

A suivre donc!

 

Publicités

Télécommande pour ruban de LEDs

J’ai placé deux rubans de LEDs  au dessus de mon espace de travail, un qui émet une lumière froide, l’autre chaude. Je cherchais un moyen de commander individuellement ces rubans. J’avais également à disposition une télécommande infrarouge avec deux boutons (ON/OFF) que j’avais eu avec une bougie à LED, exactement ce qu’il me fallait pour commander mes rubans!

C’est partit!

Collecte des données existantes

Les deux rubans sont alimentés en 12v par un transformateur 230VAC/12VDC qui peut fournir un courant de 5A max.

J’ai mesuré le courant consommé par chacun des rubans: 1.02A pour le ruban de LEDs froide, 0.91A pour celui avec les LEDs chaude, soit un total de 1,92A.

Après quelques recherches sur le net, il apparaît que la télécommande dont je dispose émet à une fréquence de 38KHz, fréquence on ne peut plus commune.

telecommande

Schéma électrique

shema_telecommande_ruban_led

Choix des composants

Le microcontrôleur

Comme à mon habitude, je travaille avec les microcontrôleurs AVR d’Atmel (récemment acquis par Microchip, fabriquant des célèbres PICs). Ils sont facile à appréhender pour les débutants comme moi et surtout, ils se programment facilement avec l’environnement Arduino.

Mon choix s’est porté sur l’Attiny 85, un microcontrôleur 8-bits  à 8 pattes que l’on trouve sur le net pour environ 1€. Malgré sa petite taille, il est doté de caractéristiques intéressantes:

  • Tension d’alimentation de 2,7 à 5,5 V
  • Courant max par broche: 40 mA, courant total max de 200 mA
  • Fréquence de 1 à 16 Mhz avec l’oscillateur interne, jusqu’à 20 MHz avec un externe.
  • 8 Kb de mémoire Flash, 512 bytes de RAM, 512 bytes d’EEPROM.
  • 6 entrées/sorties digitales, 2 supportent la PWM.
  • 4 entrées analogiques avec un ADC de 10 bits (3 utilisables avec Arduino).
52713d5b757b7fc0658b4567
Pinout de l’Attiny85

Je ne décrirai par contre pas comment les utiliser avec l’IDE Arduino, ni la manière de les programmer. Il existe d’excellents articles à ce niveau là et je vous renvoie donc vers eux:

Retenez par contre que les libraires qui fonctionnent pour l’Arduino UNO ne sont pas toutes supportées par l’Attiny85 (Ex: la librairie Serial) mais des versions adaptées existent. Votre moteur de recherche préféré sera votre meilleur allié.

Le récepteur infrarouge

tsop48

Concernant le choix du récepteur infrarouge, j’ai utilisé un TSOP4838 de chez Vishay qui est prévu pour fonctionner avec une fréquence de modulation de 38 KHz. Toutes les télécommandes infrarouges ne fonctionne pas à cette fréquence, il est donc nécessaire de choisir le récepteur adéquat.

Retenez également qu’il existe une multitude de protocoles infrarouges:

  • NEC
  • Sony
  • RC5/RC6
  • Samsung
  • ….

Leur fonctionnement est plutôt simple mais un peu fastidieux à mettre en place, d’autant plus que je n’ai pas d’oscilloscope numérique (plus pour longtemps). Heureusement, il existe de bonnes librairies qui se chargeront de le faire pour vous 😉

Pour en savoir plus sur le fonctionnement de la télécommande infrarouge et son utilisation avec l’Arduino:

Les MOSFETs

irf7304-pinout

J’ai pris des IRF7304 de chez International Rectifier (racheté par Infineon). Ce sont deux MOSFETs à canal P dans un boîtier SOIC8, bien pratique car prennent peu de place sur un PCB. Il supporte une tension Vdsmax de -20V, un  Idss max de -2.5 A et un Rds(on) de 0,09Ω avec Vgs =-4.5V .

J’étais un peu inquiet par rapport à la puissance dissipée par ce si petit boiter. Le fabriquant dit que le boitier supporte facilement des puissance de plus de 0.8W. J’ai donc pris ma calculette. Pour calculer la puissance dissipée par un MOSFET, on applique la formule suivante: Pd = Rds * Id², en n’oubliant pas qu’il y en a deux par boiter.

Cela donne donc:

Pd1 = 0,09 * 1.02 = 0.094W
Pd2 = 0.09 * 0.92² = 0,075W

Pdt = 0.094 + 0.075 = 0.169W

On est on ne peut plus dans la tranche garantie par le fabriquant, mes craintes se sont dissipées si je puis dire :-D.

Une simple résistance de pull-down de 10KΩ entre la ligne  commande et la masse suffit à piloter le MOSFET.

Les diodes de roue libre

Diodes S1A de chez Vishay. Bien qu’elles ne soient pas nécessaire dans ce projet, j’ai réservé leurs emplacements sur le PCB pour une éventuelle utilisation de la carte avec des bobines (moteurs, relais,…).

Le reste des composants

Rien de bien spécial. Des borniers pour raccorder l’alimentation et la sortie des LEDs, un régulateur de tension L78M05 et ses condensateurs de découplage de 330nF et 100nF, un condensateur de découplage de 100nF pour le microcontrôleur et des résistances de pull-down de 10KΩ.

Principe de fonctionnement

diagramme_commande_ruban_led

Le principe de fonctionnement est plutôt simple. Le récepteur infrarouge reçoit le signal de la télécommande, le microcontrôleur le décode et commande les MOSFETs à l’aide de transistors qui se chargeront d’allumer ou éteindre le ou les rubans correspondants.

Le bouton ON de la télécommande sélectionne la source à activer. Lorsqu’on alimente le circuit, les deux sorties sont à OFF.

OUT1 OUT2
 1er appui ON OFF
 2ème appui OFF ON
 3ème appui ON ON
 4ème appui OFF OFF

Ce cycle se répète à l’infini.

Le bouton OFF gère l’intensité grâce à la PWM. Le nombre de pas  est défini dans le code source. Chaque appui diminue d’un pas. Arrivé au minimum, l’intensité est à nouveaux maximale et le cycle recommence.

Le code source

Voici le code source, libre à vous de le modifier:

/* 
  Télécommande pour rubans de leds V 1.0
  https://roysone.wordpress.com

  Permet de gérer deux rubans de LEDs à l'aide d'une télécommande infrarouge
  !! ATTENTION !! Ce code ne fonctionne qu'avec un Attiny85.

  Voici les codes des boutons de la télécommande. 
  Pour les récupérer, j'ai suivi le tuto suivant:
  https://learn.adafruit.com/using-an-infrared-library/hardware-needed

   IR Code ON: 1FE58A7
   IR Code OFF: 1FEA05F
*/
// Inclustion des libraires
#include 
#include 

// Définition des constantes
#define BTN_ON 0x1FE58A7
#define BTN_OFF 0x1FEA05F

#define PIN_OUT_1 0
#define PIN_OUT_2 1
#define ON 0
#define OFF 255
#define NB_PWM_STEPS 11

// Définition des variables
byte ct_out = 0;
byte ct_pwm =0;
byte etat_out_1 =OFF;
byte etat_out_2 =OFF;

// Création des objets nécessaire 
// pour le décodage des signaux infrarouge
IRrecv RecepteurIR(2);
decode_results DecodeurIR;

/****** Setup ******/
void setup() 
  {
  // On définit les pins en mode sortie
  pinMode(PIN_OUT_1, OUTPUT);
  pinMode(PIN_OUT_2, OUTPUT);
  
  // On définit les sorties à 0
  analogWrite(PIN_OUT_1, OFF);
  analogWrite(PIN_OUT_2, OFF);
  
  //On active le récepteur IR
  RecepteurIR.enableIRIn();
  }


/****** Loop ******/
void loop()
{
// On détecte un signal infrarouge
if (RecepteurIR.decode(&DecodeurIR))
    {
      // Si on a appuyé sur le bouton ON, 
      // on sélectionne la ou les sorties à activer
      if (DecodeurIR.value == BTN_ON)
          {
            
          // On incrémente le compteur et en fonction 
          // de sa valeur, on sélectionne la ou les sortie(s) à activer
          ct_out++;
          ct_pwm =0;
          
          if (ct_out==1)
            {
            etat_out_1 =ON;
            etat_out_2 =OFF;
            }

          if (ct_out==2)
            {
            etat_out_1 =OFF;
            etat_out_2 =ON;
            }
          if (ct_out==3)
            {
            etat_out_1 =ON;
            etat_out_2 =ON;
            }
          if (ct_out==4)
            {
            etat_out_1 =OFF;
            etat_out_2 =OFF;
            ct_out =0;
            }
          }

      // Si on appuyé sur le bouton OFF, on gère la PWM
      if (DecodeurIR.value == BTN_OFF)
        {
        ct_pwm++;
        
        if(ct_pwm == NB_PWM_STEPS)
          {
            ct_pwm =0;
            if(etat_out_1 > 0)etat_out_1 =ON;
            if(etat_out_2 > 0)etat_out_2 =ON; 
          }

        else
          {
          if (etat_out_1 > 0)etat_out_1-=(256/NB_PWM_STEPS);
          if (etat_out_2 > 0)etat_out_2-=(256/NB_PWM_STEPS);
          }   
       }

    // On applique aux sorties les valeurs choisies ci-dessus
    analogWrite(PIN_OUT_1, etat_out_1);
    analogWrite(PIN_OUT_2, etat_out_2);

    // On rend la main au récepteur infrarouge
    RecepteurIR.resume();
    }
}

Le PCB

J’ai désigné un PCB à l’aide d’Eagle que je fais fabriquer par l’excellent site dirtypcbs.com. Pour 25$, livraison incluse, on peut se faire faire 10 PCBs de qualité professionnelle: 2 couches, couleur au choix, 10cmx10cm max. Pas mal!

Voici à quoi cela devrait ressembler:

top

Vous noterez que le capteur n’est pas sur la plaque et qu’il y a 4 sorties. Vu qu’il est impossible d’en recevoir moins de 10, autant les rendre les plus universels possible afin de les réutiliser pour un max de projets.

Dès que je les reçoit, je vous ferai une démo du montage.

Si vous avez des questions, n’hésitez-pas à me contacter.

Détecteur d’éclairs, partie 2: prototype

Si ce n’est déjà fait, je vous invite à lire la partie théorique avant d’aller plus loin.

IMG_20160714_090651

Après la théorie, place à la pratique!

De gauche à droite, on trouve: la photodiode, la plaquette et la pile, le cordon de l’appareil photo.

La photodiode

Au départ, une BPW34, ca ressemble à ça:

Osram-BPW34

Lors de mes premiers essais, j’ai simplement soudé deux fils sur chaque patte et relié le tout au circuit. Je réglait le seuil de déclenchement et ensuite je simulait des éclairs à l’aide du flash de mon appareil photo.
Dans mon bureau un peu sombre, pas de soucis mais une fois placé dans la lumière du jour, le montage ne fonctionnait plus. Or la finalité de ce montage est de faire des photos d’éclair en pleine journée. La misère!

Ai-je commis une erreur de montage?  Mes calculs sont-ils mauvais? Non en principe tout devrait aller quand tout à coup, je me suis dit « Et si la lumière du jour saturait ma photodiode? ». L’idée, c’est que le soleil sature la diode et donc qu’un éclair ne fera jamais déclencher l’appareil car le seuil maximum est déjà atteint par le soleil. J’ai donc exploré cette piste: il me fallait fabriquer un filtre atténuateur.

Google étant mon ami, je  je suis tombé sur un article d’une grande qualité qui m’a permis non seulement de réaliser un filtre fonctionnel mais aussi d’avoir un cours précis sur les photodiodes.

Cette personne utilise également une BPW34 et est confronté au même problème que moi. Sa solution est tellement simple et bien faite que je l’ai tout simplement copiée. Tout le mérite revient donc à cette personne.

Voici comment je l’ai réalisé:
IMG_20160614_090602.jpg

J’ai utilisé raccord de plomberie, un petit tube de plastique, deux rondelles, une photodiode, un petit bout de veroboard, un peu de soudure et de la colle chaude.

J’ai tout d’abord soudé la photodiode sur le bout de véroboard. J’ai ensuite soudé les deux fils dessus. J’ai placé le tube dans le raccord, une des rondelles sert à maintenir le tube à la hauteur désiré. Le bout de tube servira de support pour la photodiode.

J’ai placé la photodiode et fixé le tout à la colle chaude. Le pistolet à colle chaude est certainement l’un des outils que tout bon maker devrait avoir dans sa boite à outil.

Pour le filtre, j’ai découpé des rondelles dans des sachets antistatiques. Ceux-ci sont en effet opaque et donc atténue la lumière reçue sur la photodiode. J’ai placé une rondelle pour les maintenir en place.
IMG_20160614_095539

J’ai connecté la photodiode « filtrée », réglé le seuil et fait un nouveau test avec l’appareil photo. Et là ça marche super bien. Ouf, une épine tirée hors du pied!

La plaquette

Pas grand chose à dire si ce n’est qu’elle a été réalisée avec des composants traversants. A terme, le tout sera réalisé sur un PCB et les composants seront des CMS (composants montés en surface) pour un gain de place évident.

Le câble

Celui-ci a été récupéré sur une télécommande trouvée sur Ebay au prix mirobolant de 2€! Quand on voit ce qu’il y a à l’intérieur et que Nikon vend les siennes 30€, on se sent profondément volé! A terme, je le remplacerai par un cordon avec un connecteur jack. Cela permettra d’utiliser le détecteur sur un appareil d’une autre marque en changeant simplement le câble.

Premier essai

Il n’y a plus qu’à attendre les orages. Grosse déception, je n’ai eu qu’un seul orage à la nuit tombée et qu’avec des éclairs intra-nuageux. J’ai dû dévisser le filtre car il était trop puissant, plus aucune lumière le traversait mais malgré tout, le montage fait le job demandé.

Je n’ai pas posté de photos car elles n’avaient pas beaucoup d’intérêt. Pas de traceurs à voir, juste de gros halos de lumière dans les nuages. Il me tarde d’avoir un orage digne de ce nom pour un test solide!

La suite?

Pour la suite, j’ai réalisé un PCB sous Eagle que j’ai envoyé chez OSHPark. En effect, cela me coûte moins d’1€ pour obtenir trois plaquette de grande qualité.

Cela fera partie de mon prochaine article consacré au détecteur d’éclair.

A bientôt!

 

Détecteur d’éclairs, partie 1: théorie

15115063028_cb3e35f335_b
Liège, 2014

 

J’ai mis de côté mon feu rouge pour me concentrer sur mon projet de détecteur d’éclairs pour appareil photo car la saison des orages approche et je tiens à être prêt!

J’ai toujours été fasciné par les éclairs. La puissance qu’ils dégagent nous rappelle qu’au final, nous sommes peu de choses.

Faire de la photo d’éclairs de nuit n’est pas trop problématique: une pose longue, un trépied, une télécommande et un peu de chance suffisent amplement. Les photos de jour sont quand à elles plus compliquées…

Tout d’abord, il est impossible de faire des poses longues sans utiliser de filtres à densité neutre. L’avantage, c’est qu’ils allongent le temps de pose et donc les chances de capturer un éclair. L’inconvénient, c’est qu’ils ont tendance à atténuer le halo de l’éclair. celui-ci paraît du coup très « fade ».

Enfin, si on désire se passer de filtres afin d’obtenir un résultat plus « spectaculaire », il va falloir mitrailler au pif en espérant capturer un éclair dans ce laps de temps. Non seulement, cela va faire un paquet de photos à traîter, mais en plus, le rideau et le capteur vont être sollicité pour rien, provoquant l’usure prématurée du matériel.
La solution? Utiliser un détecteur d’éclairs. Il en existe deux types: à radiodétection et optiques.

Les détecteurs à radiodétection fonctionnent à l’aide d’un récepteur AM (identique à ceux utilisé dans les radios). Les éclairs génèrent des perturbations électromagnétiques sur les ondes AM. Le détecteur les repèrent et déclenche l’appareil photo.
Avantage: hyper rapide
Inconvénient: détecte les éclairs jusqu’à 60km de distance. Peu d’intérêt car même pas dans le champ de vision.

Les détecteurs optique fonctionnent quand à eux grâce à l’intensité lumineuse produite par l’éclair. Celle-ci est repérée par le détecteur qui déclenche l’appareil photo.
Avantage: ne détecte que les éclairs visible sur la scène.
Inconvénient: plus lent et plus sensible aux lumières parasites.

Le hic, c’est que ces bestioles coûtent cher: entre 90 et 200€! Alors l’idée m’est venue d’en faire un moi-même.

La théorie:

J’étais partit sur une base d’Arduino couplé avec une photorésistance. Ca marche mais c’est ultra lent! Il faut savoir que la durée d’un éclair est de maximum 50 millisecondes, autant dire que chaque microseconde compte! Je me suis alors tourné vers les composants analogiques et pour moi qui ait de faibles connaissances dans ce domaine, ce fût un véritable défi.

J’avais acheté une photodiode BPW34 de chez Vishay dans le but de faire de la photo haute vitesse avec l’Arduino car elle est très sensible aux variations de lumières et très rapide (180ns de temps de réaction!). Après quelques recherches, j’ai découvert qu’une photodiode s’utilise en inverse. Lorsqu’elle est dans le noir, aucun courant de passe mais dès que la lumière frappe la cellule, un micro-courant de fuite s’échappe de celle-ci. Le problème, c’est qu’il est tellement infime qu’il est inexploitable tel quel. Ça tombe bien, je venais justement de voir les amplis opérationnels en cours qui vont me servir en principe à réaliser mon détecteur.

L’idée de base, c’est d’amplifier le micro-courant en tension exploitable et de comparer cette tension avec une autre qui sert de référence. Quand celle-ci est dépassée, l’appareil photo est déclenché.

J’ai donc utilisé un LM324 (un circuit intégré qui contient 4 amplis) que j’avais sous la main et  j’ai raccordé un des amplis en montage dit « de transimpédance »

Capture d’écran 2016-07-05 à 22.07.29
Ce montage convertit le micro-courant en tension en utilisant le gain énorme des ampli op en s’appuyant sur la relation suivante:

Vout= -Id.R1

-Id: courant de fuite de la photodiode.
Vout: Tension de sortie de l’ampli op
R1 : résistance qui fixe le gain (avec 1MΩ, on utilise le gain maxi).

Et ça marche! Le montage est alimenté en 5V. Quand je raccorde Vout à l’oscilloscope, la tension est à 0V quand la photodiode est plongée dans le noir. Plus on approche une source de lumière, plus la tension augmente. En approchant ou en reculant sa main devant le capteur, on voit clairement la tension fluctuer entre 0V et un peu moins de 5v (saturation de la diode).

J’ai ensuite utilisé un second ampli comme comparateur de tension. La tension de référence est fixée à l’aide d’un potentiomètre.

Capture d’écran 2016-07-05 à 22.36.55

Le potentiomètre (10K) me sert à régler le seuil de déclenchement. Je le règle à peine au dessus de la lumière ambiante, ainsi, une fois qu’un éclair aura lieu, le seuil sera passé, l’ampli saturera et la sortie ira contrôler le déclenchement de l’appareil. J’ai fait des essais avec le flash de l’appareil photo et ça marche parfaitement.

Voilà pour le principe de base. Je vais maintenant vous montrer  mon schéma final et vous expliquer le fonctionnement.

Capture d’écran 2016-07-05 à 22.58.29

Liste des composants:

  • 1 x OPA380 : ampli transimpédance grande vitesse
  • 1 x LM311 : comparateur de tension grande vitesse
  • 1 x NE555 : oscillateur
  • 1 x LM7805 : régulateur de tension 5v
  • 2 x BC547 : transistor NPN
  • 2 x ACPL-217 : optocoupleur rapide
  • 1 x BPW34 : photodiode
  • 1 x Buzzer actif (avec oscillateur intégré, trouvé sur Ebay)
  • 1 x  résistance 470KΩ
  • 3 x  résistance  1KΩ
  • 4 x  résistance  220Ω
  • 1 x résistance 22KΩ
  • 1 x pot 10KΩ
  • 1 x codo 22uF
  • 1 x codo 330nF
  • 3 x codo 100nF
  • 1 led blanche
  • 1 led rouge
  • 3 switchs

Fonctionnement:

Amplification:
La photodiode est branché à l’entrée inverseuse de l’OPA380 qui est un ampli transimpédance rapide. La résistance de contre-réaction vaut 470K , elle sert à fournir un gain élevé tout en évitant le bruit (je vous fait grâce des calculs). Le condensateur de 100nF est un codo de découplage (ne jamais négliger le découplage des circuits).

Comparaison:
La sortie est reliée à l’entrée inverseuse du comparateur de tension LM311, qui est-lui même très rapide (165ns!). Le potentiomètre est raccordé à l’entrée non-inverseuse. Devant le potentiomètre, j’ai placé une résistance de 1K afin d’avoir une plage de réglage la plus fine possible.

Impulsion:
La sortie du comparateur  est reliée à l’entrée du NE555 raccordé en monostable. L’utilité du NE555 est de fournir une impulsion suffisamment longue pour déclencher l’appareil photo. La durée se fait à l’aide du condensateur de 22UF et de la résistance de 22K. On obtient une impulsion d’environ 0.5 s

Déclenchement:
La sortie du NE555 est raccordée à la base des deux transistors NPN BC547. Ils agissent comme des interrupteurs. La résistance de 1K limite le courant mais est suffisante pour faire saturer le transistor. Le 1er déclenche le buzzer, le second la led blanche et l’optocoupleur OPTO1 qui déclenche l’appareil.

Pourquoi deux optocoupleurs alors qu’un seul aurait suffit? il faut d’abord comprendre comment fonctionne le déclencheur photo.

Sur le schéma, on voit trois fils: shutter, focus et GND. le shutter déclenche l’appareil, le focus s’occupe de faire la mise au point, et la masse, ben voilà quoi! Il est impossible de déclencher l’appareil sans avoir fait au préalable le focus.

En résumé:
1. Focus + GND => Mise au point.
2. Shutter  + GND => Rien.
3. Shutter + focus => Rien.
4. Shutter + focus + GND => Clic!

Il est impératif que la mise au point soit faite au moment où le détecteur repère un éclair. En effet, si l’appareil devait faire la mise au point à chaque éclair, l’éclair serait fini que la MAP serait à peine faite.

Donc l’intérêt de l’optocoupleur OPTO2 permet de gagner du temps en maintenant le focus mais aussi de pouvoir le désactiver à l’aide de l’interrupteur. Pourquoi me diriez-vous? Cela permet de faire le réglage du seuil sans faire une batterie de photos à chaque fois qu’il est dépassé!

Alimentation:
Une pile de 9V fournit l’énergie nécessaire au circuit. La tension est abaissée à 5V via le régulateur de tension  linéaire LM7805. Les deux condensateurs de 100 et 330 nF servent au découplage.

Vitesse de déclenchement:
J’ai fait en sorte de trouver de composants les plus rapides, pas évident quand on voit l’épaisseur des catalogues! Il y a surement mieux mais d’après mes calculs, le montage déclenche en moins de 3 microsecondes!
Il faut ajouter à ça la vitesse de l’obturateur propre à mon appareil (Nikon D7000): 53 microsecondes.

Au final, 56 microsecondes se seront écoulées entre la détection de l’éclair et le début de la capture. On comprend tout de suite pourquoi il est impératif que le temps de réponse du montage soit le plus bas possible.

Conclusion:

Voilà pour cette page de théorie un peu lourde. J’espère avoir été suffisamment précis sans avoir été rébarbatif.
Mon montage peut certainement être amélioré. Si vous avez des questions ou des idées, n’hésitez pas à me contacter.

Le prochain article traitera de la réalisation du proto, des problèmes rencontrés et des premiers essais.