[TUTORIEL] - 1-Communication série (USB) entre Gladys et un Arduino


#1

Bonjour à tous,

Vous venez de croisez un magnifique tuto en ligne pour faire ce précieux capteur dont vous rêviez, ou bien ce super contrôleur de votre piscine, spa et Hammam. :stuck_out_tongue:
Comment le déclarer dans Gladys ?
Des modules existent en standard pour connecter des produits tels que Milight, Sonons, DIO, etc. avec Gladys.
Mais comment faire si vous fabriquez vous même votre périphérique ? par exemple un capteur de température et d’humidité comme dans ce tuto ?
Et si en plus de recevoir des données dans Gladys, je souhaite en envoyer à mon périphérique ? par exemple pour commander un relais comme dans ce tuto ?

Il y a donc plusieurs problèmes à résoudre :

  • Encoder et/ou décoder des données depuis l’Arduino au format compréhensible par Gladys.
  • Transmettre à Gladys et/ou recevoir les données de Gladys

:bulb: Voici un point à date de mes connaissances sur ces sujets. Merci à tous ceux qui ont contribué (à leur insu) à ce tuto : une bonne part de leurs participations sur le forum se retrouve dans ces lignes. :slight_smile:


Ce tuto est le premier d’une série sur la communication entre Gladys et un Arduino. A venir :

  • La communication par RF 433 MHz
  • La communication par Ethernet/wifi
  • La communication avec NRF24L01 (Le protocole des device MySensors).

Bonne lecture !

1. Gladys :arrow_right: Arduino connecté en USB

ou “comment envoyé un ordre de mise à jour d’un device à un arduino ?”

1.1. Du côté de Gladys

1.1.a. Le module “Serial”

Il faut d’abord dire à Gladys qu’un Arduino est connecté sur un des ports USB de la Raspberry. Le module “Serial” est fait pour ça.
Il suffit donc de l’installer depuis le store de module de Gladys, accessible par l’entrée de menu “Modules”, en suivant la procédure.
Remarque : A chaque déconnexion/reconnexion de l’Arduino, il faudra cliquer sur le bouton “configuration” de ce module.

1.1.b. Le module “Gladys to Arduino”

Ce module, créé par @MathieuA, ne se trouve pas (à la date du 27/05/2018) dans le store de Gladys. Il permet d’envoyer une chaîne de type JSON à l’Arduino qui sera analyser pour action par ce dernier. Son installation se fait à partir de l’onglet “Avancé” du menu “Modules” :

Le slug est très important : il correspond au service d’un device (et dans certains cas, également au protocole), et permet à Gladys de savoir comment communiquer. Il faut donc bien le noter.

Puis cliquez sur le bouton “Installer”. Une fois l’installation terminé, redémarrez Gladys.

1.1.c. Création de votre super actionneur dans Gladys (ou autre device fait maison)

Vous venez de terminez votre super actionneur, capable de commander votre portail (ou tout ce qui vous passe par la tête !), le fer à souder est encore chaud. Il n’y a plus qu’à dire à Gladys que vous avez fini :
Allez sur l’onglet “Mes devices” du menu “Devices”. La dernière ligne du tableau permet l’ajout manuel d’un device :

  • Nom : comment voulez-vous l’appelez, en clair ?
  • Identifier : Vous pouvez lui donner un identifiant pour que Gladys l’identifie de façon unique (sans espace).
  • Protocol : il faut mettre obligatoirement le slug du module “Gladys to Arduino”, soit “gladys-to-arduino” dans le cadre de ce tuto.
  • Service : Idem que “Protocol”.
  • Pièce : Vous pouvez dire à Gladys où votre device se trouve. Cela permettra d’y avoir accès depuis l’onglet “Contrôler mes devices”. pas obligatoire.
  • Utilisateur : Pas obligatoire, sauf si vous voulez que Gladys contrôle l’accès à votre device.
  • Puis cliquez sur le bouton “Créer”.
    Vous obtenez quelque chose d’approchant à cette capture d’écran :

    Maintenant, Gladys sait que vous avez connecté votre actionneur, et qu’il est accessible par l’intermédiaire du service “gladys-to-arduino”.
    Par contre, elle ne sait pas ce qu’elle doit faire avec : Qu’elles sont les fonctionnalités que vous voulez pilotez depuis Gladys ?

