Développement de contrôleurs pour la locomotion d'un robot by bdj93780

VIEWS: 0 PAGES: 38

									               Projet de semestre
                       au
        Laboratoire de Systèmes Logiques
                    Eté 2003




  Développement de contrôleurs pour la
locomotion d'un robot quadrupède à base
       d'oscillateurs non linéaires




                   Projet réalisé par
                Mathieu Salzmann

                  Sous la direction du
                Prof. Auke Ijspeert



                           1
Table des matières
Table des matières ...............................................................................................................2
1    Introduction .................................................................................................................4
2    Implémentation............................................................................................................4
  2.1     Stein .....................................................................................................................6
     2.1.1     Equations .....................................................................................................6
     2.1.2     Fichiers ........................................................................................................6
     2.1.3     Paramètres ...................................................................................................7
     2.1.4     Résultats.......................................................................................................7
  2.2     Van der Pol ..........................................................................................................9
     2.2.1     Equations .....................................................................................................9
     2.2.2     Fichiers ........................................................................................................9
     2.2.3     Paramètres .................................................................................................10
     2.2.4     Résultats.....................................................................................................11
  2.3     FitzHugh-Nagumo .............................................................................................13
     2.3.1     Equations ...................................................................................................13
     2.3.2     Fichiers ......................................................................................................13
     2.3.3     Paramètres .................................................................................................14
     2.3.4     Résultats.....................................................................................................14
  2.4     Conclusion sur l’implémentation.......................................................................16
3    Recherche ..................................................................................................................17
  3.1     Phase 1...............................................................................................................17
     3.1.1     But .............................................................................................................17
     3.1.2     Méthode .....................................................................................................17
     3.1.3     Résultats.....................................................................................................19
  3.2     Méthodes d’intégration......................................................................................19
     3.2.1     Euler...........................................................................................................20
     3.2.2     Runge-Kutta...............................................................................................20
     3.2.3     Cash-Karp Runge-Kutta ............................................................................21
     3.2.4     Dormand-Prince Runge-Kutta ...................................................................22
     3.2.5     Fehlberg Runge-Kutta ...............................................................................22
     3.2.6     Conclusion sur l’intégration ......................................................................23
  3.3     Phase 2...............................................................................................................24
     3.3.1     But .............................................................................................................24
     3.3.2     Méthode .....................................................................................................24
     3.3.3     Premier système de couplage ....................................................................24
        3.3.3.1 Analyse des résultats .............................................................................25
        3.3.3.2 Conclusion sur le premier système........................................................26
     3.3.4     Deuxième système de couplage.................................................................27
        3.3.4.1 Analyse des résultats .............................................................................27
        3.3.4.2 Conclusion sur le deuxième système.....................................................32
  3.4     Conclusion sur la recherche...............................................................................33
4    Simulation..................................................................................................................33


                                                                  2
  4.1    Fonctionnement .................................................................................................34
  4.2    Implémentation..................................................................................................34
  4.3    Résultats.............................................................................................................35
5    Conclusion et travaux futurs......................................................................................36
6    Annexe.......................................................................................................................37
7    Références .................................................................................................................37




                                                                 3
1 Introduction
Le but de ce projet est de développer des simulations numériques de contrôleurs de
locomotion pour un robot quadrupède à l’aide de Matlab. Ces contrôleurs sont modélisés
à l’aide d’oscillateurs non linéaires sous la forme d’équations différentielles.

L’idée principale est de permettre des transitions entre les divers modes de locomotion,
tels que marche, trot, saut, à l’aide de signaux de commande simples. Idéalement, ces
transitions doivent pouvoir se faire avec le changement d’un seul paramètre de l’équation
différentielle.

L’expérience effectuée par Shik, Severin et Orlovskii, article [8], a montré que, en
appliquant un signal tonique, c’est-à-dire non périodique, sur des chats décérébrés, on
pouvait obtenir différents types de démarche en variant la valeur du signal. Ils
observèrent que les types de démarche variaient par palier et ceci semble confirmer
l’hypothèse qu’il est possible de réaliser les transitions entre divers modes de locomotion
à l’aide de signaux de commande simples.

Matlab offrant la possibilité de résoudre les équations différentielles à l’aide de la
méthode de Runge-Kutta ainsi que de visualiser les signaux obtenus est un outil adéquat
pour la réalisation de ce projet.

Dans un premier temps, le travail effectué est d’implémenter et de vérifier les méthodes
proposées par Collins et Richmond dans leur article [1]. Trois méthodes sont introduites.
La première utilise le modèle neuronal de Stein, la seconde se base sur l’oscillateur de
Van der Pol et la dernière sur le modèle de Fitzhugh-Nagumo.

Ces méthodes n’étant pas satisfaisantes car elles contiennent une composante périodique
et ainsi diffèrent de l’expérience décrite dans l’article [8], la deuxième partie du projet
consiste à explorer comment modifier ces équations afin de les rendre acceptables. Pour
ce faire, le modèle de Stein est utilisé en modifiant ses paramètres et le couplage des
oscillateurs.


2 Implémentation
Le système de l'article [1] a été testé avec trois types d’oscillateurs différents afin de
montrer que les résultats ne dépendent pas des équations utilisées, mais bien de la
variations des paramètres de ces équations. Collins et Richmond voulaient montrer
l’universalité des résultats, c’est-à-dire que la dynamique du système est indépendante de
l’implémentation des oscillateurs.
Les trois méthodes proposées dans l’article [1], bien que basées sur des systèmes
d’équations différents, présentent tout de même des similarités.


                                            4
La première de ces similarités est le couplage utilisé entre les oscillateurs. Dans les trois
cas, le couplage est identique et est le suivant :



                             1                        4




                             2                        3


où un lien entre deux oscillateurs représente l’inhibition d’un oscillateur sur un autre et
chaque lien a un poids de -0.2. Par exemple, l’oscillateur 1 inhibe l’oscillateur 2. Dans les
équations de ces méthodes, le poids du lien est représenté par λ ji .
Avec ce système, la marche est représentée par la suite des signaux 1, 3, 4 et 2. Chacun
de ces signaux est déphasé de 90° par rapport au précédent. Le trot revient à avoir les
signaux 1 et 3 en phase, déphasés de 180° par rapport aux signaux 2 et 4 qui sont en
phase eux aussi. Le saut (ou galop) est caractérisé par les signaux 1 et 4 en phase,
déphasés de 180° par rapport aux signaux 2 et 3 qui sont en phase eux aussi. On
considère ici que le saut et le galop sont équivalents. En effet cette hypothèse est
raisonnable, car dans le saut, les pattes avants sont en phase et déphasées de 180° par
rapport aux pattes arrières qui sont en phase, alors que dans le galop, un léger déphasage
est introduit entre les deux pattes avants et entre les deux pattes arrières, ce qui ne
modifie que très peu l’apparence globale des signaux.
Collins et Richmond n’expliquent pas la manière utilisée pour mesurer le déphasage entre
deux signaux, mais ils donnent une tolérance de ± 10% sur le déphasage pour que celui-ci
soit considéré comme correspondant à une valeur connue.
D’autre part, dans les trois méthodes, les paramètres des équations sont égaux pour les
quatre oscillateurs. C’est-à-dire que pour une démarche, les quatre oscillateurs ont les
mêmes valeurs de paramètres.
De plus, dans les trois cas, les transitions du saut à la marche et du saut au trot ne peuvent
pas être effectuées directement. Il faut doubler brusquement les paramètres contrôlant la
fréquence du signal directeur pour deux oscillateurs. Cette méthode est appelée « power-
pair strategy ».




                                              5
2.1 Stein
2.1.1 Equations
Le modèle de Stein a été implémenté à l’aide de Matlab en utilisant les équations
suivantes :
                                                 1                
                   xi = a ∗  − xi +
                    &                                              
                                    1 + exp(− f ci − byi − bz i ) 

                        yi = xi − py i
                        &

                        z i = xi − qz i
                        &

                                                          4           
                        f ci = f * 1 + k1 sin (k 2 t ) + ∑ λ ji * x j 
                                                         j =1         


2.1.2 Fichiers
Le fichier ‘stein.m’ correspond à l’implémentation de ces équations pour les quatre
                                                                                     &&
oscillateurs. La fonction ‘stein’ retourne un vecteur de longueur douze représentant x, y
   &
et z pour chaque oscillateur.
Les paramètres passés à la fonction représentent le temps, le vecteur x, y, z pour chaque
oscillateur, et les paramètres des équations.
Les valeurs initiales pour x, y, et z de chaque oscillateur sont les suivantes :
                       x1=0.47, y1=0, z1=0
                       x2=0.55, y2=0, z2=0
                       x3=0.47, y3=0, z3=0
                       x4=0.13, y3=0, z3=0
Ces valeurs ont été choisies par l’essai en tenant compte des déphasages et des valeurs
maximale, minimale et moyenne trouvées pour un oscillateur non couplé. Dans l’article
[1], rien ne précise les conditions initiales si ce n’est le fait qu’elles doivent respecter les
déphasages relatifs, mais les résultats semblent montrer que ce choix convient. En
utilisant d’autres valeurs initiales, les signaux obtenus ne correspondent absolument plus
à ceux recherchés. Soit ils oscillent mais ne donnent pas un type de démarche voulu, soit
ils n’oscillent plus du tout.
Le fichier ‘stein_sol.m’ contient l’initialisation et le changement de valeur des paramètres
ainsi que l’appel à la fonction Matlab ode45 permettant de résoudre les équations
différentielles spécifiées dans le fichier ‘stein.m’ par la méthode de Runge-Kutta. Les
résultats sont affichés à l’aide de la fonction ‘plot’ de Matlab.
Finalement, le fichier ‘stein_trans.m’ est utilisé lors de certaines transitions exigeant un
traitement particulier des paramètres.


                                                   6
2.1.3 Paramètres
Pour obtenir les différents types de locomotion du quadrupède, l’article [1] propose de
faire varier les paramètres selon le tableau suivant :


Paramètre               Marche                     Trot                  Saut
a                       10.0                       12.0                  16.0
f                       40.0                       40.0                  50.0
k1                      0.0                        0.1                   0.1
k2                      0.0                        57.0                  59.0


