Arduino Mecanum Wheels-robot

In deze tutorial leren we hoe we een Arduino Mecanum Wheels-robot kunnen bouwen die in elke richting kan bewegen. Deze unieke mobiliteit van de robot wordt bereikt door gebruik te maken van een speciaal type wielen, Mecanum Wheels genaamd.

Je kunt de volgende video bekijken of de schriftelijke tutorial hieronder lezen.

Overzicht

Ik heb deze wielen eigenlijk ontworpen en in 3D geprint omdat ze een beetje duur kunnen zijn om te kopen. Ze werken best goed en ik moet zeggen dat het besturen van dit robotplatform zo leuk is. We kunnen de robot draadloos besturen met behulp van de NRF24L01 radiotransceivermodules, of in mijn geval gebruik ik mijn DIY RC-zender die ik in een van mijn vorige video's heb gemaakt.

Ik heb het ook mogelijk gemaakt om met een smartphone te worden bestuurd via Bluetooth-communicatie. Ik heb een aangepaste Android-applicatie gemaakt waarmee we de Mecanum-wielenrobot kunnen besturen om in elke richting te bewegen. Met behulp van de schuifregelaar in de app kunnen we ook de bewegingssnelheid regelen.

Het brein van dit robotplatform is een Arduino Mega-bord dat elk wiel afzonderlijk bestuurt. Elk wiel is bevestigd aan een NEMA 17-stappenmotor, en wetende dat stappenmotoren nauwkeurig kunnen worden bestuurd, heb ik nog een coole functie in de app toegevoegd waarmee we de robot kunnen programmeren om automatisch te bewegen. Met behulp van de knop Opslaan kunnen we elke positie of stap opslaan en vervolgens kan de robot deze stappen automatisch uitvoeren en herhalen. Met dezelfde knop kunnen we de automatische werking pauzeren en alle stappen resetten of verwijderen, zodat we nieuwe kunnen opslaan.

Mecanum Wheels Robot 3D-model

Om te beginnen heb ik deze Mecanum Wheels-robot ontworpen met behulp van 3D-modelleringssoftware. Het basisplatform van deze robot is een eenvoudige doos die ik zal maken van MDF-platen van 8 mm dik.

De vier stappenmotoren zijn bevestigd aan dit platform en de Mecanum-wielen zijn bevestigd aan de assen van de motor.

U kunt dit 3D-model vinden en downloaden, en het ook verkennen in uw browser op Thangs.

Download het 3D-assemblagemodel 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 in een hoek van 45 graden ten opzichte van de rotatie-as van het wiel geplaatst. Hierdoor oefent het wiel kracht uit in diagonale richting bij het vooruit of achteruit rijden.

Dus door de wielen in een bepaald patroon te draaien, gebruiken we deze diagonale krachten en zo kan de robot in elke richting bewegen.

We moeten hier ook opmerken dat we twee soorten Mecanum-wielen nodig hebben, vaak linkshandige en rechtshandige Mecanum-wielen genoemd. Het verschil tussen hen is de oriëntatie van de rollen en ze moeten op specifieke locaties in de robot worden geïnstalleerd. De rotatie-as van de bovenste rol van elk wiel moet naar het midden van de robot wijzen.

Hier is een korte demonstratie van hoe de robot beweegt, afhankelijk van de draairichting van de wielen.

Als alle vier de wielen naar voren bewegen, zal de resulterende beweging van de robot naar voren zijn, en vice versa als alle wielen achteruit gaan, zal de robot achteruit gaan. Om naar rechts te gaan, moeten de rechterwielen in de robot draaien, terwijl de linkerwielen buiten de robot moeten draaien. De resulterende kracht door de diagonaal geplaatste rollen zorgt ervoor dat de robot naar rechts beweegt. Hetzelfde maar het tegenovergestelde gebeurt bij het naar links bewegen. Met deze wielen kunnen we ook beweging in diagonale richting bereiken door slechts twee wielen te draaien.

De Mecanum Wheels-robot maken

Desalniettemin, laat me je nu laten zien hoe ik dit robotplatform heb gebouwd. Zoals ik al zei, gebruik ik voor het maken van de basis van het platform MDF-platen van 8 mm. Met behulp van een tafelzaag heb ik eerst alle stukken gesneden volgens de afmetingen van het 3D-model.