Nous allons les créer en cliquant sur le bouton “Edit”, ce qui ouvrira la fenêtre des deviceType du device. Remplissez la dernière ligne du tableau comme ceci :

  • ID : identifiant unique de chaque deviceType. Donné par Gladys. C’est ce numéro qui vous nous permettre de dire à Gladys sur quel deviceType il faudra modifier la valeur.
  • Identifier : Nom en clair de la fonction. Par exemple “Pompe à eau” si vous piloter une pompe-à-eau depuis Gladys, ou bien “Porte de Garage” si le relais commande l’ouverture et la fermeure de votre garage.
  • Type : Il va définir la façon dont l’actionneur du deviceType sera affiché :
    • binary : type bouton on/off
    • multilevel : curseur
  • Catégorie : ce qui vous semble le plus parlant ! :slight_smile:
  • tag : nom court devotre deviceType .
  • unité : renseigné si nécessaire.
  • min : valeur minimale autorisée. Dans le cas d’un type “binary”, mettre “0”.
  • max : valeur maximale autorisée. Dans le cas d’un type “binary”, mettre “1”.
  • capteur : si votre device ne fait que renvoyer des données, cocher la case. Ainsi Gladys n’affichera que la valeur, sans permettre de la modifier. Comme nous sommes dans l’étude d’un actionneur, ne pas cocher cette case.
    Cliquez ensuite sur le bouton “créer” :

    Le bouton de la colonne “Afficher” permet de masquer ou non le deviceType sur l’onglet “Contrôler mes devices”.
    Créer autant de deviceType que nécessaire, selon le nombre de fonctionnalité offerte par votre actionneur.

Chez moi, ça donne ça :

C’est terminé pour Gladys ! Bravo si vous êtes arrivé jusque là :slight_smile: :tada:

1.2. Le format JSON

Issu du monde Javascript, le format JSON est un format standard léger d’échange de donnée, très simple à lire et à comprendre.
JSON se base sur deux structures:

  • Une collection de couples nom/valeur, séparés par une virgule
  • Une liste de valeurs ordonnées dans un tableau, commençant par [ et se terminant par ].

Un objet JSON commence donc par { et se termine par } . Chaque nom est suivi de : (deux-points) et les couples nom/valeur sont séparés par , (virgule).

Exemple :

{
  "cle1":"valeur1",
  "cle2":"[1,2,3,4]",
  "cle3":{
    "clea":"valeura",
    "cleb":"['a','b','c']"
  }
}

qui peut également s’écrire :

   {"cle1":"valeur1","cle2":"[1,2,3,4]","cle3":{"clea":"valeura","cleb":"['a','b','c']"} }

Pour en savoir plus, allez voir sur le site officiel de JSON ou sur cette page en français d’Alsacréations.
Des outils en ligne permettent également de visualiser et valider un objet JSON (c’est à dire votre chaîne de caractère) :

Revenons à Gladys : un objet JSON valide pour elle est, par exemple :

{"deviceType":"4","value":"1"}

Ce qui signifie que le deviceType dont l’ID est 4 à comme valeur 1, soit, pour un deviceType de type binary, la valeur max autorisé ; il est donc sur ON.
Donc, en cliquant sur le bouton On/Off de votre device tout juste créé (soit sur la page des devices, soit sur celle des deviceTypes), Gladys enverra à l’Arduino par liaison USB l’objet JSON dont le deviceType est l’ID correspondant, avec la nouvelle valeur.

1.3. Du côté de l’Arduino

Nous pourrions écrire le code pour analyser et décomposer la chaîne reçue. Mais il est plus simple de faire appel à une bibliothèque prévu pour ça : ArduinoJson. Cette bibliothèque, créée par un français, est téléchargeable ici.
Commencez par l’installer dans l’IDE Arduino depuis le gestionnaire de bibliothèque.

1.3.a. La logique du sketch

