DIY-Kamera-Slider mit Schwenk- und Neigekopf

In diesem Tutorial lernen wir, wie man einen motorisierten Kameraschieber mit Schwenk- und Neigekopf herstellt. Dieses Arduino-basierte Projekt ist zu 100 % DIY, gebaut aus billigen Materialien wie MDF und Sperrholz und gesteuert mit Arduino, drei Schrittmotoren, einigen Knöpfen und einem Joystick, der auf einer kundenspezifischen Leiterplatte angebracht ist. Trotzdem ist das Endergebnis ziemlich beeindruckend, mit superflüssigen Kamerabewegungen, die es uns ermöglichen, professionell aussehende Filmaufnahmen zu machen.

Sie können sich das folgende Video ansehen oder das schriftliche Tutorial unten lesen.

Übersicht

Mit dem Controller können wir die Kamera entweder manuell bewegen oder wir können Start- und Endpunkte festlegen und dann bewegt sich die Kamera automatisch von einer zur anderen Position. Mit dem Stützarm können wir den Slider auch auf einem kleineren Stativ in jedem gewünschten Winkel montieren und erhalten dennoch stabile Bewegungen.

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

Sie können dieses 3D-Modell finden und herunterladen und alle Abmessungen aus dem 3D-Modell unten abrufen sowie es in Ihrem Browser auf Thangs erkunden.

Laden Sie das 3D-Modell der Baugruppe von Thangs herunter.

3D-gedrucktes GT2-Riemenscheibenglied:

Thingiverse

Bauen des Kamera-Sliders

Also begann ich mit der Herstellung der Gleitschienen, für die ich 22-mm-Tick-Kupferrohr verwendete. Ich beschloss, den Schieber 1 Meter lang zu machen, also schneide ich zwei Stücke auf 1 Meter Länge. Kupferrohre können leicht oxidieren, daher müssen wir sie mit einer Metallpolitur polieren. In meinem Fall hatte ich keine, also habe ich zu diesem Zweck eine Zahnpasta verwendet.

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

Dann machte ich weiter mit der Herstellung des Holzsockels, auf dem die beiden Rohre befestigt werden und der auch dazu dient, den Schieber auf einem Stativ zu montieren. Mit einer Kreissäge schneide ich zwei Stücke 21 mm dickes Sperrholz und klebte sie zusammen, um ein einzelnes Tickerstück zu erhalten. Dann machte ich mit einem Massivholz eine Nachbildung meiner Stativ-Montageplatte und befestigte sie mit einem Holzleim und einer Schraube am Sperrholzstück. Jetzt kann die Slider Base einfach auf dem Stativ montiert werden.

Ich werde die Gleitschienen mit 8-mm-Gewindestangen an der Basis montieren, also habe ich zwei Löcher in die Basis gemacht und die 138 mm langen Stangen eingesetzt, die ich zuvor zugeschnitten habe. Als nächstes musste ich 8-mm-Zeckenlöcher in die Rohre bohren, was tatsächlich etwas knifflig sein kann.

Zu diesem Zweck habe ich eine einfache Schablone gemacht, bei der ich den Stift auf eine Höhe von 11 mm oder das ist die Hälfte des Rohrdurchmessers angehoben habe. Dann befestigte ich das Rohr auf einer ebenen Fläche und markierte das Rohr mit der Spannvorrichtung von beiden Seiten. Dies ermöglicht präzise Bohrungen von beiden Seiten. Also markierte ich zuerst die Bohrpunkte mit einer scharfen Schraubenspitze und bohrte sie dann nach und nach mit 2, 4, 6 und 8 mm Bohrern.

Danach steckte ich die Schienen durch die Gewindestangen und befestigte sie mit einigen Unterlegscheiben und Muttern an der Schieberbasis. Auf ähnliche Weise habe ich mit einem Stück Sperrholz und einer Gewindestange die Enden der Schienen befestigt.

