Projet ROB (Amel, Clarence, Adrien)

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

Informations

• Prénoms et noms :
  • • Amel HADDADI 
    • Clarence PFISTER
    • Adrien MILLE
• Adresses mail :
  • • amel.haddadi@etu.sorbonne-universite.fr
    • adrien.mille@etu.sorbonne-universite.fr
      
    • clarence.pfister@etu.sorbonne-universite.fr
• Cursus : 
  • • 1ere année cycle ingénieur en Robotique à Polytech Sorbonne
• Date de début - Date de fin estimée (ou réelle) :
  • • 07/02/2024 - 22/05/2024

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)

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).

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).

 

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 

1.2 : Jacobienne 

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. 

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

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.

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. 

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.

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.

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.

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.

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.

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.

                

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.

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.

3.2 : Schéma électrique

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;
int buttonState1;  // état du bouton poussoir (HIGH ou LOW)
int buttonState2;
int buttonState3;
int buttonState4;
/*Paramètres Joystick*/
const int SW_pin = 2;  // Pin digital pour indiquer la postion du bouton poussoir du Joystick
int buttonStateSW;     // état du bouton poussoir du Joystick
int Pen;               // 1 si le stylo touche le papier, 0 sinon
const int X_pin = A0;  // Pin analogique pour la coordonnée X
const int Y_pin = A1;  // Pin analogique pour la coordonnée Y
float joyX, joyY;      // Variables pour les valeurs données par le joystick à potentiomètre 2 axes
/*Paramètres du Modèle Géométrique*/
float Ex, Ey;                 // coordonnées cartésiennes du stylo
float theta1, theta2;         // correspondent respectivement à l'angle theta A et theta B du modèle géométrique
const float angleHIGH = 100;  // angles de servo3 correspondants aux positions basses et hautes du stylo
const float angleLOW = 110;
const float D = 80;        // distance entre deux servomoteurs 1 et 2 en mm
const float L = 90;        // longueur d'un bras en mm
const float centerX = 40;  // coordonnées du centre du carré 50mm x 50mm
const float centerY = 140;
const float R = 25;              // rayon de cercle en mm
const float Xmin = centerX - R;  // cadrer un carré de 50mm x 50mm
const float Xmax = centerX + R;
const float Ymin = centerY - R;
const float Ymax = centerY + R;
/*Paramètres Vitesse*/
String message;               // chaîne de caractères pour stocker la commande reçue à partir du moniteur série
int speed;                    // vitesse de mouvement pendant le mode Joystick
                              // allons de 0 à 5 // 0 : pas de mouvement, 1 : très lent, 3 : moyen, 5 : très rapide
int pause;                    // le temps de pause à chaque mouvement pendant le mode Joystick
                              // plus le nombre est petit, plus la rotation est rapide
const int autoPause = 50;     // la pause pendant les modes automatiques
const int transitTime = 300;  // le temps de passage de servo1,2.write() à servo3.write() (et inversement)

void setup() {
  /*Initialisation Servomoteur*/
  pinMode(pinServo1, OUTPUT);
  pinMode(pinServo2, OUTPUT);
  pinMode(pinServo3, OUTPUT);
  servo1.attach(pinServo1);
  servo2.attach(pinServo2);
  servo3.attach(pinServo3);
  servo3.write(90);
  delay(transitTime);
  theta1 = servo1.read();
  theta2 = servo2.read();
  calculatePosition(theta1, theta2);
  GoToPoint(centerX, centerY);
  /*Initialisation Bouton poussoir*/
  pinMode(button1, INPUT_PULLUP);  // INPUT_PULLUP lie l'entrée à 5V avec une résistance interne de 10kOhm
  pinMode(button2, INPUT_PULLUP);
  pinMode(button3, INPUT_PULLUP);
  pinMode(button4, INPUT_PULLUP);
  buttonState1 = digitalRead(button1);
  buttonState2 = digitalRead(button2);
  buttonState3 = digitalRead(button3);
  buttonState4 = digitalRead(button4);
  /*Initialisation Joystick*/
  pinMode(SW_pin, INPUT_PULLUP);
  buttonStateSW = digitalRead(SW_pin);
  pinMode(X_pin, INPUT);
  pinMode(Y_pin, INPUT);
  /*Configuration du moniteur série*/
  Serial.begin(9600);
  Serial.setTimeout(1);  // définit le nombre maximum de millisecondes d'attente pour les données série
  /*Configuration de la vitesse*/
  Serial.println("\nVeuillez régler la vitesse (0 à 5): ");
  message = "";
  setSpeed();
  servo3.write(angleHIGH);
  Pen = 0;

  delay(1000);
}

