Rapport du projet Arduino
BRAS ROBOTIQUE
Dirigé par : Rédigé par les étudiants de la L2 :
Mr. Odilon BANINGI MUTOMB Emmanuel
MENEMENE Myriam
BEWO Christivie
TAMBWE Albert
KALIMBA Dieu-vit
Année Académique 2024-2025
TABLE DES MATIERES
Contents
TABLE DES MATIERES..................................................................................... 2
1. Introduction ..................................................................................................... 3
2. DEFINITION DU PROJET ............................................................................ 4
3. CONCEPTION SUR SOLIDWORKS ........................................................... 4
3.1 Corps du bras ............................................................................................ 5
4. CABLAGE ...................................................................................................... 6
5. FONCTIONS ET PROGRAMMATION ....................................................... 7
5.1 Présentation des Fonctions ....................................................................... 7
Fonction position_initiale............................................................................ 7
Fonction recuperer_charge ........................................................................ 8
Fonction deposer_charge ............................................................................ 9
5.2 L'Ordre de Fonctionnement : Boucle Principale .................................... 10
6. Conclusion ................................................................................................... 11
1. Introduction
Dans le cadre de notre projet académique, nous avons décidé d'explorer les
fascinants domaines de la robotique et de l'automatisation en choisissant de
programmer un bras robotique à l'aide de la plateforme Arduino. Ce projet ne se
limite pas à la simple mécanique ; il constitue une immersion dans les bases
essentielles de la robotique, un domaine en pleine expansion qui joue un rôle
crucial dans notre société moderne. L'objectif principal de ce projet est de
comprendre les divers principes qui régissent le fonctionnement des systèmes
robotiques tout en développant nos compétences pratiques en programmation
Arduino et en électronique.
Le bras robotique que nous avons programmé aura la capacité d'effectuer des
mouvements précis, ce qui le rend apte à manipuler différents objets légers avec
soin. En intégrant des servomoteurs de haute précision et une carte Arduino, nous
avons élaborer un système interactif qui pourra exécuter des commandes
spécifiques, telles que la saisie, la rotation ou le déplacement d'objets, selon des
instructions programmées.
Ce projet représente une opportunité unique d’approfondir notre compréhension
de la logique de programmation, qui constitue la clé de voûte de l’ingénierie
logicielle, ainsi que de l'intégration de servo-moteur qui permettront au bras de
répondre dynamiquement à son environnement. En somme, ce bras robotique ne
représente pas seulement un projet technique ; il plonge également dans un
processus d’apprentissage enrichissant, où nous avons l’occasion d'appliquer nos
connaissances théoriques à un projet pratique. Cela permet de stimuler notre
créativité et notre esprit d'innovation, tout en nous préparant aux défis futurs dans
le monde de l'ingénierie et des technologies émergentes.
2. DEFINITION DU PROJET
Notre projet consiste à concevoir un bras robotisé automatisé capable de saisir,
déplacer et déposer des charges d'un point A à un point B en utilisant les
servomoteurs. Le système suit une séquence prédéfinie pour assurer un
mouvement fluide et précis. Il peut être optimisé avec des capteurs et des
commandes externes pour une meilleure efficacité.
charge
L’utilisateur
Bras
robotique
Déplacer
automatiquement des
charges
3. CONCEPTION SUR SOLIDWORKS
Ce modèle SolidWorks représente un bras de liaison, une pièce mécanique
utilisée pour transmettre un mouvement entre deux points articulés. Il possède
deux alésages aux extrémités, indiquant des zones de fixation pour des axes ou
des pivots. Les dimensions des trous (Ø14 mm et Ø8 mm) permettent de
déterminer les types de connexions compatibles. La forme incurvée et allongée
du bras optimise sa résistance et son mouvement. Cette pièce peut être intégrée
dans des systèmes mécaniques comme des bras robotisés ou des mécanismes
de transmission. Une extrusion a été appliquée pour obtenir un solide 3D à partir
d’une esquisse en 2D.
3.1Corps du bras
4. CABLAGE
Le projet utilise quatre servomoteurs connectés à une carte Arduino pour
contrôler les mouvements d'un bras robotisé. Chaque servomoteur possède
trois fils:
1. Fil rouge → +5V de l’Arduino (alimentation)
2. Fil noir (ou marron) → GND de l’Arduino (masse)
3. Fil jaune (ou blanc) → Broches PWM de l’Arduino (signal de
commande)
Dans notre cas, les servos sont connectés aux broches 8, 9, 10 et 2 de l'Arduino.
L’alimentation des servos peut se faire via l’Arduino si la consommation est
faible comme dans ce cas, sinon une alimentation externe est recommandée (en
reliant le GND de l’Arduino et celui de l’alimentation).
L’Arduino envoie des signaux PWM aux servos via la bibliothèque Servo.h,
ce qui permet de contrôler leur position en fonction du programme.
5. FONCTIONS ET PROGRAMMATION
Nous avons programmé un bras robotique utilisant Arduino, dotée de plusieurs
fonctions pour effectuer des actions précises comme récupérer et déposer des
charges. Pour cela, nous avons programmé trois fonctions principales : position
initiale, recuperer_charge, et deposer_charge. Chacune de ces fonctions joue
un rôle essentiel dans le fonctionnement global du bras, permettant des
mouvements coordonnés et la manipulation d'objets légers. Ce document
détaillera le fonctionnement de ces fonctions et fournira des exemples de code
afin d'illustrer le processus.
5.1Présentation des Fonctions
Fonction position_initiale
La fonction position_initiale initialise la position de tous les servomoteurs à
90 degrés. Cela constitue une étape cruciale avant d’exécuter d’autres
mouvements, car elle permet d’assurer que le bras robotique commence dans
une position sûre et standardisée. Voici un exemple de code pour cette fonction
:
void position_initiale() {
servo1.write(90); // base
servo2.write(90); // bras
servo3.write(90); // coude
servo4.write(90); // pince
delay(500); // attente pour compléter le mouvement
}
Fonction recuperer_charge
La fonction recuperer_charge est responsable du processus de récupération
d’une pièce. Voici les étapes de mouvement :
• Le servomoteur de la base (servo1) pivote de 90 à 0 degrés, permettant
d’aligner le bras au-dessus de l’objet à récupérer.
• Ensuite, le servomoteur du bras (servo2) descend également de 90 à 0 degrés
pour se positionner à la hauteur de l’objet.
• Parallèlement, le servo de la pince (servo4) s’ouvre de 90 à 0 degrés pour
saisir l’objet.
• Une fois l’objet saisi, le bras remonte, et le servo2 retourne à 90 degrés.
Voici l'implémentation de cette fonction :
// Simulation de la récupération de charge
void recuper_charge() {
// Descente de Mot1
for (pos = 90; pos >= 0; pos -= 1) {
Mot1.write(pos);
delay(20);
}
delay(500);
// Mot2 et Mot4
for (pos = 90; pos >= 0; pos -= 1) {
Mot2.write(pos);
Mot4.write(pos);
delay(20);
}
delay(500);
// Remontée de Mot2
for (pos = 0; pos <= 90; pos += 1) {
Mot2.write(pos);
delay(20);
}
delay(500);
}
Fonction deposer_charge
La fonction deposer_charge exécute le processus de dépôt de l'objet récupéré.
Les étapes de cette fonction sont les suivantes :
• Le servomoteur de base (servo1) fait un mouvement de 0 à 180 degrés pour
orienter le bras au-dessus de la zone de dépôt.
• Ensuite, le servomoteur du bras (servo2) descend pour déposer l'objet.
• Finalement, le bras remonte, le (servo4) se ferme.
Voici comment serait codée cette fonction :
// Simulation du dépôt de charge
void deposer_charge() {
// Remontée de Mot1
for (pos = 0; pos <= 180; pos += 1) {
Mot1.write(pos);
delay(20);
}
delay(500);
// Descente de Mot2
for (pos = 90; pos >= 0; pos -= 1) {
Mot2.write(pos);
delay(20);
}
delay(500);
// Remontée de Mot2
for (pos = 0; pos <= 90; pos += 1) {
Mot2.write(pos);
delay(20);
}
delay(500);
// Relâchement de la charge (Mot4)
for (pos = 0; pos <= 90; pos += 1) {
Mot4.write(pos);
delay(20);
}
delay(500);
}
5.2L'Ordre de Fonctionnement : Boucle Principale
La boucle principale du programme, void loop, est le cœur de notre
programme. Elle permet d'appeler successivement les fonctions que nous
avons définies. Voici un exemple de la façon dont cela pourrait être
implémenté :
void loop() {
position_initiale();
recuper_charge();
deposer_charge();}
Cette structure de boucle permet au bras robotique d’exécuter des cycles
d'actions continuellement, ce qui est essentiel pour certaines applications
pratiques où le bras doit interagir régulièrement avec son environnement.
6. Conclusion
À travers ce projet, nous avons non seulement acquis des compétences
techniques en matière de programmation avec Arduino, mais nous avons
également développé une compréhension concrète des principes de la
robotique. La mise en place de ces trois fonctions—
position_initiale, recuperer_charge, et deposer_charge—illustre comment des
mouvements coordonnés peuvent se traduire par des actions spécifiques, tout
en soulignant l'importance de la logique de programmation et de l'intégration
de composants électroniques dans un système robotiques.
Ce projet de bras robotique nous a également permis d’encourager notre
créativité et de résoudre des problèmes techniques actuels, préparant ainsi le
terrain pour nos futures explorations dans le domaine de l’automatisation et de
la robotique. Nous sommes impatients de continuer à affiner notre prototype,
peut-être en y intégrant des capteurs pour enrichir ses capacités d’interaction
avec le monde qui l’entoure.