La routine SerialEvent() est exécutée entre chaque boucle loop(). Elle est utilisé pour tester si des données sont en attente d’être lues sur le port série. Plusieurs octets pouvant être disponibles, à chaque boucle loop(), un caractère est lu. Pour lire un message en entier, il va falloir attendre que quelques bouclesloop() se fassent … :sleeping:

Nous allons donc créer une fonction permettant de lire et décoder le JSON reçu, fonction que nous appellerons depuis SerialEvent(), en passant en paramètre une structure. La fonction y enregistrera les valeurs du JSON.

1.3.b. Entête du sketch

L’entête de notre sketch est donc:

#include <ArduinoJson.h>	// Inclusion de la bibiothèque ArduinoJson

struct actionneurData {		// déclaration d'une structure "actionneurData",
  int id;					// pouvant conteneur 2 valeurs : la première de type Integer, appelée "id", 
  int valeur;				// et la deuxième, de type Integer, appelée "valeur".
};

actionneurData cde;			// Création d'une variable "cde" de type "actionneurData"

Nous avons donc maintenant à notre disposition une variable “cde”, pouvant enregistrer l’ID et la valeur d’un message JSON.

1.3.c. La fonction serialEvent() :

void serialEvent() {
  if (deserialize(cde)) {		// Appel de la fonction qui va décoder le JSON et enregistrer ses données dans notre variable "cde". cette fonction retourne "true" si elle a réussi, "false" si échec.
// A partir d'ici, ajouter votre code pour agir en fonction des valeurs reçues. Par exemple, le code ci-dessous renvoi à Gladys le message reçu, si l'Arduino est connecté au Raspberry. Vous pourrez ainsi le lire dans les logs de Gladys :       
    String tmpCde="";
    tmpCde="{\"deviceType\":\"";
    tmpCde+=cde.id;				// On ajoute la valeur "id" de notre objet "cde".
    tmpCde+="\",\"value\":\"";
    tmpCde+=cde.valeur;			// On ajoute la valeur "valeur" de notre objet 
    tmpCde+="\"}";
    Serial.println(tmpCde);
      }
    }

:bulb: Le caractère “\” est un caractère d’échappement. Notre message est de type “string” ; il sera donc encadré par des guillemets. Mais comment faire si nous voulons pourvoir mettre des guillemets dans notre message ? Simplement en disant au compilateur que chaque caractère précédé de “\” doit juste être recopié, et non pas interprété.
Donc "{\"deviceType\":\"" sera lu comme étant "{"deviceType\":"".

Il ne nous reste plus qu’à créer la fonction “deserialize()”.

1.3.d. La fonction deserialize()

Elle va découper le message reçu selon les couples “nom/valeur” et les enregistrer dans notre objet “cde” :

bool deserialize(actionneurData &data) {
  StaticJsonBuffer<55> jsonBuffer;
  JsonObject& root = jsonBuffer.parseObject(Serial);
  if (root == JsonObject::invalid()) {
    return false;
  }
  else {
    data.id = root["deviceType"];
    data.valeur = root["value"];
    return true;
  }
}

Quelques explications sur ce code :

bool deserialize(actionneurData &data)

Déclare la fonction, avec comme paramètre un objet “data”, de type “actionneurData”. Cet objet est reçu par référence (symbole & devant “data”), c’est à dire que la fonction peut le modifier directement, bien qu’il ait été déclaré hors de cette fonction. Elle renvoi un booléen , selon si elle a réussi à lire le JSON ou pas.

StaticJsonBuffer<55> jsonBuffer;

Nous avons besoin d’un tampon pour enregistrer les données temporaires pendant l’analyse du JSON. Cette déclaration permet de ne réserver que la mémoire nécessaire au tampon,
Pour calculer la valeur 55, rendez-vous ici. Vous pourrrez saisir dans la colonne de gauche un exemple de JSON ; A droite, vous lirez la taille du tampon à déclarer (=buffer), selon le type de microprocesseur. (Pour obtenir “55”, j’ai mis les valeurs limites du type “int”, soit -32768).

JsonObject& root = jsonBuffer.parseObject(Serial);

Cette ligne permet de créer un objet appelé root, de type JsonObject, qui va enregistrer dans le tampon précédemment créé ce que l’Arduino va recevoir sur le port série.
On test alors la validité du JSON ; si il n’est pas conforme, on renvoit “false”:

  if (root == JsonObject::invalid()) {
    return false;
  }