Als nächstes ist die Schiebeplattform. Wieder habe ich eine Kreissäge zum Zuschneiden der 8 mm dicken MDF-Platte gemäß dem 3D-Modell verwendet. Ich habe auch ein 8-mm-Loch für die Gewindestangen gemacht, an denen das Lager befestigt werden soll. Für die Montage der Plattform habe ich einen Holzleim und einige Schrauben verwendet. Mit einem Akku-Bohrschrauber habe ich zuerst Pilotlöcher gemacht, dann die Senkungen gemacht und die 3-mm-Schrauben eingeschraubt.

Sobald die Platten befestigt waren, fuhr ich mit der Montage des Lagersystems fort. Die Lager, die ich verwende, sind 608Z mit einem Außendurchmesser von 22 mm. Zwei Unterlegscheiben und eine Mutter zwischen zwei Lagern sorgen für genügend Abstand und ermöglichen so einen guten Kontakt mit den 22-mm-Schienen.

Um die Plattform sicherer zu machen, wenn der Schieber in einem Winkel verwendet wird, habe ich auf ähnliche Weise zwei weitere Lagersätze an der Unterseite der Plattform eingefügt. Am Ende hat sich herausgestellt, dass die Schiebeplattform perfekt funktioniert.

Hier können wir feststellen, dass jetzt beim Bewegen der Plattform entlang des Schiebers auf meinem kleinen, nicht schweren Stativ der Kopf das Gewicht der Plattform nicht halten kann, sodass ich einen Stützarm machen musste, um den Schieber zu stabilisieren. Also habe ich aus zwei Holzstücken und einigen Muttern und Schrauben eine einfache Klemme gemacht, die an einem der Stativbeine befestigt werden kann.

Die Klemme hat einen Bolzen, an dem der Tragarm befestigt werden kann. Als nächstes musste ich einen Schlitz am Stützarm machen, um den Schieber in einem anderen Winkel positionieren zu können. Ich machte den Schlitz, indem ich einfach viele 6-mm-Löcher nahe beieinander bohrte und dann mit einer Raspel feine gerade Linien machte. Dieses unterstützende System funktionierte schließlich perfekt.

Ich habe diesen Aufbau mit dem Hinzufügen von Beinen zum Schieber fortgesetzt, falls Sie kein Stativ verwenden möchten oder müssen. Ich habe sie aus 8mm MDF gemacht. Mit einer Handsäge und einer Raspel bekam ich leicht die gewünschte Form der Beine. Dann befestigte ich sie mit etwas Klebstoff und zwei Muttern an den Enden des Schiebers.

Der nächste Schritt ist der Bau des Schwenk- und Neigesystems, das oben auf der Schiebeplattform befestigt wird. Mit der Kreissäge schneide ich alle benötigten Teile mit den Maßen aus dem 3D-Modell. Ich habe einige Sperrholzstücke verwendet, um den Scharniermechanismus der Nivellierungsplattform für die Kamera herzustellen, wenn der Schieber schräg eingestellt ist, sowie einige MDF-Platten, auf denen ich entsprechende Löcher für den Motor und die Lager für das Schwenksystem gemacht habe.

Ich ging weiter mit der Installation des Schrittmotors und des Zahnriemens für die Schiebeplattform. Auf einer Seite der Plattform befestigte ich den Schrittmotor mit einem Stück MDF-Platte und einigen Schrauben und Bolzen. Und auf der anderen Seite des Schiebers habe ich eine Umlenkrolle befestigt, damit ich jetzt den Zahnriemen montieren kann. Mit zwei Schrauben und Kabelbindern befestigte ich den Zahnriemen einfach an der Schiebeplattform.

Damit war der Schiebemechanismus komplett fertig.

Ich fuhr mit der Herstellung der oberen Teile des Schwenk- und Neigesystems fort. Entsprechend dem 3D-Modell habe ich alle passenden Löcher für den Schrittmotor und die Lager gemacht und alles zusammengeklebt und verschraubt.