Vervolgens heb ik met een boor van 3 mm en een Forstner-bit van 25 mm de openingen in de zijpanelen gemaakt voor het bevestigen van de stappenmotoren. Toen ik de onderdelen klaar had, ging ik verder met het in elkaar zetten. Ik gebruikte een houtlijm en enkele schroeven om ze vast te zetten. Het belangrijkste hierbij is dat de openingen voor de motoren precies gemaakt moeten worden, zodat alle wielen later zelfs contact met het oppervlak hebben.

Natuurlijk kun je dit basisplatform ook 3D-printen, in plaats van het met MDF te maken, dus ik zal er een 3D-bestand van opnemen in het website-artikel. Ten slotte heb ik de basis gespoten en het is bedekt met een witte kleur.

De volgende zijn de Mecanum-wielen. Zoals ik al eerder zei, kunnen deze wielen een beetje duur zijn om te kopen, daarom heb ik besloten om mijn eigen wielen te ontwerpen en te 3D-printen. De wielen bestaan uit twee delen, buiten- en binnenzijde, die aan elkaar worden vastgezet met enkele M4 bouten en moeren. Ze hebben elk 10 rollen en een askoppeling die speciaal is ontworpen voor een NEMA 17 stappenmotor.

Ik heb alle onderdelen voor de Mecanum-wielen in 3D geprint met mijn Creality CR-10 3D-printer.

Hier is een link naar deze 3D-printer voor het geval je hem wilt bekijken.

Dus toen ik de 3D-geprinte onderdelen klaar had, ging ik verder met het maken van de assen voor de rollen. Ik heb daarvoor 3 mm tick staaldraad gebruikt. De lengte van de assen moet ongeveer 40 mm zijn, dus met behulp van een roterend gereedschap knip ik de draad op die lengte.

Ik begon met het monteren van het Mecanum-wiel door de twee zijkanten en de askoppeling vast te zetten met vier M4-bouten en moeren. De lengte van de bouten moet 45 mm zijn.

Om de rollen te installeren, moeten we eerst de as iets door de gaten aan de omtrek van de binnenzijde steken.

Dan kunnen we een kleine M3-ring plaatsen, de rol plaatsen en de as helemaal in de gleuf van de buitenzijde van het wiel duwen. Ik heb een enkele ring gebruikt omdat ik niet genoeg ruimte had om een tweede ring aan de andere kant te plaatsen.

Ik herhaalde dit proces voor alle 10 rollen. Het is eigenlijk gemakkelijk en leuk om deze wielen in elkaar te zetten. Wat hier belangrijk is, is dat de rollen vrij moeten kunnen bewegen.

Aan het einde heb ik een paar druppels AC-lijm in elk van de binnenste gaten gebruikt om ervoor te zorgen dat de assen niet losraken.

Oké, dus zodra de wielen klaar zijn, kunnen we doorgaan met het monteren van de hele robot. Eerst moeten we de stappenmotoren aan het basisplatform bevestigen. Om ze vast te zetten heb ik M3-bouten gebruikt met een lengte van 12 mm.

Vervolgens moeten we de wielen aan de assen van de motor bevestigen. De askoppeling die ik heb gemaakt heeft een gleuf voor het inbrengen van een M3-moer, waar een M3-bout doorheen kan en zodat we het wiel aan de as kunnen bevestigen.

Vervolgens heb ik, om de bovenklep aan de basis te bevestigen, draadstangen op twee hoeken van de basis bevestigd. Ik maakte gaten op dezelfde positie in de hoes, zodat ik de hoes gemakkelijk kon plaatsen en aan de basis kon bevestigen.

Aan de achterkant van de basis heb ik een gat van 20 mm gemaakt om later een aan / uit-schakelaar te bevestigen, evenals een gat van 5 mm voor het bevestigen van een LED.

Circuitdiagram

Nu kunnen we verder met de elektronica. Hier is het volledige schakelschema van dit project.

Dus we zullen de vier NEMA 17 stappenmotoren besturen met behulp van vier DRV8825 stappenmotoren, of we kunnen ook de A4988 stappenmotoren gebruiken. Voor het voeden van de steppers en de hele robot zullen we een 12V-voeding gebruiken, en in mijn geval zal ik een 3S Li-Po-batterij gebruiken die ongeveer 12V levert. Voor de radiocommunicatie gebruiken we de NRF24L01-module en voor de Bluetooth-communicatie gebruiken we de HC-05 Bluetooth-module. Ik heb ook een eenvoudige spanningsdeler toegevoegd die zal worden gebruikt voor het bewaken van de batterijspanning en een LED-aansluiting om aan te geven wanneer de batterijspanning onder de 11V komt.