Sinon, le JSON est valide et on affecte alors les valeurs reçus à notre objet data, qui sera donc modifier pour tous les autres traitements de notre sketch :

  else {
    data.id = root["deviceType"];
    data.valeur = root["value"];
    return true;
  }

1.3.e. le sketch dans son intégralité :

#include <ArduinoJson.h>

struct actionneurData {
  int id;
  int valeur;
};

actionneurData cde;

void setup() {
  Serial.begin(9600);
}

void loop() {
}

void serialEvent() {
  if (deserialize(cde)) {
    String tmpCde = "";
    tmpCde = "{\"deviceType\":\"";
    tmpCde += cde.id;
    tmpCde += "\",\"value\":\"";
    tmpCde += cde.valeur;
    tmpCde += "\"}";
    Serial.println(tmpCde);
  }
}

bool deserialize(actionneurData &data) {
  StaticJsonBuffer<55> jsonBuffer;
  JsonObject& root = jsonBuffer.parseObject(Serial);
  if (root == JsonObject::invalid()) {
    Serial.println("JSON invalid");
    return false;
  }
  else {
    Serial.println("JSON received");
    data.id = root["deviceType"];
    data.valeur = root["value"];
    return true;
  }
}

Voilà, c’est pas plus compliqué que ça ! :wink:

2. Arduino connecté en USB :arrow_right: Gladys

Imaginons que nous avons raccordé à notre Arduino un magnifique capteur de température et d’humidité (comme le DHT11, moins d’1€ chez AliExpress) , et que nous voulons transmettre à Gladys 3 valeurs :

  1. Température (°C)
  2. Humidité (%)
  3. Température ressentie (°C)

Nous allons donc devoir créer 3 deviceTypes pour le device DHT11 dans Gladys, et les mettre à jour par l’envoi de 3 messages JSON depuis l’Arduino.

2.1. Du côté de Gladys

2.1.a. Le module “Serial” - Autre version !

Le module “Serial” du store ne permet pas de recevoir des messages JSON par le port USB du Raspberry. Il faut donc installé un autre module “Serial”, non présent dans le store (au 29/05/2018), créé par @Isokar.
Ce module a la même fonction que le module du store, avec en plus les fonctions suivantes :

  • Recevoir un message JSON depuis le port USB et l’interpréter.
  • Dans le cas où plusieurs Arduino sont connectés au Raspberry, il permet d’identifier celui qui échangera des messages JSON avec Gladys en passant par ce module.
    Il suffit donc de désinstaller celui du store (si vous l’aviez installé :upside_down_face:), et d’installer celui-ci, qui le remplacera avantageusement pour nous :
    Son installation se fait à partir de l’onglet “Avancé” du menu “Modules” :
  • Nom : Serial-Isokar
  • Version : 0.1.1
  • URL git (https) : https://github.com/isokar/gladys-serial.git
  • slug : serial

Le slug est très important : il correspond au service d’un device (et dans certains cas, également au protocole), et permet à Gladys de savoir comment communiquer. Il faut donc bien le noter.

En choisissant “serial” comme slug, les devices existant déjà dans Gladys et ayant comme service “serial” fonctionneront sans rien modifier.

Puis cliquez sur le bouton “Installer”. Une fois l’installation terminée, redémarrez Gladys.

Si vous avez suivi le tuto du premier chapitre, vous avez du remarquer qu’un message d’erreur apparaît dans Gladys au moment où vous modifier l’état d’une commande d’un device : En effet, le module “serial” du store ne peut interpréter le message JSON reçu de l’Arduino. Avec ce dernier module, non seulement le message est bien envoyé à l’Arduino, mais en plus, il est correctement interprété par Gladys.
Ce module permet donc la communication bi-directionnelle.

Après redémarrage, cliquez sur le bouton “Configuration”. Dans la liste de vos devices, vous devriez alors voir votre Arduino, si ce dernier est connecté à un des ports USB de la Raspberry :


Notez la valeur de l’“identifier”, en général quelque chose sous cette forme : /dev/ttyACM0

