Bluetooth-gesteuerter Arduino Motorisierter Kameraschlitten für kinematische Aufnahmen

Komponenten und Zubehör

Komponente	Menge	Hinweise
Arduino UNO	1
PCBWay Custom PCB	1	Projekt-Link
V-Slot 20×40 Linear Rail	1	Länge nach Bedarf
Solid V Wheel Kit	4
Drop In Tee Nuts	4
Exzentrische Distanzhülse	2
9 mm Aluminium-Distanzhülse	2
3 mm Aluminium-Distanzhülse	2
Flachkopf M5 Schrauben 20 mm mit Muttern	4
Flachkopf M5 Schrauben 10 mm	4
M3 Inbusschrauben 16 mm mit Muttern	8
8 mm Selbstausrichtende Kissenflansch-Lager	2
GT2 Bohrung 8 mm 20 Zähne Zahnriemenscheibe Aluminium	1
8 mm Linearschienenwelle	1	60 mm Länge
GT2 Bohrung 5 mm 20 Zähne Zahnriemenscheibe Aluminium	1
GT2-6 mm Offener Zahnriemen	1	Länge abhängig von der Profilschienenlänge
Bipolarer NEMA17 Schrittmotor	1
A4988 Schrittmotortreiber	1
12 V 3 A Wiederaufladbarer Akku	1
HC-05 Bluetooth Modul	1

Benötigte Werkzeuge und Maschinen

3D-Drucker (beliebig)

Apps und Online-Dienste

Autodesk Fusion 360
Autodesk Eagle
Arduino IDE

Projektübersicht

Für Hobby-Videografen ist ein motorisierter Kameraschlitten oft zu teuer. Deshalb habe ich einen eigenen gebaut. In diesem Tutorial gehen wir jeden Schritt durch, um einen eigenen Bluetooth-gesteuerten motorisierten Kameraschlitten zu bauen.

Heute bauen wir einen motorisierten Kameraschlitten, den wir kabellos per Bluetooth über eine selbst erstellte Android-App steuern können. Ich habe das Tool „MIT App Inventor“ verwendet, um die App zu erstellen, die uns die Kontrolle über viele Parameter ermöglicht: Bewegungsgeschwindigkeit, Fahrweg, Beschleunigungs-/Verzögerungsrate und vieles mehr. Die App ist sehr robust – man kann die Schlittenlänge einstellen, sodass man Schlitten bis zu 10 Meter Länge bauen kann, ohne sich um die App kümmern zu müssen.

Bluetooth-gesteuerter Arduino Motorisierter Kameraschlitten für kinematische Aufnahmen

Als Antrieb dient ein NEMA17-Schrittmotor, damit wir präzise steuern können, wie viele Schritte der Schlitten fährt. Um einen Schrittmotor mit dem Arduino zu steuern, benötigen wir einen Treiber, der die Befehle des Arduino in die Sprache des Motors übersetzt. Hier kommt der A4988 Pololu-Schrittmotortreiber ins Spiel, der fünf verschiedene Mikroschritt-Auflösungen (bis zu 1/16 Schritt) bietet, um maximale Bewegungsgenauigkeit und Laufruhe zu erreichen.

Dieses Projekt wurde so entworfen, dass es in einem FabLab, Makerspace oder Hackerspace nachgebaut werden kann.

CAD und 3D-Modellierung

Wir haben Fusion 360 für das Design verwendet und bewusst weit verbreitete, leicht beschaffbare mechanische Komponenten gewählt, die man fast überall online oder im Laden kaufen kann.

Als mechanische Struktur nutzen wir OpenBuilds-Hardware: Die V-Slot 2040 Linear Rail führt die Kamera. Zwei Riemenscheiben – eine auf der Schrittmotorwelle, die andere auf einer 8 mm Linearschienenwelle auf der gegenüberliegenden Seite – werden über einen offenen Zahnriemen verbunden, um die Drehbewegung in Linearbewegung umzuwandeln.

Die 8 mm Linearschienenwelle sitzt zwischen zwei selbstausrichtenden Kissenflansch-Lagern, die mit vier M5-Schrauben an der oberen und unteren Platte befestigt sind.

Vier Delrin V-Slot Solid Wheels laufen in der V-Nut der V-Slot-Schiene und sorgen für extrem sanfte Kamerabewegung. Die Kameraplatte hat mittig ein 1/4-Zoll-Loch für ein Standard-Stativgewinde.