Ein Freund von mir hat 2 Riemenscheiben mit 80 Zähnen für mich in 3D gedruckt. Auf diese Weise erhielt ich eine 5-fache Geschwindigkeitsreduzierung im Vergleich zu der 16-Zahn-Riemenscheibe, die am Schrittmotor angebracht ist.

Jetzt musste ich einen Zahnriemen mit geschlossener Schleife gemäß meinem Setup herstellen, also habe ich gemessen, wie viel Riemenlänge ich brauchte, ihn geschnitten und dann einfach mit einem CA-Kleber geklebt und ein Stück Klebeband darauf angebracht. Der CA-Kleber leistet hervorragende Arbeit mit Gummi, sodass der geschlossene Riemen ohne Probleme funktioniert.

Als nächstes begann ich mit der Endmontage des Schwenk- und Neigesystems. Zuerst befestigte ich den Kippmotor mit einigen Schrauben und fügte dann die beiden Lager hinzu, während ich sie mit etwas Epoxid in den Schlitzen befestigte. Dann befestigte ich die Kippplattform auf der Schwenkplattform mit einigen 8-mm-Schrauben und befestigte gleichzeitig die 80-Zahn-Riemenscheibe zusammen mit dem Zahnriemen.

Hier bemerkte ich, dass der Riemen etwas locker war, aber ich fügte ein kleines Lager an der Stelle hinzu, wo die Schrittmotorschraube als Riemenspanner dient. Das Ding hat geklappt und jetzt hatte der Riemen genug Spannung, um richtig zu funktionieren.

Als nächstes befestigte ich den Schwenkmotor und fügte Lager auf der Oberseite der Nivellierplattform sowie auf der Unterseite hinzu. Dann steckte ich eine Schraube durch sie, fügte ein Axiallager, die 80-Zahn-Riemenscheibe und den Zahnriemen hinzu und fügte oben darauf den zuvor zusammengebauten Neigekopf hinzu. Abschließend habe ich es mit einem Bolzen gesichert und das war es, mit diesem Schritt ist der Bau des Schiebers abgeschlossen.

Schaltplan

Ok, als nächstes kommt der lustige Teil oder die Installation der Elektronikkomponenten. Hier ist der Schaltplan dieses DIY-Kamera-Slider-Projekts.

Die drei NEMA 17 Schrittmotoren werden also über die drei A4988 Schritttreiber angesteuert. Zur Steuerung der Schieberbewegung verwenden wir ein Potentiometer, das mit einem analogen Eingang des Arduino verbunden ist, und zur Steuerung des Schwenk- und Neigekopfs verwenden wir ein Joystick-Modul, das eigentlich aus zwei Potentiometern besteht, also mit zwei analogen Eingängen verbunden ist. Es gibt auch ein weiteres Potentiometer, mit dem die Geschwindigkeit der automatischen Bewegung von der Ein- und Aus-Position eingestellt werden kann. Diese Ein- und Aus-Position werden mit Hilfe von Druckknöpfen eingestellt. Dieser Taster hat einen Pull-up-Widerstand und ist mit einem digitalen Pin des Arduino-Boards verbunden. Es gibt auch einen Reset-Taster, einen Netzschalter und eine Netzbuchse sowie einen Endschalter für den Schieber und zwei LEDs zur Anzeige des Ein- und Aus-Status. Wir können dieses Projekt entweder mit 9 oder 12 V versorgen.

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

Schrittmotor (NEMA17)……….
A4988 Schrittmotortreiber…………….
12V 2A Adapter…………………..….
Joystick …………………………………
Netzbuchse …………….………….……
Arduino-Board ………………………

PCB-Design

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

Ich habe das mit der kostenlosen Online-Schaltungsdesign-Software EasyEDA gemacht. Die Schaltung hatte einige Verbindungen, also habe ich sowohl die obere als auch die untere Schicht verwendet und es geschafft, eine funktionale und gut aussehende Leiterplatte zu erhalten. Sobald ich mit diesem Schritt fertig war, habe ich die Gerber-Datei generiert, die für die Herstellung der Leiterplatte benötigt wird. Dann bestellte ich die Platine bei JLCPCB, das eigentlich der Sponsor dieses Tutorials ist.

