Table des matières

Cinématique d'un système de solides

1. Introduction

L'objectif est de définir un algorithme permettant de calculer le mouvement d'un système de solides cinématiquement contraint. Il s'agit d'un ensemble de solides indéformables reliés par des liaisons (pivot, glissière, etc.) et dont la configuration à tout instant est entièrement définie par des données cinématiques. La plupart des machines et des robots constituent des systèmes de ce type, avec une configuration contrôlée par des moteurs ou des vérins. Le système manivelle-bielle est un exemple (figure ci-dessous). Il permet de convertir un mouvement de rotation en mouvement de translation, ou inversement.

biellemanivelle.svgFigure pleine page

Le solide (1) est fixé au bâti. La manivelle (2) est en liaison pivot avec (1). La bielle (3) est en liaison pivot avec (2) et en liaison pivot avec le solide (4), lequel est contraint de se déplacer en translation dans la direction X. Un moteur fixé dans le solide (1) contrôle l'orientation du solide (2). Il s'agit de déterminer la configuration du système, en particulier la position du solide (4).

Nous limiterons l'étude au cas des systèmes subissant un mouvement plan.

2. Mise en équation

2.a. Répérage des solides

On utilise un repère fixe OXY lié au bâti, le repère global. La position d'un solide dans le plan est déterminée par trois variables : les deux coordonnées d'un point lié au solide (par exemple son centre de masse) et un angle définissant son orientation. Ces trois variables seront désignées comme les coordonnées du solide. Il a donc a priori trois degrés de liberté. Nous associons à chaque solide un repère qui lui est lié, appelé le repère propre du solide. Pour le solide numéro i, soit Oi l'origine de ce repère et (xi,yi) les deux axes. La figure suivante montre un choix possible pour chacun des quatre solides du système pris en exemple :

biellemanivelle-reperes.svgFigure pleine page

Soit Ri=OOi le vecteur définissant la position du point Oi lié au solide i. Dans le repère global OXY, les coordonnées du point Oi sont notées (Rix,Riy). L'orientation du solide est définie par l'angle θi=(OX,Oixi). La position du solide est donc définie par les trois variables (Rix,Riyi).

Soit Pi un point lié au solide i : ses coordonnées (xPi,yPi) dans le repère (Oi,xi,yi) sont constantes. Ses coordonnées dans le repère OXY sont données par :

XPi=Rix+xPicos(θi)-yPisin(θi)(1)YPi=Riy+xPisin(θi)+yPicos(θi)(2)

Il s'agit d'une transformation affine, que l'on peut aussi mettre sous la forme matricielle suivante :

(XpiYpi)=(RixRiy)+(cos(θi)-sin(θi)sin(θi)cos(θi))(xpiypi)(3)

2.b. Contraintes cinématiques

Sans la prise en compte des contraintes cinématiques, un système de N solides comporte 3N degrés de liberté. Les liaisons présentes dans le système réduisent le nombre de degrés de liberté. Dans l'exemple considéré, la liaison du solide (1) avec le bâti fixe ses trois degrés de liberté. Une liaison pivot enlève deux degrés de liberté au système. La liaison glissière entre le solide (4) et le support enlève deux degrés de liberté. Finalement, il reste pour cet exemple 12-3-2-2-2-2=1 degré de liberté. Supposons qu'un moteur impose la valeur de θ2, il ne reste plus aucun degré de liberté. En imposant la valeur de θ2 (ou de toute autre variable), on impose la configuration du système. Il s'agit de déterminer cette configuration, c'est-à-dire les valeurs des 3N variables suivantes :

q=(R1x,R1y,θ1,R2x,R2y,θ2,,RNx,RNy,θN)(4)

Une contrainte cinématique est une équation reliant des variables du système, c'est-à-dire des variables de la matrice q. Chaque contrainte enlève un degré de liberté au système. Nous allons voir comment s'expriment ces équations pour quelques liaisons.

2.c. Liaison encastrement

Deux solides reliés par un encastrement forment un seul système indéformable. Dans l'exemple, le solide 1 est en liaison encastrement avec le bâti. Ses trois coordonnées (R1x,R1y1) sont donc fixées (par exemple à des valeurs nulles). En pratique, deux solides encastrés peuvent être définis par un seul solide. On s'intéresse donc uniquement à l'encastrement d'un solide avec le bâti lié au référentiel (OXY), qui s'exprime par les trois équations suivantes :

R1x-R1x0=0(5)R1y-R1y0=0(6)θ1-θ10=0(7)

