Firefly Synch

Realizzazione di un sistema firefly che simula il comportamento di 3 lucciole, gestendo inoltre la sincronizzazione tra queste.

1. Costruire il simulatore di un sistema costituito da 3 lucciole
2. Le lucciole lampeggiano ciascuna con una frequenza propria e costante
3. Dopo 10 secondi le lucciole devono lampeggiare in modo sincronizzato

• Per poter definire il sistema, ne viene definito il modello in linguaggio QAK: Il sistema prende il nome di fireflysync. In primo il comportamento della singola lucciola viene rappresentato da un QActor firefly. Ognuna delle 3 lucciole, dovendo presentare un comportamento autonomo è realizzata da un QActor distinto. Le lucciole non interagiscono tra di loro, durante il loro tempo di vita. Il comportamento atteso da ogni firefly, nell'attore QAK è l'alternanza accensione/spegnimento, ad intervalli costanti, definiti per ogni firefly.

                  System fireflysync
  
                  QActor firefly context ctxfirefly{
                      State s0 initial{
                          // Definizione del Timer specifico per ogni lucciola
                      }
                      Goto flash
  
                      State flash{
                          
                          //Turn on the Light 
                          //Wait	
                          //Turno Off the Light
                      }
                      Transition t0
                          whenTimeVar Timer   -> flash
                  }
              

• Per realizzare il comportamento da autonomo a sincronizzato:
  1. si considera la presensza di un orchestratore (es lucciola regina) che dopo 10 secondi emette una frequenza a cui tutte le lucciole devono stare atteni. Come pro ha che l'orchestratore decide tutto il comportamento e la politica complessiva del sistema.
     

Per gestire la sincronizzazione delle firefly si considera il modello con orchestratore. In particolare si realizza l'orchestratore come un QActor di nome fireflyqueen, che invia un messaggio di sincronizzazione di priorità più elevata, al fine di dettare la frequenza delle altre lucciole. Queste passano da una prorpia frequenza personale, a quella dettata dall'orchestratore. Questo nuovo attore scambia informazini con le lucciole.
L'orchestratore dopo un tempo di 10 secondi, emana ad intervalli costanti un evento sync, secondo un timer da lui deciso. Questi eventi dettano il tempo alle lucciole

                System fireflysync
                
                //messaggio per la gestione della sincronizzazione, in questa implementazione l'argomento è superfluo
                Event sync : time ( X )

                //QActor orchestratore, fireflyqeen, dopo un periodo di 10 secondi, comincia a dettare tramite eventi il timing
                QActor fireflyqueen context ctxfirefly {

                    //init a variable TimeToSync at 10 second
                     
                    State s0 initial{
                        //initial state, wait until 10 second enlapsed
                    }
                    Transition t0 
                        whenTimeVar TimeToSync -> handleSync 
                    
                    State handleSync{	
                        //emit periodically the new time
                        emit sync : time($Timer)
                    }
                    Transition t0 
                        whenTimeVar Timer -> handleSync
                } 
            

La crezione delle lucciole avviene dinamicamente tramite il QActor creator, cui unico scopo è creare le lucciole, etichettate come dinamicOnly.

                               
                Context ctxfirefly ip [ host="localhost" port=8040 ]
                
                //QActor responsabile della creazione delle firefly
                QActor creator context ctxfirefly{
                    State s0 initial{      
                        //initial state:
                        //Create 3 firefly inst.
                    }
                }   
            

Si specifica ulteriormente il comportamento del QActor firefly, il quale per gestire la sincronizzazione, deve elaborare gli eventi di sincronizzazione periodici e prioritari che manda l'orchestratore. Si definisce pertanto un ulteriore stato handleSync, in cui si accende/spegne la luce della singola firefly al tempo dettato dall'evento emanato dall'orchestratore.

                //QActor firefly definisce il modello della firefly e ne definisce il comportamento
                QActor firefly context ctxfirefly dynamicOnly{
                    
                    // Definizione delle variabili per la temporizzazione:
                    // Definisco una variabile Timer

                    State s0 initial{
                        //init firefly state
                    }
                    Goto flash

                    State flash{
                        
                        //Turn on the Light              
                        //Wait 
                        //Turno Off the Light
                    }
                    Transition t0
                        whenTimeVar Timer   -> flash
                        whenEvent   sync    -> syncflash
                        
                    State handleSync{
                        //Turn on the Light           
                        //Wait	
                        //Turno Off the Light
                    }
                    Transition t0
                        whenEvent   sync    -> syncflash
                    
                }