DIY gemotoriseerde camera-slider met Pan & Tilt – Arduino-gecontroleerd project

In deze tutorial leren we hoe we een gemotoriseerde camera-slider met pan- en tilt-kop maken. Dit Arduino-gebaseerde project is 100% DIY, gebouwd met goedkope materialen zoals MDF en multiplex en bestuurd met Arduino, drie stappenmotoren, enkele knoppen en een joystick op een op maat ontworpen PCB. Ondanks dit is het eindresultaat indrukwekkend, met ultrazachte camerabewegingen die ons in staat stellen professionele cinemato-grafische opnames te maken.

Je kunt de volgende video bekijken of de geschreven tutorial hieronder lezen.

Overzicht

Met de controller kunnen we de camera handmatig bewegen of we kunnen start- en eindpunten instellen, waarna de camera automatisch van de ene naar de andere positie beweegt. Ook met de steunarm kunnen we de slider zelfs op een kleinere statief monteren, onder elke hoek die we willen, en nog steeds stabiele bewegingen krijgen.

Om te beginnen, heb ik de slider ontworpen met 3D-modelleringssoftware.

Je kunt dit 3D-model vinden en downloaden en alle afmetingen eruit halen, alsook het in je browser verkennen op Thangs.

Download het assemblage-3D-model van Thangs.

3D-geprint GT2-tandwiel link: Thingiverse

De camera-slider bouwen

Ik begon met het maken van de slider-rollen waarvoor ik 22 mm dik koperen buis gebruikte. Ik besloot de slider 1 meter lang te maken, dus ik zaagde twee stukken van 1 meter lengte. Koperen buizen kunnen gemakkelijk oxideren, dus we moeten ze polijsten met metaalpolijst. In mijn geval had ik er geen, dus ik gebruikte tandpasta daarvoor.

Dit was niet de perfecte oplossing, maar ik kon toch een verschil zien en de buizen iets schoner krijgen.

Vervolgens ging ik door met het maken van het houten basisframe waarop de twee buizen bevestigd worden en dat ook dient om de slider op een statief te monteren. Met een zaagzaag zaagde ik twee stukken 21 mm dik multiplex en lijmde ze samen om één dikker stuk te krijgen. Vervolgens maakte ik met massief hout een replica van mijn statiefmontageplaat en bevestigde die aan het multiplexstuk met houtlijm en een schroef. Nu kan de sliderbasis gemakkelijk op het statief worden gemonteerd.

Ik zal de slider-rollen aan de basis bevestigen met 8 mm draadstangen, dus ik boorde twee gaten in de basis en plaatste de 138 mm lange stangen die ik al op maat had gezaagd. Vervolgens moest ik 8 mm gaten in de buizen boren, wat eigenlijk een beetje tricky kan zijn.

Daarvoor maakte ik een eenvoudige hulpmiddel waarbij ik het potlood op een hoogte van 11 mm (de helft van de buisdiameter) oplichte. Vervolgens bevestigde ik de buis op een vlakke oppervlakte en markeerde ik de buis vanaf beide kanten met de hulpmiddel. Hierdoor krijg je precies uitgelijnde gaten aan beide kanten. Eerst markeerde ik de boorpunten met een scherpe schroeftop en boorde ze progressief met 2, 4, 6 en 8 mm boor.

Daarna schuifde ik de rollen door de draadstangen en bevestigde ze met enkele ringen en moeren aan de sliderbasis. Op een vergelijkbare manier, met een stuk multiplex en een draadstang, bevestigde ik de uiteinden van de rollen.

Vervolgens is het glijplatform aan de beurt. Opnieuw gebruikte ik de zaagzaag om het 8 mm dik MDF-bord op maat te zagen volgens het 3D-model. Ik maakte ook 8 mm gaten voor de draadstangen waarop de lagers bevestigd gaan worden. Voor de assemblage van het platform gebruikte ik houtlijm en enkele schroeven. Met een accuschroefboormachine maakte ik eerst voorboorgaten, daarna kontersunken en schroefde ik de 3 mm schroeven op hun plaats.

Zodra de panelen bevestigd waren, ging ik door met het monteren van the lagersysteem. De lagers die ik gebruik zijn 608Z met een buitendiameter van 22 mm. Twee ringen en een moer tussen twee lagers creëren voldoende afstand tussen hen, wat goed contact met de 22 mm rollen mogelijk maakt.

