User Tools

Site Tools


2014_2015:s3:concprogobjet:td:td6

This is an old revision of the document!


Digital Home : Observer/observable et intégration

Objectifs de ce TD :

  1. Appréhender une petite application dans sa totalité
  2. Travailler sur l'intégration
  3. Savoir utiliser un patron “observer”
digital home - Computer Definition. A residence that is fully automated. It uses computing devices and home appliances that conform to some common standard for internetworking so that everything can be controlled by computer.

Les temps indiqués sont là pour vous aider. Il s'agit des temps maximum.

Cadre général

Nous simplifions la définition précédente comme suit.

Une “maison numérique” est équipée de “dispositifs” : capteurs (composants qui permettent de relever des mesures) et actionneurs (composant permettant d'agir sur d'autres composants en vue de modifier leur comportement ou leur état).

Les “dispositifs” sont soit associés à la maison (par exemple, un thermostat central), soit associés aux pièces (interrupteurs, thermomètre, …).

Un tableau de contrôle permet de visualiser les valeurs relevées par les capteurs de la maison.

Notre objectif est de permettre de :

  1. créer des maisons numériques auxquelles on peut ajouter des dispositifs
  2. visualiser les valeurs des différents dispositifs contenus dans la maison.

QUESTION (15 mn):

  • Analyser le problème sur papier (préparation à l'examen).
    • Vous devez maintenant savoir seuls ce dont vous avez besoin pour analyser un problème.
    • Vous devez vérifier que vous savez faire les diagrammes sans outil.

Les capteurs physiques sont des dispositifs qui présentent une grande variabilité. Nous allons les modéliser via des composants logiciels. Déterminer les dépendances envisagées entre vos classes et les tests d'intégration à prévoir si l'on considère que les dispositifs devront être intégrés au reste de l'application.

QUESTION (15 mn):

  • Lire l'ensemble de l'énoncé à présent et compléter ou corriger votre modélisation.

Capteurs Passifs

Les capteurs “passifs” sont des capteurs qu'il faut interroger pour obtenir la valeur correspondant par exemple à une température ou un éclairage. A un capteur passif nous associons un capteur physique qui vous est donné. Il s'agit d'un composant très simple qui lit et écrit une valeur dans un fichier. Il vous sert de “bouchon” puisque nous ne disposons pas d'un vrai capteur physique auquel nous connecter.

QUESTION (15 mn):

  1. Mettez à jour votre diagramme de classe si besoin.
  2. Définir la classe CapteurPassif en lui associant un capteurPhysique.

Pièce équipée

Une pièce est équipée de capteurs. On peut ajouter des capteurs à la pièce. On peut visualiser les valeurs de tous les capteurs de la pièce.

QUESTION (20 mn):

  1. Compléter ou corriger si besoin votre diagramme de classe sur cette partie afin d'obtenir un diagramme de classes en conception : toutes vos relations sont bien définies avec les multiplicités et les rôles ; les principales méthodes de vos classes sont bien représentées.
  2. Définir la classe Pièce
  3. Créer un jeu de tests vous permettant de tester votre classe Pièce.

Exemple de trace :

Salon
	thermometre:19.0	humidite:12.7	lumiere:120.0

Maison numérique

Une maison numérique est une composition de pièces équipées.

A une maison numérique est associé un tableau de contrôle. Il permet de visualiser tous les capteurs présents dans toutes les pièces de la maison.

QUESTION (20 mn):

  • Implémenter et tester la classe MaisonNumerique et tout ce qui est nécessaire pour répondre aux exigences.

Capteur Passif Réactif (Simple)

Un capteur Passif réactif est un capteur passif mais qui peut être observé. Lorsque sa valeur est modifiée par un setValeur, il notifie les observeurs du changement de valeur.

Nous n'utiliserons pas les classes prédéfinies en java comme Observer et Observable pour bien comprendre l'intérêt de ce pattern et l'adapter à notre cas d'étude.

QUESTION :

  • Définir la classe CapteurPassifReactif comme une extension de la classe CapteurPassif.
  • Vous rendez ses instances observables en respectant le pattern ci-après :
    • Un observeur d'un CapteurPassifReactif doit pouvoir recevoir des messages update(String message) : Nous aurons des “ObserveurDeCapteur”
    • On peut enregistrer des ObserveurDeCapteur dans un CapteurPassifReactif et en enlever
    • A chaque appel au setValeur d'un CapteurPassifReactif tous les oberveurs sont notifiés par un “update” et la nouvelle valeur du capteur en paramètre

Nous n'avons pas encore défini d'observeur d'un capteur. Cependant nous voulons vérifier que les notifications sont bien prévues.

Test d'intégration et Capteur Passif Réactif

Ces tests sont basés sur http://easymock.org/

Il s'agit de vérifier que lorsque que la valeur du capteur réactif est modifiée, la méthode update des observeurs est bien appelée.

Pour cela voici un extrait de code qui doit vous aider.

voici l'archive dont vous avez besoin

import java.io.IOException;
 
import org.easymock.EasyMockRunner;
import org.easymock.EasyMockSupport;
import org.easymock.Mock;
 
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.After;
import org.junit.Before;
 
@RunWith(EasyMockRunner.class)
public class CapteurPassifReactifTest extends EasyMockSupport {
	CapteurPassifReactif cpTemporaire ;
 
    @Mock
    private ObserverDeCapteur observeur; 
    @Mock
    private ObserverDeCapteur observeur2; 
 
    @Before
    public void setUp() throws Exception {
       cpTemporaire = new CapteurPassifReactif(new CapteurPhysique("cp1"));		
	}
 
     @After
     public void tearDown() throws Exception {
		cpTemporaire.unregister(observeur);
	}
 
    //tests integration
    @Test
    public void testCapteurSetValeur() throws IOException, NonAccessibleCapteurException {
	observeur.update("12.2"); //Appel attendu
	replayAll(); //Memoriser
	cpTemporaire.register(observeur);
	cpTemporaire.setValeur(12.2);
        verifyAll(); //Verification
    }
 
 
    //tests integration
    @Test
     public void testCapteurSetValeurMultipleObserveurs() throws IOException, NonAccessibleCapteurException {
	observeur2.update("12.2");//
	observeur.update("12.2"); //Appel attendu
	replayAll(); //Memoriser
	cpTemporaire.register(observeur);
	cpTemporaire.register(observeur2);
	cpTemporaire.setValeur(12.2);
        verifyAll(); //Verification
    }
 

Vous pouvez faire le choix de continuer à tester avec EasyMock ou de faire les tests en créant les bouchons etc.

Pièce numérique "intelligente"

L'objectif est à présent de définir des pièces intelligentes comme contenant des capteurs passifs et des capteurs passifs réactifs. Lorsque l'un de ces derniers capteurs a sa valeur modifiée, la pièce est notifiée du changement et le update consiste à ré-afficher les valeurs de tous les capteurs.

Question : Vous devez définir une “SmartPiece” sans modifier une Piece.

Maison numérique évolutive

Lorsque l'on ajoute un capteur à une pièce de la maison on veut que le tableau de bord de la maison prenne automatiquement en compte cette évolution.

Question : Modifier vos classes pour prendre en compte cette nouvelle exigence, si vous ne l'aviez pas déjà fait. Si vous le voulez, vous êtes autorisé à cette étape à utiliser les classes java java.util.Observable et java.util.Observer.

Capteurs Réactifs

Un capteur actif est associé à un capteur physique. Il scrute régulièrement la valeur physique du capteur physique qui lui est associé et notifie ses observeurs chaque fois qu'il détecte un changement.

Voici les éléments de code dont vous avez besoin pour le définir :

  • Ce code vous permet de le déclarer comme pouvant s'exécuter “dans une thread à part” :
    public class CapteurReactif  ... implements... Runnable{
  • Ce code est une méthode de votre CapteurActif qui explicite la boucle qui va lire le composant physique:
     public void run() {
    		System.out.println("Run lancé");
    		while (!stop) {
    			try {
    				Thread.sleep(2000);
    				if (!(valeurCourante.equals(getValeur())))  {
    					setValeurCourante(getValeur());
    				}
    			} catch (InterruptedException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    		}
    	}
  • Le code suivant vous permet de “lancer” votre capteur :
CapteurActif cpTemporaire = new CapteurActif(new CapteurPhysique("cp1"));	
Thread threadCP= new Thread(cpTemporaire);
threadCP.start();

QUESTION (15mn) :

  • Définir les capteurs réactifs

2014_2015/s3/concprogobjet/td/td6.1414959302.txt.gz · Last modified: 2014/11/02 21:15 by blay