Le programme précédent fonctionne, est facile à comprendre et à modifier. Pourtant, il est courant en robotique de concevoir les programmes en termes de comportements, exprimés sous forme de machines à états finis, qui sont des graphes d'états reliés entre-eux par des transitions. La figure 6.1 illustre le graphe de comportement du programme de détection de balle, qui est exemple très simple de comportement à deux états.

Figure 6.1. Le graphe de comportement de la détection de balle

Les ellipses représentent les états (dans lequels le robot boucle des actions ou une surveillance) et les flèches les transitions, étiquetées par des conditions. Les rectangles associés aux transitions indiquent certaines actions à exécuter lorsque la transition s'effectue.

La meilleure façon de programmer ce genre de graphe de comportement en URBI est d'utiliser une conjonction des fonctions avec les commandes at et stop pour relier le tout. Tout d'abord, définissons les deux fonctions associées aux deux états du programme de détection de balle:

// Etat de suivi
function suis() {
  whenever (ball.visible) {
    headPan  = headPan + ball.a * camera.xfov * ball.x &
    headTilt = headTilt+ ball.a * camera.yfov * ball.y;
  }
};

// Etat de recherche
function cherche() {
  period = 10s;
  {
    headPan'n  = 0.5 smooth:1s &
    headTilt'n = 1   smooth:1s
  } |
  {
    headPan'n  = 0.5 sin:period ampli:0.5 &
    headTilt'n = 0.5 cos:period ampli:0.5
  }
};

Maintenant, nous pouvons simplement relier les états entre-eux en établissant les transitions avec deux commandes at et en terminant l'état précédent avec des commandes stop:

// Transitions
at (ball.visible ~ 100ms) {
  stop recherche;
  speaker = trouvee;
  suivi: suis();
};

at (!ball.visible ~ 100ms) {
  stop suivi;
  speaker = perdue;
  recherche: cherche();
};

L'avantage de ré-écrire le programme de détection de balle en termes de machine à états finis peut ne pas vous apparaître évident pour l'instant car le programme est très simple. Mais, avec des comportements plus riches de dizaines d'états, chacun avec plusieurs transitions, il s'agit de la façon la plus sure de programmer. Cela rend le code modulaire, clair et facile à modifier.

Les machines à états finis sont une excellente façon de décrire les comportements des robots. Elles ne sont pas parfaites mais c'est pour l'instant la technique la plus employée en robotique. URBI est également capable de décrire des architectures subsumées, hiérarchisées ou réactives et bien d'autres paradigmes.