Introduction

Goal: Realizzazione di un sistema in grado di sincronizzarsi in modo autonomo.

Requirements

Requirement Analysis

- Quando il cliente si connette al sito, vengono mostrate a schermo le "lucciole"
  (inizialmente spente) che iniziano a lampeggiare in modo randomico, ognuna a
  una sua frequenza.

- Dopo 10 secondi le lucciole si sincronizzano e iniziano a lampeggiare con la
  stessa frequenza e durata.

- Ogni lucciola viene rappresentata come un Attore poiché entità in grado di agire
  (in questo caso lampeggiare) in modo autonomo (è un'entità viva).

Firefly

    QActor firefly context ctxfirefly {
[# 
   var X = 0        //coordinata X
   var Y = 0        //coordinata Y
   var Timer = 0L   //frequenza di lampeggiamento
#] 

    State s0 initial {
        //viene in inizializzato in modo randomico il timer
    }
    Goto flash

    State flash {
        // Accensione lucciola
        // La lucciola rimane accesa
        // Spegnimento lucciola
    }
    Transition t0 
        whenTimeVar Timer -> flash      //scaduto il tempo, ritorna allo stato flash
}

Problem Analysis

- È possibile realizzare la sincronizzazione delle lucciole in due modi possibili:
  con o senza l'utilizzo di un coordinatore (orchestratore).

    Nel primo caso, le lucciole agiscono in modo autonomo e "sconnesso" fino a
    quando un'altra entità distinta (o una delle lucciole stesse) invia un segnale
    (evento) che obbliga le lucciole a sincronizzarsi.

    Nel secondo caso, invece, le lucciole si sincronizzano totalmente in modo
    autonomo, senza l'aiuto di un'entità esterna.

- Per semplicità, decidiamo di usufruire di un orchestratore che "comanda" le
  lucciole affinché lampeggino alla stessa frequenza comune a tutte (prestabilita).

- Avendo già a disposizione "griddisplay", lo ricicliamo per permettere la
  visualizzazione a schermo delle lucciole, rappresentate come celle di una griglia.
  Inizialmente sono verdi; quando si accendono diventano rosse.

- Come linguaggio viene scelto QAK.

Di seguito vengono mostrati pseudocodici delle entità in gioco:

Firefly

Ogni lucciola viene realizzata nel secondo modo:

QActor firefly context ctxfirefly {
    [#
        var X     = 0   
        var Y     = 0   
        var Timer = 0L  
        var FLAMP = 500L  //frequenza che le lucciole devono seguire dopo 10 secondi
    #]

    State s0 initial {
        //inizializzazione timer
    }
    Goto flash

    State flash {
        // Accensione lucciola
        // aspetta mezzo secondo prima di spegnersi
        // Spegnimento lucciola
    }
    Transition t0
        whenTimeVar Timer -> flash       // scatta il timer → torna a flash
        whenEvent   synch  -> handleSynch  // arriva evento → gestisci sync

    State handleSynch {
        // viene settata la frequenza (Timer) al valore FLAMP stabilito
    }
    Goto flash  // ritorna a lampeggiare
}

Coordinator

QActor coordinator context ctxfirefly {

		[#
		val Timer = 10000L  //entro quanto si devono sincronizzare le lucciole 
		val FLAMP = 500L   //frequenza comune delle lucciole
		#]
	
	State s0 initial {
		//stato iniziale
	}
	Transition t0
		whenTimeVar Timer -> changeFLAMP //allo scadere del timer, manda evento a tutte le lucciole

	State changeFLAMP {
        // Mando a tutte le lucciole (a tutto il contesto) l'"ordine" di sincronizzarsi attraverso l'evento
	}
}

Test Plans

Project

Testing

Deployment

Maintenance