Les trois constantes sont notées avec un exposant 0. Nous avons donc trois contraintes, définies par trois équations que l'on écrira sous la forme (C1(q)=0,C2(q)=0,C3(q)=0). Ces trois équations enlèvent trois degrés de liberté au système. Nous appellerons fonctions de contraintes les fonctions Ck.

Nous aurons aussi besoin des dérivées partielles de ces fonctions par rapport aux variables qu'elles contiennent :

C1R1x=1(8)C2R1y=1(9)C3θ1=1(10)

2.d. Liaison pivot

Dans le cas d'un mouvement plan, la liaison pivot entre deux solides (i et j) impose un point fixe commun aux deux solides. Il existe donc un point (et un seul) lié au solide i, noté Pi, qui coïncide à tout instant avec un point lié au solide j, noté Pj.

pivot.svgFigure pleine page

Dans le repère OXY, la liaison pivot s'exprime donc par les deux équations :

XPi-XPj=0(11)YPi-YPj=0(12)

Écrivons ces deux équations explicitement en fonction des coordonnées des deux solides et des coordonnées des deux points dans les repères de chaque solide :

Rix+xPicos(θi)-yPisin(θi)-Rjx-xPjcos(θj)+yPjsin(θj)=0(13) Riy+xPisin(θi)+yPicos(θi)-Rjy-xPjsin(θj)-yPjcos(θj)=0(14)

Les coordonnées (xPi,yPi,xPj,yPj) sont des constantes puisque les points Pi et Pj sont liés respectivement au solide i et au solide j; elles définissent la position de la liaison pivot dans le repère propre de chacun des deux solides. Nous obtenons donc deux équations que l'on écrira sous la forme (C1(q)=0,C2(q)=0), qui enlèvent deux degrés de liberté au système.

Les dérivées partielles de ces fonctions sont :

C1Rix=1(15)C1Rjx=-1(16)C1θi=-xPisin(θi)-yPicos(θi)(17)C1θj=xPjsin(θj)+yPjcos(θj)(18) C2Riy=1(19)C2Rjy=-1(20)C2θi=xPicos(θi)-yPisin(θi)(21)C2θj=-xpPjcos(θj)+yPjsin(θj)(22)

2.e. Glissière horizontale

Dans l'exemple considéré, le solide (4) est contraint de se déplacer en translation dans la direction X. Il s'agit d'un cas particulier de liaison glissière. La liaison glissière en général étant beaucoup plus complexe à mettre en équation, nous traitons à part ce cas simple, que l'on peut qualifier de glissière horizontale. Cette liaison s'exprime par les deux équations suivantes :

Riy-Riy0=0(23)θi-θi0=0(24)

2.f. Liaison glissière

Dans la liaison glissière, le mouvement du solide j par rapport au solide i se limite à une translation de long d'un axe. Soient Pi un point lié au solide i et Pj un point lié au solide j tels que la droite (PiPj) soit l'axe de translation. On a aussi besoin d'un point Qi lié au solide i tel que les vecteurs QiPi et PiPj soient orthogonaux.

glissiere.svgFigure pleine page

La liaison glissière s'exprime par les deux contraintes suivantes (θ0 est une constante) :

θi-θj-θ0=0(25)PiPjQiPi=0(26)

Pour exprimer la seconde condition à l'aide des coordonnées des deux solides, écrivons tout d'abord les composantes des deux vecteurs :

u=Rix+xPicos(θi)-yPisin(θi)-Rjx-xPjcos(θj)+yPjsin(θj) (27)v=Riy+xPisin(θi)+yPicos(θi)-Rjy-xPjsin(θj)-yPjcos(θj)(28)a=(xPi-xQi)cos(θi)-(yPi-yQi)sin(θi)(29)b=(xPi-xQi)sin(θi)+(yPi-yQi)cos(θi)(30)

La seconde contrainte s'écrit alors :

ua+vb=0(31)

Notons C2(q)=0 cette dernière équation. Les dérivées partielles de C2(q)=ua+vb se calculent aisément.

2.g. Variable imposée

Pour qu'un système soit cinématiquement contraint, il faut enlever les degrés de liberté restant après prise en compte des liaisons, en imposant les valeurs d'un nombre de variables égal au nombre de degrés de liberté restant. Dans l'exemple considéré, il reste un degré de liberté après la prise en compte des liaisons, que l'on élimine en imposant la valeur de θ2, ce qui correspond en pratique à un contrôle effectué par un moteur. L'équation exprimant cette condition s'écrit :

