Der Aufbau einer Roboter, der Mauszeiger folgt

  importieren processing.serial. *;

 // Die Daten, die las war geschickt, um arduino:
 int _LastSent_MouseX;
 int _LastSent_MouseY;
 int _LastSent_PenUp;

 // Die aktuellen Werte der Mausposition und Stift nach oben / unten Staat:
 int _Current_MouseX;
 int _Current_MouseY;
 boolean _Current_PenUp;

 // Eigenschaften des Zeichnungsfensters:
 int _WindowWidth;
 int _WindowHeight;

 // Port für die Kommunikation mit arduino
 Serien _SerialPort;

 ////////////////////////////////////////////////// ////
 // Einrichten der Verarbeitung Leinwand
 Leere setup () {
   _WindowWidth = 1600;
   _WindowHeight = 800;
   Größe (_WindowWidth, _WindowHeight);
   strokeWeight (8);

   // Zur Kommunikation mit dem Arduino Öffnen Sie die serielle Schnittstelle
   // Sicherstellen, dass die COM-Schnittstelle ist die gleiche wie die von Arduino verwendet (Extras> Serial Port-Menü)
   _SerialPort = New Serien (this, "COM7", 9600);
   _SerialPort.bufferUntil ('\ N');
 }

 ////////////////////////////////////////////////// ////
 // Auf dem Computerbildschirm Zeichnen Sie das Fenster
 Leere draw () {
   // Canvas grau Füllen
   Hintergrund (100);  
   // Stellen Sie die Strichfarbe auf weiß
   Hub (255);
   // Zeichne einen Kreis an der Mausposition
   Ellipse (_Current_MouseX, _Current_MouseY, 8, 8);
 }

 ////////////////////////////////////////////////// ////
 // Aktualisiert die meisten aktuellen Stand der Mausposition und sendet diese Informationen an arduino
 Leere mouse () {  
   _Current_MouseX = MouseX;
   _Current_MouseY = MouseY;
   SendToArduino ();
 }
 // Aktualisiert die meisten aktuellen Stand der Feder nach oben / unten Zustand und sendet diese Informationen an arduino
 Leere mouse () {
   _Current_PenUp = _Current_PenUp!;
   SendToArduino ();
 }

 ////////////////////////////////////////////////// ////
 Leere SendToArduino () {
   // Es ist leistungsfähiger, um einfache ints über die serielle Schnittstelle an das Arduino-Board senden
   // Ist es jedoch schwierig, zu gewährleisten, dass die Daten in der richtigen Reihenfolge auf der Seite empfangen arduino
   // Um ​​zu vermeiden, falsch interpretiert gesendeten Daten über den seriellen Anschluss, verwenden wir die folgende Konvention:
   // Position X wird als als int-Wert von 0..127 gesendet werden
   // Y Position wird als int Wert 127..255 gesendet werden
   // Auf / Ab-Zustand wird als int-Wert von 100 oder 200 gesendet werden
   int new_MouseX = round (map (_Current_MouseX, 0, _WindowWidth, 0, 127));
   int new_MouseY = round (map (_Current_MouseY, 0, _WindowHeight, 255., 127.));
   int new_PenUp = _Current_PenUp?  100: 200;  //

   // Wir sind nur gehen, um die Daten an die Arduino zu senden, wenn einer der Werte geändert
   if (new_MouseX! = _ LastSent_MouseX || new_MouseY! = _ LastSent_MouseY || new_PenUp! = _ LastSent_PenUp) {
     _LastSent_MouseX = New_MouseX;
     _LastSent_MouseY = New_MouseY;
     _LastSent_PenUp = New_PenUp;

     _SerialPort.write ((Byte) new_MouseX);
     _SerialPort.write ((Byte) new_MouseY);
     _SerialPort.write ((Byte) new_PenUp);
   }
 }

 ////////////////////////////////////////////////// ////
 // Das ist nützlich, um die Nachrichten aus dem Arduino-Board über die serielle Schnittstelle gesendet angezeigt
 // Für Debug-Zwecke
 Leere serialEvent (Serial myport)
 {
   String myString = myPort.readStringUntil ('\ n');
   println (MyString);
 }

  #include <Servo.h>
 // Um ​​Debug-Ausgaben zu aktivieren, kommentieren Sie die folgende Zeile ein:
 // #define DEBUG

 Servo servoLeft;
 Servo servoRight;
 Servo servoUp;
 const float pi = 3.14159;
 schweben RadianToDegree = 180 / pi;
 schweben DegreeToRadian = pi / 180;

 // Die Länge des Armabschnitts (Abmessungen sind so skaliert, dass Armsegment Länge gleich 1 ist)
 const float a = 1 .;
 // Der Versatz zwischen den beiden Servoachsen:
 const float d = 5,7 / 14,7;
 // Um ​​eingehende Bytes Werte schweben zu konvertieren:
 const float ByteToFloat = 1,0 / 255,0;
 // Sicherheitsmargen zu vermeiden Verlassen des sicheren Streckzone:
 // Beachten Sie, dass die Zeichenfläche hat hier die gleiche x / y-Verhältnis als bei der Verarbeitung Skizze
 const float thetaMax = acos (d / 2 - 1.);
 const float YMin = sin (thetaMax) + d;
 const float XAmplitude = 2,2;
 const float YAmplitude = 1,1;
 const float XMin = -0.5 * (XAmplitude-d);
 const float XMax = d-XMin;
 const float YMax = YMin + YAmplitude;
 // Stiftposition (Abmessungen sind so skaliert, dass Arm Segmentlänge gleich 1 ist)
 float x = 0 .;
 float y = 1,2;

 // Für Kommunikation über serielle Schnittstelle:
 int MyDelay = 10;
 int incomingByteX = 0;
 int incomingByteY = 0;
 int incomingByteU = 0;

 // Servopositionen und serielle Schnittstelle initialisieren
 Leere setup ()
 {
   Serial.begin (9600);
   servoLeft.attach (9);
   servoRight.attach (10);
   servoUp.attach (6);
   servoLeft.writeMicroseconds (1940);
   servoRight.writeMicroseconds (1095);
   servoUp.writeMicroseconds (1100);
 }

 // Die folgende Methode liest die serielle Eingänge, 
 // Konvertiert eingehende Daten an Stift Positionen
 // Wandelt pen Positionen zu Servomotor Winkel
 // Sendet Winkelwerte zu Servomotoren
 Leere Schleife ()
 {
   // Warten, bis 3 Bytes
   if (Serial.available ()> = 3);  
   {
     incomingByteX = Serial.read ();
     incomingByteY = Serial.read ();
     incomingByteU = Serial.read ();
    // Überprüfen, ob eingehende Daten im Einklang mit den convetions wir bei der Verarbeitung Skizze eingestellt
    // Dies vermeidet falsch interpretiert Daten, die ungeordnete kommt
     if ((incomingByteU == 100 || incomingByteU == 200) 
     && IncomingByteX> = 0 && incomingByteX <= 127 
     && IncomingByteY> = 127 && incomingByteY <= 255)
     {
       #ifdef DEBUG
       Serial.print ("SERIAL X:"); Serial.print (incomingByteX);
       Serial.print ("|| SERIAL Y:"); Serial.print (incomingByteY);
       Serial.print ("|| SERIAL U:"); Serial.print (incomingByteU); Serial.println ();
       #endif
  
       x = incomingByteX * ByteToFloat * 2 * (XMax-XMin) + XMin;
       y = (incomingByteY * ByteToFloat - 0,5) * 2 * (YMax-YMin) + YMin;
     
       // Convert (x, y) Werte zu Servomotor Winkel
       schweben ThetaLeft = GetThetaLeft (x, y);
       schweben ThetaRight = GetThetaRight (x, y);
      
       // Senden die Positionen der Servomotoren
       SetServoLeftToTheta (ThetaLeft);
       SetServoRightToTheta (ThetaRight);
       ServoUp (incomingByteU == 100);
     }
   }
     Verzögerung (MyDelay);
 }

 // Die folgenden Methoden zu konvertieren (x, y) Positionen zu Servomotor Winkel
 schweben GetThetaLeft (float x, float y) {
   float R = hypot (x, y);
   schweben Theta = atan2 (y, x);
   schweben phi = acos (R / 2.);
   schweben Out = RadianToDegree * (Theta + Phi);
   zurück Out;
 }
 schweben GetThetaRight (float x, float y) {
   x = (xd);
   float R = hypot (x, y);
   schweben Theta = atan2 (y, x);
   schweben phi = acos (R / 2.);
   schweben Out = RadianToDegree * (Theta - Phi);
   zurück Out;
 }
 // Die folgenden Verfahren eingestellt Winkelpositionen auf den beiden Arm-Servomotoren
 schweben SetServoLeftToTheta (float ThetaLeft) {
   // Kalibrierung für links Servo Hitech-5645MG
   // Theta | US
   // ---------------------------
   // 2200
   // 90 1940
   // 180 1020
   // 750
   schweben mS = 1940 + (ThetaLeft-90.) * (1020.-1940.) / 90 .;
   servoLeft.writeMicroseconds (round (MS));
 }
 schweben SetServoRightToTheta (float ThetaRight) {
   // Kalibrierung für links Servo Hitech-5645MG
   // Theta | US
   // ---------------------------
   // 2200
   // 0 1995
   // 90 1095
   // 750
   schweben mS = 1995 + (ThetaRight) * (1095.-1995.) / 90 .;
   servoRight.writeMicroseconds (round (MS));
 }
 // Die folgende Methode bringt die Hebeservo auf Stift-oben oder Stift-abwärts-Position
 Leere ServoUp (boolean stifthoch) {
   if (stifthoch) {servoUp.writeMicroseconds (1000);  }
   else {servoUp.writeMicroseconds (1200);  }
 }

