Intervallaufnahme mit der Kamera ohne Interne Funktion

Die Funktion für eine Intervallaufnahme ist simpel, daher ist es für mich unverständlich, warum nicht zumindest die Systemkameras von der Nikon 1 Serie in ihren Modellen diese Option anbieten. Nun gut, dies war kein Kaufkriterium, wäre aber schön gewesen. Ich selbst verwende die Nikon 1 J3 (die J1 hat die Intervallaufnahme), allerdings sollte mein Beispiel auch für andere Kameras funktionieren. Grundsätzlich geht es darum einen Servo auf den Auslöser zu drücken. Für diesen Zweck habe ich aus Aluminium Eckschienen eine Vorrichtung gebaut.

Wie schon am Bild zu erkennen ist, sollten zum Schutz die Alu Eckschienen nach der Verarbeitung abgerundet und ggf. mit Filzaufklebern beklebt werden.

Die Materialliste:

• Alu Eckschienen ca. 20cm
• Filzaufkleber
• ein paar 3mm Schrauben und entsprechende Muttern
• Mini Servo mit ca. 10 Ncm
• Eine passende Schraube zur Kamera dass mit dem Stativ auch verschraubt werden kann. (siehe folgendes Bild)

Zum Ansteuern wird der Netduino mit einem passenden Shield zur Ansteuerung für einen Servo verwendet. Die geringe Belastung kann das Board verkraften. Bei Normalen und größeren Servos wird eine Externe Stromversorgung notwendig.

Der Aufwand des Programmcodes gestaltet sich übersichtlich. Zusehen ist, dass noch ein Analoger Wert eingelesen wird, worauf ich im nächsten Absatz zu sprechen komme.

