Arduino Robotarm en Mecanum Wheels Platform Automatische bediening
In deze tutorial laat ik je zien hoe ik mijn Mecanum Wheels Robot Platform uit mijn vorige video heb gemaakt, om samen te werken en automatisch te laten werken met mijn 3D-geprinte Robotic Arm, ook een Arduino-project uit een van mijn vorige video's.
Je kunt de volgende video bekijken of de schriftelijke tutorial hieronder lezen.
Overzicht
We kunnen de Mecanum-wielenrobot dus besturen met de op maat gemaakte Android-applicatie op dezelfde manier als uitgelegd in de vorige video. Daarnaast heeft de app nu ook knoppen om de robotarm te bedienen.
De originele app voor robotarmbesturing had eigenlijk schuifregelaars voor het besturen van de robotgewrichten, maar dat veroorzaakte wat problemen met de armstabiliteit. Op deze manier werkt de arm veel beter, daarom zal ik deze bijgewerkte versie van de robotarmbesturingsapp en de Arduino-code ook aan het originele robotarmproject leveren.
Desalniettemin is de coolste eigenschap van deze robot de mogelijkheid om de bewegingen op te slaan en ze vervolgens automatisch te herhalen.
Met behulp van de knop Opslaan kunnen we eenvoudig de posities van de motoren voor elke stap opslaan. Dan hoeven we alleen maar op de knop Uitvoeren te klikken en de robot herhaalt de opgeslagen bewegingen automatisch steeds opnieuw.
De Arduino-robot bouwen
Ok, dus hier heb ik het Mecanum wielenplatform al gemonteerd en je kunt er alle details over vinden in mijn vorige video.
Ook heb ik hier de 3D-geprinte delen van de robotarm en de servomotoren en nu zal ik je laten zien hoe je ze monteert. Hier is het 3D-model van dit project.
U kunt dit 3D-model vinden en downloaden, en het ook verkennen in uw browser op Thangs.
Download het 3D-model op Thangs.
STL-bestanden voor 3D-printen:
De eerste servo van de robotarm wordt direct op de bovenklep van het platform met mecanumwielen gemonteerd.
Ik heb de locatie gemarkeerd en met een boor van 10 mm heb ik verschillende gaten gemaakt.
Vervolgens heb ik met een rasp de gaten doorgesneden en vervolgens de opening voor de servo fijn afgesteld. Ik heb de servo op de bovenplaat bevestigd met vier M3-bouten en moeren.
Vervolgens moeten we op deze uitgaande as van deze servo, met behulp van de ronde hoorn die als accessoire bij de servo wordt geleverd, het volgende onderdeel of de taille van de robotarm bevestigen. Wel merken we dat op deze manier het onderdeel ongeveer 8 mm boven de plaat blijft. Daarom heb ik twee stukken MDF-platen van 8 mm bevestigd, zodat het taillegedeelte erop kan schuiven en de verbinding stabieler wordt.
De ronde hoorn wordt aan het taillegedeelte bevestigd met behulp van de zelftappende schroeven die als accessoires bij de servo worden geleverd, en vervolgens wordt de ronde hoorn aan de servo-as bevestigd met de juiste bouten die ook bij de servo worden geleverd.
Vervolgens hebben we de schouderservo. We plaatsen het eenvoudig op zijn plaats en bevestigen het aan het 3D-geprinte onderdeel met zelftappende schroeven.
De ronde hoorn gaat op het volgende deel, en dan worden de twee delen aan elkaar bevestigd met een bout op de uitgaande as van de servo.
We moeten er rekening mee houden dat voordat we de onderdelen vastzetten, we ervoor moeten zorgen dat het onderdeel het volledige bewegingsbereik heeft. Hier heb ik ook een rubberen band aan het schoudergewricht toegevoegd, zodat het een beetje hulp geeft aan de servo, omdat deze servo het gewicht van de rest van de arm en de lading draagt.
Op dezelfde manier heb ik de rest van de robotarm in elkaar gezet.
Vervolgens moeten we het grijpermechanisme monteren. De grijper wordt aangestuurd met een SG90 servomotor, waarop we eerst een speciaal ontworpen schakelmechanisme bevestigen. We koppelen deze schakel aan een andere schakelschakel aan de andere kant, die wordt vastgezet met M4-bouten en moeren. Eigenlijk zijn alle andere schakels verbonden met M4-bouten en -moeren.
Het 3D-model van de grijper heeft oorspronkelijk gaten van 3 mm, maar ik had niet genoeg M3-bouten, dus daarom heb ik de gaten vergroot met een boor van 4 mm en in plaats daarvan de M4-bouten gebruikt.
Nadat ik het grijpermechanisme had gemonteerd, heb ik het aan de laatste servo bevestigd en zo was de robotarm voltooid.
Vervolgens heb ik wat kabelbeheer gedaan. Ik heb de servodraden door de speciaal ontworpen gaten van de robotarm geleid. Met een boor van 10 mm heb ik een gat gemaakt in de bovenplaat zodat de draden erdoor kunnen.
Met behulp van een kabelbinder heb ik alle draden aan elkaar vastgemaakt, en nu hoef je ze alleen nog maar aan te sluiten op het Arduino-bord.
Arduino Robot-schakelschema
Hier is het schakelschema van dit project en hoe alles moet worden aangesloten.
U kunt de componenten die nodig zijn voor dit project verkrijgen via de onderstaande links:
- Stappenmotor – NEMA 17 …………..…
- DRV8825 Stepper-stuurprogramma ……….…….…
- MG996R servomotor……………….….
- SG90 microservomotor …………….….
- HC-05 Bluetooth-module …………….…
- Li-Po-batterij ………………………….……
- Arduino Mega-bord ………….………….…
In de vorige tutorial heb ik uitgelegd hoe het Mecanum Wheels robot onderdeel werkt en ook laten zien hoe ik er een custom PCB voor heb gemaakt.
Ik heb een 5V-spanningsregelaar op deze PCB opgenomen zodat we dit project kunnen maken, of de servomotoren kunnen aansluiten omdat ze op 5V werken. De spanningsregelaar is de LM350, die tot 3 ampère stroom aankan. Alle zes servo's van de robotarm kunnen van ongeveer 2 ampère tot 3 ampère stroom trekken, wat betekent dat hij ze aankan, maar de regelaar zal erg heet worden.
Daarom heb ik er een koellichaam aan bevestigd, evenals een kleine 12V DC-ventilator om wat lucht te blazen, omdat het koellichaam zelf niet genoeg was om de regelaar af te koelen.
Ik heb de signaaldraden van de servo's aangesloten op de digitale pinnen van Arduino van nummer 5 tot 10, en voor het voeden gebruikte ik de 5V-pinheader op de PCB. Ten slotte heb ik alle draden in het platform geduwd en de bovenplaat eraan vastgemaakt met behulp van de twee moeren.
En dat was 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, zal ik voor een beter begrip de broncode van het programma in secties plaatsen met een beschrijving voor elke sectie. En aan het einde van dit artikel zal ik de volledige broncode posten.
Dus eerst moeten we de 6 servo, de 4 stappenmotoren en de Bluetooth-communicatie definiëren, evenals enkele variabelen die nodig zijn voor het onderstaande programma. In het setup-gedeelte stellen we de maximale snelheid van de steppers in, definiëren we de pinnen waarop de servo's zijn aangesloten, starten we de Bluetooth-communicatie en zetten we de robotarm in de beginpositie.
#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);
}Code language: Arduino (arduino)Vervolgens beginnen we in de loop-sectie met het controleren of er binnenkomende gegevens zijn.
// Check for incoming data
if (Bluetooth.available() > 0) {
dataIn = Bluetooth.read(); // Read the dataCode language: Arduino (arduino)Deze gegevens komen van de smartphone of de Android-app, dus laten we eens kijken wat voor soort gegevens het daadwerkelijk verzendt. De Android app is gemaakt met behulp van de MIT App Inventor online applicatie. Het bestaat uit eenvoudige knoppen met passende afbeeldingen als achtergrond.
Als we naar de blokken van de app kijken, kunnen we zien dat het alleen getallen van één byte verzendt wanneer op de knoppen wordt geklikt.
Dus, afhankelijk van de aangeklikte knop, vertellen we de Arduino wat hij moet doen. Als we bijvoorbeeld het nummer '2' ontvangen, gaat het platform met mecanumwielen naar voren, met behulp van de aangepaste functie moveForward.
if (dataIn == 2) {
m = 2;
}
//
if (m == 2) {
moveForward();
}Code language: Arduino (arduino)Deze aangepaste functie zorgt ervoor dat alle vier de stappenmotoren vooruit draaien.
void moveForward() {
LeftFrontWheel.setSpeed(wheelSpeed);
LeftBackWheel.setSpeed(wheelSpeed);
RightFrontWheel.setSpeed(wheelSpeed);
RightBackWheel.setSpeed(wheelSpeed);
}Code language: Arduino (arduino)Om in een andere richting te bewegen, hoeven we alleen de wielen in de juiste richting te draaien.
Voor het aansturen van de robotarm gebruiken we dezelfde methode. Nogmaals, we hebben knoppen in de app en wanneer je de knoppen ingedrukt houdt, bewegen de robotarmgewrichten in een bepaalde richting.
Zoals ik eerder al zei, gebruikten we in de originele Robot Arm-besturingsapp schuifregelaars voor het regelen van de posities van de servo's, maar dat veroorzaakte wat 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 een fout maakt of dat de robotarm trilt en zich abnormaal gedraagt.
Op deze manier sturen we eenvoudig een enkel 1-byte nummer wanneer een bepaalde knop wordt ingedrukt.
De Arduino-code komt in de while-lus van dat nummer en blijft daar totdat we de knop aanraken, omdat we op dat moment het nummer 0 sturen, wat betekent dat de robot niets moet 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 aangeraakte knoppen, bewegen de servo's in positieve of negatieve richting. Voor alle servomotoren geldt hetzelfde werkingsprincipe. Voor het wijzigen van de bewegingssnelheid gebruiken we de waarden die uit de schuifregelaar komen, die variëren 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 worden gebruikt als vertraging in microseconden in de while-lussen voor het aansturen van de servo's.
Voor het opslaan van de robotbewegingen slaan we eenvoudig de huidige posities van de servo's en de steppers op in arrays, telkens wanneer op de knop Opslaan wordt geklikt.
// 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)Wanneer we vervolgens op de knop Uitvoeren drukken, roepen we de aangepaste functie runSteps() aan. Deze aangepaste functie doorloopt 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 vanaf de eerste positie en naar de laatste positie gaat, en dat steeds opnieuw herhaalt. Daarom moeten we bij het opslaan van de stappen de robot zo plaatsen dat de eerste stap dezelfde positie heeft als de laatste stap. Tijdens het doorlopen van de stappen kunnen we ook de snelheid van zowel het platform als de robotarm wijzigen, evenals alle stappen pauzeren en resetten.
Hier kunt u deze app en het bewerkbare projectbestand downloaden:
Hier is de volledige 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 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);
}
}
}
}
}Code language: Arduino (arduino)Dus dat is zo ongeveer alles voor deze tutorial. Het project werkt goed, maar houd er rekening mee dat het verre van perfect is. De automatische bewegingen zijn misschien niet zo nauwkeurig vanwege het slippen van de mecanumwielen en de slechte prestaties van de servomotoren. Deze goedkope servomotoren kunnen ook trillen of trillen, zelfs als ze niet bewegen, alleen omdat ze niet genoeg kracht hebben om het gewicht van de 3D-geprinte onderdelen te dragen.
Ik hoop dat je deze tutorial leuk vond en iets nieuws hebt geleerd. Stel gerust een vraag in de opmerkingen hieronder en bekijk mijn Arduino Projects-collectie.
Productieproces
- Bouw uw internetgestuurde videostreamingrobot met Arduino en Raspberry Pi
- Simple Pi Robot
- Obstakels vermijden robot met servomotor
- Een Roomba-robot besturen met Arduino en Android-apparaat
- Besturing van servomotor met Arduino en MPU6050
- Eenvoudige en slimme robotarm met Arduino
- Littlearm 2C:bouw een 3D-geprinte Arduino-robotarm
- DIY Arduino-robotarm – bestuurd door handgebaren
- Lokale en op afstand programmeerbare robotarm
- Bedien de Arduino-robotarm met Android-app
- Robot combineert collaboratieve robotarm met mobiel platform