SML - State Machine Language

INTRODUZIONE

                               +------+
      +------+    *******    +------+ |
      |      |    *     *    |      | |
      | .sml |--->* SML *--->|      | |   files generati
      |      |    *     *    |      |-+      .c e .h
      +------+    *******    +------+

CONVENZIONI DEL DOCUMENTO

FUNZIONAMENTO

• wait event
• dispatcher

• opzione nel linguaggio SML
• opzione al lancio di SML
• define di compilazione dei sorgenti generati

MODALITA' WAIT EVENT

   Codice Generato                 Codice Libreria
   main
     EVENTINIT()
     main_SM1()
       while( EVENTWAIT(SM1) )     Attende evento per la StateMachine SM1
                                   quando evento ritorna
         esegue funzione utente()
     EVENTEND()

MODALITA' DISPATCHER

   Codice Generato                 Codice Libreria
   main
     EVENTINIT()
     while( DISPATCHER(CH1) )
                                   while
                                     Attende eventi sul canale CH1
                                     quando evento esegue funzione utente()
     EVENTEND()

TESTING

***********                         **********
*         *       +---------+       *        *
* SMLTEST *  -->  | | | | | |  -->  * SMLGEN *
*         *       +---------+       *        *
***********       event queue       **********

FILES GENERATI

• smlmain.c
• smlutil.c
• smlgen.c
• smlgen.h
• smlgen.doc
• smlgen.mak
• smltest.c

• smlgen
• smltest

MODULARITA'

             +------------------+ +------------------+
             |  generated code  | |    user code     |
             +------------------+ +------------------+
                       |                 |   |
                       +---------+-------+   |
                                 |           |
......................................................................
. LIBRARY SML                    |           |                       .
.                       +------------------+ |                       .
.                       |     events       | |                       .
.                       +------------------+ |                       .
.                                |           |                       .
.       +-----------+------------+-----------+                       .
.       |           |            |           |                       .
.  +---------+ +---------+  +---------+ +---------+  +---------+     .
.  | userevt | |  timer  |--|  input  | |   sm    |--| context |     .
.  +---------+ +---------+  +---------+ +---------+  +---------+     .
.                                |                                   .
.                     +----------+-----------+                       .
.                     |          |           |                       .
.                 +--------+ +--------+ +--------+                   .
.                 | queues | |  pipe  | | stream |                   .
.                 +--------+ +--------+ +--------+                   .
.                                                                    .
......................................................................

PORTABILITA'

CODICE UTENTE

