En computación , una máquina de estados finitos (FSM) está impulsada por eventos si la transición de un estado a otro es desencadenada por un evento o un mensaje . Esto contrasta con los orígenes de la teoría del análisis sintáctico del término máquina de estados finitos, donde se describe a la máquina como consumidora de caracteres o tokens .
A menudo, estas máquinas se implementan como subprocesos o procesos que se comunican entre sí como parte de una aplicación más grande. Por ejemplo, un protocolo de telecomunicaciones se implementa la mayor parte del tiempo como una máquina de estados finitos controlada por eventos.
Este código describe la máquina de estados de un sistema de radio de automóvil muy básico. Básicamente, es un bucle infinito que lee eventos entrantes. La máquina de estados tiene solo dos estados: modo de radio o modo CD. El evento es un cambio de modo de radio a CD y viceversa, o un paso al siguiente (próximo ajuste preestablecido para la radio o siguiente pista para el CD).
/********************************************************************/ #incluir <stdio.h> /********************************************************************/ typedef enum { ST_RADIO , ST_CD } ESTADOS ; typedef enumeración { EVT_MODE , EVT_NEXT } EVENTOS ; EVENTOS readEventFromMessageQueue ( void ); /********************************************************************/ int main ( void ) { /* El estado predeterminado es radio */ STATES state = ST_RADIO ; int stationNumber = 0 ; int trackNumber = 0 ; /* Bucle infinito */ while ( 1 ) { /* Leer el próximo evento entrante. Generalmente, esta es una función de bloqueo. */ EVENTOS event = readEventFromMessageQueue (); /* Cambia el estado y el evento para ejecutar la transición correcta. */ switch ( state ) { case ST_RADIO : switch ( event ) { case EVT_MODE : /* Cambia el estado */ state = ST_CD ; break ; case EVT_NEXT : /* Aumenta el número de estación */ stationNumber ++ ; break ; } break ; caso ST_CD : switch ( evento ) { caso EVT_MODE : /* Cambiar el estado */ estado = ST_RADIO ; break ; caso EVT_NEXT : /* Ir a la siguiente pista */ trackNumber ++ ; break ; } break ; } } } Ginr es un compilador de nivel industrial que produce autómatas de estado finito multicinta a partir de patrones racionales, funciones y relaciones expresadas en términos algebraicos de semiring . El ejemplo siguiente muestra una función racional binaria equivalente al ejemplo anterior, con una transición adicional (nil, radio) para poner el sistema en su estado inicial. Aquí los símbolos de entrada nil, mode, next denotan eventos que controlan un transductor con efectores de salida cd, nextTrack, radio, nextStation . Expresiones como esta son generalmente mucho más fáciles de expresar y mantener que listados explícitos de transiciones.
Máquina de estados = ( (Ninguno, radio) ( (modo, cd) (siguiente, siguiente pista)* (modo, radio) (siguiente, siguiente estación)* )* ( (modo, cd) (siguiente, siguiente pista)* )?);
La compilación produce un transductor binario subsiguiente (de valor único) que asigna secuencias de eventos a secuencias de efectores que activan características del dispositivo de CD/radio.
Máquina de estado:prsseq;(INICIO) nil [radio] 11 modo [ cd ] 22 modo [radio] 32 siguiente [ siguientePista ] 23 modo [ cd ] 23 siguiente [ siguienteEstación ] 3
Al modelar sistemas discretos de esta manera se obtiene una clara separación de la sintaxis (ordenación aceptable de los eventos) y la semántica (implementación de los efectores). El orden sintáctico de los eventos y su extensión al dominio semántico se expresa en un dominio simbólico (semirrígido) donde se pueden manipular algebraicamente, mientras que la semántica se expresa en un lenguaje de programación procedimental como funciones efectoras simples, libres de preocupaciones sintácticas. Las expresiones racionales proporcionan mapas holísticos concisos de los protocolos que afectan la gobernanza del sistema. Los autómatas compilados se posprocesan para obtener controladores eficientes para la implementación en tiempo de ejecución.