Abschließend gibt es ein Gehäuse für die Elektronik. Alle Teile werden mit M3×16 mm Schrauben und Muttern verbunden.

Digitale Fertigung (3D-Druck)

Alle Gehäuseteile werden mit 0,2 mm Schichthöhe und 20 % Infill gedruckt, außer den linken und rechten Beinen des Schlittens (50 % Infill).

STL-Dateien gibt es auf Thingiverse.

V-Wheel-Kit Montage

Die Montage ist einfach. Zuerst bauen wir die vier Solid V-Wheels zusammen. Jedes Kit besteht aus einem Gummiring, zwei Lagern, zwei Präzisionsscheiben und einer Kontermutter.

Lager von einer Seite in den Gummiring drücken, Rad drehen, eine Präzisionsscheibe einlegen, dann das zweite Lager von der anderen Seite einsetzen.

Mechanische Montage des Kameraschlittens

Zuerst die Kameraplatte mit den vier V-Wheels verbinden, dabei 9 mm Aluminium-Distanzhülsen, Präzisionsscheiben und Kontermuttern verwenden.

Diesen Schritt für alle vier Räder wiederholen: bei den zwei rechten Rädern 9 mm Distanzhülsen, bei den linken die exzentrische Distanzhülse mit 3 mm Distanzhülse verwenden.

Jetzt die Kameraplatte in das V-Slot-Profil einsetzen. Wenn sie wackelt, die exzentrische Mutter anziehen, bis sie fest sitzt.

Je zwei Drop-in Tee Nuts in jedes Ende des V-Slot-Profils einsetzen, um die Beine zu verbinden.

Die beiden Beine in das Profil schieben.

Vier M5×10 mm Schrauben befestigen die Beine am Profil.

NEMA 17 Schrittmotor auf seiner Platte montieren und mit vier M3×16 mm Schrauben fixieren.

Am linken Bein zwei Muttern in die vorgesehene Aufnahme einsetzen.

Motorplatte auf das linke Bein setzen und mit zwei M3×16 mm Schrauben befestigen.

GT2 5 mm Bohrung Riemenscheibe auf die Motorwelle schieben und mit Inbusschlüssel die Madenschraube anziehen.

Am rechten Bein vier M3 Muttern in die Aufnahmen einsetzen.

Die beiden Lagerplatten auf das rechte Bein setzen.

Mit vier M3×16 mm Schrauben fixieren.

Ein 8 mm Flanschlagerblock auf die obere rechte Platte montieren (zwei M5×20 mm Schrauben + Muttern).

Dasselbe für den unteren Lagerblock wiederholen.

8 mm Linearschienenwelle von unten in die Lagerblöcke schieben, dann die 8 mm Bohrung Riemenscheibe auf die Welle setzen und Madenschraube anziehen.

Jetzt fehlt nur noch der Zahnriemen. Den 6 mm Riemen auf die 5 mm Motorriemenscheibe und die 8 mm Riemenscheibe am rechten Bein legen, dann mit der Kameraplatte spannen.

Steuerplatine zusammenbauen: Cairo Camera Slider Arduino Shield auf den Arduino stecken.

Arduino mit Shield in das Gehäuse einsetzen.

Zwei M3 Muttern in das linke Bein einsetzen und das Gehäuse mit M3×16 mm Schrauben befestigen.

Deckel mit zwei M3 Schrauben und Muttern schließen – fertig!

Schrittmotor-Teststeuerung

Nach dem Zusammenbau testen wir die Mechanik. Schrittmotor über A4988 Treiber mit Arduino verbinden und Testcode hochladen.

A4988 Schrittmotortreiber

Der A4988 Treiber übersetzt Arduino-Befehle in Motorschritte. Er steuert einen bipolaren Motor mit bis zu 2 A pro Spule, benötigt nur zwei digitale Pins (Step/Dir), hat ein Potentiometer zur Stromeinstellung und bietet Mikroschritte bis 1/16.

VMOT, GND: Motorversorgung 8–35 V (hier 12 V 3 A mit 100 µF Elko gegen Spannungsspitzen).
2B, 2A / 1A, 1B: Ausgang für Spule 1 und 2 (je max. 2 A).
VDD, GND: Logikversorgung 3–5,5 V, galvanisch getrennt von VMOT.
EN (Enable): Aktiv LOW (0 V = aktiv, 5 V = deaktiviert), standardmäßig LOW.
MS1, MS2, MS3: Mikroschritt-Auflösung wählen (Full, Half, Quarter, Eighth, Sixteenth). Interner Pulldown → Standard Full Step.
RST, SLP: Reset (aktiv LOW) und Sleep (aktiv LOW, default HIGH).
STP, DIR: Step-Puls = ein Mikroschritt in Richtung DIR (HIGH = CW, LOW = CCW).