Pour passer d’un type de locomotion à un autre, il suffit de changer les valeurs des
paramètres, sauf dans le cas d’une transition saut-marche ou saut-trot où l’on utilise la
stratégie « power-pair ». Celle-ci consiste à faire passer le paramètre f à 130.0 et le
paramètre k1 à 0.5 pour les oscillateurs 3 et 4. Les autres paramètres ainsi que les deux
autres oscillateurs gardent les valeurs correspondant au saut. Cette transition est
appliquée pendant deux cycles des oscillateurs et ensuite, les paramètres sont rétablis aux
valeurs souhaitées, c’est-à-dire correspondant à la marche ou au trot.


2.1.4 Résultats
L’implémentation des oscillateurs de Stein montre en effet que ceux-ci permettent
d’obtenir les trois types de marches désirés. Les transitions marche-trot, marche-saut,
trot-marche et trot-saut sont bien réalisable par la variation des paramètres, et les deux
transitions saut-marche et saut-trot sont faisables à l’aide de la stratégie « power-pair ».
La transition saut-trot est plus difficile à réaliser. Il faut appliquer le signal de transition
« power-pair » bien plus longtemps que pour la transition saut-marche.
Le seul problème de cette méthode est qu’il est impossible de commencer avec du trot.
Pour obtenir cette démarche, il faut d’abord passer par la marche ou le saut et effectuer la
transition sur le trot. Ce problème est mentionné dans l’article [1].
On peut aisément reconnaître les trois types de démarche en observant les graphiques ci-
dessous. La marche se caractérise par les quatre différents signaux séparés par le même
intervalle de temps. Le trot est représenté par des signaux groupés deux à deux (1 et 3, 2
et 4) et chaque groupe est séparé du précédant par le même intervalle de temps. Le saut se
présente comme le trot mais les groupes sont différents (1 et 4, 2 et 3).
Dans l’ensemble, les résultats montrent que cette méthode fonctionne et donne les mêmes
résultats que ceux présentés dans l’article [1].




                                               7
0.55
                                                                                                                   0.55


 0.5
                                                                                                                    0.5


0.45                                                                                                               0.45


 0.4                                                                                                                0.4



0.35                                                                                                               0.35


                                                                                                                    0.3
 0.3


                                                                                                                   0.25
0.25

                                                                                                                    0.2
 0.2

                                                                                                                   0.15
0.15

                                                                                                                    0.1
         8.35     8.4    8.45     8.5      8.55     8.6        8.65          8.7          8.75      8.8                      16.7    16.75     16.8      16.85         16.9    16.95    17     17.05     17.1     17.15
                                             temps [s]                                                                                                                    temps [s]




                Figure 1: Stein marche                                                                                           Figure 2: Stein trot

 0.7
                                                                                                                    0.6


                                                                                                                   0.55
 0.6
                                                                                                                    0.5


 0.5                                                                                                               0.45


                                                                                                                    0.4

 0.4
                                                                                                                   0.35


                                                                                                                    0.3
 0.3
                                                                                                                   0.25


                                                                                                                    0.2
 0.2

                                                                                                                   0.15


 0.1                                                                                                                0.1
       26.9     26.95    27      27.05     27.1    27.15           27.2       27.25         27.3      27.35               9.8        9.9            10          10.1          10.2      10.3      10.4          10.5
                                            temps [s]                                                                                                                     temps [s]




                Figure 3: Stein saut                                                                                             Figure 4: Stein marche-trot

                                                                                                                    0.6
 0.7
                                                                                                                   0.55


 0.6                                                                                                                0.5


                                                                                                                   0.45

 0.5
                                                                                                                    0.4


                                                                                                                   0.35
 0.4

                                                                                                                    0.3

 0.3
                                                                                                                   0.25


                                                                                                                    0.2
 0.2

                                                                                                                   0.15

 0.1
                                                                                                                    0.1
         55      55.2   55.4    55.6     55.8       56      56.2      56.4         56.6      56.8         57              19.8      20       20.2        20.4          20.6      20.8    21      21.2      21.4        21.6
                                                temps [s]                                                                                                                 temps [s]




                Figure 5: Stein marche-saut                                                                                      Figure 6 : Stein trot-marche




                                                                                                               8
                                                                                                                 Stratégie Powerpair
                                                                                                      0.9


    0.7                                                                                               0.8



    0.6                                                                                               0.7



                                                                                                      0.6
    0.5


                                                                                                      0.5
    0.4

                                                                                                      0.4

    0.3
                                                                                                      0.3


    0.2
                                                                                                      0.2



    0.1                                                                                               0.1

          19.8    20   20.2   20.4       20.6           20.8   21          21.2   21.4                      72        72.5   73      73.5         74    74.5   75   75.5
                                       temps [s]                                                                                            temps [s]




                 Figure 7: Stein trot-saut                                                                       Figure 8: Stein saut-marche


                                                               Stratégie Powerpair

                                     0.9



                                     0.8


                                     0.7



                                     0.6


                                     0.5



                                     0.4



                                     0.3


                                     0.2



                                     0.1

                                                   40               40.5            41         41.5              42           42.5                 43
                                                                                         temps [s]




                                                                       Figure 9: Stein saut-trot



2.2 Van der Pol
2.2.1 Equations
Le modèle de Van der Pol a été implémenté avec Matlab en utilisant les équations
suivantes :
                  &&i + µ * ( x ai − p 2 ) * xi + g 2 * x ai = q * [1 + k1 sin(k 2 t )]
                  x             2
                                             &
                                                                       4
                                           x ai = xi + ∑ λ ji * x j
                                                                      j =1


2.2.2 Fichiers
Le fichier ‘vdp.m’ correspond à l’implémentation de ces équations pour les quatre
                                                                                  &
oscillateurs. La fonction ‘vdp’ retourne un vecteur de longueur huit représentant x et
&& pour chaque oscillateur.
x



                                                                                          9
                                                                         &
Les paramètres passés à la fonction représentent le temps, le vecteur x, x pour chaque
oscillateur, et les paramètres des équations.
                                &
Les valeurs initiales pour x et x de chaque oscillateur sont les suivantes :
                             &
                       x1=0, x 1=1
                             &
                       x2=4, x 2=-1
                              &
                       x3=-4, x 3=1
                             &
                       x4=0, x 3=-1
Ces valeurs ont été choisies par l’essai en tenant compte des déphasages et des valeurs
maximale, minimale et moyenne trouvées pour un oscillateur non couplé. Dans l’article
[1], rien ne précise les conditions initiales si ce n’est le fait qu’elles doivent respecter les
déphasages relatifs, mais les résultats semblent montrer que ce choix convient. D’autres
valeurs ne donnent plus du tout les signaux rechercher et même parfois ne donnent plus
d’oscillation.
Le fichier ‘vdp_sol.m’ contient l’initialisation et le changement de valeur des paramètres
ainsi que l’appel à la fonction Matlab ode45 permettant de résoudre les équations
différentielles spécifiées dans le fichier ‘vdp.m’ par la méthode de Runge-Kutta. Les
résultats sont affichés à l’aide de la fonction ‘plot’ de Matlab.
Finalement, le fichier ‘vdp_trans.m’ est utilisé lors de certaines transitions exigeant un
traitement particulier des paramètres.


2.2.3 Paramètres
Pour obtenir les différents types de locomotion du quadrupède, l’article [1] propose de
faire varier les paramètres selon le tableau suivant :


Paramètre               Marche                   Trot                    Saut
p2                      3.0                      3.0                     10.0
q                       0.0                      -25.0                   -25.0
k1                      0.0                      5.0                     5.0
k2                      0.0                      7.5                     7.5


Pour passer d’un type de locomotion à un autre, il suffit de changer les valeurs des
paramètres, sauf dans le cas d’une transition saut-marche ou saut-trot où l’on utilise la
stratégie « power-pair ». Celle-ci consiste à faire passer le paramètre q à -50.0 pour la
marche ou à -200 pour le trot et le paramètre k1 à 10.0 pour les oscillateurs 3 et 4. Cette
transition est appliquée pendant deux cycles des oscillateurs. Contrairement à la méthode
de Stein, les autres paramètres ainsi que les deux autres oscillateurs sont tout de suite
fixés aux valeurs souhaitées, c’est-à-dire correspondant à la marche ou au trot. On ne
garde pas les valeurs du saut pendant la stratégie « power-pair ».



                                              10
2.2.4 Résultats
Comme dans le cas de Stein, les oscillateurs de Van der Pol nous permettent d’obtenir les
trois types de démarche. On parvient aussi à réaliser les transitions marche-trot, marche-
saut, trot-marche et trot-saut par le changement des paramètres, ainsi que les transitions
saut-marche et saut-trot en utilisant la stratégie « power-pair ».
Malgré tout, cette méthode est bien plus sensible aux instants auxquels sont effectuées les
transitions que celle de Stein. En effet si les transitions trot-marche, saut-marche et saut-
trot ne sont pas effectuées lors du bon demi cycle, elles résultent en une démarche
erronée. Rien de ceci n’est mentionné dans l’article de Collins et Richmond, dans lequel
ils précisent par contre que la transition marche-trot est sensible à l’instant du cycle où
elle est effectuée, mais ceci n’a pas été observé dans cette implémentation.
Ceci nous fera préférer le modèle de Stein à celui de Van der Pol pour la partie recherche
du projet.




     4

                                                                                                4
     3
                                                                                                3

     2                                                                                          2


                                                                                                1
     1

                                                                                                0

     0
                                                                                                -1


     -1                                                                                         -2


                                                                                                -3
     -2
                                                                                                -4

     -3
                                                                                                -5


     -4                                                                                         -6

          10.5           11        11.5   12           12.5        13     13.5   14                  33.5      34        34.5         35            35.5        36        36.5
                                               temps [s]                                                                             temps [s]




                        Figure 10: Van der Pol marche                                                        Figure 11:Van der Pol trot


     6

                                                                                                4

     4
                                                                                                3


                                                                                                2
     2
                                                                                                1


     0                                                                                          0


                                                                                                -1

     -2
                                                                                                -2


                                                                                                -3
     -4
                                                                                                -4


     -6                                                                                         -5


                                                                                                -6

                 72.5         73          73.5                74        74.5          75                19     20   21          22     23      24          25        26   27     28
                                              temps [s]                                                                              temps [s]




                        Figure 12: Van der Pol saut                                                          Figure 13:Van der Pol marche-trot



                                                                                           11
