API REST de gestion des périphériques 1-wire.

1.1.1        Théorie

Déjà, c’est quoi une API ?

En voici une belle définition, et une définition un peu plus informatique.

Pour nous, cela va correspondre à un service accessible par un navigateur ou un programme capable de récupérer des informations d’un serveur Web.

Cette API permettra de gérer les périphériques du bus 1-wire. Les mesures et les informations seront fournies au format JSON. Le bus 1-wire ainsi que les périphériques de type DS18B20 et DS2431 ont été étudiés précédemment, il n’est pas inutile de consulter ces chapitres pour bien comprendre ce que fait l’API. L’électronique sera donc en tous points identiques aux chapitres sur les périphériques 1-wire.

Comme indiqué, cela va être une API REST, c’est-à-dire, qu’elle va communiquer en http. Donc pour simplifier, qu’elle va utiliser le même protocole que le Web.

Il est possible de faire une API REST avec pleins de langage, le Python, le PHP, le C++, le Java et encore  bien d’autres. Si vous voulez voir une belle foire d’empoigne, il suffit de demander sur Internet quel est le meilleur langage pour faire une API REST, chacun aura sa solution et ce sera bien sur la meilleure.

Pour cette fois, je ne vais pas utiliser le C++, mais le Java et je vais utiliser un Framework, Spring Boot pour me simplifier un peu la programmation.

Le Framework Spring Boot fait automatiquement pas mal de chose qu’il est donc inutile de programmer. Spring Boot fera la plomberie et vous n’aurez qu’à vous focaliser sur la partie métier, l’intelligence du programme. Enfin, ça c’est sur le papier, Spring Boot est sympathique, mais c’est une sacrée usine à gaz quand on ne le connait pas.


 

1.1.2        Installation des outils de développement

Les outils de programmation étant un peu, voire très lourds, la programmation se fera sur un PC et on transfèrera le programme au Raspberry pour l’utiliser. Cette technique pose quelques problèmes surtout si on est sous Windows car certaines fonctionnalités et en particulier la gestion des fichiers sont différentes entre Windows et Linux, cela pose pas mal de problèmes de débogage.

Donc, soit on reste sur Windows et la mise au point du programme sera un peu plus fastidieuse, soit on installe un Linux sur le PC. L’installation d’un Linux peut se faire sur une machine virtuelle de type VirtualBox ou VmWare.

De mon côté, je suis resté sous Windows…

Pour faire fonctionner tout ça et nous simplifier la vie, on va installer quelques logiciels :

-          Déjà, si on fait du Java, il faut Java. L’installation a déjà été présentée dans le chapitre sur le web. Si ce n’est pas déjà fait, installé le. Attention, il faut impérativement un JDK, une version de Java avec le compilateur, pas un JRE qui est une version qui peut exécuter du Java, mais pas le compiler.

-          Maven qui est un outil de gestion des librairies Java. Si vous vous souvenez, avec Eclipse on l’avait fait à la main et c’était un peu pénible.

-          STS, Spring Tools Suite, qui est une version d’Eclipse comme celui qu’on a déjà utilisé, mais qui est préconfiguré pour faire du Spring Boot.

-          Cmder qui est un interpréteur de commande un million de fois mieux que le cmd de Windows (inutile si vous avez pris l’option Linux). Il ressemble d’ailleurs très fortement à l’interpréteur Linux. Il est capable d’exécuter indifféremment des commande Linux et Windows.

-          Postman (Chrome) ou RestClient (Firefox) pour envoyer des demandes à notre API. Simplement, on peut le faire via un navigateur, mais pas pour toutes les commandes. Personnellement, j’utilise Chrome et donc Postman, je ne ferais que la présentation de cet outil.

Pour mettre tout sans trop polluer votre machine, je vous conseille de créer un répertoire dédié afin d’éviter qu’il y en ait partout.


 

1.1.2.1       Maven

Maven se trouve en téléchargement sur le site d’apache.

