12
/
11/2013

DIY Tonauslöser (I)

Bursting water balloon

So sieht es aus, wenn sich die Hülle eines mit Wasser gefüllten Luftballons verabschiedet und die Tropfen für den Moment des Schreckens träge in der Luft verharren.

Momentaufnahmen wie diese, das Platzen einer Wasserbombe, das Bersten von Glas oder die Explosion eines Eis bringen Laien wie Fotografen immer wieder zum Staunen. Kamera und Blitz im genau richtigen Moment auszulösen gleicht einem Glücksspiel.

Mit technischer Unterstützung kann das Gelingen der Aufnahme jedoch beinahe wortwörtlich vorprogrammiert werden. Im Folgenden möchte ich einen Vorschlag vorstellen, wie man im Eigenbau einen Tonauslöser realisieren, programmieren und verwenden kann. Als Helferlein kommt bei mir der Raspberry Pi zum Einsatz.
Verbesserungsvorschläge und Anmerkungen aller Art sind natürlich herzlich Willkommen, dazu einfach unter dem Eintrag einen Kommentar verfassen ;-)

gphoto am Raspberry Pi

Als ersten Versuch schloss ich die Kamera über USB an den Pi an. Mit gphoto, eine Sammlung von Unix-Programmen zur Komminaktion mit wirklich fast jedem Kameramodell, war auch schnell ein Programm gefunden, das den Kamerazugriff vom Computer ermöglicht.
Mit gphoto2 --capture-image lässt sich die Kamera bequem per Kommandozeile auslösen. Darüber verfügt gphoto über allerhand Funktionen, vom Ausgeben der Einstellungen, der Video- und Tonaufnahme bis zum Kopieren der RAW-Dateien.

Leider war schnell festzustellen, dass sich gphoto nicht für den angestrebten Tonauslöser gebrauchen lässt. Nach Bestätigen des Kommandos dauerte es geschlagene 24 Sekunden, bis die Kamera den Erhalt des Befehls mit einem Spiegelklappen quittierte. Nach Leeren der Speicherkarte reduzierte sich die Latenz immerhin auf "nur" drei Sekunden, doch ob die Tropfen einer platzenden Wasserbombe drei Sekunden in der Luft schwebend gegen die Schwerkraft ankämpfen möchten, ist zu bezweifeln.

Eine schellere Lösung musste her. Nach kurzer Recherche stieß ich bei doc-diy.net auf eine Liste der Pinouts von Fernauslösern für viele Kameramodelle und -hersteller. Wer keine D90, D7100, D300, D700 oder D800 hat, der kann sich auf dieser Seite über den Anschluss seiner Kamera informieren. Nikon ist leider Führer an Erfinderreichtum bei der Entwicklung neuer Stecker. Für die genannten Modelle habe ich die Pinbelegung und ein passendes Anschlusskabel parat.

Für die Nikon D90 und D7100 eignet sich ein Kabel ähnlich dem MC-D2 (z.B. das hier), für die D300, D700, D800 ähnlich dem des MC-30 (z.B. hier enthalten).

Schaltung des Auslösers

Schneidet man das Kabel auf, kommen drei Drähte zum Vorschein. In meinem Fall sind sie grün, blau und rot. Der grüne Draht steht für den Fokus (Focus), das rote für den Auslöser (Shutter) und das blaue für die Masse (GND). Schließt man Focus und GND kurz, ist bereits zu hören, wie die Kamera fokussiert und wenn vorhanden der Bildstabilisator anspringt. Hält man zusätzlich Shutter dazu (d.h. Focus und GND sowie Shutter und GND sind kurzgeschlossen), sollte die Kamera auslösen.
Bei wem die Drähte mit anderen Farben isoliert sind, der sollte mit dem Messgerät die Enden vergleichen. [Bilder dazu folgen.]

Das Verbinden der Drähte wollen wir so eine Schaltung gießen, dass die Kamera von der Kommandozeile bzw. programmgesteuert ausgelöst werden kann.
Schaltplan Kameraauslöser Dazu verwenden wir zwei GPIOs vom Raspi für Focus und Shutter und zwei NPN-Transistoren (z.B. BC547C) als Schalter. Wird der obere GPIO aktiviert, verbindet der obere Transistor Kollektor und Basis, und die Kamera empfängt das Signal zu fokussieren.
Aktivieren wir zusätzlich den unteren GPIO, werden Shutter und GND kurzgeschlossen und die Kamera löst aus. Dabei ist zu beachten, dass Focus weiterhin aktiviert bleibt.