Schließen Sie das Arduino an den PC mit einem USB-Kabel. Kompilieren Sie das Arduino Sketch und laden Sie sie auf die Arduino-Board, mit dem Arduino IDE Kompilierung und laden Sie Schaltflächen. Prüfen Sie, welche COM-Port Arduino wird mit unter dem Tools> Serieller Port-Menü der Arduino IDE. Überprüfen Sie, ob das Verarbeitungsprogramm mit dem gleichen seriellen Schnittstelle ist die entsprechende Zeile im Setup () -Methode. Kompilieren Sie das Verarbeitungsprogramm. Untergrund achten ountput des Arduino-Board ist mit dem Masseausgang Ihres DC-Netzteil, wenn Sie mit einem verbunden sind. Un-verbinden die Unterarm Extremitäten und Stift-raising-Systemkabel, bevor Sie das Servos unangemessene und unerwartete Bewegungen zu vermeiden. Überprüfen Sie die Armsegmente drehen leicht an ihren Gelenken. Überprüfen Sie die ruhenden Beine traf die Schreibfläche zur gleichen Zeit wie der Kugelschreiber Punkt, um den Kugelschreiber Punkt dauert zu großen Hits, wenn der Stift abgesenkt zu vermeiden. Überprüfen Sie die Armsegmente passieren leicht über die Klemmnaben Halten der Ruhe Beine (wenn nicht können Sie die Arme ein wenig, indem Sie einen flachen Metallring zwischen dem Arm und dem Servo-Hub zu erhöhen). Überprüfen Sie die Servo-Drähten oder anderen elektrischen Leitungen nicht riskieren, durch die Bewegung der Arme gerissen. Macht, zu testen und zu kalibrieren die Servopositionen einzeln, so dass die Winkel von den Servos genommen sind genau die, die zu erwarten (siehe Diagramm in Mathematik Abschnitt). Dies kann entweder durch die Programmierung Digital-Servos mit getan werden dieser Art von Gerät, oder durch Anpassungen in der Arduino-Code. Die entsprechenden Verfahren sind SetServoLeftToTheta und SetServoRightToTheta. Starten Sie die Verarbeitungsprogramm von der Verarbeitung IDE. Der Roboter sollte nun die Bewegung des Mauszeigers folgen auf dem Verarbeitungsfenster auf Ihrem Computerbildschirm.