FSM

Mquinas de Estado Finito Ingeniera de Software I
- 1 -
Mquinas de Estado Finito

INTRODUCCIN................................................................................................................2
SINTAXIS..............................................................................................................................2
SEMNTICA........................................................................................................................3
EJEMPLO..............................................................................................................................3
TRAZAS ................................................................................................................................4
EJEMPLO..............................................................................................................................4
DEADLOCK.........................................................................................................................5
EJEMPLO..............................................................................................................................5
SEMNTICA DEL DEADLOCK ................................................................................................5
COMPOSICIN DE FSM...................................................................................................6
SINTAXIS DE LA COMPOSICIN.............................................................................................7
Ejemplo ...........................................................................................................................7
Sobre la composicin......................................................................................................8
EJEMPLO..............................................................................................................................9
EXTENSIONES..................................................................................................................10
CONDICIONES ....................................................................................................................10
ACCIONES..........................................................................................................................10
VARIABLES ........................................................................................................................10
Ejemplo .........................................................................................................................11
CONDICIONES DE SALIDA DE UN ESTADO ...........................................................................11
Ejemplo .........................................................................................................................12
FSMS TEMPORIZADAS.......................................................................................................12
Ejemplo .........................................................................................................................13
NO DETERMINISMO.......................................................................................................13
EJEMPLO............................................................................................................................13
MODELO CONCEPTUAL...............................................................................................17
EJEMPLO............................................................................................................................17
ACLARACIONES .................................................................................................................20
- 2 -
Introduccin

Las mquinas de estado finito son una herramienta muy til para especificar aspectos
relacionados con tiempo real, dominios reactivos o autnomos, computacin reactiva,
protocolos, circuitos, arquitecturas de software, etc.

El modelo de FSM (Finite State Machine) es un modelo que posee sintaxis y semntica
formales y que sirve para representar aspectos dinmicos que no se expresan en otros
diagramas.

Sintaxis

Las mquinas de estado finito se definen como una tupla , , , S A S S sk , donde:

{ }
1 2
, ,..., :
m
S s s s = es un conjunto finito de nodos.
: es un alfabeto finito de etiquetas.
: A es un conjunto finito de aristas etiquetadas que unen nodos.
: sk S es el estado inicial.

Ejemplo

{ } 1, 2, 3 S =
,

{ } , a b =
,

( ) ( ) ( ) ( ) { }
1, , 2 , 2, , 3 , 3, ,1 , 1, , 3 A a b a b =
,

1 sk =

Vale la pena destacar que formalmente la mquina de estado es la tupla anterior y no el
dibujo. Este es tan slo una representacin grfica de la mquina de estado para tener una
ms sencilla y rpida visualizacin de su contenido.
1
3
a
b
b
a
2
- 3 -
Semntica

Los nodos representan los posibles estados de aquello que se desea modelar. Las etiquetas
representan eventos que provocan un cambio. Las aristas determinan de qu manera cada
estado, dado un evento, deriva en otro estado.
Ejemplo

Supongamos que se quiere modelar el comportamiento de una puerta. La puerta,
inicialmente cerrada, puede pasar a estar abierta tras el evento abrir puerta. Una vez
abierta, puede pasar al estado cerrada, tras el evento cerrar puerta.

cerrada abierta
abrir puerta
cerrar puerta
- 4 -
Trazas

El conjunto de posibles trazas correspondientes a una mquina de estado finitos, se puede
definir en trmino de grafos, cmo el conjunto de todos los caminos (de ejes) alcanzables
desde el estado inicial.

Ejemplo

Dada la FSM de ejemplo:

Las trazas de esta FSM son:

{a, b, a} correspondiente a 1, 2, 3, 1
{b, a} correspondiente a 1, 3, 1
{a, b, a, b, a} correspondiente a 1, 2, 3, 1, 3, 1
{b, a, a, b, a} correspondiente a 1, 3, 1, 2, 3, 1
{b, a, b, a, ... , b, a} 1, 3, 1, 3, , 1, 3
Etc

1
2
3
a
b
b
a
- 5 -
Deadlock

Formalmente hablando, una FSM , , , S A S S sk , tiene deadlock, si existe algn
nodo s S , tal que no existen un evento e y un nodot S tal que ( ) , , s e t A . En otras
palabras, si existe algn nodo que no posea salida para ningn evento.

Ejemplo

El estado 2 no posee salida alguna.

Semntica del deadlock

