Arduino Mecanum Wheels Roboter

In diesem Tutorial lernen wir, wie man einen Arduino Mecanum Wheels Robot baut, der sich in jede Richtung bewegen kann. Diese einzigartige Mobilität des Roboters wird durch die Verwendung spezieller Räder erreicht, die als Mecanum-Räder bezeichnet werden.

Sie können sich das folgende Video ansehen oder das schriftliche Tutorial unten lesen.

Übersicht

Ich habe diese Räder tatsächlich entworfen und in 3D gedruckt, weil sie in der Anschaffung etwas teuer sein können. Sie funktionieren ganz gut und ich muss sagen, dass das Fahren dieser Roboterplattform so viel Spaß macht. Wir können den Roboter mit den NRF24L01-Funk-Transceiver-Modulen drahtlos steuern, oder in meinem Fall verwende ich meinen DIY-RC-Sender, den ich in einem meiner vorherigen Videos gemacht habe.

Ich habe es auch möglich gemacht, mit einem Smartphone über Bluetooth-Kommunikation gesteuert zu werden. Ich habe eine benutzerdefinierte Android-Anwendung erstellt, mit der wir den Mecanum-Räderroboter so steuern können, dass er sich in jede Richtung bewegt. Außerdem können wir mit dem Schieberegler in der App die Bewegungsgeschwindigkeit steuern.

Das Gehirn dieser Roboterplattform ist ein Arduino Mega Board, das jedes Rad einzeln steuert. Jedes Rad ist an einem NEMA 17-Schrittmotor befestigt, und da ich wusste, dass Schrittmotoren präzise gesteuert werden können, fügte ich der App eine weitere coole Funktion hinzu, mit der wir den Roboter so programmieren können, dass er sich automatisch bewegt. Mit der Schaltfläche Speichern können wir jede Position oder jeden Schritt speichern und der Roboter kann diese Schritte automatisch ausführen und wiederholen. Mit derselben Taste können wir den automatischen Betrieb pausieren sowie alle Schritte zurücksetzen oder löschen, um neue zu speichern.

Mecanum Wheels Roboter 3D-Modell

Zunächst habe ich diesen Mecanum Wheels-Roboter mit einer 3D-Modellierungssoftware entworfen. Die Basisplattform dieses Roboters ist eine einfache Box, die ich aus 8 mm dicken MDF-Platten machen werde.

Die vier Schrittmotoren sind an dieser Plattform befestigt und die Mecanum-Räder sind an den Wellen des Motors befestigt.

Sie können dieses 3D-Modell finden und herunterladen sowie es in Ihrem Browser auf Thangs erkunden.

Laden Sie das 3D-Modell der Baugruppe von Thangs herunter.

STL-Dateien für den 3D-Druck:

Wie Mecanum-Räder funktionieren

Ein Mecanum-Rad ist ein Rad, an dessen Umfang Rollen angebracht sind. Diese Rollen sind diagonal oder in einem 45-Grad-Winkel zur Rotationsachse des Rads positioniert. Dadurch übt das Rad eine Kraft in diagonaler Richtung aus, wenn es sich vorwärts oder rückwärts bewegt.

Indem wir also die Räder in einem bestimmten Muster drehen, nutzen wir diese diagonalen Kräfte und somit kann sich der Roboter in jede Richtung bewegen.

Wir sollten hier auch beachten, dass wir zwei Arten von Mecanum-Rädern benötigen, die oft als linkshändige und rechtshändige Mecanum-Räder bezeichnet werden. Der Unterschied zwischen ihnen besteht in der Ausrichtung der Rollen und sie müssen an bestimmten Stellen im Roboter installiert werden. Die Rotationsachse der oberen Rolle jedes Rads sollte auf die Mitte des Roboters zeigen.

Hier ist eine kurze Demonstration, wie sich Roboter in Abhängigkeit von der Drehrichtung der Räder bewegen.

Wenn sich alle vier Räder vorwärts bewegen, ist die resultierende Bewegung des Roboters vorwärts, und umgekehrt, wenn sich alle Räder rückwärts bewegen, bewegt sich der Roboter rückwärts. Um sich nach rechts zu bewegen, müssen sich die rechten Räder innerhalb des Roboters drehen, während sich die linken Räder außerhalb des Roboters drehen müssen. Die resultierende Kraft aufgrund der diagonal angeordneten Rollen bewegt den Roboter nach rechts. Dasselbe, aber das Gegenteil passiert, wenn Sie sich nach links bewegen. Mit diesen Rädern können wir auch eine Bewegung in diagonaler Richtung erreichen, indem wir nur zwei Räder drehen.

Herstellung des Mecanum Wheels-Roboters

