Präzisen PC-gesteuerten Roboterarm mit Arduino Nano & Tower Pro MG996R Servos bauen

Komponenten und Materialien

Komponente	Menge
Arduino Nano R3	1
Servos (Tower Pro MG996R)	4

Apps und Online-Dienste

• Microsoft Visual Studio 2015
• Arduino IDE

Über dieses Projekt

Ich bewundere seit jeher moderne Fertigungstechnologien und die wichtige Rolle, die diese Maschinen in verschiedenen Bereichen der Fertigung spielen: Heben von Materialien, Installieren und Sammeln von Teilen, Schweißen und Schneiden und nicht zuletzt ihre Verwendbarkeit in Lagern.

Meine Erfahrung beim Bau dieses Roboterarms war eine Herausforderung. Als Einstieg wählte ich einen einfachen Roboterarm, der 2016 von fortzeroas entworfen wurde. Dann entschied ich mich, ihn nicht wie üblich manuell zu steuern, sondern eine Automatisierungs-App als „C# Windows Application“ zu erstellen, die wie Fertigungsautomatisierungs-Apps aussieht.

Basierend auf meinen Programmiererfahrungen habe ich diese Automatisierungsanwendung erstellt, um den Roboterarm vollständig zu steuern, seine Bewegungen zu überwachen und ihm verschiedene Aufgaben zuzuweisen.

Schritt 1: Material

Das Hauptmaterial ist MDF-Holz. Ich verwendete 2 mm für die Struktur und 4 mm für die Basis.

Bauplänen stehen im letzten Schritt zum Download bereit. Sie müssen das Muster ausdrucken und direkt auf das MDF kleben.

Entlang der Konturen schneiden und Bohrlöcher bohren. Ich verwendete ein Rotationswerkzeug zum Bohren und Schneiden des Holzes. Für die Basis habe ich keine Baupläne, aber ich denke, Sie können improvisieren.

Schritt 2: Lackieren und Gestalten

Um dem Projekt ein attraktives Aussehen zu verleihen, verwendete ich dieselben Baupläne und entwarf mit Photoshop eine Abdeckung mit Decals und geometrischen Formen für einen realistischen Look, die ich dann mit Weißleim auf das Holz klebte.

Schritt 3: Rahmenmontage

Dieser Roboterarm war einfach zu montieren, da alles im Voraus geplant war. Es ging einfach darum, die Servomotoren mit Schrauben an Ort und Stelle zu befestigen, wobei ich während der Arbeit kleinere Anpassungen vornahm.

Um die rechte und linke Seite zu verbinden, verwendete ich dicke Holzstäbe und klebte sie mit Sekundenkleber statt mit langen Schrauben, um das Gewicht zu reduzieren.

Schritt 4: Greifer (Klemmmechanismus)

Ich bog zwei Metallstangen mit einer Zange und bohrte ein Loch in ein 3 mm dickes Holzstück mit dem Rotationswerkzeug und klebte es mit Sekundenkleber.

Schritt 5: Basis bauen

Die Basis besteht aus 4 mm dickem MDF-Holz. Ich sägte ein Quadrat von ca. 17 cm × 10 cm mit der Tischsäge und bohrte ein Loch für den Basis-Servomotor 9g. Um die Reibung zwischen Basis und Zylinder zu verringern, schnitt ich ein Stück starker Pappe (2,5 cm Höhe, 10 cm Durchmesser) zu und bohrte es ebenfalls, um die Servomotorwelle zu befestigen.

Schritt 6: Elektronik

Bei der Verwendung von mehr als zwei Servos mit Arduino müssen Sie eine externe Stromquelle für diese verwenden. In diesem Projekt verwendete ich drei Mikroservos 9g und einen großen Servomotor.

Natürlich war der erste Demonstrationstest virtuell auf tinkercad.com, um die Servos zu simulieren und den elektrischen Schaltkreis zu testen.

In diesem Fall verwendete ich 4 AA-Batterien à 1,5 V, was 6 V ergibt. Dann baute ich einen Testaufbau auf dem Steckbrett und anschließend eine sehr einfache Erweiterungsplatine für den Arduino Nano.