6                                                                                               4


                                                                                                3
4
                                                                                                2

2
                                                                                                1


                                                                                                0
0

                                                                                                -1
-2
                                                                                                -2

-4                                                                                              -3


                                                                                                -4
-6

                                                                                                -5
-8
                                                                                                -6
     58        59        60      61              62          63        64                                 38        39              40                41             42         43
                               temps [s]                                                                                                  temps [s]




          Figure 14: Van der Pol marche-saut                                                                   Figure 15: Van der Pol trot-marche


                                                                                                                                Stratégie Powerpair

6
                                                                                                4


4
                                                                                                2

2


                                                                                                0
0



-2                                                                                              -2



-4
                                                                                                -4


-6

                                                                                                -6

-8


          39        40        41            42              43         44                             79       80   81    82         83       84           85   86        87   88    89
                                temps [s]                                                                                                 temps [s]




          Figure 16: Van der Pol trot-saut                                                                     Figure 17: Van der Pol saut-marche


                                                                                       Stratégie Powerpair

                                                 4


                                                 2


                                                 0


                                             -2


                                             -4


                                             -6


                                             -8


                                            -10


                                            -12



                                                      78    79    80        81   82        83        84        85    86        87
                                                                                 temps [s]




                                                           Figure 18:Van der Pol saut-trot




                                                                                 12
2.3 FitzHugh-Nagumo
2.3.1 Equations
Le modèle de FitzHugh-Nagumo a été implémenté avec Matlab en utilisant les équations
suivantes :
                                        x3
                    xi = c * ( yi + xi − i + f ci )
                    &
                                         3
                    yi = −( xi − a − byi ) / c
                    &
                                                           4           
                      f ci = f a + f b * k1 sin(k 2 t ) + ∑ λ ji * x j 
                                                          j =1         
La première de ces équations diffère de celle donnée dans l’article [1]. En effet, le terme
au cube a un signe négatif alors qu’il était donné avec un signe positif dans l’article.
Après avoir implémenté les équations comme données par Collins et Richmond, on
pouvait remarquer que les signaux obtenus divergeaient et n’oscillaient pas du tout. En
cherchant dans d’autres articles les équations de FitzHugh-Nagumo, l’erreur a pu être
rectifiée.

2.3.2 Fichiers
Le fichier ‘nagumo.m’ correspond à l’implémentation de ces équations pour les quatre
                                                                                     &
oscillateurs. La fonction ‘nagumo’ retourne un vecteur de longueur huit représentant x et
 &
y pour chaque oscillateur.
Les paramètres passés à la fonction représentent le temps, le vecteur x, y pour chaque
oscillateur, et les paramètres des équations.
Les valeurs initiales pour x et y de chaque oscillateur sont les suivantes :
                       x1=0.1, y1=0
                       x2=1.2, y2=0
                       x3=-0.8, y3=0
                       x4=0.1, y3=0
Ces valeurs ont été choisies par l’essai en tenant compte des déphasages et des valeurs
maximale, minimale et moyenne trouvées pour un oscillateur non couplé. Dans l’article
[1], rien ne précise les conditions initiales si ce n’est le fait qu’elles doivent respecter les
déphasages relatifs, mais les résultats semblent montrer que ce choix convient. Comme
précédemment, d’autres valeurs de conditions initiales ne donnent plus les bons signaux,
voire même plus d’oscillation.
Le fichier ‘nagumo_sol.m’ contient l’initialisation et le changement de valeur des
paramètres ainsi que l’appel à la fonction Matlab ode45 permettant de résoudre les
équations différentielles spécifiées dans le fichier ‘nagumo.m’ par la méthode de Runge-
Kutta. Les résultats sont affichés à l’aide de la fonction ‘plot’ de Matlab.



                                              13
Finalement, le fichier ‘nagumo_trans.m’ est utilisé lors de certaines transitions exigeant
un traitement particulier des paramètres.


2.3.3 Paramètres
Pour obtenir les différents types de locomotion du quadrupède, l’article [1] propose de
faire varier les paramètres selon le tableau suivant :


Paramètre              Marche                 Trot                   Saut
c                      0.75                   1.5                    1.5
fa                     0.0                    0.0                    1.0
fb                     1.0                    1.0                    1.5
k1                     0.0                    2.0                    2.0
k2                     0.0                    1.0                    1.0


Les essais effectués en utilisant ces valeurs de paramètres montrent qu’elles ne
permettent pas d’obtenir tous les types de démarche. En effet, seule la marche est
possible avec ces valeurs. Des essais m’ont permis de trouver d’autres valeurs convenant
mieux (changement de k1 et k2 pour le trot et le saut):


Paramètre              Marche                 Trot                   Saut
c                      0.75                   1.5                    1.5
fa                     0.0                    0.0                    1.0
fb                     1.0                    1.0                    1.5
k1                     0.0                    -0.6                   -0.5
k2                     0.0                    2.0                    1.5


Pour passer d’un type de locomotion à un autre, il suffit de changer les valeurs des
paramètres, sauf dans le cas d’une transition saut-marche ou saut-trot où l’on utilise la
stratégie « power-pair ». Celle-ci consiste à faire passer le paramètre fb à 10.0 et le
paramètre k1 à -4.0 pour les oscillateurs 3 et 4. Les autres paramètres ainsi que les deux
autres oscillateurs gardent les valeurs correspondant au saut. Cette transition est
appliquée pendant deux cycles des oscillateurs et ensuite, les paramètres sont rétablis aux
valeurs souhaitées, c’est-à-dire correspondant à la marche ou au trot.


2.3.4 Résultats
Les oscillateurs de FitzHugh-Nagumo avec les quelques modifications apportées par
rapport à l’article [1] permettent d’obtenir les trois démarches voulues. De même que
pour Stein, il est impossible de commencer par le trot. Il faut donc faire une transition
marche-trot pour obtenir cette démarche.


                                            14
Les transitions marche-trot, marche-saut, trot-marche et trot-saut peuvent être obtenue par
la variation des paramètres. La transition saut-marche est réalisée par la technique
« power-pair », mais est sensible à l’instant où elle est effectuée comme pour Van der
Pol. Par contre, la transition saut-trot est impossible à réaliser avec les paramètres choisis.
Il est difficile de savoir si cette transition serait possible étant donné qu’il a fallut faire
plusieurs modifications par rapport à l’article [1] pour obtenir des résultats.
Dans l’ensemble, il semble que cette méthode soit moins efficace que Van der Pol ou
Stein.




                                                                                               2
      1

                                                                                             1.5
    0.8


    0.6                                                                                        1


    0.4
                                                                                             0.5

    0.2
                                                                                               0
      0

                                                                                             -0.5
    -0.2


    -0.4                                                                                      -1


    -0.6
                                                                                             -1.5

    -0.8
                                                                                              -2
             54         56         58            60       62     64     66         68               160         162      164             166           168       170         172
                                              temps [s]                                                                              temps [s]




            Figure 19: Nagumo marche                                                                      Figure 20: Nagumo trot


                                                                                               2
      2


                                                                                             1.5
    1.5



      1                                                                                        1



    0.5                                                                                      0.5



      0                                                                                        0



    -0.5                                                                                     -0.5



     -1                                                                                       -1



    -1.5                                                                                     -1.5



     -2                                                                                       -2
      258   260   262        264        266         268    270   272   274   276                    94     96     98   100     102       104     106     108   110     112   114
                                              temps [s]                                                                              temps [s]




            Figure 21: Nagumo saut                                                                        Figure 22: Nagumo marche-trot




                                                                                        15
                                                                                       2
      2


                                                                                     1.5
    1.5


                                                                                       1
      1



    0.5                                                                              0.5



      0                                                                                0



    -0.5                                                                             -0.5



     -1                                                                               -1


    -1.5
                                                                                     -1.5


     -2
                                                                                      -2
            95       100    105             110         115         120                     515    520   525   530     535      540       545   550   555   560     565
                                    temps [s]                                                                                temps [s]




                 Figure 23: Nagumo marche-saut                                                    Figure 24: Nagumo trot-marche


                                                                                                                     Stratégie Powerpair
                                                                                       5
      2
                                                                                       4

    1.5
                                                                                       3

      1
                                                                                       2


    0.5                                                                                1


                                                                                       0
      0

                                                                                      -1
    -0.5

                                                                                      -2
     -1
                                                                                      -3

    -1.5
                                                                                      -4

     -2
                                                                                      -5
           195        200         205             210         215         220                     300    310     320         330        340     350   360     370
                                    temps [s]                                                                                 temps [s]




                 Figure 25: Nagumo trot-saut                                                      Figure 26: Nagumo saut-marche




2.4 Conclusion sur l’implémentation
Les résultats obtenus nous montrent que les méthodes employées par Collins et
Richmond dans l’article [1] permettent dans la plupart des cas de résoudre le problème
des démarches des quadrupèdes.
On voit clairement que le modèle de Stein est le plus performant. Il permet d’obtenir les
trois types de démarche et d’effectuer toutes les transitions sans y apporter aucune
modification.
Le modèle de Van der Pol est lui aussi assez efficace mis à part le fait que certaines
transitions sont sensibles à l’instant où elles sont effectuées.
Quant au modèle de FitzHugh-Nagumo, tel que présenté par Collins et Richmond, il ne
permet absolument pas de résoudre le problème, et même quelques modifications ne
suffisent pas à le rendre performant. Ceci contredit le principe d’universalité des résultats
prôné par Collins et Richmond selon lequel la dynamique du système ne dépendrait pas
de l’implémentation des oscillateurs. Il semble en fait que certains types d’oscillateurs ne
permettent pas d’obtenir la dynamique souhaitée.


                                                                                16
Les équations de Stein paraissant être les plus efficaces, elles seront donc utilisées pour la
suite du projet.


