martedì 1 luglio 2014

Trigger per fotografare i fulmini

È da un po' che avevo voglia di costruire un qualcosa per fotografare i fulmini, li ho sempre fotografati utilizzando la posa B della macchina fotografica, ma è una cosa che può andare bene ad esempio di notte, in pieno giorno è impensabile. Quindi mi sono documentato in rete e ho visto che esistono dei sistemi (anche commerciali) per poter fotografare i fulmini, l'idea è quella di misurare l'intensità luminosa con un fototransistor e scattare una foto quando questa varia. E qui sorge un dubbio: ce la fa la macchina a scattare? Un fulmine dura un istante!? In realtà, da quello che ho letto almeno, un fulmine ha una durata media di 200 millisecondi, la macchina fotografica (la mia almeno) ha un ritardo, da quando si da l'input di scattare, di 85 millisecondi, ora non so il ritardo esatto del circuito ma anche lì sono pochi millisecondi, quindi ci si riesce senza problemi.


Una foto scattata con il trigger durante il test

Un'altra cosa importante è il fototransistor, bisognerà sceglierne uno che lavora in uno spettro di luce in cui emette il fulmine, ora non so dirvi esattamente su che spettro emettono i fulmini, però la luce visibile al nostro occhio è tra i 380 e i 760 nanometri. Cercando su ebay sono riuscito a trovare un SFH309 (qui il datasheet) che ha uno spettro da 380 a 1180 nanometri, quindi considerando che i fulmini si vedono ad occhio nudo, anche il sensore li rileva.
Il fototransistor in questione è un NPN e, teoricamente, andrebbe montato così:

Non so spiegarvi il perché, ma facendo delle prove ho visto che è più sensibile se montato al contrario, ossia così:
In teoria non dovrebbe andare, ma va...
Veniamo al circuito, il circuito è questo
Praticamente il funzionamento è il seguente: il PIC legge il valore del transistor tramite l'A/D, se |V(t)-V(t-1)| > SOGLIA allora scatta una foto, dove V(t) è il valore del fotodiodo all'istante attuale, V(t-1) è il valore letto all'istante precedente e la SOGLIA è un valore pre-impostato.
Il led L1 segnala che è stato rilevato un fulmine, i pulsanti UP e DOWN servono ad incrementare/decrementare il valore di SOGLIA e L2 segnala la pressione di uno dei pulsanti.
Avendo l'A/D di questo PIC una risoluzione a 10 bit, abbiamo 1024 valori possibili, quindi una variazione di un punto nella soglia corrisponde circa ad una variazione di 4,9 millivolt nel photransistor. In realtà ponendo la soglia ad 1 il PIC fa scattare la macchina fotografica "a caso", diciamo che una buona soglia è su 8-10, poi potete fare delle prove per vedere qual è meglio.
Un'altra cosa che ho notato è che, a volte, non rileva fulmini un po' deboli (magari quelli belli tutti ramificati ma molto sottili), mi è stato consigliato di mettere più fotodiodi in parallelo per aumentare la sensibilità, però non ho ancora provato.
Di seguito è riportato il codice che serve a programmare il PIC
#include <htc.h>
#define abs(x) ((x) > 0 ? (x) : -(x))
#define SOGLIA 10

/* ---------------------- HEADER ---------------------- */
void initialize(void);
void delay_ms(unsigned int D);

/* --------------------- VARIABILI -------------------- */
int value, new_value, soglia;

/* ----------------------- MAIN ----------------------- */
void main(void){
   initialize();
   while(1){
      if(GPIO4 == 1){                        //Incrementa la soglia di sensibilità
         if(soglia < 100){
            soglia = soglia + 1;
         }
         GPIO5 = 0;
         GPIO1 = 1;
         delay_ms(2000);
      }
      else if(GPIO2 == 1){                  //Decrementa la soglia di sensibilità
         if(soglia > 1){
            soglia = soglia - 1;
         }
         GPIO5 = 0;
         GPIO1 = 1;
         delay_ms(2000);
      }
      else{                              //Ciclo normale
         GPIO1 = 0;
         if(GO_DONE == 0){                  //Aspetto che finisca la conversione
             new_value = (ADRESH<<8)|ADRESL;      //Leggo il valore iniziale
            if(abs(new_value-value)>soglia){
               GPIO5 = 1;
               delay_ms(1);
               GPIO5 = 0;
            }
            value = new_value;
            GPIO5 = 0;
            ADIF = 0;                     //Resetto il flag
            GO_DONE = 1;                  //Riavvio la conversione
         }
      }
   }
}

/* --------------------- FUNZIONI --------------------- */

/* Inizializzazione */
void initialize(void){
   TRISIO = 0b010101;               //Selezione ingressi
   GPIO = 0b000000;               //Uscite a 0

   CMCON = 0x00;                  //Disabilito comparatore
   ANSEL = 0x00;                  //Disabilito ADC

   GIE = 0;                     //Disabilito interrupt globali
   PEIE = 0;                     //Disabilito interrupt da periferiche
   ADIE = 0;                     //Disabilito interrupt AD
   OSCCAL = 0b111111;               //Dovrebbe impostare il clock interno alla frequenza massima

   ADCS2 = 0;                     //Seleziono velocità di conversione 8*Tosc
   ADCS1 = 0;
   ADCS0 = 1;
   
   ADFM = 1;                     //Seleziono che in ADESL metta il LSB e ADRESH il MSB
   VCFG = 0;                     //Seleziono voltaggio di reference Vcc, quindi il valore letto varia da 0 (V=0) a 1023 (V=Vcc)
   TRISIO0 = 1;                  //Imposto il canale 0 come ingresso
   ANS0 = 1;                     //Imposto il canale 0 come ingresso analogico
   CHS1 = 0;                     //Seleziono il canale 0 come ingresso per l'AD
   CHS0 = 0;
   
   soglia = SOGLIA;

   delay_ms(1);                  //Aspetto un attimo per inizializzazione
   ADON = 1;                     //Accendo AD
   delay_ms(1);                  //Aspetto un attimo per inizializzazione
   
   GO_DONE = 1;                  //Avvio lettura valore
   while(GO_DONE);                  //Aspetto che finisca la conversione
   value = (ADRESH<<8)|ADRESL;         //Leggo il valore iniziale
   ADIF = 0;                     //Resetto il flag
   GO_DONE = 1;                  //Riavvio la conversione
}

/* Delay */
void delay_ms(unsigned int D){
   unsigned int i, j;
   for(i=0; i<D; i++);
   for(j=0; j<1000; j++);
}

Qui potete trovare il PCB per realizzare il trigger.
Qui la maschera per posizionare i componenti, E$10 è un 7805, E$12 e E$13 sono due condensatori ceramici da 0.1uF e E$2 (quel cerchietto sopra alle piazzole dove va l'alimentazione) è un diodo tipo 1N4007 per evitare l'inversione di polarità nel caso ci si sbagli a collegare l'alimentazione. I pulsanti per la regolazione vanno messi tra P+ e P-. L'integrato in alto è l'LM358, mentre quello in basso è il PIC.

Io ho realizzato un involucro con l'attacco per la slitta del flash in modo da poterlo montare comodamente sulla fotocamera

Questo è un video in cui si vede il funzionamento del circuito, il test è stato fatto con un flash

Queste sono altre immagini catturate con il trigger

Nessun commento:

Posta un commento