Commander un Arduino avec une tablette Android

- Etude de cas -

IV. Programmation des Arduinos▲

Nous nous intéressons ici à l'écriture du code C des Arduinos :

A lire

dans [ref2] : l'utilisation de bibliothèques JSON (Annexes, paragraphes 11.1 et 11.2) ;
dans l'IDE de l'Arduino, tester l'exemple d'un serveur TCP (le serveur web par exemple) et celui d'un client TCP (le client Telnet par exemple) ;
les annexes sur l'environnement de programmation des Arduinos au paragraphe , page .

IV-A. Les spécifications de la couche [Arduino]▲

Un Arduino est un ensemble de pins reliées à du matériel. Ces pins sont des entrées ou des sorties. Leur valeur est binaire ou analogique. Pour commander l'Arduino, il y aura deux opérations de base :

écrire une valeur binaire / analogique sur une pin désignée par son numéro ;
lire une valeur binaire / analogique sur une pin désignée par son numéro ;

A ces deux opérations de base, nous en ajouterons une troisième :

faire clignoter une led pendant une certaine durée et avec une certaine fréquence. Cette opération peut être réalisée en appelant de façon répétée les deux opérations de base précédentes. Mais nous verrons aux tests que les échanges de la couche [DAO] avec un Arduino sont de l'ordre de la seconde. Il n'est alors pas possible de faire clignoter une led toutes les 100 millisecondes. Aussi implanterons-nous sur l'Arduino lui-même cette fonction de clignotement.

Le fonctionnement de l'Arduino sera le suivant :

les communications entre la couche [DAO] et un Arduino se font via un réseau TCP-IP par échanges de lignes de texte au format JSON (JavaScript Object Notation) ;
au démarrage, l'Arduino vient se connecter au port 100 d'un serveur d'enregistrement présent dans la couche [DAO]. Il envoie au serveur une unique ligne de texte :

Sélectionnez

{"id":"192.168.2.3","desc":"duemilanove","mac":"90:A2:DA:00:1D:A7","port":102}

C'est une chaîne JSON caractérisant l'Arduino qui se connecte :

id : un identifiant de l'Arduino, ici son adresse IP ;
desc : une description de ce que sait faire l'Arduino. Ici on a simplement mis le type de l'Arduino ;
mac : adresse Mac de l'Arduino ;
port : le numéro du port sur lequel l'Arduino va attendre les commandes de la couche [DAO].

Toutes ces informations sont de type chaînes de caractères sauf le port qui est un nombre entier.

une fois que l'Arduino s'est inscrit auprès du serveur d'enregistrement, il se met à l'écoute sur le port qu'il a indiqué au serveur. Il attend des commandes JSON de la forme suivante :

Sélectionnez

{"id":"identifiant","ac":"une_action","pa":{"param1":"valeur1","param2":"valeur2",...}}

C'est une chaîne JSON avec les éléments suivants :

id : un identifiant de la commande. Peut être quelconque ;
ac : une action. Il y en a trois :
pw (pin write) pour écrire une valeur sur une pin,
pr (pin read) pour lire la valeur d'une pin,
cl (clignoter) pour faire clignoter une led ;
pa : les paramètres de l'action. Ils dépendent de l'action.
l'Arduino renvoie systématiquement une réponse à son client. Celle-ci est une chaîne JSON de la forme suivante :

Sélectionnez

{"id":"1","er":"0","et":{"pinx":"valx"}}

où

id : l'identifiant de la commande à laquelle on répond ;
er (erreur) : un code d'erreur s'il y a eu une erreur, 0 sinon ;
et (état) : un dictionnaire toujours vide sauf pour la commande de lecture pr. Le dictionnaire contient alors la valeur de la pin n° x demandée.

Voici des exemples destinés à clarifier les scpécifications précédentes :

Faire clignoter la led n° 8 10 fois avec une période de 100 millisecondes :

Commande	{"id":"1","ac":"cl","pa":{"pin":"8","dur":"100","nb":"10"}}
Réponse	{"id":"1","er":"0","et":{}}

Les paramètres pa de la commande cl sont : la durée dur en millisecondes d'un clignotement, le nombre nb de clignotements, le n° pin de la pin de la led.