La existencia de deadlock no necesariamente habla de un mal modelado. Ms adelante
veremos que puede ser un efecto no deseado de la composicin de FSMs.

Un ejemplo en donde el deadlock no necesariamente est mal, podra ser el siguiente:
Queremos modelar un partido de ftbol. Un partido de ftbol, en particular, se organiza, se
juega y finaliza. Y una vez finalizado, ese partido no se juega ni organiza nunca ms.
Entonces podramos modelarlo de la siguiente manera:

1
2
3
a
b
a
Esperando
inicio
Partido en
curso
rbitro pita comienzo del partido
Partido
finalizado
rbitro pita fin del partido
- 6 -
Composicin de FSM

Supongamos que se quiere modelar el siguiente comportamiento de un horno microondas:
El horno microondas posee una puerta. Si la puerta est cerrada, entonces puede estar o no
en funcionamiento (segn se prenda o apague). Estando prendido no es posible abrir la
puerta del horno sin antes apagarlo.

Tambin asumamos lo siguiente: en cualquier momento es posible establecer el modo de
coccin.

No es obligatorio etiquetar los nodos, sin embargo puede resultar muy til hacerlo: sobre
todo aquellos nodos que representan los estados principales de que se est modelando.

Muchas veces es posible descomponer un complicado problema en problemas ms
pequeos y ms fciles de tratar. Esto tambin es aplicable a las FSMs: una FSM puede
descomponerse en varias FSMs ms simples. Sin embargo (como vern resolviendo los
ejercicios de la prctica) no es trivial hacerlo, y hay que tener mucho cuidado de que la
composicin de las maquinas sencillas represente exactamente a la FSM descompuesta y no
a una parecida.
Puerta abierta y
encendido
deshabilitado
Puerta cerrada y
horno apagado
Puerta cerrada y
horno prendido
cerrar puerta
apagar horno
prender horno
abrir puerta
modo de
coccin
modo de
coccin
modo de
coccin
- 7 -
Sintaxis de la composicin

La composicin de FSMs se realiza a travs de la sincronizacin de etiquetas.

Sean A = , , ,
A A A A A A A
S A S S sk y B = , , ,
B B B B B B B
S A S S sk dos FSM.
La composicin paralela A || B se define como
( ) ( ) ( ) ( ) , , , ,
A B A B A B A B A B
S A S S S S sk sk donde:

A B
S S S
( ) ( ) ( )
, , , ,
a b c d
s s e s s A slo si se cumple alguna de estas condiciones:
o ( ) , ,
a c A B b d
s e s A e s s =
o ( ) , ,
b d B A a c
s e s A e s s =
o ( ) ( ) , , , ,
a c A b d B A B
s e s A s e s A e

Ejemplo

A1
A2
a
c
b
A
B1
B3
B2
a
d
b
B
A||B
A1,B1
A2,B2
a
d
b
A2,B3
c
c
- 8 -
Sobre la composicin

Analicemos el siguiente ejemplo:

Qu sucede con A||B?

Segn nuestras reglas de composicin, A||B quedara con el estado inicial (A1,B1) y la
nica transicin posible sera a, dejando a la mquina en el estado (A2, B2) y en deadlock.
Las mquinas A y B no posean deadlock, pero su composicin s. Tambin podra pasar al
revs. Componer dos FSM no es simplemente poner el smbolo || entre sus nombres: se
debe analizar el posible resultado para comprobar que se est modelando lo que uno
realmente desea modelar.
A1
A2
a a
A
B1
B2
a b
B
b
A1,B1
A2,B2
a
A||B
- 9 -
Ejemplo

Volviendo a nuestro ejemplo:

Podemos descomponer este problema en tres partes: por un lado modelaremos una puerta
que se abre y se cierra, y por otro un horno que se prende y apaga y trataremos el modo de
coccin de manera independiente.

Puerta abierta y
encendido
deshabilitado
Puerta cerrada y
horno apagado
Puerta cerrada y
horno prendido
cerrar puerta
apagar horno
prender horno
abrir puerta
modo de
coccin
modo de
coccin
modo de
coccin
Puerta
abierta
Puerta
cerrada
cerrar
puerta!

Puerta
abrir
puerta!

Modo
modo de
coccin

Horno
apagado
Horno
prendido
cerrar
puerta?

Horno
abrir
puerta?

Encendido
deshabilitado

prender
horno

apagar
horno

