392 lines
9.3 KiB
JavaScript
392 lines
9.3 KiB
JavaScript
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]);
|
|
};
|
|
|
|
|
|
})();
|