3 Recherche
Après avoir implémenté les équations telles que données dans l’article de Collins et
Richmond [1], la question était de savoir s’il était possible de supprimer la composante
périodique afin de n’avoir plus qu’un signal tonique, c’est-à-dire non oscillant, pour
réguler la marche du quadrupède. En effet il semble, selon l’expérience décrite dans
l’article [8], que les différents types de démarche d’un quadrupède ainsi que les
transitions de l’une à l’autre ne sont générées que par des signaux toniques. Les modèles
réalisés par Collins et Richmond nécessitent en plus un signal phasique.
Le but de cette partie de recherche est donc de vérifier si le système de Collins et
Richmond peut être modifié de manière à n'utiliser que des signaux toniques pour
changer le type de démarche d’un quadrupède.


3.1 Phase 1
3.1.1 But
Dans un premier temps, nous décidons d’observer les effets de la variation d’un
paramètre en gardant le couplage donné par l’article [1] et présenté au point 2. Les
équations de Stein seront utilisées en supprimant la partie k1 sin (k 2t ) représentant la
composante périodique. Un premier essai en prenant les valeurs de paramètres utilisées
lors de l’implémentation montre que, sans cette composante sinusoïdale, on obtient
toujours la marche et le saut. Malheureusement, le trot s’est changé en marche. Malgré
cela, la méthode semble bonne étant donné qu’il nous reste toujours deux types de
démarche sur les trois que nous cherchons à obtenir. Il faudra donc faire une étude
systématique des paramètres.
Le but de cette première phase de la recherche peut être formulé à l’aide de la question
suivante :

Question 1 : Est-il possible d’obtenir la marche, le trot et le saut avec le même système
             de couplage que précédemment, mais avec seulement des signaux toniques
             et en ne faisant varier qu’un seul paramètre de chaque oscillateur ?

3.1.2 Méthode
Le paramètre ‘a’ est choisi pour varier comme il semble avoir le plus grand effet sur le
déphasage des signaux et qu’il est le principal paramètre déterminant la fréquence
d’oscillation. On a pu remarquer en effet que lors de l’implémentation précédente, ce
paramètre changeait pour chaque démarche.
Nous feront donc varier ‘a’ indépendamment pour chaque oscillateur et pour chaque
ensemble de valeurs, nous vérifierons le déphasage entre les signaux afin de savoir si l’on
trouve de la marche, du trot, du saut ou une démarche inconnue. Chaque paramètre ‘a’
variera entre 5 et 20 par pas de 2.5. On testera aussi cette variation de ‘a’ pour deux


                                             17
valeur du paramètre ‘f’ comme celui-ci change pour la marche ou pour le saut. ‘f’ prendra
donc les valeurs 40 ou 50. Le schéma du système est présenté ci-dessous :


                a2 a1                                   a4 a3



                          1                        4




                          2                        3

où chaque poids de lien a une valeur de -0.2 comme dans le couplage de la phase
d’implémentation.

Pour faire la vérification des déphasages, le fichier « get_phases.m » a été implémenté.
La méthode utilisée est la suivante :
Une première supposition est que les signaux ont été calculés suffisamment longtemps
pour être stables. Tout d’abord, calculer les maxima de chaque signal à l’aide de la
fonction Matlab « imregionalmax ». Celle-ci retourne un tableau contenant à chaque
position ‘1’ si la valeur correspondante du signal est un maximum local, ‘0’ sinon.
Ensuite, en partant de la fin du signal, trouver la valeur correspondant au dernier
maximum, puis chercher le prochain maximum ayant la même valeur (à une tolérance
près). En réalité, on n’utilise pas le dernier maximum car celui-ci est souvent faux. En
effet, si le signal était en train de monter à la fin des calculs, la fonction
« imregionalmax » considère que le dernier point est un maximum. On essaie donc de
trouver le dernier maximum global. Les indices des maxima choisis sont sauvés. Vérifier
ensuite les périodes valides. En effet, rien ne prouve que les maxima choisis
correspondent tous à une période correcte. On considère alors que la première période
trouvée est juste (ce qui est raisonnable si le signal est stable) et on vérifie que les
maxima suivant forment des périodes de même valeurs (dans une certaine tolérance) tout
en calculant la période moyenne du signal. Seuls les indices corrects sont conservés.
Une fois ceci effectué pour chaque signal, on compare les quatre périodes obtenues afin
de vérifier qu’elles sont semblables. Il est ensuite facile de calculer le déphasage d’un
signal par rapport à un autre comme on connaît les indices des maxima. Les déphasages
sont tous calculés par rapport au premier signal ce qui nous permet aisément de vérifier si
l’on obtient une démarche connue. On accepte une erreur de ±10% sur le déphasage
comme dans l’article de Collins et Richmond. Les démarches que nous cherchons à
retrouver sont, comme précédemment, la marche, le trot et le saut.




                                            18
Le fichier « test_param.m » contient le code principal qui fait varier le paramètre ‘a’ de
chaque oscillateur entre des valeurs choisies par pas fixés. On peut remarquer qu’une
phase de calcul ou les valeurs de ‘a’ sont fixées à 10 précède à chaque fois la phase de
calcul avec les véritables valeurs de ‘a’. En effet, comme on l’a vu lors de la phase
d’implémentation des équations de Stein, il est impossible d’obtenir directement le trot.
Cette première phase est donc de la marche qui nous permettrait de faire une transition
sur le trot.

Le fichier « new_stein.m » représente les équations de Stein pour chaque oscillateur dans
lesquelles la composante périodique a été supprimée.

3.1.3 Résultats
Cette première phase de recherche ne donne pas les résultats espérés. En effet un premier
test avec une valeur du paramètre f fixé à 40 pour chaque oscillateur nous donne de la
marche pour toutes les valeurs des paramètres a, sauf pour les valeurs (20, 20, 17.5, 20),
(20, 20, 20, 17.5) et (20, 20, 20, 20) où l’on obtient du saut. Pour ce test, les paramètres a
varient entre 5 et 20 par pas de 2.5.
Un second test avec 50 pour valeur du paramètre f nous donne à nouveau de la marche
pour beaucoup de valeurs de a sauf pour (15, 15, 15, 15) et (20, 20, 20, 20) où l’on
obtient du saut.
Bien entendu, dans les deux tests, une grande partie des valeurs de a ne donne aucune
démarche connue. Mais il semble difficile d’obtenir du trot avec le couplage proposé
dans l’article [1].
Ceci nous amène donc à la prochaine phase de la recherche dans laquelle nous testerons
divers couplages afin d’étendre l’observation des résultats.


3.2 Méthodes d’intégration

Lors de la phase 2 de la recherche, expliquée plus bas, nous essaierons différent
couplages pour lesquels nous testerons à nouveau la variation du paramètre ‘a’. Il aurait
été aisé d’utiliser les mêmes fichiers Matlab que lors de la première phase de recherche
en ajoutant la variation des poids de couplage, mais le temps pris par Matlab pour
exécuter les calculs d’un seul couplage était déjà tellement long (environ trois heures)
qu’il semblait plus judicieux de réimplémenter la méthode en C. Le principal problème
de l’implémentation est qu’il n’existe pas en C de méthode d’intégration prédéfinie
comme ode45 pour Matlab. Il a donc fallut en implémenter une. Le premier choix fut
Euler qui est sans doute la méthode la plus évidente. Les résultats n’étant pas
satisfaisants, d’autres méthodes, présentées ci-dessous, ont été testées. Afin de pouvoir
observer les résultats et les comparer avec ceux obtenus avec ode45, j’ai d’abord
implémenté ces méthodes sous Matlab avec le couplage connu et pour des valeurs de
paramètres donnant de la marche puis du saut. Toutes les méthodes d’intégration
implémentées, sauf Euler, sont basées sur Runge-Kutta avec un pas d’intégration
constant. La fonction ode45 de Matlab peut utiliser un pas variable, mais celui-ci sera
fixé afin de correspondre aux méthodes utilisées.



                                             19
3.2.1 Euler
La méthode d’intégration d’Euler consiste à ajouter à la valeur du signal x à chaque pas
de temps un certain delta x. Cette valeur est calculée à l’aide de la dérivée de x par
rapport au temps multipliée par la valeur du pas de temps. On reconstruit donc le signal
pas à pas grâce à sa dérivée. Cette méthode est décrite par l’équation suivante :

                                      dxt
                        xt +1 =xt +       dt
                                      dt


Afin de vérifier la stabilité des résultats, il faut choisir un pas de temps assez petit, faire
les calculs, puis diminuer de moitié ce pas et tester à nouveau. Si les valeurs sont toujours
les mêmes, on peut considérer que les résultats sont stables et utiliser le premier pas de
temps choisi.
Après avoir trouvé un pas de temps adéquat les résultats Matlab nous ont montré que
cette méthode ne correspondait pas à ode45. La phase de saut était bien identique, mais la
marche était transformée en saut. Il semble en effet que la méthode d’Euler soit moins
précise et, comme les signaux varient brusquement avant de se stabiliser, une partie des
informations était perdue, nous donnant ainsi des résultats différents. Ceci n’est pas très
surprenant, car on sait que la méthode d’Euler n’est pas la meilleure méthode
d’intégration. Il fallait donc utiliser une autre méthode.


3.2.2 Runge-Kutta
Etant donné qu’ode45 est basé sur la méthode de Runge-Kutta de quatrième ordre, il
semblait logique d’essayer cette méthode plus compliquée qu’Euler mais plus précise. En
effet, au lieu de ce baser sur une seule valeur de delta x comme dans Euler, Runge-Kutta
de quatrième ordre se base sur une moyenne pondérée de quatre approximations du
prochain point du signal. Cela demande donc plus de calcul pour chaque nouveau point,
mais permet d’être plus exact. Les équations, selon les documents du site [7] se
présentent ainsi :




                                               20
                                  dxt
                       k1 =h *
                                  dt
                                          k1
                                  d ( xt +    )
                       k 2 =h *            2
                                          h
                                  d (t + )
                                          2
                                          k
                                d ( xt + 2 )
                       k 3 =h *            2
                                          h
                                  d (t + )
                                          2
                                 d ( xt + k 3 )
                       k 2 =h *
                                  d (t + h)
                                    1
                       xt +1 =xt + * (k1 + 2k 2 + 2k 3 + k 4 ) + O(h 5 )
                                     6

