[143] Arduino mierzy czasy migawek aparatów klasycznych cz. 1

Czasy świetności fotografii mamy już za sobą. Najpierw klasycznej, która 20 lat temu ustąpiła cyfrowej. W pierwszej dekadzie naszego wieku miała miejsce największa popularność tejże i wszyscy zachłysnęliśmy się możliwością nieskończonego pstrykania za darmo – oczywiście po wysupłaniu niemałej kwoty na sam aparat. Wówczas miało miejsce jeszcze jedno zjawisko: masowego pozbywania się aparatów klasycznych.

Po kolejnych kilku latach nastąpiły dwa nowe zjawiska: pierwsze to zmęczenie fotografią, której nagle wszędzie zrobiło się pełno. Drugie – oferowanie coraz lepszych aparatów w smartfonach, które najpierw zastąpiły kompakty, a potem aparaty ambitniejsze. Obecnie w miejscach atrakcyjnych turystycznie trzeba mieć szczęście, by zobaczyć kogoś z prawdziwym aparatem. I tu pojawiło się kolejne zjawisko, które znamy choćby z rynku audio.

Zaczęło się od wyciągania starych płyt ze strychów i pawlaczy, potem na rynku pojawiły się nowe tłoczenia i stało się to na tyle popularne, że nawet supermarkety, obok stoisk z warzywami mocowały półkę z płytami. Do łask wróciły kasety i walkmany. A co z fotografią? Nie na tę skalę oczywiście, ale wyraźnie więcej osób chce znowu fotografować na błonach i kliszach niż kilka lat temu. Toteż aparaty z duszą podrożały i ciężko już dziś znaleźć je przy śmietniku. Problem polega na tym, że te wszystkie gramofony, magnetofony i aparaty starzeją się. W przypadku sprzętu audio to po prostu słychać, z aparatem sprawa się komplikuje, bo jego niesprawność odkryjemy dopiero po wywołaniu filmu i to nie do końca jednoznacznie. W tym artykule będę chciał temu zaradzić.

Zacznijmy od podstaw: techniczne elementy dobrej fotografii to właściwa ostrość i ekspozycja. Pierwsza jest łatwa do weryfikacji – zdjęcie ostre od nieostrego odróżnimy od razu. Drugi element jest znacznie trudniejszy do identyfikacji, bo film jest tolerancyjny, ale nic za darmo: jeśli światła będzie za dużo albo za mało, wzrośnie ziarno, ubędzie szczegółów, tonalności i ogólnie wyjdzie lipa: zamiast pięknej analogowej fotografii zobaczymy tak zwaną pamiątkę z wakacji, o kiepskim kontraście i braku detali.

Na ekspozycję znowu mają wpływ trzy elementy: czułość filmu – tutaj musimy zaufać producentowi, przysłona – tę możemy sobie obejrzeć dokładnie pod światło i czas. I to z czasem jest problem, bo nasze oko nie jest w stanie określić, czy błysk światła trwał 1/100 sekundy czy 1/125. Ale od czego mamy Arduino? Niech ono się tym zajmie. I tak właśnie zrobimy.

Interfejs będzie wyjątkowo prosty. Będziemy potrzebować dwóch elementów: fototranzystora i rezystora. Fototranzystor może być dowolnego rodzaju i kształtu z jednym zastrzeżeniem: musi pracować w świetle widzialnym. To znaczy… nie musi, ale tak będzie o wiele wygodniej i do jego oświetlenia będziemy mogli użyć lampki czy latarki. Zatem elementy w charakterystycznych ciemnych czy czarnych obudowach odpadają. Element ze zdjęcia wykazuje maksimum czułości w świetle zielonym i minimalną latencję rzędu kilkunastu mikrosekund, więc nadaje się znakomicie. Jak zwykle użyję płytki edukacyjnej TME, bo mam tu wyświetlacz, który przyda mi się później, ale oczywiście można użyć jakiegokolwiek Arduino i elementów, które przedstawię, podłączanych osobno.

Emiter fototranzystora łączymy z masą, a kolektor z pinem drugim. Do tej końcówki trzeba będzie jeszcze podłączyć rezystor, którego drugi koniec należy połączyć z pięcioma woltami. Jaka jest wartość tego rezystora? Zaraz ją dobierzemy – u mnie wyszło 10 kΩ i od takiej zacząłbym. Na początku napiszmy krótki szkic testowy.

const int inputPin = 2;   // Pin wejściowy.
const int outputPin = 13; // Pin wyjściowy (wbudowana dioda).

void setup() {
  pinMode(inputPin, INPUT);
  pinMode(outputPin, OUTPUT);
}

void loop() {
  digitalWrite(outputPin, digitalRead(inputPin));
}

Deklarujemy porty: fototranzystora oraz diody świecącej, korzystając z pokładowej diody na porcie trzynastym. Cały program to nieustanne przepisywanie zaprzeczenia zawartości jednego portu w drugi. Po co nam to? By móc dobrać wartość rezystora i moc światła oświetlającego fototranzystor. Po skompilowaniu programu musimy uzyskać jednoznaczną odpowiedź: światło zasłonięte – dioda się nie świeci, fototranzystor oświetlony – dioda się świeci. Zaprzeczenie dorzuciłem po to, by obserwować błyski przy testach z migawką, człowiek o wiele lepiej widzi krótkie zapalanie się światła niż krótkie przerwy w jego świeceniu.

