Automatischer Betrieb der Arduino-Roboterarm- und Mecanum-Räderplattform
In diesem Tutorial zeige ich Ihnen, wie ich meine Mecanum Wheels Robot Platform aus meinem vorherigen Video erstellt habe, um mit meinem 3D-gedruckten Roboterarm zusammenzuarbeiten und automatisch zu arbeiten, ebenfalls ein Arduino-Projekt aus einem meiner vorherigen Videos.
Sie können sich das folgende Video ansehen oder das schriftliche Tutorial unten lesen.
Wir können also den Mecanum-Räderroboter mit der speziell entwickelten Android-Anwendung auf die gleiche Weise steuern, wie im vorherigen Video erklärt. Darüber hinaus verfügt die App jetzt auch über Schaltflächen zur Steuerung des Roboterarms.
Die ursprüngliche Roboterarmsteuerungs-App hatte tatsächlich Schieberegler zum Steuern der Robotergelenke, aber das verursachte einige Probleme mit der Armstabilität. Auf diese Weise funktioniert der Arm viel besser, daher werde ich diese aktualisierte Version der Roboterarm-Steuerungs-App und den Arduino-Code auch für das ursprüngliche Roboterarm-Projekt bereitstellen.
Das coolste Feature dieses Roboters ist jedoch die Fähigkeit, die Bewegungen zu speichern und sie dann automatisch zu wiederholen.
Mit dem Speichern-Button können wir einfach die Positionen der Motoren für jeden Schritt speichern. Dann müssen wir nur noch auf die Schaltfläche Ausführen klicken und der Roboter wiederholt automatisch die gespeicherten Bewegungen immer und immer wieder.
Ok, hier habe ich also die Mecanum-Räderplattform bereits zusammengebaut und Sie können alle Details dazu in meinem vorherigen Video finden.
Außerdem habe ich hier die 3D-gedruckten Teile des Roboterarms und der Servomotoren und jetzt zeige ich Ihnen, wie man sie zusammenbaut. Hier ist das 3D-Modell dieses Projekts.
Sie können dieses 3D-Modell finden und herunterladen sowie es in Ihrem Browser auf Thangs erkunden.
Laden Sie das 3D-Modell bei Thangs herunter.
STL-Dateien für den 3D-Druck:
Das erste Servo des Roboterarms wird direkt auf der oberen Abdeckung der Mecanum-Räderplattform montiert.
Ich habe die Stelle markiert und mit einem 10-mm-Bohrer mehrere Löcher gebohrt.
Dann habe ich mit einer Raspel die Löcher durchgeschnitten und dann die Öffnung für das Servo fein abgestimmt. Ich befestigte das Servo an der oberen Platte mit vier M3-Schrauben und Muttern.
An dieser Ausgangswelle dieses Servos müssen wir dann mit dem als Zubehör mitgelieferten runden Horn das nächste Teil oder die Taille des Roboterarms befestigen. Wir können jedoch feststellen, dass das Teil auf diese Weise etwa 8 mm über der Platte bleibt. Deshalb habe ich zwei 8 mm MDF-Platten angebracht, damit das Taillenteil darauf gleiten kann und die Verbindung stabiler ist.
Das runde Horn wird mit den selbstschneidenden Schrauben, die als Zubehör mit dem Servo geliefert werden, am Taillenteil befestigt, und dann wird das runde Horn mit den entsprechenden Schrauben, die ebenfalls mit dem Servo geliefert werden, an der Servowelle befestigt.
Als nächstes haben wir das Schulterservo. Wir setzen es einfach ein und befestigen es mit selbstschneidenden Schrauben am 3D-gedruckten Teil.
Das runde Horn kommt auf das nächste Teil, und dann werden die beiden Teile mit einer Schraube an der Ausgangswelle des Servos miteinander verbunden.
Wir sollten beachten, dass wir vor dem Befestigen der Teile sicherstellen müssen, dass das Teil den vollen Bewegungsbereich hat. Hier habe ich auch noch ein Gummiband am Schultergelenk angebracht, damit es dem Servo etwas nachhilft, denn dieses Servo trägt das Gewicht des restlichen Arms sowie die Nutzlast.
Auf ähnliche Weise habe ich den Rest des Roboterarms zusammengebaut.
Als nächstes müssen wir den Greifermechanismus zusammenbauen. Der Greifer wird mit einem SG90-Servomotor gesteuert, an dem wir zuerst eine kundenspezifische Getriebeverbindung anbringen. Wir paaren dieses Glied mit einem anderen Getriebeglied auf der anderen Seite, das mit M4-Bolzen und Muttern befestigt wird. Tatsächlich werden alle anderen Glieder mit M4-Bolzen und Muttern verbunden.
Das 3D-Modell des Greifers hat ursprünglich 3-mm-Löcher, aber ich hatte nicht genug M3-Schrauben, also habe ich die Löcher mit einem 4-mm-Bohrer erweitert und stattdessen die M4-Schrauben verwendet.
Nachdem ich den Greifmechanismus zusammengebaut hatte, befestigte ich ihn am letzten Servo und so war der Roboterarm fertig.
Als nächstes habe ich etwas Kabelmanagement gemacht. Ich führte die Servodrähte durch die speziell entworfenen Löcher des Roboterarms. Mit einem 10-mm-Bohrer habe ich ein Loch in die obere Platte gebohrt, damit die Drähte hindurchgehen können.
Mit einem Kabelbinder habe ich alle Drähte zusammengehalten, und jetzt müssen sie nur noch mit dem Arduino-Board verbunden werden.
Hier ist der Schaltplan dieses Projekts und wie alles angeschlossen werden muss.
Die für dieses Projekt benötigten Komponenten erhalten Sie über die folgenden Links:
Im vorherigen Tutorial habe ich erklärt, wie das Mecanum-Räder-Roboterteil funktioniert, und Ihnen auch gezeigt, wie ich eine benutzerdefinierte Leiterplatte dafür erstellt habe.
Ich habe einen 5-V-Spannungsregler auf dieser Platine eingebaut, damit wir dieses Projekt durchführen oder die Servomotoren anschließen können, weil sie mit 5 V arbeiten. Der Spannungsregler ist der LM350, der bis zu 3 Ampere Strom verarbeiten kann. Alle sechs Servos des Roboterarms können etwa 2 Ampere bis 3 Ampere Strom ziehen, was bedeutet, dass er damit umgehen kann, aber das wird dazu führen, dass der Regler sehr heiß wird.
Daher habe ich einen Kühlkörper daran angebracht, sowie einen kleinen 12-V-DC-Lüfter, um etwas Luft zu blasen, da der Kühlkörper selbst nicht ausreichte, um den Regler zu kühlen.
Ich habe die Signalleitungen der Servos mit den digitalen Arduino-Pins von Nummer 5 bis 10 verbunden und zur Stromversorgung die 5-V-Stiftleiste auf der Platine verwendet. Schließlich schob ich alle Drähte in die Plattform und befestigte die obere Platte mit den beiden Muttern daran.
Und das war's, jetzt sind wir mit diesem Projekt fertig.
Was bleibt, ist, einen Blick darauf zu werfen, wie der Arduino-Code und die Android-Anwendung funktionieren. Da der Code etwas länger ist, werde ich zum besseren Verständnis den Quellcode des Programms in Abschnitten mit Beschreibung für jeden Abschnitt veröffentlichen. Und am Ende dieses Artikels werde ich den kompletten Quellcode posten.
Also müssen wir zuerst die 6 Servos, die 4 Schrittmotoren und die Bluetooth-Kommunikation definieren, sowie einige Variablen definieren, die für das Programm unten benötigt werden. Im Setup-Bereich stellen wir die maximale Geschwindigkeit der Stepper ein, definieren die Pins, an denen die Servos angeschlossen sind, starten die Bluetooth-Kommunikation und bringen den Roboterarm in die Ausgangsposition.
Dann beginnen wir im Schleifenabschnitt damit, zu prüfen, ob es irgendwelche eingehenden Daten gibt.
Diese Daten stammen vom Smartphone oder der Android-App, schauen wir uns also an, welche Art von Daten es tatsächlich sendet. Die Android-App wird mit der Online-Anwendung MIT App Inventor erstellt. Es besteht aus einfachen Schaltflächen mit entsprechenden Bildern als Hintergrund.
Wenn wir uns die Blöcke der App ansehen, können wir sehen, dass sie nur Ein-Byte-Zahlen sendet, wenn auf die Schaltflächen geklickt wird.
Je nach angeklickter Schaltfläche sagen wir dem Arduino also, was zu tun ist. Wenn wir beispielsweise die Zahl „2“ erhalten, bewegt sich die Plattform der Mecanum-Räder mithilfe der benutzerdefinierten Funktion „moveForward“ vorwärts.
Diese benutzerdefinierte Funktion stellt alle vier Schrittmotoren so ein, dass sie sich vorwärts drehen.
Um sich in eine andere Richtung zu bewegen, müssen wir nur die Räder in die entsprechende Richtung drehen.
Für die Steuerung des Roboterarms verwenden wir die gleiche Methode. Auch hier haben wir Schaltflächen in der App und beim Halten der Schaltflächen bewegen sich die Roboterarmgelenke in die jeweilige Richtung.
Wie ich bereits erwähnt habe, haben wir in der ursprünglichen Roboterarm-Steuerungs-App Schieberegler verwendet, um die Positionen der Servos zu steuern, aber das verursachte einige Probleme, weil wir auf diese Weise Text an den Arduino senden mussten, anstatt eine 1-Byte-Zahl. Das Problem ist, dass der Arduino manchmal den von der App kommenden Text verpasst und Fehler macht oder der Roboterarm zittert und sich abnormal verhält.
Auf diese Weise senden wir einfach eine einzelne 1-Byte-Zahl, wenn eine bestimmte Schaltfläche berührt wird.
Der Arduino-Code tritt in die While-Schleife dieser Zahl ein und bleibt dort, bis wir die Schaltfläche berühren, da wir in diesem Moment die Zahl 0 senden, was bedeutet, dass der Roboter nichts tun soll.
Abhängig von den berührten Tasten bewegen sich die Servos also entweder in positive oder negative Richtung. Für alle Servomotoren gilt das gleiche Arbeitsprinzip. Um die Bewegungsgeschwindigkeit zu ändern, verwenden wir die vom Schieberegler kommenden Werte, die von 100 bis 250 reichen.
Durch Teilen durch 10 erhalten wir Werte von 10 bis 25, die als Verzögerung in Mikrosekunden in den Whiles-Schleifen zum Ansteuern der Servos verwendet werden.
Zum Speichern der Roboterbewegungen speichern wir einfach die aktuellen Positionen der Servos und der Stepper in Arrays, jedes Mal, wenn auf die Schaltfläche Speichern geklickt wird.
Wenn wir dann auf die Schaltfläche „Ausführen“ klicken, rufen wir die benutzerdefinierte Funktion „runSteps()“ auf. Diese benutzerdefinierte Funktion durchläuft alle gespeicherten Schritte mit einigen For- und While-Schleifen.
Wir sollten beachten, dass es von der ersten Position beginnt und zur letzten Position geht und dies immer wieder wiederholt. Daher müssen wir beim Speichern der Schritte den Roboter tatsächlich so positionieren, dass der erste Schritt die gleiche Position wie der letzte Schritt hat. Während wir die Schritte durchlaufen, können wir auch die Geschwindigkeit sowohl der Plattform als auch des Roboterarms ändern sowie alle Schritte anhalten und zurücksetzen.
Hier können Sie diese App sowie die editierbare Projektdatei herunterladen:
Hier ist der vollständige Arduino-Code für dieses Arduino-Roboterprojekt:
Das ist also so ziemlich alles für dieses Tutorial. Das Projekt funktioniert gut, aber bitte beachten Sie, dass es alles andere als perfekt ist. Die automatischen Bewegungen sind aufgrund des Durchrutschens der Mecanum-Räder sowie der schlechten Leistung der Servomotoren möglicherweise nicht so präzise. Diese billigen Servomotoren können auch zittern oder zittern, selbst wenn sie sich nicht bewegen, nur weil sie nicht genug Kraft haben, um das Gewicht der 3D-gedruckten Teile zu halten.
Ich hoffe, Ihnen hat dieses Tutorial gefallen und Sie haben etwas Neues gelernt. Fühlen Sie sich frei, Fragen im Kommentarbereich unten zu stellen und sehen Sie sich meine Arduino-Projektsammlung an.Übersicht
Den Arduino-Roboter bauen
Arduino-Roboter-Schaltplan
Arduino-Code
#include <SoftwareSerial.h>
#include <AccelStepper.h>
#include <Servo.h>
Servo servo01;
Servo servo02;
Servo servo03;
Servo servo04;
Servo servo05;
Servo servo06;
SoftwareSerial Bluetooth(A8, 38); // Arduino(RX, TX) - HC-05 Bluetooth (TX, RX)
// Define the stepper motors and the pins the will use
AccelStepper LeftBackWheel(1, 42, 43); // (Type:driver, STEP, DIR) - Stepper1
AccelStepper LeftFrontWheel(1, 40, 41); // Stepper2
AccelStepper RightBackWheel(1, 44, 45); // Stepper3
AccelStepper RightFrontWheel(1, 46, 47); // Stepper4
#define led 14
int wheelSpeed = 1500;
int lbw[50], lfw[50], rbw[50], rfw[50]; // arrays for storing positions/steps
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;
int dataIn;
int m = 0;
void setup() {
// Set initial seed values for the steppers
LeftFrontWheel.setMaxSpeed(3000);
LeftBackWheel.setMaxSpeed(3000);
RightFrontWheel.setMaxSpeed(3000);
RightBackWheel.setMaxSpeed(3000);
pinMode(led, OUTPUT);
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(5);
delay(20);
Serial.begin(38400);
// Move robot arm to initial position
servo1PPos = 90;
servo01.write(servo1PPos);
servo2PPos = 100;
servo02.write(servo2PPos);
servo3PPos = 120;
servo03.write(servo3PPos);
servo4PPos = 95;
servo04.write(servo4PPos);
servo5PPos = 60;
servo05.write(servo5PPos);
servo6PPos = 110;
servo06.write(servo6PPos);
} Codesprache:Arduino (arduino) // Check for incoming data
if (Bluetooth.available() > 0) {
dataIn = Bluetooth.read(); // Read the data Codesprache:Arduino (arduino) 
if (dataIn == 2) {
m = 2;
}
//
if (m == 2) {
moveForward();
} Codesprache:Arduino (arduino) void moveForward() {
LeftFrontWheel.setSpeed(wheelSpeed);
LeftBackWheel.setSpeed(wheelSpeed);
RightFrontWheel.setSpeed(wheelSpeed);
RightBackWheel.setSpeed(wheelSpeed);
} Codesprache:Arduino (arduino) 
// Move servo 1 in positive direction
while (m == 16) {
if (Bluetooth.available() > 0) {
m = Bluetooth.read();
}
servo01.write(servo1PPos);
servo1PPos++;
delay(speedDelay);
}
// Move servo 1 in negative direction
while (m == 17) {
if (Bluetooth.available() > 0) {
m = Bluetooth.read();
}
servo01.write(servo1PPos);
servo1PPos--;
delay(speedDelay);
} Codesprache:Arduino (arduino) // If arm speed slider is changed
if (dataIn > 101 & dataIn < 250) {
speedDelay = dataIn / 10; // Change servo speed (delay time)
} Codesprache:Arduino (arduino) // If button "SAVE" is pressed
if (m == 12) {
//if it's initial save, set the steppers position to 0
if (index == 0) {
LeftBackWheel.setCurrentPosition(0);
LeftFrontWheel.setCurrentPosition(0);
RightBackWheel.setCurrentPosition(0);
RightFrontWheel.setCurrentPosition(0);
}
lbw[index] = LeftBackWheel.currentPosition(); // save position into the array
lfw[index] = LeftFrontWheel.currentPosition();
rbw[index] = RightBackWheel.currentPosition();
rfw[index] = RightFrontWheel.currentPosition();
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
m = 0;
} Codesprache:Arduino (arduino) if (m == 14) {
runSteps();
// If button "RESET" is pressed
if (dataIn != 14) {
stopMoving();
memset(lbw, 0, sizeof(lbw)); // Clear the array data to 0
memset(lfw, 0, sizeof(lfw));
memset(rbw, 0, sizeof(rbw));
memset(rfw, 0, sizeof(rfw));
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
}
} Codesprache:Arduino (arduino) /*
Arduino Robot Arm and Mecanum Wheels Robot
Smartphone Control via Bluetooth
by Dejan, www.HowToMechatronics.com
*/
#include <SoftwareSerial.h>
#include <AccelStepper.h>
#include <Servo.h>
Servo servo01;
Servo servo02;
Servo servo03;
Servo servo04;
Servo servo05;
Servo servo06;
SoftwareSerial Bluetooth(A8, 38); // Arduino(RX, TX) - HC-05 Bluetooth (TX, RX)
// Define the stepper motors and the pins the will use
AccelStepper LeftBackWheel(1, 42, 43); // (Type:driver, STEP, DIR) - Stepper1
AccelStepper LeftFrontWheel(1, 40, 41); // Stepper2
AccelStepper RightBackWheel(1, 44, 45); // Stepper3
AccelStepper RightFrontWheel(1, 46, 47); // Stepper4
#define led 14
int wheelSpeed = 1500;
int lbw[50], lfw[50], rbw[50], rfw[50]; // arrays for storing positions/steps
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;
int dataIn;
int m = 0;
void setup() {
// Set initial seed values for the steppers
LeftFrontWheel.setMaxSpeed(3000);
LeftBackWheel.setMaxSpeed(3000);
RightFrontWheel.setMaxSpeed(3000);
RightBackWheel.setMaxSpeed(3000);
pinMode(led, OUTPUT);
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(5);
delay(20);
Serial.begin(38400);
// Move robot arm to initial position
servo1PPos = 90;
servo01.write(servo1PPos);
servo2PPos = 100;
servo02.write(servo2PPos);
servo3PPos = 120;
servo03.write(servo3PPos);
servo4PPos = 95;
servo04.write(servo4PPos);
servo5PPos = 60;
servo05.write(servo5PPos);
servo6PPos = 110;
servo06.write(servo6PPos);
}
void loop() {
// Check for incoming data
if (Bluetooth.available() > 0) {
dataIn = Bluetooth.read(); // Read the data
if (dataIn == 0) {
m = 0;
}
if (dataIn == 1) {
m = 1;
}
if (dataIn == 2) {
m = 2;
}
if (dataIn == 3) {
m = 3;
}
if (dataIn == 4) {
m = 4;
}
if (dataIn == 5) {
m = 5;
}
if (dataIn == 6) {
m = 6;
}
if (dataIn == 7) {
m = 7;
}
if (dataIn == 8) {
m = 8;
}
if (dataIn == 9) {
m = 9;
}
if (dataIn == 10) {
m = 10;
}
if (dataIn == 11) {
m = 11;
}
if (dataIn == 12) {
m = 12;
}
if (dataIn == 14) {
m = 14;
}
if (dataIn == 16) {
m = 16;
}
if (dataIn == 17) {
m = 17;
}
if (dataIn == 18) {
m = 18;
}
if (dataIn == 19) {
m = 19;
}
if (dataIn == 20) {
m = 20;
}
if (dataIn == 21) {
m = 21;
}
if (dataIn == 22) {
m = 22;
}
if (dataIn == 23) {
m = 23;
}
if (dataIn == 24) {
m = 24;
}
if (dataIn == 25) {
m = 25;
}
if (dataIn == 26) {
m = 26;
}
if (dataIn == 27) {
m = 27;
}
// Move the Mecanum wheels platform
if (m == 4) {
moveSidewaysLeft();
}
if (m == 5) {
moveSidewaysRight();
}
if (m == 2) {
moveForward();
}
if (m == 7) {
moveBackward();
}
if (m == 3) {
moveRightForward();
}
if (m == 1) {
moveLeftForward();
}
if (m == 8) {
moveRightBackward();
}
if (m == 6) {
moveLeftBackward();
}
if (m == 9) {
rotateLeft();
}
if (m == 10) {
rotateRight();
}
if (m == 0) {
stopMoving();
}
// Mecanum wheels speed
if (dataIn > 30 & dataIn < 100) {
wheelSpeed = dataIn * 20;
}
// Move robot arm
// Move servo 1 in positive direction
while (m == 16) {
if (Bluetooth.available() > 0) {
m = Bluetooth.read();
}
servo01.write(servo1PPos);
servo1PPos++;
delay(speedDelay);
}
// Move servo 1 in negative direction
while (m == 17) {
if (Bluetooth.available() > 0) {
m = Bluetooth.read();
}
servo01.write(servo1PPos);
servo1PPos--;
delay(speedDelay);
}
// Move servo 2
while (m == 19) {
if (Bluetooth.available() > 0) {
m = Bluetooth.read();
}
servo02.write(servo2PPos);
servo2PPos++;
delay(speedDelay);
}
while (m == 18) {
if (Bluetooth.available() > 0) {
m = Bluetooth.read();
}
servo02.write(servo2PPos);
servo2PPos--;
delay(speedDelay);
}
// Move servo 3
while (m == 20) {
if (Bluetooth.available() > 0) {
m = Bluetooth.read();
}
servo03.write(servo3PPos);
servo3PPos++;
delay(speedDelay);
}
while (m == 21) {
if (Bluetooth.available() > 0) {
m = Bluetooth.read();
}
servo03.write(servo3PPos);
servo3PPos--;
delay(speedDelay);
}
// Move servo 4
while (m == 23) {
if (Bluetooth.available() > 0) {
m = Bluetooth.read();
}
servo04.write(servo4PPos);
servo4PPos++;
delay(speedDelay);
}
while (m == 22) {
if (Bluetooth.available() > 0) {
m = Bluetooth.read();
}
servo04.write(servo4PPos);
servo4PPos--;
delay(speedDelay);
}
// Move servo 5
while (m == 25) {
if (Bluetooth.available() > 0) {
m = Bluetooth.read();
}
servo05.write(servo5PPos);
servo5PPos++;
delay(speedDelay);
}
while (m == 24) {
if (Bluetooth.available() > 0) {
m = Bluetooth.read();
}
servo05.write(servo5PPos);
servo5PPos--;
delay(speedDelay);
}
// Move servo 6
while (m == 26) {
if (Bluetooth.available() > 0) {
m = Bluetooth.read();
}
servo06.write(servo6PPos);
servo6PPos++;
delay(speedDelay);
}
while (m == 27) {
if (Bluetooth.available() > 0) {
m = Bluetooth.read();
}
servo06.write(servo6PPos);
servo6PPos--;
delay(speedDelay);
}
// If arm speed slider is changed
if (dataIn > 101 & dataIn < 250) {
speedDelay = dataIn / 10; // Change servo speed (delay time)
}
// If button "SAVE" is pressed
if (m == 12) {
//if it's initial save, set the steppers position to 0
if (index == 0) {
LeftBackWheel.setCurrentPosition(0);
LeftFrontWheel.setCurrentPosition(0);
RightBackWheel.setCurrentPosition(0);
RightFrontWheel.setCurrentPosition(0);
}
lbw[index] = LeftBackWheel.currentPosition(); // save position into the array
lfw[index] = LeftFrontWheel.currentPosition();
rbw[index] = RightBackWheel.currentPosition();
rfw[index] = RightFrontWheel.currentPosition();
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
m = 0;
}
// If button "RUN" is pressed
if (m == 14) {
runSteps();
// If button "RESET" is pressed
if (dataIn != 14) {
stopMoving();
memset(lbw, 0, sizeof(lbw)); // Clear the array data to 0
memset(lfw, 0, sizeof(lfw));
memset(rbw, 0, sizeof(rbw));
memset(rfw, 0, sizeof(rfw));
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
}
}
}
LeftFrontWheel.runSpeed();
LeftBackWheel.runSpeed();
RightFrontWheel.runSpeed();
RightBackWheel.runSpeed();
// Monitor the battery voltage
int sensorValue = analogRead(A0);
float voltage = sensorValue * (5.0 / 1023.00) * 3; // Convert the reading values from 5v to suitable 12V i
//Serial.println(voltage);
// If voltage is below 11V turn on the LED
if (voltage < 11) {
digitalWrite(led, HIGH);
}
else {
digitalWrite(led, LOW);
}
}
void moveForward() {
LeftFrontWheel.setSpeed(wheelSpeed);
LeftBackWheel.setSpeed(wheelSpeed);
RightFrontWheel.setSpeed(wheelSpeed);
RightBackWheel.setSpeed(wheelSpeed);
}
void moveBackward() {
LeftFrontWheel.setSpeed(-wheelSpeed);
LeftBackWheel.setSpeed(-wheelSpeed);
RightFrontWheel.setSpeed(-wheelSpeed);
RightBackWheel.setSpeed(-wheelSpeed);
}
void moveSidewaysRight() {
LeftFrontWheel.setSpeed(wheelSpeed);
LeftBackWheel.setSpeed(-wheelSpeed);
RightFrontWheel.setSpeed(-wheelSpeed);
RightBackWheel.setSpeed(wheelSpeed);
}
void moveSidewaysLeft() {
LeftFrontWheel.setSpeed(-wheelSpeed);
LeftBackWheel.setSpeed(wheelSpeed);
RightFrontWheel.setSpeed(wheelSpeed);
RightBackWheel.setSpeed(-wheelSpeed);
}
void rotateLeft() {
LeftFrontWheel.setSpeed(-wheelSpeed);
LeftBackWheel.setSpeed(-wheelSpeed);
RightFrontWheel.setSpeed(wheelSpeed);
RightBackWheel.setSpeed(wheelSpeed);
}
void rotateRight() {
LeftFrontWheel.setSpeed(wheelSpeed);
LeftBackWheel.setSpeed(wheelSpeed);
RightFrontWheel.setSpeed(-wheelSpeed);
RightBackWheel.setSpeed(-wheelSpeed);
}
void moveRightForward() {
LeftFrontWheel.setSpeed(wheelSpeed);
LeftBackWheel.setSpeed(0);
RightFrontWheel.setSpeed(0);
RightBackWheel.setSpeed(wheelSpeed);
}
void moveRightBackward() {
LeftFrontWheel.setSpeed(0);
LeftBackWheel.setSpeed(-wheelSpeed);
RightFrontWheel.setSpeed(-wheelSpeed);
RightBackWheel.setSpeed(0);
}
void moveLeftForward() {
LeftFrontWheel.setSpeed(0);
LeftBackWheel.setSpeed(wheelSpeed);
RightFrontWheel.setSpeed(wheelSpeed);
RightBackWheel.setSpeed(0);
}
void moveLeftBackward() {
LeftFrontWheel.setSpeed(-wheelSpeed);
LeftBackWheel.setSpeed(0);
RightFrontWheel.setSpeed(0);
RightBackWheel.setSpeed(-wheelSpeed);
}
void stopMoving() {
LeftFrontWheel.setSpeed(0);
LeftBackWheel.setSpeed(0);
RightFrontWheel.setSpeed(0);
RightBackWheel.setSpeed(0);
}
// Automatic mode custom function - run the saved steps
void runSteps() {
while (dataIn != 13) { // 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.read();
if ( dataIn == 15) { // If button "PAUSE" is pressed
while (dataIn != 14) { // Wait until "RUN" is pressed again
if (Bluetooth.available() > 0) {
dataIn = Bluetooth.read();
if ( dataIn == 13) {
break;
}
}
}
}
// If speed slider is changed
if (dataIn > 100 & dataIn < 150) {
speedDelay = dataIn / 10; // Change servo speed (delay time)
}
// Mecanum wheels speed
if (dataIn > 30 & dataIn < 100) {
wheelSpeed = dataIn * 10;
dataIn = 14;
}
}
LeftFrontWheel.moveTo(lfw[i]);
LeftFrontWheel.setSpeed(wheelSpeed);
LeftBackWheel.moveTo(lbw[i]);
LeftBackWheel.setSpeed(wheelSpeed);
RightFrontWheel.moveTo(rfw[i]);
RightFrontWheel.setSpeed(wheelSpeed);
RightBackWheel.moveTo(rbw[i]);
RightBackWheel.setSpeed(wheelSpeed);
while (LeftBackWheel.currentPosition() != lbw[i] & LeftFrontWheel.currentPosition() != lfw[i] & RightFrontWheel.currentPosition() != rfw[i] & RightBackWheel.currentPosition() != rbw[i]) {
LeftFrontWheel.runSpeedToPosition();
LeftBackWheel.runSpeedToPosition();
RightFrontWheel.runSpeedToPosition();
RightBackWheel.runSpeedToPosition();
}
// 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);
}
}
}
}
} Codesprache:Arduino (arduino)
Herstellungsprozess
- Bauen Sie Ihren internetgesteuerten Videostreaming-Roboter mit Arduino und Raspberry Pi
- Einfacher Pi-Roboter
- Hindernisse vermeiden Roboter mit Servomotor
- Steuerung eines Roomba-Roboters mit Arduino und Android-Gerät
- Steuerung des Servomotors mit Arduino und MPU6050
- Einfacher und intelligenter Roboterarm mit Arduino
- Littlearm 2C:Erstellen Sie einen 3D-gedruckten Arduino-Roboterarm
- DIY Arduino Roboterarm – gesteuert durch Handgesten
- Lokaler und remote programmierbarer Roboterarm
- Robot kombiniert einen kollaborativen Roboterarm mit einer mobilen Plattform