Lassen Sie mich Ihnen jetzt trotzdem zeigen, wie ich diese Roboterplattform gebaut habe. Wie ich bereits erwähnt habe, verwende ich für die Herstellung der Basis der Plattform 8-mm-Tick-MDF-Platten. Mit einer Tischkreissäge schneide ich zuerst alle Teile gemäß den Abmessungen des 3D-Modells.

Als nächstes habe ich mit einem 3mm Bohrer und einem 25mm Forstnerbohrer die Öffnungen an den Seitenwänden zum Anbringen der Schrittmotoren gemacht. Nachdem ich die Teile fertig hatte, fuhr ich mit dem Zusammenbau fort. Ich benutzte einen Holzleim und einige Schrauben, um sie zu befestigen. Das Wichtigste dabei ist, die Öffnungen für die Motoren passgenau anfertigen zu lassen, damit später alle Räder gleichmäßigen Kontakt zum Untergrund haben.

Natürlich könnten Sie diese Basisplattform auch in 3D drucken, anstatt sie mit MDF herzustellen, daher werde ich eine 3D-Datei davon in den Website-Artikel aufnehmen. Schließlich habe ich die Basis und die Abdeckung mit weißer Farbe besprüht.

Als nächstes kommen die Mecanum-Räder. Wie ich bereits sagte, können diese Räder in der Anschaffung etwas teuer sein, deshalb habe ich mich entschieden, meine eigenen zu entwerfen und in 3D zu drucken. Die Räder bestehen aus zwei Teilen, Außen- und Innenseite, die mit einigen M4-Schrauben und Muttern zusammengehalten werden. Sie haben jeweils 10 Rollen und eine Wellenkupplung, die speziell für einen NEMA 17-Schrittmotor ausgelegt ist.

Ich habe alle Teile für die Mecanum-Räder mit meinem Creality CR-10 3D-Drucker in 3D gedruckt.

Hier ist ein Link zu diesem 3D-Drucker, falls Sie ihn ausprobieren möchten.

Nachdem ich also die 3D-gedruckten Teile fertig hatte, machte ich weiter mit der Herstellung der Wellen für die Walzen. Dazu habe ich 3 mm dicken Stahldraht verwendet. Die Länge der Wellen muss etwa 40 mm betragen, also schneide ich den Draht mit einem Drehwerkzeug auf diese Länge.

Ich begann mit der Montage des Mecanum-Rades, indem ich die beiden Seiten und die Wellenkupplung mit vier M4-Schrauben und Muttern befestigte. Die Länge der Bolzen muss 45 mm betragen.

Um die Rollen zu montieren, müssen wir zuerst die Welle leicht durch die Löcher führen, die sich am Umfang der Innenseite befinden.

Dann können wir eine kleine M3-Unterlegscheibe einsetzen, die Rolle einsetzen und die Welle bis zum Anschlag in den Schlitz der Außenseite des Rads schieben. Ich habe eine einzelne Unterlegscheibe verwendet, weil ich nicht genug Platz hatte, um eine zweite Unterlegscheibe auf der anderen Seite einzusetzen.

Ich wiederholte diesen Vorgang für alle 10 Walzen. Es ist eigentlich einfach und macht Spaß, diese Räder zusammenzubauen. Wichtig dabei ist, dass sich die Rollen frei bewegen können.

Am Ende habe ich in jedes der inneren Löcher ein paar Tropfen AC-Kleber aufgetragen, um sicherzustellen, dass sich die Wellen nicht lösen.

Ok, sobald die Räder fertig sind, können wir mit dem Zusammenbau des ganzen Roboters fortfahren. Zuerst müssen wir die Schrittmotoren an der Basisplattform befestigen. Zur Befestigung habe ich M3-Schrauben mit einer Länge von 12 mm verwendet.

Als nächstes müssen wir die Räder an den Wellen des Motors befestigen. Die Wellenkupplung, die ich gemacht habe, hat einen Schlitz zum Einsetzen einer M3-Mutter, durch die eine M3-Schraube hindurchgehen kann, und so können wir das Rad an der Welle befestigen.

Als nächstes befestigte ich zur Befestigung der oberen Abdeckung an der Basis Gewindestangen an zwei Ecken der Basis. Ich habe Löcher an der gleichen Position in der Abdeckung gemacht und so konnte ich die Abdeckung einfach einsetzen und an der Basis befestigen.

Auf der Rückseite des Sockels habe ich ein 20-mm-Loch zum späteren Anbringen eines Netzschalters sowie ein 5-mm-Loch zum Anbringen einer LED gemacht.

Schaltplan

Jetzt können wir mit der Elektronik weitermachen. Hier ist der vollständige Schaltplan dieses Projekts.

