Le projet présenté ici consiste à faire dessiner un bras robotisé muni d’un crayon sur une feuille de papier. Un très bon exercice pour programmer et piloter correctement un bras robotisé.

Matériel

  • Bras robotisé Handy
  • 4x Servomoteur SMS1012
  • Driver de servomoteurs ou servo shield
  • alimentation 5V
  • Câble USB
  • Carte Arduino UNO

 

Objectif

Obj: Dessiner un cercle à l’aide d’un bras robotisé

Pour réaliser ce projet il nous faut:

  • Monter le bras robotisé (Structure)
  • Réaliser le montage électronique permettant le contrôle du bras et l’alimentation électrique (Hardware)
  • Développer le programme permettant de piloter la séquence de servomoteur afin de décrire une forme dans l’espace (Software)

 

Bras robotisé

Obj: La structure doit pouvoir porter un crayon et se déplacer dans les trois dimensions de l’espace.

Le bras Handy est utilisé pour ce projet. Les moteurs choisis sont des micro servomoteur 9g léger, bon marché et simple d’utilisation.

Le bras est monté avec ses servomoteurs et son support est fixé à une planche. Pour ce projet nous avons aussi dessiné et imprimé un porte crayon que vous pouvez télécharger ici.

 

Hardware

Obj: L’électronique doit pourvoir distribuer l’alimentation à la carte de contrôle ainsi qu’aux servomoteurs et piloter les servomoteurs à l’aide d’un signal PWM.

  • arduino UNO

Les cartes Arduino sont simple d’utilisation, de nombreuses librairies sont disponibles et disposent d’une communauté d’entraide importante. Le programme nécessitant un peu de mémoire vive, nous avons opté pou la carte Arduino UNO.

La carte arduino est alimentée soit le PC à l’aide du câble USB.

  • driver de servomoteur

La carte Arduino ne peut pas alimenter autant de servomoteurs il est donc nécessaire d’ajouter un driver au montage.

Un driver de servomoteurs a été fabriqué en suivant ce tutoriel, et est alimenté à l’aide de piles en série.

Software

Objectif du programme

Couchons sur papier les objectifs du programme et déclinons-les en tâches à réaliser

  • Décrire les coordonnées de la forme dans l’espace
  • Transformer les coordonnées dans l’espace du cercle en angle des articulations du robot.
  • Contrôler la position du robot
  • Convertir les angles du robot en en commande pour le servomoteur
  • Envoyer une commande au servomoteur

 

Décrire les coordonnées de la forme dans l’espace

La forme choisie est un cercle pour sa simplicité. Les équations paramétriques d’un cercle dans l’espace sont:

Pour la coordonnée en z nous prenons la taille du crayon soit 20mm.

Nous écrivons une fonction qui retourne la position cible Xd du robot en fonction du pas de temps:

void circleTraj(double R,double x,double y,double z,int i,double Te, float Xd[6]){
        Xd[0]=x+R*cos(2*PI*Te*i);
        Xd[1]=y+R*sin(2*PI*Te*i);
        Xd[2]=z;
        Xd[3]=0;
        Xd[4]=0;
        Xd[5]=0;
}

 

Transformer les coordonnées dans l’espace du cercle en angle des articulations du robot.

Le bras robotisé peut être décrit comme une chaine robotique par la méthode de Denavit-Hartenberg. Cette méthode est intéressante pour piloter un bras avec plus de trois articulations.

 

Cette méthode consiste à définir un repère cartésien pour chaque articulation en suivant la même logique et qui permet de définir des paramètres pour décrire mathématiquement les mouvements de chaque lien dans l’espace.

Définir les paramètres de chaque lien robotique en fonction de la géométrie(paramètre DH)

j Sigmaj Thetaj Dj (mm) Aj (mm) alphaj
1 0 Th1 45 0 90
2 0 Th2 0 75 0
3 0 Th3 0 75 0
4 0 Th4 4 0 -90

 