où h représente le pas de temps. On peut donc voir que l’erreur est de l’ordre du pas de
temps à la puissance 5, ce qui est souvent négligeable. Les équations montrent bien que le
prochain x est calculé à l’aide de plusieurs coefficients k représentant le delta à ajouter à
la valeur précédente. Une même méthode que pour Euler nous permet de vérifier la
stabilité des résultats.
Malheureusement, bien qu’ode45 soit basé sur cette méthode, les résultats obtenus
n’étaient à nouveau pas semblables à ceux d’ode45 avec pas d’intégration fixe. La phase
marche du ficher test était de nouveau transformée en une phase saut. Un peu de
recherche, m’a ensuite permis de trouver d’autres variantes de Runge-Kutta utilisant une
pondération différente. Ces méthodes sont décrites ci-dessous.


3.2.3 Cash-Karp Runge-Kutta
Cette méthode, donnée dans les documents du site [7], est décrite par les équations
suivantes :

                                dxt
                       k1 =h *
                                dt
                                d ( xt + b21k1 )
                       k 2 =h *
                                 d (t + a 2 h)
                       ...
                                  d ( xt + b61k1 + ... + b65 k 5 )
                       k 6 =h *
                                           d (t + a 6 h)
                       xt +1 =xt + c1 k1 + c2 k 2 + c3 k 3 + c 4 k 4 + c5 k 5 + c6 k 6 + O(h 5 )

où les coefficients sont donnés dans le tableau suivant :



                                                   21
         i    ai                               bij                                     ci
         1                                                                 2825/27648
         2    1/5     1/5                                                  0
         3    3/10    3/40         9/40                                    18575/48384
         4    3/5     3/10         -9/10   6/5                             13525/55256
         5    1       -11/54       5/2     -70/27    35/27                 277/14336
         6    7/8     1631/55296   175/512 575/13824 44275/110592 253/4096 1/4
         j    =       1            2       3         4            5

         Une fois de plus, les résultats donnés par cette méthode ne correspondent pas à ode45 et
         la marche est à nouveau changée en saut. D’autres méthodes proposent d’autres valeurs
         de pondération.


         3.2.4 Dormand-Prince Runge-Kutta
         Cette méthode est, selon le site [2], celle utilisée par ode 45. Les mêmes équations que
         précédemment sont utilisées mais les coefficients k sont au nombre de sept. Les valeurs
         de pondération, trouvées dans l’article [5], sont présentées dans le tableau ci-dessous :


i   ai                                   bij                                                  ci
1                                                                                             5179/57600
2   1/5      1/5                                                                              0
3   3/40     3/40       9/40                                                                  7571/16695
4   4/5      44/45      -56/15     32/9                                                       393/640
5   8/9      19372/6561 -          64448/6561 -212/729                                        -
                        25360/2187                                                            92097/339200
6 1          9017/3168 -355/33     46732/5247 49/176                -                         187/2100
                                                                    5103/18656
7 1          35/384        0            500/1113       125/192      -2187/6784 11/84          1/40
j =          1             2            3              4            5          6

         Malgré le fait que cette méthode semble être celle utilisée par ode45, les résultats obtenus
         sont toujours les mêmes. La phase de marche est toujours une phase de saut. J’ai encore
         testé une dernière méthode présentée ci-dessous.


         3.2.5 Fehlberg Runge-Kutta
         Selon le site [3], cette méthode est celle utilisée par ode45 ce qui est en contradiction
         avec le site [2]. Malheureusement, la documentation de Matlab ne précise rien quant à la
         méthode exacte qu’ode45 utilise. La méthode de Fehlberg Runge-Kutta repose à nouveau
         sur les mêmes équations que précédemment (avec coefficients k1 à k6) avec la
         pondération, donnée sur le site [6], suivante :




                                                     22
i      ai                                  bij                                 ci
1                                                                              16/135
2     ¼         1/4                                                            0
3     3/8       3/32      9/32                                                 6656/12825
4     12/13     1932/2197 -         7296/2197                                  28561/56430
                          7200/2197
5     1         439/216   -8        3680/513 -845/4104                         -9/50
6     1/2       -8/27     2         -         1859/4104 -11/40                 2/55
                                    3544/2565
j     =         1         2         3         4         5

Là encore, mêmes résultats qu’avec les autres méthodes. Impossible d’obtenir les mêmes
signaux qu’en utilisant ode45 dans Matlab.


3.2.6 Conclusion sur l’intégration
Après avoir testé toutes ces méthodes d’intégration sans obtenir de résultats concluants,
nous sommes arrivés à la conclusion que le système d’équations de Stein utilisé dans ce
projet était très instable lorsque les signaux n’ont pas encore atteint de démarche fixe. En
effet, en observant le début des signaux, on remarque qu’ils sont semblables pour ode45
et une autre méthode d’intégration. Mais rapidement, une petite imprécision fait changer
le signal et nous obtenons finalement une trajectoire différente.
Une comparaison des signaux donnés par ode45 et Runge-Kutta de quatrième ordre sur
un seul oscillateur non couplé nous a montré que nous obtenions exactement le même
signal. Il ne s’agit donc pas d’une erreur d’implémentation, mais bien d’un problème de
précision sur le système couplé.
Etant donné que pour réaliser la deuxième phase du projet il nous fallait utiliser une des
méthodes d’intégration, nous avons opté pour Runge-Kutta de quatrième ordre tel que
présenté au paragraphe 3.2.2. En effet cette méthode est assez précise et est celle utilisée
par Collins et Richmond dans l’article [1]. Il semble donc judicieux d’utiliser cette
technique en espérant de plus que les résultats obtenus seront peut-être plus stables que
ceux de ode45. En effet, à l’inverse d’ode45 dont les signaux ne sont calculables que par
cette fonction, on peut espérer trouver une solution plus stable à l’aide de la méthode de
Runge-Kutta.
En réalité, mais ceci n’est apparu que bien plus tard, il semble, selon des tests effectués
par Jonas Buchli, qu’on ne puisse pas réellement fixer le pas d’intégration d’ode45. En
fait, la méthode calcule toujours les valeurs avec un pas variable, mais elle donne les
résultats échantillonnés à intervalle fixe. Ceci explique le fait que nous n’avons pas réussi
à trouver une méthode d’intégration équivalente.




                                             23
3.3 Phase 2
3.3.1 But
La première phase du projet ne donnant pas de résultats satisfaisant, nous décidâmes
d’élargir la recherche de variation des paramètres en utilisant plusieurs couplages
différents. L’idée était de vérifier si avec un autre couplage, on pouvait obtenir les trois
démarches voulues en ne faisant varier que le paramètre ‘a’ de chaque oscillateur.
Le système d’oscillateurs reste le même que précédemment, mais le système de couplage
est différent. Deux systèmes présentés plus bas seront testés.
Le but de cette deuxième phase de la recherche peut être formulé à l’aide de la question
suivante :

Question 2 : Est-il possible d’obtenir la marche, le trot et le saut avec des signaux
toniques et en ne faisant varier qu’un seul paramètre de chaque oscillateur à l’aide d’un
système de couplage différent de celui utilisé précédemment ?

3.3.2 Méthode
La méthode principale ainsi que les équations de Stein sont donc les mêmes (auxquelles
ont été ajoutées les variations des poids de couplage). L’analyse des déphasages des
signaux a été modifiée afin de pouvoir faire une analyse plus poussée des résultats
obtenus. Il a fallut déterminer si l’on avait de la marche, du trot ou du saut, mais aussi si
les signaux étaient d’un autre type mais périodiques, chaotiques ou encore non
oscillatoires.
Pour trouver les signaux non oscillatoires, il suffisait de calculer le nombre de maxima de
chaque signal. Si celui-ci est plus petit que 5, on peut estimer que le signal commence par
osciller, puis s’arrête ensuite.
Si le signal oscille, le nombre de périodes valides, c’est-à-dire de périodes de même
longueur, nous permet de déterminer si le signal est chaotique. En effet, si l’on ne trouve
pas de période fixe, le signal n’est pas périodique.
Les autres signaux sont donc périodiques, il suffit alors de les compter et de soustraire le
nombre de signaux de marche, trot et saut pour obtenir les autres signaux périodiques.
De plus une autre analyse donne le nombre de chaque type de signaux pour chaque poids
de chaque lien afin de déterminer si un lien avec un certain poids donne plutôt un certain
type de démarche.
Le même genre d’analyse a été fait pour les paramètres ‘a’ afin de déterminer si un ‘a’ a
plus d’influence qu’un autre sur le type de démarche en fonction de sa valeur.


3.3.3   Premier système de couplage

Le premier système de couplage des oscillateurs se présente ainsi :




                                             24
                             1                         4




                             2                         3



Ce couplage est complet, les liens sont bidirectionnels et chaque lien à un poids pouvant
prendre les valeurs -0.2, 0 ou 0.2. Il n’existe pas de symétrie globale sur ce système, mais
chaque lien est symétrique. Par exemple, le lien 1-2 est égal au lien 2-1. Cette méthode
permet d’analyser une grande gamme de couplages étant donné qu’un lien peut être
inexistant s’il a le poids 0.
Pour chacun de ces couplages, la même méthode de variation des paramètres ‘a’ que
précédemment a été utilisée. Chaque oscillateur possède son propre paramètre ‘a’ et
celui-ci varie entre 5 et 20 par pas de 5.