Skoro testy przejdą pozytywnie, czas na pierwszy użyteczny program. Będziemy mierzyć czasy migawek różnych aparatów, wstawiając po stronie obiektywu źródło światła – latarkę czy lampę biurową, a po stronie filmu nasz fototranzystor. Dobrze wykonywać te pomiary w półmroku, by obce źródła światła nie powodowały zakłóceń. Warto też na fototranzystor założyć czarną koszulkę, ograniczającą jego kąt widzenia. Przyjrzyjmy się programowi.

volatile unsigned long openingMoment = 0;  // Moment otwarcia migawki.
volatile unsigned long closingMoment = 0;  // Moment zamknięcia migawki.
volatile bool isMeasuring = false;         // Flaga - ustawiona, jeśli trwa pomiar.
const byte phototransistorPort = 2;        // Adres portu fototranzystora (2 albo 3)

void setup() {
  pinMode(phototransistorPort, INPUT);                                             // Deklaruj port fototranzystora jako wejście.
  Serial.begin(115200);                                                            // Inicjuj port monitora.
  attachInterrupt(digitalPinToInterrupt(phototransistorPort), interrupt, CHANGE);  // Włącz przerwania z portu fototranzystora.
}
void loop() {
  if (closingMoment > 0) {                                       // Jeśli pomiar jest zakończony...
    unsigned long exposureTime = closingMoment - openingMoment;  // Policz czas migawki.
    Serial.print(exposureTime);                                  // Wyświetl czas migawki.
    Serial.println(" µs");                                       // Wyświetl napis.
    closingMoment = 0;                                           // Wyzeruj licznik dla kolejnego pomiaru.
  }
}
void interrupt() {
  if (digitalRead(phototransistorPort) == LOW) {  // Jeśli migawka została otwarta...
    if (!isMeasuring) {                           // Jeśli nie było mierzenia...
      openingMoment = micros();                   // Wpisz stan micros do zmiennej momentu otwarcia migawki.
      isMeasuring = true;                         // Włącz flagę mierzenia.
    }
  } else {                       // Jeśli migawka została zamknięta...
    if (isMeasuring) {           // Jeśli było mierzenie...
      closingMoment = micros();  // Wpisz stan micros do zmiennej momentu zamknięcia migawki.
      isMeasuring = false;       // Wyłącz flagę mierzenia.
    }
  }
}

Przede wszystkim wyniki będziemy przesyłać na monitor, czyli na ekran komputera. Stąd odpowiednie definicje i przesłania. Na razie pomiary będziemy otrzymywać w mikrosekundach. Cała idea programu to wyzwalanie przerwań podczas zmiany stanu portu, do którego podłączony jest fototranzystor. Dlatego też na wstępie należy włączyć owe przerwania w trybie CHANGE, czyli zmiany. Przerwanie pojawi się zarówno przy zmianie stanu niskiego na wysoki jak i na odwrót. Z tego też powodu port fototranzystora można utworzyć z pinu 2 lub 3 tylko, bo inne nie obsługują przerwań zewnętrznych.

W samej obsłudze przerwania musimy rozróżnić czy migawka została otwarta (poziom niski), czy zamknięta (poziom wyskoki). W pierwszym przypadku, jeśli pomiar nie trwał, przepisujemy w zmienną openingMoment stan zmiennej systemowej o nazwie micros. Co to takiego? To taka zmienna w Arduino typu long, która zmienia się co mikrosekundę. Działa to zawsze i można wykorzystać między innymi do precyzyjnych pomiarów odcinków czasu. Na koniec trzeba ustawić flagę trwania pomiaru.

Jeśli migawka została zamknięta, a pomiar trwał, przepisujemy wspomniany micros do kolejnej zmiennej: closingMoment i zerujemy flagę mierzenia, czyli kończymy mierzenie. I to wszystko, jeśli chodzi o pomiar. W głównej pętli zajmujemy się przesłaniem wyników do komputera. A więc jeśli pomiar będzie większy od zera, stworzymy kolejną zmienną o nazwie exposureTime. Będzie ona różnicą czasu, kiedy migawka została otwarta i zamknięta. Teraz wystarczy ją wysłać, dopisując jeszcze symbol mikrosekund, bo w takich jednostkach mierzymy tu czas. Ach, jeszcze trzeba wyzerować ową zmienną. Dzięki temu wszystko odbywa się tu automatycznie, a wyniki nadchodzą kolejno, po kolejnym wyzwalaniu migawki.

Tak to wygląda w okienku monitora. Widzimy tutaj serię pomiarów migawki Nikona FG20. Jednak mikrosekundy nie są przyjazne fotografom, gdyż migawki zwykło określać się w ułamkach sekundy, najczęściej z pominięciem licznika. Przeróbmy więc szkic – ale o tym napiszę w kolejnym artykule.