Domaine 1 Communication et exploration robotique

Tuto

cozmo_fsm : Machines à états finis

Une machine à états finis (FSM) est un modèle utilisé pour représenter et contrôler
le flux d'exécution (similaire aux diagrammes de flux).

Les FSM sont largement utilisés en informatique et en ingénierie pour modéliser les
comportements des machines, par exemple, le mouvement d’un robot.

En bref, un fsm est constituée de :

▪ Un ou de plusieurs états.
▪ Une ou de plusieurs transitions
▪ Des événements

Une FSM commence par un état spécial, appelé état initial, procède par
transitions, en fonction de l'entrée, aux différents états et se termine normalement
dans des états terminaux. Un état qui marque un flux d'opération réussi est appelé
un état d'acceptation.

La machine est dans un état actif à la fois. Puisqu’une machine à états finis est un
système event-driven, les transitions sont déclenchées par des événements.

Pour pouvoir effectuer des différentes actions, elle doit transitionner d'un état à un
autre en fonction de l’état précédent et des événements. Chaque état peut avoir
multiples transitions sources et de destination.

1 / Paquet cozmo_fsm

Le paquet cozmo_fsm fournit un modèle de programmation de machine à états

finis pour le SDK du Cozmo. Il est inclus dans le paquet cozmo-tools.

cozmo_fsm fournit une notation abrégée qui facilite la construction de FSM bien
formées. Les fichiers écrits avec cette notation doivent être traduits en fichiers
Python à l'aide de l'outil genfsm et exécutés dans simple_cli en utilisant la
commande runfsm.
page
01
 Tuto cozmo_fsm : Machines à états finis

1 Notations

La syntaxe pour construire une instance de nœud est la suivante:

label: NodeClass(arguments)

La syntaxe pour construire une instance de transition est la suivante:

source =label: type(arguments)=> destination

La source et la destination doivent être une définition de nœud, une étiquette de

nœud ou une liste d'étiquettes de nœuds.

Allez à l’Annexe B pour consulter une liste de nœuds et transition communs.

2 / FSM 1 : Déplacements et paroles

Nous avons ici une machine comportant deux nœuds. Une première action pour
avancer 50 mm (le nœud initial) et un deuxième qui consiste à faire parler le robot.

En utilisant simplement le SDK, le programme serait :

move_and_say.py
1 import cozmo
2 from cozmo.util import distance_mm, speed_mmps
3
4 def cozmo_program(robot: cozmo.robot.Robot):
5
6 robot.drive_straight(distance_mm(50), speed_mmps(50)).wait_for_completed()
7 robot.say_text("Salut le monde").wait_for_completed()
8
9 cozmo.run_program(cozmo_program)

page
02
 Tuto cozmo_fsm : Machines à états finis

1 La notation raccourcie de cozmo_fsm permet de définir cette machine comme suit :

MoveAndSay.fsm
1 from cozmo_fsm import *
2
3 class MoveAndSay(StateMachineProgram):
4 $setup{
5 Forward(50) =C=> Say("Salut le monde")
6 }

Pour utiliser ce programme, il faut d’abord le transformer en code python avec

genfsm et après le lancer avec runfsm sur la console simple_cli :

$ conda activate cozmo-env

$ python genfsm MoveAndSay.fsm
Wrote generated code to MoveAndSay.py.
$ python simple_cli
… initialization stuff …
C> runfsm(‘MoveAndSay’)

Important !

Pour pouvoir lancer les programmes genfsm, simple_cli et runfsm depuis votre
dossier de travail il est nécessaire de faire une configuration additionnelle.
Référez-vous à l’Annexe A pour en savoir plus.

Analyse

▪ [1] On importe le paquet cozmo_fsm, qui à son tour, importe

automatiquement la base du SDK de Cozmo.

▪ [3] À la différence de le SDK, on utilise une classe et non une fonction pour
créer un programme. Cette classe doit hériter de StateMachineProgram.

▪ [4] Définition des états et des transitions. Le premier nœud indiqué devient
le nœud initial, dans ce cas, le nœud Forward.

▪ Les noms de la classe et du fichier doivent être égaux. Le fichier a l’extension

.fsm. Le code python sera généré dans le même dossier sur le même nom
mais avec l’extension .py.

page
03
 Tuto cozmo_fsm : Machines à états finis

1 Activité 2.1 Ouvrez le code généré et analysez-le !

3 / FSM2 : Métronome

Dans cet exemple, nous avons deux nœuds qui indiquent à Cozmo de parler deux
fois, la première pour dire « tick » et après « tock ». Entre les deux il y a un temps
mort de 1 seconde pour aller de « tick » à « tock » et de « tock » à « tick »
indéfiniment.

Créez le programme en SDK pure qui réalise les actions