θ2-f(t)=0(32)

f(t) est une fonction du temps qui exprime la position angulaire imposée par le moteur, par exemple f(t)=ωt pour une vitesse angulaire constante.

3. Algorithme

3.a. Principe

Pour un système comportant N solides, donc n=3N degrés de liberté, notons q=(q1,q2,qn) les 3N variables R1x,R1y,θ1,R2x,R2y,θ2,,RNx,RNy,θN . Si le système est cinématiquement contraint, il y a n équations (C1(q)=0,C2(q)=0,Cn(q)=0) qui expriment les 3N contraintes. Par exemple, deux équations sont associées à chaque liaison pivot. Il faut résoudre ce système d'équations afin de déterminer q. Il s'agit d'un système d'équations non linéaires, car certaines contraintes s'expriment par une relation non linéaire entre les variables (c'est le cas des liaisons pivot et glissière).

Si le problème est bien posé, le système admet au moins une solution, mais il peut en admettre plusieurs. Par exemple, le système bielle-manivelle admet plusieurs solutions : la bielle peut être orientée vers la droite ou vers la gauche et il y a deux orientations possibles pour le solide 4, ce qui fait en tout quatre solutions. En pratique, on s'intéresse à une seule de ces solutions car on suppose que le mouvement se fait continûment à partir d'une condition initiale donnée. Par exemple, la bielle (solide 3) ne peut pas se retourner d'un seul coup.

3.b. Méthode de Newton-Raphson

La méthode de Newton-Raphson permet d'obtenir une solution du système d'équations suivant :

Ck(q2,q2,qn)=0(k=1,2,n)(33)

Il s'agit d'une méthode itérative reposant sur le développement de Taylor suivant :

Ck(q1+δq1,q2+δq2,qn+δqn)=Ck(q1,q2,qn)+i=1nCkqiδqi+O(δq2) (34)

Supposons que l'on dispose de valeurs (q1,q2,qn) proches de la solution cherchée. On recherche les incréments (δq1,δq2,,δqn) permettant de réaliser Ck(q1+δq1,q2+δq2,qn+δqn)=0 . En limitant le développement de Taylor à l'ordre 1, cette condition s'écrit :

Ck(q1,q2,qn)+i=1nCkqiδqi=0(35)

Il s'agit d'un système d'équations linéaires pour (δq1,δq2,,δqn) . Afin de l'écrire sous forme matricielle, on introduit la matrice jacobienne définie par :

J=(C1q1C1q2C1qnC2q1C2q2C2qnCnq1Cnq2Cnqn)(36)

Les éléments de cette matrice carrée sont Jki=Ckqi . La k-ième ligne contient donc les dérivées partielles de la k-ième fonction de contrainte. Si l'on note δq la matrice colonne contenant les inconnues (δq1,δq2,,δqn) et C la matrice colonne contenant les n valeurs Ck(q1,q2,qn) pour k=1,n , alors le système linéaire à résoudre s'écrit :

Jδq=-C(37)

Ce système est résolu par la méthode d'élimination de Gauss-Jordan. Les valeurs (δq1,δq2,,δqn) obtenues permettent de calculer une nouvelle approximation (q1+δq1,qn+δqn) plus proche de la solution, à condition que la première estimation soit assez proche de la solution. La procédure est appliquée itérativement, ce qui permet de s'approcher de plus en plus de la solution. Les itérations sont stoppées lorsqu'on estime que les incréments δqi sont assez petits, par exemple lorsque l'inégalité suivante est vérifiée :

i=1n(δqi)2 < ε(38)

ε est une tolérance qui devra être d'autant plus faible que l'on souhaite une bonne précision.

Supposons que l'on cherche les configurations du système obtenues en faisant varier un paramètre, l'angle θ2 dans notre exemple. Il est parfois possible de choisir une valeur initiale du paramètre qui permette de calculer à la main les coordonnées initiales des solides. Dans le cas contraire, il faudra choisir des coordonnées initiales proches de la solution cherchée, assez proches pour que l'itération de Newton-Raphson converge effectivement vers cette solution. Chaque nouvelle valeur du paramètre est obtenue à partir de la précédente par un petit incrément, de telle sorte que la nouvelle solution soit très proche de la précédente. Dans ces conditions, la méthode de Newton-Raphson converge rapidement vers la nouvelle solution. Si une discontinuité de mouvement d'un des solides est observée, il faut réduire l'incrément de variation du paramètre.