void loop() {
  /*Réglage de la vitesse*/
  if (Serial.available() > 0) {
    setSpeed();
  }
  /*Mode de pilotage par Joystick*/
  if (digitalRead(SW_pin) != buttonStateSW)  // si le bouton1 est appuyé
  {
    PenUpDown();
    delay(500);
  }
  joyX = analogRead(X_pin);  // lire les valeurs de potentiomètre
  joyY = analogRead(Y_pin);
  if (joyX > 700 && Ex < Xmax) {
    Ex += 0.1;
  }
  if (joyX < 300 && Ex > Xmin) {
    Ex -= 0.1;
  }
  if (joyY > 700 && Ey > Ymin) {
    Ey -= 0.1;
  }
  if (joyY < 300 && Ey < Ymax) {
    Ey += 0.1;
  }
  calculateAngle(Ex, Ey);
  servo1.write(theta1);
  servo2.write(theta2);
  delay(pause);
  /*Tracer une ligne*/
  if (digitalRead(button1) != buttonState1)  // si le bouton1 est appuyé
  {
    Serial.println("Tracer une ligne");
    servo3.write(angleHIGH);  // lever le stylo
    delay(transitTime);
    GoToPoint(Xmin, Ey);  // aller au point le plus gauche
    delay(transitTime);
    servo3.write(angleLOW);  // baisser le stylo
    delay(transitTime);
    while (Ex < Xmax) {  // déplacer horizontalement le stylo vers la droite par millimètres
      Ex++;
      calculateAngle(Ex, Ey);
      servo1.write(theta1);
      servo2.write(theta2);
      delay(autoPause);
    }
    delay(transitTime);
    servo3.write(angleHIGH);  // lever le stylo
    Pen = 0;
    delay(transitTime);
  }
  /*Tracer un cercle*/
  if (digitalRead(button2) != buttonState2) {
    Serial.println("Tracer un cercle");
    servo3.write(angleHIGH);  // lever le stylo
    delay(transitTime);
    float theta = 0;
    float startX = centerX + R * cos(theta);
    float startY = centerY + R * sin(theta);
    GoToPoint(startX, startY);  // aller au point de l'angle de 0 rad
    delay(transitTime);
    servo3.write(angleLOW);  // baisser le stylo
    delay(transitTime);
    while (theta < 2 * PI) {  // allons de 0 rad à 2*pi rad
      theta = theta + 0.1;    // augmenter l'angle de 0.1 rad
      Ex = centerX + R * cos(theta);
      Ey = centerY + R * sin(theta);
      calculateAngle(Ex, Ey);
      servo1.write(theta1);
      servo2.write(theta2);
      delay(autoPause);
    }
    delay(transitTime);
    servo3.write(angleHIGH);  // baisser le stylo
    Pen = 0;
    delay(transitTime);
  }
  /*Tracer une ligne pointillée*/
  if (digitalRead(button3) != buttonState3) {
    Serial.println("Tracer une ligne pointillée");
    servo3.write(angleHIGH);
    delay(transitTime);
    GoToPoint(Xmin, Ey);
    Ex = Xmin;
    delay(transitTime);
    servo3.write(angleLOW);
    Pen = 1;
    delay(transitTime);
    while (Ex < Xmax) {
      Ex++;
      if ((int)Ex % 5 == 0)  // lever ou baisser le stylo tous les 5 mm
      {
        PenUpDown();
      }
      calculateAngle(Ex, Ey);
      servo1.write(theta1);
      servo2.write(theta2);
      delay(autoPause);
    }
    delay(transitTime);
    servo3.write(angleHIGH);
    Pen = 0;
    delay(transitTime);
  }
  /*Tracer un cercle pointillé*/
  if (digitalRead(button4) != buttonState4) {
    Serial.println("Tracer un cercle pointillé");
    servo3.write(angleHIGH);
    delay(transitTime);
    float theta = 0;
    float startX = centerX + R * cos(theta);
    float startY = centerY + R * sin(theta);
    GoToPoint(startX, startY);
    delay(transitTime);
    servo3.write(angleLOW);
    Pen = 1;
    delay(transitTime);
    while (theta < 360) {          // allons de 0° à 360°
      theta = theta + 1;           // augmenter l'angle de 1°
      if ((int)theta % 15 == 0) {  // lever ou baisser le stylo tous les 15°
        PenUpDown();
      }
      Ex = centerX + R * cos(radians(theta));
      Ey = centerY + R * sin(radians(theta));
      calculateAngle(Ex, Ey);
      servo1.write(theta1);
      servo2.write(theta2);
      delay(15);
    }
    delay(transitTime);
    servo3.write(angleHIGH);
    Pen = 0;
    delay(transitTime);
  }
}