public class Program {     // Für die Einstellung des Druckpunktes.     private static SecretLabs.NETMF.Hardware.AnalogInput _Input;     // Ansteuerung des Servos für den Auslöser.     private static PWM _Servo;     // Led Status wiedergeben.     private static OutputPort _Status;    // Einen Zähler.     private static int _IntervallCounter = 0;    // Nach wie viel Sekunden soll ausgelöst werden.    private static int _IntervallEnd = 15;//30;     public static void Main()     {         _Input = new SecretLabs.NETMF.Hardware.AnalogInput(Pins.GPIO_PIN_A0);         _Servo = new PWM(Pins.GPIO_PIN_D5);         _Status = new OutputPort(Pins.ONBOARD_LED, false);                     // 20ms für den Analog Servo.         uint periode = 20000;         // Mittelstellung bei 1,5ms         _Servo.SetPulse(periode, 1500);        while (true)         {            if (_IntervallCounter >= _IntervallEnd)             {                 for (int i = 0; i < 3; i++)                 {                     _Status.Write(true);                     Thread.Sleep(100);                     _Status.Write(false);                     Thread.Sleep(100);                 }                 // Hinweis: bei Netduino 1 wird ein Wert gelesen von 0 bis 1023.                 //          Der Netduino 2 hingegen liest bis 4095.                 //uint duration = 1000 + (uint)_Input.Read();         // Ein kommentieren um den Servo                 //Debug.Print("Duration: " + duration.ToString());  // einzustellen am Pin A1.                 _Servo.SetPulse(periode, 1710); // 1710 ist eine Einstellung, an meiner Kamera                 Thread.Sleep(400);                // Zähler Zurücksetzten.                 _IntervallCounter = 0;             }             else             {                 // Aktivität zeigen                 _Status.Write(true);                 Thread.Sleep(100);                 _Status.Write(false);                Thread.Sleep(900);                 _IntervallCounter++;             }            // Zurückstellen.             _Servo.SetPulse(periode, 1500);         }     } }

Das gleiche nochmal für den Arduino.

#include <Servo.h> // Servo Kontrolle anlegen Servo controlServo; // Einstellung wie weit sich der Servo drehen darf int pinAnalogIn = A0; // Servo ansteuern int pinServo = 5; // LED Status int pinLed = 13; // Intervall Zähler int intervall = 0; // IntervallLänge in Sekunden int intervallLength = 15; // 30; void setup(){   // Dient zu Einstellgunszwecke   Serial.begin(9600);   // Pins zuweisen   pinMode(pinAnalogIn, INPUT);   controlServo.attach(pinServo);   pinMode(pinLed, OUTPUT); } void loop() {   if(intervall >= intervallLength)   {     for(int i = 0; i < 3; i++)     {       digitalWrite(pinLed, HIGH);       delay(100);       digitalWrite(pinLed, LOW);       delay(100);     }        // Einkommentieren um die Reichweite des Servos einzustellen,     // mit einem Potitometer am Pin A1.     int result = 500; //analogRead(pinAnalogIn);         controlServo.write(map(result, 0, 1023, 0, 179));     delay(400);         // Zähler zurück setzen     intervall = 0;   }   else   {    digitalWrite(pinLed, HIGH);    delay(100);     digitalWrite(pinLed, LOW);     delay(900);     intervall++;   }     // Zurück stellen.   controlServo.write(90); }

Jetzt fehlt noch ein fester Wert für den Druckpunkt. Der Potentiometer wird an Pin A1 angeschlossen, die Spannungsversorgung muss beim Netduino mit 3,3V angelegt werden. Das Auslesen des Stellwertes erfolgt beim Netduino über Debug.Print() und wird über die Ausgabe angezeigt. Beim Arduino wird der Stellwert über dem Serial Monitor wiedergegeben. Je nach Belastung kann die Versorgung über USB instabil werden. Das zeigt sich dann, wenn der Servo beim Drücken des Auslösers leicht zittert. Später, mit einem 9V Akku oder Netzteil, sollten diese Schwierigkeiten nicht mehr auftauchen. Ansonsten muss der Servo einen eigenen Stromkreis erhalten, um zu verhindern, dass die Versorgung des Mikrocontrollers zu sehr schwankt und so zu einem Neustart des Programms führt.

Zu den Einstellungen der Kamera. Um ein schnelles Auslösen der Kamera zu ermöglichen, sollte auf den Kreativ Modus gewechselt werden. Die Blende, die Verschlusszeit und der Fokus sind am besten manuell festzulegen. Spätestens bei Nachtaufnahmen kommt man an diesen Einstellungen nicht vorbei. Achja, das Dateiformat JPG ist für die Ausgabe zu empfehlen. Mit dem NEF bzw. RAW ist das Bearbeiten im Video Schnittprogramm kaum machbar.

Tipp zur Nachtaufnahme: acht bis fünfzehn Sekunden für die Verschlusszeit bei maximal offener Blende reichen aus. Zu lange Belichtung führt dazu, dass die Sterne Streifen bilden, also praktisch gesehen wird die Erdrotation sichtbar. Die idealen Nächte mit Sternenhimmel sind in der Zeit um Neumond. Die besten Bedingungen sind Orte, die so dunkel sind, dass beim Hinabsehen die eigenen Füße nicht mehr zu sehen sind.

Nun noch ein paar Aufnahmen, die ich mit meiner Apparatur erstellt habe.

Zu guter Letzt auch noch der Quellcode zum Herunterladen.

• Netduino Codebeispiel mit .NET Micro Framework 4.2
• Arduino Codebeispiel

Netduino Sensor & Controller Shield für den Quadrocopter

Servo Test am neuen Neduino Shield

Irgendwann kommt die Zeit, dass man sich von Altem trennen muss. Besonders dann, wenn man einen Prototypen Shield hat, der aus zusammengesteckten Leiterbahnen besteht und dadurch viele Fehlerquellen haben kann. Zudem musste ich über eine weitere Schaltung das PWM Signal verstärken. So baumelte noch bis vor kurzem eine weitere Platine mit 4 Pegelwandlern am Shield. Eine wackelige Angelegenheit kann ich euch nur sagen...

Prototypen Shield mit zusätzlichen Pegelwandler

Am letzten Donnerstag kamen endlich die bestellten Arduino/Netduino Platinen aus China. Die Verarbeitung ist vernünftig und das Geld wert. Ich habe hier 4€ pro Stück bezahlt, zusätzlich Porto und Versand. Hier ist es sinnvoll gleich ein paar mehr zu bestellen. Den richtigen Pegelwandler habe ich erst aussuchen müssen. Ich habe zwei verschiedene bestellt, zum probieren. Entschieden habe ich mich für den 74HCT125N. Der Pegelwandler soll später das Pulssignal bzw. PWM von 3,3V auf 5V anheben. Zwar geht es auch mit 3,3V, aber ich habe öfters keine Reaktion beim Steuern der Servos oder Regler gehabt. Erst mit dem selbstgebastelten Pegelwandler war das Signal stabil.

Links ist der 74HCT125N und rechts der 74HCT245N

Ich überlegte zunächst, wie ich meine Sensoren anordne und wo ich später den Pegelwandler mit den Anschlüssen positioniere. Hinzu kam noch ein Anschluss für den Lithium Polymer Akkumulator, der den Mikrocontroller mit Strom versorgt. Später soll auch die Kapazität gemessen werden, sobald ich damit ein paar Versuche durchgeführt habe. Am Ende habe ich dann für mein Netduino folgende Bauteile verwendet:

- Arduino Platine - Buchsenleisten - Stiftleisten - einen Pegelwandler (74HCT125N) - Buchse für einen 3S LiPo Akku - Gelbe 3mm LED mit 20mcd Leuchtkraft - 150Ohm Widerstand - Druckknopf.

Zusätzlich kamen natürlich auch Kabel und Überbrückungstücke hinzu, um den richtigen Schaltkreis herzustellen. Nachdem ich mit dem Löten fertig war, musste ich noch das Lötfett entfernen. Das ging am besten mit heiß Wasser und Seife (mit anschließendem ausreichenden Trocknen, versteht sich).

Mein fertiges Netduino Shield, (oder fast fertig)

Das was nicht so schön ist habe ich auf der Unterseite verlötet.

Gelb sind die Signalleitungen. Rot für anliegende Spannung, wie z.B. +5V.

Nun kurz zur Erklärung der Funktionsweise des Shields:

• Die LED soll später die Aktivität des Controllers wiedergeben.
• Auf den Buchsen wird der Beschleunigungssensor gesteckt, um die Lage des Quadrocopter zu stabilisieren.
• Auf die vier 3-Pin Anschlüsse kommen jeweils die Regler für die Brushless Motoren. Das PWM Signal wird zuvor mit dem Pegelwandler von 3,3V auf 5V angehoben.
• Die weisse Buchse ist der Anschluss für einen 3S LiPo Akku, um den Netduino mit Strom zu versorgen.

Das sind noch nicht alle Funktionen, die ich für dieses Shield geplant habe. Wenn ich mit den Tests soweit durch bin, kann ich sicher ohne weiteres die Platine mit den erforderlichen Bauteilen ergänzen.
Geplant sind noch:

• Magnetsensor
• Gyroskop
• Akkukapazitätsmessung
• Anschluss für ein Display