Activité 3.1
indiquées ci-dessus.

Cet automate peut être défini avec la notation abrégée cozmo_fsm de la façon
suivante :

TickTock.fsm
1 from cozmo_fsm import *
2
3 class TickTock(StateMachineProgram):
4 $setup{
5 tick: Say('Tick') =T(1)=> tock
6 tock: Say('Tock') =T(1)=> tick
7 }

Analyse

▪ [4] On définit un nœud étiqueté comme « tick » qui réalise l’action Say. En
fait, Say est un nœud d’action.

page
04
Tuto cozmo_fsm : Machines à états finis

1 ▪ Après, il y a la transition TimerTrans (ou simplement T) indiquant une

seconde d’attente.

▪ Une fois que le temps est épuisé, la machine se dirige vers l’état étiqueté
comme « tock » (ligne 5).

▪ [5] On définit un nœud étiqueté comme « tock » qui réalise l’action Say.

▪ Après, il y a la transition d’attente TimerTrans.

▪ Une fois que le temps est épuisé, la machine se dirige vers l’état étiqueté
comme « tock » (ligne 4).

▪ On recommence, indéfiniment.

Transformez le code fsm en code python et lancez le

Activité 3.2
programme.

4 / FSM2 : Action parallèles

Examinons un exemple de Fork/Join des nœuds. On a le nœud initial qui n’a pas de
conditions pour passer d’un côté ou de l’autre (transition Null), c’est un fork.

Les nœuds « driver » et « speaker » s’exécutent au même temps. De la complétion

du nœud « speaker » la machine ira à « speaker » au nouveau jusqu’à la fin du
nœud « driver ».

page
05
 Tuto cozmo_fsm : Machines à états finis

1 De la complétion du nœud « driver » la machine passera à l’état « finisher », c’est

un join.

Créez le programme en SDK pure qui réalise les actions

Activité 4.1
indiquées ci-dessus.

Le code de l’automate fork/join est le suivant :

BackItUp.fsm
1 from cozmo_fsm import *
2
3 class BackItUp(StateMachineProgram):
4 $setup{
5 launcher: StateNode() =N=> {driver, speaker}
6
7 driver: Forward(-100, 10)
8 speaker: Say('Beep!') =C=> speaker
9
10 {drive, speak} =C=> finisher: Say('Safety first')
}

Analyse

▪ [5] On définit un nœud basique (sans action) étiqueté comme « launcher »

qui est suivi de la transition Null et d’une liste de nœuds (fork).

▪ [6-7] Définitions des nœuds d’action « driver » et « speaker ».

▪ [9] La machine passe au nœud « finisher » (qui reçoit deux étiquettes de

nœud) après la complétion des actions (join).

Transformez le code fsm en code python et lancez le

Activité 4.2
programme.

page
06
Tuto cozmo_fsm : Machines à états finis

1 5 / Des FSM perfectionnées

cozmo_fsm est un modèle de programmation qui permet de créer des machines :

▪ Hiérarchiques : Les FSM peuvent être imbriquées.

▪ Parallèles : Des états multiples peuvent être actifs en même temps.

▪ Communicatifs : Les transitions peuvent transmettre des informations à

leurs nœud destination.

▪ Extensibles : Afin que vous puissiez créer vos propres types de nœuds et de
transitions.

Pour en apprendre plus à propos de cozmo_fsm :

▪ Lisez les articles dans Cozmopedia.

▪ Regardez le code des exemples dans cozmo_tools/cozmo_fsm/exemples.

▪ Lisez le code source de cozmo_fsm, surtout les fichiers node.py et

transitions.py.

Exercices d’entraînement

Créez un programme dans lequel Cozmo dessine un carré de 100

Exercice 1
mm de côté pendant qu’il compte à haute voix de zéro à dix.
Après avoir approfondi dans la connaissance de cozmo_fsm, c’est
Exercice 2 votre tour de transformer votre parcours fait avec le SDK en une
machine à états finis.

page
07
Tuto cozmo_fsm : Machines à états finis

1 Annexe A : Configuration de cozmo-fsm

Pour faire la programmation avec cozmo_fsm plus facile, il est recommandé de
créer ou modifier la variable d’environnement PYTHONPATH qui pointe vers le
chemin d'accès au dossier cozmo_fsm.

Note

Le dossier cozmo_fsm se trouve dedans le dossier cozmo-tools. Si vous n’avez

pas installé le paquet cozmo-tools, référez-vous à la guide de Configuration de
l’environnement python.

Windows

Avec l'explorateur de fichiers, accédez à <Votre chemin>\cozmo-tools\cozmo_fsm.

Vous allez maintenant ajouter ce chemin à votre variable d'environnement
PYTHONPATH à l'étape suivante.

1. Ouvrez un explorateur de fichiers