Le calcul des angles moteurs désirés en fonction de la position désirée passe par l’inversion de la matrice Jacobienne définie à l’aide des paramètres DH. Pour les calculs matriciels, nous utilisons la librairie MatrixMath.h

 

void computeAngle(){
float J[6][nbLinks];
float Jt[nbLinks][6];
float JJt[nbLinks][nbLinks];
float invJ[nbLinks][6];
double detJ;
//    compute jacobian
jacobian(sig,a,al,d,th,q,nbLinks,(float*)J);
// avoid singularity
Matrix.Transpose((float*)J,6,nbLinks,(float*)Jt);
Matrix.Multiply((float*)Jt, (float*)J, nbLinks, 6, nbLinks,(float*)JJt);
detJ=detrm(JJt,nbLinks);
// invert jacobian
if(detJ>=1){
Matrix.Invert((float*)JJt,nbLinks);
Matrix.Multiply((float*)JJt,(float*)Jt,nbLinks,nbLinks,6,(float*)invJ);
}
for(int i=0;i<nbLinks;i++){
qu[i]=0;
for(int j=0;j<6;j++){
qu[i]+=invJ[i][j]*Xu[j];
}
}
}

 

Fonction permettant de convertir les angles du robot en commande pour le servomoteur

La conversion des angles en commande PWM dépend du positionnement des servomoteurs, des valeurs nominales de PWM, ainsi que de la convention des repères cartésiens utilisés pour décrire les articulations du robot dans l’espace.
La conversion est différente pour chaque servomoteur.

 

Servo/Joint Min impulse Max impulse Min robot Max robot
1 500 2500 -PI/2 PI/2
2 500 2500 PI 0
3 600 2600 -PI/2 PI/2
4 500 2500 -PI/2 PI/2

 

 

int jointToImp(double x,int i) {
int imp=(x - joint_min[i]) * (imp_max[i]-imp_min[i]) / (joint_max[i]-joint_min[i]) + imp_min[i];
imp=max(imp,imp_min[i]);
imp=min(imp,imp_max[i]);
return imp;  
}

 

Envoyer une commande au servomoteur

Pour piloter les servomoteurs, nous utilisons la librairie Servo.h disponible de base dans l’IDE d’Arduino. Nous écrivons une fonction qui envoie la commande PWM à chaque servomoteur en fonction de l’angle demandé.

void servoToImp(double q[nbLinks],int velocity){
for (int i=0; i<nbLinks; i++) {
servo[i].writeMicroseconds(jointToImp(q[i],i));
delay(velocity);  
}
}

 

Fonction permettant le contrôle du robot

Pour contrôler les servomoteurs, il faut, à chaque instant, comparer la position désirée du robot à sa position actuelle

On calcul donc la position du robot en fonction des angles moteurs. Pour cela nous utilisons les matrices de transformation définies par la méthode de Denavit-Hartenberg.

        forwardKinematics(sig,a,al,d,th,q,nbLinks,X);

 

On applique le contrôleur pour calculer la prochaine position du robot

        circleTraj(20,165,0,20,k,Te,Xd);
circleTraj(20,165,0,20,k+1,Te,Xk);
for(int i=0;i<6;i++) Xu[i]=(Xk[i]-Xd[i]+gain*Te*(Xd[i]-X[i]));

 

On détermine les angles moteurs pour atteindre la prochaine position

        for(int i=0;i<nbLinks;i++) qN1[i]=q[i];
computeAngle();
for(int i=0;i<nbLinks;i++) q[i]=qN1[i]+qu[i];

 

On applique la commande PWM à chaque servomoteur

        servoToImp(q,10);

 

Résultat

 

Le moteur dessine sur la feuille et suit la trajectoire définie.

 

Si vous souhaitez de l’aide avec votre bras robotisé ou si vous désirez plus d’information sur ce projet, n’hésitez pas à laisser un commentaire ou à nous contacter.

Référence

programmer avec Arduino

Pilotez un servomoteur avec Arduino

méthode Denavit-Hartenberg

Vous pouvez retrouver le robot ici.

Handy