3.3.3.1 Analyse des résultats
Le fichier « result_phase2_1.txt » contient les résultats obtenus après l’exécution du code
C basé sur la méthode d’intégration de Runge-Kutta. On peut y trouver chaque
combinaison des poids de couplage suivi de la liste des démarches obtenues pour les
diverses valeurs des paramètres a. Le nombre total de tests effectués s’élève à 186624, ce
qui représente 3 à la puissance 6 multiplié par 4 à la puissance 4.
Les poids représentent dans l’ordre les liens entre les oscillateurs 1-2, 1-3, 1-4, 2-3, 2-4 et
3-4. Ces lien étant bidirectionnels, ils suffisent à un couplage complet. Comme précisé
plus tôt, les poids varient entre -0.2 et 0.2 par pas de 0.2.
Les valeurs des paramètres a de chaque oscillateur varient entre 5 et 20 par pas de 5.
Les résultats montrent que pour aucun des couplages on parvient à obtenir les trois
démarches voulues. On peut remarquer que dans plusieurs cas, deux des trois démarches
sont trouvées. On obtient donc parfois marche et saut, ou marche et trot, ou encore trot et
saut, mais dans aucun cas marche, trot et saut.
L’analyse globale des résultats nous montre que les signaux oscillent pour tous les
couplages et les valeurs de a. On obtient une majorité de signaux périodiques d’un type
différent de ceux recherchés. Ensuite viennent les signaux chaotiques, puis la marche qui
devance (307) le trot (184) et le saut (177). Ceci est représenté sur les histogrammes ci-
dessous :




                                              25
  350                                                160000
  300                                                140000

  250                                                120000                     autres
                                                     100000                     périodiques
                                      m arche
  200                                                                           chaotiques
                                      trot           80000
  150
                                      saut           60000
                                                                                non oscillants
  100                                                40000
   50                                                20000
    0                                                    0


L’analyse des couplages, dans le fichier « analyse_couplage_1.txt », nous montre que le
saut semble être favorisé par une forte valeur (0.2) des liens 1-4, 4-1 et 2-3, 3-2 ou par
une faible valeur (-0.2) des liens 1-2, 2-1 et 1-3, 3-1 et 2-4, 4-2 et 4-3, 3-4. De même, une
forte valeur des liens 1-3, 3-1 et 2-4, 4-2 ou une faible valeur des liens 1-2, 2-1 et 1-4, 4-1
et 2-3, 3-2 et 4-3, 3-4 favorise le trot. La marche semble être favorisée par une forte
valeur des liens 1-2, 2-1 ou par une faible valeur des liens 1-4, 4-1 et 2-3, 3-2, mais est
clairement la démarche la plus facile à obtenir.
Ces résultats paraissent logiques car on peut voir que les liens favorisant une démarche
lorsqu’ils ont une forte valeur sont le complément de ceux qui favorisent la même
démarche avec une faible valeur.
L’analyse des valeurs des paramètres a, dans le fichier « analyse_a_1.txt », semble
montrer qu’une faible valeur de a débouche plutôt sur la marche que sur le trot ou le saut.
Ces deux dernière démarche sont plus facilement atteintes avec des valeurs plus élevées
pour les paramètres a.


3.3.3.2 Conclusion sur le premier système
L’analyse des résultats de ce premier système de couplage montre que celui-ci ne nous
permet pas d’obtenir les trois démarches voulues.
Après avoir fait cette observation, on peut remarquer que le système choisi n’est peut-être
pas optimal. En effet, la nature nous montre qu’il existe souvent une symétrie gauche-
droite dans le corps humain. Cette symétrie n’est pas du tout représentée par ce système
de couplage. Une deuxième approche est présentée ci-dessous.




                                                26
3.3.4   Deuxième système de couplage

Le deuxième système de couplage des oscillateurs se présente ainsi :


                             1                         4




                             2                         3



Seule la moitié des liens est représentées dans ce schéma, l’autre moitié se retrouve par
symétrie selon l’axe dessiné. Ce couplage est complet, chaque lien à un poids pouvant
prendre les valeurs -0.2, 0 ou 0.2. Les liens 1-4 et 4-1 sont égaux, de même que les liens
4-2 et 1-3, 1-2 et 4-3, 2-3 et 3-2, 2-1 et 3-4 ainsi que 2-4 et 3-1.Cette méthode permet
d’analyser les couplages ayant une symétrie droite-gauche, ce qui représente ce que l’on
observe dans la nature.
Pour chacun de ces couplages, la même méthode de variation des paramètres ‘a’ que
précédemment a été utilisée. Chaque oscillateur possède son propre paramètre ‘a’ et
celui-ci varie entre 5 et 20 par pas de 5. Le paramètre ‘f’ de chaque oscillateur a été fixé a
40.


3.3.4.1 Analyse des résultats
Le fichier « result_phase2_2.txt » contient les résultats obtenus après l’exécution du code
C basé sur la méthode d’intégration de Runge-Kutta. On peut y trouver chaque
combinaison des poids de couplage suivi de la liste des démarches obtenues pour les
diverses valeurs des paramètres a. Le nombre total de tests effectués s’élève à 186624, ce
qui représente 3 à la puissance 6 multiplié par 4 à la puissance 4.
Les poids représentent dans l’ordre les liens entre les oscillateurs 1-2, 1-3, 1-4, 2-3, 2-4 et
2-1. Ces liens possédant chacun son symétrique, ils suffisent à un couplage complet.
Comme précisé plus tôt, les poids varient entre -0.2 et 0.2 par pas de 0.2.
Les valeurs des paramètres a de chaque oscillateur varient entre 5 et 20 par pas de 5.
Les résultats montrent que pour trois des couplages on parvient à obtenir les trois
démarches voulues.
En effet, pour les valeurs de couplage (-0.2, 0, -0.2, 0.2, 0.2, -0.2) les valeurs des
paramètres a (15, 5, 5, 15), (20, 5, 5, 20) et (20, 5, 10, 20) donnent de la marche. Les
valeurs (20, 15, 15, 20) donnent du trot et les valeurs (5, 10, 10, 5) donnent du saut. Ces
premières valeurs permettent de commencer par n’importe quelle démarche et d’effectuer
toutes les transitions possibles sans devoir recourir à la stratégie « power-pair ». Les


                                              27
signaux sont présentés dans les figures 27-29 avec les valeurs (15, 5, 5, 15) pour la
marche. Le schéma de cette première solution est présenté ci-dessous (un poids de -0.2
est représenté par une ligne terminée par un cercle, un poids de +0.2 est représenté par
une ligne terminée par un carré) :

             Marche : 5    15                                   15 5
             Trot :   15   20                                   20 15
             Saut :   10    5                                   5  10



                                1                         4




                                2                         3


Pour les valeurs de couplage (-0.2, 0, -0.2, 0.2, 0.2, 0), les valeurs de a (20, 5, 5, 20)
donnent de la marche, les valeurs (15, 10, 10, 15) donnent du trot et les valeurs (5, 15, 20,
15) donnent du saut. La marche et le trot ne posent aucun problème avec ces valeurs, par
contre si l’on fait une transition de la marche sur le saut, celui-ci est modifié et ne
correspond plus à aucune démarche définie. Ce système est donc moins bon que le
précédant. Les signaux sont présentés dans les figures 30-33. Le schéma de cette
deuxième solution est présenté ci-dessous :

             Marche : 5    20                                   20    5
             Trot :   10   15                                   15   10
             Saut :   15    5                                   15   20



                                1                         4




                                2                         3




                                             28
      Pour les valeurs de couplage (0, -0.2, -0.2, 0, -0.2, -0.2), les valeurs de a (15, 15, 10,
15), (15, 15, 20, 15) et (20, 20, 15, 20) donnent de la marche, les valeurs (15, 10, 15, 20)
donnent du trot et les valeurs (5, 20, 20, 15) donnent du saut. Le problème de ce système
est que le trot est modifié de manière à ne plus correspondre à aucune démarche connue
s’il est précédé de la marche. La marche et le saut sont stables, mais ce système est
malgré cela moins bon que le premier. Les signaux sont présentés dans les figures 34-37
avec les valeurs (15, 15, 10, 15) pour la marche. Ce système est présenté ci-dessous :


               Marche : 15   15                                     15   10
               Trot :   10   15                                     20   15
               Saut :   20    5                                     15   20



                                    1                         4




                                    2                         3



Pour les trois configurations présentées ci-dessus, si l’on observe ces valeurs à l’aide de
Matlab, on peut remarquer que du point de vue du déphasage on obtient en effet les
démarches souhaitées. Le problème est que les signaux n’ont plus tous la même
amplitude, mais qu’ils sont groupés deux par deux (pattes avants ensembles et pattes
arrières ensembles).
Il est donc impossible d’utiliser directement ces signaux sur un robot quadrupède, mais
un traitement des signaux nous permettrait de rapidement obtenir des signaux
exploitables. Il suffirait juste de multiplier les valeurs obtenues pour les signaux plus
faibles par une constante pour obtenir la même amplitude partout. Le déphasage resterait
correct et les signaux seraient alors utilisables. Comme, dans le cas du robot Aibo, il faut
de toute manière traiter les signaux pour obtenir les angles de rotations en radian, il serait
possible de corriger ces différences d’amplitude au même moment sans que cela pose de
problème.
L’analyse globale des résultats nous montre que les signaux oscillent pour tous les
couplages et les valeurs de a. On obtient une majorité de signaux périodiques d’un type
différent de ceux recherchés. Ensuite viennent les signaux chaotiques, puis la marche qui
devance largement (3225) le saut (286) et le trot (210). Ceci est présenté dans les
histogrammes ci-dessous :




                                              29
  3500                                                                                          160000
  3000                                                                                          140000

  2500                                                                                          120000                                        autres
                                                                                  marche        100000                                        périodiques
  2000                                                                                                                                        chaotiques
                                                                                  trot          80000
  1500                                                                            saut          60000
                                                                                                                                              non oscillants
  1000                                                                                          40000
   500                                                                                          20000
      0                                                                                                 0