Hier können wir einfach die Gerber-Datei hochladen und nach dem Hochladen können wir unser PCB noch einmal im Gerber-Viewer überprüfen. Wenn alles in Ordnung ist, können wir weitermachen, die Eigenschaften auswählen, die wir für unsere Leiterplatte wünschen, und dann können wir unsere Leiterplatte zu einem günstigen Preis bestellen. Beachten Sie, dass Sie bei Ihrer ersten Bestellung bei JLCPCB bis zu 10 PCBs für nur 2 Dollar erhalten können.

Trotzdem sind nach einer Woche die Platinen eingetroffen. Die Qualität der Leiterplatten ist großartig und ich muss zugeben, dass es sehr befriedigend ist, sein eigenes Leiterplattendesign herstellen zu lassen.

Montage der Elektronik

Ok, als nächstes ging es weiter mit der Montage der Elektronikkomponenten. Ich begann mit dem Löten von Stiftleisten PCB. Dies ermöglicht bei Bedarf ein einfacheres Verbinden und Trennen der Komponenten. Ich habe eigentlich für alles Stiftleisten verwendet, außer für die Kondensatoren und die Widerstände, die ich direkt auf die Platine gelötet habe. Deshalb habe ich mit dem Löten von Schaltdrähten an alle elektronischen Komponenten fortgefahren.

Auf diese Weise kann ich die Komponenten einfach auf dem Controllergehäuse montieren und gleichzeitig mit der Platine verbinden.

Was das Controller-Gehäuse betrifft, habe ich mich entschieden, es aus 4 mm dickem transparentem Acryl zu machen, weil ich wollte, dass die Schönheit aller elektronischen Komponenten sichtbar ist. Ich benutzte eine Kreissäge, um die Platten für den Fall zu schneiden. Dann machte ich mit einem Bohrer und Forstner-Bits die Öffnung auf der Frontplatte für die Tasten, die Potentiometer, den Netzschalter und den Joystick. Danach habe ich das Gehäuse mit 5 Minuten Epoxid zusammengebaut, und wie für die Oberseite habe ich zwei Schrauben eingesetzt und geklebt, durch die die Frontplatte eingesetzt und mit Muttern darauf befestigt werden kann.

Schließlich begann ich mit dem Zusammenbau der Elektronik, indem ich das Arduino-Board und die A4988-Stepper-Treiber auf die Platine steckte. Dann fuhr ich mit dem Einsetzen und Befestigen der Tasten und der anderen Komponenten auf der Frontplatte fort.

Sobald ich sie gesichert hatte, verband ich die Komponenten mit den entsprechenden Stiftleisten auf der Platine. An der Seitenwand des Gehäuses fügte ich die Strombuchse hinzu und steckte dann die Platine in das Gehäuse. Auf der gleichen Platte gibt es auch ein Loch, durch das ich Überbrückungsdrähte stecke, um die Treiber mit den Schrittmotoren zu verbinden, sowie den Endschalter, den ich am Ende des Schiebers platziert habe.

Mit einem Schrumpfschlauch organisierte ich die Überbrückungsdrähte, die aus dem Controller-Gehäuse herauskamen, und schließlich blieb nur noch, den Controller mit den drei Schrittmotoren und dem Endschalter zu verbinden.

Für die Stromversorgung des Schiebereglers habe ich drei 3,7-V-Li-Ionen-Batterien verwendet, die in Reihe geschaltet sind und etwa 11 V erzeugen. Und das war's, der Slider ist fertig und funktioniert einwandfrei.

DIY Camera Slider Arduino Code

Was nun in diesem Tutorial übrig bleibt, ist, einen Blick auf den Arduino-Code zu werfen und zu erklären, wie das Programm funktioniert. Da der Code etwas länger ist, werde ich zum besseren Verständnis den Quellcode des Programms in Abschnitten mit Beschreibung für jeden Abschnitt veröffentlichen. Und am Ende dieses Artikels werde ich den kompletten Quellcode posten.

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