Schritt 7: Arduino Code

1. Laden Sie die neueste Version der Arduino IDE herunter und installieren Sie sie. Die neueste Version für Windows, Linux oder macOS finden Sie auf der Arduino-Website: arduino.cc
2. Stecken Sie Ihr Arduino-Board in den USB-Port.
3. Gehen Sie zu Werkzeuge > Board und wählen Sie Ihr Board aus.
4. Kopieren Sie den Code in den IDE-Editor.
5. Überprüfen Sie Ihren Code, indem Sie auf das (✔) Symbol klicken.
6. Laden Sie den Code auf Ihr Board, indem Sie auf das (➤) Symbol klicken.

Schritt 8: Automatisierungsanwendung

Dies ist eigentlich mein Lieblingsteil: Ein Arduino-Projekt mit dem PC zu automatisieren. Meiner Meinung nach war es ein guter Einstieg, um zu lernen, wie man die Fähigkeiten zur Steuerung des Boards und zukünftiger Projekte verbessert.

Das Erreichen fester Winkelpositionen war nicht einfach. Anfangs löste ich dieses Problem mit einer Drittanbieter-Anwendung namens „Processing 3“. In der Anfangsphase erstellte ich eine unterstützende Schnittstelle, die die Roboterarm-Servos (Basis, Schulter, Ellbogen und Greifer) per Tastatur simulierte und sie separat „Winkel für Winkel“ bewegte, bis sie eine zuvor vorbereitete feste Position erreichte.

Wenn diese Position erreicht war, zeichnete ich diese vier Winkel in ein Code-Array (A,B,C,D) auf. Diese Multi-Arrays verwendete ich später in meiner Windows-Anwendung. Das half mir sehr, die Grenzen jedes Servomotors an seiner Position zu kennen.

Diese erfassten Grenzwerte setzte ich als Richtlinien in die Benutzeroberflächen-Seitenleisten ein, um den ARM unter Kontrolle zu halten und die Wiedergabefunktion zu unterstützen.

Mit dieser Anwendung können Sie den Roboterarm wie folgt steuern, aufzeichnen und überwachen:

1. Bewegungssteuerung

Es gibt zwei Modi zur Steuerung dieses Roboterarms. Der erste ist manuell durch Ziehen der Schieberegler, die einen bestimmten Servo steuern:

• Greifer: Klicken Sie auf „Öffnen“ & „Schließen“, um den Roboter-Greifer zu öffnen und zu schließen.
• Basis: Ziehen Sie den Schieberegler nach rechts & links oder verwenden Sie die Pfeiltasten (rechts/links), um die Basis nach rechts und links zu bewegen.
• Schulter: Ziehen Sie den Schieberegler nach rechts & links oder verwenden Sie die Pfeiltasten (oben/unten), um die Schulter nach oben und unten zu bewegen.
• Ellbogen: Ziehen Sie den Schieberegler nach rechts & links oder verwenden Sie die Tasten (w/s), um den Ellbogen-Motor nach oben und unten zu bewegen.

2. Bewegungsaufzeichnung

Sobald Sie die Bewegung des Roboterarms automatisieren möchten, müssen Sie die Position in jedem Schritt durch Klicken auf den „Rec. Position“-Button oder Drücken von (R) auf der Tastatur aufzeichnen. Die Anwendung kümmert sich um den Rest.

In jedem Schritt erkennt die Anwendung die bewegte Motorposition und speichert sie separat in einer Liste.

Durch Klicken auf den Button „Start Auto Modus“ sendet die Anwendung die gespeicherten Positionen als Sequenz von Befehlen.

3. Überwachung

Ich habe eine grafische Oberfläche erstellt, die jeden Schritt in einem Diagramm darstellt, damit der Benutzer ungewöhnliche Änderungen bemerken kann. Gleichzeitig gibt es eine Datentabelle auf der rechten Seite, die den spezifischen Winkel und die genaue Zeit für jede Bewegung anzeigt.