HornoMicroondas = Puerta || Horno || Modo
- 10 -
Cuando se hagan composiciones de FSMs, en las transiciones que posean etiquetas con el
mismo nombre en dos o ms maquinas de estado diferentes (es decir las transiciones que
componen) se utilizar el smbolo de exclamacin y de interrogacin para diferenciar entre
el arco que realmente dispara la transicin, del que recibe el impulso. Al nombre de
etiqueta del primero se le concatenar un signo de exclamacin, mientras que al segundo
uno de exclamacin. La semntica es tan simple como que la transicin con el signo de
exclamacin es la que realmente emite y dispara el evento, y las que poseen el de
interrogacin son las que lo reciben.
Extensiones

Para aumentar el poder expresivo, existen extensiones al lenguaje de FSM visto
anteriormente.

Condiciones

Son expresiones booleanas que determinan si una transicin entre estados puede realizarse.
Se escriben entre corchetes.

Acciones

Inmediatamente despus de ejecutar una transicin y antes de arribar al siguiente estado, la
mquina de estado ejecuta una accin. Bsicamente, para nosotros, las acciones sern
asignaciones de valores a variables. En algunos contextos, dentro de las acciones, tambin
se lanzan eventos (para luego sincronizar otras mquinas). Se escriben entre corchetes.

Variables

Sus valores posibles deben pertenecer a un dominio finito. Pueden utilizarse estructuras
como arreglos o tipos abstractos de datos en general (cmo por ejemplo conjuntos o pilas).

Los variables pueden usarse dentro de las expresiones booleanas de las condiciones y su
valor puede cambiarse utilizando acciones, generalmente asignaciones. A su vez, salvo
explicitado lo contrario, las variables son compartidas por todas las FSMs de la
composicin (es decir pueden verse como globales a todas las mquinas de estado).

{accin; accin}
[expresin booleana]
- 11 -
Ejemplo

Un local de ropa puede estar vaco o lleno segn la cantidad de personas que hay en su
interior. Inicialmente est vaco, pero luego de ingresar la primer persona esta lleno. A
partir de ah, la gente puede ingresar o salir. Cuando sale el ltimo, vuelve a estar vaco.

Todas las variables se deben definir de antemano:

contador : [0, 99999999] (por simplicidad, permitiremos decir . Sin embargo, debemos
resaltar que esto no es del todo correcto: el dominio debe tener un nmero finito de
valores).

Condiciones de salida de un estado

Es posible colocar condiciones booleanas dentro de los estados (utilizando [expresin
booleana] dentro de los nodos) para obligar a que se salga del mismo. Mientras la condicin
agregada a un estado sea verdadera es posible mantenerse en dicho estado o salir del mismo
a travs de una transicin cualquiera. Sin embargo apenas dicha condicin se haga falsa la
maquina estar obligada a dejar dicho estado por alguna de las transiciones de salida. Si hay
muchas posibles se saldr por cualquiera de estas de forma no determinstica. Si en cambio
no hay ninguna transicin posible, se caer indefectiblemente en un deadlock.

Supongamos que al ejemplo anterior del local de ropa se le agrega la condicin de que si
hay ms de 1000 personas dentro debe sonar una alarma. Una forma de representar dicha
situacin es componiendo la siguiente FSM a la ya hecha:
vaco
lleno
ingresa persona
{contador++}

Local
{contador = 0}
ingresa persona
{contador++}

egresa persona
[contador > 1]
{contador--}

egresa persona
[contador = 1]
{contador--}

- 12 -
Ejemplo

LocalSeguro = Local || Alarma

FSMs Temporizadas

Muchas veces los disparadores de los eventos que provocan los cambios de estado de las
mquinas son iniciados por el paso del tiempo. Por ej. el cambio de luz de los semforos,
un rociador automtico de csped que se enciende y riega cada 2 horas por 10 minutos, o un
sistema de dosificacin de qumicos en una caera que cada determinada cantidad de
tiempo inyecta distintas sustancias en un orden especial. En todos estos casos la decisin de
que ocurran los eventos es disparada por el tiempo. Para poder representar este
funcionamiento utilizando FSMs se hace necesario extenderlas agregando un componente
extra denominado timer.

Este ser declarado junto con el resto de las variables de la siguiente manera:

nombreTimer: timer. En -unidad de tiempo-. (por ej. segundos).