/* Loi entrée/sortie du modèle géométrique direct*/
void calculatePosition(float x, float y) {
  /*Ajuster à l'angle des servos*/
  x = 180 - x;
  y = 180 - y;

  x = radians(x);
  y = radians(y);
  float Dx = L * cos(x);
  float Dy = L * sin(x);
  float Cx = D + L * cos(y);
  float Cy = L * sin(y);
  float P = sqrt(pow(Cx - Dx, 2) + pow(Cy - Dy, 2));
  float alpha1 = acos(P / (2 * L));
  float alpha2 = atan((Cy - Dy) / (Cx - Dx));
  Ex = Dx + L * cos(alpha1 + alpha2);
  Ey = Dy + L * sin(alpha1 + alpha2);
}

/* Loi entrée/sortie du modèle géométrique inverse*/
void calculateAngle(float x, float y) {
  float n = sqrt(pow(x, 2) + pow(y, 2));
  float m = sqrt(pow(D - x, 2) + pow(y, 2));
  float alpha1 = acos(n / (2 * L));
  float alpha2 = acos(m / (2 * L));
  float beta1 = atan(y / x);
  float beta2 = atan(y / (D - x));
  theta1 = alpha1 + beta1;
  theta2 = PI - (alpha2 + beta2);
  theta1 = degrees(theta1);
  theta2 = degrees(theta2);

  /*Ajuster à l'angle des servos*/
  theta1 = 180 - theta1;
  theta2 = 180 - theta2;
}
/*Lever ou baisser le stylo*/
void PenUpDown() {
  if (Pen == 1)  // si le stylo touche le papier
  {
    servo3.write(angleHIGH);  // lever le stylo
    Pen = 0;
  } else  // sinon
  {
    servo3.write(angleLOW);  // baisser le stylo
    Pen = 1;
  }
}
/*Réglage de vitesse*/
void setSpeed() {
  speed = 0;
  while (speed == 0) {
    while (!Serial.available()) {
      delay(1);  // attandre de recevoir la commande de l'utilisateur
    }
    while (Serial.available()) {
      delay(2);  // délai pour permettre au buffer de se remplir
      if (Serial.available() > 0) {
        char c = Serial.read();
        message += c;
      }
    }
    Serial.print("La vitesse : ");
    Serial.print(message);
    if (message != "0\n") {  // si la vitesse commandée n'est pas de 0
      speed = message.toInt();
      pause = (int)(10 - speed * 2);
      Serial.println(pause);
    }
    message = "";
  }
}
/*Aller au point désigné*/
void GoToPoint(float x, float y) {
  while (Ex < x - 0.1 || Ex > x + 0.1 || Ey < y - 0.1 || Ey > y + 0.1) {
    if (Ex < x && Ex < Xmax) {
      Ex += 0.1;
    }
    if (Ex > x && Ex > Xmin) {
      Ex -= 0.1;
    }
    if (Ey < y && Ey < Ymax) {
      Ey += 0.1;
    }
    if (Ey > y && Ey > Ymin) {
      Ey -= 0.1;
    }
    calculateAngle(Ex, Ey);
    servo1.write(theta1);
    servo2.write(theta2);
    delay(1);
  }
}
/*Vérification de fonctionnalités*/
void check() {
  Serial.println("Coordonnées");
  Serial.println(Ex, 4);
  Serial.println(Ey, 4);
  Serial.println(theta1, 4);
  Serial.println(theta2, 4);
  Serial.println("Etats des boutons");
  Serial.println(digitalRead(button1));
  Serial.println(digitalRead(button2));
  Serial.println(digitalRead(button3));
  Serial.println(digitalRead(button4));
  Serial.println("Etat du joystick");
  Serial.println(digitalRead(SW_pin));
  Serial.println(analogRead(X_pin));
  Serial.println(analogRead(Y_pin));
  delay(1000);
}