Om het platform veiliger te maken wanneer de slider onder een hoek wordt gebruikt, voegde ik op dezelfde manier nog twee sets lagers aan de onderzijde van het platform toe. Aan het eind werkte het glijplatform perfect.

Hier merken we dat nu, wanneer we het platform langs de slider op mijn kleine, niet zware statief bewegen, de kop het gewicht van het platform niet kan dragen, dus ik moest een steunarm maken om de slider te stabiliseren. Met twee stukken hout en enkele moeren en bouten maakte ik een eenvoudige klem die aan één van de statiefpoten kan worden bevestigd.

De klem heeft een bout waarop de steunarm kan worden bevestigd. Vervolgens moest ik een gat in de steunarm maken om de slider onder verschillende hoeken te positioneren. Ik maakte het gat door simpelweg veel 6 mm gaten dicht bij elkaar te boren en daarna met een rasp fijne rechte lijnen te maken. Dit steunsysteem werkte perfect.

Ik ging verder met het toevoegen van poten aan de slider, voor het geval je geen statief wilt of hoeft te gebruiken. Ik maakte ze van 8 mm MDF. Met een handzaag en een rasp kreeg ik de gewenste vorm van de poten. Vervolgens bevestigde ik ze met een beetje lijm en twee moeren aan de uiteinden van de slider.

De volgende fase is het bouwen van het pan- en tiltsysteem dat bovenop het glijplatform wordt bevestigd. Met de zaagzaag zaagde ik alle benodigde stukken, met afmetingen afgeleid van het 3D-model. Ik gebruikte enkele stukken multiplex voor het scharniermechanisme van het uitlijningsplatform voor de camera wanneer de slider onder een hoek staat, alsook enkele MDF-borden waarop ik de juiste gaten voor de motor en de lagers voor het pansysteem maakte.

Een vriend van mij 3D-printte twee 80-tandige tandwielen voor me. Op die manier kreeg ik een 5-voudige snelheidsverlaging ten opzichte van het 16-tandige tandwiel dat op de stappenmotor zit.

Nu moest ik een gesloten tijmband maken volgens mijn opstelling, dus ik meette hoeveel lengte band ik nodig had, zaagde het en plakte het simpelweg met CA-lijm en plakte een stukje tape erbovenop. De CA-lijm doet het uitstekend met rubber, dus de gesloten tijmband werkt zonder probleem.

Vervolgens startte ik de finale assemblage van het pan- en tiltsysteem. Eerst bevestigde ik de tilt-motor met enkele bouten en voegde de twee lagers op hun plaats toe, terwijl ik ze in de sleuven met epoxy bevestigde. Vervolgens bevestigde ik het tilt-platform op het pan-platform met enkele 8 mm bouten en bevestigde ik tegelijkertijd het 80-tandige tandwiel eraan samen met de tijmband.

Hier merkte ik dat de band een beetje los was, maar ik voegde een kleine lager toe op de plaats waar de bout van de stappenmotor zit, om als bandspanner te fungeren. Dit werkte uitstekend en nu had de band voldoende spanning om correct te werken.

Vervolgens bevestigde ik de pan-motor en voegde lagers toe aan de bovenzijde van het uitlijningsplatform, alsook aan de onderzijde. Daarna stak ik een bout doorheen, voegde een drijflager, het 80-tandige tandwiel en de tijmband toe, en bovenop plaatste ik de eerder gemonteerde tilt-kop. Ten slotte bevestigde ik het met een bout en daarmee is de constructie van de slider voltooid.

Schakelschema

Ok, nu komt het leuke deel: de elektronica installeren. Hier is het schakelschema van dit DIY-cameraslider-project.

De drie NEMA 17-stappenmotoren worden bestuurd via drie A4988-stuurprogramma's. Voor het besturen van de sliderbeweging gebruiken we een potentiometer aangesloten op een analoge ingang van de Arduino, en voor het besturen van de pan- en tilt-kop gebruiken we een joystick-module die eigenlijk uit twee potentiometers bestaat, dus die is aangesloten op twee analoge ingangen. Er is ook nog een potentiometer voor het instellen van de snelheid van de automatische beweging tussen de in- en uit-posities. Deze in- en uit-posities worden ingesteld met behulp van een drukknop. Deze drukknop heeft een pull-up-weerstand en is aangesloten op een digitale pin van de Arduino. Er is ook een reset-drukknop, een voedingsschakelaar en een voedingsconnector, alsook een eindschakelaar voor de slider en twee LED's voor het aanwijzen van de in- en uit-status. We kunnen dit project voeden met 9 of 12 V.