#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;

Codesprache:Arduino (arduino)

Im Setup-Bereich legen wir die Anfangsgeschwindigkeitswerte für die Stepper fest, definieren einige Pin-Modi und fügen die drei Stepper der Multi-Stepper-Steuerungsinstanz namens „StepperControl“ hinzu. Mit den While-Schleifen bewegen wir den Schieberegler in die Ausgangsposition, oder er bewegt sich, bis er den Endschalter drückt, und bewegt sich dann 200 Schritte zurück, um den Endschalter freizugeben.

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();
  }
} Codesprache:Arduino (arduino)

Im Schleifenabschnitt prüfen wir zunächst, ob der Schieber die Endlagen erreicht hat, oder das der Endschalter ist oder 80cm auf der anderen Seite davon.

// 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) {} Codesprache:Arduino (arduino)

Mit der nächsten if-Anweisung erhöhen wir die Pan- und Tilt-Geschwindigkeit mit jedem Drücken des Joystick-Schalters.

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

Dann prüfen wir, ob wir die Set-Taste gedrückt haben, die zum Setzen der IN- und OUT-Positionen dient. Mit dem ersten Tastendruck speichern wir die IN-Positionen von Schrittmotoren und lassen zusätzlich die IN-LED leuchten.

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; Codesprache:Arduino (arduino)

Auf die gleiche Weise speichern wir mit dem zweiten Druck die OUT-Positionen und die OUT-LED leuchtet 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; Codesprache:Arduino (arduino)

Dann lesen wir mit dem nächsten Knopfdruck den Wert des Auto-Speed-Potentiometers ab, mit dem die maximale Geschwindigkeit der Motoren eingestellt wird. Außerdem fügen wir die IN-Positionen in das Array „gotoposition“ ein, das in der Funktion moveTo() verwendet wird, die die erforderliche Geschwindigkeit für alle Stepper separat berechnet. Dann bewegt sich der Slider mit der Funktion runSpeedToPosition() 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; Codesprache:Arduino (arduino)

Genauso bringen wir bei Fall Nummer 3 oder mit einem weiteren Tastendruck den Schieberegler auf die Position OUT.

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; Codesprache:Arduino (arduino)

Falls wir die Set-Taste länger als eine halbe Sekunde gedrückt halten, wird die 4. case-Anweisung ausgeführt, die die IN- und OUT-Position zurücksetzt, damit wir neue setzen können.

Als nächstes kommt die Joystick-Schwenk- und Neigesteuerung. Der Analogwert, den wir vom Joystick erhalten, liegt zwischen 0 und 1024, oder wenn er in der Mitte ruht, liegen die Werte bei etwa 500. Wenn wir also den Joystick nach links bewegen und der Analogwert größer als 600 ist, stellen wir die Geschwindigkeit ein des jeweiligen Motors auf positiv und umgekehrt, wenn wir den Joystick nach rechts bewegen, stellen wir die Geschwindigkeit des Motors 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);
  } Codesprache:Arduino (arduino)

Bleibt er in der Mitte, wird die Geschwindigkeit auf 0 gesetzt. Diese Methode wird sowohl für die Achsen des Joysticks als auch für das Slider-Potentiometer verwendet. Tatsächlich verwenden wir im Fall des Potentiometers seinen analogen Wert, um auch die Geschwindigkeit des Motors zu erhöhen, wenn wir das Potentiometer weiter drehen.

// 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);
  } Codesprache:Arduino (arduino)

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

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

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:
  http://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();
} Codesprache:Arduino (arduino)

Das wäre alles, ich hoffe, Sie haben dieses Arduino-Projekt genossen und etwas Neues gelernt. Fühlen Sie sich frei, Fragen im Kommentarbereich unten zu stellen und sehen Sie sich meine Arduino-Projektsammlung an.