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”

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

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.

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.

Voici les codes dont vous avez besoin :

• capteurphysique.zip
• fichiero.zip

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

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.

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.

QUESTION (30mn) :

• 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 observeurs 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.

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
    }
 

QUESTION (30mn) :

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

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 (10mn) :

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

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.

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 CapteurActif  ... 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 (30mn) :

• Définir les capteurs actifs