SMMP/test/client/lib.js

var Pin;

(function(){

	// Constructeur de Pin
	Pin = function(value){
		if( parseInt(value) == value && value >= 0 && value <= 255 )
			this.value = parseInt(value);
		else
			this.value = 0;
	};

	Pin.prototype = { value: this.value };

	Pin.prototype.set = function(value){
		if( parseInt(value) == value && value >= 0 && value <= 255 )
			this.value = parseInt(value);
	};

	Pin.prototype.get = function(){
		return this.value;
	};

})();







var Board;

(function(){


	/* CONSTRUCTEUR DE CARTE
	*
	* @maxPin<int> 											Nombre de pin de la board
	*
	*/
	Board = function(maxPin){
		if( parseInt(maxPin) != maxPin || maxPin < 1 )
			return;

		this.maxPin    = maxPin;
		this.pins      = [];
		this.listener  = [];

		for( var i = 0 ; i < this.maxPin ; i++ )
			this.pins[i]     = false;
			this.listener[i] = null;
	};

	Board.prototype = {
		maxPin:   this.maxPin,  // Nombre de Pins de la Board
		pins:     this.pins,    // Liste des valeurs des pins (FALSE->libre, Pin()->prise)
		listener: this.listener // Contient la classe d'amorcage pour chaque pin
	};


	/* BRANCHE UNE PUCE SUR LA Board
	*
	* @chipInterface<Object>		 							Interface contenant la carte et la mise à jour
	*
	*/
	Board.prototype.plug = function(chipInterface){
		/* [0] Vérification des paramètres
		=========================================================*/
		if( !(chipInterface.chip instanceof Chip) )
			return false;

		/* [1] Vérification des Pins
		=========================================================*/
		for( var i = 0 ; i < chipInterface.chip.pins.length ; i++ )
			if( this.pins[chipInterface.chip.pins[i]] instanceof Pin ) // si pin déja prise
				return false;

		/* [2] Branchement + on lie l'interface
		=========================================================*/
		for( i = 0 ; i < chipInterface.chip.pins.length ; i++ ){
			this.pins[chipInterface.chip.pins[i]]     = chipInterface.chip.values[i];
			this.listener[chipInterface.chip.pins[i]] = chipInterface;
		}
	};

	/* MODIFICATION D'UNE VALEUR DE PIN
	*
	* @pinOrder<int> 										Indice de la pin
	* @value<int> 											Valeur à attribuer
	*
	* @return nomRetour<typeRetour> 						Description du retour
	*
	*/
	Board.prototype.set = function(pinOrder, value){
		/* [0] Vérification des paramètres
		=========================================================*/
		/* (1) On vérifie que @pinOrder est un entier et qu'il est branché */
		if( parseInt(pinOrder) != pinOrder || pinOrder > this.maxPin )  return;

		/* (2) On vérifie que la pin de @pinOrder est branchée */
		if( !(this.pins[pinOrder] instanceof Pin) )                     return;

		/* (3) On vérifie que @value est un booléen, si oui : true=>255, false=>0 */
		if( typeof value == 'boolean' )
			value = value ? 255 : 0;

		/* (4) On vérifie que @value est dans 0-255 */
		else if( value != parseInt(value) || value < 0 || value > 255 ) return;

		// On met @value en entier
		value = parseInt(value);


		/* [1] On attribue la valeur
		=========================================================*/
		this.pins[pinOrder].set(value);

		/* [2] On lance le listener
		=========================================================*/
		if( typeof this.listener[pinOrder].update === 'function' )
			this.listener[pinOrder].update();
	};


})();





var Chip;

