Bouw een Arduino Mecanum Wiel Robot: 360° Mobiliteit DIY Handleiding
In deze tutorial leer je hoe je een Arduino Mecanum Wiel Robot bouwt die in elke richting kan bewegen. Deze unieke mobiliteit van de robot wordt bereikt door het gebruik van een speciaal type wielen, genaamd Mecanum Wielen.
Je kunt de volgende video bekijken of de geschreven tutorial hieronder lezen.
Overzicht
Ik ontwierp en 3D-printte deze wielen eigenlijk zelf omdat ze best wat duur kunnen zijn om te kopen. Ze werken behoorlijk goed en ik moet zeggen dat het besturen van dit robotplatform heel leuk is. We kunnen de robot draadloos besturen met de NRF24L01 radio transceiver modules, of in mijn geval gebruik ik mijn DIY RC-zender die ik in een eerdere video maakte.
Ik maakte het ook mogelijk om het te besturen via een smartphone met Bluetooth-communicatie. Ik maakte een custom Android-applicatie waarmee we het Mecanum wielrobot in elke richting kunnen besturen. Ook met de schuifregelaar in de app kunnen we de snelheid van de beweging regelen.
De "hersenen" van dit robotplatform is een Arduino Mega bord dat elk wiel individueel bestuurt. Elk wiel is bevestigd op een NEMA 17 stappenmotor, en wetende dat stappenmotoren precies bestuurbaar zijn, voegde ik nog een leuke functie toe in de app waarmee we de robot kunnen programmeren om automatisch te bewegen. Met de Opslaan-knop kunnen we elke positie of stap opslaan en de robot kan deze stappen dan automatisch uitvoeren en herhalen. Met dezelfde knop kunnen we de automatische operatie ook pauzeren en resetten of alle stappen wissen om nieuwe op te slaan.
Mecanum Wiel Robot 3D-model
Allereerst ontwierp ik deze Mecanum Wiel robot met een 3D-modelleringssoftware. Het basisplatform van deze robot is een eenvoudige doos die ik uit 8mm dikke MDF-platen zal maken.
De vier stappenmotoren zijn aan dit platform bevestigd en de Mecanum wielen aan de motorassen.
Je kunt dit 3D-model vinden en downloaden, en in je browser verkennen op Thangs.
Download het assemblage 3D-model van Thangs.
STL-bestanden voor 3D-printen:
Hoe Mecanum Wielen Werken
Een Mecanum wiel is een wiel met rollen aan de omtrek. Deze rollen zijn diagonaal of onder een hoek van 45 graden ten opzichte van de draaias van het wiel gepositioneerd. Hierdoor uitoefent het wiel een diagonale kracht wanneer het vooruit of achteruit beweegt.
Door de wielen in een bepaald patroon te laten draaien, benutten we deze diagonale krachten en kan de robot in elke richting bewegen.
We moeten ook vermelden dat we twee typen Mecanum wielen nodig hebben, vaak aangeduid als linkshandige en rechtshandige Mecanum wielen. Het verschil zit in de oriëntatie van de rollen en ze moeten op specifieke locaties in de robot gemonteerd worden. De draaias van de bovenste rol van elk wiel moet naar het midden van de robot wijzen.
Hier is een snelle demonstratie van hoe de robot beweegt afhankelijk van de wieldraairichting.
Als alle vier de wielen vooruit draaien, zal de resulterende beweging van de robot vooruit zijn, en omgekeerd als alle wielen achteruit draaien, zal de robot achteruit rijden. Voor het bewegen naar rechts, moeten de rechter wielen naar binnen draaien, terwijl de linker wielen naar buiten moeten draaien. De resulterende kracht door de diagonaal gepositioneerde rollen zal de robot naar rechts laten bewegen. Hetzelfde maar omgekeerde gebeurt bij het bewegen naar links. Met deze wielen kunnen we ook diagonaal bewegen door slechts twee wielen te laten draaien.
De Mecanum Wiel Robot Maken
Desondanks, laat me je nu laten zien hoe ik dit robotplatform bouwde. Zoals gezegd, voor de basis van het platform gebruik ik 8mm dikke MDF-platen. Met een tafelzaag zaagde ik eerst alle stukken naar maat volgens de afmetingen van het 3D-model.
Vervolgens, met een 3mm boor en een 25mm Forstner-boor, maakte ik de openingen in de zijpaneelen voor het bevestigen van de stappenmotoren. Zodra ik de stukken klaar had, ging ik door met het monteren. Ik gebruikte houtlijm en enkele schroeven voor het bevestigen. Het belangrijkste hier is dat de openingen voor de motoren precies gemaakt zijn zodat alle wielen later gelijkmatig contact hebben met de ondergrond.
Natuurlijk kun je dit basisplatform ook 3D-printen in plaats van het van MDF te maken, dus ik zal een 3D-bestand ervan op de websiteartikel plaatsen. Ten slotte spuitte ik de basis en het deksel wit.
Vervolgens de Mecanum wielen. Zoals ik eerder zei, kunnen deze wielen best wat duur zijn om te kopen, daarom besloot ik ze zelf te ontwerpen en te 3D-printen. De wielen bestaan uit twee delen, buiten- en binnenkant, die met enkele M4-bouten en moeren aan elkaar bevestigd worden. Ze hebben 10 rollen elk, en een askoppeling specifiek ontworpen om op een NEMA 17 stappenmotor te passen.
Ik 3D-printte alle onderdelen voor de Mecanum wielen met mijn Creality CR-10 3D-printer.
Hier is een link naar deze 3D-printer voor het geval je hem wilt bekijken.
Zodra ik de 3D-geprinte onderdelen klaar had, ging ik door met het maken van de assen voor de rollen. Daarvoor gebruikte ik 3mm dikke staaldraad. De lengte van de assen moet ongeveer 40mm zijn, dus met een draaigereedschap zaagde ik de draad tot die lengte.
Ik begon met het monteren van het Mecanum wiel door de twee kanten en de askoppeling met vier M4-bouten en moeren vast te zetten. De lengte van de bouten moet 45mm zijn.
Voor het installeren van de rollen, moeten we eerst de as iets door de gaten aan de omtrek van de binnenkant duwen.
Dan kunnen we een kleine M3-ring, de rol erin duwen en de as helemaal in de sleuf van de buitenkant van het wiel duwen. Ik gebruikte één ring omdat ik niet genoeg ruimte had voor een tweede ring aan de andere kant.
Ik herhaalde dit proces voor alle 10 rollen. Het is eigenlijk makkelijk en leuk om deze wielen te monteren. Wat belangrijk is, is dat de rollen vrij moeten kunnen bewegen.
Aan het einde gebruikte ik enkele druppjes AC-lijm in elk van de binnengaten om ervoor te zorgen dat de assen niet los kunnen komen.
Ok, nu de wielen klaar zijn, kunnen we doorgaan met het monteren van de hele robot. Eerst moeten we de stappenmotoren aan het basisplatform bevestigen. Voor het bevestigen gebruikte ik M3-bouten met een lengte van 12mm.
Vervolgens moeten we de wielen aan de motorassen bevestigen. De askoppeling die ik maakte heeft een sleuf voor een M3-moer, doorheen welke een M3-bout kan passeren en zo kunnen we het wiel aan de as bevestigen.
Vervolgens, voor het bevestigen van het bovenste deksel aan de basis, bevestigde ik draadstangen aan twee hoekjes van de basis. Ik maakte gaten op dezelfde positie op het deksel en zo kon ik het deksel gemakkelijk invoegen en bevestigen aan de basis.
Aan de achterkant van de basis maakte ik een 20mm gat voor het later bevestigen van een voedingsschakelaar, evenals een 5mm gat voor een LED.
Schakelschema
Nu kunnen we doorgaan met de elektronica. Hier is het complete schakelschema van dit project.
We zullen de vier NEMA 17 stappenmotoren besturen met vier DRV8825 stappenmotor-drivers, of we kunnen ook de A4988 stappenmotor-drivers gebruiken. Voor de voeding van de steppers en de hele robot gebruiken we een 12V voeding, en in mijn geval gebruik ik een 3S Li-Po accu die ongeveer 12V levert. Voor de radiocommunicatie gebruiken we de NRF24L01-module, en voor de Bluetooth-communicatie de HC-05 Bluetooth-module. Ik nam ook een simpele spanningsdeler op voor het monitoren van de accuspanning en een LED-aansluiting voor het aangeven wanneer de accuspanning onder de 11V daalt.
Ik nam ook een speciale 5V spanningsregelaar op die ongeveer 3A stroom kan leveren. Dit is optioneel, maar ik plan in een toekomstige video dit project te combineren met mijn Arduino Robotarm-project, en daarvoor zou ik 5V nodig hebben voor het aansturen van de servo-motoren.
Je kunt de benodigde componenten voor dit project via de onderstaande links verkrijgen:
- Stappenmotor – NEMA 17………………
- DRV8825 Stappenmotor Driver…………………
- NRF24L01 Transceiver Module…….…
- HC-05 Bluetooth Module …………….…
- Li-Po accu …………………………….……
- Arduino Mega Bord ………………….…
PCB-ontwerp
Om de elektronische componenten georganiseerd te houden en de draadwarte te vermijden, ontwierp ik een custom PCB met de gratis online ontwerpsoftware EasyEDA. Deze PCB zal eigenlijk fungeren als een Arduino MEGA shield omdat we hem direct bovenop het Arduino Mega-bord kunnen verbinden. Ik gebruikte zowel de boven- als de onderlaag voor de verbindingen. Voor die Arduino-pinnen die ik niet gebruikte, nam ik pinheader-verbindingen op zodat ze beschikbaar zijn voor toekomstig gebruik. Ik nam ook 12V, 5V en GND-aansluitingen op, evenals pinnen voor het selecteren van de stapresolutie van de drivers.
Hier is een link naar de projectbestanden van dit PCB-ontwerp. Na het voltooien van het ontwerp genereerde ik de Gerber-bestanden nodig voor de productie van de PCB.
Gerber-bestand:
Vervolgens bestelde ik de PCB bij JLCPCB, die ook de sponsor van deze video is.
We kunnen eenvoudig het Gerber-bestand slepen en neerzetten en zodra geüpload, kunnen we onze PCB bekijken in de Gerber-viewer. Als alles klopt, kunnen we doorgaan en de eigenschappen selecteren die we voor onze PCB willen. Deze keer koos ik voor de PCB-kleur blauw om te matchen met de kleur van het Arduino-bord. Dat is het, nu kunnen we onze PCB bestellen tegen een redelijke prijs. Let op: als het je eerste bestelling is bij JLCPCB, kun je tot 10 PCB's voor slechts $2 krijgen.
Na enkele dagen zijn de PCB's aangekomen. De kwaliteit is geweldig en alles is precies hetzelfde als in het ontwerp.
De PCB Monteren
Ok, nu kunnen we doorgaan met het monteren van de PCB. Ik begon met het solderen van de kleinere componenten eerst, de weerstanden en condensators. Daarna plaatste en soldeerde ik mannelijke pinheaders op de PCB die gebruikt zullen worden voor het verbinden met het Arduino-bord.
Vervolgens plaatste ik alle vrouwelijke pinheaders op hun plek en soldeerde ze ook. Voor de stappenmotorverbindingen en pinnen voor het selecteren van de stapresolutie gebruikte ik mannelijke pinheaders. Op deze manier kunnen we de motoren direct aan de PCB verbinden en jumpers gebruiken voor het selecteren van de stapresolutie. Daarna soldeerde ik de klemblokken, de trimmer en de spanningsregelaar.
En dat is het, de PCB is nu klaar en we kunnen doorgaan met het plaatsen van de drivers en het verbinden van de motoren. Eerst plaatste ik de jumpers voor het selecteren van de stapresolutie. Ik selecteerde 1/16 stapresolutie door de MS3-pinnen van de drivers met 5V te verbinden.
Daarna plaatste ik de DRV8825-drivers erbovenop, evenals de NRF24L01-module en de HC-05 Bluetooth-module. Nu kunnen we de PCB gewoon op het Arduino-bord plaatsen.
Vervolgens verbond ik de accu met de juiste klemblok en plaatste ze in het basisplatform.
Hier plaatste ik de voedingsschakelaar en verbond hem met de andere klemblok. Rechtboven de voedingsschakelaar plaatste ik ook de accu-indicator LED.
Wat overblijft is de motoren aan de PCB te verbinden. We moeten hier opmerken dat bij het verbinden van tegenovergestelde motoren, we hun connectors ook tegenovergesteld moeten verbinden. Dit is later nodig bij het programmeren van de robot, zodat bijvoorbeeld het vooruit-commando beide motoren in dezelfde richting laat draaien, hoewel ze eigenlijk omgekeerd zitten en de ene kloksgewijs en de andere tegen de klok in zou draaien.
Aan het einde kan ik het deksel bovenaan plaatsen, en zo zijn we klaar met dit Mecanum Wiel robotproject.
Mecanum Wiel Robot Arduino Code
Wat overblijft voor deze video is om te kijken naar de Arduino-code. Eigenlijk zijn er twee aparte Arduino-codes. Deze is voor het besturen van de robot met de NRF24L01-modules en de andere voor het besturen van de robot met een smartphone.
Arduino-code voor het besturen van de robot met de NRF24L01-modules:
/* === Arduino Mecanum Wheels Robot === Radio control with NRF24L01 by Dejan, www.HowToMechatronics.com Libraries: RF24, https://github.com/tmrh20/RF24/ AccelStepper by Mike McCauley: https://www.airspayce.com/mikem/arduino/AccelStepper/index.html */
#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>
#include <AccelStepper.h>
RF24 radio(48, 49); // nRF24L01 (CE, CSN)
const byte address[6] = "00001";
unsigned long lastReceiveTime = 0;
unsigned long currentTime = 0;
// 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
int wheelSpeed = 1500;
// Max size of this struct is 32 bytes - NRF24L01 buffer limit
struct Data_Package {
byte j1PotX;
byte j1PotY;
byte j1Button;
byte j2PotX;
byte j2PotY;
byte j2Button;
byte pot1;
byte pot2;
byte tSwitch1;
byte tSwitch2;
byte button1;
byte button2;
byte button3;
byte button4;
};
Data_Package data; // Create a variable with the above structure
void setup() {
// Set initial seed values for the steppers
LeftFrontWheel.setMaxSpeed(3000);
LeftBackWheel.setMaxSpeed(3000);
RightFrontWheel.setMaxSpeed(3000);
RightBackWheel.setMaxSpeed(3000);
radio.begin();
radio.openReadingPipe(0, address);
radio.setAutoAck(false);
radio.setDataRate(RF24_250KBPS);
radio.setPALevel(RF24_PA_LOW);
radio.startListening(); // Set the module as receiver
Serial.begin(115200);
}
void loop() {
// Check whether we keep receiving data, or we have a connection between the two modules
currentTime = millis();
if ( currentTime - lastReceiveTime > 1000 ) {
// If current time is more then 1 second since we have received the last data, that means we have lost connection
resetData(); // If connection is lost, reset the data. It prevents unwanted behavior, for example if a drone has a throttle up, if we lose connection it can keep flying away if we dont reset the function
}
// Check whether there is data to be received
if (radio.available()) {
radio.read(&data, sizeof(Data_Package)); // Read the whole data and store it into the 'data' structure
lastReceiveTime = millis(); // At this moment we have received the data
}
// Set speed - left potentiometer
wheelSpeed = map(data.pot1, 0, 255, 100, 3000);
if (data.j1PotX > 150) { moveSidewaysLeft(); }
else if (data.j1PotX < 100) { moveSidewaysRight(); }
else if (data.j1PotY > 160) { moveForward(); }
else if (data.j1PotY < 100) { moveBackward(); }
else if (data.j2PotX < 100 & data.j2PotY > 160) { moveRightForward(); }
else if (data.j2PotX > 160 & data.j2PotY > 160) { moveLeftForward(); }
else if (data.j2PotX < 100 & data.j2PotY < 100) { moveRightBackward(); }
else if (data.j2PotX > 160 & data.j2PotY < 100) { moveLeftBackward(); }
else if (data.j2PotX < 100) { rotateRight(); }
else if (data.j2PotX > 150) { rotateLeft(); }
else { stopMoving(); }
// Execute the steps
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
// 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);
}
void resetData() {
// Reset the values when there is no radio connection - Set initial default values
data.j1PotX = 127;
data.j1PotY = 127;
data.j2PotX = 127;
data.j2PotY = 127;
data.j1Button = 1;
data.j2Button = 1;
data.pot1 = 1;
data.pot2 = 1;
data.tSwitch1 = 1;
data.tSwitch2 = 1;
data.button1 = 1;
data.button2 = 1;
data.button3 = 1;
data.button4 = 1;
}Code language: Arduino (arduino)Beschrijving: Hier gebruiken we de RF24-bibliotheek voor de radiocommunicatie en de AccelStepper-bibliotheek voor het besturen van de stappenmotoren. Eerst moeten we de pinnen definiëren waaraan alles verbonden is, enkele variabelen definiëren die nodig zijn voor het programma hieronder, en in de setup-sectie de maximumsnelheid van de steppers instellen en de radiocommunicatie starten.
In de loop-sectie beginnen we met het lezen van de data die van de RC-zender komt. De RC-zendercode en meer details over hoe deze communicatie werkt vind je op mijn speciale tutorial ervoor.
Afhankelijk van de ontvangen data, bijvoorbeeld als de linker joystick vooruit wordt geduwd, zal de waarde groter zijn dan 160 en in dat geval roepen we de moveForward()-custom-functie aan. Als we kijken naar deze functie, zien we dat hij niets anders doet dan de snelheid van de motoren op positief zetten. Voor achteruit rijden wordt de snelheid op negatief gezet. Voor alle andere richtingen hoeven we de rotaties van de wielen gewoon op de juiste manier in te stellen zoals uitgelegd in het begin.
Voor het uitvoeren van deze commando's, moeten we in de loop-sectie de runSpeed()-functies voor alle steppers aanroepen. In de loop-sectie lezen we ook de analoge ingang van de spanningsdeler die van de accu komt, en volgens deze waarde weten we wanneer de accuspanning onder de 11V daalt zodat we de indicator-LED kunnen aansturen.
Arduino-code voor het besturen van de robot met een smartphone:
/* === Arduino Mecanum Wheels Robot === Smartphone control via Bluetooth by Dejan, www.HowToMechatronics.com Libraries: RF24, https://github.com/tmrh20/RF24/ AccelStepper by Mike McCauley: https://www.airspayce.com/mikem/arduino/AccelStepper/index.html */
#include <SoftwareSerial.h>
#include <AccelStepper.h>
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 dataIn, m;
int lbw[50], lfw[50], rbw[50], rfw[50]; // for storing positions/steps
int index = 0;
void setup() {
// Set initial seed values for the steppers
LeftFrontWheel.setMaxSpeed(3000);
LeftBackWheel.setMaxSpeed(3000);
RightFrontWheel.setMaxSpeed(3000);
RightBackWheel.setMaxSpeed(3000);
Serial.begin(38400);
Bluetooth.begin(38400); // Default baud rate of the Bluetooth module
Bluetooth.setTimeout(1);
delay(20);
pinMode(led, OUTPUT);
}
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; }
// Set speed
if (dataIn >= 16) { wheelSpeed = dataIn * 10; Serial.println(wheelSpeed); }
}
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(); }
// If button "SAVE" is pressed
if (m == 12) {
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();
index++; // Increase the array index
m = 0;
}
if (m == 14) {
runSteps();
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));
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 runSteps() {
for (int i = index - 1; i >= 0; i--) { // Run through all steps(index)
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();
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) { stopMoving(); break; }
}
}
}
if (dataIn >= 16) { wheelSpeed = dataIn * 10; dataIn = 14; }
if (dataIn == 13) { break; }
}
}
}
// Go back through steps
for (int i = 1; i <= index - 1; i++) { // Run through all steps(index)
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();
// Serial.print(" current: ");
// Serial.println(LeftBackWheel.currentPosition());
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) { stopMoving(); break; }
}
}
}
if (dataIn >= 16) { wheelSpeed = dataIn * 10; dataIn = 14; }
if (dataIn == 13) { break; }
}
}
}
}
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);
}Code language: Arduino (arduino)Beschrijving: De andere code voor het besturen van de robot met de Android-applicatie, is erg vergelijkbaar en werkt op dezelfde manier. Hier in plaats van de radiomodule moeten we de Bluetooth-module definiëren en de communicatie ervan initialiseren in de setup-sectie. Opnieuw lezen we eerst de binnenkomende data van de smartphone of de Android-app, en volgens die data vertellen we de robot in welke richting hij moet bewegen.
Als we kijken naar de Android-app, zien we dat het simpelweg nummers van 0 tot 15 via Bluetooth verstuurt wanneer de knoppen worden ingedrukt.
De app is gemaakt met de MIT App Inventor online applicatie en je kunt meer details erover vinden in mijn speciale tutorial ervoor.
Hier kun je deze app downloaden evenals het bewerkbare projectbestand:
Voor het programmeren van de automatische robotbeweging met deze app, wanneer we op de "OPSLAAN"-knop drukken, slaan we simpelweg de huidige posities van de stappenmotoren op in arrays. Dan wanneer we op de "START"-knop drukken, roepen we de runSteps()-custom-functie aan die alle opgeslagen stappen uitvoert met behulp van enkele for- en while-lussen.
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 Bluetooth-gecontroleerde Raspberry Pi Robot met Audio Feedback
- Servo-gestuurde obstakelvermijdende robot: Bouw met Arduino & HC-SR04
- Bouw Een Autonome Lijnvolgende Robot Met Arduino UNO
- Bouw een Stemgecontroleerde Robot met Arduino Nano
- PiBot: De Arduino-aangedreven pianorobot voor precisiemuziek
- LittleArm 2C: Bouw een Duurzame 3D-geprinte Arduino Robotarm voor STEM Onderwijs
- Bouw een Autonome Thuisassistent Robot: Complete Onderdelenlijst & Opzetgids
- Arduino robotarm besturen via speciale Android-app
- Slim Indoor Navigatie Robot Kit voor Arduino Projecten
- WiDC: Wi‑Fi FPV-robot – Externe bediening met live video
- Maak een slimme pratende humanoïde robot met Arduino UNO