Läuft meine Super-8-Kamera konstant mit 18 bzw. 24 Bildern pro Sekunde? Und wie lang ist die Belichtungszeit genau? Mit meiner Super-8-Messkassette, bestehend aus Arduino und Fototransistor, kann ich mir diese Fragen jetzt präzise beantworten – ohne einen Testfilm zu opfern.
Der Fototransistor steckt in einer leeren Super-8-Kassette – dort, wo normalerweise das Filmbild belichtet wird, direkt gegenüber des Filmfensters der Kamera. Der Transistor kann auch sehr kurze Hell-Dunkel-Unterschiede wahrnehmen und übermittelt sie in Form eines kleinen Stroms an das Arduino-Board. Das zählt mittels Software, wie oft Impulse ankommen bzw. wie lange sie bestehen.
Die Spule, auf der sich normalerweise der unbelichtete Film befindet, ist fest mit der Kassette verklebt. Das aktiviert die Rutschkupplung der Kamera und simuliert “Zug”, als ob wirklich Film durch die Kamera laufen würde.
Die eigentliche Elektronik besteht nur aus zwei Widerständen: einem Pull-Up-Resistor für den Eingangspin des Arduino, und dem Vorwiderstand für den Fototransistor. Ein Taster ist mit einem weiteren Eingangspin verbunden. Mit ihm startet man die Messung. Die Bauteile habe ich auf einer Lochrasterplatine angebracht, die als simples “Shield” auf den Arduino aufgesteckt wird.
Der Schaltplan ist sehr simpel und lässt sich schnell aufbauen.
Die eigentliche Messung der Bildfrequenz ist ebenso einfach: Kassette in Kamera einlegen, Objektiv vor Lichtquelle (z.B. Schreibtischlampe) platzieren, Kamera auf die gewünschte Geschwindigkeit einstellen.
Dann die Kamera einige Sekunden laufen lassen, während die Kamera schon läuft den Taster drücken, und das Messergebnis abwarten.
Dabei muss der Arduino an einen PC angeschlossen und folgendes Programm hochgeladen sein:
int ButtonPin = 10; int ButtonState = 0; int lastButtonState = 0; int LightPin = 2; int LightState = 0; int lastLightState = 0; long counter = 0; boolean Messung = 0; unsigned long Startzeit = 0; unsigned long Messzeit = 0; unsigned long ZeitseitMessstart = 0; int Messdauer = 10000; double fps = 0; void setup() { pinMode(ButtonPin, INPUT); pinMode(LightPin, INPUT); Serial.begin(9600); } void loop() { ButtonState = !digitalRead(ButtonPin); LightState = !digitalRead(LightPin); if (ButtonState != lastButtonState) { if (ButtonState == HIGH) { Startzeit = millis(); counter = 0; Messung = HIGH; Serial.println("Messung gestartet."); lastButtonState = HIGH; } } if (Messung == HIGH) { Messzeit = millis(); ZeitseitMessstart = Messzeit-Startzeit; if (ZeitseitMessstart >= Messdauer) { Messung = LOW; ZeitseitMessstart = 0; fps = counter; counter = 0; lastButtonState = LOW; fps = fps / (Messdauer/1000); Serial.print("Messung beendet: "); Serial.print(fps); Serial.println(" fps"); } } if (LightState != lastLightState) { if (LightState == HIGH) { counter++; } } lastLightState = LightState; }
Das Programm arbeitet so, dass zehn Sekunden lang jeder Lichtimpuls gezählt, und anschließend durch zehn geteilt wird, um den Mittelwert für eine Sekunde Laufzeit zu errechnen. Zählt der Arduino beispielsweise 172 Impulse, sind das durchschnittlich 17,2 fps.
Das Programm, das die durchschnittliche Belichtungszeit misst, sieht so aus:
/* millisDuration Sketch Gibt an, wie lange (in Millisekunden) eine Taste gedrückt wude */ const int switchPin = 2; // Eingangspin long startTime; // millis-Wert beim ersten Drücken der Taste long duration; // Variable für die Dauer int framecounter; long belichtungszeit; float ergebnis; float endergebnis = 0; int Messung = 0; void setup() { pinMode(switchPin, INPUT); digitalWrite(switchPin, HIGH); // Pullup-Widerstand aktivieren Serial.begin(9600); } void loop() { if(digitalRead(switchPin) == LOW) { // Sobald die Taste gedrückt wurde Messung = HIGH; startTime = micros(); while(digitalRead(switchPin) == LOW) ; // Warten, solange die Taste gedrückt wird long duration = micros() - startTime; belichtungszeit = belichtungszeit + duration; framecounter++; ergebnis = duration; ergebnis = ergebnis / 1000; endergebnis = endergebnis + ergebnis; } if (Messung = HIGH && framecounter >= 100) { endergebnis = endergebnis / 100; endergebnis = 1000 / endergebnis; Serial.print("Durchschnittliche Belichtungszeit: 1 / "); Serial.print(endergebnis); Serial.println(" s"); framecounter = 0; Messung = LOW; } }
Es misst die Dauer der einzelnen Impulse, addiert sie über eine Spanne von 100 Bildern und bildet wieder den Mittelwert.
Die ursprüngliche Idee war, den Arduino selbst in die Kassette zu integrieren (z.B. mit einem Arduino micro), zusammen mit Taster, Batterien und einer 7-Segment-LED-Anzeige, die die Messwerte anzeigt. Da aber verschiedene Kamerytypen existieren (bei manchen schiebt man die Kassette von der Hinterseite ins Fach, bei anderen Kameras legt man sie von der Seite ein), müsste man wohl zwei verschiedene Varianten bauen. Daher scheint es am einfachsten, die Kassette mit dünnen Leitungen an das Shield anzuschließen. So kann man das Kassettenfach während der Messung problemlos schließen.
Abschließend möchte ich noch einmal darauf hinweisen, dass ich kein Programmierer bin, und es sicherlich einen effizienteren Weg gibt, dem Arduino das Zählen beizubringen. Für Verbesserungsvorschläge in den Kommentaren bin ich natürlich offen.
Muss unbedingt auch zu filmkorn.org – super Sache!