Wir werden also die vier NEMA 17-Schrittmotoren mit vier DRV8825-Schritttreibern steuern, oder wir könnten auch die A4988-Schritttreiber verwenden. Für die Stromversorgung der Stepper und des gesamten Roboters verwenden wir eine 12-V-Stromversorgung, und in meinem Fall verwende ich einen 3S-Li-Po-Akku, der etwa 12 V liefert. Für die Funkkommunikation verwenden wir das NRF24L01-Modul und für die Bluetooth-Kommunikation das HC-05 Bluetooth-Modul. Ich habe auch einen einfachen Spannungsteiler eingebaut, der zur Überwachung der Batteriespannung verwendet wird, und einen LED-Anschluss, um anzuzeigen, wenn die Batteriespannung unter 11 V fällt.

Ich habe auch einen dedizierten 5-V-Spannungsregler eingebaut, der etwa 3 A Strom liefern kann. Dies ist optional, aber ich plane in einem zukünftigen Video, dieses Projekt mit meinem Arduino Robot Arm-Projekt zu kombinieren, und zu diesem Zweck würde ich 5 V zum Antreiben seiner Servomotoren benötigen.

Die für dieses Projekt benötigten Komponenten erhalten Sie über die folgenden Links:

• Schrittmotor – NEMA 17………………
• DRV8825 Schrittmotortreiber …………………
• NRF24L01 Transceiver-Modul …….…
• HC-05 Bluetooth-Modul …………….…
• Li-Po-Akku …………………………….……
• Arduino-Mega-Board ………………….…

PCB-Design

Um die elektronischen Komponenten dennoch organisiert zu halten und das Kabelsalat zu beseitigen, habe ich mit der kostenlosen Online-Schaltungsdesign-Software EasyEDA eine benutzerdefinierte Leiterplatte entworfen. Diese Platine fungiert tatsächlich als Arduino MEGA-Schild, da wir sie direkt auf der Arduino Mega-Platine anschließen können. Ich habe sowohl die obere als auch die untere Schicht zum Ausführen der Verbindungen verwendet. Für die Arduno-Pins, die ich nicht verwendet habe, habe ich Pin-Header-Verbindungen eingefügt, damit sie verfügbar sind, falls wir sie in Zukunft für etwas verwenden möchten. Ich habe auch 12-V-, 5-V- und GND-Anschlussstifte sowie Stifte zur Auswahl der Schrittauflösung der Treiber hinzugefügt.

Hier ist ein Link zu den Projektdateien dieses PCB-Designs. Als ich also mit dem Design fertig war, generierte ich die Gerber-Datei, die für die Herstellung der Leiterplatte benötigt wurde.

Gerber-Datei:

Dann bestellte ich die Platine bei JLCPCB, die auch der Sponsor dieses Videos sind.

Hier können wir die Gerber-Datei einfach per Drag-and-Drop ziehen und nach dem Hochladen können wir unser PCB im Gerber-Viewer überprüfen. Wenn alles in Ordnung ist, können wir fortfahren und die gewünschten Eigenschaften für unsere Leiterplatte auswählen. Dieses Mal habe ich die PCB-Farbe blau gewählt, um mit der Farbe der Arduino-Platine übereinzustimmen. Und das war's, jetzt können wir unsere Leiterplatte einfach zu einem günstigen Preis bestellen. Beachten Sie, dass Sie bei Ihrer ersten Bestellung bei JLCPCB bis zu 10 PCBs für nur 2 $ erhalten können.

Nach einigen Tagen sind die Leiterplatten eingetroffen. Die Qualität der Leiterplatten ist super und alles ist genau so wie im Design.

Montage der Leiterplatte

Ok, jetzt können wir weitermachen und die Platine zusammenbauen. Ich begann mit dem Löten der kleineren Komponenten zuerst, der Widerstände und der Kondensatoren. Dann habe ich Stiftleisten auf die Platine gesteckt und gelötet, die zum Anschluss an die Arduino-Platine verwendet werden.

Als nächstes platzierte ich alle Buchsenleisten und lötete sie auch. Wie für die Schrittmotoranschlüsse und Pins zur Auswahl der Schrittauflösung habe ich männliche Stiftleisten verwendet. Auf diese Weise können wir die Motoren direkt an die Platine anschließen und Jumper zur Auswahl der Schrittauflösung verwenden. Dann habe ich die Klemmenblöcke, den Trimmer und den Spannungsregler gelötet.

Und das war's, die Platine ist jetzt fertig und wir können mit dem Einsetzen der Treiber und dem Anschließen der Motoren fortfahren. Zuerst habe ich die Jumper für die Auswahl der Schrittauflösung platziert. Ich habe die 16. Schrittauflösung ausgewählt, indem ich die MS3-Pins der Treiber mit 5 V verbunden habe.

