Ho terminato il test e liberata la scrivania da tutto l'ambaradan che è stato necessario predisporre per la verfica sul campo (la moglie è stata molto paziente per tutto il tempo in cui la stanza dei nostri figlioli, al momento lontani da casa, si è trasformata poco alla volta in un cantiere).
Anche questa volta in un video ho raccolto alcuni scatti per illustrare quanto si possa realizzare con l'ausilio del microprocessore Arduino o comunque da un qualsiasi altro micro programmabile. Ad ogni scatto sono stati regolati i livelli e il contrasto.
http://imageshack.us/clip/my-videos/809/ie6.mp4/Nel corso dei test è stato necessario apportare alcune modifiche al progetto ma li analizzeremo alla fine del 3D. Per ottenere un flusso di gocce di uguali caratteristiche ho utilizzato una bottiglia di Mariotte che consente di mantenere la pressione costante all'ingresso della valvola al variare del livello del liquido nella bottiglia. La si può costruire riciclando un flacone di detersivo liquido e una cannuccia. Una volta reso solidale il gruppo elettrovalvola/sensore passaggio goccia è stato possibile iniziare i primi test reali. La parte software era già stata testata grazie ai led di monitoraggio.
L'idea progettuale è stata, fin dall'inzio, quella di costruire un meccanismo molto flessibile in grado di consentire di fotografare una singola goccia durante la sua caduta e le fasi di rimbalzo e la collisione tra quanto rimbalza dalla caduta di una prima goccia e una seconda rilasciata ad hoc. Potere ripetere uno scatto, nei limiti tecnici dell'attrezzatura utilizzata, offre opportunità che non è possibile ottenere dalla casualità di una naturale caduta di gocce. Le prime foto del video mostrano che la scena si può riprodurre quante volte si vuole ritrovando, con ragionevole probabilità, la goccia nella stessa posizione.
Nell'acquisire le conoscenze necessarie per realizzare il progetto ho trovato in rete un 3D sul forum di Arduino dell'utente Jens (
http://www.arduino.cc/cgi-bin/yabb2/YaB ... 45507913/0 ) che ringrazio per il codice che ha scritto e reso pubblico e che mi ha permesso di realizzare quanto mi ero prefissato; nel corso delle prove ho apportato delle modifiche per rendere più flessibile il suo uso evitando di dovere intervenire continuamente sui parametri di funzionamento.
Ma come funziona il tutto?
Il programma esegue le seguenti operazioni:
a) attende che si pigi il tasto di start
b) alimenta il fotodiodo a infrarosso
c) apre l'otturatore della macchina
d) apre l'elettrovalvola per tot millisecondi
e) attende che il sensore di passaggio goccia ne rilevi il transito
d) dopo il rilievo di transito attende tot millisecondi e poi comanda l'accensione del flash
e) dopo 50 ms rilascia il comando di apertura dell'otturatore e spegne il led ad infrarosso.
f) attende 20 secondi e poi si predispone ad un nuovo ciclo.
I 20 secondi sono necessari per ricaricare il flash, per stabilizzare la superficie dell'acqua in cui cade la goccia, per trasferire a mezzo di un programma tipo PK-tether la foto al pc, intervenire per ottimizzare il punto di messa a fuoco o i parametri del flash.
Occorre personalizzare alcuni parametri altrimenti non si fotografa nulla.
Considerando che ho utilizzato una vecchia elettrovalvola (ovvero quella utilizzata per lo stop benzina negli impianti a gas per auto con carburatore) e avendo posto la bottiglia di mariotte a 30 cm al dispora di essa, il tempo minimo di apertura, per avere con elevata probabilità il rilascio di una goccia, è risultato pari a 15-20 ms.
Serve poi il valore del ritardo tra la rilevazione del transito della goccia e quando essa toccherà la superficie dell'acqua; per un dislivello di 90 cm necessitano circa 280ms.
Con questi parametri è già possibile provare uno scatto e ripeterlo quante volte vogliamo. Il risultato sarà una serie di foto quasi tutte uguali visto che la forza di gravità non cambia, la distanza tra ugello e superficie è sempre la stessa e il ritardo di funzionamento del flash è irrisorio.
E' evidente che per avere una diversa immagine bisogna variare il parametro tempo tra la rilevazione del transito della goccia e l'accensione del flash. Dopo i primisssimi test mi sono convinto che non era affatto comodo modificare questo parametro dopo ogni scatto visto che il microprocessore era utilizzato nella sua forma base ovvero senza opzional quali un micromonitor e altre amenità.
Dunque, con molta pazienza, ho aggiunto al programma altri comandi e in questa ultima versione prima di trasferire al microcontrollore il programma è necessario settare alcuni parametri per fotografare momenti diversi dell'evento. In pratica occorre valorizzare i seguenti parametri:
1) il numero di scatti da eseguire
2) il tempo base della prima apertura dell'elettrovalvola
3) Il tempo base di attesa per la riapertura dell'elettrovalvola
4) il tempo base della seconda apertura della elettrovalvola
5) il tempo base di ritardo tra la rilevazione del passaggio della goccia e lo scatto del flash
6) i singoli valori di incremento dei parametri base per i punti 2,3,4,5
7) il valore di incremento del tempo base per il punto 5 in microsecondi ( 1000 micro = 1 millisecondo)
Non vi spaventate basta poco per famigliarizzare con questi dati ma è stato necessario inserirli perchè il programma è ora decisamente più flessibile. Un esempio.
Vogliamo scattare una sequenza di foto seguendo passo passo la goccia dal momento che entra nella visuale del sensore fino a che termini di sobbalzare sulla superficie dell'acqua.
Impostiamo 10 scatti da eseguire; 15 ms la prima apertura della valvola; a zero il tempo al punto 3 e 4 ovvero la valvola aprirà solo una volta rilasciando una goccia; a 280ms il punto 5; a 10 ms l'incremento ad ogni ciclo del tempo base al punto 5. Tutti gli altri parametri a zero.
Ovvero
int scatti = 10;
int ritardoFlash_milli = 280;
int ritardoflash_Micro = 0;
int aperturaValvola = 15;
int attesaRiaperturaValvola =0;
int secondaAperturaValvola =0;
int plus_milli = 10;
int plus_micro = 0;
int plus_apert_valvola = 0;
int plus_riapert_valvola = 0;
int plus_seconda_apert_valvola = 0;
Ora trasferiamo il programma sul microprocessore e pigiamo il pulsante di start.
Dopo il primo scatto il programma incrementa di 10 ms il tempo al punto 5,si predispone per il secondo scatto che avverà dopo la pausa imposta dal punto f e così lo incrementerà per i successivi scatti. Al termine dell'intero ciclo avremo realizzato 10 scatti in cui si vedrà di quanto si è spostata la goccia dopo 10ms.
Modificando sia il tempo base che l'incremento sarà possibile fotografare altri momenti del percorso della goccia.
Ad esempio possiamo verificare quale è il minimo tempo necessario alla goccia per entrare nel campo di ripresa del sensore e l'ultimo tempo in cui non è più significativa la sua oscillazione nell'acqua. Basta ridurre il tempo ritardoFlash_milli = 280; e aumentare plus_milli = 10 per risparmiare scatti.
Oppure sarà possibile scattare n fotogrammi con un incremento di 1 ms per documentare tutto il percorso fatto dalla goccia per poi utilizzare questi fotogrammi per montare un video simile a quello che ho postato all'apertura del 3D.
Sarà possibile posizionarsi al momento in cui la goccia è prossima a toccare la superficie dell'acqua e incrementare il tempo base anzichè in ms in microsecondi per cogliere i dettagli dell'impatto.
La vera forza del progetto è la sua flessibilità e se avete osservato con attenzione il video lo avevte già intuito .
Ora parliamo di collisione. Nel primo video si nota che la goccia è penetrata nell'acqua spostando una piccola massa d'acqua verso il fondo che poco dopo ritorna in superficie e avendo ancora energia da dissipare si alza di qualche cm dalla superficie. E' questo il momento buono per farla collidere con una seconda goccia . Nei primi scatti abbiamo fotografata la goccia nel suo cadere e pertanto conosciamo sia il tempo che impiega ad arrivare in prossimità della superficie che quello in cui ha la massima emersione dalla superficie; nel mio esempio 390ms e 290 ms. La differenza tra i due tempi è, con una buona approssimazione, il ritardo da impostare tra le due aperture della elettrovalvola. Aggiorniamo i parametri e trasferiamoli sul microprocessore:
int scatti = 10;
int ritardoFlash_milli = 390;
int ritardoflash_Micro = 0;
int aperturaValvola = 15;
int attesaRiaperturaValvola =100;
int secondaAperturaValvola =15;
int plus_milli = 1;
int plus_micro = 0;
int plus_apert_valvola = 0;
int plus_riapert_valvola = 0;
int plus_seconda_apert_valvola = 0;
Dopo lo start si accende il led ad infrarosso; si apre l'otturatore; si apre l'elettrovalvola e poi si chiude; dopo che sono trascorsi 100ms si riapre l'elettrovalvola; viene abilitata la rilevazione del transito della goccia (la prima è già passata davanti al sensore); il flash sarà attivato dopo 390 ms; dopo dieci scatti distanziati di 1ms la sequenza si arresterà. Visionate le foto e in base ai risultati decidete quali parametri variare per ottenere risultati diversi.
Siamo giunti alla metà del video. Gli scatti sono stati realizzati riempiendo di acqua la bottiglia di mariotte mentre i vari recipienti che raccoglievano la goccia sono stati riempiti con acqua, con acqua colorata con tempera gialla, con acqua e sciroppo di orzata.
Negli ultimi scatti ho utilizzato la tempera liquida sia nel raccoglitore che nella bottiglia di mariotte. I primi scatti con tempera bianca i gli ultimi caricando la sola bottiglia con acqua colorata con tempera blu acquamarina. Ora la goccia che cade non è più trasparente e lo sfondo non interferisce con la sua colorazione.
Mia figlia dopo avere visto il video mi ha scritto : papà belle foto (inconscio e puro incoraggiamento familiare ); mi sono piaciute le ultime che sembrano sculture.
In effetti alcuni scatti somigliano a piccole sculture. Come si può passare dalla collisione alle sculture? Avrete notato che fino ad ora alcuni parametri non sono stati valorizzati. Provate con questi:
int scatti = 10;
int ritardoFlash_milli = 390;
int ritardoflash_Micro = 0;
int aperturaValvola = 15;
int attesaRiaperturaValvola =100;
int secondaAperturaValvola =15;
int plus_milli = 0;
int plus_micro = 0;
int plus_apert_valvola = 5;
int plus_riapert_valvola = 0;
int plus_seconda_apert_valvola = 0;
Dopo lo start si accende il led ad infrarosso; si apre l'otturatore; si apre l'elettrovalvola e poi si chiude; dopo che sono trascorsi 100ms si riapre l'elettrovalvola; viene abilitata la rilevazione del transito della goccia (la prima è già passata davanti al sensore); il flash sarà attivato dopo 390 ms;
sarà incrementato di 5ms il tempo della prima apertura dell'elettrovalvola; saranno eseguiti 10 scatti in cui progressivamente ci sarà un maggiore passaggio di gocce o acqua mentre il ritardo del flash sarà sempre lo stesso. Ora avete 4 parametri con cui giocare in tutte le possibili combinazioni;
aggiungete le variabili derivanti dalla giometria del recipiente che raccoglie le gocce, l'altezza da cui cade la goccia, i liquidi che potete utilizzare e le colorazioni che potete usare e vi convincerete che quando fuori piove o fa freddo si possono passare piacevoli ore scattando foto al calduccio e al buio. Fa parte del divertimento predisporre il set e attendere il dopo scatto per vedere cosa si è fotografato soprattutto dopo avere modificato qualche parametro.
Di seguito lo schema aggiornato e il programma da caricare su Arduino.
Vi ricordo che se volete ripetere una sequenza di scatti dovete prima resettare Arduino, con l'apposito tastino, altrimenti i tempi incrementati resteranno tali.
http://imageshack.us/clip/my-videos/818/iy6.mp4/
int PinPulsante = 2; // Il pulsante di start è connesso al pin 2
int PinScatto = 3; // Il comando scatto otturatore è connesso al pin 3
int PinValvola = 4; // L'elettrovalvola è connessa al pin 4
int PinFlash = 5; // Il comando scatto del flash è connesso al pin 5
int Pinscattidiodo = 6; // Il rilevatore di passagio goccia è connesso al pin 6
int PinLed = 9; // Alimenta il led ad infrarosso
int i = 0; // Variabile di servizio
int varloop = 0; // Variabile per il rilevatore passaggio goccia.
int val = 0; // Variabile per controllare se la goccia è stata vista passare dal rilevatore
int pulsante = 0; // Variabile per controllare se il pulsante di start è stato pigiato
int numero = 0; // Variabile denominazione file
int scatti = 20; // Numero di scatti da effettuare dopo lo start
int ritardoFlash_milli = 390; // Ritardo comando scatto flash in millisecondi
int ritardoflash_Micro = 50; // Ulteriore ritardo comando scatto flash in microsecondi (1000= 1 millisecondo)
int aperturaValvola = 15; // Tempo prima apertura elettrovalvola per erogare la prima goccia
int attesaRiAperturaValvola =100; // Ritardo tempo seconda apertura elettrovalvola per erogare la seconda goccia
int secondaAperturaValvola =0; // Tempo seconda apertura elettrovalvola per erogare la seconda goccia
int plus_milli = 0; // Incremento in milli ritardo scatto flash
int plus_micro = 500; // Incremento in micro ritardo scatto flash
int plus_I_apert_valvola = 0; // Incremento in millisecondi del tempo della prima apertura valvola
int plus_riapert_valvola = 0; // Incremento in millisecondi del tempo di attesa II apertura valvola
int plus_II_apert_valvola = 0; // Incremento in millisecondi del tempo della seconda apertura valvola
int interdizione = 15000; // Attesa per lo scatto successivo
void setup()
{
pinMode(PinPulsante, INPUT);
pinMode(PinScatto, OUTPUT);
pinMode(PinValvola, OUTPUT);
pinMode(PinFlash, OUTPUT);
pinMode(Pinscattidiodo, INPUT);
pinMode(PinLed, OUTPUT);
Serial.begin(9600);
Serial.println("CLEARDATA");
Serial.println("LABEL,Ora,Foto,Ritardo_mill,Ritardo_micro,I Apertura,Attesa riapertura,II Apertura ");
}
void loop()
{
pulsante = digitalRead(PinPulsante);
for (i = 1; i <= scatti; i++)
{
if (pulsante == HIGH)
{
varloop = 0;
}
else
{
Inizio_Sequenza();
while(varloop != 1)
{
scattoFlash();
}
varloop = 0;
}
}
}
int Inizio_Sequenza()
{
digitalWrite(PinLed, HIGH); // alimenta il led ad infrarosso
delay(500);
digitalWrite(PinValvola, HIGH); //comando apertura dell'elettrovalvola
delay(aperturaValvola); //tempo di apertura dell'elettrovalvola
digitalWrite(PinValvola, LOW); //comando chiusura dell'elettrovalvola
delay(attesaRiAperturaValvola); //tempo attesa per seconda apertura dell'elettrovalvola
digitalWrite(PinValvola, HIGH); //comando apertura dell'elettrovalvola
delay(secondaAperturaValvola); //tempo di apertura dell'elettrovalvola
digitalWrite(PinValvola, LOW); //comando chiusura dell'elettrovalvola
}
int scattoFlash()
{
digitalWrite(PinScatto, HIGH); // comanda l'apertura dell'otturatore
val = digitalRead(Pinscattidiodo); // il fotodiodo controlla se la goccia è transitata
if (val == HIGH)
{
delay(ritardoFlash_milli); // primo ritardo in millesecondi
delayMicroseconds(ritardoflash_Micro); // secondo ritardo in microsecondi
digitalWrite(PinFlash, HIGH); // chiusura contatto caldo del flash
delay(50);
digitalWrite(PinFlash, LOW); // apertura contatto caldo del flash
delay(50);
digitalWrite(PinScatto, LOW); // comanda chiusura otturatore
digitalWrite(PinLed, LOW); // disalimenta il led ad infrarosso)
Serial.print("DATA,TIME,");
Serial.print("DCIM_");Serial.print(numero); Serial.print(",");
Serial.print(ritardoFlash_milli); Serial.print(",");
Serial.print(ritardoflash_Micro); Serial.print(",");
Serial.print(attesaRiAperturaValvola);Serial.print(",");
Serial.println(secondaAperturaValvola);
ritardoFlash_milli = ritardoFlash_milli + plus_milli;
ritardoflash_Micro = ritardoflash_Micro + plus_micro;
aperturaValvola = aperturaValvola + plus_I_apert_valvola;
attesaRiAperturaValvola = attesaRiAperturaValvola + plus_riapert_valvola;
secondaAperturaValvola = secondaAperturaValvola + plus_II_apert_valvola;
numero++;
delay(interdizione); // Attesa per lo scatto successivo
varloop = 1;
}
}
Gironzolando in rete ho trovato questo blog scritto da un nikoniano ma che merita di essere letto.
http://marcocrupifoto.blogspot.com/2011 ... zione.htmlHo apportato, ai primi del 2012, una modifica al flusso del programma in modo da ridurre il tempo complessivo di apertura dell'otturatore.