4. Implémentation

4.a. Principe

L'objectif est de concevoir un ensemble de fonctions permettant de définir un système mécanique quelconque et d'accomplir le calcul de sa configuration avec l'algorithme décrit ci-dessus. Il devra aussi être en mesure de représenter graphiquement les solides. Une animation du mouvement du système (lorsqu'on fait varier un paramètre) permettra de vérifier le bon déroulement des calculs.

Avant de penser à coder l'algorithme à proprement parler, il faut bien réfléchir aux structures de données que l'on va utiliser, car un mauvais choix peut rendre l'algorithme très difficile à implémenter.

4.b. Implémentation des solides

Un solide est défini par ces trois coordonnées Rix,Riy,θi . Il faut aussi définir sa représentation graphique. Pour faire au plus simple, on définira un contour sous la forme d'une liste de points à relier par des segments. Les coordonnées de ces points doivent être données dans le repère propre de chaque solide, car elles sont fixes dans ce repère. Nous aurons aussi besoin d'une fonction pour tracer le contour. Lorsqu'un système comporte plusieurs objets similaires (ici les solides) avec des fonctions permettant de les manipuler, il est intéressant d'utiliser la programmation orientée objet. Pour définir des objets permettant de représenter les solides, il faut définir une classe, qui représente une classe d'objets similaires. Nous allons définir une classe intitulée Solide. Un objet comporte des données et des fonctions agissant sur ces données. En python, on ne déclare pas explicitement les données (car celle-ci sont créées dynamiquement au moment de l'exécution) mais on doit définir les fonctions. Voici la définition de la classe que nous allons utiliser :

class Solide:
    def __init__(self,Rx,Ry,theta,contour=[]):
        self.Rx = Rx
        self.Ry = Ry
        self.theta = theta
        self.contour = contour
        self.line = None
    def coord_point(self,xp,yp):
        # xp,yp : coordonnées d'un point lié au solide dans le repère propre
        cos = numpy.cos(self.theta)
        sin = numpy.sin(self.theta)
        X = self.Rx + xp*cos-yp*sin
        Y = self.Ry + xp*sin+yp*cos
        return [X,Y]
    def dessiner(self,ax):
        liste_x = []
        liste_y = []
        for k in range(len(self.contour)):
            p = self.contour[k]
            XY = self.coord_point(p[0],p[1])
            liste_x.append(XY[0])
            liste_y.append(XY[1])
        self.line, = ax.plot(liste_x,liste_y,"-",linewidth=2)
    def redessiner(self,ax):
        liste_x = []
        liste_y = []
        for k in range(len(self.contour)):
            p = self.contour[k]
            XY = self.coord_point(p[0],p[1])
            liste_x.append(XY[0])
            liste_y.append(XY[1])
        self.line.set_data(liste_x,liste_y)
                         

Une classe comporte obligatoirement une fonction __init__ qui est appelée pour créer l'objet (fonction constructeur). Dans notre cas, cette fonction prend en argument les coordonnées initiales de l'objet et la définition de son contour. Voici comment créer un objet :

solide_1 = Solide(0.1,0,0,[[-0.1,0],[0.1,0]])

L'appel de la fonction portant le nom de la classe exécute la fonction __init__ de cette classe. On remarque que le premier argument de cette fonction, nommé self, n'apparaît pas dans l'appel. Il représente l'objet qui est en train d'être créé et qui est en fait renvoyé par le constructeur. Les variables associées à l'objet sont créées dans __init__. Par exemple la ligne self.Rx=Rx crée une variable numérique nommée Rx et lui attribue la valeur de l'argument nommé Rx (on utilise le même nom pour la clarté).

Toutes les autres fonctions de la classe ont un premier argument self qui représente l'objet particulier qui doit être traité. Par exemple, la fonction coord_point, dont le rôle est de calculer les coordonnées d'un point lié au solide, se sert de l'argument self pour désigner l'objet sur lequel la fonction agit, par exemple self.Rx désigne la variable Rx de l'objet en cours de traitement. Voyons comment utiliser cette fonction avec l'objet créé ci-dessus :

[X,Y] = solide_1.coord_point(1,0)