Mit diesen Funktionen können Sie Ihre eigenen Bewegungen komponieren und als Aufgabe an den Roboterarm senden, genau wie in der Fertigungsautomatisierung.

Schritt 9: Updates

August 2018:

Kürzlich habe ich dasselbe Design nach einigen Modifikationen auf einer Laserschneidmaschine mit 3 mm MDF erstellt. Diese zusätzliche Idee war besonders cool, besonders als ich einen benutzerdefinierten Joystick hinzufügte.

Code

Task.ino Arduino

int delayT = 350;

void Home() // Diese Funktion aufrufen, wenn Arm in Home-Position gesetzt werden soll
{
  MyServo0.write(valGripper); // Greifer
  delay(15);
  MyServo.write(valBase); // Basis
  delay(30);
  MyServo2.write(valShoulder); // Schulter
  delay(30);
  MyServo3.write(valElbow); // Ellbogen
  delay(delayT);
}

void Pick() // Feste Pick-Position
{
  MyServo.write(4); // Basis
  delay(delayT);
  MyServo3.write(125); // Ellbogen
  MyServo2.write(95); // Schulter
  delay(delayT);
  MyServo0.write(50); // Greifer weit öffnen
  delay(delayT);
  MyServo0.write(2); // Greifer schließen
  delay(delayT);
  MyServo2.write(60); // Schulter etwas hoch
  MyServo3.write(80); // Ellbogen etwas hoch
  delay(delayT);
  Serial.println("Object Picked");
}

void Drop() // Feste Drop-Position
{
  MyServo.write(145); // Basis
  delay(delayT);
  MyServo2.write(80); // Schulter
  delay(15);
  MyServo3.write(115); // Ellbogen
  delay(delayT);
  MyServo0.write(40); // Greifer weit öffnen
  delay(delayT);
  MyServo3.write(90); // Ellbogen etwas hoch
  delay(delayT);
  Serial.println(F("Object Dropped"));
}

void Playback() {
  // https://arduino.stackexchange.com/questions/1013/how-do-i-split-an-incoming-string
  // Eingabe MUSS Array sein ( servoId : Position & servoId : Position & servoId : Position )
  // String phrase;
  // phrase = String(phrase + ByteReceived);
  // char-Eingabe in String konvertieren, der geteilt werden kann
  
  // Jedes Befehlspaar lesen
  char* command = strtok(ByteReceived, "&");
  while (command != 0) {
    // Befehl in zwei Werte aufteilen
    char* separator = strchr(command, ':');
    if (separator != 0) {
      // String tatsächlich in 2 teilen: ':' durch 0 ersetzen
      *separator = 0;
      int servoId = atoi(command);
      ++separator;
      int angle = atoi(separator);
      
      // Etwas mit servoId und angle machen
      if (servoId = 1) {
        MyServo.write(angle);
        delay(delayT);
      } else if (servoId = 2) {
        MyServo2.write(angle);
        delay(delayT);
      } else if (servoId = 3) {
        MyServo3.write(angle);
        delay(delayT);
      }
    }
    // Nächsten Befehl in Eingabe-String finden
    command = strtok(0, "&");
  }
}

RobotArm.ino Arduino

// Geschrieben von AhmedAzouz
#include 

Servo MyServo, MyServo2, MyServo3, MyServo0;
char ByteReceived;
int MyPosition, MyPosition2, MyPosition3, MyPositionG;
int runCounter = 0;
int ledPin = A5;

// Standard-Home-Servopositionen festlegen
int valGripper = 30;
int valBase = 70;
int valShoulder = 25;
int valElbow = 150;

void setup() {
  Serial.begin(9600);
  pinMode(ledPin, OUTPUT);
  digitalWrite(13, LOW);
  
  MyServo0.attach(12); // Greifer
  MyServo.attach(11);  // Basis
  MyServo2.attach(13); // Schulter
  MyServo3.attach(10); // Ellbogen
  
  // Startpositionen setzen
  MyServo0.write(valGripper); // Greifer
  delay(15);
  MyServo.write(valBase); // Basis
  delay(30);
  MyServo2.write(valShoulder); // Schulter
  delay(30);
  MyServo3.write(valElbow); // Ellbogen
  delay(300);
}