Sobald die Schaltung verlötet ist, die Seite links an die GPIOs des Raspi angeschlossen und das Ende des Auslöserkabels in der Kamera steckt, können wir uns an die Programmierung machen. Im Folgenden habe ich den Focus Pin an GPIO 0 und den Shutter Pin an GPIO 2 angeschlossen (und GND an GND natürlich).

Ansteuern mit WiringPi

Zum Ansteuern der GPIOs des Raspi über die Kommandozeile empfiehlt sich wegen ihrer einfachen Bedienung die WiringPi library, welche wir nun installieren wollen.

Zuerst müssen wir GIT installieren.

sudo apt-get install git-core

Wer dabei mit Fehlermeldungen kämpfen muss, sollte sein System auf dem neusten Stand bringen:

sudo apt-get update
sudo apt-get upgrade

Über GIT kann wiringPi heruntergeladen und installiert werden.

git clone git://git.drogon.net/wiringPi
cd wiringPi
./build

Nun sollte wiringPi erfolgreich installiert und zur Verwendung bereit sein.
Schauen wir uns zuerst den Status der GPIOs an.
($-Zeichen nicht eingeben. Das sei nur zur Verdeutlichung, dass diese Zeile vom Benutzer eingeben wird, während Zeilen ohne $-Zeichen als Ausgabe erscheinen.)

$ gpio readall
+----------+-Rev2-+------+--------+------+-------+
| wiringPi | GPIO | Phys | Name   | Mode | Value |
+----------+------+------+--------+------+-------+
|      0   |  17  |  11  | GPIO 0 | IN   | High  |
|      1   |  18  |  12  | GPIO 1 | IN   | High  |
|      2   |  27  |  13  | GPIO 2 | IN   | High  |
|      3   |  22  |  15  | GPIO 3 | IN   | Low   |
|      4   |  23  |  16  | GPIO 4 | IN   | High  |
|      5   |  24  |  18  | GPIO 5 | IN   | High  |
|      6   |  25  |  22  | GPIO 6 | IN   | Low   |
|      7   |   4  |   7  | GPIO 7 | IN   | Low   |
|      8   |   2  |   3  | SDA    | ALT0 | High  |
|      9   |   3  |   5  | SCL    | ALT0 | High  |
|     10   |   8  |  24  | CE0    | ALT0 | High  |
|     11   |   7  |  26  | CE1    | ALT0 | High  |
|     12   |  10  |  19  | MOSI   | ALT0 | Low   |
|     13   |   9  |  21  | MISO   | ALT0 | Low   |
|     14   |  11  |  23  | SCLK   | ALT0 | Low   |
|     15   |  14  |   8  | TxD    | ALT0 | High  |
|     16   |  15  |  10  | RxD    | ALT0 | High  |
|     17   |  28  |   3  | GPIO 8 | IN   | Low   |
|     18   |  29  |   4  | GPIO 9 | IN   | Low   |
|     19   |  30  |   5  | GPIO10 | IN   | Low   |
|     20   |  31  |   6  | GPIO11 | IN   | Low   |
+----------+------+------+--------+------+-------+

Es ist zu erkennen, dass alle relevanten GPIOs auf ein Eingangssignal warten. Durch Setzen des Modus markieren wir GPIO 0 und GPIO 2 als Ausgang.

gpio mode 0 out
gpio mode 2 out

Zum Ausprobieren geben wir der Kamera eine Sekunde Zeit zum Fokussieren, drücken daraufhin den Auslöser quasi durch und erlösen ihn nach einer weiteren Sekunde wieder. Je nach Belichtungszeit nimmt die Kamera dabei mehr als ein Foto auf.

gpio write 0 1 && (sleep 1; gpio write 2 1) && (sleep 1; gpio write 0 0; gpio write 0 0)

Der &&-Operator führt jeweils seinen rechten Befehl aus, wenn der linke erfolgreich abgeschlossen wurde.

Jetzt können wir die Kamera ohne größere Latenz von der Kommandozeile auslösen. Im nächsten Schritt kommt dann der Ton ins Spiel.

+

Einen Kommentar hinzufügen

Name: 
eMail*: 
Wie viel ist 3 + 5? 
 

*) Die eMail-Adresse wird nicht veröffentlicht.