Arduino-Projekt: Super 8 – Messkassette

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.

Messkassette für Super-8-Kameras

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.

Messkassette für Super-8-KamerasDie 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.

Schaltplan Super-8-MesskassetteDer 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.

Messkassette für Super-8-KamerasDas 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.

Messkassette für Super-8-KamerasDie 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.

Ein Kommentar zu „Arduino-Projekt: Super 8 – Messkassette

Hinterlassen Sie eine Antwort

Ihre E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind markiert *

Du kannst folgende HTML-Tags benutzen: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong>