Naadloze Besturing van Arduino Robotarm met Mecanum Wielplatform
In deze tutorial laat ik zien hoe ik mijn Mecanum Wiel Robotplatform uit mijn vorige video heb laten samenwerken en automatisch opereren met mijn 3D-geprinte Robotarm, ook een Arduino-project uit een eerdere video.
Je kunt de volgende video bekijken of de geschreven tutorial hieronder lezen.
Overzicht
We kunnen het Mecanum wielrobot besturen met de custom-gebouwde Android-applicatie op dezelfde manier als uitgelegd in de vorige video. Daartoe heeft de app nu ook knoppen voor het besturen van de robotarm.
De originele robotarm-besturingsapp had schuifregelaars voor het besturen van de robotgewrichten, maar dat veroorzaakte problemen met de stabiliteit van de arm. Op deze manier werkt de arm veel beter, dus ik zal deze bijgewerkte versie van de robotarm-besturingsapp en de Arduino-code ook beschikbaar stellen voor het originele robotarm-project.
Desondanks is de coolste functie van deze robot de mogelijkheid om bewegingen op te slaan en ze daarna automatisch te herhalen.
Met de Opslaan-knop kunnen we simpelweg de posities van de motoren voor elke stap opslaan. Daarna hoeven we alleen op de Start-knop te klikken en de robot zal de opgeslagen bewegingen steeds weer automatisch herhalen.
De Arduino Robot Bouwen
Ok, hier heb ik het Mecanum wielplatform al gemonteerd en alle details vind je in mijn vorige video.
Ook heb ik hier de 3D-geprinte onderdelen van de robotarm en de servo-motoren en nu laat ik je zien hoe je ze montert. Hier is het 3D-model van dit project.
Je kunt dit 3D-model vinden en downloaden, en in je browser verkennen op Thangs.
Download het 3D-model op Thangs.
STL-bestanden voor 3D-printen:
De eerste servo van de robotarm wordt direct op de bovenste deksel van het mecanum wielplatform gemonteerd.
Ik markeerde de locatie, en met een 10mm boor maakte ik verschillende gaten.
Vervolgens zaagde ik met een rasp door de gaten en werkte de opening voor de servo bij. Ik bevestigde de servo aan de bovenplaat met vier M3-bouten en moeren.
Dan op de uitvoeras van deze servo, met de ronde hoorn die als accessoire bij de servo komt, moeten we het volgende deel of de taille van de robotarm bevestigen. We kunnen echter zien dat het deel op deze manier ongeveer 8mm boven de plaat blijft. Daarom bevestigde ik twee stukjes 8mm MDF-plaat, zodat het tailledeel erover kan glijden en het gewricht stabieler wordt.
De ronde hoorn wordt met de zelfsnijdende schroeven die als accessoires bij de servo komen aan het tailledeel bevestigd, en daarna wordt de ronde hoorn met de bijpassende bouten die ook bij de servo horen aan de servo-as bevestigd.
Vervolgens hebben we de schouderservo. We plaatsen hem op zijn plek en bevestigen hem aan het 3D-geprinte deel met zelfsnijdende schroeven.
De ronde hoorn gaat op het volgende deel, en de twee delen worden met een bout op de uitvoeras van de servo aan elkaar bevestigd.
We moeten opmerken dat voordat we de delen bevestigen, we moeten controleren of het deel het volledige bewegingsbereik heeft. Hier voegde ik ook een rubberband toe aan het schoudergewricht zodat het de servo een beetje helpt, want deze servo draagt het gewicht van de rest van de arm en de nuttige last.
Op dezelfde manier monteerde ik de rest van de robotarm.
Vervolgens moeten we het grijpermechanisme monteren. De grijper wordt bestuurd met een SG90 servo-motor, aan welke we eerst een custom ontworpen getande link bevestigen. We koppelen deze link met een andere getande link aan de andere kant, die bevestigd wordt met een M4-bout en moer. Eigenlijk zijn alle andere links verbonden met M4-bouten en moeren.
Het 3D-model van de grijper heeft oorspronkelijk 3mm gaten, maar ik had niet genoeg M3-bouten, dus ik boorde de gaten uit met een 4mm boor en gebruikte M4-bouten in plaats daarvan.
Zodra ik het grijpermechanisme gemonteerd had, bevestigde ik het aan de laatste servo en de robotarm was voltooid.
Vervolgens deed ik wat kabelbeheer. Ik leidde de servo-draden door de specifiek ontworpen gaten van de robotarm. Met een 10mm boor maakte ik een gat in de bovenplaat zodat de draden erdoorheen kunnen.
Met een kabelbinder bevestigde ik alle draden samen, en wat overblijft is ze aan het Arduino-bord te verbinden.
Arduino Robot Schakelschema
Hier is het schakelschema van dit project en hoe alles verbonden moet worden.
Je kunt de benodigde componenten voor dit project via de onderstaande links verkrijgen:
- Stappenmotor – NEMA 17 ……………..…
- DRV8825 Stappenmotor Driver ……….…….…
- MG996R Servo Motor………………….….
- SG90 Micro Servo Motor …………….….
- HC-05 Bluetooth Module …………….…
- Li-Po accu …………………………….……
- Arduino Mega Bord ………….……….…
In de vorige tutorial legde ik uit hoe het Mecanum wielrobot-deel werkt en toonde ik hoe ik een custom PCB voor het project maakte.
Ik nam een 5V spanningsregelaar op in deze PCB zodat we dit project kunnen maken, of de servo-motoren kunnen aansluiten omdat ze op 5V werken. De spanningsregelaar is de LM350, die tot 3 ampère stroom kan aan. Alle zes servo's van de robotarm kunnen van ongeveer 2 tot 3 ampère stroom trekken, wat betekent dat hij ze kan aansturen, maar dat zal de regelaar erg heet maken.
Daarom bevestigde ik een koelblok aan hem, evenals een kleine 12V DC-ventilator om wat lucht te blazen, want het koelblok alleen was niet genoeg om de regelaar te koelen.
Ik verbond de signaaldraden van de servo's met de Arduino digitale pinnen 5 tot 10, en voor de voeding gebruikte ik de 5V pinheader op de PCB. Tot slot duwde ik alle draden naar binnen in het platform en bevestigde de bovenplaat met de twee moeren.
En dat is het, nu zijn we klaar met dit project.
Arduino Code
Wat overblijft is om te kijken hoe de Arduino-code en de Android-applicatie werken. Omdat de code wat langer is, voor beter begrip, zal ik de broncode in secties posten met beschrijving voor elke sectie. Aan het einde van dit artikel zal ik de complete broncode posten.
Eerst moeten we de 6 servo's, de 4 stappenmotoren en de Bluetooth-communicatie definiëren, evenals enkele variabelen die nodig zijn voor het programma hieronder. In de setup-sectie stellen we de maximumsnelheid van de steppers in, definiëren de pinnen waaraan de servo's verbonden zijn, starten de Bluetooth-communicatie en zetten de robotarm in initiële positie.
#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 they 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);
}Code language: Arduino (arduino)Dan in de loop-sectie beginnen we met controleren of er binnenkomende data is.
// Check for incoming data
if (Bluetooth.available() > 0) {
dataIn = Bluetooth.read(); // Read the data
Code language: Arduino (arduino)Deze data komt van de smartphone of de Android-app, laten we eens kijken wat voor data het eigenlijk verstuurt. De Android-app is gemaakt met de MIT App Inventor online applicatie. Het bestaat uit simpele knoppen met passende afbeeldingen als achtergrond.
Als we kijken naar de blokken van de app, zien we dat het niets anders doet dan één-byte nummers sturen wanneer de knoppen worden aangeklikt.
Dus, afhankelijk van de aangeklikte knop, vertellen we de Arduino wat hij moet doen. Bijvoorbeeld, als we het nummer '2' ontvangen, zal het mecanum wielplatform vooruit rijden, met behulp van de moveForward custom functie.
if (dataIn == 2) { m = 2; } // if (m == 2) { moveForward(); }Code language: Arduino (arduino)Deze custom functie zet alle vier de stappenmotoren om vooruit te draaien.
void moveForward() {
LeftFrontWheel.setSpeed(wheelSpeed);
LeftBackWheel.setSpeed(wheelSpeed);
RightFrontWheel.setSpeed(wheelSpeed);
RightBackWheel.setSpeed(wheelSpeed);
}Code language: Arduino (arduino)Voor het bewegen in elke andere richting, hoeven we de wielen alleen in de juiste richtingen te laten draaien.
Voor het besturen van de robotarm gebruiken we dezelfde methode. Weer hebben we knoppen in de app en wanneer we de knoppen ingedrukt houden, bewegen de robotarm-gewrichten in de specifieke richting.
Zoals ik eerder zei, in de originele Robotarm-besturingsapp gebruikten we schuifregelaars voor het besturen van de posities van de servo's, maar dat veroorzaakte problemen omdat we op die manier tekst naar de Arduino moesten sturen, in plaats van 1-byte nummer. Het probleem is dat de Arduino soms de tekst van de app mist en fouten maakt of de robotarm schudt en abnormaal gedraagt.
Op deze manier sturen we gewoon een enkel 1-byte nummer wanneer een bepaalde knop wordt ingedrukt (touch down).
De Arduino-code gaat in de while-lus van dat nummer, en blijft daar tot we de knop loslaten (touch up), want dan sturen we het nummer 0 wat betekent dat de robot niets hoeft te doen.
// 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);
}Code language: Arduino (arduino)Dus, afhankelijk van de ingedrukte knoppen bewegen de servo's in positieve of negatieve richting. Hetzelfde werkingsprincipe geldt voor alle servo-motoren. Voor het veranderen van de snelheid van beweging, gebruiken we de waarden van de schuifregelaar die lopen van 100 tot 250.
// If arm speed slider is changed
if (dataIn > 101 & dataIn < 250) {
speedDelay = dataIn / 10; // Change servo speed (delay time)
}Code language: Arduino (arduino)Door ze te delen door 10 krijgen we waarden van 10 tot 25, die gebruikt worden als vertraging in microseconden in de while-lussen voor het aansturen van de servo's.
Voor het opslaan van de robotbewegingen, slaan we simpelweg de huidige posities van de servo's en de steppers op in arrays, elke keer dat de Opslaan-knop wordt aangeklikt.
// 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;
}Code language: Arduino (arduino)Dan als we op de Start-knop drukken, roepen we de runSteps() custom functie aan. Deze custom functie loopt door alle opgeslagen stappen met behulp van enkele for- en while-lussen.
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
}
}Code language: Arduino (arduino)We moeten opmerken dat het begint bij de eerste positie en gaat naar de laatste positie, en dat herhaalt zich steeds weer. Daarom, bij het opslaan van de stappen, moeten we de robot eigenlijk zo positioneren dat de eerste stap dezelfde positie heeft als de laatste stap. Tijdens het aflopen van de stappen kunnen we ook de snelheid van zowel het platform als de robotarm veranderen, evenals pauzeren en alle stappen resetten.
Hier kun je deze app downloaden evenals het bewerkbare projectbestand:
Hier is de complete Arduino-code voor dit Arduino robotproject:
/* 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 they 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
// 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 incoming 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);
}
}
}
}
}Code language: Arduino (arduino)Dat is eigenlijk alles voor deze tutorial. Het project werkt goed, maar let op dat het ver van perfect is. De automatische bewegingen zijn misschien niet zo precies door het glijden van de mecanum wielen en de slechte prestaties van de servo-motoren. Deze goedkope servo-motoren kunnen ook trillen of trillen zelfs als ze niet bewegen, gewoon omdat ze niet genoeg kracht hebben om het gewicht van de 3D-geprinte onderdelen te houden.
Ik hoop dat je van deze tutorial hebt genoten en iets nieuws hebt geleerd. Stel gerust vragen in de reacties hieronder en bekijk mijn Arduino-projectenverzameling.
Productieproces
- Bouw een Internet-gecontroleerde Video-streamende Robot met Arduino & Raspberry Pi
- Simple Pi Robot – Bouw een 2-WD Autonome Rover met Raspberry Pi
- Servo-gestuurde obstakelvermijdende robot: Bouw met Arduino & HC-SR04
- Bestuur Je Roomba Create 2 Met Arduino En Android: Stapsgewijze Handleiding
- Arduino & MPU6050: Precieze Servomotor Besturing met SG90 & MG996R
- Bouw een Slimme Arduino-gestuurde Robotarm: Eenvoudige DIY Handleiding
- LittleArm 2C: Bouw een Duurzame 3D-geprinte Arduino Robotarm voor STEM Onderwijs
- DIY Handgebaren-gestuurde Arduino Robotarm – Stap‑voor‑Stap Bouwhandleiding
- Programmeerbare 3-As Robotarm Kit – Lokaal & Remote Besturing met Arduino en Bluetooth
- Arduino robotarm besturen via speciale Android-app
- KUKA KMR iiwa: Mobiele Collaboratieve Robotarm voor Industry 4.0