Projet Rob3 : Fatah,Oualid,Dounia (FOD : Fonctional Omnidirectional Drawing Robot )
I ) Préaumbule :
1) Membres de l'équipe :
| Identité | Contacte | Formation |
| Mohamed El Oualid BOUDEMAGH | mohamed_el_oualid.boudemagh@etu.sorbonne-universite.fr | Polytech-Sorbonne ( ROB3 ) |
| Fatah MSAID | fatah.msaid@etu.sorbonne-universite.fr | Polytech-Sorbonne ( ROB3 ) |
| Dounia BAKALEM | dounia.bakalem@etu.sorbonne-universite.fr | Polytech-Sorbonne ( ROB3 ) |
Période du projet : 14/02/2024 au 23/05/2022024
2) Indroduction, cadre et objectifs de la réalisation :
Etant actuellement des étudiants en vue de devenir des ingénieurs roboticiens, nous sommes amenés à concevoir un robot en passant par toutes les étapes de modélisation et réalisation. Dans le cadre de ce projet, il s'agit d'un robot qui dessine sur une face 2D de dimension 25*25 mm.
De ce fait, vous trouverez dans la suite de ce rapport notre cheminement pour mener à bien ce projet, cela comportera la conception de la partie mécanique, le système de commande, la motorisation, l'interface de pilotage et les différents codes informatiques pilotants.
Ainsi, nous mettrons en pratique les connaissance acquises en programmation (langage C), en modélisation (SolidWorks), en calculs cinématiques (Modèles géométriques direct/indirecte). Par ailleurs, nous aspirons à consolider notre inventaire de Roboticien en apprenant le codage en Arduino, les impressions 3D et le découpage laser.assemblage_FOD_final.zip
Enfin, nous nous engageons à prendre soin du matériel mis à notre disposition au sein du FablabSU, nous tenons également à remercier nos enseignants et le personnel qui nous encadront tout au long de notre projet.
3 ) Diagramme de Gantt (au 21/02/2024) et distribustion des rôles :
II ) Cahier des charges :
Le but général est de faire un robot capable de dessiner avec un crayon sur un support plan horizontal.
2.1 Fonctions à réaliser
Le robot doit être fixé ou posé sur une plaque horizontale carrée de 250mm par 250mm. Il doit être capable de réaliser deux exercices :
1) Tracer, avec l’aide d’un crayon fixé sur l’organe terminal du robot, dans le plan de la plaque support différentes figures imposées de difficulté croissante :
a. Une ligne de 5cm de long,
b. Une ligne pointillée de 5cm de long,
c. Un cercle de 2.5cm de rayon,
d. Un cercle pointillé de 2.5cm de rayon.
Le tracé de chacune des figures doit être réalisé en 10 secondes +/- 0.2 secondes.
2) Tracer, avec l’aide d’un crayon fixé sur l’organe terminal du robot, dans le plan de la plaque support, un dessin imposé dans un carré de 5cm par 5cm. Le déplacement de l’organe terminal du robot devra être piloté par un joystick. Il est possible que la figure soit discontinue, et donc il faut prévoir de pouvoir relever le crayon du support horizontal sur lequel on écrit.
Une fonction supplémentaire, optionnelle , peut être réalisée :
Être capable de modifier la vitesse de déplacement du robot via l’interface.
2.2 Fonctions contraintes
Les contraintes imposées sont :
- Respect des règles d’utilisation du FABLAB de Sorbonne Université au sein duquel vous travaillerez, en particulier la charte des FabLab du MIT. Cela implique que vous travaillerez sur le WIKI du FABLAB pour documenter votre projet. Il y a une bonne documentation ici pour savoir comment utiliser le WIKI.
- Utilisation de composants (moteurs, contrôleurs, boutons, éléments de guidage, alimentation stabilisée, boutons, etc.) parmi un ensemble imposé. Une liste de composants utilisables est disponible au paragraphe 4.
- Fabrication des pièces grâce à :
- Machine à découpe LASER.
- Imprimantes RAISE 3D PRO2.
Ces machines du FABLAB de sont pas toutes accessibles tout le temps ni en même temps. C’est une contrainte qu’il vous faut intégrer dans la gestion de votre projet (par exemple, privilégier la découpe LASER qui est très rapide, lorsque c’est possible).
Un objectif est de minimiser la quantité de matière utilisée pour réaliser le projet.
- Programmation en C utilisant la chaîne de développement Arduino IDE
CE NE SONT PAS LES FONCTIONS CONTRAINTE DE L'OBJET, MAIS VOS CONTRAINTES DE REALISATION DU PROJET
4. Liste des composants et matériels disponibles
- Un crayon
- Interface de commande :
- Une carte arduino UNO avec câble USB-B;
- Un joystick:
- Une platine de protoypage;
- Alimentation régulée 5V ;
- Câbles, LEDs, boutons poussoirs, résistances.
- Motorisation :
- Deux servomoteurs HS422 180°;
- Un servomoteur Emax ES08A 180°.
- Mécanique :
- Matière PLA pour impression 3D;
- Feuilles medium : 3mm et 6mm d'épaisseur;
- Vis et écrous : M2, M2.5, M3, M4.
- Roulements et axes de diamètre 4mm.
III ) Solutions Proposées :
1 ) Solution 1 : La voiture qui dessine
-
L'une des idées explorées était de concevoir un robot sous forme de voiture capable d'écrire avec un stylo. Cependant, après avoir examiné les servomoteurs disponibles et les contraintes du projet, nous avons constaté que ces servomoteurs ne conviendraient pas pour tourner les roues de manière efficace en raison de leur limitation de rotation maximale à 180 degrés. De plus, les restrictions imposées, comme l'interdiction d'utiliser des outils externes tels qu'un hacheur pour la motorisation, et l'incapacité d'incorporer un système Bluetooth pour contrôler la voiture avec un joystick, ont été des obstacles significatifs.
En raison de ces contraintes techniques et de conception, nous avons été contraints d'abandonner l'idée de la voiture robotique. Nous nous sommes plutôt concentrés sur des alternatives qui seraient réalisables dans le cadre des ressources et des contraintes du projet, tout en restant conformes au cahier des charges initial.
2 ) Solution 2 : Robot à deux rails :
|
|
|
Schéma non-contractuel du robot à deux rails Source de la photo : (19) Technical Tushar - YouTube
- Fonctionnement : Le servomoteur 1 est collé sur le pignon 1 qui est lui même fixé sur la plateforme fixe. Ce premir système entraine la translation de la crémallière 1 selon x. Au bout de cette dernière, la plateforme mobile est fixé, cette plateforme se deplace donc selon x suivant la crémallière 1. Par ailleurs, le même mécanisme (servomoteur 2, pignon 2, crémallière 2) fixé sur la plateforme mobile entraine la traslation du stylo selon y. Enfin, le servomoteur 3 actionne la manivel permettant au stylo d'être ou non au contacte avec la feuille.
- Noter que les servomoteurs ne pouvant effectuer une rotation de 90° dans un sens et 90° dans l'autre, les pignons sont dimensionnés en conséquence (ici r = 2.5cm) permettant au stylo d'agir sur une surface de 7cm * 7cm.
- Avantages : - Simplicité de conception, de réalisation et de calcul. - Rigidité et solidité du système. - Précision permettant au stylo de dessiner toute forme. - Absence de singularité dans le cadre des 7 * 7 cm. - Consommation assez raisonnable de ressources
- Limites :
- Une lubrification peut être envisageable.
- Frottements.
- La plateforme tenant le stylo peut se pencher vers le sol à cause de son poids.
3 ) Solution 3: Robot à 3 rails :
|
|
Nous avons pris cette photo afin d'illustrer nos explications dans "Fonctionnement". Cela dit, elle ne relète pas notre solution, puisque ici on voit des translations réaisées à l'aide de courroie alors que notre idée repose sur un mécanisme Servomoteur, pignon et crémallière comme décrit ci-contre. |
Source de la photo : Laser Engraver TT-5.5S Laser Wood Engraver - Two Trees (twotrees3d.com)
- Fonctionnement :Le fonctionnement demeure fondamentalement inchangé par rapport à la solution précédente. Simplement, ici le mécanisme servomoteur-pignon-crémalliere (sur le rail 1) entraine la translation du stylo selon y, et en face (sur le rail 2) on retrouve un roulement qui réalise le guidage permettant au rail 3 de toujours être perpendiculaire aux rails 1 et 2. De plus, un autre mecanisme servomoteur-pignon-crémalliere permet au style de se deplacer selon x ( sur le rail 3). Enfin, le dernier servomoteur actionne la manivel permettant au stylo d'être ou non au contacte avec la feuille.
- Avantages : - Absence de singularité dans le cadre des 7 * 7 cm. - Calculs théoriques assez simples.
- Limites :
- Le guidage n'est pas optimal ce qui peut engendrer la diagonalisation du rail 3.
- Trop de ressources utilisées.
- Conception, réalisation et montage assez fastidieux .
- Nécéssité absolue de lubrification (notamment le roulement).
4 ) Solution 4 : (Solution retenue ) : Robot a articulations :
Pour la 3ème idée nous avons opté pour un robot qui utilise le principe du FANUC pour fonctionner ,
Le principe : le but de cette solution est d'atteindre le maximum de points dans un carrée , pour cela on va relier 2 bras sous forme de "L" avec 3 servos-moteurs , un pour le bras droit, un pour le bras gauche , un pour remonter les bras selon z , donc on aura au totale 3 mouvements selon les 3 axes , chaque bout de bras sera relier a l'aide d'une articulation pivot et donc pour chaque mouvement du bras relier au moteur , l'autre bras suivra .
Pour réaliser cela , nous reliant un repaire pour chaque bout de bras et à l'aide des matrices de DH on pourra donner directement les coordonnées articulaires pour la taches voulue et le microcontroleur calculera les angles nécessaire a faire pour le réaliser , cette solution est plus précise par rapport au 2 autres car on pourra atteindre n'importe quel point à l'aide de calcules
Problèmes :
Malgré l'efficacité de cette solution , elle pose un problème extrêmement contraignant qui est : les points de singularités, effectivement , contrairement, aux 2 autres solutions , les singularités sont atteintes très facilement ce qui donc nous limitera dans le nombre de mouvement possibles , ces points de singularités sont atteint pour : les angles des 2 bras est de 180° et quand l'un des deux bras est totalement tendu , quand l'angles des bras atteins au meme temps 90° AH BON ? VOUS l'AVEZ CALCULE ?
Croquis à main levée de la solution
Exemple de la solution
source de la photo : https://youtu.be/s5AP7tbfueg
Pourquoi avons-nous gardé cette idée ?
Cette idée est restée pour nous la plus réaliste et la plus efficace , effectivement , la réalisation de ce type de robot n'est pas très compliquée vue que pour le guidage on aura besoin que 2articulations pivot , et donc facile a réaliser , de plus , cette solution nous permet d'avoir plus de liberté car on pour pratiquement atteindre n'importe quelle point dans un carré si on envoie les bonne coordonnées articulaires , bien-sur tout en évitant les cas de singularités , donc au final, le vrai gros problème de cette solution serait la singularité qui est un problème qui théoriquement ne devrait pas être très dur a résoudre si on le compare avec les solutions abandonnées .
IV.IV ). conception détaillée :
1)Schéma électrique et modèle géométrique :
1 .1).modèle géométrique (1er modèle) :
Les coordonnées articulaires sont nécéssaire pour qu'on puissent attendre les positions voulue par notre robot , et pour les trouver on a du calculer le modèle géométrique inverse de notre robot et nous avons ainsi trouver les équations qui relie les coordonnées articulaires aux paramètres de notre robot et aux paramètres de la position voulue . Cela a pu étre effectuer selon les étapes suivantes :
- Relier chaque corps du robot a un repaire
- Trouver les équations de contraintes qui relient les repaires
- Trouver les coordonnées voulue en fonction des angles articulaires
- Regrouper tout en équations
- Enfin après avoir dérivés les équations et les avoir résolue nous obtenons les relations suivantes pour chaque coordonnées articulaire :
Source : Cours de Mr.Morel de mécanique général
Remarque : ici l3=0
Schéma cinématique du robot
Remarque :
S1 : Biele 1
S2 : Biele 2
S3 : Biele 3
S4 : Biele 4
O1 : Centre du 1er servo-moteur
O2 : Centre du 2ème servo-moteur
Ensuite nous avons implémenter le résultat sur MATLAB pour effectuer le calcule des coordonnées articulaires
Code de la fonction utilisée pour le calcule du modèle géométrique inverse
1.2).Modèle géométrique final :
Après avoir réalisé le premier modèle géométrique, nous avons constaté rapidement qu'il comportait quelques erreurs, notamment parce qu'il était établi à partir d'un seul bras, ne prenant pas en considération le fait que les deux bras fonctionnent ensemble.
ParÀ conséquent,l'aide de Monsieur Carillet, nous avons opté pourélaboré un nouveau modèle, plus complet. Ce nouveau modèle prend en compte les mouvements des deux bras en parallèle. LaLe fonction MATLABschéma ci-dessous illustre ce nouveau modèle géométrique amélioré, qui calcule les angles nécessaires pour les deux bras en fonction des coordonnées (x, y) et des longueurs des bras (l1, l2, l3, l4)l4 et l5).
on travaille sur le triangle O1BP :
On a :
avec :
et
Code MATLAB utilisée
2 ) . Schéma électrique :
Schéma électrique du FOD
| Composant | Pin |
| Bouton gris | 2 |
| Bouton bleu | 3 |
| Bouton noir | 4 |
| Bouton vert | 5 |
| Joystick | X: A0 , Y : A1 , SW : 10 |
| Servo droit | 7 |
| Servo gauche | 8 |
| Servo haut | 9 |
3.3 ). Code :
Dans cette étape, nous avons exploré deux méthodes distinctes. Pour la première méthode, nous avons utilisé MATLAB pour calculer les angles à donner aux servomoteurs, puis nous les avons intégrés directement dans notre code Arduino.
Descriptif du code :
Cependant, lorsque nous avons introduit le joystick dans notre système, nous avons réalisé que cette méthode limitait notre flexibilité et rendait impossible l'utilisation du joystick.
C'est pourquoi nous avons opté pour la deuxième méthode, où nous effectuons les calculs directement dans le code Arduino. Cette approche nous permet d'obtenir les angles directement à partir du programme, ce qui simplifie l'intégration du joystick et offre une plus grande flexibilité dans le contrôle du système.
Pour réaliser cela, nous avons implémenté dans notre code une fonction qui effectue le même calcul que celui que nous avions réalisé avec MATLAB. Cette fonction prend en compte les coordonnées de destination et les longueurs des bras, puis calcule les angles nécessaires pour positionner les bras de manière appropriée.
Code de la fonction de calcule du modèle géométrique
En incorporant cette fonction dans notre code Arduino, nous avons pu obtenir les angles requis directement à partir du microcontrôleur, sans avoir besoin de faire des calculs préalables dans MATLAB. Cela simplifie le processus et permet une exécution plus efficace des opérations, ce qui est particulièrement important dans un environnement en temps réel comme celui des systèmes embarqués. De plus, cela nous permet d'avoir un contrôle total sur le fonctionnement du système directement à partir du code Arduino, offrant ainsi une solution plus intégrée et autonome.
Remarque : Pour la partie Joystick , elle est en cours de développement et doit être testée
OrganigrameOrganigramme du programme
A partir de cette organigramme nous avons commencer la creation du code .
Le code comporte 5 partie :
1)- dessin de la ligne continue de 5 cm :
2)-Dessin de la ligne discontinue de 5cm :
3) Dessin du cercle de rayon 2.5 cm:
4) Dessin du cercle discontinue de rayon 2.5 cm :
5) Mode manuel (joystick) :
Pour le mode manuel, le travail a été réalisé en collaboration avec les membres du projet robot "Majin". Ensemble, nous avons réfléchi à la manière de concevoir et de coder ce mode manuel. Et donc, nous avons pu commander notre robot en position et en vitesse.
L'afficheur LCD :
Après avoir finalisé le code, nous avons constaté qu'il manquait encore un élément essentiel à notre robot : une interface permettant de connaître en temps réel le mode de fonctionnement. Initialement, nous avions pensé utiliser des LED, mais cela encombrait notre montage et n'était pas intuitif pour une personne extérieure sans explications. C'est alors que nous avons eu l'idée d'ajouter un afficheur LCD.
Comment ça marche ?
Nous avons utilisé un afficheur LCD LiquidCrystal I2C. C'est un module pratique et facile à utiliser pour afficher des informations sur deux lignes de 16 caractères chacune. Il se connecte à une Arduino via le bus I2C et ne nécessite que 4 broches : Vcc, GND, SDA et SCL.
#include <Servo.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 16,2);
#define X_pin A0
#define Y_pin A1
#define sw 10
#define Bb 2 //Bouton Bleu
#define Bv 3 //Bouton Vert
#define Br 4 //Bouton Rouge
#define Bg 7 //Bouton Gris
//Etat des boutons
int bouttonb_stat = 0;
int bouttonv_stat = 0;
int bouttonr_stat = 0;
int bouttong_stat = 0;
float Rx;//Cordonnée Actuel selon x
float Ry;//Cordonnée Actuel selon y
float Rxx;//Cordonnée a atteindre selon x
float Ryy;//Cordonnée a atteindre selon y
int angle_effecteur=0;
//Definition des servos
Servo droit;
Servo gauche;
Servo haut;
//Valeur de sauvgarde d'états
int haut_s=50;
int bas_s=43;
int etat=bas_s;
float cpt=0;
//Parametres du modele geometrique inverse
float l1=7;
float l4=8;
float l2=7;
float l3=8;
float l5=3.5;
float a=5;
int cpts=0;
int x_val;
int y_val;
int sw_val;
//Modele geometrique inverse
float theta1(float xp,float yp){
float O1P=sqrt((-a+xp)*(-a+xp)+(yp)*(yp));
float b=(((l1*l1)-(l5*l5 +l4*l4 -2*l4*l5*cos((180-angle_effecteur)*M_PI/180.0) )+(O1P*O1P))/(2*l1*O1P));
float alpha=acos(b)*180/M_PI;
float beta=atan(((yp)/(a-xp)))*180/M_PI;
float theta=180-(beta+alpha);
return theta;
}
float theta2(float xp,float yp){
float O1P=sqrt((-a+xp)*(-a+xp)+(yp)*(yp));
float omega=(acos(((O1P*O1P)-(l5*l5 +l4*l4 -2*l4*l5*cos((180-angle_effecteur)*M_PI/180.0))-(l1*l1))/(-2*(sqrt(l5*l5 +l4*l4 -2*l4*l5*cos((180-angle_effecteur)*M_PI/180.0)))*l1))*180.0/M_PI)+acos((-(l5*l5 +l4*l4 -2*l4*l5*cos((180-angle_effecteur)*M_PI/180.0))+(l5*l5)-(l4*l4))/(-2*l4*(sqrt(l5*l5 +l4*l4 -2*l4*l5*cos((180-angle_effecteur)*M_PI/180.0)))))*180.0/M_PI;
float omega_bis=omega-theta1(xp,yp)-angle_effecteur;
float O2C=sqrt((a+(xp+l5*(cos(omega_bis*M_PI/180.0))))*(a+(xp+l5*cos(-omega_bis*M_PI/180.0)))+(yp+l5*sin(-omega_bis*M_PI/180.0))*(yp+l5*sin(-omega_bis*M_PI/180.0)));
float alpha2=acos((((l2*l2)-(l3*l3)+(O2C*O2C))/(2*l2*O2C)))*180/M_PI;
float beta2=atan(((yp+l5*sin(-omega_bis*M_PI/180.0))/(a+xp+l5*cos(-omega_bis*M_PI/180.0))))*180.0/M_PI;
float theta2=beta2+alpha2;
return theta2;
}
//DEbut du programme
void setup() {
Serial.begin(9600);
droit.attach(5);
gauche.attach(6);
haut.attach(9);
pinMode(X_pin,INPUT);
pinMode(Y_pin,INPUT);
pinMode(sw,INPUT_PULLUP);
pinMode (Bb,INPUT_PULLUP);
pinMode (Bv,INPUT_PULLUP);
pinMode (Br,INPUT_PULLUP);
pinMode (Bg,INPUT_PULLUP);
droit.write(90);
gauche.write(120);
haut.write(60);
lcd.init();//initialisation de l'afficheur Lcd
lcd.backlight();//Allumer le retro eclairage
}
void loop() {
//initialisation des bouttons
bouttong_stat = digitalRead(Bg);
bouttonb_stat = digitalRead(Bb);
bouttonr_stat = digitalRead(Br);
bouttonv_stat = digitalRead(Bv);
//Ligne continue
if(bouttonb_stat==LOW){
haut.write(60);
lcd.setCursor(1,0);//Position d'écriture dans l'afficheur
lcd.print("Mode : Ligne ");//Ecriture dans l'afficheur
haut.write(45);
//Dessin d'une ligne de 5cm
for(float i=-2.5;i<=2.5;i=i+0.0015){
droit.write(180-theta1(i,12));
gauche.write(180-theta2(i,12));
}
delay(50);
haut.write(60);
droit.write(180-theta1(-2.5,12));
gauche.write(180-theta2(-2.5,12));
delay(1000);
lcd.clear();//Effacer
}
//Ligne discontinue
if(bouttonv_stat==LOW){
lcd.setCursor(1,0);//Position d'écriture dans l'afficheur
lcd.print("Mode : Ligne ");//Ecriture dans l'afficheur
lcd.setCursor(1,1);//Position d'écriture dans l'afficheur
lcd.print("Discontinue ");//Ecriture dans l'afficheur
//Dessin d'une ligne de 5cm
for(float i=-2.5;i<=2.5;i=i+0.1){
droit.write(180-theta1(i,12));
gauche.write(180-theta2(i,12));
cpt=cpt+0.1;
//Sauvegarde de l'état
if(cpt>=0.1 && etat==bas_s ){
etat=haut_s;
haut.write(haut_s);
delay(700);
}
else if(cpt>=0.1 && etat==haut_s) {
etat=bas_s;
haut.write(bas_s);
delay(700);
}
}
delay(50);
droit.write(180-theta1(-2.5,12));
gauche.write(180-theta2(-2.5,12));
delay(1000);
lcd.clear();//Effacer
}
//Cercle
if(bouttonr_stat==LOW){
lcd.setCursor(1,0);//Position d'écriture dans l'afficheur
lcd.print("Mode : Cercle ");//Ecriture dans l'afficheur
haut.write(40);
//Dessin du demi cercle superieur
for(float x=-2;x<=2;x=x+0.009){
gauche.write(180-theta2(x,12+sqrt((2*2)-(x*x))));
droit.write(180-theta1(x,12+sqrt((2*2)-(x*x))));
delay(10);
}
//Dessin du demi cercle inferieur
for(float x=2;x>=-2;x=x-0.009){
gauche.write(180-theta2(x,12-sqrt((2*2)-(x*x))));
droit.write(180-theta1(x,12-sqrt((2*2)-(x*x))));
delay(10);
}
delay(2000);
lcd.clear();//Effacer
}
//Cercle discontinue
if(bouttong_stat==LOW){
lcd.setCursor(1,0);//Position d'écriture dans l'afficheur
lcd.print("Mode : Cercle ");//Ecriture dans l'afficheur
lcd.setCursor(1,1);//Position d'écriture dans l'afficheur
lcd.print("Discontinue ");//Ecriture dans l'afficheur
cpt=0;
etat=haut_s;
//Dessin du demi cercle superieur
for(float x=-2.5;x<=2.5;x=x+0.2){
gauche.write(180-theta2(x,12+sqrt((2.5*2.5)-(x*x))));
droit.write(180-theta1(x,12+sqrt((2.5*2.5)-(x*x))));
delay(10);
cpt=cpt+0.1;
//Sauvgarde de l'etat actuel
if(cpt>=0.1 && etat==bas_s ){
etat=haut_s;
cpt=0;
haut.write(haut_s);
delay(700);
}
else if(cpt>=0.1 && etat==haut_s) {
etat=bas_s;
cpt=0;
haut.write(bas_s);
delay(700);
}
}
//Dessin du demi cercle inferieur
for(float x=2.5;x>=-2.5;x=x-0.2){
gauche.write(180-theta2(x,12-sqrt((2.5*2.5)-(x*x))));
droit.write(180-theta1(x,12-sqrt((2.5*2.5)-(x*x))));
delay(10);
cpt=cpt+0.1;
//Sauvgarde de l'etat actuele
if(cpt>=0.1 && etat==bas_s ){
etat=haut_s;
cpt=0;
haut.write(haut_s);
delay(700);
}
else if(cpt>=0.1 && etat==haut_s) {
etat=bas_s;
haut.write(bas_s);
delay(700);
}
}
delay(2000);
lcd.clear();//Effacer
}
//Mode manuel
if (bouttonr_stat == HIGH && bouttonb_stat == HIGH && bouttonv_stat == HIGH && bouttong_stat == HIGH) {
lcd.setCursor(1,0);//Position d'écriture dans l'afficheur
lcd.print("Mode : Manuel ");//Ecriture dans l'afficheur
// Lecture des valeurs du joystick
sw_val=digitalRead(sw);
Serial.println(sw_val);
x_val = analogRead(X_pin);
y_val = analogRead(Y_pin);
//conversion
Rx=map(x_val,0,1023,3,-3);
Ry=map(y_val,0,1023,13.8,7);
//Commande en vitesse
if (Rxx < Rx) {
Rxx += 0.01;
if (Rxx > Rx) {
Rxx = Rx;
}
} else if (Rxx > Rx) {
Rxx -= 0.01;
if (Rxx < Rx) {
Rxx = Rx;
}
}
if (Ryy < Ry) {
Ryy += 0.01;
if (Ryy > Ry) {
Ryy = Ry;
}
} else if (Ryy > Ry) {
Ryy -= 0.01;
if (Ryy < Ry) {
Ryy = Ry;
}
}
droit.write(180-theta1(Rxx,Ryy));
gauche.write(180-theta2(Rxx,Ryy));
//Lever le stylo
if(!digitalRead(sw) && etat==haut_s){
haut.write(45);
etat=bas_s;
delay(300);
}
else if (!digitalRead(sw) && etat==bas_s){
haut.write(60);
etat=haut_s;
delay(300);
}
/*if(cpts==1 && sw_val==0 ){
haut.write(haut_s);
}
else{
haut.write(bas_s);
}*/
delay(10);
}
}
2) Conception CAO :
Dans une optique de sobriété et de démarche éco-responsable, nous avons imaginer la CAO se sorte à avoir l'intégralité des pièces en découpe laser donc en bois. Cela nous a évité les imprimantes 3D et de ce fait l'utilisation du plastique qui est nocif pour l'environnement .
Nous avons procédé à la modélisation de notre robot à l'aide du logiciel SolidWorks.
Cette conception peut être segmentée en deux principaux sous-ensembles :
Le bâti : Cet ensemble abrite les deux servo-moteurs qui dirigent les deux bras, chacun composé de deux bielles.
La table : Destinée à recevoir la feuille sur laquelle écrire, cette composante intègre un servo-moteur situé en dessous. Ce dernier est connecté à la table et permet de régler la hauteur du stylo pour l'écriture en basculant l'ensemble du bâti. Les détails de ce mécanisme sont explicités ci-dessous
image du robot final
Le bâti: du robot a été conçu en privilégiant la découpe laser comme méthode de fabrication principale. Il se compose de trois pièces qui s'emboîtent de manière adéquate, toutes adaptées à la découpe laser. La pièce centrale présente deux ouvertures destinées à recevoir les deux servomoteurs. Les bielles sont fixées aux servomoteurs au moyen d'une vis au centre, avec un trou additionnel permettant le vissage à l'hélice du moteur pour assurer le guidage.
le bâtisSupport
Les liaisons entres les bielles :
Comme évoqué précédemment dans notre documentation, le robot est constitué de quatre bielles. Pour les articulations entre ces bielles, nous avons opté pour l'utilisation de roulements associés à des vis pour assurer la fixation. Comme illustré dans l'image ci-dessous, l'une des bielles présente un trou de diamètre correspondant à celui du roulement externe, tandis que l'autre bielle possède un diamètre légèrement inférieur (correspondant au diamètre interne du roulement). Ces éléments sont ensuite solidement fixés à l'aide d'une vis et d'un écrou, soigneusement serrés. Nous avons également intercalé une plaque métallique entre le roulement et la vis afin de garantir la fluidité du mouvement.
Images qui illustrent les liaisons entres les bielles
Emplacement et Réglage du Stylo dans le Mécanisme du Robot :
- Comme visible, l'une des bielles est préalablement équipée d'une extension et d'un orifice destiné à recevoir le stylo. Étant donné que cette pièce sera fabriquée en bois, nous aurons la possibilité d'ajouter ultérieurement un trou sur le côté pour insérer une vis permettant de régler la hauteur du stylo.
bielle du stylo
-
Le mécanisme pour lever le stylo consiste à fixer la bielle au moyen d'une vis sur l'hélice du servomoteur. Cette bielle est ensuite fixée sur une pièce émergeant du bâti. Les bâtis et la table sont ainsi reliés par deux liaisons pivot sur les côtés, comme illustré dans l'image. Pour réduire les frottements et faciliter le mouvement, nous prévoyons d'utiliser un morceau de cylindre inséré dans le trou de la table, lequel sera fixé à l'aide d'une vis et d'un écrou traversant le trou du bâti.
Mécanisme de Levage du Stylo : Illustration et Fonctionnement
vousSolidWorkstrouverez ci-joint l'ensembles des fichiers SolidWorks::assemblage_FOD.assemblage_FOD_final.zip.
Fichiers