Bouw een Slimme Arduino-gestuurde Robotarm: Eenvoudige DIY Handleiding

Onderdelen en benodigdheden

Over dit project

In deze tutorial bouw ik een eenvoudige robotarm die wordt bestuurd door een "meester-arm" (master arm). De arm onthoudt bewegingen en speelt ze in volgorde af. Het concept is niet nieuw – geïnspireerd door "Mini Robotic Arm" van Stoerpeak – maar ik wilde het al lang maken. Toen was ik nog beginner zonder programmeerkennis. Nu bouw ik er eindelijk een, eenvoudig, goedkoop, en deel het met jullie.

Laten we beginnen...

Stap 1: Benodigdheden

• Servomotoren × 5
• Potentiometers × 5
• Arduino UNO
• Voeding (ik gebruik een 5V adapter)
• Breadboard
• Karton/Hout/Sun-board/Acrylaat – wat beschikbaar is
• Arduino IDE geïnstalleerd

Stap 2: De arm maken

Ik gebruikte ijshoutjes (popsicle sticks) voor de arm. Elk materiaal dat beschikbaar is werkt; je kunt ook andere mechanische ontwerpen proberen voor een stabielere arm. Mijn ontwerp is niet erg stabiel.

Servo's vastgezet met dubbelzijdig tape op de ijshoutjes en bevestigd met schroeven.

Voor de meester-arm: potentiometers op ijshoutjes gelijmd en als arm in elkaar gezet.

Alles gemonteerd op een A4-formaat canvas bord als basis.

Stap 3: Verbindingen maken

1. Alle servomotoren parallel aan de voeding: rode draad aan +, zwart/bruin aan GND.
2. Signaaldraden (geel/oranje) naar PWM-pinnen van de Arduino.
3. Potentiometers parallel aan +5V en GND van Arduino.
4. Middenpoot (wiper) van elke potentiometer naar analoge ingang van Arduino.

Pin-indeling:

• Digitale PWM-pinnen 3, 5, 6, 9, 10 → servomotoren
• Analoge pinnen A0 t/m A4 → potentiometers
• Servo op pin 3 ← potentiometer op A0, servo op pin 5 ← pot op A1, enz.

Belangrijk: Zelfs als servo's niet via de Arduino gevoed worden, moet de GND van de servo's met de Arduino GND verbonden zijn, anders werkt de arm niet.

Stap 4: Programmeren

De logica is eenvoudig: potentiometerwaarden worden in een array opgeslagen, vervolgens wordt de array afgegaan met een for-lus en bewegen de servo's naar de opgeslagen posities. Referentie: Arduino Potentiometer Servo Control & Memory.

Globale variabelen

#include <Servo.h>
// Servo-objecten
Servo Servo_0; Servo Servo_1; Servo Servo_2; Servo Servo_3; Servo Servo_4;
// Potentiometer-variabelen
int Pot_0, Pot_1, Pot_2, Pot_3, Pot_4;
// Servo-positie opslag
int Servo_0_Pos, Servo_1_Pos, Servo_2_Pos, Servo_3_Pos, Servo_4_Pos;
// Vorige posities
int Prev_0_Pos, Prev_1_Pos, Prev_2_Pos, Prev_3_Pos, Prev_4_Pos;
// Huidige posities
int Current_0_Pos, Current_1_Pos, Current_2_Pos, Current_3_Pos, Current_4_Pos;
int Servo_Position; // Hoek
int Servo_Number;   // Servo-nummer
int Storage[600];   // Data-array (groter = meer geheugen)
int Index = 0;      // Array-index
char data = 0;      // Seriële invoer

Setup-functie

void setup() {
  Serial.begin(9600);
  Servo_0.attach(3); Servo_1.attach(5); Servo_2.attach(6);
  Servo_3.attach(9); Servo_4.attach(10);
  // Startpositie 100 graden
  Servo_0.write(100); Servo_1.write(100); Servo_2.write(100);
  Servo_3.write(100); Servo_4.write(100);
  Serial.println("Druk 'R' om op te nemen, 'P' om af te spelen");
}

Potentiometer-leesfunctie

void Map_Pot() {
  // Servo's draaien 180°, maar limieten (1-179) gebruiken voorkomt buzzen
  Pot_0 = analogRead(A0);
  Servo_0_Pos = map(Pot_0, 0, 1023, 1, 179);
  Servo_0.write(Servo_0_Pos);

  Pot_1 = analogRead(A1);
  Servo_1_Pos = map(Pot_1, 0, 1023, 1, 179);
  Servo_1.write(Servo_1_Pos);

  Pot_2 = analogRead(A2);
  Servo_2_Pos = map(Pot_2, 0, 1023, 1, 179);
  Servo_2.write(Servo_2_Pos);

  Pot_3 = analogRead(A3);
  Servo_3_Pos = map(Pot_3, 0, 1023, 1, 179);
  Servo_3.write(Servo_3_Pos);

  Pot_4 = analogRead(A4);
  Servo_4_Pos = map(Pot_4, 0, 1023, 1, 179);
  Servo_4.write(Servo_4_Pos);
}