Ik heb ook een speciale 5V-spanningsregelaar meegeleverd die ongeveer 3A stroom kan leveren. Dit is optioneel, maar ik ben van plan in een toekomstige video dit project te combineren met mijn Arduino Robot Arm-project, en voor dat doel zou ik 5V nodig hebben voor het aandrijven van de servomotoren.

U kunt de componenten die nodig zijn voor dit project verkrijgen via de onderstaande links:

Stappenmotor – NEMA 17………………
DRV8825 Stepper-stuurprogramma………………
NRF24L01 Zendontvangermodule…….…
HC-05 Bluetooth-module …………….…
Li-Po-batterij ………………………….……
Arduino Mega-bord ……………….…

PCB-ontwerp

Desalniettemin, om de elektronische componenten georganiseerd te houden en de bedradingspuinhoop kwijt te raken, heb ik een aangepaste PCB ontworpen met behulp van de gratis EasyEDA-software voor online circuitontwerp. Deze PCB zal eigenlijk fungeren als een Arduino MEGA-schild omdat we hem rechtstreeks op het Arduino Mega-bord kunnen aansluiten. Ik heb zowel de bovenste als de onderste laag gebruikt voor het uitvoeren van de verbindingen. Voor die Arduno-pinnen die ik niet heb gebruikt, heb ik pin-headerverbindingen toegevoegd, zodat ze beschikbaar zijn voor het geval we ze in de toekomst ergens voor willen gebruiken. Ik heb ook 12V-, 5V- en GND-verbindingspinnen toegevoegd, evenals pinnen voor het selecteren van de stapresolutie van de stuurprogramma's.

Hier is een link naar de projectbestanden van dit PCB-ontwerp. Dus toen ik klaar was met het ontwerp, genereerde ik het Gerber-bestand dat nodig was voor het maken van de PCB.

Gerber-bestand:

Toen bestelde ik de PCB bij JLCPCB, die ook de sponsor van deze video zijn.

Hier kunnen we eenvoudig het Gerber-bestand slepen en neerzetten en eenmaal geüpload, kunnen we onze PCB bekijken in de Gerber-viewer. Als alles in orde is, kunnen we doorgaan en de eigenschappen selecteren die we voor onze PCB willen. Deze keer heb ik gekozen voor de kleur van de PCB om blauw te zijn om overeen te komen met de kleur van het Arduino-bord. En dat was het, nu kunnen we onze PCB gewoon voor een redelijke prijs bestellen. Houd er rekening mee dat als het uw eerste bestelling bij JLCPCB is, u tot 10 PCB's kunt krijgen voor slechts $ 2.

Na enkele dagen zijn de PCB's gearriveerd. De kwaliteit van de PCB's is geweldig en alles is precies hetzelfde als in het ontwerp.

Montage van de print

Ok nu kunnen we verder gaan en de printplaat monteren. Ik begon eerst met het solderen van de kleinere componenten, de weerstanden en de condensatoren. Vervolgens heb ik mannelijke pin-headers op de PCB geplaatst en gesoldeerd die zal worden gebruikt om deze op het Arduino-bord aan te sluiten.

Vervolgens plaatste ik alle vrouwelijke pin-headers op hun plaats en soldeerde ze ook. Wat betreft de verbindingen van de stappenmotoren en pinnen voor het selecteren van de stapresolutie heb ik mannelijke pin-headers gebruikt. Op deze manier kunnen we de motoren direct op de print aansluiten en jumpers gebruiken voor het selecteren van de stappenresolutie. Daarna heb ik de klemmenblokken, de trimmer en de spanningsregelaar gesoldeerd.

En dat was het, de print is nu klaar en we kunnen verder met het plaatsen van de drivers en het aansluiten van de motoren erop. Eerst plaatste ik de jumpers voor het selecteren van de stapresolutie. Ik heb de resolutie van de 16e stap geselecteerd door de MS3-pinnen van de stuurprogramma's aan te sluiten op 5V.

Daarop heb ik de DRV8825-stuurprogramma's geplaatst en de NRF24L01-module en de HC-05 Bluetooth-module aangesloten. Nu kunnen we de print eenvoudig op het Arduno-bord bevestigen.

Vervolgens heb ik de batterij op het juiste aansluitblok aangesloten en in het basisplatform geplaatst.