Depuis l’entrée de menu “Paramètres”, allez sur l’onglet “Paramètres” et créez le paramètre suivant :

  • Clé : Serial_tty
  • Valeur : /dev/ttyACM0 (dans mon exemple ; mettre la valeur que vous avez notée à l’étape précédente)

Ainsi, le flux des messages passant par le port USB pour l’Arduino le feront toujours par le même “chemin”. Il vous faudra donc toujours connecter votre Arduino sur le même port.

2.1.b. Création de votre super capteur dans Gladys (ou autre device fait maison)

Voir le paragraphe b. du chapitre précédent.
Dans notre exemple, nous allons avoir besoin de 3 devicetypes :

  • Température
  • Humidité
  • Température ressentie

:bulb: Ne pas oublier de cliquer sur “capteur”, de façon à pouvoir les mettre à jour.

Voilà ce que ça donne chez moi :


Pour les valeurs “min” et “max”, j’ai repris les caractéristiques du DHT11.

2.2. Du côté de l’Arduino

A ce stade, vous avez suivi le tuto “qui va bien” jusqu’au bout, la librairie “DHT sensor library” est installée depuis le gestionnaire de librairie de l’IDE Arduino ; il ne reste qu’à transmettre les données à Gladys.
Nous allons modifier le sketch de la façon suivante :

  • Comme pour le 1er chapitre, nous allons créer une structure dans l’entête du sketch, qui nous servira à stocker les valeurs du capteurs, ainsi que 3 variables pour stocker les ID des devicetypes créés dans Gladys,
  • Appeler une fonction depuis la boucle loop() pour la communication avec Gladys.
  • Créer la fonction serialize pour construire les JSON et l’envoyer à Gladys.

2.2.a. Entête du sketch

Nous allons ajouter une structure équivalente à celle du 1er chapitre, que nous appellerons cette fois sensorData, les 3 constantes des ID devicetype de Gladys, ainsi que la librairie ArduinoJson :

struct sensorData {
      int id;
      float valeur;
    };

int devicetype_id1 = 5; //id du devicetype de gladys "température". Mettre le votre !
int devicetype_id2 = 7; //id du devicetype de gladys "Humidité". Mettre le votre !
int devicetype_id3 = 8; //id du devicetype de gladys "Temp. ressentie". Mettre le votre !

#include <ArduinoJson.h>
#define SENSORDATA_JSON_SIZE (JSON_OBJECT_SIZE(2))

2.2.b. Dans la fonction loop()

Il faut remplacer :

/* Affichage de la température et du taux d'humidité */
Serial.print(F("Humidite (%): "));
Serial.println(humidity, 2);
Serial.print(F("Temperature (^C): "));
Serial.println(temperature, 2);
break;

par :

sensorData dataT;				// Objet pour l'enregistrement de la température
sensorData dataH;				// Objet pour l'enregistrement de l'humidité
sensorData dataTr;				// Objet pour l'enregistrement de la température ressentie.

dataT.id = devicetype_id1;		// Affectation de l'id du devicetype "température"
dataT.valeur = t;				// Affectation de la valeur de la température reçue par le capteur
serialize(dataT)				// Appel de la fonction "serialize" pour construire le JSON et l'envoyer à Gladys.
   
dataH.id = devicetype_id2;		// Affectation de l'id du devicetype "humidité"
dataH.valeur = h;				// Affectation de la valeur de l'humidité reçue par le capteur
serialize(dataH);				// Appel de la fonction "serialize" pour construire le JSON et l'envoyer à Gladys.
  
dataTr.id = devicetype_id3;		// Affectation de l'id du devicetype "Température ressentie"
dataTr.valeur = dht.convertFtoC(dht.computeHeatIndex(f, h));				// Affectation de la valeur de la température ressentie
serialize(dataTr);				// Appel de la fonction "serialize" pour construire le JSON et l'envoyer à Gladys.

:bulb: La température ressentie est calculé à l’aide de la température (en Farenheit) et de l’humidité. C’est ce que fait la fonction computeHeatIndex(). On obtient en retour une température en Farenheit, que l’on convertit en °C à l’aide de la fonction convertFtoC().

2.2.c. La fonction serialize