Si vous êtes sous Windows, prenez la version zip et si vous êtes sous Linux la tar.gz

Décompactez le logiciel dans le répertoire dédié au développement

Créez ensuite des variables d’environnement pour le fonctionnement du logiciel.

M3_HOME qui représenta la racine de Maven

M3 qui pointera sur le répertoire bin de Maven

Intégrez la variable M3 dans le PATH pour pouvoir l’utiliser n’ importe où

Ensuite, un petit test pour voir si tout va bien. Avec un interpréteur de commande tapez la commande mvn –version et Maven devrait répondre quelque chose comme ça

 


 

1.1.2.2       Spring Tools Suite

Téléchargez environnement de développement.

Un petit clic sur le bouton  lance le téléchargement, mais de la version 32 bits. Si vous voulez la version 64 bits ou si vous  êtes sous Linux, regarder le lien  .

On se retrouve avec un zip de plus de 380Mo

On le décompacte dans le répertoire dédié et on se retrouve avec quelque-chose qui s’appelle sts-bundle


 

Faites un raccourci du programme STS.exe pour le coller sur le bureau, ça sera plus facile.

Au premier lancement, vous devez sélectionner un workspace, c’est l’endroit où les fichiers des programmes seront stockés. Par défaut, il propose un chemin dans le répertoire de l’utilisateur.


 

Mais vous pouvez aussi le configurer dans votre répertoire dédié au développement

Au premier lancement, le programme charge pleins de choses et propose une page avec les dernières nouvelles sur Spring.


 

Dans le menu Windows Préférence, sélectionnez Maven puis Installation


 

Puis cliquez sur le bouton « Add » afin d’ajouter le Maven précédemment installé


 

Sélectionnez le afin qu’il soit bien pris en compte

Puis OK pour valider


 

A noter que STS est directement paramétré avec un serveur Pivotal qui est en fait un serveur Tomcat légèrement amélioré afin que la maintenance et le déploiement d’application soit facilité (possibilité de le mettre directement dans un jar ou un war pour des applications plus autonome).

STS est prêt pour la programmation de l’API


 

1.1.2.3       Cmder

Cmder est disponible ici, cliquez sur le bouton  pour le télécharger (cette opération n’est que pour Windows). Vous obtenez un fichier cmder.zip d’environ 85Mo. Créez dans votre répertoire dédié un sous répertoire pour accueillir Cmder et le décompacter.

Créer un raccourci du programme Cmder.exe à copier sur le bureau.

1.1.2.4       Postman

Recherchez Postman dans google

Cliquez sur le lien

Cliquez sur  puis sur 

La nouvelle application est disponible sur l’URL chrome://apps/ ou dans le menu « Démarrer »


 

Au premier lancement, il faut se connecter


 

Il faut faire une connexion soit par un compte Google, soit en créant un nouveau compte

Pour voir si tout fonctionne, demandé l’URL http://www.google.com et vous verrez que la réponse comporte prêt de 800 lignes de code. La petite page qui lance le moteur de recherche Google est loin d’être anodine


 

1.1.3        Le logiciel

1.1.3.1       Première compilation et premier test

Pour faire un premier test, récupérez le zip oneWire.zip à la fin du document et décompactez-le dans votre répertoire dédié à ce projet.

Ensuite, lancer le Cmder et se positionner dans le répertoire onewire (celui où il y a le fichier pom.xml, c’est lui qui indique que c’est un projet Maven)


 

Puis la commande qui demande à Maven de construire le logiciel à partir des sources Java

Après quelques secondes (un peu moins de 10 pour moi) et des centaines de lignes cabalistiques, vous devriez avoir le message BUILD SUCCESS. Il se peut que cela soit beaucoup plus long si Maven doit télécharger toutes les librairies, mais il ne le fera que la première fois.

La compilation a fait apparaitre un répertoire target

Contenant un fichier de 15Mo nommé oneWire-1.0.0.jar

C’est notre logiciel.