4. Fabrication :

Nous avons procédé à la fabrication de nos pièces en utilisant différentes technologies en fonction de leur géométrie. Certaines pièces ont été fabriquées par impression 3D, tandis que d'autres ont été découpées au laser.

Pour cette phase de fabrication, nous avons utilisé les machines du FabLab et suivi les documentations fournies. Nous avons ainsi appris à utiliser les logiciels Inkscape pour la découpe laser et Ideamaker pour l'impression 3D, sur lesquels nous avons importé les mises en plan de nos pièces. Ces outils nous ont permis de préparer nos fichiers de conception.

Par ailleurs lors de la fabrication, nous avons remarqué quelques soucis techniques, pour cela nous avons dû revoir quelques aspects de la CAO. Certaines dimensions ont dû être légèrement modifiées, quand bien même dans la majeure partie des cas, limer un peu les pièces était suffisant. En revanche, la modification la plus importante concerne la liaison pignon - crémaillère, puisque nous avons réalisé que nous avions fait l’erreur de ne pas prévoir de guidage pour la translation de la crémaillère. Pour pallier cela, nous avons donc ajouté un pilier au sein de la crémaillère, collé à la bielle inférieure, évitant ainsi les degrés de liberté non désirés.

figure(20)

Pour ce qui est des liaisons pivots, l’écrou assurant la MAP étant en contact avec la bielle, celui-ci était entraîné en rotation et se dévissait légèrement, créant du jeu. Pour résoudre ce problème, quand bien même l’idéal aurait été de prendre cela en compte dans la CAO, nous avons usé d’écrous freins, qui ont pour avantage de ne pas se dévisser.

On peut finalement noter que pour certaines pièces réalisées par découpe laser telles que les pièces du bâti, certaines parties de la MAP n’étaient pas présentes dans la CAO, ce qui s’explique par le fait qu’elles ont été collées entre elles. 

Après avoir fabriqué toutes les pièces, nous les avons toutes assemblées afin de réaliser notre robot final et par la suite exécuter le programme et faire des tests afin de vérifier son bon fonctionnement. 

5. Tests :

Après avoir finalisé l'assemblage de notre robot, nous avons réaliser les tâches demandées dans le cahier de charge en exécutant le code : une ligne droite de 5cm, une ligne pointillée de 5cm, un cercle de 2.5cm et un cercle en pointillé de rayon 2.5cm.  Nous avons également essayer de reproduire un dessin à l'aide d'un joystick.

Résultat : ces tâches ont été réalisées avec succès par le robot.

6. Conclusion et points d'amélioration :

Pour conclure, ce projet nous a permis de mettre en pratique nos différents acquis théoriques  au cours de notre formation, nous montrant également l'importance de la théorie avant sa concrétisation. À travers ce projet, nous avons pu atteindre nos objectifs initiaux en concevant un système robotique divisé en quatre axes : mécanique, actionnement, commande et interface de pilotage.

De plus, ce projet nous a permis de comprendre l'importance du travail en équipe. Nous avons appris à nous organiser au sein du groupe en répartissant et synchronisant les tâches, afin de gérer le temps et les délais du projet. En nous entraidant face à chaque difficulté, nous avons relevé tous les défis possibles, démontrant ainsi que l'union fait la force.

Ce projet nous a également donné l'occasion de découvrir et de maîtriser un nouvel environnement de travail, le FabLab, ce qui nous a permis d'accéder directement aux technologies de fabrication.

Si jamais nous devions refaire ce projet, certaines améliorations seraient nécessaires. Tout d’abord, nous avons manqué de rigueur dans le dimensionnement des pièces, ce qui a conduit à un système surdimensionné. Concernant les bielles, il est important de bien délimiter l’espace de travail du robot pour éviter les singularités. Le problème provient également de l'épaisseur excessive de nos pièces, qui aurait pu être réduite. Un autre point à améliorer est celui des liaisons pivots entre les bielles, pour lesquelles l’utilisation de roulements aurait permis de réduire les frottements.

En somme, ce projet a été une expérience enrichissante, nous permettant d’appliquer nos connaissances théoriques, de travailler efficacement en équipe et de nous familiariser avec des technologies de pointe, tout en identifiant des domaines où nous pouvons encore progresser.