Devant l’impatience générale :stuck_out_tongue_winking_eye:, la voici :

void serialize(sensorData &data)
{
  StaticJsonBuffer<SENSORDATA_JSON_SIZE> jsonBuffer;	// Déclaration du buffer de la taille adéquate
  JsonObject& root = jsonBuffer.createObject();			// Création de l'objet "root"
  root["devicetype"] = data.id;				// Affectation de l'id de la structure "data" passée en paramètre.
  root["value"] = data.valeur;				// Affectation de la valeur de la structure "data" passée en paramètre.
  root.printTo(Serial);						// Impression directement sur le port série du JSON créé
  Serial.println("");                       // permet de séparer les JSON 
}

Je pense que les commentaires suffisent à comprendre ce code, surtout si vous n’avez pas sauté le 1er paragraphe :confused:

2.2.d. Le sketch en entier

#include "DHT.h"          // Librairie des capteurs DHT
#include <ArduinoJson.h>  // Libraison pour manipuler les messages JSON
#define DHTPIN 2          // Changer le pin sur lequel est branché le DHT

#define DHTTYPE DHT11     // DHT 11 
//#define DHTTYPE DHT22   // DHT 22  (AM2302)
//#define DHTTYPE DHT21   // DHT 21 (AM2301)

struct sensorData {       // Création du type "sensorData pour enregistrer les mesures.
  int id;
  float valeur;
};

int devicetype_id1 = 5; 	// id du devicetype de gladys "température"
int devicetype_id2 = 7;		// id du devicetype de gladys "Humidité"
int devicetype_id3 = 8; 	// id du devicetype de gladys "Temp. ressentie"

#define SENSORDATA_JSON_SIZE (JSON_OBJECT_SIZE(2))  // Variable indiquant la taille du buffer qui sera utilisé pour manipuler le JSON

DHT dht(DHTPIN, DHTTYPE);                           // Création d'un objet dht, de type DHT11, dont le pin "data" est branché sur le pin 2. 

void setup() {
  Serial.begin(9600);

  dht.begin();        // Initialisation de l'objet dht
}

void loop() {
  // Délai de 2 secondes entre chaque mesure. La lecture prend 250 millisecondes pour un DHT22, et 1 seconde pour le DT11
  delay(2000);
  
  sensorData dataT;       // Objet pour l'enregistrement de la température
  sensorData dataH;       // Objet pour l'enregistrement de l'humidité
  sensorData dataTr;      // Objet pour l'enregistrement de la température ressentie.

  // Lecture du taux d'humidité
  float h = dht.readHumidity();

  // Lecture de la température en °C
  float t = dht.readTemperature();

  // Pour lire la température en farenheit
  float f = dht.readTemperature(true);

  // Stop le programme et renvoie un message d'erreur si le capteur ne renvoie aucune mesure
  if (isnan(h) || isnan(t) || isnan(f)) {
    Serial.println("Echec de lecture !");
  } else {

    // Message JSON température
    dataH.id = devicetype_id2;
    dataH.valeur = h;
    serialize(dataH);

    // Message JSON humidité
    dataT.id = devicetype_id1;
    dataT.valeur = t;
    serialize(dataT);

    // Message JSON température ressentie
    dataTr.id = devicetype_id3;
    dataTr.valeur = dht.convertFtoC(dht.computeHeatIndex(f, h));
    serialize(dataTr);
  }
}

void serialize(sensorData &data)
{
  StaticJsonBuffer<SENSORDATA_JSON_SIZE> jsonBuffer;
  JsonObject& root = jsonBuffer.createObject();
  root["devicetype"] = data.id;
  root["value"] = data.valeur;
  root.printTo(Serial);               // Impression du JSON sur le serial
  Serial.println("");                 // permet de séparer les JSON 
}

3. Conclusion

A l’aide des modules Serial (version modifiée) et Gladys to Arduino, il est possible de recevoir et d’envoyer des messages JSON à Gladys, depuis un Arduino connecté en USB.