2. Clic droit sur l'icône Ce PC et sélectionnez Propriétés.

3. Sélectionnez Paramètres système avancés > Avancés > Variables

d'environnement.

4. Sous Variables utilisateur, sélectionnez PYTHONPATH et cliquez sur

Modifier. Si la variable n’existe pas, créez-la en cliquant sur Nouvelle.

5. Sous Valeur de la variable ajoutez le chemin d'accès au dossier

contenant cozmo_fsm (par exemple, C:\Utilisateurs\votre_nom\cozmo-
dev\cozmo-tools\cozmo_fsm). Cliquez sur OK dans toutes les boîtes de
dialogue pour confirmer votre modification.

Linux

Avec l'explorateur de fichiers ou la console, accédez à <Votre chemin>\cozmo-

tools\cozmo_fsm. Vous allez maintenant ajouter ce chemin à votre variable
d'environnement PYTHONPATH à l'étape suivante.

page
08
Tuto cozmo_fsm : Machines à états finis

1 1. Éditez votre fichier ~/.bashrc et ajoutez cette ligne :

export PYTHONPATH=${PYTHONPATH}:<votre-chemin>/cozmo-
tools/cozmo_fsm

2. Enregistrez .bashrc puis appelez:

$ source .bashrc

Toutes les plate-formes

Confirmez que PYTHONPATH pointe correctement vers cozmo_fsm.

1. Ouvre une nouvelle console Anaconda Prompt.

$ conda activate cozmo-env

2. Activez l’environnement python et après importez le paquet cozmo_fsm.

Aucune erreur ne doit apparaître.

$ pyhon
… initialization stuff …
>>> from cozmo_fsm import *
>>>

3. Maintenant copiez les programmes simple_cli et genfsm (qui sont dedans

cozmo-tools) à votre dossier de travail, c’est-à-dire, au dossier qui contient
vos codes source.

Ces modifications vous permettent :

▪ Importer cozmo_fsm dans vos codes depuis n’importe quel chemin.

▪ Exécuter genfsm et runfsm directement dès votre dossier de travail.

page
09
Tuto cozmo_fsm : Machines à états finis

1 Annexe B : Noeuds et transitions

À continuation la liste de nœuds et transitions les plus communs de cozmo_fsm :

ActionNode
Say(text)
Forward(distance, speed)
Turn(angle)
GoToPose(pose)
SetHeadAngle(angle)
SetLiftHeight(height)
DockWithCube(object)
PickUpObject(object)
PlaceObjectOnGroundHere(object)
PlaceOnObject(object)
Animation Nodes
AnimationNode(anim_name)
AnimationTriggerNode(trigger)
StartBehavior(behavior)
StopBehavior
FindFaces
KnockOverCubes
LookAroundInPlace
Action Nodes
Classe de base pour les nœuds d'action
Parle du texte.
Avance une distance à une vitesse spécifiés.
Tourne un angle spécifié.
Utilise la méthode go_to_pose() du SDK.
Place la tête à l'angle spécifié.
Met le levier à la hauteur spécifiée.
Utilise la méthode dock_with_cube() du
SDK.
Utilise la méthode pick_up_object() du
SDK.
Utilise la méthode
place_object_on_ground_here() du SDK.
Utilise la méthode place_on_object() du
SDK.
Utilise la méthode play_anim() du SDK.
Utilise la méthode play_anim_trigger()
du SDK.
Behavior Node
Utilise la méthode start_behavior() du
SDK.
Utilise la méthode stop() du SDK.
Utilise le comportement FindFaces du
SDK.
Utilise le comportement KnockOverCubes
du SDK.
Utilise le comportement
LookAroundInPlace du SDK.

page
010
Tuto cozmo_fsm : Machines à états finis

1 PounceOnMotion Utilise le comportement PounceOnMotion

du SDK.
RollBlock Utilise le comportement RollBlock du SDK.
StackBlocks Utilise le comportement StackBlocks du
SDK.
Transitions
Forme longue Abréviation Description
NullTrans N Se déclenche immédiatement.
TimerTrans(secs) T(secs) Se déclenche après un certain nombre
de secondes spécifié.
CompletetionTrans(n) C ou C(n) Se déclenche lorsque tous (ou au moins
n) les nœuds sources sont terminés.
SuccessTrans(n) S ou S(n) Se déclenche lorsque tous (ou au moins
n) les nœuds sources ont publié un
événement SuccessEvent.
FailureTrans(n) F ou F(n) Se déclenche lorsque tous (ou au moins
n) les nœuds sources ont publié un
événement FailureEvent.
TapTrans(cube) Tap ou Se déclenche lorsqu’un cube (ou un
Tap(cube) cube spécifique, par exemple, cube1)
est tapé.

page
011