L’analyse des couplages, dans le fichier « analyse_couplage_2.txt », nous montre que le
saut semble être favorisé par une forte valeur (0.2) des liens 1-4, 4-1 et 2-3, 3-2 ou par
une faible valeur (-0.2) des liens 1-2, 4-3 et 1-3, 4-2 et 2-4, 3-1 et 2-1, 3-4. De même, une
forte valeur des liens 1-3, 4-2 et 2-4, 3-1 ou une faible valeur des liens 1-2, 4-3 et 1-4, 4-1
et 2-3, 3-2 et 2-1, 3-4 favorise le trot. La marche semble être favorisée par une forte
valeur des liens 1-2, 4-3 et 2-4, 3-1 ou par une faible valeur des liens 1-3, 4-3 et 1-4, 4-1
et 2-3, 3-2 et 2-1, 3-4.
Ces résultats paraissent logiques car on peut voir que les liens favorisant une démarche
lorsqu’ils ont une forte valeur sont le complément de ceux qui favorisent la même
démarche avec une faible valeur.
L’analyse des valeurs des paramètres a, dans le fichier « analyse_a_2.txt », ne semble pas
clairement montrer qu’un paramètre a une plus grande importance pour un type de
démarche. Il semble que ces paramètres reflètent les nombres totaux des différentes
démarches.




                                                                                                  0.7
    0.6


                                                                                                  0.6

    0.5

                                                                                                  0.5


    0.4
                                                                                                  0.4



    0.3
                                                                                                  0.3



    0.2                                                                                           0.2



                                                                                                  0.1
    0.1


          8.45    8.5   8.55   8.6   8.65      8.7      8.75   8.8   8.85   8.9    8.95                     18.1   18.2   18.3         18.4     18.5    18.6
                                            temps [s]                                                                      temps [s]




                 Figure 27: Système 1, marche                                                           Figure 28: Système 1, trot




                                                                                           30
                                                       0.65


                                                        0.6


                                                       0.55


                                                        0.5


                                                       0.45


                                                        0.4


                                                       0.35


                                                        0.3


                                                       0.25


                                                        0.2


                                                       0.15


                                                               33.4         33.5         33.6    33.7       33.8      33.9      34
                                                                                                temps [s]




                                                                            Figure 29: Système 1, saut



0.7


                                                                                                            0.6
0.6



                                                                                                            0.5
0.5




0.4                                                                                                         0.4




0.3                                                                                                         0.3




0.2                                                                                                         0.2



0.1
                                                                                                            0.1


             6.5          6.6          6.7               6.8                6.9             7                       15.2      15.3      15.4               15.5          15.6      15.7
                                       temps [s]                                                                                               temps [s]




            Figure 30: Système 2, marche                                                                           Figure 31: Système 2, trot


0.8
                                                                                                            0.8


0.7
                                                                                                            0.7


0.6
                                                                                                            0.6



0.5
                                                                                                            0.5



0.4                                                                                                         0.4



0.3                                                                                                         0.3



0.2                                                                                                         0.2



0.1                                                                                                         0.1


      6.4    6.45   6.5   6.55   6.6   6.65      6.7      6.75        6.8   6.85   6.9                               36.4    36.5    36.6          36.7           36.8      36.9    37
                                       temps [s]                                                                                               temps [s]




            Figure 32: Système 2, saut sans transition                                                             Figure 33: Système 2, saut avec transition
                                                                                                                   depuis marche




                                                                                                31
                                                                                                                         0.6
    0.6




                                                                                                                         0.5
    0.5




                                                                                                                         0.4
    0.4




                                                                                                                         0.3
    0.3




                                                                                                                         0.2
    0.2




                                                                                                                         0.1
    0.1


                 6.8   6.85      6.9   6.95      7      7.05          7.1   7.15          7.2   7.25          7.3              8.1          8.15   8.2    8.25      8.3      8.35          8.4   8.45   8.5      8.55
                                                     temps [s]                                                                                                        temps [s]




            Figure 34: Système 3, marche                                                                                       Figure 35: Système 3, trot sans transition



    0.7                                                                                                                  0.7



    0.6                                                                                                                  0.6



    0.5                                                                                                                  0.5



    0.4                                                                                                                  0.4



    0.3                                                                                                                  0.3



    0.2                                                                                                                  0.2



    0.1
                                                                                                                         0.1



          37.7            37.8            37.9                   38                38.1                38.2                          15.6          15.7          15.8               15.9         16           16.1
                                                     temps [s]                                                                                                          temps [s]




            Figure 36: Système 3, saut                                                                                         Figure 37: Système 3, trot avec transition
                                                                                                                               depuis marche




3.3.4.2 Conclusion sur le deuxième système
L’analyse des résultats de ce deuxième système de couplage montre que celui-ci nous
permet d’obtenir les trois démarches voulues. Le meilleur système a pour valeurs de
couplage (-0.2, 0, -0.2, 0.2, 0.2, -0.2). Les valeurs des paramètres a (15, 5, 5, 15), (20, 5,
5, 20) et (20, 5, 10, 20) donnent de la marche. Les valeurs (20, 15, 15, 20) donnent du trot
et les valeurs (5, 10, 10, 5) donnent du saut. Toutes les transitions sont possibles entre ces
démarches sans affecter les signaux. Après avoir effectué des tests sur les conditions
initiales du système, on peut encore remarquer que celles-ci n’influencent pas les
signaux. Ces derniers mettent parfois un peu plus de temps à ce stabiliser, mais il semble
qu’on obtient toujours la démarche voulue. Ceci nous montre que cette solution est
meilleure que celle de Collins et Richmond étant donné que l’on peut commencer avec
n’importe quelle démarche, effectuer n’importe quelle transition sans avoir recours à une
stratégie différente et que les signaux obtenus ne dépendent pas (ou peu) des conditions
initiales.


                                                                                                                    32
De plus, ce système a été testé à l’aide de la fonction ode45 de Matlab à la place de la
méthode de Runge-Kutta. Les résultats obtenus sont les mêmes ce qui montre que le
système n’est pas sensible à la méthode d’intégration.
Le problème restant est que les amplitudes des quatre signaux ne sont plus égales comme
dans le cas de l’article [1]. Malgré tout, si l’on ne considère que les déphasages, on peut
admettre que ces résultats sont acceptables.

3.4 Conclusion sur la recherche
Si l’on ne tient compte que des déphasages entre les signaux du système, la recherche
effectuée nous montre qu’il est possible d’obtenir les trois démarches souhaitées avec
quatre oscillateurs.
Si, par contre, il est aussi important d’avoir la même amplitude pour tous les signaux, il
semble que quatre oscillateurs ne suffisent pas pour obtenir les trois démarches
souhaitées. Une recherche future pourrait se porter sur un cas à plus de quatre
oscillateurs, comme décrit dans l’article [4] qui prône le fait que trois démarches ne
peuvent être obtenues qu’à l’aide d’au moins huit oscillateurs.
Ceci ne sera pas traité dans ce projet où l’on essaiera plutôt d’implémenter les résultats
obtenus sur le robot Aibo de Sony.


4 Simulation
Après avoir trouvé un système nous permettant d’obtenir les trois types de démarches
souhaitées, il serait intéressant de vérifier si les signaux peuvent effectivement être
appliqués à un quadrupède et si celui-ci parviendra à supporter les transitions entre les
démarches sans tomber.
Afin de ne pas maltraiter le robot Aibo et de pouvoir tester les résultats obtenus, une
simulation a été effectuée à l’aide du logiciel Webots. Ce logiciel a été créé par Olivier
Michel et sa société Cyberbotics (URL [9]) et permet de charger un fichier représentant
l’environnement dans lequel le robot va se déplacer ainsi que le robot lui-même. Un
second fichier fait office de contrôleur pour le robot. C’est avec ce fichier que l’on peut
déterminer la trajectoire du robot. Le logiciel Webots offre déjà une simulation
permettant de contrôler les mouvements du robot Aibo (voir images ci-dessous).




                                            33
4.1 Fonctionnement
Une description détaillée du fonctionnement de Webots peut être trouvée sur le site [9],
mais on peut ici brièvement expliquer comment le simulateur du robot Aibo fonctionne
dans ce logiciel.
Le robot Aibo est définit dans Webots comme étant une suite de partie de corps articulées
à l’aide de joints nommés « servo ». Chacun de ces servos possède un nom qui lui est
propre et qui a été déterminé par Sony. Seuls les servos correspondant aux pattes du robot
nous intéresse dans ce projet. Chaque patte possède trois articulations : au niveau de la
hanche, une permettent le mouvement avant-arrière (appelée j1) et une autre permettant
le mouvement latéral (j2), ainsi qu’une au niveau du genou (j3).
Le fichier « aibo_ers210.wbt » de Webots définit un environnement représentant un sol
délimité par quatre murs sur lequel se trouve le robot Aibo ainsi qu’une balle. Ce fichier
est écrit en VRML, ce qui permet de le modifier aisément, et offre une base idéale pour la
simulation qui nous intéresse. En plus de définir une simple vision graphique d’un
monde, ce fichier fixe aussi les coefficients de frottement des éléments sur le sol et gère
les interactions (collisions) entre les objets (par exemple entre la balle et le robot).
Le fichier de contrôle « ers_210.c » permet, grâce à une interface graphique, de faire
bouger indépendamment chaque articulation du robot. Une valeur correspondant à l’angle
en radians par rapport au point zéro du membre est appliquée à l’articulation souhaitée.
Dans le cas des pattes, le point zéro se situe près de la verticale. Une valeur positive
appliquée à j1 fait avancer une patte avant ou reculer une patte arrière et inversement
pour une valeur négative.
En modifiant ces deux fichiers, on peut obtenir une simulation permettant de visualiser
les résultats obtenus lors de la phase de recherche précédente.


4.2 Implémentation
Le premier système obtenu comme résultats de la recherche étant le meilleur, il a été
choisi pour l’implémentation de la simulation. Celui-ci permet en effet de réaliser toutes
les transitions entre les trois démarches observées (marche, trot et saut) et paraît donc
idéal pour un test sur le robot.
Dans un premier temps, le fichier « my_aibo_ers210.wbt » représentant l’environnement
Webots a été implémenté. Ce fichier est en fait une copie du fichier original de Webots,
légèrement modifié. La balle a été supprimée car elle ne nous intéresse pas ici, et le sol a
été allongé afin de permettre un déplacement suffisamment grand du robot.
Le travail principal a été effectué dans le fichier « my_ers_210.c ». Celui-ci est une copie
du fichier de contrôle de Webots. Tout d’abord, l’interface graphique a été supprimée
ainsi que la vue de la caméra frontale du robot.
La méthode utilisée pour faire bouger Aibo est de calculer la trajectoire, puis de la lui
appliquer. La phase de calcul de la trajectoire est effectuée en deux temps. Premièrement,
les signaux sont calculés à l’aide de la même méthode d’intégration (Runge-Kutta) que
dans la partie de recherche du projet, puis les signaux ainsi obtenus sont transformés pour
correspondre aux besoins du simulateur.



                                            34