Un arduino pouvant servir à bien d’autre chose qu’à “jouer” à la station météo, les sketchs ont été pensé de façon à pouvoir inclure d’autres fonctionnalités, à un détail près : Dans le sketch du DHT11, une lecture est faite toutes les 2 secondes, à l’aide de delay(2000), ce qui stoppe le déroulement du programme. Il est plus judicieux de le faire de cette façon :

Déclarer dans l’entête du sketch :

unsigned long startMillis;  		// référence temps
unsigned long currentMillis;  		// temps actuel
const unsigned long period = 300000;	// le temps en millisecondes entre 2 mesures : 300000 = 5 minutes.

Dans setup(), ajouter :

startMillis = millis();  //Enregistre le temps actuel en milliseconde (c'est à dire le temps en milliseconde depuis que le programme à démarré)

A la place de la ligne delay(2000), dans la boucle loop() :

currentMillis = millis(); // enregistre le "temps" actuel 
if (currentMillis - startMillis >= period) //Test si le temps entre les 2 valeurs est >= à la période  
{  
// Inclure ici la partie sur la mesure
startMillis = currentMillis; //IMPORTANT enregistre comme temps de référence celui de la dernière mise à jour.  
}

:bulb: Le DHT11 est un capteur bas-de-gamme ; préférez le DHT22, plus précis et guère plus cher !
Vous pouvez également intégrer des valeurs correctives des mesures faites, si elles sont constantes. Attention de les intégrer au bon endroit, de façon à permettre un bon calcul de la température ressentie !
Une fonction supplémentaire de ce type de capteur pourrait être le calcul de l’index Humidex, avec envoi de sa valeur à Gladys dans un nouveau deviceType.

Pour allez plus loin :


Emetteur / Recepteur 433 Mhz
[Resolu] Config device Gladys ON/OFF
Retour utilisation télécommande 433 dans Gladys
Gladys vers Arduino->relais
#2

Costaud le tuto !
Je suis pas encore assez dans le DIY pour me lancer mais si jamais j’ai la motivation, c’est sûr que je viendrais voir de ce côté !
Merci pour la communauté ! :wink:


Module Gladys-Radio / radioemitter / serial
#3

Merci :slight_smile:
J’ai en préparation celui par RF333, Wifi ou Ethernet. Et je finirais par NRF24L01. Comme ça, tout le monde pourra s’éclater à créer tout ce qu’il voudra :smile: !


#4

Bravo pour ton tutoriel :metal: Je le partage ce week-end sur les réseaux sociaux :wink:


#5

Wouha ! Je vais devenir célèbre alors ? :hugs:


#6

Wouah cte tuto ! Bravo&Merci. Il va me falloir une semaine de vacances pour tout suivre :wink:


#7

Partagé =>


#8

Hello !

Bravo pour le tuto !!!
Une petite question, tu pars du principe que Gladys va envoyer le JSON : {“deviceType”:ID, “value”:valeur}
Toutefois, si on utilise l’arduino pour commander des prises 433mhz, le module radioemitter enverra plutôt le JSON : {“function_name”:“SendRadioCode”,“code”:"${code}"}

Je me demande donc comment faire pour tester si c’est “function_name” OU “deviceType” du coté de l’arduino,
Mon code est le suivant, je voudrais juste une confirmation que c’est bien le fonctionnement attendu :

char endMarker = “%”;

void serialEvent() {
//lit toutes les données (vide le buffer de réception)
char last_readed_char = Serial.read();
if ( last_readed_char == endMarker ) {
deserialize(command);
command = “”;
} else {
command += last_readed_char;
}
}

void deserialize(String json_data) {
StaticJsonBuffer<200> jsonBuffer;
JsonObject& v = jsonBuffer.parseObject(json_data);
// JSON d’envoie d’un code 433mhz
if ( v[“function_name”] == String(“SendRadioCode”) ) {
SendRadioCode(v[“code”]);
}
// JSON de demande de lecture de la température via la télécommande
if ( v[“deviceType”] == 77 ){
renvoyerTemp = true;
}
}

Deuxième chose sur ce code, c’est repris du module radioemitter de Gladys. en relisant ton tuto j’ai l’impression que ma fonction SerialEvent ralentie ce que je fais, Elle concatène les caractères un par un jusqu’au endMarker (%) puis appel deserialize.
Toi tu deserialize tout de suite, je me trompe ?

