Robot à roues Arduino Mecanum
Dans ce tutoriel, nous allons apprendre à construire un robot Arduino Mecanum Wheels capable de se déplacer dans n'importe quelle direction. Cette mobilité unique du robot est obtenue en utilisant un type spécial de roues, appelée Mecanum Wheels.
Vous pouvez regarder la vidéo suivante ou lire le didacticiel écrit ci-dessous.
J'ai en fait conçu et imprimé en 3D ces roues car elles peuvent être un peu chères à l'achat. Ils fonctionnent plutôt bien et je dois dire que conduire cette plate-forme robotique est tellement amusant. Nous pouvons contrôler le robot sans fil à l'aide des modules émetteurs-récepteurs radio NRF24L01, ou dans mon cas, j'utilise mon émetteur RC DIY que j'ai fabriqué dans l'une de mes vidéos précédentes.
J'ai également rendu possible le contrôle à l'aide d'un smartphone via une communication Bluetooth. J'ai créé une application Android personnalisée à travers laquelle nous pouvons contrôler le robot à roues Mecanum pour qu'il se déplace dans n'importe quelle direction. De plus, en utilisant le curseur de l'application, nous pouvons contrôler la vitesse de déplacement.
Le cerveau de cette plate-forme robotique est une carte Arduino Mega qui contrôle chaque roue individuellement. Chaque roue est fixée sur un moteur pas à pas NEMA 17, et sachant que les moteurs pas à pas peuvent être contrôlés avec précision, j'ai ajouté une autre fonctionnalité intéressante dans l'application grâce à laquelle nous pouvons programmer le robot pour qu'il se déplace automatiquement. En utilisant le bouton Enregistrer, nous pouvons enregistrer chaque position ou étape, puis le robot peut automatiquement exécuter et répéter ces étapes. Avec le même bouton, nous pouvons mettre en pause le fonctionnement automatique ainsi que réinitialiser ou supprimer toutes les étapes afin de pouvoir en stocker de nouvelles.
Pour commencer, j'ai conçu ce robot Mecanum Wheels à l'aide d'un logiciel de modélisation 3D. La plate-forme de base de ce robot est une simple boîte que je fabriquerai à partir de panneaux MDF de 8 mm.
Les quatre moteurs pas à pas sont fixés à cette plate-forme et les roues Mecanum sont fixées aux arbres du moteur.
Vous pouvez trouver et télécharger ce modèle 3D, ainsi que l'explorer dans votre navigateur sur Thangs.
Téléchargez le modèle 3D d'assemblage à partir de Thangs.
Fichiers STL pour l'impression 3D :
Une roue Mecanum est une roue avec des rouleaux attachés à sa circonférence. Ces rouleaux sont positionnés en diagonale ou à 45 degrés par rapport à l'axe de rotation de la roue. Cela fait que la roue exerce une force dans la direction diagonale lors du déplacement vers l'avant ou vers l'arrière.
Ainsi, en faisant tourner les roues selon un certain schéma, nous utilisons ces forces diagonales et ainsi le robot peut se déplacer dans n'importe quelle direction.
Nous devons également noter ici que nous avons besoin de deux types de roues Mecanum, souvent appelées roues Mecanum pour gaucher et droitier. La différence entre eux est l'orientation des rouleaux et ils doivent être installés dans le robot à des endroits spécifiques. L'axe de rotation du rouleau supérieur de chaque roue doit pointer vers le centre du robot.
Voici une démonstration rapide de la façon dont le robot se déplace en fonction du sens de rotation des roues.
Si les quatre roues avancent, le mouvement résultant du robot sera vers l'avant, et vice versa si toutes les roues reculent, le robot reculera. Pour se déplacer vers la droite, les roues droites doivent tourner à l'intérieur du robot, tandis que les roues gauches doivent tourner à l'extérieur du robot. La force résultante due aux rouleaux positionnés en diagonale fera déplacer le robot vers la droite. La même chose mais l'inverse se produit lorsque vous vous déplacez vers la gauche. Avec ces roues, nous pouvons également obtenir un mouvement dans le sens diagonal en ne faisant tourner que deux roues.
Néanmoins, laissez-moi maintenant vous montrer comment j'ai construit cette plate-forme robotique. Comme je l'ai mentionné, pour fabriquer la base de la plate-forme, j'utilise des panneaux MDF de 8 mm. À l'aide d'une scie à table, j'ai d'abord coupé toutes les pièces selon les dimensions du modèle 3D.
Ensuite, à l'aide d'une perceuse de 3 mm et d'un foret Forstner de 25 mm, j'ai fait les ouvertures sur les panneaux latéraux pour fixer les moteurs pas à pas. Une fois les pièces prêtes, j'ai continué à les assembler. J'ai utilisé une colle à bois et quelques vis pour les fixer. La chose la plus importante ici est que les ouvertures pour les moteurs soient faites avec précision afin que toutes les roues aient un contact uniforme avec la surface plus tard.
Bien sûr, vous pouvez également imprimer en 3D cette plate-forme de base, au lieu de la fabriquer en MDF, j'en inclurai donc un fichier 3D dans l'article du site Web. Enfin, j'ai peint à la bombe la base et sa couverture de couleur blanche.
Viennent ensuite les roues Mecanum. Comme je l'ai dit plus tôt, ces roues peuvent être un peu chères à l'achat, c'est pourquoi j'ai décidé de concevoir et d'imprimer les miennes en 3D. Les roues sont constituées de deux parties, côté extérieur et côté intérieur, qui sont fixées ensemble avec des boulons et des écrous M4. Ils ont 10 rouleaux chacun et un coupleur d'arbre spécialement conçu pour s'adapter à un moteur pas à pas NEMA 17.
J'ai imprimé en 3D toutes les pièces des roues Mecanum à l'aide de mon imprimante 3D Creality CR-10.
Voici un lien vers cette imprimante 3D au cas où vous voudriez la vérifier.
Donc, une fois que j'ai préparé les pièces imprimées en 3D, je suis passé à la fabrication des arbres pour les rouleaux. Pour cela, j'ai utilisé du fil d'acier de 3 mm d'épaisseur. La longueur des tiges doit être d'environ 40 mm, donc à l'aide d'un outil rotatif, j'ai coupé le fil à cette longueur.
J'ai commencé à assembler la roue Mecanum en fixant les deux côtés et le coupleur d'arbre à l'aide de quatre boulons et écrous M4. La longueur des boulons doit être de 45 mm.
Pour installer les rouleaux, nous devons d'abord insérer légèrement l'arbre à travers les trous situés à la circonférence du côté intérieur.
Ensuite, nous pouvons insérer une petite rondelle M3, insérer le rouleau et pousser l'arbre à fond dans la fente du côté extérieur de la roue. J'ai utilisé une seule rondelle car je n'avais pas assez d'espace pour insérer une deuxième rondelle de l'autre côté.
J'ai répété ce processus pour les 10 rouleaux. C'est en fait facile et amusant d'assembler ces roues. Ce qui est important ici, c'est que les rouleaux doivent pouvoir bouger librement.
À la fin, j'ai utilisé quelques gouttes de colle AC dans chacun des trous intérieurs pour m'assurer que les tiges ne se détachent pas.
Ok, une fois les roues prêtes, nous pouvons passer à l'assemblage de l'ensemble du robot. Tout d'abord, nous devons attacher les moteurs pas à pas à la plate-forme de base. Pour les fixer en place, j'ai utilisé des boulons M3 d'une longueur de 12 mm.
Ensuite, nous devons attacher les roues aux arbres du moteur. Le coupleur d'arbre que j'ai fabriqué a une fente pour insérer un écrou M3, à travers lequel un boulon M3 peut passer et ainsi nous pouvons fixer la roue à l'arbre.
Ensuite, pour fixer le capot supérieur à la base, j'ai attaché des tiges filetées aux deux coins de la base. J'ai fait des trous au même endroit sur le couvercle et j'ai donc pu facilement insérer et fixer le couvercle à la base.
Au dos de la base, j'ai fait un trou de 20 mm pour fixer un interrupteur d'alimentation plus tard, ainsi qu'un trou de 5 mm pour fixer une LED.
Maintenant, nous pouvons passer à l'électronique. Voici le schéma de circuit complet de ce projet.
Nous allons donc contrôler les quatre moteurs pas à pas NEMA 17 à l'aide de quatre pilotes pas à pas DRV8825, ou nous pourrions également utiliser les pilotes pas à pas A4988. Pour alimenter les steppers et l'ensemble du robot, nous utiliserons une alimentation 12V, et dans mon cas, j'utiliserai une batterie Li-Po 3S qui fournit environ 12V. Pour la communication radio, nous utilisons le module NRF24L01 et pour la communication Bluetooth, nous utilisons le module Bluetooth HC-05. J'ai également inclus un simple diviseur de tension qui sera utilisé pour surveiller la tension de la batterie et une connexion LED pour indiquer quand la tension de la batterie descendra en dessous de 11 V.
J'ai également inclus un régulateur de tension dédié de 5V qui peut fournir environ 3A de courant. Ceci est facultatif, mais je prévois dans une future vidéo de combiner ce projet avec mon projet Arduino Robot Arm, et à cette fin j'aurais besoin de 5V pour piloter ses servomoteurs.
Vous pouvez obtenir les composants nécessaires à ce projet à partir des liens ci-dessous :
Néanmoins, afin de garder les composants électroniques organisés et de se débarrasser du désordre de câblage, j'ai conçu un circuit imprimé personnalisé à l'aide du logiciel de conception de circuits en ligne gratuit EasyEDA. Ce PCB agira en fait comme un blindage Arduino MEGA car nous pourrons le connecter directement au-dessus de la carte Arduino Mega. J'ai utilisé à la fois la couche supérieure et la couche inférieure pour exécuter les connexions. Pour les broches Arduno que je n'ai pas utilisées, j'ai inclus des connexions d'en-tête de broche afin qu'elles soient disponibles au cas où nous voudrions les utiliser pour quelque chose à l'avenir. J'ai également inclus des broches de connexion 12V, 5V et GND, ainsi que des broches pour sélectionner la résolution pas à pas des pilotes.
Voici un lien vers les fichiers de projet de cette conception de PCB. Donc une fois la conception terminée, j'ai généré le fichier Gerber nécessaire à la fabrication du PCB.
Fichier Gerber :
Ensuite, j'ai commandé le PCB à JLCPCB qui est également le sponsor de cette vidéo.
Ici, nous pouvons simplement faire glisser et déposer le fichier Gerber et une fois téléchargé, nous pouvons revoir notre PCB dans la visionneuse Gerber. Si tout va bien, nous pouvons continuer et sélectionner les propriétés que nous voulons pour notre PCB. Cette fois, j'ai choisi la couleur du PCB pour qu'elle soit bleue afin de correspondre à la couleur de la carte Arduino. Et voilà, maintenant nous pouvons simplement commander notre PCB à un prix raisonnable. Notez que s'il s'agit de votre première commande auprès de JLCPCB, vous pouvez obtenir jusqu'à 10 PCB pour seulement 2 $.
Après plusieurs jours, les PCB sont arrivés. La qualité des PCB est excellente et tout est exactement comme dans la conception.
Ok maintenant nous pouvons passer à autre chose et assembler le PCB. J'ai commencé par souder d'abord les composants les plus petits, les résistances et les condensateurs. Ensuite, j'ai inséré et soudé des en-têtes de broches mâles sur le PCB qui seront utilisés pour le connecter à la carte Arduino.
Ensuite, j'ai placé tous les en-têtes de broches femelles en place et les ai également soudés. En ce qui concerne les connexions des moteurs pas à pas et les broches pour sélectionner la résolution pas à pas, j'ai utilisé des en-têtes de broches mâles. De cette façon, nous pouvons connecter directement les moteurs au PCB et utiliser des cavaliers pour sélectionner la résolution pas à pas. Ensuite j'ai soudé les borniers, le trimmer et le régulateur de tension.
Et voilà, le PCB est maintenant prêt et nous pouvons passer à l'insertion des pilotes et à la connexion des moteurs. Tout d'abord, j'ai placé les cavaliers pour sélectionner la résolution de progression. J'ai sélectionné la résolution de 16e étape en connectant les broches MS3 des pilotes à 5V.
Ensuite, au-dessus d'eux, j'ai placé les pilotes DRV8825, ainsi que connecté le module NRF24L01 et le module Bluetooth HC-05. Maintenant, nous pouvons simplement attacher le PCB à la carte Arduno.
Ensuite, j'ai connecté la batterie au bornier approprié et je les ai placées dans la plate-forme de base.
Ici, j'ai inséré l'interrupteur d'alimentation en place et l'ai connecté à l'autre bornier. Juste au-dessus de l'interrupteur d'alimentation, j'ai également inséré le voyant de la batterie.
Il ne reste plus qu'à connecter les moteurs au PCB. Nous devons noter ici que lors de la connexion de moteurs opposés, nous devons également connecter leurs connecteurs en face. Cela est nécessaire plus tard lors de la programmation du robot, de sorte que, par exemple, la commande avant déplace les deux moteurs dans la même direction, bien qu'ils soient en fait inversés et que l'un fasse une rotation dans le sens des aiguilles d'une montre et l'autre dans le sens inverse.
À la fin, je peux simplement insérer le couvercle en haut, et nous en avons terminé avec ce projet de robot Mecanum Wheels.
Ce qui reste pour cette vidéo est de jeter un œil au code Arduino. En fait, il existe deux codes Arduino distincts. Celui-ci sert à contrôler le robot à l'aide des modules NRF24L01 et l'autre sert à contrôler le robot à l'aide d'un smartphone.
Code Arduino pour contrôler le robot à l'aide des modules NRF24L01 :
Description : Nous utilisons donc ici la bibliothèque RF24 pour la communication radio et la bibliothèque AccelStepper pour le contrôle des moteurs pas à pas. Nous devons d'abord définir les broches auxquelles elles sont toutes connectées, définir certaines variables nécessaires au programme ci-dessous, et dans la section de configuration, définir la vitesse maximale des steppers et commencer la communication radio.
Dans la section boucle, nous commençons par lire les données provenant de l'émetteur RC. Le code de l'émetteur RC ainsi que plus de détails sur le fonctionnement de cette communication peuvent être trouvés sur mon tutoriel particulier pour cela.
Ainsi selon les données reçues, par exemple, si le Joystick gauche est avancé, sa valeur sera supérieure à 160 et dans ce cas appellera la fonction personnalisée moveForward(). Si nous jetons un coup d'œil à cette fonction, nous pouvons voir qu'elle ne fait que régler la vitesse des moteurs sur positive. Pour reculer, la vitesse est réglée sur négative. Donc, pour se déplacer dans toutes les autres directions, il suffit de régler les rotations des roues de manière appropriée, comme expliqué au début.
Pour exécuter ces commandes, dans la section loop, nous devons appeler les fonctions runSpeed() pour tous les steppers. Dans la section boucle, nous lisons également l'entrée analogique du diviseur de tension provenant de la batterie, et selon cette valeur, nous pouvons savoir quand la tension de la batterie chutera sous 11V afin que nous puissions allumer la LED d'indication.
Code Arduino pour contrôler le robot à l'aide d'un smartphone :
Description: The other code for controlling the robot using the Android application, is very similar and works the same way. Here instead of the radio module we need to define the Bluetooth module and initialize its communication in the setup section. So again, first we read the incoming data from the smartphone or the Android app, and according to it, tell the robot in which direction to move.
If we take a look at the Android app we can see that it simply sends numbers from 0 to 15 through the Bluetooth when the buttons are pressed.
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. Feel free to ask any question in the comments section below and check my Arduino Projects Collection.Aperçu
Modèle 3D du robot Mecanum Wheels
Comment fonctionnent les roues Mecanum
Fabriquer le robot Mecanum Wheels
Schéma du circuit
Conception de circuits imprimés
Assemblage du PCB
Code Arduino Robot Roues Mecanum
/*
=== 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)/*
=== 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)
Processus de fabrication
- Robot Raspberry Pi contrôlé par Bluetooth
- Obstacles pour éviter le robot avec servomoteur
- Robot suiveur de ligne
- Robot à commande vocale
- Robot piano contrôlé par Arduino :PiBot
- Littlearm 2C :Construire un bras de robot Arduino imprimé en 3D
- Robot assistant domestique autonome
- Contrôler le bras robotique Arduino avec l'application Android
- Robot pour une navigation intérieure super cool