Caballon

Un émulateur est un logiciel qui permet de reconstituer par modélisation une plateforme hardware. Les plus joueurs d’entre nous connaissent les émulateurs des anciennes consoles sur PC qui permettent de jouer aux mêmes jeux.

En robotique, la plateforme hardware que nous n’avons pas, c’est l’ensemble muscles-squelette. Cet ensemble nous permet de faire des mouvements à la fois fluides et puissants et que l’on reconnait assez facilement. Pourtant, on s’en rend compte quand un robot ressemble trait pour trait à un homme (comme un androïde), quand il ne bouge pas, il est troublant… quand il bouge, il fait peur. La perception que l’on a du mouvement est très fine. D’autant plus qu’un mouvement optimal n’est pas notre priorité.

Nous n’avons pas de muscles en robotique (à part les muscles pneumatiques mais ils sont encore mauvais du point de vue efficacité) mais nous avons des moteurs. Les techniques de contrôle et d’asservissement des moteurs sont maintenant plus que poussées pour une application industrielle précise au micron près. Par contre, la science du geste (et non de la trajectoire) est encore un domaine réservé aux marionnettistes. Comment réconcilier gestuelle et moteurs ? Comment générer un geste et non pas un mouvement ?

Où en sont les chercheurs ?

Où en sont les marionnettistes ?

Même si je trouve le travail de Meka Robotics très intéressant, on voit un énorme fossé du point de vue du mouvement et surtout du geste. Cependant, Ahmed n’a pas de servomoteurs… (enfin je crois)

Les solutions pour résoudre ce problème est de regarder comment fonctionne une articulation, de l’impulsion nerveuse au mouvement et aussi d’observer le travail du marionnettiste. Le tout en s’appuyant sur ce qu’il est possible de faire en contrôle-commande et informatique.

Comment fonctionne le muscle ?

Quand le moteur génère une vitesse quand il a une tension, le muscle génère un effort quand il reçoit un train d’impulsions plus ou moins rapprochées. La curiosité pousse à savoir qu’est-ce qu’il se passe dans cette « usine ».

Un muscle a une forme de fuseau avec de part et d’autre des tendons qui sont rattachés aux os. Ce muscle est une illustration de la géométrie fractale puisqu’il est lui-même composé de fibres musculaires, composées elles-même de cellules musculaires, composées elles-même de myofibrilles. (le préfixe « myo » précise que l’on parle de muscle). Une myofibrille est le composant chimique qui génère le mouvement. Une myofibrille est composée de deux éléments : l’actine et la myosine.Ces deux molécules sont des filaments qui s’enchevêtrent et qui se tirent les unes des autres. Pour cela elles consomment les réserves d’énergie du muscle (sous la forme de la molécule d’ATP qui libère de l’énergie en se coupant en ADP+P). La vidéo ci-dessous montre bien ce qu’il se passe. Je compare souvent la myosine à un rameur d’aviron et l’actine à l’eau.

Seulement, l’accrochage entre la myosine et l’actine est conditionnée par un autre élément : le calcium. S’il n’ a pas de calcium, la myosine n’adhère pas à l’actine et il n’y a pas de traction. Ceci implique que la concentration en calcium dans une cellule musculaire va déterminer le niveau de traction. Il faut savoir que dans tout le corps il y a des ions calcium et que dans une cellule musculaire, il existe des organes qui ont pour fonction d’évacuer les ions calcium (comme des pompes). Ainsi, quand une impulsion nerveuse arrive au muscle, elle ouvre des canaux dans la membrane de la cellule et naturellement (pour rétablir le déséquilibre de concentration) les ions calcium vont entrer. Plus on va exciter la cellule, plus la quantité de calcium injectée va être forte, plus la force générée va être importante. Par contre, quand l’excitation s’arrête, le taux de calcium diminue plus lentement à cause des pompes à calcium.

Ainsi, un muscle va se contracter instantanément mais se décontracter au bout d’un certain moment.

Une petite expérience que vous pouvez faire chez vous est de vous mettre de profil contre un mur et de pousser fortement ce mur avec votre bras pendant une dizaine de secondes. Ensuite, mettez vous au centre de la pièce en décontractant vos bras… le bras montera tout seul jusqu’à ce que la concentration en calcium soit trop faible.

Cet effet de rémanence musculaire, nous ne le percevons pas et nous ne l’avons pas. La raison est que les muscles travaillent par deux. Un muscle a toujours au moins un antagoniste qui va tirer dans le sens opposé. Ainsi, ce phénomène de rémanence du muscle qui se décontracte est gommé par la réactivité du muscle antagoniste qui se contracte rapidement.

Si on simplifie le problème, un couple appliqué sur une articulation par un muscle augmente plus rapidement qu’il ne décroit.

Modélisation musculaire

La plupart des moteurs que l’on utilise en robotique sont des servomoteurs qui sont asservis en position angulaire. Le travail d’émulation consiste à calculer la position que doit prendre le servomoteur pour que sont comportement soit équivalent à une articulation musculaire. On pourra ainsi commander notre articulation en excitant plus ou moins l’un des deux muscles antagonistes.

