DIY Motorisierter Kamera-Slider mit Pan & Tilt

In diesem Tutorial lernen wir, wie man einen motorisierten Kamera-Slider mit Pan- und Tilt-Kopf baut. Dieses Arduino-basierte Projekt ist zu 100% DIY, gebaut mit günstigen Materialien wie MDF und Sperrholz und gesteuert mit Arduino, drei Schrittmotoren, einigen Tastern und einem Joystick auf einer benutzerdefinierten PCB. Trotz alledem ist das Endergebnis beeindruckend: superweiche Kamerafahrten ermöglichen professionell aussehende kinematische Aufnahmen.

Sie können das folgende Video ansehen oder die schriftliche Anleitung unten lesen.

Überblick

Mit dem Controller können wir die Kamera entweder manuell bewegen oder Start- und Endpunkte festlegen, woraufhin die Kamera automatisch von einer Position zur anderen fährt. Mit dem Stützarm können wir den Slider sogar auf einem kleineren Stativ in jedem Winkel montieren und trotzdem stabile Bewegungen erzielen.

DIY Motorisierter Kamera-Slider mit Pan & Tilt – Arduino-gesteuertes Projekt

Zunächst habe ich den Slider mit einer 3D-Modellierungssoftware entworfen.

Sie finden und laden dieses 3D-Modell herunter und erhalten alle Maße aus dem 3D-Modell unten sowie können es in Ihrem Browser auf Thangs erkunden.

Download des Assembly 3D-Modells von Thangs.

3D-gedrucktes GT2-Riemenscheiben-Link: Thingiverse

Bau des Kamera-Sliders

Ich begann mit den Slider-Schienen, für die ich 22mm dicke Kupferrohre verwendete. Ich entschied mich für eine Länge von 1 Meter und schnitt zwei Stücke auf 1 Meter Länge. Kupferrohre oxidieren leicht, daher müssen wir sie mit Metallpolitur polieren. In meinem Fall hatte ich keine, also verwendete ich Zahnpasta dafür.

Das war nicht die perfekte Lösung, aber ich konnte einen Unterschied feststellen und die Rohre wurden etwas sauberer.

Dann ging ich zum Holzsockel über, auf dem die beiden Rohre befestigt werden und der auch zur Montage des Sliders auf einem Stativ dient. Mit einer Kreissäge schnitt ich zwei Stücke 21mm dickes Sperrholz und klebte sie zusammen, um ein dickeres Einzelstück zu erhalten. Dann fertigte ich aus Massivholz eine Replik meiner Stativ-Montageplatte an und befestigte sie mit Holzleim und einer Schraube am Sperrholzstück. Jetzt kann der Slider-Sockel einfach auf dem Stativ montiert werden.

Ich werde die Slider-Schienen mit 8mm Gewindestangen am Sockel befestigen, also bohrte ich zwei Löcher in den Sockel und setzte die 138mm langen Stangen ein, die ich zuvor auf Maß geschnitten hatte. Als Nächstes musste ich 8mm Löcher in die Rohre bohren, was tatsächlich etwas knifflig sein kann.

Dafür baute ich eine einfache Schablone, bei der ich den Stift auf eine Höhe von 11mm anhebte – das ist der halbe Rohrdurchmesser. Dann fixierte ich das Rohr auf einer flachen Oberfläche und markierte es mit der Schablone von beiden Seiten. So erhält man präzise ausgerichtete Löcher von beiden Seiten. Zuerst markierte ich die Bohrpunkte mit einer scharfen Schraubenspitze und bohrte dann progressiv mit 2, 4, 6 und 8mm Bohrern.

Danach schob ich die Schienen durch die Gewindestangen und befestigte sie mit Unterlegscheiben und Muttern am Slider-Sockel. Auf ähnliche Weise fixierte ich die Enden der Schienen mit einem Stück Sperrholz und einer Gewindestange.

