Event-driven finite-state machine

<h2 id="example-in-c">Example in C</h2>
<p>This code describes the state machine for a very basic car radio system. It is basically an infinite loop that reads incoming events. The state machine is only 2 states: radio mode, or CD mode. The event is either a mode change from radio to cd back and forth, or a go to next (next preset for radio or next track for CD). 
</p>
/********************************************************************/
#include <stdio.h>

/********************************************************************/
typedef enum {
        ST_RADIO,
        ST_CD
} STATES;

typedef enum {
        EVT_MODE,
        EVT_NEXT
} EVENTS;

EVENTS readEventFromMessageQueue(void);

/********************************************************************/
int main(void)
{
  /* Default state is radio */  
  STATES state = ST_RADIO;
  int stationNumber = 0;
  int trackNumber = 0;

/* Infinite loop */
  while (1)
  {
    /* Read the next incoming event. Usually this is a blocking function. */
    EVENTS event = readEventFromMessageQueue();

/* Switch the state and the event to execute the right transition. */
    switch (state)
    {
      case ST_RADIO:
        switch (event)
        {
          case EVT_MODE:
            /* Change the state */
            state = ST_CD;
            break;
          case EVT_NEXT:
            /* Increase the station number */
            stationNumber++;
            break;
        }
        break;

case ST_CD:
        switch (event)
        {
          case EVT_MODE:
            /* Change the state */
            state = ST_RADIO;
            break;
          case EVT_NEXT:
            /* Go to the next track */
            trackNumber++;
            break;
        }
        break;
    }
  }
}

<h2 id="same-example-in-ginr">Same example in Ginr</h2>
<p><a href="https://github.com/ntozubod/ginr">Ginr</a> is an industrial-strength compiler producing multitape finite state automata from rational patterns, functions and relations expressed in <a href="/facts/Semiring/7cSvWXVQ">semiring</a> algebraic terms. The example below shows a binary rational function equivalent to the above example, with an additional transition (nil, radio) to set the system into its initial state. Here the input symbols nil, mode, next denote events that drive a transducer with output effectors cd, nextTrack, radio, nextStation. Expressions like this are generally much easier to express and maintain than explicit listings of transitions.
</p>
StateMachine = (
  (nil, radio)
  (
    (mode, cd) (next, nextTrack)*
    (mode, radio) (next, nextStation)*
  )*
  (
    (mode, cd) (next, nextTrack)*
  )?
);

<p>Compilation produces a subsequential (single-valued) binary transducer mapping sequences of events to sequences of effectors that actuate features of the CD/radio device.
</p>
StateMachine:prsseq;

(START)  nil [ radio ]          1
1        mode [ cd ]            2
2        mode [ radio ]         3
2        next [ nextTrack ]     2
3        mode [ cd ]            2
3        next [ nextStation ]   3

<p>Modelling discrete systems in this manner obtains a clean separation of syntax (acceptable ordering of events) and semantics (effector implementation). The syntactic order of events and their extension into the semantic domain is expressed in a symbolic (semiring) domain where they can be manipulated algebraically while semantics are expressed in a procedural programming language as simple effector functions, free from syntactic concerns. The rational expressions provide concise holistic maps of the protocols that effect system governance. The compiled automata are post-processed to obtain efficient controllers for run-time deployment.
</p>
<h2 id="see-also">See also</h2>
<ul><li><a href="/facts/Finite-state_machine/GMusWd0a">Finite-state machine</a></li>
<li><a href="/facts/Specification_and_Description_Language/dW7Q5zIe">Specification and Description Language</a></li></ul>
<h2 id="external-links">External links</h2>
<ul><li><a href="https://github.com/ntozubod/ginr/blob/main/USAGE.md">Ginr</a> (ginr whitepaper and user's guide)</li>
<li><a href="https://github.com/jrte/ribose/blob/master/README.md">Ribose</a> (demonstrates using ginr to transduce sequential media)</li></ul>
<h2 id="further-reading">Further reading</h2>
<ul><li>Peatman, John B. (1977). <i>Microcomputer-based Design</i>. New York: McGraw-Hill, Inc. <a href="/facts/ISBN_(identifier)/15AdSPa9">ISBN</a> 0-07-049138-0.</li>
<li>Brookshear, J. Glenn (1989). <i>Theory of Computation: Formal Languages, Automata, and Complexity</i>. Redwood City, California: Benjamin/Cummings Publish Company, Inc. <a href="/facts/ISBN_(identifier)/15AdSPa9">ISBN</a> 0-8053-0143-7.</li></ul>

Event-driven finite-state machine open-in-new

Event-driven finite-state machine