Ecrire la valeur binaire 1 sur la pin n° 7 :

Commande	{"id":"2","ac":"pw","pa":{"pin":"7","mod":"b","val":"1"}}
Réponse	{"id":"2","er":"0","et":{}}

Les paramètres pa de la commande pw sont : le mode mod b (binaire) ou a (analogique) de l'écriture, la valeur val à écrire, le n° pin de la pin. Pour une écriture binaire, val est 0 ou 1. Pour une écriture analogique, val est dans l'intervalle [0,255].

Ecrire la valeur analogique 120 sur la pin n° 2 :

Commande	{"id":"3","ac":"pw","pa":{"pin":"2","mod":"a","val":"120"}}
Réponse	{"id":"3","er":"0","et":{}}

Lire la valeur analogique de la pin 0 :

Commande	{"id":"4","ac":"pr","pa":{"pin":"0","mod":"a"}}
Réponse	{"id":"4","er":"0","et":{"pin0":"1023"}}

Les paramètres pa de la commande pr sont : le mode mod b (binaire) ou a (analogique) de la lecture, le n° pin de la pin. S'il n'y a pas d'erreur, l'Arduino met dans le dictionnaire "et" de sa réponse, la valeur de la pin demandée. Ici pin0 indique que c'est la valeur de la pin n° 0 qui a été demandée et 1023 est cette valeur. En lecture, une valeur analogique sera dans l'intervalle [0, 1024].

Nous avons présenté les trois commandes cl, pw et pr. On peut se demander pourquoi on n'a pas utilisé des champs plus explicites dans les chaînes JSON, action au lieu de ac, pinwrite au lieu de pw, parametres au lieu de pa, ... On va découvrir qu'un Arduino a une mémoire très réduite. Or les chaînes JSON échangées avec l'Arduino participent à l'occupation mémoire. On a donc choisi de raccourcir celles-ci au maximum.

Voyons maintenant quelques cas d'erreur :

Commande	xx
Réponse	{"id":"","er":"100","et":{}}

On a envoyé une commande qui n'est pas au format JSON. L'Arduino a renvoyé le code d'erreur 100.

Commande	{"id":"4","ac":"pr","pa":{"mod":"a"}}
Réponse	{"id":"4","er":"302","et":{}}

On a envoyé une commande pr en oubliant le paramètre pin. L'Arduino a renvoyé le code d'erreur 302.

Commande	{"id":"4","ac":"pinread","pa":{"pin":"0","mod":"a"}}
Réponse	{"id":"4","er":"104","et":{}}

On a envoyé une commande pinread inconnue (c'est pr). L'Arduino a renvoyé le code d'erreur 104.

On ne continuera pas les exemples. La règle est simple. L'Arduino ne doit pas planter, quelque soit la commande qu'on lui envoie. Avant d'exécuter une commande JSON, il doit s'assurer que celle-ci est correcte. Dès qu'une erreur apparaît, l'Arduino arrête l'exécution de la commande et renvoie à son client la chaîne JSON d'erreur. Là encore, parce qu'on est contraint en espace mémoire, on renverra un code d'erreur plutôt qu'un message complet.

IV-B. Enregistrement de l'Arduino▲

A lire

dans [ref2] : l'utilisation de bibliothèques JSON (Annexes, paragraphes 11.1 et 11.2) ;
dans l'IDE de l'Arduino, tester l'exemple d'un serveur TCP (le serveur web par exemple) et celui d'un client TCP (le client Telnet par exemple) ;
les annexes sur l'environnement de programmation des Arduinos au paragraphe , page .

IV-B-1. Le code▲

Au démarrage, l'Arduino doit s'enregistrer auprès d'un serveur de la couche [DAO] sur le port 102 en lui envoyant une chaîne JSON de la forme :

Sélectionnez

{"id":"192.168.2.3","desc":"duemilanove","mac":"90:A2:DA:00:1D:A7","port":102}

Le code de démarrage de l'Arduino pourrait être le suivant :

Sélectionnez

#include <SPI.h>
#include <Ethernet.h>
#include <String.h>
#include <aJSON.h>

// ---------------------------------- CONFIGURATION DE L'ARDUINO DUEMILANOVE
// adresse MAC de l'Arduino DUEMILANOVE
byte macArduino[] = { 
  0x90, 0xA2, 0xDA, 0x00, 0x1D, 0xA7 };
String strMacArduino="90:A2:DA:00:1D:A7";
// l'adresse IP de l'Arduino
IPAddress ipArduino(192,168,2,3);
// son identifiant=IP
String idArduino="192.168.2.3";
// description de l'Arduino
String descriptionArduino="duemilanove";
// port du serveur Arduino
int portArduino=102;
// le serveur Arduino travaillera sur le port 102
EthernetServer server(portArduino);
// IP du serveur d'enregistrement
IPAddress ipServeurEnregistrement(192,168,2,1); 
// port du serveur d'enregistrement
int portServeurEnregistrement=100;
// le client Arduino du serveur d'enregistrement
EthernetClient clientArduino;

// initialisation
void setup() {
  // Le moniteur série permettra de suivre les échanges
  Serial.begin(9600);
  // démarrage de la connection Ethernet
  Ethernet.begin(macArduino,ipArduino);  
  // mémoire disponible
  Serial.print(F("Memoire disponible : "));
  Serial.println(freeRam());
}

// boucle infinie
void loop()
{
  boolean enregistrementFait=false;
  // tant que l'arduino ne s'est pas enregistré auprès du serveur, on ne peut rien faire
  while(! enregistrementFait){
    // on se connecte au serveur d'enregistrement
    Serial.println(F("Connexion au serveur d'enregistrement..."));
    if (connecte(&clientArduino,ipServeurEnregistrement,portServeurEnregistrement)) {
      // suivi
      Serial.println(F("Connecte..."));
      // on envoie l'adresse Mac de l'Arduino, une description de ses fonctionnalités, son port de service
      String msg="{\"id\":\""+idArduino+"\",\"desc\":\""+descriptionArduino+"\",\"mac\":\""+strMacArduino+"\",\"port\":"+portArduino+"}";
      clientArduino.println(msg);
      Serial.print(F("enregistrement : "));
      Serial.println(msg);
      // enregistrement fait
      enregistrementFait=true;
      // on ferme la connexion
      delay(1);
      clientArduino.stop();
      // suivi
      Serial.println(F("Enregistrement termine..."));
    } 
    else {
      // suivi
      Serial.println(F("Echec de la connexion..."));
    }
  }
  // suivi
  Serial.print(F("Demarrage du serveur sur l'adresse IP "));
  Serial.print(Ethernet.localIP());
  Serial.print(F(" et le port "));
  Serial.println(portArduino);

  // on lance le serveur
  server.begin();
  // mémoire disponible
  Serial.print(F("Memoire disponible avant service : "));
  Serial.println(freeRam());  
  // on attend indéfiniment les clients
  // on les traite un par un
  while(true){
   // placer ici votre code
   // .................
  }
}

// connexion au serveur
int connecte(EthernetClient *client, IPAddress serveurIP, int serveurPort) {
  // on se connecte au serveur après 1 seconde d'attente
  delay(1000);
  return client->connect(serveurIP, serveurPort);
}

// mémoire libre
int freeRam ()
{
  extern int __heap_start, *__brkval;
  int v;
  return (int) &v - (__brkval == 0 ? (int) &__heap_start : (int) __brkval);
}

lignes 1-4 : les fichiers headers des fonctions utilisées dans le code ;
ligne 1 : pour les fonction de base de l'Arduino ;
ligne 2 : pour les fonction réseau ;
ligne 3 : pour le type String des chaînes de caractères ;
ligne 4 : pour la bibliothèque JSON d'écriture / lecture des chaînes JSON ;
lignes 8-9 : adresse Mac de l'Arduino. Mettez votre propre adresse Mac ;
ligne 10 : idem sous forme de chaîne de caractères ;
ligne 12 : adresse IP de l'Arduino. Mettez votre propre adresse IP ;
ligne 14 : idem sous forme de chaîne de caractères ;
ligne 16 : description de l'Arduino ;
ligne 18 : le port du serveur de l'Arduino ;
ligne 20 : le serveur de l'Arduino ;
ligne 22 : l'adresse IP du serveur d'enregistrement. C'est l'adresse IP locale du PC auquel vous avez relié l'Arduino, normalement 192.168.2.1 ;
ligne 24 : port du service d'enregistrement des Arduinos ;
ligne 26 : le client Arduino du service d'enregistrement ;
ligne 29 : la fonction [setup] d'initialisation de l'Arduino ;
ligne 33 : la carte réseau de l'Arduino est initialisée ;
lignes 35-36 : on logue la mémoire disponible au démarrage de l'application ;
ligne 35 : on notera la notation F(chaîne). Cela met la chaîne de caractères dans la mémoire Flash de l'Arduino. Ainsi celle-ci n'est pas placée dans la même mémoire que les autres variables du programme. Cela contribue à libérer de la mémoire pour ces dernières ;
lignes 95-100 : la fonction freeRam rend le nombre d'octets disponibles dans la mémoire. Cette fonction a été trouvée sur internet. Au départ, on a environ 1100 octets disponibles sur un Arduino de type " uno " ou " duemilanove ". En-deça de 600 octets le programme " plante ". Il faudra appeler régulièrement cette fonction dans votre code pour voir comment évolue la mémoire ;
ligne 40 : la boucle infinie exécutée par l'Arduino ;
lignes 44-67 : ce code est exécuté tant que l'Arduino n'a pas réussi à s'enregistrer auprès du serveur d'enregistrement de la couche [DAO] ;
ligne 47 : on essaie de se connecter. Les paramètres sont les suivants :
l'adresse du client Arduino de la ligne 26,
l'adresse IP du serveur d'enregistrement,
le port du service d'enregistrement ;
ligne 91 : notez la façon dont on se connecte à un serveur ;
ligne 48 : lorsqu'on est là, c'est qu'on a réussi à se connecter au serveur d'enregistrement. On rappelle que l'Arduino doit alors envoyer une ligne JSON du genre :

Sélectionnez

{"id":"192.168.2.3","desc":"duemilanove","mac":"90:A2:DA:00:1D:A7","port":102}

ligne 51 : cette ligne est préparée ;
ligne 52 : elle est envoyée au serveur d'enregistrement ;
ligne 59 : on ferme la connexion avec le serveur d'enregistrement ;
ligne 68 : l'enregistrement est terminé. Maintenant l'Arduino va exécuter les commandes que va lui envoyer la couche [DAO]. Pour cela, on crée un serveur ;
ligne 75 : un serveur est lancé sur le port 102 de l'Arduino ;
lignes 81-84 : dans une boucle infinie, vous allez traiter les commandes envoyées au serveur.

IV-B-2. Les ▲

Nous allons tester cette première mouture du code de l'Arduino. On va vérifier qu'il s'enregistre bien auprès du serveur d'enregistrement qui opère sur le port 100 de la machine hôte.

Tout d'abord, vérifiez votre réseau local. Il doit être le suivant :

Ensuite, chargez dans l'IDE Arduino, le programme [arduino_1.ino] que vous trouverez dans le dossier [support] du TP :

Téléversez-le sur l'Arduino, puis faites afficher la console de logs (Ctrl-M) :

Toutes les secondes, l'Arduino essaie de se connecter au serveur d'enregistrement qui n'existe pas encore. Nous allons en créer un.

Sous Eclipse, importez le projet Maven [Serveur Tcp générique] du dossier [support] :

Ce projet Maven crée un serveur générique sur un port de la machine hôte qu'on lui passe en paramètre. Ce serveur affiche sur la console toutes les commandes qu'il reçoit. Nous allons le lancer sur le port 100 de la machine hôte, là où doit opérer le serveur d'enregistrement des Arduinos. On va voir ainsi si l'Arduino arrive à se connecter et à envoyer la ligne de texte qui l'identifie.

Il nous faut configurer le projet Eclipse :

en [1,2], créez une nouvelle configuration d'exécution de type [Java Application] [3] ;
en [4], sélectionnez le projet [serveurTcpGenerique] ;
en [5], sélectionnez sa classe principale, celle qui a la méthode [main] ;
en [6], donnez un nom à la configuration d'exécution que vous êtes en train de créer ;
dans l'onglet [Arguments] [7], mettez 100 [8] pour indiquer que le serveur doit s'exécuter sur le port 100 de la machine hôte ;

Exécutez la configuration [9]. Le serveur s'exécute et affiche des logs dans la console :

Sélectionnez

1.
2.
3.
4.
5.

Serveur générique lancé sur le port 100
Thread de lecture des réponses du serveur au client 1 lancé
Thread de lecture des demandes du client 1 lancé
--> 1 : <-- {"id":"192.168.2.3","desc":"duemilanove","mac":"90:A2:DA:00:1D:A7","port":102}
[fin du Thread de lecture des demandes du client 1]

ligne 1 : le serveur a été lancé ;
entre les lignes 1 et 2, un client a été détecté : l'Arduino ;
lignes 2-3 : deux threads sont lancés : un pour lire les demandes du client (ligne 3), l'autre pour lire les lignes tapées par l'utilisateur au clavier (ligne 2). Ici, le client n'attend pas de réponse, donc nous n'aurons pas à taper une réponse au clavier ;
ligne 4 : le serveur affiche la commande que l'Arduino lui a envoyée. C'est bien la ligne attendue ;
ligne 5 : le client (l'Arduino) a fermé sa connexion. Ceci a pour conséquence de fermer le thread lancé ligne 3 ;

Maintenant consultons la console de logs de l'Arduino :

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 : 1286

ligne 1 : toutes les secondes l'Arduino essaie de se connecter au serveur d'enregistrement ;
ligne 2 : il y arrive ;
ligne 3 : la ligne qu'il a envoyée au serveur d'enregistrement ;
ligne 4 : l'enregistrement est terminé. L'Arduino va fermer sa connexion avec le serveur d'enregistrement ;
ligne 5 : le serveur qui opère sur le port 102 de l'Arduino est alors lancé. Il va exécuter toutes les commandes que la couche [DAO] va lui envoyer ;
ligne 6 : la mémoire disponible. On a déjà perdu 1472-1286=186 octets ;

IV-C. Exécution des commandes de la couche [DAO]▲

Le serveur qui vient d'être lancé sur le port 102 de l'Arduino va exécuter les commandes JSON que la couche [DAO] va lui envoyer.

A lire

Dans les exemples de l'IDE Arduino :

le code du serveur web [Ethernet / Webserver] ;
le code de l'exemple [aJson / Examples / MultiLevelParsing] ;

IV-C-1. Le code▲

Le traitement des commandes envoyées à l'Arduino pourrait ressembler à ce qui suit (cf while ligne 81 page ):

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.
74.
75.
76.
77.
78.
79.
80.
81.
82.
83.
84.
85.
86.
87.
88.
89.
90.
91.
92.
93.
94.
95.
96.
97.
98.
99.
100.
101.
102.
103.
104.
105.
106.
107.
108.
109.
110.
111.
112.
113.
114.
115.
116.
117.
118.
119.
120.
121.
122.
123.
124.
125.
126.
127.
128.
129.
130.
131.
132.
133.
134.
135.
136.
137.
138.
139.
140.
141.
142.
143.
144.
145.
146.
147.
148.
149.
150.
151.
152.
153.
154.
155.
156.
157.
158.
159.
160.
161.
162.
163.
164.
165.
166.
167.
168.
169.
170.
171.
172.
173.
174.
175.
176.
177.
178.
179.
180.
181.
182.
183.
184.
185.
186.
187.
188.
189.
190.
191.
192.
193.
194.
195.
196.
197.
198.
199.
200.
201.
202.
203.
204.
205.
206.
207.
208.
209.
210.
211.
212.
213.
214.
215.
216.
217.
218.
219.
220.
221.
222.
223.
224.
225.
226.
227.
228.
229.
230.
231.
232.
233.
234.
235.
236.
237.
238.
239.
240.
241.
242.
243.
244.
245.
246.
247.
248.
249.
250.
251.
252.
253.
254.
255.
256.
257.
258.
259.
260.
261.
262.
263.
264.
265.
266.
267.
268.
269.
270.
271.
272.
273.
274.
275.
276.
277.
278.
279.
280.
281.
282.
283.
284.
285.
286.
287.
288.
289.
290.
291.
292.
293.
294.
295.
296.
297.
298.
299.
300.
301.
302.
303.
304.
305.
306.
307.
308.
309.
310.
311.
312.
313.
314.
315.
316.
317.
318.
319.
320.
321.
322.
323.
324.
325.
326.
327.
328.
329.
330.
331.

  while(true){
    // mémoire disponible
    Serial.print(F("Memoire disponible avant service : "));
    Serial.println(freeRam());
    // on attend un client
    EthernetClient client=server.available();
    while(! client ){
      delay(1);
      client=server.available();
    }
    // si et tant que ce client est connecté
    while(client.connected()){
      Serial.println(F("client connecte...")); 
      // mémoire disponible
      Serial.print(F("Memoire disponible debut boucle : "));
      Serial.println(freeRam());

      // on lit la commande de ce client
      String commande=lireCommande(&client);
      // suivi
      Serial.print(F("commande : ["));
      Serial.print(commande);
      Serial.println(F("]"));
      // si la commande est vide, on ne la traite pas
      if(commande.length()==0){
        continue;
      }
      // sinon on la traite
      traiterCommande(&client,commande);
      // mémoire disponible
      Serial.print(F("Memoire disponible fin boucle : "));
      Serial.println(freeRam());
      // on passe à la commande suivante
      delay(1);
    }
    // on est déconnecté - on passe au client suivant
    Serial.println(F("client deconnecte..."));     
    client.stop();
    // mémoire disponible
    Serial.print(F("Memoire disponible fin service : "));
    Serial.println(freeRam());
  }
  // on ne rebouclera jamais sur le loop (normalement)
  Serial.println(F("loop"));
}

// traitement d'une commande
void traiterCommande(EthernetClient *client, String commande){
  // on décode la commande pour voir quelle action est demandée
  int l = commande.length();
  char cmd[l+1];
  commande.toCharArray(cmd, l+1);
  // on parse la commande JSON
...
  // pb ?
  if(json==NULL){
    sendReponse(client,reponse(NULL,"100",NULL));
    return;
  }
  // attribut id
...
  if(id==NULL){
    // suppression json
    aJson.deleteItem(json);
    // on envoie la réponse
    sendReponse(client,reponse(NULL,"101",NULL));
    // retour
    return;
  }
  // on mémorise l'id
...
  // attribut action
....
  if(action==NULL){
    // suppression json
    aJson.deleteItem(json);
    // on envoie la réponse
    sendReponse(client,reponse(NULL,"102",NULL));
    // retour
    return;
  }
  // on mémorise l'action
...
  // on récupère les parametres
...
  if(parametres==NULL){
    // suppression json
    aJson.deleteItem(json);
    // on envoie la réponse
    sendReponse(client,reponse(NULL,"103",NULL));
    // retour
    return;
  }
  // c'est bon - on traite l'action
  // echo
  if(strcmp("ec",strAction)==0){
    // traitement    
    doEcho(client, strId);
    // suppression json
    aJson.deleteItem(json);
    // retour
    return;
  }
  // clignotement
  if(strcmp("cl",strAction)==0){
    // traitement
    doClignoter(client,strId,parametres);
    // suppression json
    aJson.deleteItem(json);
    // retour
    return;
  }
  // pinWrite
  if(strcmp("pw",strAction)==0){
    // traitement
    doPinWrite(client,strId,parametres);
    // suppression json
    aJson.deleteItem(json);
    // retour
    return;
  }
  // pinRead
  if(strcmp("pr",strAction)==0){
    // traitement
    doPinRead(client,strId,parametres);
    // suppression json
    aJson.deleteItem(json);
    // retour
    return;
  }

  // ici, l'action n'est pas reconnue
  // suppression json
  aJson.deleteItem(json);
  // réponse
  sendReponse(client, reponse(strId,"104",NULL));
  // retour
  return;
}

// connexion au serveur
int connecte(EthernetClient *client, IPAddress serveurIP, int serveurPort) {
  // on se connecte au serveur après 1 seconde d'attente
  delay(1000);
  return client->connect(serveurIP, serveurPort);
}

// lecture d'une commande du serveur
String lireCommande(EthernetClient *client){
  String commande="";
...
  // on rend la commande
  return commande;
}

// formatage json de la réponse au client
String reponse(String id, String erreur, String etat){
  // chaîne json de la réponse au client
  // attribut id
  if(id==NULL){
    id="";
  }
  // attribut erreur
  if(erreur==NULL){
    erreur="";
  }
  // attribut etat - pour l'instant dictionnaire vide
  if(etat==NULL){
    etat="{}";
  }
  // construction de la réponse
  String reponse="{\"id\":\""+id+"\",\"er\":\""+erreur+"\",\"et\":"+etat+"}";
  
  // résultat
  return reponse;
}

// echo
void doEcho(EthernetClient *client, char * strId){
  // on fait l'écho
  sendReponse(client, reponse(strId,"0",NULL));
}

//clignoter
void doClignoter(EthernetClient *client,char * strId, aJsonObject* parametres){
  // exploitation des parametres
  // il faut une pin
...
  if(pin==NULL){
    // réponse d'erreur
    sendReponse(client, reponse(strId,"202",NULL));
    return;
  }
  // valeur de la pin à eteindre
...
  Serial.print(F("clignoter led="));
  Serial.println(led);
  // il faut la durée d'un clignotement
....
  if(dur==NULL){
    // réponse d'erreur
    sendReponse(client, reponse(strId,"211",NULL));
    return;
  }
  // valeur de la durée
...
  Serial.print(F("duree="));
  Serial.println(duree);
  // il faut le nombre de clignotements
...
  if(nb==NULL){
    // réponse d'erreur
    sendReponse(client, reponse(strId,"212",NULL));
    return;
  }
  // valeur du nombre de clignotements
...
  Serial.print(F("nb="));
  Serial.println(nbClignotements);

  // on rend la réponse tout de suite
  sendReponse(client, reponse(strId,"0",NULL));

  // on opère le clignotement
...
}

// pinWrite
void doPinWrite(EthernetClient *client, char * strId, aJsonObject* parametres){
  // il faut une pin
...
  if(pin==NULL){
    // réponse d'erreur
    sendReponse(client, reponse(strId,"201",NULL));
    return;
  }
  // numéro de la pin à écrire
  ...
  // suivi
  Serial.print(F("pw pin="));
  Serial.println(pin2);
  // il faut une valeur
  ...
  if(val==NULL){
    // réponse d'erreur
    sendReponse(client, reponse(strId,"202",NULL));
    return;
  }
  // valeur à écrire
  ...
  // suivi
  Serial.print(F("pw val="));
  Serial.println(val2);
  // il faut un mode d'écriture
  ...
  if(mod==NULL){
    // réponse d'erreur
    sendReponse(client, reponse(strId,"203",NULL));
    return;
  }
  ...
  // ce doit être a (analogique) ou b (binaire)
  if(...){
    // réponse d'erreur
    sendReponse(client, reponse(strId,"204",NULL));
    return;
  }
  // c'est bon pas d'erreur
  sendReponse(client,reponse(strId,"0",NULL));
  // suivi
  Serial.print(F("pw mod="));
  Serial.println(mod2);
  // on écrit sur la pin
...
}

//pinRead
void doPinRead(EthernetClient *client,char * strId, aJsonObject* parametres){
  // exploitation des parametres
  // il faut une pin
  ...
  if(pin==NULL){
    // réponse d'erreur
    sendReponse(client, reponse(strId,"302",NULL));
    return;
  }
  // numéro de la pin à lire
  ...
  // suivi
  Serial.print(F("pr pin="));
  Serial.println(pin2);
  // il faut un mode d'écriture
  ...
  if(mod==NULL){
    // réponse d'erreur
    sendReponse(client, reponse(strId,"303",NULL));
    return;
  }
  ...
  // ce doit être a (analogique) ou b (binaire)
  if(strcmp(mod2,"a")!=0 && strcmp(mod2,"b")!=0){
    // réponse d'erreur
    sendReponse(client, reponse(strId,"304",NULL));
    return;
  }
  // c'est bon pas d'erreur  
  // suivi
  Serial.print(F("pw mod="));
  Serial.println(mod2);
  // on lit la pin
...
  // on rend le résultat
  String json="{\"pin"+String(pin2)+"\":\""+valeur+"\"}";  
  sendReponse(client, reponse(strId,"0",json));
}

// envoi réponse
void sendReponse(EthernetClient *client, String message){
  // envoi de la réponse
...
  // suivi
  Serial.print(F("reponse="));
  Serial.println(message);
  
}

// mémoire libre
int freeRam ()
{
...
}

1 : Ecrire le code complet de l'Arduino. Vous pouvez suivre l'ossature proposée ou bien opter pour votre propre solution qui devra respecter les spécifications.

Note : vous trouverez le code précédent dans le dossier [support du TP] :

IV-C-2. de la couche [Arduino]▲

Pour tester la couche [Arduino], il faut lui envoyer des commandes JSON et voir comment elles sont traitées. On pourra procéder comme suit :

mettez en place le serveur Java qui va permettre l'enregistrement de l'Arduino (voir page , paragraphe ) ;

Vérifiez votre réseau local. Il doit être le suivant :

Téléversez votre programme sur l'Arduino, puis faites afficher la console de logs (Ctrl-M) :

Ci-dessus, l'Arduino s'est enregistré auprès du serveur d'enregistrement. Il attend désormais des commandes JSON sur le port 102 de l'Arduino.

Sous Eclipse, importez le projet Maven [Client Tcp générique] du dossier [support] :

Ce projet Maven crée un client générique TCP pour une machine distante et un port qu'on lui passe en paramètres. Ce client permet d'envoyer des lignes de texte à la machine distante et affiche ce que celle-ci renvoie. Nous allons le connecter au port 102 de l'Arduino.

Il nous faut configurer le projet Eclipse :

en [1,2], créez une nouvelle configuration d'exécution de type [Java Application] [3] ;
en [4], sélectionnez le projet [clientTcpGenerique] ;
en [5], sélectionnez sa classe principale, celle qui a la méthode [main] ;
en [6], donnez un nom à la configuration d'exécution que vous êtes en train de créer ;
dans l'onglet [Arguments] [7], mettez IPArduino 102 [8] où IPArduino est l'adresse IP de votre Arduino. Cela va connecter le client générique au port 102 de l'Arduino. C'est là qu'il attend les commandes JSON ;

Exécutez la configuration [9]. Si le client générique arrive à se connecter à l'Arduino, il affiche la chose suivante sur la console [1] :

Maintenant dans la console, tapez la commande suivante qui fait clignoter la led de la pin n° 8 :

Sélectionnez

{"id":"1","ac":"cl","pa":{"pin":"8","dur":"100","nb":"10"}}

La led doit clignoter 10 fois et l'Arduino doit renvoyer la réponse JSON suivante :

Sélectionnez

<-- {"id":"1","er":"0","et":{}}

qui indique que la commande a été exécutée correctement.

Sur la console de l'Arduino, des logs affichent l'échange qui vient d'avoir lieu :

Sélectionnez

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

client connecte...
Memoire disponible debut boucle : 832
commande : [{"id":"1","ac":"cl","pa":{"pin":"8","dur":"100","nb":"10"}}]
clignoter led=8
duree=100
nb=10
reponse={"id":"1","er":"0","et":{}}
Memoire disponible fin boucle : 617
client connecte...
Memoire disponible debut boucle : 617

Exécutez les commandes JSON que vous trouverez dans le dossier [support] du TP :

Vous y trouverez les trois commandes attendues par l'Arduino ainsi qu'un lot de commandes erronées. Pour ces dernières, l'Arduino doit renvoyer un code d'erreur significatif de l'erreur faite. Pour chaque commande, consultez la console de logs de l'Arduino.

Nous avons terminé la programmation des Arduinos. Nous n'y reviendrons plus. Nous allons passer maintenant à la construction du serveur de l'application.

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.