NEMA17 Schrittmotor

Schrittmotoren drehen in präzisen Schritten (hier 1,8° pro Vollschritt). Im Gegensatz zu Gleichstrommotoren werden sie durch elektrische Impulse an den Spulen gesteuert – ideal für präzise Positionierung auch bei niedrigen Geschwindigkeiten.

Wir nutzen einen bipolaren NEMA 17 (4 Drähte, 2 Spulen). Nennspannung 9 V, für maximale Leistung 12 V.

Verdrahtungsplan

Schrittmotor, A4988, Arduino UNO und 12 V 3 A Li-Ion-Akku verbinden.

Arduino Code (Test)

AccelStepper Bibliothek installieren

In der Arduino IDE: Sketch → Bibliothek einbinden → Bibliotheken verwalten → „AccelStepper“ suchen → Installieren (von Mike McCauley).

Testcode

// Bounce stepper test program
// Make a single stepper bounce from one limit to another
// Copyright (C) 2020 makesomestuff.org

#include <AccelStepper.h>
#define stepPin 2
#define dirPin 3

AccelStepper stepper(AccelStepper::DRIVER, stepPin, dirPin);

void setup() {
  stepper.setMaxSpeed(100);
  stepper.setAcceleration(20);
  stepper.moveTo(500);
}

void loop() {
  if (stepper.distanceToGo() == 0)
    stepper.moveTo(-stepper.currentPosition());
  stepper.run();
}

Der Code initialisiert den Stepper, setzt Maximalgeschwindigkeit (100 Steps/s) und Beschleunigung (20 Steps/s²), bewegt 500 Schritte und lässt den Motor zwischen den Endpunkten hin- und herfahren.

Volle kabellose Steuerung

Nach dem Test geht es an die mobile App (MIT App Inventor) und den finalen Arduino-Code mit Bluetooth-Kommunikation.

Mobile App erstellen

Die App läuft auf jedem Android-Gerät. Quellcode ist Open Source. Die App kommuniziert per Bluetooth mit dem Schlitten.

Die folgende Grafik erklärt die Funktionen der Buttons.

Verdrahtung mit Bluetooth

HC-05 Bluetooth Modul anschließen (Serial Port Protocol):

Tx (Arduino) → Rx (HC-05)
Rx (Arduino) → Tx (HC-05)
5 V (Arduino) → VCC (HC-05)
GND (Arduino) → GND (HC-05)

Schaltplan und PCB-Fertigung

Statt Steckbrett ein eigenes Arduino UNO Shield PCB (gefertigt bei PCBWay, ca. 5 $). Alle Komponenten (HC-05, A4988, Akku) werden aufgesteckt.

PCB-Design und Bestellung über PCBWay: PCB Source Files & Ordering

Arduino Code und Bluetooth-Kommunikation

/*
 TODO:: Update the arduino program to Make the user able to choose the motor driver micro stepping mode...
*/
#include <MultiStepper.h>
#include <AccelStepper.h>

#define stepPin 2
#define dirPin 3

bool homingPositionFlag = false;
int startupSetupFlag = 0;
bool delayedStart = false;

int incomingData = 0;
int movementDistance = 50;
long steps = 0;
int microStepResolution = 0;
long railLength = 0;
int sliderSpeed = 10;

AccelStepper stepper(AccelStepper::DRIVER, stepPin, dirPin);