On va copier ce logiciel dans le Raspberry via WinSCP par exemple

Et via Putty ou en local, on va le démarrer


 

Le logiciel n’est pas un exécutable, c’est une archive Java, la commande de démarrage est donc java –jar oneWire-1.0.0.jar

Le logiciel met plus de 18s à se lancer. Gardez cette fenêtre en l’état, ne la fermez surtout pas.

Retour sur le PC, on ouvre un navigateur sur l’URL http://adresse_ip_du Raspberry :8081/api/v1/onewire/familly (pour moi http://192.168.1.27:8081/api/v1/onewire/familly)

Et on se retrouve avec  un superbe texte au format JSON. Ce texte pourra être différent pour vous en fonction des périphériques 1-wire connectés à votre Raspberry. Pour moi, il indique qu’il y a un périphérique w1, c’est le gestionnaire 1-wire et au moins un périphérique 2d (EEPROM DS2431) ainsi qu’au moins un 28 (thermomètre DS18B20).

Voilà, même si c’est encore très mystérieux, et que ça va demander beaucoup d’explications, on sait déjà que l’API fonctionne et qu’elle répond. On a réussi la compilation du projet et le premier test.

 


 

1.1.3.2       Description du logiciel

Maintenant, une explication du logiciel en lui-même.

Pour cela relancez STS en validant le workspace que vous avez sélectionné.


 

Nous allons importer le projet afin de voir un peu le code.

Aller dans le menu File/ Import


 

Sélectionnez « Existing Maven Projects »

Puis cliquez sur


 

Sélectionnez ensuite l’emplacement où le logiciel « oneWire » a été copié.

Plus cliquez sur le bouton .


 

Le projet est ensuite importé et compilé.

 


 

Regardons un peu dans chaque package de src/main/java ce qu’il y a :

Dans com.totof.onewire se trouve la classe OneWireApplication. C’est le lanceur de l’application.


 

Dans com.totof.onewire.api se trouve la classe MesureApi. C’est elle qui donne le chemin principal de l’url (ici /api/v1/onewire) et chaque fonction donne un mapping et un verbe http. @GetMapping("/admin") veut dire lance cette méthode lorsque je demande l’url /api/v1/onewire/admin avec un GET. On peut demander tous les verbes http (GET, POST, PUT, DELETE, PATCH), on a l’habitude du GET , mais le http a en fait été conçu pour faire pleins d’autres actions telle que la création, la mise à jour et la suppression de données.

En plus, on peut mettre des expressions régulières pour écouter un groupe d’url, par exemple, @PostMapping("/devices/{id:2d-[a-zA-Z0-9]{1,}}") veut dire : lance cette méthode lorsque tu recevras un POST sur /api/v1/onewire/devices/2d-xxxxxxxxxx (xxxxxxxxxx étant au moins un chiffre ou une lettre majuscule, ou minuscule)

On peut également récupérer les paramètres de l’url, @RequestParam(value = "message", required = true) veut dire qu’on recevra une url avec un paramètre message obligatoire : par exemple /api/v1/onewire/devices/2d-000000abc123ff ?message=ceci est mon texte à mettre dans l’EEPROM.

Cette classe indique également que l’API va produire du JSON encodé en UTF-8


 

Dans com.totof.onewire.configure, il y a une classe qui force le changement de certain paramètre de configuration. Ici, le port est forcé à une autre valeur que le 8080 par défaut de Tomcat.

 


 

Dans com.totof.onewire.domain, on trouve tous les objets qui vont être gérés par les services et renvoyé par l’API. A noter qu’il y a un objet abstrait Slave que tous les périphériques doivent étendre, cela donne un cadre commun à tous le périphériques 1-wire.

 


 

Dans com.totof.onewire.error, on trouve les messages d’erreurs applicatives et leurs gestions

 


 

Dans com.totof.onewire.exceptions, se trouve la classe de gestion des exceptions. Cela permet de centraliser les erreurs et de renvoyer dans le navigateur des messages et des codes d’erreurs prévus à l’avance.

 


 