Nous allons repartir des bases : la dynamique.

La somme des couples appliqués à un solide est proportionnel à son accélération angulaire avec un coefficient appelé moment d’inertie dépendant de la forme et de la répartition des masses de ce solide.

Dans notre cas, l’os est soumis à 4 couples :

• le couple du poids de l’os
• le couple du muscle direct
• le couple du muscle antagoniste
• un couple d’amortissement

Dans un micro contrôleur, une fois que l’on a calculé chaque couple, il faut en déduire la position. C’est ce que l’on appelle résoudre une équation différentielle. Dans notre cas c’est simple. Si la somme des couples est égale à 4N.m et que mon inertie est égale à 1kg/m², cela veut dire que l’accélération sera de 4rad/s². donc si la fréquence de calcul du micro contrôleur est de 10ms, en 10ms la vitesse de mon moteur aura augmentée de 0.04rad/. Donc sur 10ms, la position aura évolué de 0.0004rad. Si on fait ce calcul simple toutes les 10ms, on obtient bien le comportement qu’aurait une articulation musculaire.

La tête

Les mouvements de la tête sont justement très intéressants à analyser. On peut découpler le contrôle de l’axe de tangage (oui-oui) de l’axe de lacet (non-non). Si on émule une telle tête en prenant aussi en compte que le centre de gravité de la tête est haut par rapport au cou et qu’il est légèrement avancé, on trouve que quand tous les muscles sont détendus, la tête tombe en avant (chose faite quand on s’endort). Voici un code de Thread C# faisant le calcul des 3 articulations du visage.

while (Thread.CurrentThread.IsAlive)
{
                 // declaration des variables locales
                 float pgama1,pgama2,tgama1,tgama2,agama1,agama2,ratio;
                 ratio=100;
                 // calcul des couples moteurs stockés dans un tableau et multiplié par un ratio de réglage
                 pgama1=couples[0]/ratio;
                 pgama2=-couples[1]/ratio;
                 tgama1=couples[2]/ratio;
                 tgama2=-couples[3]/ratio;
                 agama1=couples[4]/ratio;
                 agama2=-couples[5]/ratio;

                 // equation du cou : (pp = derive deux fois, p = derive une fois)
                 // psi = angle de lacet (non-non)
                 psipp=(pgama1+pgama2-az*psip)/Izz;
                 psip=psip+dt*psipp;
                 psi=psi+dt*psip;

                 // equation de la nuque
                 // theta = angle de tangage (oui-oui)
                 // d = déport vers l'avant du centre de gravité de la tête
                 tetapp=(tgama1+tgama2-d*(float)Math.Cos(teta)*M*10-ax*tetap)/Ixx;
                 tetap=tetap+dt*tetapp;
                 teta=teta+dt*tetap;

                 // equation de l'oeil
                 // alpha = angle entre la direction des yeux et l'axe normal au visage.
                 alphapp=(agama1+agama2-aeye*alphap)/Ieye;
                 alphap=alphap+dt*alphapp;
                 alpha=alpha+dt*alphap;
                 //on sature les angles en butée
                 if(psi<=psimin)
                 {
                     psi=psimin;psipp=0;psip=0;
                 }
                 if(psi>=psimax)
                 {
                     psi=psimax;psipp=0;psip=0;
                 }
                 if(teta<=tetamin)
                 {
                     teta=tetamin;tetapp=0;tetap=0;
                 }
                 if(teta>=tetamax)
                 {
                     teta=tetamax;tetapp=0;tetap=0;
                 }
                 if(alpha<=alphamin)
                 {
                     alpha=alphamin;alphap=0;
                 }
                 if(alpha>=alphamax)
                 {
                     alpha=alphamax;alphap=0;
                 }
}

L’implémentation de ce code est pratique puisque cela permet de travailler sur une tête virtuelle sans avoir la vraie tête CBN. Par contre, quand la tête CBN y est branchée, elle duplique le comportement de la tête virtuelle (et tombe en avant au démarrage comme prévu).

• Le but du jeu est de trouver l’excitation des muscles qui va rendre le modèle gestuel.
• Si on observe maintenant le marionnettiste, on observe plusieurs points :
• Les mouvements sont saccadés et rapides lors de phases d’énervement
• quand il fixe quelqu’un, les yeux sont en face des trous et le visage face entièrement face à la personne
• les sourcils sont super expressifs
• dans tous les cas, le nez est une flèche qui montre vers qui est adressé la parole
• le mouvement de la bouche n’a pas besoin d’être évolué, ouverture/fermeture suffit
• quasiment tout passe par les yeux

Le but n’est pas de reproduire fidèlement tous ces comportements mais de savoir d’où ils viennent pour qu’ils viennent chez le robot comme de l’intérieur d’un être vivant. Le jour où il existera un robot avec la même expressivité que Ahmed, cela cassera pas mal de barrières.

A suivre…

Related posts: