Commander un Arduino avec une tablette Android

- Etude de cas -

VI. Le serveur d'enregistrement des Arduinos▲

A lire

dans [ref4] : chapitre 6 [Les threads d'exécution], chapitre 7 [Programmation TCP / IP] ;
le code du serveur TCP générique présenté page , paragraphe ;
le code du client TCP générique présenté page , paragraphe .

VI-A. Le projet Eclipse▲

Revenons à l'architecture du serveur :

Le projet Eclipse de la couche [DAO] est le suivant :

en [1] : le projet Eclipse ;
en [2] : les dépendances Maven du projet. On notera les dépendances sur les entités du serveur ;
en [3] : les éléments de la couche [DAO] ;

VI-B. Les dépendances Maven▲

Le fichier [pom.xml] du projet est le suivant :

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>istia.st.domotique.server</groupId>
  <artifactId>server-dao</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>jar</packaging>

  <name>server-dao</name>
  <url>http://maven.apache.org</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>

  <dependencies>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
      <version>3.1.1.RELEASE</version>
      <type>jar</type>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>3.1.1.RELEASE</version>
      <type>jar</type>
    </dependency>
    <dependency>
      <groupId>istia.st.domotique.common</groupId>
      <artifactId>domotique-entities</artifactId>
      <version>1.0-SNAPSHOT</version>
    </dependency>
  </dependencies>
  
  <repositories>
    <repository>
      <id>codehaus</id>
      <url>http://repository.codehaus.org/org/codehaus</url>
    </repository>
  </repositories>  
</project>

lignes 5-8 : l'identité Maven du projet ;
lignes 30-34 : la dépendance sur le projet Maven des entités ;
lignes 18-29 : deux dépendances sur le framework Spring. Celui-ci est utilisé pour configurer et instancier la couche [DAO] ;

VI-C. L'interface de la couche [DAO]▲

L'interface [IDao] de la couche [DAO] sera la suivante :

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.

package arduino.dao;

...

public interface IDao {
  // liste des Arduinos
  public Collection<Arduino> getArduinos();
  // ajout d'un arduino
  public void addArduino(Arduino arduino);
  // suppression d'un arduino
  public void removeArduino(String idArduino);
  // envoyer une suite de commandes à un Arduino
  public List<Reponse> sendCommandes(String idArduino, List<Commande> commandes);
  // envoyer une suite de commandes Json à un Arduino
  public List<String> sendCommandesJson(String idArduino, List<String> commandes);
}

ligne 13 : la couche [DAO] peut envoyer une liste de commandes de type [Commande] à un Arduino identifié par son id. Elle reçoit une liste de réponses de type [Reponse] ;
ligne 15 : la couche [DAO] peut envoyer une liste de commandes au format texte JSON à un Arduino identifié par son id. Elle reçoit une liste de réponses texte au format JSON ;
ligne 7 : la couche [DAO] gère la liste des Arduinos qui se sont connectés. Cette méthode en donne la liste ;
ligne 9 : pour ajouter un Arduino à la liste ;
ligne 11 : pour enlever un Arduino de la liste ;

VI-D. de la couche [DAO]▲

Dans le dossier [support] du TP, vous trouverez un projet Eclipse qui va vous permettre de tester les différents éléments du serveur :

en [1] : le projet console de tests ;
en [2] : la classe [Main1] permet de tester la couche [DAO] ;

La classe [Main1] est la suivante :

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.

package arduino.dao.console;

...

import arduino.dao.IDao;

public class Main1 {

    public static void main(String[] args) throws InterruptedException {

        // création de la couche [dao]
        IDao dao = (IDao) new ClassPathXmlApplicationContext("applicationContext.xml").getBean("dao");

        // allumer la led
        List<Commande> allumer = new ArrayList<Commande>();
        // allumage pin 13
        Map<String, Object> paramètres = new HashMap<String, Object>();
        paramètres.put("pin", "8");
        paramètres.put("val", "1");
        paramètres.put("mod", "b");
        allumer.add(new Commande("0", "pw", paramètres));

        // éteindre la led
        List<Commande> eteindre = new ArrayList<Commande>();
        // extinction pin 13
        paramètres = new HashMap<String, Object>();
        paramètres.put("pin", "8");
        paramètres.put("val", "0");
        paramètres.put("mod", "b");
        eteindre.add(new Commande("1", "pw", paramètres));

        // état d'une pin
        List<Commande> getPin = new ArrayList<Commande>();
        // état pin 7
        paramètres = new HashMap<String, Object>();
        paramètres.put("pin", "0");
        paramètres.put("mod", "a");
        getPin.add(new Commande("2", "pr", paramètres));

        // boucle infinie de dialogue avec les arduinos connectés
        boolean éteinte = true;
        List<Commande> commandes;
        while (true) {
            // attente
            System.out.println("Main : attente...");
            Thread.sleep(1000);
            // allumage / extinction
            if (éteinte) {
                commandes = allumer;
            } else {
                commandes = eteindre;
            }
            // on bascule
            éteinte = !éteinte;

            // on envoie les commandes aux arduinos enregistrés
            for (Arduino arduino : dao.getArduinos()) {
                // action sur la pin
                sendCommandes(dao, arduino.getId(), commandes);
                // état de la pin
                sendCommandes(dao, arduino.getId(), getPin);
            }
        }
    }

    private static void sendCommandes(IDao dao, String idarduino, List<Commande> commandes) {
        try {
            // envoie les commandes à l'Arduino
            dao.sendCommandes(idarduino, commandes);
        } catch (Exception e) {
        }
    }
}

Nous vous laissons comprendre ce code. Il fait clignoter la led n° 8 de tous les Arduinos connectés. Pour cela, il envoie à intervalles réguliers la commande PinWrite en écrivant alternativement 0 et 1 sur la pin n° 8.

VI-E. La configuration de Spring▲

Le programme de test précédent instancie la couche [DAO] à l'aide de Spring :

Sélectionnez

1.
2.

// création de la couche [dao]
        IDao dao = (IDao) new ClassPathXmlApplicationContext("applicationContext.xml").getBean("dao");

La configuration de Spring dans [applicationContext.xml] est la suivante :

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">

  <!-- thread d'enregistrement des arduinos -->
  <bean id="recorder" class="arduino.dao.Recorder" init-method="init">
    <property name="port" value="100"/>
    <property name="ip" value="192.168.2.1"/>
    <property name="nbConnexions" value="5"/>
    <property name="traced" value="true"/>              
  </bean>
  <!-- couche dao -->  
  <bean id="dao" class="arduino.dao.Dao" init-method="init">
    <property name="recorder" ref="recorder"/>
    <property name="timeoutConnection" value="1000"/>
    <property name="timeoutRead" value="1000"/> 
    <property name="traced" value="false"/>                           
  </bean>
</beans>

La couche [DAO] est configurée par les lignes 14-19 :

ligne 14 : après instanciation de la classe [arduino.dao.Dao], Spring va exécuter la méthode init de cette classe. C'est dans cette méthode que nous créerons et lancerons le serveur d'enregistrement des Arduinos ;
ligne 15 : la couche [DAO] aura une référence sur le serveur d'enregistrement appelé ici recorder. Il est défini lignes 7-12 ;
ligne 16 : le délai d'attente maximal qu'attendra la couche [DAO] lorsqu'elle se connecte à un Arduino. Au-delà, elle lancera une exception [DomotiqueException] ;
ligne 17 : le délai d'attente maximal qu'attendra la couche [DAO] lorsqu'elle atend une réponse d'un Arduino. Au-delà, elle lancera une exception [DomotiqueException] ;
ligne 18 : un booléen qui indique si la couche [DAO] logue ou pas sur la console ce qu'elle fait ;

Le serveur d'enregistrement est configuré par les lignes 7-12 :

le port d'écoute ;
l'IP du serveur d'écoute. Une machine peut avoir plusieurs adresses IP si elle a plusieurs cartes réseau. Il est alors nécessaire de dire si le serveur écoute sur toutes les adresses IP ou seulement sur certaines comme c'est le cas ici ;
ligne 10 : les demandes à un serveur sont mises en file d'attente si le serveur est occupé lorsque la demande arrive. Ici, on fixe à 5 la taille maximale de cette file. Si une sixième demande arrive alors elle reçoit une exception de la part du serveur ;
ligne 11 : on peut demander au serveur d'enregistrement d'écrire ou non des logs sur la console ;

VI-F. L'interface [IThreadDao] du serveur d'enregistrement▲

Le serveur d'enregistrement implémente l'interface [IThreadDao] suivante :

Sélectionnez

1.
2.
3.
4.
5.
6.
7.

package arduino.dao;

// thread lancé par la couche [dao]
public interface IThreadDao extends Runnable {
  // le thread doit connaître la couche [dao]
  public void setDao(IDao dao);
}

VI-G. Le serveur d'enregistrement [Recorder]▲

Le squelette du serveur d'enregistrement est le suivant :

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.

package arduino.dao;

// paquetages
...

public class Recorder implements IThreadDao {

  // injections Spring
  private int nbConnexions;
  private int port;
  private String ip;
  private IDao dao;
  private Boolean traced;
  
  // données locales
  private InetAddress inetAddress;

  @SuppressWarnings("unused")
    private void init() {
    try {
      // on initialise l'Ip du serveur
      inetAddress = InetAddress.getByName(ip);
    } catch (UnknownHostException e) {
      throw new DomotiqueException("Erreur à l'initialisation de l'IP du serveur", e, 4);
    }
  }

  // ------------------ méthode run
  @SuppressWarnings("resource")
    public void run() {
...
  }

  // logs
  private void trace(Level level, String message, Exception e) {
    String msg = String.format("Recorder : [%s] : [%s]", new SimpleDateFormat("HH:mm:ss:SS").format(new Date()), message);
    if (e == null) {
      Logger.getLogger(Recorder.class.getName()).log(level, msg);
    } else {
      Logger.getLogger(Recorder.class.getName()).log(level, msg, e);
    }
  }

  // getters et setters
  ...
}

lignes 9-13 : proviennent du fichier de configuration de Spring ;

Question : complétez le code du serveur d'enregistrement. Pour cela, aidez-vous du code du serveur générique en éliminant de celui-ci tout ce qui est inutile pour le serveur d'enregistrement. Pour assurer son service, le serveur [Recorder] lance un thread [Recording].

Conseils :

lorsque le serveur reçoit une connexion d'un Arduino, il peut servir cette connexion lui-même ou lancer un autre thread pour le faire. La première solution est suffisante ici. La deuxième est à préférer dans le cas où le serveur a beaucoup de clients ;
lorsque le serveur a lu la ligne envoyée par l'Arduino, il doit en faire un objet [Arduino] et appeler la méthode [addArduino] de la couche [DAO] pour que celle-ci enregistre le nouvel Arduino. La construction de l'objet [Arduino] est réalisée grâce à une bibliothèque JSON ;

VI-H. Tests du serveur d'enregistrement▲

Dans le projet de tests [server-console], on exécutera le programme [Main0] suivant :

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.

package arduino.dao.console;

...
import arduino.dao.IDao;
import arduino.dao.IThreadDao;

@SuppressWarnings("deprecation")
public class Main0 implements IDao {

    public static void main(String[] args) throws InterruptedException {
        // on instancie la classe [Main0]
        new Main0();
    }

   // constructeur
    public Main0() {
        // on instancie le serveur d'enregistrement
        IThreadDao recorder = (IThreadDao) new XmlBeanFactory(new ClassPathResource("applicationContext.xml"))
                .getBean("recorder");
        // on lui injecte une couche [DAO] fictive
        recorder.setDao(this);
        // on le lance
        new Thread(recorder).start();
    }

    public Collection<Arduino> getArduinos() {
        return null;
    }

    public void addArduino(Arduino arduino) {
        // suivi
        System.out.println(String.format("L'Arduino [%s] a été ajouté", arduino));
    }

    public void removeArduino(String idArduino) {
    }

    public List<Reponse> sendCommandes(String idArduino, List<Commande> commandes) {
        return null;
    }

    public List<String> sendCommandesJson(String idArduino, List<String> commandes) {
        return null;
    }
}

ligne 8 : la classe [Main0] implémente l'interface [IDao] de la couche [DAO]. Une seule méthode de l'interface sera implémentée, celles des lignes 30-33 ;
ligne 16 : le constructeur ;
ligne 18 : on instancie le serveur d'enregistrement défini comme suit dans le fichier [applicationContext.xml] :

Sélectionnez

1.
2.
3.
4.
5.
6.
7.

  <!-- thread d'enregistrement des arduinos -->
  <bean id="recorder" class="arduino.dao.Recorder" init-method="init">
    <property name="port" value="100"/>
    <property name="ip" value="192.168.2.1"/>
    <property name="nbConnexions" value="5"/>
    <property name="traced" value="true"/>              
</bean>

Adaptez ce fichier à vos besoins.

le serveur d'enregistrement doit remonter à la couche [DAO], l'Arduino qui s'enregistre. C'est en effet la couche [DAO] qui gère la liste des arduinos connectés. Pour cela, le serveur d'enregistrement doit avoir une référence sur la couche [DAO]. C'est fait en ligne 21 ;
ligne 23 : le thread du serveur est lancé. A partir de ce moment, il va vivre tout seul, en parallèle des activités de la couche [DAO]. Ici, la classe [Main0] et le serveur d'enregistrement s'exécutent dans des threads différents ;
lorsqu'un Arduino se connecte, le serveur appelle la méthode de la ligne 30 pour l'enregistrer. On se contente de loguer l'enregistrement sur la console.

Lorsqu'on exécute la classe [Main0], on doit vérifier que l'Arduino arrive à se connecter. Cela peut se voir dans les logs du serveur si vous les avez prévus :

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.

Serveur d'enregistrement lancé sur 192.168.2.1:100
mars 30, 2013 9:22:29 AM arduino.dao.Recorder trace
Infos: Recorder : [09:22:29:265] : [Serveur d'enregistrement : attente d'un client]
mars 30, 2013 9:22:34 AM arduino.dao.Recorder trace
Infos: Recorder : [09:22:34:728] : [Serveur d'enregistrement : client détecté]
mars 30, 2013 9:22:34 AM arduino.dao.Recorder trace
Infos: Recorder : [09:22:34:733] : [Serveur d'enregistrement : attente d'un client]
mars 30, 2013 9:22:34 AM arduino.dao.Recording trace
Infos: Recording : [09:22:34:734] : [Service d'enregistrement d'un arduino lancé]
L'Arduino [id=[192.168.2.3], description=[duemilanove], mac=[90:A2:DA:00:1D:A7], ip=[192.168.2.3], port=[102]] a été ajouté
mars 30, 2013 9:22:34 AM arduino.dao.Recording trace
Infos: Recording : [09:22:34:850] : [Service d'enregistrement d'un arduino terminé]

lignes 1 et 10 : logs de [Main0] ;
les autres lignes sont des logs du serveur d'enregistrement.

Les logs de la console de l'Arduino montrent également cette connexion :

Sélectionnez

1.
2.
3.
4.
5.
6.

Connexion au serveur d'enregistrement...
Connecte...
enregistrement : {"id":"192.168.2.3","desc":"duemilanove","mac":"90:A2:DA:00:1D:A7","port":102}
Enregistrement termine...
Demarrage du serveur sur l'adresse IP 192.168.2.3 et le port 102
Memoire disponible avant service : 832

Vous avez aimé ce tutoriel ? Alors partagez-le en cliquant sur les boutons suivants :

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2013 Serge Tahé. Aucune reproduction, même partielle, ne peut être faite de ce site ni de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.