La référence de l'objet (solide_1) n'est pas fournie avec les autres arguments mais juste avant le point. Elle est transmise à la fonction par l'argument self. Il faut remarquer que le mot self n'est pas un mot clé de Python mais un nom adopté par l'usage. On peut en principe donner le nom que l'on veut à ce premier argument, bien qu'il n'y ait aucune raison de ne pas utiliser self. Le plus important est de ne pas oublier ce premier argument dans les définitions des fonctions de la classe. Bien entendu, on doit utiliser la syntaxe self. à chaque fois qu'on veut accéder à une variable de la classe. Les autres variables apparaissant dans les fonctions, par exemple la variable cos, sont des variables locales, qui cessent d'exister à la fin de la fonction.

4.c. Implémentation des contraintes

Une contrainte est définie par une fonction c(q) qui renvoie une valeur fonction des coordonnées des solides. Une liaison entre deux solides comporte plusieurs contraintes, par exemple deux pour la liaison pivot. Pour chaque contrainte, il n'y a que deux solides concernés, mais l'argument q est un tableau comportant les coordonnées des solides mises à plat. La difficulté de l'implémentation réside dans le grand nombre de types de liaison, chacune ayant ses propres fonctions de contrainte. La programmation orientée objet donne une solution simple à cette difficulté. On commence par définir une classe modèle qui correspond à un ensemble de contraintes :

class Contraintes:
    def __init__(self):
        pass
    def c(q): 
        # définition de la contrainte (c(q)=0)
        # q : [Rx,Ry,theta,...] liste à plat des coordonnées des N solides
        pass
    def Jc(q):
        # définition des lignes du jacobien de C
        pass                       
                       