Als Nächstes kam die Schlittenplattform. Wieder verwendete ich die Kreissäge, um das 8mm dicke MDF-Board gemäß dem 3D-Modell zuzuschneiden. Ich bohrte auch 8mm Löcher für die Gewindestangen, an denen die Lager befestigt werden. Für den Zusammenbau der Plattform verwendete ich Holzleim und einige Schrauben. Mit einem Akkuschrauber bohrte ich zuerst Pilotlöcher, dann Senkungen und schraubte die 3mm Schrauben fest.

Sobald die Platten befestigt waren, fuhr ich mit dem Zusammenbau des Lagersystems fort. Die verwendeten Lager sind 608Z mit einem Außendurchmesser von 22mm. Zwei Unterlegscheiben und eine Mutter zwischen zwei Lagern schaffen genügend Abstand zwischen ihnen, was einen guten Kontakt mit den 22mm Schienen ermöglicht.

Um die Plattform beim Einsatz des Sliders in einem Winkel sicherer zu machen, fügte ich auf ähnliche Weise zwei weitere Lagersätze an der Unterseite der Plattform ein. Am Ende funktionierte die Schlittenplattform perfekt.

Hier fiel auf, dass der Stativkopf bei meinem kleinen, nicht schweren Stativ das Gewicht der Plattform nicht halten konnte, daher musste ich einen Stützarm bauen, um den Slider zu stabilisieren. Mit zwei Holzstücken und einigen Muttern und Schrauben baute ich eine einfache Klemme, die an einem der Stativbeine befestigt werden kann.

Die Klemme hat einen Bolzen, an dem der Stützarm befestigt werden kann. Als Nächstes musste ich einen Schlitz in den Stützarm machen, um den Slider in verschiedenen Winkeln positionieren zu können. Ich bohrte einfach viele 6mm Löcher nahe beieinander und feilte dann feine gerade Linien. Dieses Stützsystem funktionierte perfekt.

Ich fuhr fort, dem Slider Beine hinzuzufügen, falls man kein Stativ verwenden möchte. Ich fertigte sie aus 8mm MDF an. Mit einer Handsäge und einer Feile bekam ich die gewünschte Form der Beine. Dann befestigte ich sie mit etwas Leim und zwei Muttern an den Enden des Sliders.

Der nächste Schritt ist der Bau des Pan- und Tilt-Systems, das oben auf der Schlittenplattform montiert wird. Mit der Kreissäge schnitt ich alle benötigten Teile mit den Maßen aus dem 3D-Modell. Ich verwendete einige Sperrholzstücke für den Scharniermechanismus der Nivellierplattform für die Kamera, wenn der Slider in einem Winkel steht, sowie einige MDF-Platten, in die ich passende Löcher für den Motor und die Lager des Pan-Systems bohrte.

Ich fuhr mit der Installation des Schrittmotors und des Zahnriemens für die Schlittenplattform fort. Auf einer Seite der Plattform befestigte ich den Schrittmotor mit einem Stück MDF-Board und einigen Schrauben und Bolzen. Auf der anderen Seite des Sliders befestigte ich eine Umlenkrolle, sodass ich nun den Zahnriemen installieren konnte. Mit zwei Bolzen und Kabelbindern befestigte ich den Zahnriemen einfach an der Schlittenplattform.

Damit war der Schlittenmechanismus vollständig fertig.

Ich fuhr mit dem Bau der oberen Teile des Pan- und Tilt-Systems fort. Gemäß dem 3D-Modell bohrte ich alle passenden Löcher für den Schrittmotor und die Lager und klebte und verschraubte alles zusammen.

Ein Freund von mir 3D-druckte zwei 80-Zahn-Riemenscheiben für mich. Dadurch erhielt ich eine 5-fache Geschwindigkeitsreduzierung relativ zur 16-Zahn-Riemenscheibe am Schrittmotor.

Jetzt musste ich einen geschlossenen Zahnriemen nach meinem Setup anfertigen. Ich maß die benötigte Länge, schnitt ihn zu und klebte ihn einfach mit CA-Kleber und fügte ein Stück Klebeband oben drauf. Der CA-Kleber funktioniert hervorragend mit Gummi, sodass der geschlossene Riemen ohne Probleme funktioniert.