Merci d’avance,


#9

Salut @Jojo,

En fait, celà dépend du module “Serial” que tu utilises. Si tu utilises celui que je cite, le message JSON est de la forme que j’indique.

En fait, je ne pense pas que ça ralentisse ton Arduino :slight_smile:
Par contre, oui, je deserialise dans la foulée, car la libriairie JSOn de l’Arduino le permet. Et du coup, c’est plus simple :slight_smile:


#10

Hello @piznel,

merci pour ta réponse rapide :slight_smile:

J’utilise le module serial d’isokar (comme dans le tuto), mais je ne comprends pas ce que tu veux dire. Actuellement mes prises utilisent le module ‘radioemitter’, qui lui appelle la fonction “sendCode” du module ‘serial’, hors cette fonction envoie juste le code de radioemitter, qui est le JSON suivant : {“function_name”:“SendRadioCode”,“code”:"${code}"}
Du coup je suis censé traiter mes prises comment ?

Oui ça ne le ralenti pas, je me suis mal exprimé, ça rend le code plus long (pas son exécution :stuck_out_tongue: )


#11

Bonjour @piznel,

Je suis en train d’essayer de suivre votre tuto. Mais je suis bloquée la détection de mon arduino par mon raspberry.
J’ai essayé de faire la deuxième partie du tuto, pour communiquer de l’arduino vers Gladys. J’ai installer le module serial @isokar mais lorsque j’ai fait cette partie :

Et bien rien, pas d’arduino dans ma liste de programme.
Est ce qu’il faut absolument qu’il y a le bon code de téléversé dessus? (le bon code c’est pas possible car je ne connais pas le numéro des devicesType mais au moins un code inter-agissant avec Gladys.)

Merci d’avance pour votre aide.


#12

Salut @Cecile ,
Sais-tu afficher les logs de Gladys ?
Si oui, il serait intéressant de voir ce qu’elle dit quand tu cliques sur configuration.
Si non, et bien, recherche sur internet comment se connecter en SSH à un raspberry, il y a plein de tuto super simple.
N’hésites pas à revenir en cas de diificulté :slight_smile:


#13

Ou sur le forum directement :smiley:


#14

tu as essayé ça?


#15

Bonsoir,

Me revoilà, pas trop le temps dernièrement d’avancer.

@piznel J’ai regardé les logs mais malheureusement il ne se passe strictement rien dans les logs. Je vois seulement mon script checkUserPresence se dérouler.

@benPi Merci j’ai réussi a ajouter mon Arduino, dommage que je n’ai pas reussi automatiquement.

Je vais continuer a dérouler le Tuto.


#16

Salut @Cecile, n’hésites pas à revenir vers nous surtout !


#17

Mauvaise nouvelle, rien ne s’affiche dans les courbes.
Par contre, lorsque j’ouvre ma liste de deviceType, les valeurs s’affichent, donc c’est que cela fonctionne plutôt bien.



#18

Affecte les devices à une pièce, ça devrait mieux marcher :slight_smile:


#19

Parfait, merci de ton aide.


#20

Le sketch ne fonctionne pas pour moi
Arduino : 1.8.5 (Windows 10), Carte : “Arduino/Genuino Uno”

C:\Users\AppData\Local\Temp\arduino_modified_sketch_717874\sketch_sep19a.ino: In function ‘bool deserialize(actionneurData&)’:

sketch_sep19a:30: error: ‘StaticJsonBuffer’ was not declared in this scope

StaticJsonBuffer<55> jsonBuffer;

^

sketch_sep19a:30: error: ‘jsonBuffer’ was not declared in this scope

StaticJsonBuffer<55> jsonBuffer;

                    ^

sketch_sep19a:32: error: ‘invalid’ is not a member of ‘ArduinoJson::JsonObject’

if (root == JsonObject::invalid()) {

           ^

Plusieurs bibliothèque trouvées pour “ArduinoJson.h”
Utilisé : C:\Users\Documents\Arduino\libraries\ArduinoJson
Non utilisé : C:\Users\Documents\Arduino\libraries\ArduinoJson-master
exit status 1
‘StaticJsonBuffer’ was not declared in this scope