(function(){

	/* CLASSE 'Chip' Correspond à un périphérique processeur
	*
	* @chip<String> 										Type de communication
	* @pins<Array> 											Numéros des pins de la carte
	*
	* @return Chip<Chip> 									Retourne une instance de 'Chip'
	*
	*/
	Chip = function(type, pins){
		/* [0] Vérification des paramètres
		=========================================================*/
		/* (1) @type de carte */
		if( typeof type != 'string' )                      return;

		type = type.toLowerCase();
		if( ['spi', 'i2c', 'serial'].indexOf(type) == -1 ) return;

		/* (2) @pins un tableau d'entiers */
		if( !(pins instanceof Array) )                     return;

		for( var i = 0 ; i < pins.length ; i++ )
			if( parseInt(pins[i]) != pins[i] ) return;



		/* [1] On récupère les valeurs
		=========================================================*/
		/* (1) On enregistre le type */
		this.type = type;

		/* (2) On enregistre la liste des pins et leurs valeurs */
		this.pins   = pins;
		this.values = [];

		for( i = 0 ; i < this.pins.length ; i++ )
			this.values[i] = new Pin(0);
	};

	Chip.prototype = {
		type:   this.type,  // Type de communication ('spi', 'i2c', ou 'serial')
		pins:   this.pins,  // Liste des numéros des Pin's (ordonnée)
		values: this.values // Liste des valeurs des pins (ordonnée) (objets Pin() )
	};

	/* ATTRIBUE UNE VALEUR A UNE PIN DONNEE
	*
	* @pinOrder<int> 										Indice de la pin (0, 1, 2, ...)
	* @value<int/Boolean> 									Valeur dans 0-255 (ou booléen) à attribuer
	*
	*/
	Chip.prototype.setPin = function(pinOrder, value){
		/* [0] Vérification des paramètres
		=========================================================*/
		/* (1) On vérifie que @pinOrder est un entier et qu'il est un indice de @this.pins */
		if( parseInt(pinOrder) != pinOrder || this.pins.length >= pinOrder ) return;

		/* (2) On vérifie que @value est un booléen, si oui : true=>255, false=>0 */
		if( typeof value == 'boolean' )
			value = value ? 255 : 0;

		/* (3) On vérifie que @value est dans 0-255 */
		else if( value != parseInt(value) || value < 0 || value > 255 ) return;

		// On met @value en entier
		value = parseInt(value);


		/* [1] On attribue la valeur
		=========================================================*/
		this.values[pinOrder].set(value);
	};


	/* ATTRIBUE LES VALEUR DES PIN
	*
	* @values<Array> 									Valeurs
	*
	*/
	Chip.prototype.setPins = function(values){
		for( var i = 0 ; i < this.pins.length ; i++ )
			this.setPin( i, values[i] );
	};


	/* RECUPERE LA VALEUR D'UNE PIN DONNEE
	*
	* @pinOrder<int> 										Indice de la pin à lire
	*
	* @return value<int> 									Valeur entière dans 0-255
	*
	*/
	Chip.prototype.getPin = function(pinOrder){
		/* [0] Vérification des paramètres
		=========================================================*/
		/* (1) On vérifie que @pin est un entier et qu'elle existe */
		if( parseInt(pinOrder) != pinOrder || this.pins.length <= pinOrder ) return false;


		/* [1] On retourne la valeur
		=========================================================*/
		return this.values[pinOrder].get();
	};


	/* RECUPERE LES VALEUR DES PIN
	*
	* @return values<Array> 								Valeurs
	*
	*/
	Chip.prototype.getPins = function(){
		var values = [];

		for( var i = 0 ; i < this.pins.length ; i++ )
			values[i] = this.getPin( i );

		return values;
	};

})();






var LedInterface;

(function(){


	/* CONSTRUCTEUR D'INTERFACE DE LED
	*
	* @chip<Chip> 											Puce associée à la LED
	* @container<Element> 									Conteneur de couleur
	*
	*/
	LedInterface = function(chip, container){
		/* [0] Vérification des paramètres
		=========================================================*/
		if( !(chip instanceof Chip) || !(container instanceof Element) )
			return;

		/* [1] On enregistre les valeurs
		=========================================================*/
		this.chip      = chip;
		this.container = container;
	};


	LedInterface.prototype = {
		chip:      this.chip,     // Puce associée à la LED
		container: this.container // Conteneur de couleur
	};


	/* APPLIQUE LA COULEUR EN FONCTION DES VALEURS DE LA 'CHIP'
	*
	*/
	LedInterface.prototype.update = function(){
		this.container.style.backgroundColor = 'rgb('+this.chip.getPin(0)+','+this.chip.getPin(1)+','+this.chip.getPin(2)+')';
	};



})();





var RelayInterface;

(function(){


	/* CONSTRUCTEUR D'INTERFACE DU RELAI
	*
	* @chip<Chip> 											Puce associée au relai
	* @container<Element> 									Conteneur du relai
	*
	*/
	RelayInterface = function(chip, container){
		/* [0] Vérification des paramètres
		=========================================================*/
		if( !(chip instanceof Chip) || !(container instanceof Element) )
			return;

		/* [1] On enregistre les valeurs
		=========================================================*/
		this.chip      = chip;
		this.container = container;
	};


	RelayInterface.prototype = {
		chip:      this.chip,     // Puce associée au relai
		container: this.container // Conteneur du relai
	};


	/* APPLIQUE L'ACTIVATION EN FONCTION DES VALEURS DE LA 'CHIP'
	*
	*/
	RelayInterface.prototype.update = function(){
		if( this.chip.getPin(0) > 1) this.container.addClass('active');
		else                         this.container.remClass('active');
	};



})();




var previous;
var action;

(function(){


	/* RETOURNE SI UN ETAT EST CORRECT
	*
	* @previous<String> 									Condition d'état
	* @state<Array> 										Liste des états du système
	*
	* @return state<Boolean> 								Retourne si OUI ou NON l'état répond à la condition
	*
	*/
	previous = function(previous, state){
		previous = previous.toLowerCase();

		for( var i = 0 ; i < previous.length ; i++ )
			if( previous[i] == 'x' )           continue;
			else if( previous[i] != state[i] ) return false;

		return true;
	};


	/* MODIFIE LES ETATS EN FONCTION D'UNE ACTION
	*
	* @action<String> 										Action sur les états
	* @state<Array> 										Liste des états du système
	*
	*/
	action = function(action, state){
		action = action.toLowerCase();

		for( var i = 0 ; i < action.length ; i++ )
			if(      action[i] == 'x'  ) continue;
			else                         state[i] = parseInt(action[i]);
	};


})();