Hier heb ik de aan / uit-schakelaar op zijn plaats gestoken en op het andere aansluitblok aangesloten. Rechts boven de aan/uit-schakelaar heb ik ook de batterij-indicator LED geplaatst.

Wat nu nog rest is het aansluiten van de motoren op de printplaat. We moeten hier opmerken dat we bij het aansluiten van tegenovergestelde motoren ook hun connectoren tegenover elkaar moeten aansluiten. Dit is later nodig bij het programmeren van de robot, zodat bijvoorbeeld het vooruit-commando beide motoren in dezelfde richting zou bewegen, hoewel ze eigenlijk worden omgedraaid en de ene met de klok mee en de andere tegen de klok in draait.

Aan het einde kan ik eenvoudig de hoes aan de bovenkant plaatsen, en zo zijn we klaar met dit Mecanum Wheels-robotproject.

Mecanum Wheels Robot Arduino-code

Wat overblijft voor deze video is om de Arduino-code te bekijken. Eigenlijk zijn er twee afzonderlijke Arduino-codes. Deze is voor het besturen van de robot met behulp van de NRF24L01-modules en de andere is voor het besturen van de robot met behulp van een smartphone.

Arduino-code voor het besturen van de robot met behulp van 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: http://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 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

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 receving 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 recived 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 jas 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 i
  // 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: Dus hier gebruiken we de RF24-bibliotheek voor de radiocommunicatie en de AccelStepper-bibliotheek voor het aansturen van de stappenmotoren. Eerst moeten we de pinnen definiëren waarmee ze allemaal zijn verbonden, enkele variabelen definiëren die nodig zijn voor het onderstaande programma, en in de setup-sectie de maximale snelheid van de steppers instellen en de radiocommunicatie starten.

In het lusgedeelte beginnen we met het lezen van de gegevens die van de RC-zender komen. De RC-zendercode en meer details over hoe deze communicatie werkt, zijn te vinden in mijn specifieke tutorial ervoor.

Dus afhankelijk van de ontvangen gegevens, bijvoorbeeld, als de linker joystick naar voren wordt bewogen, zal de waarde groter zijn dan 160 en in dat geval zal de aangepaste functie moveForward() worden aangeroepen. Als we naar deze functie kijken, kunnen we zien dat het alleen de snelheid van de motoren op positief zet. Om achteruit te gaan, wordt de snelheid op negatief ingesteld. Dus om in alle andere richtingen te bewegen, hoeven we alleen de rotaties van de wielen op de juiste manier in te stellen, zoals in het begin is uitgelegd.

Om deze commando's uit te voeren, moeten we in de loop-sectie de runSpeed()-functies aanroepen voor alle steppers. In het lusgedeelte lezen we ook de analoge ingang van de spanningsdeler die van de batterij komt, en volgens deze waarde kunnen we weten wanneer de batterijspanning onder 11V daalt, zodat we de indicatie-LED kunnen inschakelen.

Arduino-code voor besturing naar robot met 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: http://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 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 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();
  }
  //Serial.println(dataIn);
  // 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 i
  //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 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) {
                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 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) {
                stopMoving();
                break;
              }
            }
          }
        }
        if (dataIn >= 16) {
          wheelSpeed = dataIn * 10;
          dataIn = 14;
        }
        if ( dataIn == 13) {
          //Serial.println("DEKI");
          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 behulp van de Android-applicatie, lijkt erg op elkaar en werkt op dezelfde manier. Hier moeten we in plaats van de radiomodule de Bluetooth-module definiëren en de communicatie initialiseren in de setup-sectie. Dus nogmaals, we lezen eerst de binnenkomende gegevens van de smartphone of de Android-app en vertellen de robot in welke richting hij moet bewegen.

Als we naar de Android-app kijken, kunnen we zien dat deze eenvoudig nummers van 0 tot 15 via Bluetooth verzendt wanneer de knoppen worden ingedrukt.

The app is made using the MIT App Inventor online application and you can find more details about it in my particular tutorial for it.

Here you can download this app as well as the editable project file:

For programming the automatic robot movement with this app, when we press the “SAVE” button we simply store the current positions of the stepper motors into arrays. Then when we press the “RUN” button, we call the runSteps() custom function which executes or runs through all stored steps using some for and while loops.

I hope you enjoyed this tutorial and learned something new. Stel gerust een vraag in de opmerkingen hieronder en bekijk mijn Arduino Projects-collectie.