Darauf platzierte ich dann die DRV8825-Treiber und verband das NRF24L01-Modul und das HC-05-Bluetooth-Modul. Jetzt können wir die Platine einfach an der Arduno-Platine befestigen.

Als nächstes habe ich die Batterie an die entsprechende Klemmleiste angeschlossen und sie in die Basisplattform eingesetzt.

Hier steckte ich den Netzschalter ein und verband ihn mit der anderen Klemmleiste. Direkt über dem Netzschalter habe ich auch die Batterieanzeige-LED eingefügt.

Jetzt müssen nur noch die Motoren mit der Platine verbunden werden. Wir sollten hier beachten, dass wir beim Anschließen gegenüberliegender Motoren auch deren Anschlüsse gegenüberliegend anschließen sollten. Dies wird später beim Programmieren des Roboters benötigt, damit beispielsweise der Vorwärtsbefehl beide Motoren in die gleiche Richtung bewegt, obwohl sie eigentlich umgedreht sind und der eine im Uhrzeigersinn und der andere gegen den Uhrzeigersinn dreht.

Am Ende kann ich einfach die Abdeckung oben einsetzen, und fertig sind wir mit diesem Mecanum Wheels Roboterprojekt.

Arduino-Code für Roboter mit Mecanum-Rädern

Was für dieses Video übrig bleibt, ist, einen Blick auf den Arduino-Code zu werfen. Eigentlich gibt es zwei separate Arduino-Codes. Dieser dient zur Steuerung des Roboters mit den NRF24L01-Modulen und der andere zur Steuerung des Roboters mit einem Smartphone.

Arduino-Code zur Steuerung des Roboters mit den NRF24L01-Modulen:

/* === 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; } Codesprache:Arduino (arduino)

Beschreibung: Hier verwenden wir also die RF24-Bibliothek für die Funkkommunikation und die AccelStepper-Bibliothek für die Steuerung der Schrittmotoren. Zuerst müssen wir die Pins definieren, mit denen sie alle verbunden sind, einige Variablen definieren, die für das Programm unten benötigt werden, und im Setup-Bereich die maximale Geschwindigkeit des Steppers einstellen und die Funkkommunikation beginnen.

Im Schleifenabschnitt beginnen wir mit dem Lesen der Daten, die vom RC-Sender kommen. Den Code des RC-Senders sowie weitere Details, wie diese Kommunikation funktioniert, finden Sie in meinem speziellen Tutorial dazu.

Abhängig von den empfangenen Daten, wenn beispielsweise der linke Joystick nach vorne bewegt wird, ist sein Wert größer als 160 und ruft in einem solchen Fall die benutzerdefinierte Funktion moveForward() auf. Wenn wir uns diese Funktion ansehen, können wir sehen, dass sie lediglich die Geschwindigkeit der Motoren auf positiv setzt. Für die Rückwärtsfahrt wird die Geschwindigkeit auf negativ gesetzt. Um sich in alle anderen Richtungen zu bewegen, müssen wir also nur die Rotation der Räder entsprechend einstellen, wie am Anfang erklärt.

Um diese Befehle auszuführen, müssen wir im Schleifenabschnitt die runSpeed ​​() -Funktionen für alle Stepper aufrufen. Im Schleifenabschnitt lesen wir auch den analogen Eingang des Spannungsteilers, der von der Batterie kommt, und anhand dieses Werts können wir wissen, wann die Batteriespannung unter 11 V fallen wird, damit wir die Anzeige-LED einschalten können.

Arduino-Code zur Steuerung des Roboters mit einem 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);
} Codesprache:Arduino (arduino) 

Beschreibung: Der andere Code zur Steuerung des Roboters mit der Android-Anwendung ist sehr ähnlich und funktioniert auf die gleiche Weise. Hier müssen wir anstelle des Funkmoduls das Bluetooth-Modul definieren und seine Kommunikation im Setup-Bereich initialisieren. Also lesen wir zuerst die eingehenden Daten vom Smartphone oder der Android-App aus und sagen dem Roboter entsprechend, in welche Richtung er sich bewegen soll.

Wenn wir uns die Android-App ansehen, können wir sehen, dass sie einfach Zahlen von 0 bis 15 über Bluetooth sendet, wenn die Tasten gedrückt werden.

Die App wird mit der Online-Anwendung MIT App Inventor erstellt und Sie können weitere Details dazu in meinem speziellen Tutorial dafür finden.

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.

Ich hoffe, Ihnen hat dieses Tutorial gefallen und Sie haben etwas Neues gelernt. Fühlen Sie sich frei, Fragen im Kommentarbereich unten zu stellen und sehen Sie sich meine Arduino-Projektsammlung an.

Automatischer Betrieb der Arduino-Roboterarm- und Mecanum-Räderplattform DIY-Arduino-Gimbal | Selbststabilisierende Plattform