Dans com.totof.onewire.service se trouve la gestion et le traitement des objets (ceux de domain) Elles seront récupérés et affichés par l’API. C’est dans ces classes que se trouvent tous les traitements, l’intelligence et le métier de l’API.

 

 


 

 

Dans com.totof.onewire.utils se trouve des classes d’utilitaires et des constantes.

 


 

Dans src/main/resources, on retrouve des pages html d’erreur et la page par défaut pour les url qui ne sont pas géré par l’API. Ainsi que des paramètres de l’application et des logs.

 


 

Dans src/test/java se trouve les classes de test qui valideront l’appel des url. Il faut bien se souvenir que ces tests sont lancés dans l’environnement de développement et pas sur le Raspberry, ils n’ont donc pas accès au bus 1-wire.

Le test développé ici effectuera un appel à chaque url avec un test de leur code retour sur un serveur local lancé temporairement juste le temps du test.

 


 

On retrouve ensuite les librairies, celles du JRE et celles gérées par Maven

 


 

Doc contient la Javadoc qui peut être générée par la commande File/Export/JavaDoc

 


 

Src n’a pas d’intérêt ici

Target contient le résultat de la compilation effectué par Maven suite à la commande « mvn clean install »

 


 

Il peut également être régénéré par les commandes Run As Maven clean et Maven install

 


 

Le dernier fichier extrêmement important est le fichier pom.xml qui décrit à Maven toute l’application avec principalement son nom, sa version, sa description, le type de fichier généré (jar ou war) ainsi que toutes les librairies dont le logiciel a besoin pour fonctionner (exécution, mais aussi compilation, test…)

 


 

1.1.3.3       Fonctionnement complet

L’API nous met à disposition des url (celles définis dans la classe MesureApi).

Pour les tester, relancer l’API sur le Raspberry afin d’avoir le fonctionnement réel.

Pour expliquer, j’utiliserai l’adresse IP de mon Raspberry, la 192.168.1.27, charge à vous de mettre bien évidemment la vôtre. J’utiliserai également PostMan afin d’envoyer toutes les informations dont l’API a besoin et faire une présentation des résultats plus lisible.


 

1.       http:// 192.168.1.27:8081/api/v1/onewire/admin (en GET) : donne des informations réseau.

Dans PostMan, indiquez l’url à envoyer, bien positionner le verbe à envoyer sur puis cliquez sur . Afin que la lecture du résultat soit le plus lisible possible sélectionnez  et

 

On obtient tout un tas d’informations réseau sur le serveur web, le Raspberry et l’appelant. Il y a également à la fin  un lien sur l’adresse elle-même. Cette adresse correspond à la norme HATEOAS qui facilite la navigation en donnant les liens vers l’adresse elle-même, les parents et les enfants de l’url appelée. A noter que dans Postman, un double clic sur l’un des liens l’ouvre dans un nouvel onglet.

Cette page d’information correspond à l’appel de la méthode getAdministration dans la classe MesureApi