Las nicas operaciones permitidas por el timer es resetearlo (es decir colocar su cuenta en
0) y chequear su valor (es decir, ver el tiempo transcurrido desde su ltimo reset). Una
vez que el timer es reseteado empieza a contar el tiempo transcurrido hacia adelante, y
eso es todo lo que sabe hacer (no se lo puede setear en un valor determinado por ej.).
Podremos chequear el tiempo transcurrido a travs del uso de condiciones y podremos
resetearlo utilizando acciones.

La sintaxis para resetear el timer es colocando al nombre del mismo dentro de llaves.

Plasmemos el ejemplo del rociador automtico en una FSM para ver como se puede utilizar
esta extensin para representar dicha situacin:
alarma
apagada
[contador
<= 1000]
alarma
encendida
[contador >
1000]

[contador = 1000]
apagar alarma
Alarma
[contador > 1000]
encender alarma
- 13 -
Ejemplo

No Determinismo

Si dado un estado y dado un evento, existe ms de una transicin vlida (cuya condicin, si
existe, se satisface), hacia distintos estados, se asumir un comportamiento no
determinstico: es decir, cualquiera de los estados posibles podr ser alcanzado, sin orden
alguno.

Ejemplo

rociador
apagado
[t < 120]
{t}
rociador
encendido
[u < 10]
[t = 120]
abrir grifo

{u}

t : timer. En minutos.
u: timer. En minutos.
Rociador
[u = 10]
cerrar grifo
{t}
A
B C
a
a
b
b
- 14 -
Abusos de Notacin

Supongamos que se quiere modelar lo siguiente: un operador telefnico puede llamar a tres
personas diferentes, pero slo a una de estas a la vez.

Operador || Persona 1 || Persona 2 || Persona 3

Si en lugar de tres personas, las mismas son 100, o 1000, o 10000, rapidamente nos
encontraremos con un problema.

Operador
Sin
hablar
Hablando
Llama a 1
Llama a 3
Llama a 2
Cuelga 3
Cuelga 2
Cuelga 1
Persona 1
Llama a 1
Cuelga 1
Persona 2
Llama a 2
Cuelga 2
Persona 3
Llama a 3
Cuelga 3
- 15 -
Para modelar lo anterior, aclarando que la cantidad de personas es finita, se podr utilizar la
siguiente notacin:

Operador || Persona 1 || ... || Persona N

Es importante aclarar que al decir Persona i o Llama a i, la letra i no es una variable.
Debe pensarse como una macro que se reemplaza por el nmero correspondiente. Persona i
es el nombre de la mquina. Llama a i es una etiqueta, su nombre no puede ser dinmico.

En el caso del operador, a pesar de que responde a muchos Llama a i posee slo dos
estados: Sin hablar o Hablando.

Por simplicidad, no se recomienda indizar los estados. Es decir, hablar de por ejemplo del
estado Hablando i. La razn de esto es que facilmente se pierde control de lo que se est
queriendo modelar.

El problema anterior se podra pensar de la siguiente manera:

Operador
Sin
hablar
Hablando
Llama a 1
Llama a N
...
Cuelga 1
...
Cuelga N
Persona i
Llama a i
Cuelga i
- 16 -

Es decir, identificar en el operador, no slo si est hablando o no, sino que tambin con
quien lo est haciendo (en el otro ejemplo, esta informacin es deducible).

Puede verse cmo, al explotar los estados, se forma una especie de abanico. Imaginense
ahora que desde el estado Hablando i, sale otra flecha cuyo evento tambin se encuentra
indizado y que llega a otro estado tambin indizado. Este tipo de abuso, oculta mucha
informacin que hace a la interpretacin de la mquina de estados.
Operador
Sin
hablar
Hablando i
Llama a 1
Llama a N
...
Cuelga 1
...
Cuelga N
Persona i
Llama a i
Cuelga i
Operador
Sin
hablar
Hablando 1
Llama a 1
Llama a 3
Llama a 2
Cuelga 3
Cuelga 2
Cuelga 1
Hablando 2
Hablando 3
- 17 -
Otra forma de hacerlo (probablemente no la ms bonita desde el punto de vista de la
claridad expositiva pero sintcticamente correcta) es la siguiente, ahora utilizando una
nica maquina de estados pero agregando variables y condiciones:

destinatario: [1, N]

Es decir se reemplazan las N FSMs Persona i por una variable destinatario que
almacena al receptor de la llamada del operador y restringe la salida del estado Hablando
por la nica transicin correcta.

Modelo Conceptual