Als Nächstes begann ich die Endmontage des Pan- und Tilt-Systems. Zuerst befestigte ich den Tilt-Motor mit einigen Bolzen und fügte die beiden Lager an ihren Plätzen ein, während ich sie mit etwas Epoxidharz in den Schlitzen sicherte. Dann befestigte ich die Tilt-Plattform auf der Pan-Plattform mit einigen 8mm Bolzen und befestigte gleichzeitig die 80-Zahn-Riemenscheibe daran zusammen mit dem Zahnriemen.

Hier fiel auf, dass der Riemen etwas locker war, aber ich fügte ein kleines Lager an der Stelle hinzu, wo der Schrittmotor-Bolzen sitzt, um als Riemenspanner zu fungieren. Das funktionierte und der Riemen hatte nun genug Spannung, um ordnungsgemäß zu arbeiten.

Als Nächstes befestigte ich den Pan-Motor und fügte Lager an der Oberseite der Nivellierplattform sowie an der Unterseite hinzu. Dann steckte ich einen Bolzen durch sie, fügte ein Axiallager, die 80-Zahn-Riemenscheibe und den Zahnriemen hinzu und setzte oben den zuvor zusammengebauten Tilt-Kopf darauf. Schließlich sicherte ich ihn mit einem Bolzen, und damit war der Bau des Sliders abgeschlossen.

Schaltplan

Okay, als Nächstes kommt der spaßige Teil: die Installation der elektronischen Komponenten. Hier ist der Schaltplan dieses DIY Kamera-Slider-Projekts.

Die drei NEMA 17 Schrittmotoren werden über drei A4988 Schrittmotortreiber gesteuert. Für die Steuerung der Slider-Bewegung verwenden wir ein Potentiometer, das an einen analogen Eingang des Arduino angeschlossen ist, und für die Steuerung des Pan- und Tilt-Kopfs ein Joystick-Modul, das eigentlich aus zwei Potentiometern besteht und daher an zwei analoge Eingänge angeschlossen ist. Es gibt auch ein weiteres Potentiometer zum Einstellen der Geschwindigkeit der automatischen Bewegung zwischen den IN- und OUT-Positionen. Diese IN- und OUT-Positionen werden mit einem Taster gesetzt. Dieser Taster hat einen Pull-Up-Widerstand und ist an einen digitalen Pin des Arduino-Boards angeschlossen. Außerdem gibt es einen Reset-Taster, einen Netzschalter, eine Strombuchse, einen Endschalter für den Slider und zwei LEDs zur Anzeige des IN- und OUT-Status. Wir können dieses Projekt mit 9V oder 12V betreiben.

Sie erhalten die für dieses Projekt benötigten Komponenten über die Links unten:

Schrittmotor (NEMA17)
A4988 Schrittmotortreiber
12V 2A Netzteil
Joystick
Strombuchse
Arduino Board

PCB Design

Als Nächstes entwarf ich gemäß dem Schaltplan eine benutzerdefinierte PCB, um die elektronischen Komponenten organisiert zu halten.

Das machte ich mit der kostenlosen Online-Schaltungsdesign-Software EasyEDA. Der Schaltplan hatte ziemlich viele Verbindungen, daher verwendete ich sowohl die obere als auch die untere Lage und schaffte es, eine funktionale und gut aussehende PCB zu erhalten. Nach Abschluss dieses Schritts erstellte ich die für die PCB-Fertigung benötigte Gerber-Datei. Dann bestellte ich die PCB bei JLCPCB, was tatsächlich der Sponsor dieses Tutorials ist.

Hier können wir einfach die Gerber-Datei hochladen und sie im Gerber-Viewer erneut prüfen. Wenn alles in Ordnung ist, können wir fortfahren, die gewünschten Eigenschaften für unsere PCB auswählen und sie zu einem vernünftigen Preis bestellen. Beachten Sie, dass Sie bei Ihrer ersten Bestellung bei JLCPCB bis zu 10 PCBs für nur 2 Dollar erhalten können.