Je kunt de benodigde componenten voor dit project via de onderstaande links verkrijgen:

• Stappenmotor (NEMA17)
• A4988 Stuurprogramma
• 12V 2A Adapter
• Joystick
• Voedingsconnector
• Arduino-board

PCB-ontwerp

Volgens het schakelschema ontwierp ik een aangepaste PCB om de elektronische componenten georganiseerd te houden. Ik deed dat met de gratis online schakelontwerpsoftware EasyEDA. Het schema had behoorlijk wat verbindingen, dus ik gebruikte zowel de boven- als de onderlaag en kreeg een functioneel en mooi PCB. Zodra ik met deze stap klaar was, genereerde ik de Gerber-bestanden die nodig zijn voor de productie van de PCB. Vervolgens bestelde ik de PCB bij JLCPCB, wat eigenlijk de sponsor van deze tutorial is.

Hier kunnen we eenvoudig het Gerber-bestand uploaden en eenmaal geüpload kunnen we onze PCB nog eens bekijken in de Gerber-viewer. Als alles klopt, kunnen we doorgaan, de eigenschappen selecteren die we voor onze PCB willen, en dan kunnen we onze PCB bestellen tegen een redelijke prijs. Let op: als het je eerste bestelling is bij JLCPCB, kun je tot 10 PCB's voor slechts 2 dollar krijgen.

Na een week zijn de PCB's aangekomen. De kwaliteit is geweldig en ik moet toegeven dat het best bevredigend is om je eigen PCB-ontwerp geproduceerd te zien.

De elektronica monteren

Ok, nu gaan we de elektronische componenten monteren. Ik begon met het solderen van penkoppen op de PCB. Dit maakt het makkelijker om componenten aan te sluiten en los te koppelen wanneer nodig. Ik gebruikte eigenlijk penkoppen voor alles behalve de condensators en weerstanden die ik direct op de PCB solderde. Vervolgens solderde ik jumperdraden aan alle elektronische componenten.

Op deze manier kan ik de componenten gemakkelijk op de controllerbehuizing monteren en ze tegelijkertijd aan de PCB koppelen.

Voor de controllerbehuizing koos ik voor 4 mm dik transparant acrylaat omdat ik de schoonheid van alle elektronische componenten zichtbaar wilde maken. Ik gebruikte een zaagzaag om de panelen voor de behuizing op maat te zagen. Vervolgens maakte ik met een boormachine en Forstner-boren de opening in het frontpaneel voor de knoppen, potentiometers, voedingsschakelaar en de joystick. Daarna monteerde ik de behuizing met 5-minuten epoxy, en voor de bovenkant plaatste en lijmde ik twee bouten doorheen waarlangs het frontpaneel kan worden geschoven en bevestigd met moeren erbovenop.

Ten slotte begon ik met het monteren van de elektronica door het Arduino-board en de A4988-stuurprogramma's op de PCB te plaatsen. Vervolgens plaatste en bevestigde ik de knoppen en de andere componenten op het frontpaneel.

Zodra ze bevestigd waren, verbond ik de componenten met de juiste penkoppen op de PCB. Aan de zijde van de behuizing voegde ik de voedingsconnector toe, en schuifde ik de PCB in de behuizing. Op hetzelfde paneel zit ook een gat doorheen waar ik jumperdraden doorheen stuurde voor het verbinden van de stuurprogramma's met de stappenmotoren, alsook de eindschakelaar die ik aan het einde van de slider plaatste.

Met enige krimpkous organiseerde ik de jumperdraden die uit de controllerbehuizing komen, en ten slotte was er nog over om de controller met de drie stappenmotoren en de eindschakelaar te verbinden.

Voor de voeding van de slider gebruikte ik drie 3,7 V Li-ion-accu's in serie, wat ongeveer 11 V oplevert. En dat is het, de slider is klaar en werkt perfect.

DIY Camera Slider Arduino-code

Wat er nog overblijft in deze tutorial is een kijkje nemen bij de Arduino-code en uitleggen hoe het programma werkt. Omdat de code wat langer is, voor beter begrip, zal ik de broncode in secties posten met uitleg voor elke sectie. Aan het einde van dit artikel post ik de complete broncode.

