Follow Focus – DIY mit Arduino und Schrittmotor

Beim Arbeiten mit einer Steadycam hat man grundsätzlich das Problem, dass man die Kamera bzw. das Objektiv nicht berühren will um „Schwanker“ zu vermeiden. Wenn man also nicht mit einem automatischen Fokussystem (Follow Focus) gesegnet ist braucht man ein zusätzliches Fokussystem. In der Industrie läuft das meist so ab, dass ein zweiter Kameramann an einem externen Monitor sitzt und für die Fokusierung zuständig ist. Über Funk kann dieser einen kleinen Antrieb und somit den Fokus regeln.

Bei einer Ein-Mann Bedienung gibt es Funksysteme bei der man am Hosenbund ein Daumenrad trägt und ebenso mit einem kleinen Motor der Fokusring betätigt werden kann.

Hört sich gut an, jedoch liegen die Kosten weit über 1.000 €

Umsetzung mit einem Arduino und Schrittmotoren

Deshalb war es für mich naheliegend, ein eigenes Fokussystem mithilfe eines Mikrokontrollers (in diesem Falle einem Arduino) und Schrittmotoren zu bauen. Zusätzlich wollte ich auch die Blende steuern.

Folgende Komponenten wurden dafür verwendet:

  • Schrittmotoren
    https://www.amazon.de/gp/product/B01MCQN7GV/ref=oh_aui_detailpage_o08_s00?ie=UTF8&psc=1

    Hier kann man durchaus NEMA 14 verwenden oder andere kleine Schrittmotoren. Die verwenden NEMA Motoren sind praktisch aufgrund der rechteckigen Bauform und zurzeit gut erhältlich weil sie häufig in 3D Drucker-Bausätzen zum Einsatz kommen.
    Der Motor hat 200 Stufen pro Umdrehung -> diese sind mehr als genug da noch die Untersetzung der kleinen Riemenscheibe auf den Zahnkranz des Objektivs dazu kommt.

    Fokusweg am Objektiv: 115 mm
    => 2 Umdrehungen notwendig für eine Verstellung von Nah auf Fern. (pro Schritt ca. 0,3 mm Verstellung)
    notfalls kann man den Schrittmotor in „Interleave“ Modus betreiben.
    Dabei werden abwechselnd jeweils eine Spule und zwei Spulen angesteuert -> doppelte Auflösung.

    Datenblatt: https://cdn-shop.adafruit.com/product-files/324/C140-A+datasheet.jpg

 

Summe der Komponenten: 101,43 €

OK! ich geb zu. Die Komponenten sind teilweise zu teuer gekauft. Jedoch wollte ich kein Risiko eingehen und diese bei Billiganbietern kaufen.

 

Aufbau

Das Motorshield kommt im Bausatz. die Pins müssen nur noch angelötet werden und auf dem Arduino aufgesteckt werden.

Die Anschlüsse erfolgen wie folgt:

das Adafruit Motorshield bietet die Möglichkeit 2 Schrittmotoren anzuschließen.

M1-M2 = Schrittmotor 1 (M1 – Spule 1; M2 – Spule 2)
M3-M4 = Schrittmotor 2 (M3 – Spule 1; M4 – Spule 2)

Es gibt zwei Möglichkeiten der Spannungsversorgung des Motorschields / der Schrittmotoren:

– über den Arduino (V IN Jumper gesteckt)
– externe Stromversorgung. (5-12 V)

bei Betrieb mit einem Akku ist die externe Stromversorgung zu empfehlen, da bei der Ansteuerung ein Spannungsabfall und somit ein Ausfall des Arduinos passieren kann.

Joystick-Anschluss:

Analog Out 1 für X-Achse (Blende)
Analog Out 2 für Y-Achse (Fokus)
Ground
5V Versorgung

 

Die Schrittmotoren und der Arduino wurden einfach mit gebogenen Plexiglas an der Montageplatte des Schwebestativs montiert.

Follow Focus - Aufbau des ArduinosFollow Focus - Aufbau

 

Arudino Programm

Schritte

Adafruit Motorshield-Library einbinden
Anfangsvariablen und Pinbelegung setzen
Joystick-Wert einlesen und in Motor-Schrittgeschwindigkeit umrechnen
Motor ansteuern

Der Joystick hat in der Mittelstellung einen Analogwert von ca. 512. Dieser sollte gemittelt und mit einer Toleranz berücksichtigt werden.

Das Programm kann hier angesehen werden.

https://circuits.io/circuits/4006893-follow-focus-stepper-motor-with-motorshield-and-joystick

#include <Wire.h>
#include <Adafruit_MotorShield.h>
#include „utility/Adafruit_MS_PWMServoDriver.h“

// Erzeugt das Motorshield Objekt
Adafruit_MotorShield AFMS = Adafruit_MotorShield();

// Erzeugt die Motorobjekte mit 200 Schritten pro Umdrehung
Adafruit_StepperMotor *focusmotor = AFMS.getStepper(200, 1);
Adafruit_StepperMotor *apmotor = AFMS.getStepper(200, 2);

const int joystickx = A0; // Analog input pin für Blende
const int joysticky = A1; // Analog output pin für Fokus
const int button = 2;
int xValue = 0;
int yValue = 0;
int cycles = 0;
int yValuemaped = 0;
int xValuemaped = 0;

long runningAveragex(int M) {
#define LM_SIZE 5
static int LM[LM_SIZE]; // LastMeasurements
static byte index = 0;
static long sum = 0;
static byte count = 0;
// keep sum updated to improve speed.
sum -= LM[index];
LM[index] = M;
sum += LM[index];
index++;
index = index % LM_SIZE;
if (count < LM_SIZE) count++;

return sum / count;
}

long runningAveragey(int M) {
#define LM_SIZE 5
static int LM[LM_SIZE]; // LastMeasurements
static byte index = 0;
static long sum = 0;
static byte count = 0;
// keep sum updated to improve speed.
sum -= LM[index];
LM[index] = M;
sum += LM[index];
index++;
index = index % LM_SIZE;
if (count < LM_SIZE) count++;

return sum / count;
}

void setup() {
Serial.begin(9600); // set up Serial library at 9600 bps
Serial.println(„Stepper test!“);

AFMS.begin(); // create with the default frequency 1.6KHz
//AFMS.begin(1000); // OR with a different frequency, say 1KHz

}

void loop() {
yValue = runningAveragey(analogRead(joysticky));
xValue = runningAveragex(analogRead(joystickx));
//Serial.print(yValue);
yValuemaped = map(yValue, 512,1023,0,20);
xValuemaped = map(xValue, 512,1023,0,20);

Serial.println(xValuemaped);

if (yValuemaped != 0) {

if (cycles % (21-abs(yValuemaped)) == 0){
if (yValuemaped > 0) {
focusmotor->onestep(FORWARD, INTERLEAVE);
}
else{
focusmotor->onestep(BACKWARD, INTERLEAVE
);
}
}
}
else{
focusmotor->release();
}
if (xValuemaped != 0) {

if (cycles % (21-abs(xValuemaped)) == 0){
if (xValuemaped > 0) {
apmotor->onestep(FORWARD, INTERLEAVE);
}
else{
apmotor->onestep(BACKWARD, INTERLEAVE);
}
}
}
else{
apmotor->release();
}

cycles++;

}
cycles++;
}

6

Schreibe einen Kommentar

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