DIY Arduino-robotarm met smartphonebediening

In deze tutorial leren we hoe je een Arduino Robot Arm maakt die draadloos kan worden bestuurd en geprogrammeerd met behulp van een op maat gemaakte Android-applicatie. Ik laat je het hele bouwproces zien, van het ontwerpen en 3D-printen van de robotonderdelen, het aansluiten van de elektronische componenten en het programmeren van de Arduino, tot het ontwikkelen van onze eigen Android-applicatie voor het besturen van de Robotarm.

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

Overzicht

Met behulp van de schuifregelaars in de app kunnen we de beweging van elke servo of as van de robotarm handmatig regelen. Ook kunnen we met behulp van de knop "Opslaan" elke positie of stap vastleggen en vervolgens kan de robotarm deze stappen automatisch uitvoeren en herhalen. Met dezelfde knop kunnen we de automatische werking pauzeren en alle stappen resetten of verwijderen, zodat we nieuwe kunnen opnemen.

Arduino Robotarm 3D-model

Om te beginnen heb ik de Robotarm ontworpen met behulp van Solidworks 3D-modelleringssoftware. De arm heeft 5 vrijheidsgraden.

Voor de eerste 3 assen, de taille, de schouder en de elleboog, gebruikte ik de MG996R-servo's, en voor de andere 2 assen, de polsrol en polssteek, evenals de grijper gebruikte ik de kleinere SG90-microservo's.

U kunt dit 3D-model vinden en downloaden, en het ook verkennen in uw browser op Thangs:

Download het 3D-assemblagemodel van Thangs.

Bedankt Thangs voor het ondersteunen van deze tutorial.

STL-bestanden voor 3D-printen:

Arduino Robot Arm STL-bestanden

3D-printen van de robotarm

Met mijn nieuwe 3D-printer, Creality CR-10, heb ik alle onderdelen voor de Arduino-robotarm in 3D geprint.

Hier zou ik een shout-out willen geven aan Banggood.com voor het leveren van deze geweldige 3D-printer. De afdrukkwaliteit van de Creality CR-10 is geweldig voor zijn prijs en wat ook geweldig is, is dat hij voor bijna 90% voorgemonteerd wordt geleverd.

Om de montage te voltooien, hoeven we alleen de bovenste en onderste delen van het frame te verbinden met behulp van enkele bouten en beugels, en vervolgens de elektronische componenten te verbinden met de schakelkast met behulp van de meegeleverde kabels.

Voordat u het probeert, is het raadzaam om te controleren of de rolwielen stevig genoeg zijn, en als dit niet het geval is, kunt u ze eenvoudig met de excentrische moeren vastzetten. En dat is alles, na het egaliseren van uw 3D-printbed, bent u klaar om uw 3D-creaties om te zetten in realiteit.

Ik had alle onderdelen voor de Arduino Robot Arm in slechts enkele uren klaar.

Lees meer:​​Top 15 onmisbare accessoires en hulpmiddelen voor 3D-printers

De robotarm monteren

Ok, dus op dit punt zijn we klaar om de robotarm te monteren. Ik begon met de basis waarop ik de eerste servomotor bevestigde met behulp van de schroeven die in de verpakking waren meegeleverd. Vervolgens heb ik op de uitgaande as van de servo een ronde hoorn een bout bevestigd.

En daar bovenop heb ik het bovenste deel geplaatst en vastgezet met twee schroeven.

Ook hier gaat eerst de servo, dan de ronde hoorn op het volgende deel, en dan worden ze aan elkaar vastgezet met de bout op de uitgaande as.

We kunnen hier opmerken dat het bij de schouderas een goed idee is om een ​​soort veer toe te voegen of in mijn geval heb ik een rubberen band gebruikt om de servo wat hulp te geven, omdat deze servo ook het hele gewicht van de rest van de arm draagt als de lading.

Op dezelfde manier ging ik verder met het monteren van de rest van de robotarm. Wat betreft het grijpermechanisme heb ik ongeveer 4 millimeter bouten en moeren gebruikt om het te monteren.