Las mquinas de estado finito, puede utilizarse para especificar aspectos dinmicos de
problemas. Dichos problemas, probablemente tambin posean aspectos estticos:
estructuras de datos necesarias, entidades relacionadas entre s, invariantes, etc. Muchos de
estos aspectos pueden modelarse a travs de un modelo conceptual. A veces, puede ser til
especificar el comportamiento de las entidades identificadas en el modelo conceptual: sus
posibles cambios de estados. En estos casos, es interesante combinar distintas tcnicas:
modelo conceptual, OCL y FSM.

El objetivo ser explicar la semntica de las transiciones de la FSM, identificando
responsabilidades en las entidades, las cuales podrn ser especificadas formalmente
utilizando OCL.
Ejemplo

Operador
Sin
hablar
Hablando
Llama a 1
{destinatario=1}
Llama a N
{destinatario=N}
...
[destinatario=1]
Cuelga 1
...
[destinatario=N]
Cuelga N
- 18 -

Supongamos el siguiente dominio de problema: al ingresar una orden de compra, se
determinan cules son los electrodomsticos que se vendern. Luego, cuando la orden es
autorizada, los electrodomsticos son reservados. Slo despus de que la orden se encuentra
autorizada, sta puede ser facturada. El importe de la factura debe ser igual a la suma de los
precios de los electrodomsticos.

// Los electrodomsticos no deben estar reservados si la orden an no fue autorizada.
Context: OrdenDeCompra
Inv: self.estaAutorizada? = False implies (self.electrodomesticos->forAll( e | e.reservado = false))

// Una orden est autorizada, si posee una autorizacin asociada.
Context: OrdenDeCompra :: estaAutorizada? : boolean
Derive: self.autorizacin->size() > 0

// Una orden est facturada, si posee una factura asociada.
Context: OrdenDeCompra :: estaFacturada? : boolean
Derive: self.factura->size() > 0

// Una orden no puede ser facturada sino fue autorizada previamente.
Context: OrdenDeCompra
Inv: self.estaAutorizada? = False implies (self.estaFacturada? = False)

// El importe de la factura debe ser igual a la suma de los precios de los electrodomsticos.
Context OrdenDeCompra
Inv: self.estaFacturada? implies (self.factura.importe = self.electrodomesticos.precio->sum())
- 19 -
El ciclo de vida de una orden de compra, es el siguiente:

Cuando una FSM describa el comportamiento de una sola entidad, podremos fijar el
contexto de la misma y podremos delegar las acciones correspondientes a algunos eventos,
en responsabilidades de la entidad contexto.

Y luego se deber refinar el modelo conceptual:

Context: Orden de Compra
Ingresada
Autorizada
OrdenDeCompra
Facturada
registrarAutorizacin
emitirFactura
Ingresada
Autorizada
OrdenDeCompra
Facturada
registrarAutorizacin
R: autorizar()
emitirFactura
R: facturar()
- 20 -
Y con OCL especificar las responsabilidades:

Context: OrdenDeCompra:: autorizar
// No debe estar autorizada
Pre: self.estaAutorizada = False
// Luego de ejecutar esta responsabilidad, se crea una autorizacin asociada a la orden. Y se
reservan todos los electrodomesticos de la orden.
Post: self.autorizacin->size() = 1 and self.autorizacion.oclIsNew() and
self.electrodomesticos->forAll( e | e.reservado = true)

Context: OrdenDeCompra:: facturar
// Debe estar autorizada y no debe estar facturada
Pre: self.estaAutorizada = True and self.estaFacturada = False
// Luego de ejecutar esta responsabilidad, se crea una factura asociada a la orden.
Post: self.factura->size() = 1 and self.factura.oclIsNew() and
self.factura.importe = self.electrodomesticos.precio->sum()

Aclaraciones

La incorporacin de estas extensiones, no condiciona ni cambia el comportamiento
de la FSM ni su posible composicin. El objetivo slo es adicionar informacin
semntica sobre qu significa, con respecto al modelo conceptual, que cierta entidad
cambie de estado.

Una vez establecido el contexto de una FSM, es posible utilizar expresiones OCL en
las condiciones y acciones: se cuenta con los valores de los atributos (accediendo
mediante el operador self) y con toda la informacin disponible mediante la
navegacin del modelo conceptual.

FSM

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

FSM

Загружено:

Авторское право:

Доступные форматы

Mquinas de Estado Finito Ingeniera de Software I

Вам также может понравиться