void loop() {
  Serial.print("Base : ");
  Serial.print(valBase);
  Serial.print("\t");
  Serial.print("Shou : ");
  Serial.print(valShoulder);
  Serial.print("\t");
  Serial.print("Elbow : ");
  Serial.print(valElbow);
  Serial.print("\t");
  Serial.print("Grip : ");
  Serial.println(valGripper);
  
  while (Serial.available() > 0) {
    ByteReceived = Serial.read();
    
    switch (ByteReceived) {
      // ************* LED
      case 'n':
        digitalWrite(ledPin, HIGH); // LED einschalten
        Serial.println("LED is on");
        break;
      case 'f':
        digitalWrite(ledPin, LOW); // LED ausschalten
        Serial.println("LED is off");
        break;
      
      // ************* Basis
      case 'l':
        MyPosition = MyServo.read() + 2; // L für Basis links
        MyServo.write(MyPosition);
        Serial.print("Base");
        Serial.print("\t");
        Serial.println(MyServo.read());
        delay(15);
        break;
      case 'r':
        MyPosition = MyServo.read() - 2; // R für Basis rechts
        MyServo.write(MyPosition);
        Serial.print("Base");
        Serial.print("\t");
        Serial.println(MyServo.read());
        delay(15);
        break;
      
      // ************* Ellbogen
      case 'u':
        MyPosition2 = MyServo2.read() + 2; // U für Ellbogen hoch
        MyServo2.write(MyPosition2);
        Serial.print("Elbow");
        Serial.print("\t");
        Serial.println(MyServo2.read());
        delay(15);
        break;
      case 'd':
        MyPosition2 = MyServo2.read() - 2; // D für Ellbogen runter
        MyServo2.write(MyPosition2);
        Serial.print("Elbow");
        Serial.print("\t");
        Serial.println(MyServo2.read());
        delay(15);
        break;
      
      // ************* Schulter
      case 'w':
        MyPosition3 = MyServo3.read() + 2; // W für Schulter runter
        MyServo3.write(MyPosition3);
        Serial.print("Shoulder");
        Serial.print("\t");
        Serial.println(MyServo3.read());
        delay(15);
        break;
      case 's':
        MyPosition3 = MyServo3.read() - 2; // S für Schulter hoch
        MyServo3.write(MyPosition3);
        Serial.print("Shoulder");
        Serial.print("\t");
        Serial.println(MyServo3.read());
        delay(15);
        break;
      
      // ************* Greifer
      case 'o':
        MyServo0.write(30); // O für Greifer öffnen
        Serial.print("Gripper Open");
        Serial.print("\t");
        Serial.println(MyServo0.read());
        delay(15);
        break;
      case 'c':
        MyServo0.write(1); // C für Greifer schließen
        Serial.print("Gripper Close");
        Serial.print("\t");
        Serial.println(MyServo0.read());
        delay(15);
        break;
      
      // ************* Standard Drop-Position (schnelle Drop-Position)
      case 'q':
        digitalWrite(ledPin, HIGH);
        Serial.println("Default Dropped activated!");
        Pick();
        Drop();
        Home();
        digitalWrite(ledPin, LOW);
        break;
      
      // ************* Notstopp und Home-Position
      case 'h':
        Home();
        digitalWrite(ledPin, LOW);
        break;
      
      // ************* Automatischer Modus führt Playback-Funktion aus
      // Serial-Eingabe muss in diesem Format sein: 1:90&2:80&3:180
      // Pickup-Position ist fest, diese Funktion automatisiert die Drop-Position.
      default:
        digitalWrite(ledPin, HIGH);
        Serial.println("Automatic mood activated!");
        Pick();
        Playback();
        Home();
        digitalWrite(ledPin, LOW);
        break;
    }
  }
}

Benutzerdefinierte Teile und Gehäuse

f98t2axin238k2n_khGWAEIqdl.skp

Schaltpläne