Uiteindelijk heb ik het grijpermechanisme op de laatste servo bevestigd en de Arduino-robotarm was voltooid.

Arduino Robotarm-circuitdiagram

De volgende stap is het aansluiten van de elektronica. Het schakelschema van dit project is eigenlijk vrij eenvoudig. We hebben alleen een Arduino-bord en een HC-05 Bluetooth-module nodig voor communicatie met de smartphone. De stuurpennen van de zes servomotoren zijn verbonden met zes digitale pennen van het Arduino-bord.

Voor het aandrijven van de servo's hebben we 5V nodig, maar dit moet van een externe stroombron komen omdat de Arduino niet in staat is om de hoeveelheid stroom aan te kunnen die ze allemaal kunnen trekken. De stroombron moet minimaal 2A stroom kunnen verwerken. Dus als we alles met elkaar hebben verbonden, kunnen we doorgaan met het programmeren van de Arduino en de Android-app maken.

U kunt de benodigde componenten voor dit voorbeeld vinden via de onderstaande links:

• MG996R servomotor…………………….….
• SG90 microservomotor ……..…….….…….
• HC-05 Bluetooth-module ……………….… 
• Arduino-bord …………………………………….
• 5V 2A DC-voeding ……………….….. 

Arduino Robotarm-code

Omdat de code wat langer is, zal ik voor een beter begrip de broncode van het programma in secties plaatsen met een beschrijving voor elke sectie. En aan het einde van dit artikel zal ik de volledige broncode posten.

Dus eerst moeten we de SoftwareSerial-bibliotheek opnemen voor de seriële communicatie van de Bluetooth-module en de servo-bibliotheek. Beide bibliotheken worden meegeleverd met de Arduino IDE, zodat u ze niet extern hoeft te installeren. Vervolgens moeten we de zes servo's, de HC-05 Bluetooth-module en enkele variabelen definiëren voor het opslaan van de huidige en vorige positie van de servo's, evenals arrays voor het opslaan van de posities of de stappen voor de automatische modus.

#include <SoftwareSerial.h>
#include <Servo.h>

Servo servo01;
Servo servo02;
Servo servo03;
Servo servo04;
Servo servo05;
Servo servo06;

SoftwareSerial Bluetooth(3, 4); // Arduino(RX, TX) - HC-05 Bluetooth (TX, RX)

int servo1Pos, servo2Pos, servo3Pos, servo4Pos, servo5Pos, servo6Pos; // current position
int servo1PPos, servo2PPos, servo3PPos, servo4PPos, servo5PPos, servo6PPos; // previous position
int servo01SP[50], servo02SP[50], servo03SP[50], servo04SP[50], servo05SP[50], servo06SP[50]; // for storing positions/steps
int speedDelay = 20;
int index = 0;
String dataIn = "";Code language: Arduino (arduino)

In het setup-gedeelte moeten we de servo's en de Bluetooth-module initialiseren en de robotarm naar de beginpositie verplaatsen. We doen dat met behulp van de functie write() die de servo eenvoudig naar een willekeurige positie van 0 tot 180 graden verplaatst.

void setup() {
  servo01.attach(5);
  servo02.attach(6);
  servo03.attach(7);
  servo04.attach(8);
  servo05.attach(9);
  servo06.attach(10);
  Bluetooth.begin(38400); // Default baud rate of the Bluetooth module
  Bluetooth.setTimeout(1);
  delay(20);
  // Robot arm initial position
  servo1PPos = 90;
  servo01.write(servo1PPos);
  servo2PPos = 150;
  servo02.write(servo2PPos);
  servo3PPos = 35;
  servo03.write(servo3PPos);
  servo4PPos = 140;
  servo04.write(servo4PPos);
  servo5PPos = 85;
  servo05.write(servo5PPos);
  servo6PPos = 80;
  servo06.write(servo6PPos);
}Code language: Arduino (arduino)