Hoofd-lus

void loop() {
  Map_Pot(); // Lees potentiometers

  while (Serial.available() > 0) {
    data = Serial.read();
    if (data == 'R') Serial.println("Opnamen gestart...");
    if (data == 'P') Serial.println("Afspelen opgenomen bewegingen...");
  }

  if (data == 'R') { // OPNAME MODUS
    // Vorige posities opslaan
    Prev_0_Pos = Servo_0_Pos; Prev_1_Pos = Servo_1_Pos;
    Prev_2_Pos = Servo_2_Pos; Prev_3_Pos = Servo_3_Pos;
    Prev_4_Pos = Servo_4_Pos;

    Map_Pot(); // Nieuwe waarden lezen voor vergelijking

    // Voor elke servo: als positie gewijzigd, opslaan in array
    if (abs(Prev_0_Pos - Servo_0_Pos) > 0) { // Let: originele code had bug in abs()
      Servo_0.write(Servo_0_Pos);
      if (Current_0_Pos != Servo_0_Pos) {
        Storage[Index] = Servo_0_Pos + 0; // +0 voor servo 0
        Index++;
      }
      Current_0_Pos = Servo_0_Pos;
    }
    // Hetzelfde voor servo 1 t/m 4 met offset +100, +200, +300, +400
    if (abs(Prev_1_Pos - Servo_1_Pos) > 0) {
      Servo_1.write(Servo_1_Pos);
      if (Current_1_Pos != Servo_1_Pos) { Storage[Index] = Servo_1_Pos + 100; Index++; }
      Current_1_Pos = Servo_1_Pos;
    }
    if (abs(Prev_2_Pos - Servo_2_Pos) > 0) {
      Servo_2.write(Servo_2_Pos);
      if (Current_2_Pos != Servo_2_Pos) { Storage[Index] = Servo_2_Pos + 200; Index++; }
      Current_2_Pos = Servo_2_Pos;
    }
    if (abs(Prev_3_Pos - Servo_3_Pos) > 0) {
      Servo_3.write(Servo_3_Pos);
      if (Current_3_Pos != Servo_3_Pos) { Storage[Index] = Servo_3_Pos + 300; Index++; }
      Current_3_Pos = Servo_3_Pos;
    }
    if (abs(Prev_4_Pos - Servo_4_Pos) > 0) {
      Servo_4.write(Servo_4_Pos);
      if (Current_4_Pos != Servo_4_Pos) { Storage[Index] = Servo_4_Pos + 400; Index++; }
      Current_4_Pos = Servo_4_Pos;
    }

    // Debug output
    Serial.print(Servo_0_Pos); Serial.print("\t");
    Serial.print(Servo_1_Pos); Serial.print("\t");
    Serial.print(Servo_2_Pos); Serial.print("\t");
    Serial.print(Servo_3_Pos); Serial.print("\t");
    Serial.println(Servo_4_Pos);
    Serial.print("Index = "); Serial.println(Index);
    delay(50);
  }

  if (data == 'P') { // AFPEEL MODUS
    for (int i = 0; i < Index; i++) {
      Servo_Number = Storage[i] / 100;      // Welke servo (0-4)
      Servo_Position = Storage[i] % 100;    // Positie (0-99, eigenlijk 1-179)
      switch (Servo_Number) {
        case 0: Servo_0.write(Servo_Position); break;
        case 1: Servo_1.write(Servo_Position); break;
        case 2: Servo_2.write(Servo_Position); break;
        case 3: Servo_3.write(Servo_Position); break;
        case 4: Servo_4.write(Servo_Position); break;
      }
      delay(50);
    }
  }
}

Opmerking: In de originele code zat een bug in de abs() vergelijking (abs(Prev_0_Pos == Servo_0_Pos) levert altijd 0 of 1 op). Hierboven gecorrigeerd naar abs(Prev_0_Pos - Servo_0_Pos) > 0.

Download Record-Play.ino

Stap 5: Testen

1. Upload de code naar de Arduino.
2. Open de Seriële Monitor (Tools → Serial Monitor). De Arduino reset bij opening.
3. Bedien de robotarm met de meester-arm. Nog wordt niets opgeslagen.
4. Typ 'R' in de monitor om opname te starten. Voer de gewenste bewegingen uit.
5. Typ 'P' om de opgeslagen bewegingen af te spelen. De servo's herhalen de reeks zolang de Arduino niet gereset wordt.

Veel plezier met het project! Verbeteringen en suggesties zijn welkom in de reacties.

Schema