Het programma is gebaseerd op de AccelStepper-bibliotheek van Mike McCauley. Dit is een ongelooflijke bibliotheek die eenvoudige controle van meerdere stappenmotoren tegelijkertijd mogelijk maakt. Zodra we deze bibliotheek en de MultiStepper.h-bibliotheek (die erbij hoort) includeren, moeten we alle Arduino-pinnen definiëren die gebruikt gaan worden, de instanties voor de stappenmotoren definiëren, alsook enkele variabelen die nodig zijn voor het programma.

#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- en Uit-snelheidspotiometer
#define JoySwitch 10 // Joystick-schakelaar
#define InOutSet 12 // Set-knop
#define limitSwitch 11
#define inLED 8
#define outLED 9
// Definieer de stappenmotoren en de pinnen die ze zullen gebruiken
AccelStepper stepper1(1, 7, 6); // (Type:driver, STEP, DIR)
AccelStepper stepper2(1, 5, 4);
AccelStepper stepper3(1, 3, 2);
MultiStepper StepperControl; // Maak instantie van MultiStepper
long gotoposition[3]; // Array om de In- of Uit-positie voor elke stappenmotor op te slaan
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;

In de setup-sectie stellen we de initiële snelheidswaarden voor de stappenmotoren in, definiëren sommige pin-modes, alsook voegen we de drie stappenmotoren toe aan de multi-stepper controle-instantie genaamd "StepperControl". Met behulp van while-lussen bewegen we de slider naar de initiële positie, of het beweegt totdat de eindschakelaar wordt ingedrukt en beweegt het dan 200 stappen terug om de eindschakelaar vrij te geven.

void setup() {
  // Stel initiële snelheidswaarden in voor de stappenmotoren
  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);
  // Maak instanties voor MultiStepper - Voeg de 3 stappenmotoren toe aan de StepperControl-instantie voor multi-controle
  StepperControl.addStepper(stepper1);
  StepperControl.addStepper(stepper2);
  StepperControl.addStepper(stepper3);
  // Beweeg de slider naar de initiële positie - homing
  while (digitalRead(limitSwitch) != 0) {
    stepper1.setSpeed(3000);
    stepper1.runSpeed();
    stepper1.setCurrentPosition(0); // Wanneer eindschakelaar ingedrukt, positie op 0 stappen zetten
  }
  delay(20);
  // Beweeg 200 stappen terug van de eindschakelaar
  while (stepper1.currentPosition() != -200) {
    stepper1.setSpeed(-3000);
    stepper1.run();
  }
}

In de loop-sectie beginnen we met controleren of de slider de limietposities heeft bereikt, oftewel de eindschakelaar of 80 cm aan de andere kant.

// Beweging beperken - Niets doen als eindschakelaar ingedrukt of afgelegde afstand in andere richting groter dan 80cm
while (digitalRead(limitSwitch) == 0 || stepper1.currentPosition() < -64800) {}

Met de volgende if-statement verhogen we de Pan- en Tiltsnelheden met elke druk op de joystick-schakelaar.

// Als joystick ingedrukt, verhoog Pan- en Tiltsnelheden
if (digitalRead(JoySwitch) == 0) {
  currentSpeed = currentSpeed + 50;
  delay(200);
}

Dan controleren we of we de Set-knop hebben ingedrukt, die gebruikt wordt voor het instellen van de IN- en UIT-posities. Bij de eerste druk op de knop slaan we de IN-posities van de stappenmotoren op en laten we de IN-LED branden.