Nach einer Woche sind die PCBs angekommen. Die Qualität ist hervorragend und ich muss zugeben, dass es sehr befriedigend ist, sein eigenes PCB-Design hergestellt zu bekommen.

Elektronik zusammenbauen

Okay, als Nächstes ging ich zum Zusammenbau der elektronischen Komponenten über. Ich begann damit, Pin-Header auf die PCB zu löten. Das ermöglicht einfacheres Anschließen und Trennen der Komponenten bei Bedarf. Ich verwendete tatsächlich Pin-Header für alles außer den Kondensatoren und Widerständen, die ich direkt auf die PCB lötete. Daher fuhr ich fort, Jumper-Kabel an alle elektronischen Komponenten zu löten.

So kann ich die Komponenten einfach am Controller-Gehäuse montieren und gleichzeitig mit der PCB verbinden.

Für das Controller-Gehäuse entschied ich mich für 4mm dickes transparentes Acryl, weil ich die Schönheit aller elektronischen Komponenten sichtbar machen wollte. Ich verwendete eine Kreissäge, um die Platten für das Gehäuse zuzuschneiden. Dann bohrte ich mit einem Bohrer und Forstner-Bohrern die Öffnungen in der Frontplatte für die Taster, Potentiometer, Netzschalter und den Joystick. Danach montierte ich das Gehäuse mit 5-Minuten-Epoxidharz, und für den Deckel steckte ich zwei Bolzen ein und klebte sie, durch die die Frontplatte eingeschoben und mit Muttern oben gesichert werden kann.

Schließlich begann ich mit dem Zusammenbau der Elektronik, indem ich das Arduino-Board und die A4988 Schrittmotortreiber auf die PCB steckte. Dann fuhr ich fort, die Taster und anderen Komponenten an der Frontplatte einzusetzen und zu sichern.

Sobald sie befestigt waren, verband ich die Komponenten mit den entsprechenden Pin-Headern auf der PCB. An der Seitenwand des Gehäuses fügte ich die Strombuchse hinzu und schob die PCB in das Gehäuse. An derselben Wand befindet sich auch ein Loch, durch das ich Jumper-Kabel für die Verbindung der Treiber mit den Schrittmotoren sowie den Endschalter führte, den ich am Ende des Sliders platzierte.

Mit etwas Schrumpfschlauch organisierte ich die Jumper-Kabel, die aus dem Controller-Gehäuse herauskommen, und schließlich blieb nur noch, den Controller mit den drei Schrittmotoren und dem Endschalter zu verbinden.

Für die Stromversorgung des Sliders verwendete ich drei 3,7V Li-Ion-Akkus in Reihe, die ca. 11V liefern. Und das war's – der Slider ist fertig und funktioniert perfekt.

DIY Camera Slider Arduino Code

Was in diesem Tutorial noch bleibt, ist ein Blick auf den Arduino-Code und die Erklärung, wie das Programm funktioniert. Da der Code etwas länger ist, werde ich ihn für ein besseres Verständnis in Abschnitten mit Beschreibung für jeden Abschnitt posten. Am Ende dieses Artikels poste ich den vollständigen Quellcode.

Das Programm basiert auf der AccelStepper-Bibliothek von Mike McCauley. Dies ist eine unglaubliche Bibliothek, die die einfache Steuerung mehrerer Schrittmotoren gleichzeitig ermöglicht. Nachdem wir diese Bibliothek und die MultiStepper.h-Bibliothek, die Teil davon ist, eingebunden haben, müssen wir alle Arduino-Pins definieren, die verwendet werden, die Instanzen für die Stepper definieren sowie einige Variablen für das nachfolgende Programm.