Vervolgens controleren we in de loop-sectie, met behulp van de Bluetooth.available()-functie , constant of er binnenkomende gegevens van de smartphone zijn. Indien waar, met behulp van de functie readString() lezen we de gegevens als tekenreeks en slaan we deze op in de variabele dataIn. Afhankelijk van de binnengekomen gegevens zullen we de robotarm vertellen wat hij moet doen.

// Check for incoming data
  if (Bluetooth.available() > 0) {
    dataIn = Bluetooth.readString();  // Read the data as stringCode language: Arduino (arduino)

Android-app bedienen

Laten we nu eens kijken naar de Android-app en zien wat voor soort gegevens het daadwerkelijk naar de Arduino verzendt.

Ik heb de app gemaakt met behulp van de online applicatie MIT App Inventor en hier is hoe het werkt. Bovenaan hebben we twee knoppen om de smartphone te verbinden met de HC-05 Bluetooth-module. Dan hebben we aan de linkerkant een afbeelding van de robotarm en aan de rechterkant hebben we de zes schuifregelaars voor het besturen van de servo's en een schuif voor de snelheidsregeling.

Elke slider heeft een andere initiële, minimale en maximale waarde die past bij de robotarmgewrichten. Onderaan de app hebben we drie knoppen, SAVE, RUN en RESET waarmee we de robotarm kunnen programmeren om automatisch te werken. Er is ook een label hieronder met het aantal stappen dat we hebben opgeslagen. Desalniettemin, voor meer informatie over het bouwen van dergelijke apps met behulp van de MIT App Inventor, kun je mijn andere gedetailleerde tutorial erover raadplegen.

Oké, laten we nu het programma of de blokken achter de applicatie bekijken. Ten eerste hebben we aan de linkerkant de blokken om de smartphone aan te sluiten op de Bluetooth-module.

Dan hebben we nog de schuifblokken voor de servopositieregeling en de knoppenblokken voor het programmeren van de robotarm. Dus als we de positie van de schuifregelaar wijzigen, met behulp van de Bluetooth-functie .SendText, sturen we een tekst naar de Arduino. Deze tekst bestaat uit een voorvoegsel dat aangeeft welke schuifregelaar is gewijzigd, evenals de huidige waarde van de schuifregelaar.

Hier is een downloadbestand van het bovenstaande MIT App Inventor-project, evenals de Android-app die klaar is om op uw smartphone te worden geïnstalleerd:

Arduino Robot Arm Control MIT App Inventor Project File

Android-app voor Arduino-robotarmbesturing

Daarom controleren we bij de Arduino met behulp van de functie startsWith() het voorvoegsel van elke binnenkomende gegevens en weten we wat we moeten doen. Als het voorvoegsel bijvoorbeeld "s1" is, weten we dat we servo nummer één moeten verplaatsen. Met behulp van de functie substring() krijgen we de resterende tekst, of dat is de positiewaarde, we zetten deze om in een geheel getal en gebruiken de waarde om de servo naar die positie te verplaatsen.

// If "Waist" slider has changed value - Move Servo 1 to position
    if (dataIn.startsWith("s1")) {
      String dataInS = dataIn.substring(2, dataIn.length()); // Extract only the number. E.g. from "s1120" to "120"
      servo1Pos = dataInS.toInt();  // Convert the string into integerCode language: Arduino (arduino)

Hier kunnen we eenvoudig de functie write() aanroepen en de servo zal naar die positie gaan, maar op die manier zou de servo op zijn maximale snelheid draaien, wat te veel is voor de robotarm. In plaats daarvan moeten we de snelheid van de servo's regelen, dus ik heb enkele FOR-lussen gebruikt om de servo geleidelijk van de vorige naar de huidige positie te verplaatsen door een vertragingstijd tussen elke iteratie te implementeren. Door de vertragingstijd te wijzigen, kunt u de snelheid van de servo wijzigen.

// We use for loops so we can control the speed of the servo
      // If previous position is bigger then current position
      if (servo1PPos > servo1Pos) {
        for ( int j = servo1PPos; j >= servo1Pos; j--) {   // Run servo down
          servo01.write(j);
          delay(20);    // defines the speed at which the servo rotates
        }
      }
      // If previous position is smaller then current position
      if (servo1PPos < servo1Pos) {
        for ( int j = servo1PPos; j <= servo1Pos; j++) {   // Run servo up
          servo01.write(j);
          delay(20);
        }
      }
      servo1PPos = servo1Pos;   // set current position as previous position
    }Code language: Arduino (arduino)

Dezelfde methode wordt gebruikt voor het aandrijven van elke as van de robotarm.

Daaronder bevindt zich de OPSLAAN-knop. Als we op de SAVE-knop drukken, wordt de positie van elke servomotor opgeslagen in een array. Met elke druk op de knop wordt de index groter, zodat de array stap voor stap wordt gevuld.

// If button "SAVE" is pressed
    if (dataIn.startsWith("SAVE")) {
      servo01SP[index] = servo1PPos;  // save position into the array
      servo02SP[index] = servo2PPos;
      servo03SP[index] = servo3PPos;
      servo04SP[index] = servo4PPos;
      servo05SP[index] = servo5PPos;
      servo06SP[index] = servo6PPos;
      index++;                        // Increase the array index
    }Code language: Arduino (arduino)

Als we dan op de RUN-knop drukken, roepen we de runservo() aangepaste functie aan die opgeslagen stappen uitvoert. Laten we deze functie eens bekijken. Dus hier voeren we de opgeslagen stappen steeds opnieuw uit totdat we op de RESET-knop drukken. Met behulp van de FOR-lus lopen we door alle posities die in de arrays zijn opgeslagen en controleren we tegelijkertijd of we binnenkomende gegevens van de smartphone hebben. Deze gegevens kunnen de RUN/PAUZE-knop zijn, die de robot pauzeert en bij nogmaals klikken doorgaat met de automatische bewegingen. Als we de positie van de snelheidsschuifregelaar wijzigen, zullen we die waarde ook gebruiken om de vertragingstijd tussen elke iteratie in de FOR-lussen hieronder te wijzigen, die de snelheid van de servomotoren regelt.

// Automatic mode custom function - run the saved steps
void runservo() {
  while (dataIn != "RESET") {   // Run the steps over and over again until "RESET" button is pressed
    for (int i = 0; i <= index - 2; i++) {  // Run through all steps(index)
      if (Bluetooth.available() > 0) {      // Check for incomding data
        dataIn = Bluetooth.readString();
        if ( dataIn == "PAUSE") {           // If button "PAUSE" is pressed
          while (dataIn != "RUN") {         // Wait until "RUN" is pressed again
            if (Bluetooth.available() > 0) {
              dataIn = Bluetooth.readString();
              if ( dataIn == "RESET") {     
                break;
              }
            }
          }
        }
        // If SPEED slider is changed
        if (dataIn.startsWith("ss")) {
          String dataInS = dataIn.substring(2, dataIn.length());
          speedDelay = dataInS.toInt(); // Change servo speed (delay time)
        }
      }
      // Servo 1
      if (servo01SP[i] == servo01SP[i + 1]) {
      }
      if (servo01SP[i] > servo01SP[i + 1]) {
        for ( int j = servo01SP[i]; j >= servo01SP[i + 1]; j--) {
          servo01.write(j);
          delay(speedDelay);
        }
      }
      if (servo01SP[i] < servo01SP[i + 1]) {
        for ( int j = servo01SP[i]; j <= servo01SP[i + 1]; j++) {
          servo01.write(j);
          delay(speedDelay);
        }
      }Code language: Arduino (arduino)

Op dezelfde manier als eerder uitgelegd met deze IF-statements en FOR-lussen, verplaatsen we de servo's naar hun volgende positie. Als we ten slotte op de RESET-knop drukken, wissen we alle gegevens van de arrays naar nul en stellen we ook de index opnieuw in op nul, zodat we de robotarm kunnen herprogrammeren met nieuwe bewegingen.

// If button "RESET" is pressed
    if ( dataIn == "RESET") {
      memset(servo01SP, 0, sizeof(servo01SP)); // Clear the array data to 0
      memset(servo02SP, 0, sizeof(servo02SP));
      memset(servo03SP, 0, sizeof(servo03SP));
      memset(servo04SP, 0, sizeof(servo04SP));
      memset(servo05SP, 0, sizeof(servo05SP));
      memset(servo06SP, 0, sizeof(servo06SP));
      index = 0;  // Index to 0
    }Code language: Arduino (arduino)

En dat is het, nu kunnen we genieten en plezier hebben met de robotarm.

Hier is de volledige code van de Arduino Robot Arm:

/*        
       DIY Arduino Robot Arm Smartphone Control  
        by Dejan, www.HowToMechatronics.com  
*/

#include <SoftwareSerial.h>
#include <Servo.h>

Servo servo01;
Servo servo02;
Servo servo03;
Servo servo04;
Servo servo05;
Servo servo06;

SoftwareSerial Bluetooth(3, 4); // Arduino(RX, TX) - HC-05 Bluetooth (TX, RX)

int servo1Pos, servo2Pos, servo3Pos, servo4Pos, servo5Pos, servo6Pos; // current position
int servo1PPos, servo2PPos, servo3PPos, servo4PPos, servo5PPos, servo6PPos; // previous position
int servo01SP[50], servo02SP[50], servo03SP[50], servo04SP[50], servo05SP[50], servo06SP[50]; // for storing positions/steps
int speedDelay = 20;
int index = 0;
String dataIn = "";

void setup() {
  servo01.attach(5);
  servo02.attach(6);
  servo03.attach(7);
  servo04.attach(8);
  servo05.attach(9);
  servo06.attach(10);
  Bluetooth.begin(38400); // Default baud rate of the Bluetooth module
  Bluetooth.setTimeout(1);
  delay(20);
  // Robot arm initial position
  servo1PPos = 90;
  servo01.write(servo1PPos);
  servo2PPos = 150;
  servo02.write(servo2PPos);
  servo3PPos = 35;
  servo03.write(servo3PPos);
  servo4PPos = 140;
  servo04.write(servo4PPos);
  servo5PPos = 85;
  servo05.write(servo5PPos);
  servo6PPos = 80;
  servo06.write(servo6PPos);
}

void loop() {
  // Check for incoming data
  if (Bluetooth.available() > 0) {
    dataIn = Bluetooth.readString();  // Read the data as string
    
    // If "Waist" slider has changed value - Move Servo 1 to position
    if (dataIn.startsWith("s1")) {
      String dataInS = dataIn.substring(2, dataIn.length()); // Extract only the number. E.g. from "s1120" to "120"
      servo1Pos = dataInS.toInt();  // Convert the string into integer
      // We use for loops so we can control the speed of the servo
      // If previous position is bigger then current position
      if (servo1PPos > servo1Pos) {
        for ( int j = servo1PPos; j >= servo1Pos; j--) {   // Run servo down
          servo01.write(j);
          delay(20);    // defines the speed at which the servo rotates
        }
      }
      // If previous position is smaller then current position
      if (servo1PPos < servo1Pos) {
        for ( int j = servo1PPos; j <= servo1Pos; j++) {   // Run servo up
          servo01.write(j);
          delay(20);
        }
      }
      servo1PPos = servo1Pos;   // set current position as previous position
    }
    
    // Move Servo 2
    if (dataIn.startsWith("s2")) {
      String dataInS = dataIn.substring(2, dataIn.length());
      servo2Pos = dataInS.toInt();

      if (servo2PPos > servo2Pos) {
        for ( int j = servo2PPos; j >= servo2Pos; j--) {
          servo02.write(j);
          delay(50);
        }
      }
      if (servo2PPos < servo2Pos) {
        for ( int j = servo2PPos; j <= servo2Pos; j++) {
          servo02.write(j);
          delay(50);
        }
      }
      servo2PPos = servo2Pos;
    }
    // Move Servo 3
    if (dataIn.startsWith("s3")) {
      String dataInS = dataIn.substring(2, dataIn.length());
      servo3Pos = dataInS.toInt();
      if (servo3PPos > servo3Pos) {
        for ( int j = servo3PPos; j >= servo3Pos; j--) {
          servo03.write(j);
          delay(30);
        }
      }
      if (servo3PPos < servo3Pos) {
        for ( int j = servo3PPos; j <= servo3Pos; j++) {
          servo03.write(j);
          delay(30);
        }
      }
      servo3PPos = servo3Pos;
    }
    // Move Servo 4
    if (dataIn.startsWith("s4")) {
      String dataInS = dataIn.substring(2, dataIn.length());
      servo4Pos = dataInS.toInt();
      if (servo4PPos > servo4Pos) {
        for ( int j = servo4PPos; j >= servo4Pos; j--) {
          servo04.write(j);
          delay(30);
        }
      }
      if (servo4PPos < servo4Pos) {
        for ( int j = servo4PPos; j <= servo4Pos; j++) {
          servo04.write(j);
          delay(30);
        }
      }
      servo4PPos = servo4Pos;
    }
    // Move Servo 5
    if (dataIn.startsWith("s5")) {
      String dataInS = dataIn.substring(2, dataIn.length());
      servo5Pos = dataInS.toInt();
      if (servo5PPos > servo5Pos) {
        for ( int j = servo5PPos; j >= servo5Pos; j--) {
          servo05.write(j);
          delay(30);
        }
      }
      if (servo5PPos < servo5Pos) {
        for ( int j = servo5PPos; j <= servo5Pos; j++) {
          servo05.write(j);
          delay(30);
        }
      }
      servo5PPos = servo5Pos;
    }
    // Move Servo 6
    if (dataIn.startsWith("s6")) {
      String dataInS = dataIn.substring(2, dataIn.length());
      servo6Pos = dataInS.toInt();
      if (servo6PPos > servo6Pos) {
        for ( int j = servo6PPos; j >= servo6Pos; j--) {
          servo06.write(j);
          delay(30);
        }
      }
      if (servo6PPos < servo6Pos) {
        for ( int j = servo6PPos; j <= servo6Pos; j++) {
          servo06.write(j);
          delay(30);
        }
      }
      servo6PPos = servo6Pos; 
    }
    // If button "SAVE" is pressed
    if (dataIn.startsWith("SAVE")) {
      servo01SP[index] = servo1PPos;  // save position into the array
      servo02SP[index] = servo2PPos;
      servo03SP[index] = servo3PPos;
      servo04SP[index] = servo4PPos;
      servo05SP[index] = servo5PPos;
      servo06SP[index] = servo6PPos;
      index++;                        // Increase the array index
    }
    // If button "RUN" is pressed
    if (dataIn.startsWith("RUN")) {
      runservo();  // Automatic mode - run the saved steps 
    }
    // If button "RESET" is pressed
    if ( dataIn == "RESET") {
      memset(servo01SP, 0, sizeof(servo01SP)); // Clear the array data to 0
      memset(servo02SP, 0, sizeof(servo02SP));
      memset(servo03SP, 0, sizeof(servo03SP));
      memset(servo04SP, 0, sizeof(servo04SP));
      memset(servo05SP, 0, sizeof(servo05SP));
      memset(servo06SP, 0, sizeof(servo06SP));
      index = 0;  // Index to 0
    }
  }
}

// Automatic mode custom function - run the saved steps
void runservo() {
  while (dataIn != "RESET") {   // Run the steps over and over again until "RESET" button is pressed
    for (int i = 0; i <= index - 2; i++) {  // Run through all steps(index)
      if (Bluetooth.available() > 0) {      // Check for incomding data
        dataIn = Bluetooth.readString();
        if ( dataIn == "PAUSE") {           // If button "PAUSE" is pressed
          while (dataIn != "RUN") {         // Wait until "RUN" is pressed again
            if (Bluetooth.available() > 0) {
              dataIn = Bluetooth.readString();
              if ( dataIn == "RESET") {     
                break;
              }
            }
          }
        }
        // If speed slider is changed
        if (dataIn.startsWith("ss")) {
          String dataInS = dataIn.substring(2, dataIn.length());
          speedDelay = dataInS.toInt(); // Change servo speed (delay time)
        }
      }
      // Servo 1
      if (servo01SP[i] == servo01SP[i + 1]) {
      }
      if (servo01SP[i] > servo01SP[i + 1]) {
        for ( int j = servo01SP[i]; j >= servo01SP[i + 1]; j--) {
          servo01.write(j);
          delay(speedDelay);
        }
      }
      if (servo01SP[i] < servo01SP[i + 1]) {
        for ( int j = servo01SP[i]; j <= servo01SP[i + 1]; j++) {
          servo01.write(j);
          delay(speedDelay);
        }
      }

      // Servo 2
      if (servo02SP[i] == servo02SP[i + 1]) {
      }
      if (servo02SP[i] > servo02SP[i + 1]) {
        for ( int j = servo02SP[i]; j >= servo02SP[i + 1]; j--) {
          servo02.write(j);
          delay(speedDelay);
        }
      }
      if (servo02SP[i] < servo02SP[i + 1]) {
        for ( int j = servo02SP[i]; j <= servo02SP[i + 1]; j++) {
          servo02.write(j);
          delay(speedDelay);
        }
      }

      // Servo 3
      if (servo03SP[i] == servo03SP[i + 1]) {
      }
      if (servo03SP[i] > servo03SP[i + 1]) {
        for ( int j = servo03SP[i]; j >= servo03SP[i + 1]; j--) {
          servo03.write(j);
          delay(speedDelay);
        }
      }
      if (servo03SP[i] < servo03SP[i + 1]) {
        for ( int j = servo03SP[i]; j <= servo03SP[i + 1]; j++) {
          servo03.write(j);
          delay(speedDelay);
        }
      }

      // Servo 4
      if (servo04SP[i] == servo04SP[i + 1]) {
      }
      if (servo04SP[i] > servo04SP[i + 1]) {
        for ( int j = servo04SP[i]; j >= servo04SP[i + 1]; j--) {
          servo04.write(j);
          delay(speedDelay);
        }
      }
      if (servo04SP[i] < servo04SP[i + 1]) {
        for ( int j = servo04SP[i]; j <= servo04SP[i + 1]; j++) {
          servo04.write(j);
          delay(speedDelay);
        }
      }

      // Servo 5
      if (servo05SP[i] == servo05SP[i + 1]) {
      }
      if (servo05SP[i] > servo05SP[i + 1]) {
        for ( int j = servo05SP[i]; j >= servo05SP[i + 1]; j--) {
          servo05.write(j);
          delay(speedDelay);
        }
      }
      if (servo05SP[i] < servo05SP[i + 1]) {
        for ( int j = servo05SP[i]; j <= servo05SP[i + 1]; j++) {
          servo05.write(j);
          delay(speedDelay);
        }
      }

      // Servo 6
      if (servo06SP[i] == servo06SP[i + 1]) {
      }
      if (servo06SP[i] > servo06SP[i + 1]) {
        for ( int j = servo06SP[i]; j >= servo06SP[i + 1]; j--) {
          servo06.write(j);
          delay(speedDelay);
        }
      }
      if (servo06SP[i] < servo06SP[i + 1]) {
        for ( int j = servo06SP[i]; j <= servo06SP[i + 1]; j++) {
          servo06.write(j);
          delay(speedDelay);
        }
      }
    }
  }
}Code language: Arduino (arduino)

Ik hoop dat je deze video leuk vond en iets nieuws hebt geleerd. Stel gerust een vraag in de opmerkingen hieronder en bekijk mijn Arduino Projects-collectie.