switch (InandOut) {
  case 0: // IN-positie instellen
    InandOut = 1;
    XInPoint = stepper1.currentPosition(); // IN-positie voor stepper 1 instellen
    YInPoint = stepper2.currentPosition(); // IN-positie voor stepper 2 instellen
    ZInPoint = stepper3.currentPosition(); // IN-positie voor stepper 3 instellen
    digitalWrite(inLED, HIGH); // IN-LED aan
    break;

Op dezelfde manier slaan we bij de tweede druk de UIT-posities op en laten we de UIT-LED branden.

case 1: // UIT-positie instellen
  InandOut = 2;
  XOutPoint = stepper1.currentPosition(); // UIT-punten voor beide steppers instellen
  YOutPoint = stepper2.currentPosition();
  ZOutPoint = stepper3.currentPosition();
  digitalWrite(outLED, HIGH);
  break;

Dan met de volgende druk op de knop lezen we de waarde van de auto-snelheidspotiometer die gebruikt wordt om de maximale snelheid van de motoren in te stellen. Ook zetten we de IN-posities in de "gotoposition"-array die gebruikt wordt in de moveTo()-functie die de benodigde snelheid voor alle stappenmotoren apart berekent. Vervolgens beweegt de slider met de runSpeedToPosition()-functie automatisch naar de IN-positie.

case 2: // Naar IN-positie bewegen / ga naar case 3
  InandOut = 3;
  inOutSpeed = analogRead(inOutPot); // Auto-snelheidspotiometer
  // Plaats de IN-positie in de Array
  gotoposition[0] = XInPoint;
  gotoposition[1] = YInPoint;
  gotoposition[2] = ZInPoint;
  stepper1.setMaxSpeed(inOutSpeed);
  stepper2.setMaxSpeed(inOutSpeed);
  stepper3.setMaxSpeed(inOutSpeed);
  StepperControl.moveTo(gotoposition); // Berekent vereiste snelheid voor alle motoren
  StepperControl.runSpeedToPosition(); // Blokkeert tot alle steppers in positie zijn
  delay(200);
  break;

Precies op dezelfde manier, in case nummer 3 of met nog een druk op de knop, bewegen we de slider naar de UIT-positie.

case 3: // Naar UIT-positie bewegen / ga terug naar case 2
  InandOut = 2;
  inOutSpeed = analogRead(inOutPot);
  // Plaats de UIT-positie in de Array
  gotoposition[0] = XOutPoint;
  gotoposition[1] = YOutPoint;
  gotoposition[2] = ZOutPoint;
  stepper1.setMaxSpeed(inOutSpeed);
  stepper2.setMaxSpeed(inOutSpeed);
  stepper3.setMaxSpeed(inOutSpeed);
  StepperControl.moveTo(gotoposition);
  StepperControl.runSpeedToPosition();
  delay(200);
  break;

Als we de Set-knop langer dan half seconde ingedrukt houden, wordt de 4e case-statement uitgevoerd, die de IN- en UIT-posities reset zodat we nieuwe kunnen instellen.

Vervolgens is er de joystick Pan- en Tilt-controle. De analoge waarde die we van de joystick krijgen is 0 tot 1024, of wanneer hij in het midden rust is de waarde ongeveer 500. Als we de joystick naar links bewegen en de analoge waarde groter is dan 600, zetten we de snelheid van de betreffende motor op positief, en omgekeerd, als we de joystick naar rechts bewegen, zetten we de snelheid op negatief, wat betekent dat hij de tegenovergestelde kant op draait.

// Joystick X - Pan-beweging
JoyXPos = analogRead(JoyX);
// Als joystick naar links beweegt, beweeg stepper 2 of pan naar links
if (JoyXPos > 600) {
  stepper2.setSpeed(currentSpeed);
}
// Als joystick naar rechts beweegt, beweeg stepper 2 of pan naar rechts
else if (JoyXPos < 400) {
  stepper2.setSpeed(-currentSpeed);
}
// Als joystick in het midden blijft, geen beweging
else {
  stepper2.setSpeed(0);
}

Als hij in het midden blijft, wordt de snelheid op 0 gezet. Deze methode wordt voor beide assen van de joystick gebruikt alsook voor de slider-potentiometer. Eigenlijk, in het geval van de potentiometer gebruiken we de analoge waarde ook om de snelheid van de motor te verhogen naarmate we de potentiometer verder draaien.

// Slider-potentiometer
sliderPos = analogRead(slider);
// Als potentiometer naar links gedraaid, beweeg slider naar links
if (sliderPos > 600) {
  sliderPos = map(sliderPos, 600, 1024, 0, 3000);
  stepper1.setSpeed(sliderPos); // Verhoog snelheid naarmate we draaien
}
// Als potentiometer naar rechts gedraaid, beweeg slider naar rechts
else if (sliderPos < 400) {
  sliderPos = map(sliderPos, 400, 0, 0, 3000);
  stepper1.setSpeed(-sliderPos); // Verhoog snelheid naarmate we draaien
}
// Als potentiometer in het midden, geen beweging
else {
  stepper1.setSpeed(0);
}

Tot slot roepen we de runSpeed()-functies aan voor elk van de drie stappenmotoren en dat voert de bovenstaande commando's uit, of draait de motoren op de juiste manier.

// Voer de bovenstaande commando's uit - draai de stappenmotoren
stepper1.runSpeed();
stepper2.runSpeed();
stepper3.runSpeed();

Hier is de complete broncode:

/* DIY Camera Slider met Pan en 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
#define JoyY A1
#define slider A2
#define inOutPot A3
#define JoySwitch 10
#define InOutSet 12
#define limitSwitch 11
#define inLED 8
#define outLED 9
AccelStepper stepper1(1, 7, 6);
AccelStepper stepper2(1, 5, 4);
AccelStepper stepper3(1, 3, 2);
MultiStepper StepperControl;
long gotoposition[3];
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() {
  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);
  StepperControl.addStepper(stepper1);
  StepperControl.addStepper(stepper2);
  StepperControl.addStepper(stepper3);
  while (digitalRead(limitSwitch) != 0) {
    stepper1.setSpeed(3000);
    stepper1.runSpeed();
    stepper1.setCurrentPosition(0);
  }
  delay(20);
  while (stepper1.currentPosition() != -200) {
    stepper1.setSpeed(-3000);
    stepper1.run();
  }
}

void loop() {
  while (digitalRead(limitSwitch) == 0 || stepper1.currentPosition() < -64800) {}
  if (digitalRead(JoySwitch) == 0) {
    currentSpeed = currentSpeed + 50;
    delay(200);
  }
  if (digitalRead(InOutSet) == 0) {
    delay(500);
    if (digitalRead(InOutSet) == 0) {
      InandOut = 4;
    }
    switch (InandOut) {
      case 0:
        InandOut = 1;
        XInPoint = stepper1.currentPosition();
        YInPoint = stepper2.currentPosition();
        ZInPoint = stepper3.currentPosition();
        digitalWrite(inLED, HIGH);
        break;
      case 1:
        InandOut = 2;
        XOutPoint = stepper1.currentPosition();
        YOutPoint = stepper2.currentPosition();
        ZOutPoint = stepper3.currentPosition();
        digitalWrite(outLED, HIGH);
        break;
      case 2:
        InandOut = 3;
        inOutSpeed = analogRead(inOutPot);
        gotoposition[0] = XInPoint;
        gotoposition[1] = YInPoint;
        gotoposition[2] = ZInPoint;
        stepper1.setMaxSpeed(inOutSpeed);
        stepper2.setMaxSpeed(inOutSpeed);
        stepper3.setMaxSpeed(inOutSpeed);
        StepperControl.moveTo(gotoposition);
        StepperControl.runSpeedToPosition();
        delay(200);
        break;
      case 3:
        InandOut = 2;
        inOutSpeed = analogRead(inOutPot);
        gotoposition[0] = XOutPoint;
        gotoposition[1] = YOutPoint;
        gotoposition[2] = ZOutPoint;
        stepper1.setMaxSpeed(inOutSpeed);
        stepper2.setMaxSpeed(inOutSpeed);
        stepper3.setMaxSpeed(inOutSpeed);
        StepperControl.moveTo(gotoposition);
        StepperControl.runSpeedToPosition();
        delay(200);
        break;
      case 4:
        InandOut = 0;
        digitalWrite(inLED, LOW);
        digitalWrite(outLED, LOW);
        delay(1000);
        break;
    }
  }
  JoyXPos = analogRead(JoyX);
  if (JoyXPos > 600) {
    stepper2.setSpeed(currentSpeed);
  } else if (JoyXPos < 400) {
    stepper2.setSpeed(-currentSpeed);
  } else {
    stepper2.setSpeed(0);
  }
  JoyYPos = analogRead(JoyY);
  if (JoyYPos > 600) {
    stepper3.setSpeed(currentSpeed);
  } else if (JoyYPos < 400) {
    stepper3.setSpeed(-currentSpeed);
  } else {
    stepper3.setSpeed(0);
  }
  sliderPos = analogRead(slider);
  if (sliderPos > 600) {
    sliderPos = map(sliderPos, 600, 1024, 0, 3000);
    stepper1.setSpeed(sliderPos);
  } else if (sliderPos < 400) {
    sliderPos = map(sliderPos, 400, 0, 0, 3000);
    stepper1.setSpeed(-sliderPos);
  } else {
    stepper1.setSpeed(0);
  }
  stepper1.runSpeed();
  stepper2.runSpeed();
  stepper3.runSpeed();
}

Dat was het voor deze tutorial, ik hoop dat je ervan hebt genoten en iets nieuws hebt geleerd. Voel je vrij om vragen te stellen in de reacties hieronder en bekijk mijn Arduino-projectencollectie.