Etant donné qu’il faut appliquer des angles en radians aux servos de chaque patte, on
utilise un facteur de conversion sur chaque valeur du tableau correspondant aux signaux.
Ce facteur est calculé en faisant le rapport de la valeur actuelle sur la valeur maximale du
tableau, multiplié par la valeur maximale que peut prendre le servo. De plus, comme les
pattes arrière prennent des valeurs d’angles inversées par rapport aux pattes avant, il faut
inverser les signaux correspondant aux oscillateurs 2 et 3.
Le problème principal est que l’on n’a considéré qu’un seul signal par patte lors de la
recherche. Les signaux calculés correspondent en fait aux articulations de la hanche. En
utilisant uniquement ces signaux, le robot ne pliera jamais les genoux et la démarche
obtenue n’aura rien de naturelle. Pour résoudre ce problème, une observation simple a été
faite. On peut estimer que le signal de l’articulation du genou correspond à celui de la
hanche déphasé de 90° en avance. Bien évidemment, il faut empêcher les valeurs
négatives et donc bloquer le signal à zéro, car l’articulation du genou ne se plie pas dans
les deux sens. Ce procédé nous permet d’obtenir une démarche plus ou moins naturelle.
Cette méthode de transformation des signaux est appliquée sur chaque tableau
correspondant à une démarche intégrée. Afin de simuler les transitions entre les
démarches, les dernières valeurs d’un tableau (avant transformation) sont utilisées
comme valeurs initiales dans le tableau suivant. Ceci nous permet d’obtenir plusieurs
tableaux correspondant à un enchaînement de démarche, par exemple, dans la simulation
implémentée, nous avons la suite marche-trot-saut-trot-marche-saut-marche qui nous
donne toutes les transitions entre les trois démarches observées.
Pour appliquer les tableaux obtenus aux bons servos, il suffit de parcourir chaque servo
est d’identifier son nom. En effet, si par exemple le nom du servo courant est
« PRM:/r2/c1-Joint2:j1 » on sait alors qu’on a affaire au servo de la hanche de la patte
avant-gauche, on peut donc ainsi lui appliquer la valeur correspondante.
Un pas de temps est fixé par Webots, et à chaque pas, on applique à chaque servo la
valeur adéquate selon le tableau. Le problème restant est que, si la recherche nous a
donné une solution pour le déphasage entre les signaux, elle ne nous permet pas de faire
varier la fréquence. Le trot et le saut ont alors la même fréquence que la marche, ce qui
ne correspond pas à la réalité. Afin de remédier à ce problème, il suffit de ne pas
appliquer chaque valeur du tableau pour le trot et le saut, mais une valeur sur deux pour
le trot et une valeur sur trois pour le saut. Ainsi on avance plus rapidement dans le tableau
et la démarche obtenue semble plus rapide.


4.3 Résultats
Les résultats de la simulation peuvent être observés à l’aide des vidéos "walk.mpeg",
"trot.mpeg", "galop.mpeg", "speed_up.mpeg", "slow_down.mpeg" et "aibo.mpeg ". Ce
dernier présente la séquence de démarche telle que décrite précédemment. Ces vidéos
sont visibles depuis le site [10]. Dans un premier temps, il semblait que les fichiers mpeg
générés par Webots ne correspondaient pas aux simulations en temps réel. En effet, les
vidéos allaient deux fois plus vite que les simulations. En fait, le problème vient du fait
que le codage en mpeg des simulations ne tient pas compte des paramètres dans les
préférences. Le rafraîchissement de l'image se faisait deux fois par pas de simulation ce
qui doublait la vitesse d'exécution. En fixant ce paramètre à 1, la vitesse de la vidéo est la
même que celle de la simulation.


                                             35
En observant les vidéos générées, on peut voir que la marche paraît naturelle. Le trot
permet toujours au robot de se déplacer, mais on peut observer que les pattes glissent
légèrement sur le sol. Quant au saut, les pattes glissent complètement sur le sol et aucun
déplacement ne peut être observé. Ce glissement des pattes persiste même lorsque le
coefficient de frottement du sol est augmenté. Le fait que le saut et le trot ne fonctionnent
pas parfaitement peut être expliquer par le fait que nous avons affaire à un robot et non
pas un quadrupède vivant. En effet, les membres du robot ne sont pas aussi élastiques que
ceux d’un quadrupède vivant et cela peut nous empêcher d’obtenir les démarches
voulues.
Malgré tout, on peut remarquer que le déphasage entre les pattes correspond bien aux
trois démarches souhaitées et que les transitions entre deux démarches sont toutes
possibles grâce à leur rapidité d’exécution. Le robot ne tombe jamais, mais il arrive
parfois qu’il tourne légèrement lors de la phase de transition, c’est-à-dire lorsque la
démarche n’est pas stabilisée.
Cette simulation nous permet de voir qu’il est possible d’utiliser les signaux obtenus par
la phase de recherche sur un quadrupède. Une phase suivante du projet pourrait être de
tester le code implémenté en simulation sur le robot réel, mais aucune interface n’existe
actuellement pour convertir et charger un programme de Webots sur le robot Aibo de
Sony.



5 Conclusion et travaux futurs
Le but de ce projet a été atteint, car nous avons en effet réussi à obtenir des contrôleurs de
locomotion permettant d’effectuer les transitions entre la marche, le trot et le saut à l’aide
de signaux de commande simples.
Plusieurs alternatives sont possibles pour continuer ce projet. Dans un premier temps, il
serait bien entendu intéressant d'utiliser le code implémenté en simulation avec Webots
pour effectuer des tests sur le vrai robot Aibo. Malheureusement, comme mentionné plus
tôt, il n'existe pas encore d'interface permettant la conversion du code C Webots en code
applicable à Aibo.
Une fois ceci possible, il serait intéressant de modifier le traitement des données fait en
simulation. En effet, au lieu d'intégrer tous les signaux d'abord, puis ensuite de les
appliquer au robot, il serait possible d'effectuer l'intégration pas à pas. Etant donné que le
temps de calcul pour un pas d'intégration est assez court, le robot pourrait toujours
fonctionner en temps réel. Ceci permettrait d'observer le comportement du robot
lorsqu'un événement externe se produit. Par exemple, lorsque le robot marche, on
pourrait lui maintenir une patte en l'air, et observer le résultat. L'intégration pas à pas
permettrait alors au robot d'adapter son comportement en fonction des capteurs qu'il
possède ce qui n'est pas le cas d'une intégration faite totalement au début.
Une autre amélioration possible du système, au niveau des oscillateurs, serait de trouver
un couplage permettant d'obtenir, en plus de la variation des déphasages, la variation de
la fréquence des signaux. En effet, si le système obtenu lors de ce projet nous permet de
réaliser les trois types de démarche souhaités, la fréquence des signaux est toujours la
même. Ceci n'est pas réaliste, car on sait bien que la fréquence du trot est plus élevée que


                                             36
celle de la marche. On pourrait encore essayer d'obtenir d'autres types de démarche
connus chez les quadrupèdes, comme par exemple le pas.
Ces deux dernières alternatives ne seraient sans doutes pas réalisables à l'aide de
seulement quatre oscillateurs. Mais en ajoutant des oscillateurs de contrôle et en les
couplant au système déjà existant, il serait peut-être possible d'obtenir des résultats
intéressants.



6 Annexe
En annexe de ce document est fourni un CD contenant le fichier Word de ce rapport,
ainsi que les fichiers implémentés pour les différentes parties du projet. Ces fichiers sont
classés de la manière suivante:
    • Le dossier Implementation contenant les fichiers implémentant les méthodes de
        Stein, Van der Pol et FitzHugh-Nagumo comme présentées dans l'article [1], ainsi
        que les fichiers images des résultats de ces méthodes.

   •   Le dossier Recherche contenant les dossiers suivants:

       •   Le dossier Phase1 contenant les fichiers Matlab utiles à la réalisation de la
           phase 1 de la recherche, c'est-à-dire à la variation des paramètres a.

       •   Le dossier Integration contenant les fichiers Matlab implémentés pour tester
           les diverses méthodes d'intégration et les comparer à ode45.

       •   Le dossier Stein_rk_couple contenant le projet VisualC++ permettant de
           réaliser la deuxième phase de recherche, c'est-à-dire la variation des poids de
           couplage et des paramètres a, ainsi que les résultats de cette phase.

       •   Le dossier Phase2 contenant les fichiers Matlab implémentant les résultats de
           la phase 2 de recherche ainsi que les images de ces résultats.

       •   Le dossier Aibo contenant tous les éléments utiles à la simulation des résultats
           obtenus sous Webots, ainsi que les fichiers mpeg générés.



7 Références
[1] J. J. Collins, S. A. Richmond, “Hard-wired central pattern generators for quadrupedal
    locomotion”, Biological Cybernetics 71, 1994, p375-385
[2] http://www.mathworks.com/access/helpdesk/help/techdoc/ref/ode45.shtml
[3] http://www.utexas.edu/math/Matlab/Manual/ode45.html



                                            37
[4] M. Golubitsky, I. Stewart, P.-L. Buono, J. J. Collins, “Symmetry in locomotor central
    pattern generators and animal gaits”, Nature, vol.401, October 1999, p693-695
[5] P. Marjamäki, J. Kivilahti, R. Kouhia, “Comparison of two classes of integration
    algorithms in creep analysis”, ECCM-2001, June 2001
[6] http://www.udayton.edu/~cps/cps353/notes/ode/rkf.html
[7] http://www.library.cornell.edu/nr/bookcpdf.html

[8] M. L. Shik, F. V. Severin, G. N. Orlovsky, "Control of walking and running by means
    of electrical stimulation of the mid-brain", Institute of Biological Physics, USSR,
    Academy of Sciences, Moscow, February 1966

[9] http://www.cyberbotics.com/

[10] http://lslwww.epfl.ch/birg/PROJECTS/mathieu_salzmann/projet.shtml




                                           38

								
To top