#include <AccelStepper.h>
#include <MultiStepper.h>
#define JoyX A0 // Joystick X pin
#define JoyY A1 // Joystick Y pin
#define slider A2 // Slider potentiometer
#define inOutPot A3 // In and Out speed potentiometer
#define JoySwitch 10 // Joystick switch connected
#define InOutSet 12 // Set Button
#define limitSwitch 11
#define inLED 8
#define outLED 9
// Define the stepper motors and the pins the will use
AccelStepper stepper1(1, 7, 6); // (Type:driver, STEP, DIR)
AccelStepper stepper2(1, 5, 4);
AccelStepper stepper3(1, 3, 2);
MultiStepper StepperControl; // Create instance of MultiStepper
long gotoposition[3]; // An array to store the In or Out position for each stepper motor
int JoyXPos = 0;
int JoyYPos = 0;
int sliderPos = 0;
int currentSpeed = 100;
int inOutSpeed = 100;
int XInPoint = 0;
int YInPoint = 0;
int ZInPoint = 0;
int XOutPoint = 0;
int YOutPoint = 0;
int ZOutPoint = 0;
int InandOut = 0;

Im Setup setzen wir die Anfangsgeschwindigkeitswerte für die Stepper, definieren einige Pin-Modi und fügen die drei Stepper zur Multi-Stepper-Control-Instanz "StepperControl" hinzu. Mit while-Schleifen bewegen wir den Slider in die Anfangsposition – er fährt, bis er den Endschalter betätigt, und fährt dann 200 Schritte zurück, um den Endschalter loszulassen.

void setup() {
  // Set initial seed values for the steppers
  stepper1.setMaxSpeed(3000);
  stepper1.setSpeed(200);
  stepper2.setMaxSpeed(3000);
  stepper2.setSpeed(200);
  stepper3.setMaxSpeed(3000);
  stepper3.setSpeed(200);
  pinMode(JoySwitch, INPUT_PULLUP);
  pinMode(InOutSet, INPUT_PULLUP);
  pinMode(limitSwitch, INPUT_PULLUP);
  pinMode(inLED, OUTPUT);
  pinMode(outLED, OUTPUT);
  // Create instances for MultiStepper - Adding the 3 steppers to the StepperControl instance for multi control
  StepperControl.addStepper(stepper1);
  StepperControl.addStepper(stepper2);
  StepperControl.addStepper(stepper3);
  // Move the slider to the initial position - homing
  while (digitalRead(limitSwitch) != 0) {
    stepper1.setSpeed(3000);
    stepper1.runSpeed();
    stepper1.setCurrentPosition(0); // When limit switch pressed set position to 0 steps
  }
  delay(20);
  // Move 200 steps back from the limit switch
  while (stepper1.currentPosition() != -200) {
    stepper1.setSpeed(-3000);
    stepper1.run();
  }
}

Im Loop beginnen wir damit, zu überprüfen, ob der Slider die Endpositionen erreicht hat – also den Endschalter oder 80cm auf der anderen Seite.

// Limiting the movement - Do nothing if limit switch pressed or distance traveled in other direction greater then 80cm
while (digitalRead(limitSwitch) == 0 || stepper1.currentPosition() < -64800) {}

Mit der nächsten if-Abfrage erhöhen wir die Pan- und Tilt-Geschwindigkeiten bei jedem Drücken des Joystick-Schalters.

// If Joystick pressed increase the Pan and Tilt speeds
if (digitalRead(JoySwitch) == 0) {
  currentSpeed = currentSpeed + 50;
  delay(200);
}

Dann prüfen wir, ob wir den Set-Taster gedrückt haben, der zum Setzen der IN- und OUT-Positionen verwendet wird. Beim ersten Drücken speichern wir die IN-Positionen der Schrittmotoren und leuchten die IN-LED auf.

