Skip to main content

Projet ROB (Amel, Clarence, Adrien)

Réalisation d'un système robotisé "Robot écrivain"

Informations

Contexte

Ce projet est le sujet de notre UE Robotique. (https://wiki.fablab.sorbonne-universite.fr/BookStack/books/projets-due-2023-2024/page/le-sujet-du-projet)

Objectifs

  1. L'objectif de ce projet est de réaliser un système robotisé : sa partie mécanique, son actionnement, sa commande et son interface de pilotage. Ce système doit être dessinateur puisqu'il doit répondre à deux exercices :
  • Le premier consiste à tracer différentes figures prédéfinies dans un carré de 5cmx5cm en 10 secondes : Une ligne droite de 5cm, une ligne pointillée de 5cm, un cercle de rayon 2,5cm et un cercle pointillé de 2,5cm.
  • Le deuxième consiste à reproduire un dessin imposé (inconnu) à l'aide d'un joystick dans un carré de 5cmx5cm. 

 2.L'objectif pour chacun d'entre nous est de réussir à bien s'organiser au sein de l'équipe, la gestion du temps et apprendre les bases de la gestion projet dans le but de parvenir à concevoir un mécanisme robotisé fonctionnel.

I - Conception préliminaire :

1. Cahier des charges

Le but est de concevoir un robot capable de dessiner sur un support plan horizontal :

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.

e. Un dessin imposé (Le déplacement de l'organe terminal devra être piloté par un joystick)

Une fonction supplémentaire : Être capable de modifier la vitesse de déplacement du robot via l’interface.

1.1 : Contraintes 

Plusieurs contraintes nous ont été imposées dans la réalisation de ce projet , on les énumère ci-dessous :

  1. Les dessins imposés : Ligne, cercle en continu et en discontinus.
  2. Le temps fixé pour le dessin : 10 secondes.
  3. Utilisation de composants (moteurs, contrôleurs, boutons, éléments de guidage, alimentation stabilisée, boutons, etc.) parmi un ensemble imposé. 
  4. Programmation en C utilisant la chaîne de développement Arduino IDE.
  5. Interface de pilotage: Joystick.
  6. Contrainte sur les machines du fablab (Machine à découpe LASER, Imprimantes RAISE 3D PRO2) qui ne sont pas toutes accessibles tout le temps ni en même temps.
1.2 : Matériel

Pour accomplir ce projet, nous disposons d'une liste de composants et de matériels disponibles :

  • Un crayon
  • Interface de commande :
    • Une carte Arduino UNO avec câble USB-B;
    • Un joystick:
    • Une platine de prototypage;
    • 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
1.3 : Machines utilisées

Afin de réaliser ce projet, nous disposons des machines du fablab permettant la fabrication des pièces  à savoir : 

  • Machine à découpe LASER.
  • Imprimantes RAISE 3D PRO2.

2. Diagramme de Gantt 

Afin d'organiser au mieux nos séances de travail, et pour que l'équipe soit productif vis à vis de notre projet, nous avons réalisé un diagramme de Gantt, qui sera un outil de répartition des tâches et un calendrier prévisionnel . (En attachement le diagramme de Gantt)

Capture d'écran 2024-03-03 211734.png

Figure(1) : Diagramme de Gantt

3. Propositions de réalisation 

Afin de réaliser ce projet, et répondre au cahier des charges, nous avons essayé de discuter plusieurs solutions et propositions avant de choisir la plus adéquate et la plus convenable.

Parmi les solutions que nous avons proposées, on y trouve :

  1. Système 3P (inspiré du fonctionnement d'une imprimante 3D) : Un système sur deux rails (pignon/crémaillère) permettant la translation en x, en y et en z d'un support pour le stylo. 

figure(2) : Schéma cinématique système 3P

Points forts : 

  • Résolution simple des modèles géométriques direct et inverse en utilisant la convention "Denavit-Hartenberg" (ou pas)
  • Pièces compatibles avec le procédé découpe laser (Gain de temps).
  • Bonne précision et simplicité de contrôle.

Point faibles :

  • Complexité des guidages en translation.
  • Pas de limit switch dans le matériel disponible, ce qui peut rendre cette solution risquée (aucun autre moyen que les calculs pour vérifier si l'on est arrivé au bout du rail).
  • Solution peu compacte.

     2. Système 2RP (en partie inspiré du robot Fanuc) : Un système comportant deux rotoïdes dans le plan pour les déplacements en x et en y, ainsi qu'une liaison prismatique pour gérer la hauteur du stylo.


Figure (3) : Schéma cinématique système 2RP

Points forts : 

  • Résolution simple des modèles géométriques direct et inverse en utilisant la convention "Denavit-Hartenberg".

Points faibles : 

  • Problème de stabilité lié à la présence de deux servo-moteurs éloignés du bâti (en plus de l'effecteur), ce qui pourrait entraîner un risque de flexion.
  • Vigilance nécessaire avec l'espace de travail pour éviter les problèmes de singularité possibles. 

 3. Système à structure parallèle (pantographe) : Système à deux bras en parallèle se rejoignant au niveau de l'effecteur (stylo).

Fifure(4): Schéma cinématique structure parallèle 

Points forts : 

  • Structure légère, pas de problème de flexion.
  • Résistance aux vibrations.
  • Réduction de l'inertie.

Points faibles : 

  • Complexité de la cinématique : pour ce système on ne peut pas appliquer la convention de "Denavit-Hartenberg". (On peut tout de même s'en sortir avec un peu de géométrie).

4. Système à une rotation et une translation (RP) 

Figure(5): Schéma cinématique système RP

Points forts : 

  • Résolution simple des modèles géométriques direct et inverse en utilisant la convention "Denavit-Hartenberg".

Points faibles : 

  • Tout comme la solution inspirée du Fanuc, on pourrait avoir des problèmes de flexion lorsque l'effecteur se situe au bout du rail.

4. Solution choisie

Après réflexion, nous avons choisi la solution du système à structure parallèle car c'est la solution qui nous a paru la moins contraignante et la plus sûre pour répondre au cahier des charges fourni. Afin d'éviter d'avoir des problèmes d'ajustement avec le stylo entre glissant pour monter ou descendre, et serré pour être maintenu, nous avons imaginé une solution différente pour gérer la hauteur du stylo vis à vis de la feuille. Effectivement, nous avons pensé à utiliser une solution pignon/crémaillère pour régler la hauteur de la feuille directement, qui sera donc sur un support léger (pour que la charge soit supportable pour le servomoteur).

Structure parallèle

Figure(6): Croquis à main levé de la solution

Nous avons également pensé à une autre solution se basant sur le même concept, le changement apporté est au niveau des deux bras partant de deux points différents dans la solution précédente à deux bras partant du même point  pour cette autre solution dans le but de simplifier les calculs. (à en discuter davantage afin de choisir la meilleure option).

 Croquis 2_page-0001.jpg

Figure(7) : Croquis 

II - Conception détaillée : 

Dans cette partie, nous nous intéressons à la mécanique du robot en terme d'élaboration des modèles géométriques direct et inverse, de la CAO réalisée et le choix des pièces. Nous traiterons également la partie électronique en évoquant le schéma électrique et le câblage effectué. Et pour finir nous élaborons quelques algorithmes de commande afin de coder la solution proposée.    

Après réflexion, nous avons choisi le système où les deux moteurs n'ont pas le même axe, et nous avons changé notre solution précédente afin que la solution pignon/crémaillère assure la translation du stylo et non la translation de  la feuille, nous avons choisi cette solution car nous la trouvons plus simple et nous économise en matière de fabrication.

1. Modèles géométriques direct et inverse, et Jacobienne : 

Afin de pouvoir déterminer la position du stylo en fonction de l'angle des servomoteurs, et inversement, nous avons calculé les modèles géométriques directs et indirects de notre système. Ces deux modèles seront nécessaires dans la partie algorithmique dans le but de dessiner les formes désirées. Etant donné les contraintes du cahier des charges concernant la vitesse d'exécution des différents exercices, nous auront également besoin de la Jacobienne pour déterminer les vitesses de rotation des servomoteurs. Pour être plus précis, nous aurons besoin de la Jacobienne inverse, permettant de calculer ces vitesses angulaires à partir de la vitesse de l'effecteur souhaitée, mais nous pourrons pour cela nous servir de fonctions dans la partie algorithmique.

1.1 : Modèles géométriques direct et inverse 
Projet_ROB_MG.png1.2 : Jacobienne 

Projet_ROB_Jac_1.png

Projet_ROB_Jac_2.pngProjet_ROB_Jac_3.png

2. Conception mécanique :

Pour faire la CAO de notre système, nous nous sommes servis du logiciel SolidWorks et nous avons fait de sorte que la majorité des pièces puissent être réalisées par le procédé de découpe laser. En effet, cela sera pour nous un gain de temps conséquent lors de la réalisation. En revanche, certaines pièces devront tout de même être faites par impression 3D  par soucis de simplicité, elles sont différenciées dans le modèle 3D par un gris plus foncé.

Avant de passer à la modélisation sur SolidWorks, nous avons essayé de faire quelques croquis à main levé de nos pièces, en choisissant des dimensions ainsi que le procédé de fabrication. 

Pieces_page-0001.jpg

Figure(8) : Croquis des pièces à concevoir 

Bati _page-0001.jpg

Figure(9) : Croquis des pièces du bâti à concevoir 

Afin d'expliquer cette modélisation, on peut diviser ce système en 3 sous-assemblages, qui sont le bâti, le pantographe (bielles) permettant les mouvements en x et y, et le support du stylo, permettant une translation selon z.

Ensemble.png

Figure(10): Conception du robot sur SolidWorks

2.1 : Bâti

Nous avons pensé à une structure emboitée en montage serré composée de 4 pièces qui seront réalisées en découpe laser. 

Capture d’écran (48).png

Figure(11) : Assemblage du Bati 

2.2 : Pantographe

Les deux premières bielles mises en mouvement par les servomoteurs sont vissées sur ces derniers, et elles seront fabriquées par impression 3D du fait de l'empreinte du palonnier les rendant inconcevables par découpe laser. La transmission des efforts est ici assurée par les palonniers encastrés dans les bielles.

Capture d’écran (52).png

Figure(12): Assemblage Bielle, palonnier et servomoteur 

Le guidage en rotation de ces deux premières bielles avec les deux suivantes se fait à l'aide d'un tube en acier dans lequel passera une vis associée à un écrou.

Guidage_Bielles.png

Figure(13) : Guidage en rotation des bielles

Ensuite, dans le système d'origine que nous avions imaginé, un problème se posait au niveau de l'effecteur du fait des deux bielles de même hauteur. C'est pour cela que nous avons remplacé l'une d'entre elles par une chape, pour pouvoir ensuite réaliser le dernier pivot. Afin de pouvoir réaliser cette pièce par découpe laser, nous l'avons divisée en 3 pièces, qui seront simplement assemblées par des vis avec écrous.

Chape.png

Figure(14) : Chape

Enfin, pour la dernière liaison de bielles au niveau de l'effecteur, l'axe assurant un guidage en rotation sera cette fois un tube dans lequel le stylo pourra glisser librement. Ce tube contenant le stylo, il ne pourra pas être fixé avec le même système que les bielles précédentes. En effet, il sera vissé à la partie inférieure de la chape, grâce à une extrusion de matière le long de cette dernière, suffisamment important pour que l'écrou inséré au milieu ne soit pas un obstacle à l'autre bielle.

Capture d'écran 2024-03-05 141822.png

Figure(15) : Guidage en rotation au niveau de l'effecteur

2.3 : Support stylo

Pour la pièce de support au système permettant le maintient et le mouvement vertical du stylo, c'est la partie supérieure de notre chape qui réalise cette fonction. De ce fait, la pièce a été modifiée de sorte à pouvoir y placer précisément et fixer le servomoteur ainsi que la crémaillère, par l'intermédiaire de deux pièces encastrées par serrage. Il est toutefois important de noter que la crémaillère n'est pas totalement fixe, puisqu'il reste la translation selon z, mais cette translation est limitée comme nous le verrons juste après. De plus, un enlèvement de matière a été réalisé de sorte à ne pas bloquer le palonnier, qui ne sera pas gêné non plus par la bielle au niveau inférieur. En effet, d'après nos calculs, la variation d'angle nécessaire pour entraîner la translation de la crémaillère de quelques millimètres est suffisamment faible.

Chape_Sup.png

Chape Support.png

Figure(16) : Partie supérieure de la chape                            Figure(17) : Assemblage de la chape, du servomoteur et de la crémaillère

Afin de garantir le mouvement vertical du stylo, nous avons utilisé le système de pignon/crémaillère (module 1.5), avec une crémaillère d'assez faible dimension, étant donné que le stylo doit simplement pouvoir être légèrement surélevé afin d'arrêter de dessiner. On peut par ailleurs observer deux vis sur la capture d'écran ci-dessous qui permettent de limiter la translation de la crémaillère. Ces vis ont donc à la fois pour objectif d'empêcher le contact entre le pignon et la crémaillère de disparaître, mais également de fixer cette dernière.

                 Capture d’écran (55).png

Figure(18) : Pignon/Crémaillère 

Finalement, pour le maintien serré du stylo, nous avons décidé d'utiliser un clip, qui sera encastré dans la crémaillère.

Clip.png

Figure(19) : Clip

3. Schémas électroniques :

Pour cette partie de conception électronique, nous nous sommes servis du logiciel TinkerCad, afin de faire à la fois le schéma de câblage et le schéma électrique.

3.1 : Schéma de câblage

Notre schéma électronique se constitue donc d'une carte Arduino Uno qui permettra le contrôle des 3 servomoteurs, et d'une platine d'essai permettant notamment de relier les différents composants à l'alimentation et la masse. On retrouve sur cette platine 4 boutons pressoirs correspondant aux 4 figures prédéfinies à tracer, qui sont chacun reliés à une broche numérique. Une résistance de 10 kOhm est associée à chaque bouton poussoir pour diminuer l'intensité de courant électrique les traversant.

Pour ce qui est de la petite platine d'essai sur laquelle se trouvent deux potentiomètres et un bouton poussoir, elle représente en réalité un joystick, puisque ce composant n'est pas disponible sur ce logiciel. Cette représentation se justifie par le fait que le joystick analogique possède deux potentiomètres qui déterminent la position du joystick sur les axes X et Y. Ces deux sorties seront donc reliées à des broches analogiques (tension variant entre 0V et 5V). Le joystick possède également un bouton, qui, lorsqu’il est relâché, laisse le joystick revenir en douceur à la position centrale.

Pour finir, les 3 servomoteurs sont connectés à des broches numériques PWM (Pulse Width Modulation), puisque c'est la largeur des impulsions envoyées qui va déterminer la position de l’arbre de sortie.

Projet ROB câblage.png

3.2 : Schéma électrique

image.png

4. Algorithme de commande :

#include <Servo.h>

/*Paramètres ServoMoteur*/
const int pinServo1 = 8;
const int pinServo2 = 9;
const int pinServo3 = 10;
Servo servo1; // servomoteur au point A (bras gauche)
Servo servo2; // servomoteur au point B (bras droit)
Servo servo3; // servomoteur qui lève et baisse le stylo
/*Paramètres Bouton poussoir*/
const int button1 = 3; // Pin digital pour le bouton poussoir
const int button2 = 4;
const int button3 = 5;
const int button4 = 6;
/*Paramètres Joystick*/
const int SW_pin = 2; // Pin digital pour indiquer la postion du bouton poussoir du Joystick
const int X_pin = A0; // Pin analogique pour la coordonnée X
const int Y_pin = A1; // Pin analogique pour la coordonnée Y
double joyX, joyY; // Variables pour les valeurs du joystick
int Joystick; // 1 si on est en mode du pilotage par le joystick, 0 sinon
/*Paramètres du Modèle Géométrique*/
double Ex, Ey; // coordonnés cartésiennes du stylo
double theta1, theta2; // correspondent respectivement à l'angle theta A et theta B
double D = 77.28; // distance entre deux servomoteurs en mm
double L = 100; // longueur d'un bras en mm
const double Xmin = 13.64; // cadrer un carré de 50mm x 50mm
const double Xmax = Xmin + 50;
const double Ymin = 90;
const double Ymax = Ymin + 50;
double R = 25; // rayon de cercle en mm
double centreX = Xmin + 25; // coordonnées du centre du carré 50mm x 50mm
double centreY = Ymin + 25;

int Pen; //1 si le stylo touche le papier, 0 sinon


void setup()
{
  /*Initialisation ServoMoteur*/
  pinMode(pinServo1,OUTPUT);
  pinMode(pinServo2,OUTPUT);
  pinMode(pinServo3,OUTPUT);
  servo1.attach(pinServo1);
  servo2.attach(pinServo2);
  servo3.attach(pinServo3);
  calculateAngle(centreX,centreY);
  servo1.write(theta1);
  servo2.write(theta2);
  servo3.write(0);
  /*Initialisation Bouton poussoir*/
  pinMode(button1, INPUT);
  pinMode(button2, INPUT);
  pinMode(button3, INPUT);
  pinMode(button4, INPUT);
  /*Initialisation Joystick*/
  pinMode(SW_pin,INPUT);
  pinMode(X_pin, INPUT);
  pinMode(Y_pin, INPUT);
  /*Configuration du moniteur série*/
  Serial.begin(9600);
 
  Pen = 0;
  Joystick = 0;
  delay(1000);
}

void loop()
{
  /*Tracer une ligne*/
  if(digitalRead(button1) == HIGH) // si le bouton1 est appuyé
  {
    Ex = Xmin;
    calculateAngle(Ex,Ey);
    servo1.write(theta1);
    servo2.write(theta2);
    delay(1000);
    servo3.write(0);
    delay(500);
    while(Ex<Xmax)
    {
      Ex++;
      calculateAngle(Ex,Ey);
      servo1.write(theta1);
      servo2.write(theta2);
    }
    servo3.write(30);
    delay(500);
  }
  /*Tracer un cercle*/
  if(digitalRead(button2) == HIGH)
  {
    int theta = 0;
    Ex = centreX + R*cos(theta);
    Ey = centreY + R*sin(theta);
    calculateAngle(Ex,Ey);
    servo1.write(theta1);
    servo2.write(theta2);
    delay(1000);
    servo3.write(0);
    delay(500);
    while(theta < 2*PI)
    {
      theta = theta + PI/180;
      Ex = centreX + R*cos(theta);
      Ey = centreY + R*sin(theta);
      calculateAngle(Ex,Ey);
      servo1.write(theta1);
      servo2.write(theta2);
    }
    servo3.write(30);
    delay(500);
  }
  /*Tracer une ligne pointillée*/
  if(digitalRead(button3) == HIGH)
  {
    Ex = Xmin;
    calculateAngle(Ex,Ey);
    servo1.write(theta1);
    servo2.write(theta2);
    delay(1000);
    servo3.write(0);
    delay(500);
    while(Ex<Xmax)
    {
      Ex++;
      if((int)Ex%5 == 0)
      {
        PenUpDown();
      }
      calculateAngle(Ex,Ey);
      servo1.write(theta1);
      servo2.write(theta2);
    }
    servo3.write(30);
    delay(500);
  }
  /*Tracer un cercle pointillé*/
  if(digitalRead(button4) == HIGH)
  {
    int theta = 0;
    Ex = centreX + R*cos(theta);
    Ey = centreY + R*sin(theta);
    calculateAngle(Ex,Ey);
    servo1.write(theta1);
    servo2.write(theta2);
    delay(1000);
    servo3.write(0);
    delay(500);
    while(theta < 2*PI)
    {
      theta = theta + PI/180;
      if((int)theta%1 == 0)
      {
        PenUpDown();
      }
      Ex = centreX + R*cos(theta);
      Ey = centreY + R*sin(theta);
      calculateAngle(Ex,Ey);
      servo1.write(theta1);
      servo2.write(theta2);
      delay(500);
    }
    servo3.write(30);
    delay(500);
  }
  /*Mode de pilotage par Joystick*/
  if(digitalRead(SW_pin) == HIGH && Joystick == 0) // si le bouton1 est appuyé
  {
    Joystick = 1;
    servo3.write(0);
    delay(500);
    while(Joystick == 1)
    {
      if(digitalRead(SW_pin) == HIGH && Joystick == 1)
      {
        Joystick = 0;
        break;
      }
      joyX = analogRead(X_pin);
      joyY = analogRead(Y_pin);
      Ex = Ex + joyX;
      Ey = Ey + joyY;
      calculateAngle(Ex,Ey);
      servo1.write(theta1);
      servo2.write(theta2);
    }
    servo3.write(30);
    delay(500);
  }  
 
}
/* Loi entrée/sortie du modèle géométrique direct*/
void calculatePosition(double x,double y)
{
  double Dx = L * cos(x);
  double Dy = L * sin(y);
  double Cx = D + L * cos(y);
  double Cy = L * sin(y);
  double P = sqrt(pow(Cx-Dx,2) + pow(Cy-Dy,2));
  double alpha1 = acos(P/(2*L));
  double alpha2 = atan((Cy-Dy)/(Cx-Dx));
  Ex = Dx + cos(alpha1 + alpha2);
  Ey = Dy + sin(alpha1 + alpha2);
}
/* Loi entrée/sortie du modèle géométrique inverse*/
void calculateAngle(double x, double y)
{
  double n = sqrt(pow(x,2) + pow(y,2));
  double m = sqrt(pow(D-x,2) + pow(y,2));
  double alpha1 = acos(n/(2*L));
  double alpha2 = acos(m/(2*L));
  double beta1 = atan(y/x);
  double beta2 = atan((D-x)/y);
  theta1 = beta1 - alpha1;
  theta2 = HALF_PI - (alpha2 - beta2);
  theta1 = degrees(theta1);
  theta2 = degrees(theta2);
}

void PenUpDown()
{
  if(Pen == 1)// si le stylo touche le papier
  {
    servo3.write(30);// lever le stylo
  }
  else// sinon
  {
    servo3.write(0);// baisser le stylo
  }
}
 
void display()
{
  Serial.print(Ex,4);
  Serial.print("\t");
  Serial.print(Ey,4);
  Serial.print("\t");
  Serial.print(theta1,4);
  Serial.print("\t");
  Serial.print(theta2,4);
  Serial.print("\n");
}