void setup() {
  pinMode(stepPin, OUTPUT);
  pinMode(dirPin, OUTPUT);
  Serial.begin(9600);
  stepper.setMaxSpeed(10.00);
  stepper.setAcceleration(500.00);

  while (startupSetupFlag < 3) {
    if (Serial.available() > 1) {
      unsigned int dataOne = Serial.read();
      unsigned int dataOne1 = Serial.read();
      unsigned int incomingData = (dataOne1 * 256) + dataOne;

      // Motor Homing
      if (incomingData == 16) { // left end homing
        stepper.setCurrentPosition(steps);
        homingPositionFlag = false;
        startupSetupFlag++;
      } else if (incomingData == 17) { // right end homing
        stepper.setCurrentPosition(-(steps));
        homingPositionFlag = true;
        startupSetupFlag++;
      }

      // Mikroschritt-Auflösung
      if (incomingData == 18) {
        microStepResolution = 4; // 1/4
        startupSetupFlag++;
      } else if (incomingData == 19) {
        microStepResolution = 16; // 1/16
        startupSetupFlag++;
      }

      // Schienenlänge (1301-2300 → 1-1000 cm)
      if (incomingData >= 1301 && incomingData <= 2300) {
        railLength = incomingData - 1300;
        if (microStepResolution == 4) {
          steps = ((6100L * railLength) / 50L);
          startupSetupFlag++;
        } else if (microStepResolution == 16) {
          steps = ((25000L * railLength) / 50L);
          startupSetupFlag++;
        }
      }
    }
  }
}

void loop() {
  if (Serial.available() > 1) {
    unsigned int dataOne = Serial.read();
    unsigned int dataOne1 = Serial.read();
    unsigned int incomingData = (dataOne1 * 256) + dataOne;

    // Motorsteuerung
    if (incomingData == 1 && !stepper.isRunning() && stepper.currentPosition() != 6050 && homingPositionFlag) {
      if (delayedStart) delay(15000);
      stepper.setCurrentPosition(0);
      stepper.moveTo(steps);
      homingPositionFlag = false;
    }
    else if (incomingData == 2 && !stepper.isRunning() && stepper.currentPosition() != -6050 && !homingPositionFlag) {
      if (delayedStart) delay(15000);
      stepper.setCurrentPosition(0);
      stepper.moveTo(-(steps));
      homingPositionFlag = true;
    }
    else if (incomingData == 3 && stepper.isRunning()) {
      homing();
    }

    // Max. Geschwindigkeit (5001-9000 → 1-4000 steps/s)
    else if (incomingData >= 5001 && incomingData <= 9000) {
      sliderSpeed = incomingData - 5000;
      stepper.setMaxSpeed(sliderSpeed);
    }

    // Verzögerter Start
    else if (incomingData == 7) delayedStart = true;
    else if (incomingData == 8) delayedStart = false;

    // Fahrweg (201-1200 → 1-1000 cm)
    else if (incomingData >= 201 && incomingData <= 1200) {
      movementDistance = incomingData - 200;
      if (microStepResolution == 4)
        steps = ((6100L * movementDistance) / 50L);
      else if (microStepResolution == 16)
        steps = ((25000L * movementDistance) / 50L);
    }

    // Beschleunigung
    else if (incomingData == 11 && !stepper.isRunning()) stepper.setAcceleration(3000); // High
    else if (incomingData == 12 && !stepper.isRunning()) stepper.setAcceleration(1000); // Medium
    else if (incomingData == 13 && !stepper.isRunning()) stepper.setAcceleration(500);  // Low
    else if (incomingData == 14 && !stepper.isRunning()) stepper.setAcceleration(4000); // Very High
    else if (incomingData == 15 && !stepper.isRunning()) stepper.setAcceleration(10);   // Very Low
  }
  stepper.run();
}

void homing() {
  homingPositionFlag = (stepper.currentPosition() > 0);
  stepper.moveTo(0);
}

Codelogik

Wir nutzen die AccelStepper-Bibliothek für präzise Schrittmotorsteuerung. Beim App-Start werden Mikroschritt-Modus (1/4 = „Smooth“, 1/16 = „Very Smooth“), Schienenlänge und Homing-Position abgefragt. Falsche Mikroschritt-Einstellung führt zu Kollisionen.

Der Setup-Loop wartet auf drei Parameter (Homing, Mikroschritt, Schienenlänge) und berechnet die maximalen Schritte. Im Haupt-Loop werden Befehle (Vorwärts, Rückwärts, Stopp, Geschwindigkeit, Verzögerung, Fahrweg, Beschleunigung) verarbeitet.

Benutzerhandbuch & Fehlerbehebung

12 V anschließen, Bluetooth am Handy einschalten, mit HC-05 koppeln, App starten und „Press here to connect“ drücken → HC-05 wählen.
App fragt Mikroschritt-Modus ab (laut A4988 Jumper-Einstellung wählen).
Schienenlänge in cm eingeben.
Homing-Position wählen (Kameraplatte muss an einem Ende stehen).
Parameter werden bestätigt, dann ist der Schlitten einsatzbereit.