Cette classe se contente de définir le gabarit de deux fonctions. La fonction c(q) fournit les valeurs de plusieurs fonctions de contrainte (sous forme d'une liste) correspondant à une liaison d'un type donné. La fonction Jc(q) fournit les lignes de la matrice jacobienne pour ces contraintes.

Considérons le cas de la liaison encastrement d'un solide avec le bâti, consistant à fixer les trois coordonnées du solide. Nous définissons une classe pour implémenter cette liaison :

class SolideFixe(Contraintes):
    def __init__(self,i,Rx,Ry,theta):
        self.i = i
        self.Rx = Rx
        self.Ry = Ry
        self.theta = theta
    def c(self,q):
        c1 = q[3*self.i]-self.Rx
        c2 = q[3*self.i+1]-self.Ry
        c3 = q[3*self.i+2]-self.theta
        return numpy.array([c1,c2,c3])
    def Jc(self,q):
        Jc1 = numpy.zeros(len(q))
        Jc1[3*self.i] = 1
        Jc2 = numpy.zeros(len(q))
        Jc2[3*self.i+1] = 1
        Jc3 = numpy.zeros(len(q))
        Jc3[3*self.i+2] = 1
        return numpy.array([Jc1,Jc2,Jc3])   
                        

Dans la déclaration de la classe SolideFixe, on précise que la classe hérite de la classe Contraintes. Cette dernière ne fait rien d'autre que fixer un gabarit pour les fonctions. Dans la classe SolideFixe, ces fonctions sont implémentées et un constructeur est introduit, pour traiter le cas particulier de la liaison encastrement. Le constructeur prend en argument l'indice i qui permet d'itentifier le solide dans une liste. Les autres paramètres transmis sont les trois valeurs de coordonnées à fixer. La fonction c(self,q) calcule les valeurs des trois fonctions de contrainte, qui doivent s'annuler lorsque la contrainte est effectivement réalisée. On remarque que la liste q (qui peut aussi être un tableau ndarray à une dimension) est une liste à plat des coordonnées de tous les solides du système. En conséquence, la première coordonnée du solide d'indice i se trouve à l'indice 3*self.i de ce tableau. La fonction Jc(self,q) calcule et renvoie les trois lignes de la matrice jacobienne correspondant aux trois contraintes.

Pour la liaison pivot, la classe correspondante (à compléter) est :

class Pivot(Contraintes):
    def __init__(self,i,j,xpi,ypi,xpj,ypj):
        self.i = i
        self.j = j
        self.xpi = xpi
        self.ypi = ypi
        self.xpj = xpj
        self.ypj = ypj
    def c(q):
        # à compléter
    def Jc(q):
        # à compléter
                              

Pour cette liaison, on doit fournir les indices des deux solides et les coordonnées locales des points Pi et Pj liés respectivement au solide i et au solide j.

Voici la classe de la liaison glissière horizontale (à compléter) :

class GlissiereHorizontale(Contraintes):
    def __init__(self,i,Y):
        self.i = i
        self.Y = Y
    def c(q):
        # à compléter
    def Jc(q):
        # à compléter
                              

La liaison glissière entre deux solides est définie par :

class Glissiere(Contraintes):
    def __init__(self,i,j,xpi,ypi,xqi,yqi,xpj,ypj,angle):
        self.i = i
        self.j = j
        self.xpi = xpi
        self.ypi = ypi
        self.xqi = xqi
        self.yqi = yqi
        self.xpj = xpj
        self.ypj = ypj
        self.angle = angle
    def c(q):
        # code fourni dans le fichier annexe
    def Jc(q):
        # code fourni dans le fichier annexe
                              

Voici la classe permettant de fixer l'angle d'un solide à une valeur (qui pourra varier au cours du temps) :

class Angle(Contraintes):
    def __init__(self,i,theta):
        self.i = i
        self.theta = theta
    def c(q):
        # à compléter
    def Jc(q):
        # à compléter
                              

4.d. Système et calcul de la configuration

Nous devons finalement définir une classe Systeme qui stocke la définition du système (solides et contraintes) et qui implémente l'algorithme de calcul de la configuration, c'est-à-dire le calcul des coordonnées des N solides, compte tenu de la présence des 3N contraintes.

class Systeme:
    def __init__(self):
        self.liste_solides = []
        self.liste_contraintes = []
        self.n = 0
    def ajouter_solide(self,solide):
        self.liste_solides.append(solide)
        self.n += 3
    def ajouter_contrainte(self,contrainte):
        self.liste_contraintes.append(contrainte)
    def dessiner(self,ax):
        for solide in self.liste_solides:
            solide.dessiner(ax)
    def redessiner(self,ax):
        for solide in self.liste_solides:
            solide.redessiner(ax)
    def coordonnees(self):
        # renvoie la liste des coordonnées des solides (q)
    def jacobien(self,q):
        # renvoie la matrice jacobienne J
    def C(self,q):
        #renvoie la liste des valeurs des Ck(q) (matrice colonne C)
    def calcul(self,tolerance,max_iter=100):
        # effectue le calcul de la configuration par la méthode de Newton
        # et modifie les coordonnées des solides
                    

Les données de l'objet Systeme sont : une liste d'objets Solide, une liste d'objets Contraintes, et le nombre de contraintes à fournir (3 fois le nombre de solides). Les deux listes sont remplies comme des piles mais chaque solide est référencé par son indice, c'est-à-dire son ordre d'entrée dans la pile. Lorsqu'on définit les contraintes, il faut déjà connaître l'indice de chaque solide. Dans une version plus évoluée, on pourra bien sûr mettre en place un mode de référencement plus facile à utiliser, par exemple en attribuant un nom à chaque solide.

Les différentes matrices (q,J,C) doivent être générées dans des tableaux ndarray.

Le cœur de l'algorithme (la méthode de Newton-Raphson) est implémentée dans la fonction calcul. Il peut arriver que la méthode de Newton ne converge pas, ce qui se traduit par l'impossibilité de parvenir au critère de convergence. Il faut donc prévoir un nombre maximal d'itérations à ne pas dépasser. Si ce nombre est atteint, la boucle est stoppée et un message d'erreur doit s'afficher. La résolution du système d'équations se fait avec la fonction numpy.linalg.solve (qui implémente la méthode d'élimination de Gauss). On remarquera que le calcul d'incrémentation des coordonnées peut se faire directement avec le tableau q et le tableau δq. Lorsque la boucle de calcul est terminée, c'est-à-dire lorsque le critère de convergence (38) est satisfait, il est nécessaire de mettre à jour les coordonnées des solides, car celles-ci sont utilisées par les fonctions de tracé.

5. Travaux pratiques

Télécharger le fichier systemeCinematique-TP.py, qui contient les définitions des classes, à compléter.

Télécharger le fichier bielle.py qui contient la simulation du système manivelle-bielle présenté dans le texte.

Effectuer la simulation du système présenté sur la figure suivante :

systeme-glissiere.svgFigure pleine page

Les solides (1) et (5) sont fixes. Le solide (2) est relié au solide (1) par une liaison pivot et au solide (3) par une liaison pivot. Le solide (3) est lié au solide (4) par une liaison glissière. Le solide (4) est lié au solide (5) par une liaison pivot. L'objectif est de contrôler par un moteur la rotation du bras (2) de manière à modifier l'inclinaison du bras (4).

6. Solution

systemeCinematique.py et glissiere.py

Creative Commons LicenseTextes et figures sont mis à disposition sous contrat Creative Commons.