Fonctionnement automatique du bras du robot Arduino et de la plate-forme Mecanum Wheels
Dans ce tutoriel, je vais vous montrer comment j'ai créé ma plate-forme robotique Mecanum Wheels à partir de ma vidéo précédente, pour qu'elle fonctionne ensemble et fonctionne automatiquement avec mon bras robotique imprimé en 3D, également un projet Arduino d'une de mes vidéos précédentes.
Vous pouvez regarder la vidéo suivante ou lire le didacticiel écrit ci-dessous.
Ainsi, nous pouvons contrôler le robot roues Mecanum avec l'application Android personnalisée de la même manière que celle expliquée dans la vidéo précédente. En plus de cela, l'application dispose désormais de boutons pour contrôler le bras du robot.
L'application originale de contrôle du bras du robot comportait en fait des curseurs pour contrôler les articulations du robot, mais cela posait des problèmes de stabilité du bras. De cette façon, le bras fonctionne beaucoup mieux, donc je fournirai également cette version mise à jour de l'application de contrôle du bras du robot et le code Arduino au projet de bras du robot d'origine.
Néanmoins, la caractéristique la plus intéressante de ce robot est la possibilité de stocker les mouvements puis de les répéter automatiquement.
À l'aide du bouton Enregistrer, nous pouvons simplement stocker les positions des moteurs pour chaque étape. Ensuite, il nous suffit de cliquer sur le bouton Exécuter et le robot répétera automatiquement les mouvements stockés encore et encore.
Ok, j'ai donc ici la plate-forme de roues Mecanum déjà assemblée et vous pouvez trouver tous les détails à ce sujet dans ma vidéo précédente.
De plus, j'ai ici les pièces imprimées en 3D du bras du robot et des servomoteurs et maintenant je vais vous montrer comment les assembler. Voici le modèle 3D de ce projet.
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 sur Thangs.
Fichiers STL pour l'impression 3D :
Le premier servo du bras du robot sera directement monté sur le capot supérieur de la plate-forme des roues mecanum.
J'ai marqué l'emplacement, et à l'aide d'un foret de 10 mm, j'ai fait plusieurs trous.
Ensuite, à l'aide d'une râpe, j'ai découpé les trous, puis j'ai affiné l'ouverture pour le servo. J'ai fixé le servo à la plaque supérieure à l'aide de quatre boulons et écrous M3.
Ensuite, sur cet arbre de sortie de ce servo, à l'aide du cornet rond fourni en accessoire avec le servo, nous devons fixer la partie suivante ou la taille du bras du robot. Cependant, on peut remarquer que de cette manière la pièce reste à environ 8mm au-dessus de la plaque. Donc, j'ai attaché deux morceaux de panneaux MDF de 8 mm, afin que la partie de la taille puisse glisser dessus et que le joint soit plus stable.
Le klaxon rond est fixé à la ceinture à l'aide des vis autotaraudeuses fournies en tant qu'accessoires avec le servo, puis le klaxon rond est fixé à l'arbre du servo à l'aide des boulons appropriés qui sont également fournis avec le servo.
Ensuite, nous avons le servo d'épaule. Nous le mettons simplement en place et le fixons à la pièce imprimée en 3D à l'aide de vis autotaraudeuses.
Le klaxon rond va sur la partie suivante, puis les deux parties sont fixées l'une à l'autre à l'aide d'un boulon sur l'arbre de sortie du servo.
Nous devons noter qu'avant de fixer les pièces, nous devons nous assurer que la pièce a toute l'amplitude de mouvement. Ici, j'ai également ajouté un élastique à l'articulation de l'épaule afin d'aider un peu le servo, car ce servo supporte le poids du reste du bras ainsi que la charge utile.
De la même manière, j'ai assemblé le reste du bras du robot.
Ensuite, nous devons assembler le mécanisme de préhension. Le préhenseur est contrôlé par un servomoteur SG90, sur lequel nous attachons d'abord un lien d'engrenage conçu sur mesure. Nous associons ce lien avec un autre lien à engrenage de l'autre côté, qui est fixé à l'aide de boulons et d'écrous M4. En fait, tous les autres maillons sont connectés à l'aide de boulons et d'écrous M4.
Le modèle 3D de la pince avait à l'origine des trous de 3 mm, mais je n'avais pas assez de boulons M3. J'ai donc élargi les trous à l'aide d'un foret de 4 mm et j'ai utilisé les boulons M4 à la place.
Une fois que j'ai assemblé le mécanisme de préhension, je l'ai fixé au dernier servo et ainsi le bras du robot était terminé.
Ensuite, j'ai fait de la gestion des câbles. J'ai passé les câbles du servo à travers les trous spécialement conçus du bras du robot. À l'aide d'une perceuse de 10 mm, j'ai percé un trou sur la plaque supérieure afin que les fils puissent passer.
À l'aide d'une attache zippée, j'ai fixé tous les fils ensemble, et il ne reste plus qu'à les connecter à la carte Arduino.
Voici le schéma de circuit de ce projet et comment tout doit être connecté.
Vous pouvez obtenir les composants nécessaires à ce projet à partir des liens ci-dessous :
Dans le tutoriel précédent, j'ai expliqué le fonctionnement de la partie robot Mecanum wheels et je vous ai également montré comment j'ai créé un PCB personnalisé pour cela.
J'ai inclus un régulateur de tension 5V sur ce PCB afin que nous puissions réaliser ce projet, ou connecter les servomoteurs car ils fonctionnent à 5V. Le régulateur de tension est le LM350, qui peut gérer jusqu'à 3 ampères de courant. Les six servos du bras du robot peuvent tirer d'environ 2 ampères à 3 ampères de courant, ce qui signifie qu'il peut les gérer, mais cela entraînera une surchauffe du régulateur.
Par conséquent, j'y ai attaché un dissipateur de chaleur, ainsi qu'un petit ventilateur 12V DC pour souffler de l'air, car le dissipateur de chaleur lui-même n'était pas suffisant pour refroidir le régulateur.
J'ai connecté les fils de signal des servos aux broches numériques Arduino du numéro 5 à 10, et pour l'alimentation, j'ai utilisé l'en-tête de broche 5V sur le PCB. Enfin, j'ai poussé tous les fils à l'intérieur de la plate-forme et y ai fixé la plaque supérieure à l'aide des deux écrous.
Et voilà, nous en avons maintenant terminé avec ce projet.
Il ne reste plus qu'à voir comment fonctionnent le code Arduino et l'application Android. Comme le code est un peu plus long, pour une meilleure compréhension, je posterai le code source du programme dans des sections avec une description pour chaque section. Et à la fin de cet article, je posterai le code source complet.
Nous devons donc d'abord définir les 6 servos, les 4 moteurs pas à pas et la communication Bluetooth, ainsi que définir certaines variables nécessaires au programme ci-dessous. Dans la section de configuration, nous définissons la vitesse maximale des steppers, définissons les broches auxquelles les servos sont connectés, commençons la communication Bluetooth et réglons le bras du robot en position initiale.
Ensuite, dans la section de la boucle, nous commençons par vérifier s'il y a des données entrantes.
Ces données proviennent du smartphone ou de l'application Android, alors regardons quel type de données il envoie réellement. L'application Android est réalisée à l'aide de l'application en ligne MIT App Inventor. Il se compose de boutons simples qui ont des images appropriées en arrière-plan.
Si nous jetons un coup d'œil aux blocs de l'application, nous pouvons voir qu'elle ne fait qu'envoyer des nombres d'un octet lorsque les boutons sont cliqués.
Ainsi, en fonction du bouton cliqué, nous disons à l'Arduino quoi faire. Par exemple, si nous recevons le numéro "2", la plate-forme des roues mecanum avancera, en utilisant la fonction personnalisée moveForward.
Cette fonction personnalisée règle les quatre moteurs pas à pas pour qu'ils tournent vers l'avant.
Pour se déplacer dans n'importe quelle autre direction, il suffit de faire tourner les roues dans les directions appropriées.
Pour contrôler le bras du robot, nous utilisons la même méthode. Encore une fois, nous avons des boutons dans l'application et lorsque vous maintenez les boutons enfoncés, les articulations du bras du robot se déplacent dans la direction particulière.
Comme je l'ai mentionné plus tôt, dans l'application de contrôle Robot Arm d'origine, nous utilisions des curseurs pour contrôler les positions des servos, mais cela posait des problèmes car nous devions ainsi envoyer du texte à l'Arduino, au lieu d'un numéro à 1 octet. Le problème est que l'Arduino manque parfois le texte provenant de l'application et fait une erreur ou que le bras du robot tremble et se comporte de manière anormale.
De cette façon, nous envoyons simplement un seul numéro de 1 octet lorsqu'un bouton particulier est touché.
Le code Arduino entre dans la boucle while de ce numéro et y reste jusqu'à ce que nous touchions le bouton, car à ce moment-là, nous envoyons le numéro 0, ce qui signifie que le robot ne doit rien faire.
Ainsi, selon les boutons touchés, les servos se déplacent dans le sens positif ou négatif. Le même principe de fonctionnement s'applique à tous les servomoteurs. Pour modifier la vitesse de déplacement, nous utilisons les valeurs provenant du curseur qui vont de 100 à 250.
En les divisant par 10 on obtient des valeurs de 10 à 25, qui servent de retard en microsecondes dans les boucles whiles pour piloter les servos.
Pour stocker les mouvements du robot, nous enregistrons simplement les positions actuelles des servos et des moteurs pas à pas dans des tableaux, chaque fois que le bouton Enregistrer est cliqué.
Ensuite, lorsque nous appuyons sur le bouton Exécuter, nous appelons la fonction personnalisée runSteps(). Cette fonction personnalisée parcourt toutes les étapes stockées en utilisant des boucles for et while.
Nous devons noter qu'il commence à partir de la première position et va à la dernière position, et le répète encore et encore. Par conséquent, lors de l'enregistrement des étapes, nous devons en fait positionner le robot de manière à ce que la première étape ait la même position que la dernière étape. Tout en parcourant les étapes, nous pouvons également modifier la vitesse de la plate-forme et du bras du robot, ainsi que mettre en pause et réinitialiser toutes les étapes.
Ici, vous pouvez télécharger cette application ainsi que le fichier de projet modifiable :
Voici le code Arduino complet pour ce projet de robot Arduino :
C'est donc à peu près tout pour ce tutoriel. Le projet fonctionne bien, mais veuillez noter qu'il est loin d'être parfait. Les mouvements automatiques pourraient ne pas être aussi précis en raison du patinage des roues mécaniques ainsi que des mauvaises performances des servomoteurs. Ces servomoteurs bon marché peuvent également trembler ou trembler même lorsqu'ils ne bougent pas simplement parce qu'ils n'ont pas assez de force pour supporter le poids des pièces imprimées en 3D.
J'espère que vous avez apprécié ce tutoriel et appris quelque chose de nouveau. N'hésitez pas à poser des questions dans la section des commentaires ci-dessous et à consulter ma collection de projets Arduino.Aperçu
Construire le robot Arduino
Schéma du circuit du robot Arduino
Code Arduino
#include <SoftwareSerial.h>
#include <AccelStepper.h>
#include <Servo.h>
Servo servo01;
Servo servo02;
Servo servo03;
Servo servo04;
Servo servo05;
Servo servo06;
SoftwareSerial Bluetooth(A8, 38); // Arduino(RX, TX) - HC-05 Bluetooth (TX, RX)
// Define the stepper motors and the pins the will use
AccelStepper LeftBackWheel(1, 42, 43); // (Type:driver, STEP, DIR) - Stepper1
AccelStepper LeftFrontWheel(1, 40, 41); // Stepper2
AccelStepper RightBackWheel(1, 44, 45); // Stepper3
AccelStepper RightFrontWheel(1, 46, 47); // Stepper4
#define led 14
int wheelSpeed = 1500;
int lbw[50], lfw[50], rbw[50], rfw[50]; // arrays for storing positions/steps
int servo1Pos, servo2Pos, servo3Pos, servo4Pos, servo5Pos, servo6Pos; // current position
int servo1PPos, servo2PPos, servo3PPos, servo4PPos, servo5PPos, servo6PPos; // previous position
int servo01SP[50], servo02SP[50], servo03SP[50], servo04SP[50], servo05SP[50], servo06SP[50]; // for storing positions/steps
int speedDelay = 20;
int index = 0;
int dataIn;
int m = 0;
void setup() {
// Set initial seed values for the steppers
LeftFrontWheel.setMaxSpeed(3000);
LeftBackWheel.setMaxSpeed(3000);
RightFrontWheel.setMaxSpeed(3000);
RightBackWheel.setMaxSpeed(3000);
pinMode(led, OUTPUT);
servo01.attach(5);
servo02.attach(6);
servo03.attach(7);
servo04.attach(8);
servo05.attach(9);
servo06.attach(10);
Bluetooth.begin(38400); // Default baud rate of the Bluetooth module
Bluetooth.setTimeout(5);
delay(20);
Serial.begin(38400);
// Move robot arm to initial position
servo1PPos = 90;
servo01.write(servo1PPos);
servo2PPos = 100;
servo02.write(servo2PPos);
servo3PPos = 120;
servo03.write(servo3PPos);
servo4PPos = 95;
servo04.write(servo4PPos);
servo5PPos = 60;
servo05.write(servo5PPos);
servo6PPos = 110;
servo06.write(servo6PPos);
}Code language: Arduino (arduino)// Check for incoming data
if (Bluetooth.available() > 0) {
dataIn = Bluetooth.read(); // Read the dataCode language: Arduino (arduino)
if (dataIn == 2) {
m = 2;
}
//
if (m == 2) {
moveForward();
}Code language: Arduino (arduino)void moveForward() {
LeftFrontWheel.setSpeed(wheelSpeed);
LeftBackWheel.setSpeed(wheelSpeed);
RightFrontWheel.setSpeed(wheelSpeed);
RightBackWheel.setSpeed(wheelSpeed);
}Code language: Arduino (arduino)
// Move servo 1 in positive direction
while (m == 16) {
if (Bluetooth.available() > 0) {
m = Bluetooth.read();
}
servo01.write(servo1PPos);
servo1PPos++;
delay(speedDelay);
}
// Move servo 1 in negative direction
while (m == 17) {
if (Bluetooth.available() > 0) {
m = Bluetooth.read();
}
servo01.write(servo1PPos);
servo1PPos--;
delay(speedDelay);
}Code language: Arduino (arduino)// If arm speed slider is changed
if (dataIn > 101 & dataIn < 250) {
speedDelay = dataIn / 10; // Change servo speed (delay time)
}Code language: Arduino (arduino)// If button "SAVE" is pressed
if (m == 12) {
//if it's initial save, set the steppers position to 0
if (index == 0) {
LeftBackWheel.setCurrentPosition(0);
LeftFrontWheel.setCurrentPosition(0);
RightBackWheel.setCurrentPosition(0);
RightFrontWheel.setCurrentPosition(0);
}
lbw[index] = LeftBackWheel.currentPosition(); // save position into the array
lfw[index] = LeftFrontWheel.currentPosition();
rbw[index] = RightBackWheel.currentPosition();
rfw[index] = RightFrontWheel.currentPosition();
servo01SP[index] = servo1PPos; // save position into the array
servo02SP[index] = servo2PPos;
servo03SP[index] = servo3PPos;
servo04SP[index] = servo4PPos;
servo05SP[index] = servo5PPos;
servo06SP[index] = servo6PPos;
index++; // Increase the array index
m = 0;
}Code language: Arduino (arduino)if (m == 14) {
runSteps();
// If button "RESET" is pressed
if (dataIn != 14) {
stopMoving();
memset(lbw, 0, sizeof(lbw)); // Clear the array data to 0
memset(lfw, 0, sizeof(lfw));
memset(rbw, 0, sizeof(rbw));
memset(rfw, 0, sizeof(rfw));
memset(servo01SP, 0, sizeof(servo01SP)); // Clear the array data to 0
memset(servo02SP, 0, sizeof(servo02SP));
memset(servo03SP, 0, sizeof(servo03SP));
memset(servo04SP, 0, sizeof(servo04SP));
memset(servo05SP, 0, sizeof(servo05SP));
memset(servo06SP, 0, sizeof(servo06SP));
index = 0; // Index to 0
}
}Code language: Arduino (arduino)/*
Arduino Robot Arm and Mecanum Wheels Robot
Smartphone Control via Bluetooth
by Dejan, www.HowToMechatronics.com
*/
#include <SoftwareSerial.h>
#include <AccelStepper.h>
#include <Servo.h>
Servo servo01;
Servo servo02;
Servo servo03;
Servo servo04;
Servo servo05;
Servo servo06;
SoftwareSerial Bluetooth(A8, 38); // Arduino(RX, TX) - HC-05 Bluetooth (TX, RX)
// Define the stepper motors and the pins the will use
AccelStepper LeftBackWheel(1, 42, 43); // (Type:driver, STEP, DIR) - Stepper1
AccelStepper LeftFrontWheel(1, 40, 41); // Stepper2
AccelStepper RightBackWheel(1, 44, 45); // Stepper3
AccelStepper RightFrontWheel(1, 46, 47); // Stepper4
#define led 14
int wheelSpeed = 1500;
int lbw[50], lfw[50], rbw[50], rfw[50]; // arrays for storing positions/steps
int servo1Pos, servo2Pos, servo3Pos, servo4Pos, servo5Pos, servo6Pos; // current position
int servo1PPos, servo2PPos, servo3PPos, servo4PPos, servo5PPos, servo6PPos; // previous position
int servo01SP[50], servo02SP[50], servo03SP[50], servo04SP[50], servo05SP[50], servo06SP[50]; // for storing positions/steps
int speedDelay = 20;
int index = 0;
int dataIn;
int m = 0;
void setup() {
// Set initial seed values for the steppers
LeftFrontWheel.setMaxSpeed(3000);
LeftBackWheel.setMaxSpeed(3000);
RightFrontWheel.setMaxSpeed(3000);
RightBackWheel.setMaxSpeed(3000);
pinMode(led, OUTPUT);
servo01.attach(5);
servo02.attach(6);
servo03.attach(7);
servo04.attach(8);
servo05.attach(9);
servo06.attach(10);
Bluetooth.begin(38400); // Default baud rate of the Bluetooth module
Bluetooth.setTimeout(5);
delay(20);
Serial.begin(38400);
// Move robot arm to initial position
servo1PPos = 90;
servo01.write(servo1PPos);
servo2PPos = 100;
servo02.write(servo2PPos);
servo3PPos = 120;
servo03.write(servo3PPos);
servo4PPos = 95;
servo04.write(servo4PPos);
servo5PPos = 60;
servo05.write(servo5PPos);
servo6PPos = 110;
servo06.write(servo6PPos);
}
void loop() {
// Check for incoming data
if (Bluetooth.available() > 0) {
dataIn = Bluetooth.read(); // Read the data
if (dataIn == 0) {
m = 0;
}
if (dataIn == 1) {
m = 1;
}
if (dataIn == 2) {
m = 2;
}
if (dataIn == 3) {
m = 3;
}
if (dataIn == 4) {
m = 4;
}
if (dataIn == 5) {
m = 5;
}
if (dataIn == 6) {
m = 6;
}
if (dataIn == 7) {
m = 7;
}
if (dataIn == 8) {
m = 8;
}
if (dataIn == 9) {
m = 9;
}
if (dataIn == 10) {
m = 10;
}
if (dataIn == 11) {
m = 11;
}
if (dataIn == 12) {
m = 12;
}
if (dataIn == 14) {
m = 14;
}
if (dataIn == 16) {
m = 16;
}
if (dataIn == 17) {
m = 17;
}
if (dataIn == 18) {
m = 18;
}
if (dataIn == 19) {
m = 19;
}
if (dataIn == 20) {
m = 20;
}
if (dataIn == 21) {
m = 21;
}
if (dataIn == 22) {
m = 22;
}
if (dataIn == 23) {
m = 23;
}
if (dataIn == 24) {
m = 24;
}
if (dataIn == 25) {
m = 25;
}
if (dataIn == 26) {
m = 26;
}
if (dataIn == 27) {
m = 27;
}
// Move the Mecanum wheels platform
if (m == 4) {
moveSidewaysLeft();
}
if (m == 5) {
moveSidewaysRight();
}
if (m == 2) {
moveForward();
}
if (m == 7) {
moveBackward();
}
if (m == 3) {
moveRightForward();
}
if (m == 1) {
moveLeftForward();
}
if (m == 8) {
moveRightBackward();
}
if (m == 6) {
moveLeftBackward();
}
if (m == 9) {
rotateLeft();
}
if (m == 10) {
rotateRight();
}
if (m == 0) {
stopMoving();
}
// Mecanum wheels speed
if (dataIn > 30 & dataIn < 100) {
wheelSpeed = dataIn * 20;
}
// Move robot arm
// Move servo 1 in positive direction
while (m == 16) {
if (Bluetooth.available() > 0) {
m = Bluetooth.read();
}
servo01.write(servo1PPos);
servo1PPos++;
delay(speedDelay);
}
// Move servo 1 in negative direction
while (m == 17) {
if (Bluetooth.available() > 0) {
m = Bluetooth.read();
}
servo01.write(servo1PPos);
servo1PPos--;
delay(speedDelay);
}
// Move servo 2
while (m == 19) {
if (Bluetooth.available() > 0) {
m = Bluetooth.read();
}
servo02.write(servo2PPos);
servo2PPos++;
delay(speedDelay);
}
while (m == 18) {
if (Bluetooth.available() > 0) {
m = Bluetooth.read();
}
servo02.write(servo2PPos);
servo2PPos--;
delay(speedDelay);
}
// Move servo 3
while (m == 20) {
if (Bluetooth.available() > 0) {
m = Bluetooth.read();
}
servo03.write(servo3PPos);
servo3PPos++;
delay(speedDelay);
}
while (m == 21) {
if (Bluetooth.available() > 0) {
m = Bluetooth.read();
}
servo03.write(servo3PPos);
servo3PPos--;
delay(speedDelay);
}
// Move servo 4
while (m == 23) {
if (Bluetooth.available() > 0) {
m = Bluetooth.read();
}
servo04.write(servo4PPos);
servo4PPos++;
delay(speedDelay);
}
while (m == 22) {
if (Bluetooth.available() > 0) {
m = Bluetooth.read();
}
servo04.write(servo4PPos);
servo4PPos--;
delay(speedDelay);
}
// Move servo 5
while (m == 25) {
if (Bluetooth.available() > 0) {
m = Bluetooth.read();
}
servo05.write(servo5PPos);
servo5PPos++;
delay(speedDelay);
}
while (m == 24) {
if (Bluetooth.available() > 0) {
m = Bluetooth.read();
}
servo05.write(servo5PPos);
servo5PPos--;
delay(speedDelay);
}
// Move servo 6
while (m == 26) {
if (Bluetooth.available() > 0) {
m = Bluetooth.read();
}
servo06.write(servo6PPos);
servo6PPos++;
delay(speedDelay);
}
while (m == 27) {
if (Bluetooth.available() > 0) {
m = Bluetooth.read();
}
servo06.write(servo6PPos);
servo6PPos--;
delay(speedDelay);
}
// If arm speed slider is changed
if (dataIn > 101 & dataIn < 250) {
speedDelay = dataIn / 10; // Change servo speed (delay time)
}
// If button "SAVE" is pressed
if (m == 12) {
//if it's initial save, set the steppers position to 0
if (index == 0) {
LeftBackWheel.setCurrentPosition(0);
LeftFrontWheel.setCurrentPosition(0);
RightBackWheel.setCurrentPosition(0);
RightFrontWheel.setCurrentPosition(0);
}
lbw[index] = LeftBackWheel.currentPosition(); // save position into the array
lfw[index] = LeftFrontWheel.currentPosition();
rbw[index] = RightBackWheel.currentPosition();
rfw[index] = RightFrontWheel.currentPosition();
servo01SP[index] = servo1PPos; // save position into the array
servo02SP[index] = servo2PPos;
servo03SP[index] = servo3PPos;
servo04SP[index] = servo4PPos;
servo05SP[index] = servo5PPos;
servo06SP[index] = servo6PPos;
index++; // Increase the array index
m = 0;
}
// If button "RUN" is pressed
if (m == 14) {
runSteps();
// If button "RESET" is pressed
if (dataIn != 14) {
stopMoving();
memset(lbw, 0, sizeof(lbw)); // Clear the array data to 0
memset(lfw, 0, sizeof(lfw));
memset(rbw, 0, sizeof(rbw));
memset(rfw, 0, sizeof(rfw));
memset(servo01SP, 0, sizeof(servo01SP)); // Clear the array data to 0
memset(servo02SP, 0, sizeof(servo02SP));
memset(servo03SP, 0, sizeof(servo03SP));
memset(servo04SP, 0, sizeof(servo04SP));
memset(servo05SP, 0, sizeof(servo05SP));
memset(servo06SP, 0, sizeof(servo06SP));
index = 0; // Index to 0
}
}
}
LeftFrontWheel.runSpeed();
LeftBackWheel.runSpeed();
RightFrontWheel.runSpeed();
RightBackWheel.runSpeed();
// Monitor the battery voltage
int sensorValue = analogRead(A0);
float voltage = sensorValue * (5.0 / 1023.00) * 3; // Convert the reading values from 5v to suitable 12V i
//Serial.println(voltage);
// If voltage is below 11V turn on the LED
if (voltage < 11) {
digitalWrite(led, HIGH);
}
else {
digitalWrite(led, LOW);
}
}
void moveForward() {
LeftFrontWheel.setSpeed(wheelSpeed);
LeftBackWheel.setSpeed(wheelSpeed);
RightFrontWheel.setSpeed(wheelSpeed);
RightBackWheel.setSpeed(wheelSpeed);
}
void moveBackward() {
LeftFrontWheel.setSpeed(-wheelSpeed);
LeftBackWheel.setSpeed(-wheelSpeed);
RightFrontWheel.setSpeed(-wheelSpeed);
RightBackWheel.setSpeed(-wheelSpeed);
}
void moveSidewaysRight() {
LeftFrontWheel.setSpeed(wheelSpeed);
LeftBackWheel.setSpeed(-wheelSpeed);
RightFrontWheel.setSpeed(-wheelSpeed);
RightBackWheel.setSpeed(wheelSpeed);
}
void moveSidewaysLeft() {
LeftFrontWheel.setSpeed(-wheelSpeed);
LeftBackWheel.setSpeed(wheelSpeed);
RightFrontWheel.setSpeed(wheelSpeed);
RightBackWheel.setSpeed(-wheelSpeed);
}
void rotateLeft() {
LeftFrontWheel.setSpeed(-wheelSpeed);
LeftBackWheel.setSpeed(-wheelSpeed);
RightFrontWheel.setSpeed(wheelSpeed);
RightBackWheel.setSpeed(wheelSpeed);
}
void rotateRight() {
LeftFrontWheel.setSpeed(wheelSpeed);
LeftBackWheel.setSpeed(wheelSpeed);
RightFrontWheel.setSpeed(-wheelSpeed);
RightBackWheel.setSpeed(-wheelSpeed);
}
void moveRightForward() {
LeftFrontWheel.setSpeed(wheelSpeed);
LeftBackWheel.setSpeed(0);
RightFrontWheel.setSpeed(0);
RightBackWheel.setSpeed(wheelSpeed);
}
void moveRightBackward() {
LeftFrontWheel.setSpeed(0);
LeftBackWheel.setSpeed(-wheelSpeed);
RightFrontWheel.setSpeed(-wheelSpeed);
RightBackWheel.setSpeed(0);
}
void moveLeftForward() {
LeftFrontWheel.setSpeed(0);
LeftBackWheel.setSpeed(wheelSpeed);
RightFrontWheel.setSpeed(wheelSpeed);
RightBackWheel.setSpeed(0);
}
void moveLeftBackward() {
LeftFrontWheel.setSpeed(-wheelSpeed);
LeftBackWheel.setSpeed(0);
RightFrontWheel.setSpeed(0);
RightBackWheel.setSpeed(-wheelSpeed);
}
void stopMoving() {
LeftFrontWheel.setSpeed(0);
LeftBackWheel.setSpeed(0);
RightFrontWheel.setSpeed(0);
RightBackWheel.setSpeed(0);
}
// Automatic mode custom function - run the saved steps
void runSteps() {
while (dataIn != 13) { // Run the steps over and over again until "RESET" button is pressed
for (int i = 0; i <= index - 2; i++) { // Run through all steps(index)
if (Bluetooth.available() > 0) { // Check for incomding data
dataIn = Bluetooth.read();
if ( dataIn == 15) { // If button "PAUSE" is pressed
while (dataIn != 14) { // Wait until "RUN" is pressed again
if (Bluetooth.available() > 0) {
dataIn = Bluetooth.read();
if ( dataIn == 13) {
break;
}
}
}
}
// If speed slider is changed
if (dataIn > 100 & dataIn < 150) {
speedDelay = dataIn / 10; // Change servo speed (delay time)
}
// Mecanum wheels speed
if (dataIn > 30 & dataIn < 100) {
wheelSpeed = dataIn * 10;
dataIn = 14;
}
}
LeftFrontWheel.moveTo(lfw[i]);
LeftFrontWheel.setSpeed(wheelSpeed);
LeftBackWheel.moveTo(lbw[i]);
LeftBackWheel.setSpeed(wheelSpeed);
RightFrontWheel.moveTo(rfw[i]);
RightFrontWheel.setSpeed(wheelSpeed);
RightBackWheel.moveTo(rbw[i]);
RightBackWheel.setSpeed(wheelSpeed);
while (LeftBackWheel.currentPosition() != lbw[i] & LeftFrontWheel.currentPosition() != lfw[i] & RightFrontWheel.currentPosition() != rfw[i] & RightBackWheel.currentPosition() != rbw[i]) {
LeftFrontWheel.runSpeedToPosition();
LeftBackWheel.runSpeedToPosition();
RightFrontWheel.runSpeedToPosition();
RightBackWheel.runSpeedToPosition();
}
// Servo 1
if (servo01SP[i] == servo01SP[i + 1]) {
}
if (servo01SP[i] > servo01SP[i + 1]) {
for ( int j = servo01SP[i]; j >= servo01SP[i + 1]; j--) {
servo01.write(j);
delay(speedDelay);
}
}
if (servo01SP[i] < servo01SP[i + 1]) {
for ( int j = servo01SP[i]; j <= servo01SP[i + 1]; j++) {
servo01.write(j);
delay(speedDelay);
}
}
// Servo 2
if (servo02SP[i] == servo02SP[i + 1]) {
}
if (servo02SP[i] > servo02SP[i + 1]) {
for ( int j = servo02SP[i]; j >= servo02SP[i + 1]; j--) {
servo02.write(j);
delay(speedDelay);
}
}
if (servo02SP[i] < servo02SP[i + 1]) {
for ( int j = servo02SP[i]; j <= servo02SP[i + 1]; j++) {
servo02.write(j);
delay(speedDelay);
}
}
// Servo 3
if (servo03SP[i] == servo03SP[i + 1]) {
}
if (servo03SP[i] > servo03SP[i + 1]) {
for ( int j = servo03SP[i]; j >= servo03SP[i + 1]; j--) {
servo03.write(j);
delay(speedDelay);
}
}
if (servo03SP[i] < servo03SP[i + 1]) {
for ( int j = servo03SP[i]; j <= servo03SP[i + 1]; j++) {
servo03.write(j);
delay(speedDelay);
}
}
// Servo 4
if (servo04SP[i] == servo04SP[i + 1]) {
}
if (servo04SP[i] > servo04SP[i + 1]) {
for ( int j = servo04SP[i]; j >= servo04SP[i + 1]; j--) {
servo04.write(j);
delay(speedDelay);
}
}
if (servo04SP[i] < servo04SP[i + 1]) {
for ( int j = servo04SP[i]; j <= servo04SP[i + 1]; j++) {
servo04.write(j);
delay(speedDelay);
}
}
// Servo 5
if (servo05SP[i] == servo05SP[i + 1]) {
}
if (servo05SP[i] > servo05SP[i + 1]) {
for ( int j = servo05SP[i]; j >= servo05SP[i + 1]; j--) {
servo05.write(j);
delay(speedDelay);
}
}
if (servo05SP[i] < servo05SP[i + 1]) {
for ( int j = servo05SP[i]; j <= servo05SP[i + 1]; j++) {
servo05.write(j);
delay(speedDelay);
}
}
// Servo 6
if (servo06SP[i] == servo06SP[i + 1]) {
}
if (servo06SP[i] > servo06SP[i + 1]) {
for ( int j = servo06SP[i]; j >= servo06SP[i + 1]; j--) {
servo06.write(j);
delay(speedDelay);
}
}
if (servo06SP[i] < servo06SP[i + 1]) {
for ( int j = servo06SP[i]; j <= servo06SP[i + 1]; j++) {
servo06.write(j);
delay(speedDelay);
}
}
}
}
}Code language: Arduino (arduino)
Processus de fabrication
- Créez votre robot de streaming vidéo contrôlé par Internet avec Arduino et Raspberry Pi
- Robot Pi simple
- Obstacles pour éviter le robot avec servomoteur
- Contrôler un robot Roomba avec Arduino et un appareil Android
- Contrôle du servomoteur avec Arduino et MPU6050
- Bras robotique simple et intelligent utilisant Arduino
- Littlearm 2C :Construire un bras de robot Arduino imprimé en 3D
- Bras de robot Arduino DIY – Contrôlé par des gestes de la main
- Le robot associe un bras robotisé collaboratif à une plate-forme mobile