%{
    /* ...user code here... */
}%

   ...
   FUNCTIONS {
    NAME SM1Error BEGIN
      %{ UsrLogFunction( "Errore" ); }%
      EMIT( "SM1: error" )
      NEXTSTATE( SM1_S_IDLE )
    END
    NAME SM1fun1 {
    ...

ESEMPIO

definizione    generazione     generazione    test   verifica
StateMachine      SML          eseguibili            funzionamento

***********
* editor  *
***********
     |
     v
+---------+
|         |    ***********
| XXX.sml | -> *   SML   *
|         |    ***********
+---------+         |          +---------+
                    V          | smllib  |
                +---------+    +---------+
               +---------+|         |
              +---------+||         V
              |         |||    ***********
              |smlgen.X ||+ -> *   CC    *
              |         |+     ***********
              +---------+           |
                                    V
                               +---------+
                               |         |
                               | smltest | -> +-+
                               |         |    +-+
                               +---------+    +-+
                               +---------+    +-+
                               |         |    +-+
                               |   sml   | <- +-+    +---------+
                               |         | --------> | sml.log |
                               +---------+           +---------+

DICHIARAZIONI

• Modulo
• Dati
• Elenco State Machine
• Funzioni
• State Machine (stati/eventi)

MODULO

MODULE Example1 %{
\#include 

static flag = 1;

}%

DATI

DATA TYPE BEGIN
  NAME SM1data
  NAME SM2data
  NAME SM1toSM2
  NAME SM2toSM1
END

typedef struct {
    int         state;
    /* FIELDS ADDED by USER... */
    } SM1data; /*C1*/
/* ...omissis... */
typedef struct {
    int         state;
    /* FIELDS ADDED by USER... */
    } SM2toSM1; /*C1*/

/* data sended on channels */
typedef struct {
  Evt   evt;       /* event field */
  long  len;
  union data {
    SM1data SM1data;
    SM2data SM2data;
    SM1toSM2 SM1toSM2;
    SM2toSM1 SM2toSM1;
    } data;
  } Data, *DataP;

CHANNELS

• message queues
• shared memory
• pipes

CONTEXT

Legenda:   {N}  Channels
           [N]  StateMachine
           (N)  Context

  -------> {1} >>>> [1] ---> [5] ---> [9]
                     |        |        |
                    (1)      (1)      (1)
                     |        |
                    (2)      (2)
                              |
                             (3)

  -------> {2} >>>> [2] ---> [8] ---> [7] ---> [6]
                     |        |        |
            .       (1)      (1)      (1)
            .        |
            .       (2)

  -------> {N} >>>> [3] ---> [4]
                     |        |
                    (1)      (1)
                              |
                             (2)

EVENTI

• message queue
• pipe (fifo)
• streams
• devices
• da gestione utente

• EVENT_NONE evento nullo
• EVENT_TIMER evento da un timer
• EVENT_INPUT evento da un dispositivo di input (pipe, stream)
• EVENT_USER evento gestito dall'utente
  
• EVENT_QUIT evento di terminazione
• EVENT_RESET evento di reset rimette nello stato di partenza
• EVENT_ERROR errore a livello di sistema

EVENTI DA SORGENTI MULTIPLE

                              +------------+     +---------------+
rete locale  -->  streams --> |            |     |               |
files        -->  pipe    --> | dispatcher | --> | State Machine |
timer        -->  timer   --> |            |     |               |
                              +------------+     +---------------+

PASSAGGIO DATI

GESTIONE EVENTI

                      +-------------+
             +------->| WaitEvent() |
             |        |             | StateMachine1
Unix         |  +----<|  EvtSend(2) |
MsgQueue     |  |     +-------------+
+----+       |  |
|    |>------+  |
|    |<--+---|--+
+----+   |   |  |
         |   |  |
         |   |  |     +-------------+
         |   +------->| WaitEvent() |
         |      |     |             | StateMachine2
         |      +----<|  EvtSend(1) |
         |            +-------------+
         |(A)
         |            +-------------+
         |   +------->| WaitEvent() |
         |   |        |             | StateMachine3
         |   |  +----<|  EvtSend(4) |
Unix     +---|--|----<|  EvtSend(2) |
MsgQueue     |  |     +-------------+
+----+       |  |
|    |>------+  |
|    |<------|--+
+----+       |  |
             |  |
             |  |     +-------------+
             +------->| WaitEvent() |
                |     |             | StateMachine4
                +----<|  EvtSend(3) |
                      +-------------+

  OLD  -  Event TX for SM1 -----+-- estratti da WaitEvent di StateMachine1
   .   -  Event RX for SM2 --+  |
   .   -  Event CK for SM1 --|--+
   .   -  Event TX for SM1 --|--+
   .   -  Event CK for SM2 --+
  NEW  -  Event RX for SM2 --+----- estratti da WaitEvent di StateMachine2

ORDINE DI DICHIARAZIONE

• dichiarazione componente
• dichiarazione tipi
• dichiarazione gerarchia automi
• dichiarazione canali
• definizione automi

DICHIARAZIONE COMPONENTE

    MODULE ident PREFIX ident BEGIN ... END

    MODULE prova PREFIX prova BEGIN
    >#include 
    >
    >int debug = 0;
    >
    END

DICHIARAZIONE TIPI

DATA TYPE BEGIN
  NAME name
  ...
END

DICHIARAZIONE STATE MACHINE

STATEMACHINE DEFINITION BEGIN
  NAME name CHANNEL number TYPE datatype {ON|OFF}
  ...
END

DICHIARAZIONE GERARCHIA AUTOMI

DICHIARAZIONE CANALI

DEFINIZIONE AUTOMI

  STATEMACHINE smname {
    STATES { state1, state2, ...,  stateN }
    EVENTS { event1, event2, ...,  eventN }
    FUNCTIONS {
      NAME funname {
        instructions...
      }
      NAME funname {
        instructions...
      }
      ...
    }
    INIT = funname
    SET ( state,  event )  = funname
    SET ( state1, event1 ) = funname
    ...
    SET ( stateN, eventN ) = funname
  }

ISTRUZIONI

  EMIT( string )
  NEXSTATE( state )
  SEND( channel, sm, event, datatype )

FILES

  smlmain.c  .. contiene un main di partenza programma
                un main_XXX per ogni SM utilizzata
  smlgen.c   .. contiene le funzioni delle macchine a stati
                e le stringhe di intentificazione di eventi e stati
  smlgen.h   .. contiene le definizioni dei tipi: dati, contesti
                define per eventi e stati
                prototipi funzioni
  smlgen.doc .. contiene la documentazione delle SM generate

LOG

PREPROCESSOR

BNF

Convenzioni:    XX            .. keyword
                        .. identificatore
                        .. simbolo non terminale
                +        .. presenza di almeno un elemento (da 1 a N)
                *        .. presenza di elementi (da 0 a N)
                [xx]        .. xx e' facoltativo


sml                :=    
                         
                         
                         
                         +

module_def         :=    MODULE 
data_def           :=    DATA TYPE BEGIN
                          +
                         END
single_data_def    :=    NAME 
machines_def       :=    STATEMACHINE DEFINITION BEGIN
                           +
                         END
single_sm_def      :=    NAME  TYPE  ON|OFF

VERSIONE DEMO

• consente massimo:
  • 1 state machine (illimitate)
  • 2 stati (illimitati)
  • 2 eventi (illimitati)
• limita le tipologie di eventi a:
  • 1 timer (100)
  • 1 input (100)
  • 1 evento utente (100)
• non consente l'inserimento di codice utente nelle funzioni
• non consente l'inserimento di codice utente nei tipi di dati
• lunghezza codice utente massimo 32 byte
• lunghezza dato massima 32 byte

TIMER

  int   TimerInit( void )
  int   TimerDisplay( int id )
  int   TimerAdd( int seconds, int step, int (*fun)(int id) )
  int   TimerSet( int id, int seconds, int step, int (*fun)(int id) )
  int   TimerDel( int id )
  Timer TimerGet( int id )
  int   TimerSetStat( int id, int stat )
  int   TimerCheck( int mode, int *id )
  int   TimerManage( int mode, int *id )
  int   TimerSelect( int seconds )

INPUT

  int   InputInit( void )
  int   InputDisplay( int id )
  int   InputAdd( int fd, int (*fun)(int id) )
  int   InputSet( int id, int fd, int (*fun)(int id) )
  int   InputDel( int id )
  Input InputGet( int id )
  int   InputGetN( int id )
  int   InputManage( int mode, int *id )
  int   InputSelect( int seconds )

USER EVENTS

  int     UserEvtInit( int (*checkfun)(int *id) )
  int     UserEvtDisplay( int id )
  int     UserEvtAdd( int fd, int (*fun)(int id) )
  int     UserEvtSet( int id, int fd, int (*fun)(int id) )
  int     UserEvtDel( int id )
  UserEvt UserEvtGet( int id )
  int     UserEvtGetN( int id )
  int     UserEvtManage( int mode, int *id )