@GetMapping("/admin")

    public Administration getAdministration(HttpServletRequest

Qui appel la méthode getAdministration dans la classe OneWireDevicesServiceImpl

public Administration getAdministration(HttpServletRequest…

Et renvoie un objet de type Administration (dans les domain) dont les paramètres sont affichés via les méthodes getxxxx.


 

2.       http:// 192.168.1.27:8081/api/v1/onewire/familly (en GET) : donne la liste des familles de périphériques branchés.

Le résultat indique qu’on a au moins un périphérique de la famille 2d (EEPROM DS2431), au moins un de la famille 28 (DS18B20) et un w1 qui est le master. Ainsi que les liens utilisables pour accéder à chacun d’eux.

Pour avoir ces informations le programme a fait appel à la méthode getFamilly de MesureApi, la méthode getFamilly de OneWireDevicesServiceImpl et renvoie un objet de type FamillyList.

3.       http:// 192.168.1.27:8081/api/v1/onewire/devices/master (en GET) : donne les informations sur le maitre 1-wire

Pour avoir ces informations le programme a fait appel à la méthode getMasterDevice de MesureApi, la méthode getMasterDevice de OneWireDevicesServiceImpl et renvoie un objet de type Master.

 


 

4.       http:// 192.168.1.27:8081/api/v1/onewire/devices/’un texte sur 2 caractères’ (en GET) : donne la liste des périphériques d’une famille branchés sur le Raspberry. Cela correspond aux url données par l’appel à familly (sauf le w1 qui devient master)

J’ai bien mes trois thermomètres branchés


 

Et l’EEPROM

Pour avoir ces informations le programme a fait appel à la méthode getDevicesByFid de MesureApi, la méthode getDevicesByFid de OneWireDevicesServiceImpl et renvoie un objet de type DevicesList.

 


 

5.       http:// 192.168.1.27:8081/api/v1/onewire/devices/’un texte sur 2 caractères suivi d’un tiret et d’un certain nombre d’autres caractères’ (en GET) : donne les informations sur un périphérique.

 

Pour avoir ces informations le programme a fait appel à la méthode getDevicesById de MesureApi, la méthode getDevicesById de OneWireDevicesServiceImpl et renvoie un objet issu de Slave de type DS18B20 ou DS2431.

 


 

6.       http:// 192.168.1.27:8081/api/v1/onewire/devices/2d- ‘suivi d’un certain nombre d’autres caractères’ (en POST) et du texte à écrire: permet d’écrire dans une EEPROM de type DS2431

Attention à bien paramétrer l’envoie de l’url en

Tiens !!!!, ne serait-ce pas un message d’erreur…

En fait, on reçoit un message indiquant qu’il y a une erreur de type IOError (en gros de lecture ou d’écriture sur un fichier) avec une permission non accordée sur le fichier /sys/bus/w1/devices/2d-000014535acd/eeprom.

Ceux qui ont lu le chapitre sur le DS2431 ont surement compris, seul root a le droit d’écrire dans la mémoire de l’EEPROM

Notre API étant démarrée avec le compte pi, on n’a que le droit de lecture sur ce fichier

On va donc arrêter l’API et la relancer avec les bons droits grâce à un sudo (attention à bien arrêter la première instance de l’API car c’est impossible de lancer deux API à la même adresse sur le même port.

On renvoie notre demande avec Postman

Et on vérifie que c’est correct

Pour info, le fullMessage correspond au contenu complet de l’EEPROM avec le nouveau message, des morceaux des anciens et les cellules à 0 qui n’ont jamais été écrites. Le message est par contre bien le dernier message écrit jusqu’au premier saut de ligne (ce n’est pas prévu dans le programme, mais rien n’empêche d’écrire plusieurs textes à la suite séparés par des sauts de ligne jusqu’à 1024bits qui est la capacité maximale de l’EEPROM).

Pour avoir ces informations le programme a fait appel à la méthode setDs2431Message de MesureApi, la méthode setDs2431Message de OneWireDevicesServiceImpl et renvoie un objet de type ResultWriteDs2431.

 


 

Et d’autres url qui sont les fichiers html définis dans src/main/resources/public

1.       404.html

Cette page devrait être appelée en cas d’erreur dans l’url. Toutefois, l’erreur d’url est également gérée dans la classe d’exception FunctionalExceptionHandler elle n’est jamais appelé malgré ce que semble indiquer la documentation.

On récupère le message d’erreur générique de Spring

 

2.       4xx.html

Devrait être appelé en cas d’erreur de type 400 autre que 404, je n’ai jamais réussi à l’appeler car l’API n’a pas de cas d’erreur de ce type.


 

3.       5xx.html

Devrait être appelé en cas d’erreur interne non géré par la classe FunctionalExceptionHandler.

FunctionalExceptionHandler gère les exceptions de types connus dans l’application ainsi que les éventuelles nullPointer. Je n’ai jamais eu l’occasion d’avoir cette page.

Exemple d’erreur en cas d’appel sur un PC ou un Raspberry sans 1-wire


 

4.       Index.html : page appelé en cas d’appel à la racine du serveur

 

Cette page indique les url utilisables ainsi qu’un certain nombre d’url de documentation (le lien « ici » pointant sur /docs géré directement par la librairie Spring)

 

Note générale :

Pour les liens de type HATEOAS, chaque objet renvoyé doit étendre la classe ResourceSupport.

Par exemple public class Master extends ResourceSupport

Ce qui permet d’avoir accès à la méthode LinkTo qui pointera vers une méthode de l’API permettant de récupérer automatiquement son url

// Liens

Link linkSelf = linkTo(methodOn(MesureApi.class).getMasterDevice()).withSelfRel();

master.add(linkSelf);


 

1.1.4        Utilisation

Bon, c’est génial, on a une super API, on est vachement à la mode. Maintenant qu’est ce qu’on va bien pouvoir en faire…

1.1.4.1       Lecture depuis l’extérieur

Ce qui serait intéressant, ce serait de pouvoir lire les informations depuis l’extérieur, comme ça on pourrait par exemple connaitre la température de la maison quand on est chez mamy.

Si vous avez une box, il suffit d’ouvrir l’accès de votre Raspberry vers l’extérieur.

Pour une LiveBox, voici un petit tutoriel[c1] , je vous laisse chercher pour les autres modèles de box.

Chez moi, j’ai paramétré ceci.

C’est-à-dire que pour l’appareil raspberrypi-2 que la box connait comme étant le 192.168.1.27, j’ouvre vers l’extérieur son port 8081 sans redirection de port, c’est-à-dire que j’aurais également le port 8081 visible de l’extérieur.

Je récupère l’adresse IP de ma LiveBox vue de l’extérieur

Et un petit test sur un téléphone en 4G (pensez à bien désactiver le Wi-Fi) avec l’adresse IP de la LiveBox et les url de l’api

http://000.000.000.000:8081/api/v1/onewire/devices/28-0416525590ff

 

Bon, c’est bien, mais le seul problème c’est que régulièrement, ma LiveBox va changer d’adresse IP. Et que je ne serai pas au courant.

La solution, c’est de s’inscrire à un service qui attribue un nom de domaine à votre adresse IP de Livebox. Personnellement, j’utilise NoIP.


 

Je me suis inscrit et j’ai paramétré le service sur ma Livebox afin qu’elle envoie les informations à NoIP à chaque changement d’adresse IP (Le message « Expire in 30 days » indique que si vous ne faites rien, le service sera interrompu dans 30 jours. Mais NoIP vous enverra un mail 7 jours avant pour renouveler)

Il suffit de mettre le Hostname pour le nom d’hôte et les noms d’utilisateur et mot de passe que vous avez choisis à l’inscription à NoIP


 

Maintenant, au lieu d’utiliser l’adresse IP, il suffit de faire l’appel par le Hostname donné par NoIP

Donc si j’ai des interrupteurs, des capteurs ou n’importe quoi d’autre branchés sur mon Raspberry, je peux les commander à distance via une API. Bienvenue dans le monde merveilleux de la domotique à distance…


 

1.1.4.2       Un petit client plus sympathique

Le JSON, c’est bien joli, mais ce n’est pas toujours super lisible. Nous n’avons ici que quelques lignes, mais si on a des capteurs très sophistiqués qui nous envoient des centaines de lignes d’information, ça ne va pas être drôle à lire.

Donc on va se programmer un petit client qui décodera le JSON pour en faire quelque chose de plus lisible et de plus exploitable.

Encore une fois, tous les langages sont utilisables, personnellement, je vais rester en Java car il y a des librairies bien pratiques pour lire du JSON.

Je vais faire une application hyper classique, un client qui lira régulièrement les thermomètres via l’API et ira stocker les températures dans une base de données. Ces données pourront ensuite être exploitées pour ajuster votre consommation de gaz/fioul/électricité, faire une station météo avec des statistiques etc…

1.       Le logiciel

Récupérez le logiciel mesureTemperature.zip à la fin du document, décompactez-le et importez-le dans STS.

Une petite explication du contenu de chacun des packages.

·         com.totof.mesure

Ce package contient le lanceur de l’application et la classe qui sera lancée toutes les minutes.

Cette classe demandera via l’API la liste des devices DS18B20 puis leurs informations. Elle stockera ensuite dans la base de données la température de chaque device ainsi que la date et l’heure de la mesure.


 

·         com.totof.mesure.model.jpa

Ce package contient la classe qui fait le mapping avec la table de la base de donnée. Elle donne le nom de la table et la description de chaque champ.


 

·         com.totof.mesure.model.json

Ce package contient les classes qui vont permettre le décodage du message JSON de l’API.

La structure de ces classes a été créée grâce au site Pojo ce site permet de créer les classes java directement à partir d’un fichier JSON ou XML.

 

Un copier/coller permet d’avoir la structure des tables dans STS, il reste à mettre les annotations JSON, à faire un peu de mise en page et parfois à supprimer des classes identiques, mais c’est un excellent outil pour avoir la structure générale des classes de décodage.

Ces classes vont recevoir toutes les informations du JSON. C’est informations seront dispatchés dans les différentes classes et seront accessible par les getter des classes.

Par exemple, le fid d’un device sera accessible par un simple getFid dans le programme, pas besoin de décortiquer le JSON, c’est déjà fait.

 


 

·         com.totof.mesure.repository

Ce package contient une classe avec quasiment rien dedans, elle permet juste de récupérer les fonctionnalités de la classe Spring JpaRepository qui permet de gérer (Create, read, update et delete, le CRUD) la table décrite dans le package model.jpa. Même si ici on n’utilise que le create (l’insert SQL) on a accès à toutes les possibilités via des méthodes java.

·         com.main.resources

Ce package contient un fichier application.properties qui donne les informations de connexion à la base de données. La ligne spring.jpa.hibernate.ddl-auto=update indique que la table utilisée par l’application sera créé au premier lancement puis mise à jour ensuite. Il y a plein d’autres possibilités comme recréer la table à chaque lancement ou la vider à chaque lancement ou ne rien faire…


 

·         Comme pour tous projets Maven, le pom.xml donne toutes les librairies nécessaires au fonctionnement du logiciel.

 

2.       Le fonctionnement

La compilation du logiciel par Maven

Le jar fait rien de moins que 24Mo, car il y a beaucoup de librairies (si vous êtes curieux, ouvrez le jar avec 7zip).

Un petit regard sur la base de données avec pgAmin avant le lancement (la même que l’on a utilisé dans le chapitre sur PostgreSQL)

 

On a notre table « composants » utilisée dans le chapitre sur PostgreSQL et rien d’autre.


 

On va maintenant lancer le logiciel. On peut le faire de n’importe où du moment qu’il y un accès à l’API et la base de données.

Pour moi, je vais le lancer du PC qui m’a servi à faire le développement alors que la base PostgreSQL et l’API sont sur le Raspberry 192.168.1.27.

Le logiciel va lancer la méthode ScheduledTasks.saveTemperature() toutes les minutes

Les mesures prennent environ 6 secondes (entre le start et le end), c’est le temps qu’il faut pour lire les thermomètres via l’API et stocker les mesures dans la base.

Coté base de données, que s’est-il passé ?

Il y a eu la création d’une table « temperatures » et d’une séquence « hibernate_sequence », la table est bien remplie avec les informations des thermomètres.


 

1.1.5        Liste des programmes

https://github.com/montotof123/raspberry/blob/master/150_Api/mesureTemperature.zip

https://github.com/montotof123/raspberry/blob/master/150_Api/oneWire.zip

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Lien vers la base du site.


 [c1]