switch (InandOut) {
  case 0: // Set IN position
    InandOut = 1;
    XInPoint = stepper1.currentPosition(); // Set the IN position for steppers 1
    YInPoint = stepper2.currentPosition(); // Set the IN position for steppers 2
    ZInPoint = stepper3.currentPosition(); // Set the IN position for steppers 3
    digitalWrite(inLED, HIGH); // Light up inLed
    break;

Auf die gleiche Weise speichern wir beim zweiten Drücken die OUT-Positionen und leuchten die OUT-LED auf.

case 1: // Set OUT position
  InandOut = 2;
  XOutPoint = stepper1.currentPosition(); // Set the OUT Points for both steppers
  YOutPoint = stepper2.currentPosition();
  ZOutPoint = stepper3.currentPosition();
  digitalWrite(outLED, HIGH);
  break;

Beim nächsten Drücken lesen wir den Wert des Auto-Speed-Potentiometers, das zum Einstellen der maximalen Geschwindigkeit der Motoren verwendet wird. Auch legen wir die IN-Positionen in das "gotoposition"-Array, das in der moveTo()-Funktion verwendet wird, die die erforderliche Geschwindigkeit für alle Stepper separat berechnet. Dann bewegt sich der Slider mit der runSpeedToPosition()-Funktion automatisch in die IN-Position.

case 2: // Move to IN position / go to case 3
  InandOut = 3;
  inOutSpeed = analogRead(inOutPot); // Auto speed potentiometer
  // Place the IN position into the Array
  gotoposition[0] = XInPoint;
  gotoposition[1] = YInPoint;
  gotoposition[2] = ZInPoint;
  stepper1.setMaxSpeed(inOutSpeed);
  stepper2.setMaxSpeed(inOutSpeed);
  stepper3.setMaxSpeed(inOutSpeed);
  StepperControl.moveTo(gotoposition); // Calculates the required speed for all motors
  StepperControl.runSpeedToPosition(); // Blocks until all steppers are in position
  delay(200);
  break;

Genau auf die gleiche Weise bewegen wir in Case 3 oder mit einem weiteren Tastendruck den Slider in die OUT-Position.

case 3: // Move to OUT position / go back to case 2
  InandOut = 2;
  inOutSpeed = analogRead(inOutPot);
  // Place the OUT position into the Array
  gotoposition[0] = XOutPoint;
  gotoposition[1] = YOutPoint;
  gotoposition[2] = ZOutPoint;
  stepper1.setMaxSpeed(inOutSpeed);
  stepper2.setMaxSpeed(inOutSpeed);
  stepper3.setMaxSpeed(inOutSpeed);
  StepperControl.moveTo(gotoposition); // Calculates the required speed for all motors
  StepperControl.runSpeedToPosition(); // Blocks until all are in position
  delay(200);
  break;

Falls wir den Set-Taster länger als eine halbe Sekunde gedrückt halten, wird der 4. Case ausgeführt, der die IN- und OUT-Positionen zurücksetzt, damit wir neue setzen können.

Als Nächstes kommt die Joystick Pan- und Tilt-Steuerung. Der analoge Wert, den wir vom Joystick erhalten, liegt zwischen 0 und 1024; in der Mittelposition beträgt er ca. 500. Bewegt man den Joystick nach links und der analoge Wert ist größer als 600, setzen wir die Geschwindigkeit des betreffenden Motors auf positiv; bewegt man ihn nach rechts, setzen wir die Geschwindigkeit auf negativ, was bedeutet, dass er sich in die entgegengesetzte Richtung dreht.

// Joystick X - Pan movement
JoyXPos = analogRead(JoyX);
// if Joystick is moved left, move stepper 2 or pan to left
if (JoyXPos > 600) {
  stepper2.setSpeed(currentSpeed);
}
// if Joystick is moved right, move stepper 2 or pan to right
else if (JoyXPos < 400) {
  stepper2.setSpeed(-currentSpeed);
}
// if Joystick stays in middle, no movement
else {
  stepper2.setSpeed(0);
}

Bleibt er in der Mitte, wird die Geschwindigkeit auf 0 gesetzt. Diese Methode wird für beide Achsen des Joysticks sowie das Slider-Potentiometer verwendet. Beim Potentiometer nutzen wir seinen analogen Wert auch, um die Motorgeschwindigkeit zu erhöhen, je weiter man das Potentiometer dreht.

// Slider potentiometer
sliderPos = analogRead(slider);
// If potentiometer is turned left, move slider left
if (sliderPos > 600) {
  sliderPos = map(sliderPos, 600, 1024, 0, 3000);
  stepper1.setSpeed(sliderPos); // Increase speed as turning
}
// If potentiometer is turned right, move slider right
else if (sliderPos < 400 ) {
  sliderPos = map(sliderPos, 400, 0, 0, 3000);
  stepper1.setSpeed(-sliderPos); // Increase speed as turning
}
// If potentiometer in middle, no movement
else {
  stepper1.setSpeed(0);
}

Schließlich rufen wir die runSpeed()-Funktionen für jeden der drei Schrittmotoren auf, die die obigen Befehle ausführen bzw. die Motoren entsprechend drehen.

// Execute the above commands - run the stepper motors
stepper1.runSpeed();
stepper2.runSpeed();
stepper3.runSpeed();

Hier ist der vollständige Quellcode:

/* DIY Camera Slider with Pan and Tilt Head by Dejan Nedelkovski www.HowToMechatronics.com Library - AccelStepper by Mike McCauley: https://www.airspayce.com/mikem/arduino/AccelStepper/index.html */
#include <AccelStepper.h>
#include <MultiStepper.h>
#define JoyX A0 // Joystick X pin
#define JoyY A1 // Joystick Y pin
#define slider A2 // Slider potentiometer
#define inOutPot A3 // In and Out speed potentiometer
#define JoySwitch 10 // Joystick switch connected
#define InOutSet 12 // Set Button
#define limitSwitch 11
#define inLED 8
#define outLED 9
// Define the stepper motors and the pins the will use
AccelStepper stepper1(1, 7, 6); // (Type:driver, STEP, DIR)
AccelStepper stepper2(1, 5, 4);
AccelStepper stepper3(1, 3, 2);
MultiStepper StepperControl; // Create instance of MultiStepper
long gotoposition[3]; // An array to store the In or Out position for each stepper motor
int JoyXPos = 0;
int JoyYPos = 0;
int sliderPos = 0;
int currentSpeed = 100;
int inOutSpeed = 100;
int XInPoint = 0;
int YInPoint = 0;
int ZInPoint = 0;
int XOutPoint = 0;
int YOutPoint = 0;
int ZOutPoint = 0;
int InandOut = 0;

void setup() {
  // Set initial seed values for the steppers
  stepper1.setMaxSpeed(3000);
  stepper1.setSpeed(200);
  stepper2.setMaxSpeed(3000);
  stepper2.setSpeed(200);
  stepper3.setMaxSpeed(3000);
  stepper3.setSpeed(200);
  pinMode(JoySwitch, INPUT_PULLUP);
  pinMode(InOutSet, INPUT_PULLUP);
  pinMode(limitSwitch, INPUT_PULLUP);
  pinMode(inLED, OUTPUT);
  pinMode(outLED, OUTPUT);
  // Create instances for MultiStepper - Adding the 3 steppers to the StepperControl instance for multi control
  StepperControl.addStepper(stepper1);
  StepperControl.addStepper(stepper2);
  StepperControl.addStepper(stepper3);
  // Move the slider to the initial position - homing
  while (digitalRead(limitSwitch) != 0) {
    stepper1.setSpeed(3000);
    stepper1.runSpeed();
    stepper1.setCurrentPosition(0); // When limit switch pressed set position to 0 steps
  }
  delay(20);
  // Move 200 steps back from the limit switch
  while (stepper1.currentPosition() != -200) {
    stepper1.setSpeed(-3000);
    stepper1.run();
  }
}

void loop() {
  // Limiting the movement - Do nothing if limit switch pressed or distance traveled in other direction greater then 80cm
  while (digitalRead(limitSwitch) == 0 || stepper1.currentPosition() < -64800) {}
  // If Joystick pressed increase the Pan and Tilt speeds
  if (digitalRead(JoySwitch) == 0) {
    currentSpeed = currentSpeed + 50;
    delay(200);
  }
  // If Set button is pressed - toggle between the switch cases
  if (digitalRead(InOutSet) == 0) {
    delay(500); // If we hold set button pressed longer then half a second, reset the in and out positions
    if (digitalRead(InOutSet) == 0) {
      InandOut = 4;
    }
    switch (InandOut) {
      case 0: // Set IN position
        InandOut = 1;
        XInPoint = stepper1.currentPosition(); // Set the IN position for steppers 1
        YInPoint = stepper2.currentPosition(); // Set the IN position for steppers 2
        ZInPoint = stepper3.currentPosition(); // Set the IN position for steppers 3
        digitalWrite(inLED, HIGH); // Light up inLed
        break;
      case 1: // Set OUT position
        InandOut = 2;
        XOutPoint = stepper1.currentPosition(); // Set the OUT Points for both steppers
        YOutPoint = stepper2.currentPosition();
        ZOutPoint = stepper3.currentPosition();
        digitalWrite(outLED, HIGH);
        break;
      case 2: // Move to IN position / go to case 3
        InandOut = 3;
        inOutSpeed = analogRead(inOutPot); // Auto speed potentiometer
        // Place the IN position into the Array
        gotoposition[0] = XInPoint;
        gotoposition[1] = YInPoint;
        gotoposition[2] = ZInPoint;
        stepper1.setMaxSpeed(inOutSpeed);
        stepper2.setMaxSpeed(inOutSpeed);
        stepper3.setMaxSpeed(inOutSpeed);
        StepperControl.moveTo(gotoposition); // Calculates the required speed for all motors
        StepperControl.runSpeedToPosition(); // Blocks until all steppers are in position
        delay(200);
        break;
      case 3: // Move to OUT position / go back to case 2
        InandOut = 2;
        inOutSpeed = analogRead(inOutPot);
        // Place the OUT position into the Array
        gotoposition[0] = XOutPoint;
        gotoposition[1] = YOutPoint;
        gotoposition[2] = ZOutPoint;
        stepper1.setMaxSpeed(inOutSpeed);
        stepper2.setMaxSpeed(inOutSpeed);
        stepper3.setMaxSpeed(inOutSpeed);
        StepperControl.moveTo(gotoposition); // Calculates the required speed for all motors
        StepperControl.runSpeedToPosition(); // Blocks until all are in position
        delay(200);
        break;
      case 4: // If Set button is held longer then half a second go back to case 0
        InandOut = 0;
        digitalWrite(inLED, LOW);
        digitalWrite(outLED, LOW);
        delay(1000);
        break;
    }
  }
  // Joystick X - Pan movement
  JoyXPos = analogRead(JoyX);
  // if Joystick is moved left, move stepper 2 or pan to left
  if (JoyXPos > 600) {
    stepper2.setSpeed(currentSpeed);
  }
  // if Joystick is moved right, move stepper 2 or pan to right
  else if (JoyXPos < 400) {
    stepper2.setSpeed(-currentSpeed);
  }
  // if Joystick stays in middle, no movement
  else {
    stepper2.setSpeed(0);
  }
  //Joystick Y - Tilt movement
  JoyYPos = analogRead(JoyY);
  if (JoyYPos > 600) {
    stepper3.setSpeed(currentSpeed);
  }
  else if (JoyYPos < 400) {
    stepper3.setSpeed(-currentSpeed);
  }
  else {
    stepper3.setSpeed(0);
  }
  // Slider potentiometer
  sliderPos = analogRead(slider);
  // If potentiometer is turned left, move slider left
  if (sliderPos > 600) {
    sliderPos = map(sliderPos, 600, 1024, 0, 3000);
    stepper1.setSpeed(sliderPos); // Increase speed as turning
  }
  // If potentiometer is turned right, move slider right
  else if (sliderPos < 400 ) {
    sliderPos = map(sliderPos, 400, 0, 0, 3000);
    stepper1.setSpeed(-sliderPos); // Increase speed as turning
  }
  // If potentiometer in middle, no movement
  else {
    stepper1.setSpeed(0);
  }
  // Execute the above commands - run the stepper motors
  stepper1.runSpeed();
  stepper2.runSpeed();
  stepper3.runSpeed();
}