Créer une jauge sur dashboard pour cuve eaux de pluies?

Bonjour à tous :smiley:

Je vais commercer par le plus important je suis un vraiment débutant et un pur autodidacte de l’informatique mais avec persévérance je progresse. :trophy:

J’ai réussi à créer via un arduino nano + capteur à ultrason HRC-04 et un émetteur 433Mhz :satellite: un code pour récupérer la distance du haut de ma cuve au fond.

J’ai ensuite via le code du récepteur :mailbox_with_mail: sur l’arduino uno modifier la valeur en format JSON puis pour finir j’ai utilisé node-red pour créer une jauge. (comme le module rpi-info de @piznel).

Est ce que quelqu’un pourrait m’aider pour créer un module sur gladys afin de l’intégrer au dashboard.

Merci d’avance à tous ceux qui vont m’aider

1 Like

Hello @jerome!

Je suppose que tu es sur Gladys 3? Je ne sais pas si tu suis l’actuellement du projet, mais actuellement on travaille sur Gladys 4 et une première version alpha est déjà sortie.

Dans Gladys 3 il n’est pas possible de faire une box dashboard lié à un module. Dans Gladys 4 le fonctionnement module un peu différent, mais c’est possible!

Salut @pierre-gilles.

En effet je suis sur gladys 3 pour le moment. Je suis le projet en effet, je regarde le forum tous les jours.

Avant de me lancer dans l’alpha, j’essaye que tous fonctionne sur gladys 3 déjà.

En faite mon idée serait d’avoir quelque chose de similaire à rpi-info.

Voila ce que j’ai réussi à faire avec node-red

1 Like

Je répond pas à ta question mais tu pourra partager ton montage ? J’ai acheté une maison qui a une cuve et ça m’intéresse beaucoup :grin:

Pas de souci, Tu veux des photos ou un schéma?

J’aime l’idée de la “Cuve aux de pluies” :smirk:
Moi aussi je suis preneur pour un futur projet.

1 Like

Les deux mon capitaine :grin:

1 Like

Salut,

tu feras deux heureux, je suis preneur aussi de ton montage/photos :smile:. J’ai aussi en projet de suivre la quantité d’eau restante dans ma pluie, histoire de ne pas lancer l’arrosage automatique quand elle est vide ^^

1 Like

Salut
un de plus :grin:, j’ai en projet de réaliser la même chose mais pas pour de suite…
Il me faut trouver du temps :wink:
Donc je suis preneur, Merci !!

2 Likes

J’arrive pas à intégrer dans firtzing l’émetteur et le récepteur 433Mhz.

Quelqu’un sait ?

/* 
 * Code d'exemple pour un capteur à ultrasons HC-SR04.
 * Communication de la valeur en 433Mhz
 */

#include <VirtualWire.h>

/* Constantes pour les broches */
const byte TRIGGER_PIN = 2; // Broche TRIGGER
const byte ECHO_PIN = 3;    // Broche ECHO
const byte VW_SET_TX_PIN = 12;
 
/* Constantes pour le timeout */
const unsigned long MEASURE_TIMEOUT = 25000UL; // 25ms = ~8m à 340m/s

/* Vitesse du son dans l'air en mm/us */
const float SOUND_SPEED = 340.0 / 1000;

/** Fonction setup() */
void setup() {

/** Initialisation de la bibliothèque VirtualWire */
vw_setup(2000);

  /* Initialise le port série */
  Serial.begin(115200);
   
  /* Initialise les broches */
  pinMode(TRIGGER_PIN, OUTPUT);
  digitalWrite(TRIGGER_PIN, LOW); // La broche TRIGGER doit être à LOW au repos
  pinMode(ECHO_PIN, INPUT);
}
 
/** Fonction loop() */
void loop() {
  
  /* 1. Lance une mesure de distance en envoyant une impulsion HIGH de 10µs sur la broche TRIGGER */
  digitalWrite(TRIGGER_PIN, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIGGER_PIN, LOW);
  
  /* 2. Mesure le temps entre l'envoi de l'impulsion ultrasonique et son écho (si il existe) */
  long measure = pulseIn(ECHO_PIN, HIGH, MEASURE_TIMEOUT);
   
  /* 3. Calcul la distance à partir du temps mesuré */
  int distance_mm = measure / 2.0 * SOUND_SPEED;
   
  /* Affiche les résultats en mm */
 
  Serial.print(distance_mm);
  Serial.println();

  /* On envoie le message */
  vw_send((byte *) & distance_mm, sizeof(distance_mm));

  /* On attend la fin de l'envoi */
  vw_wait_tx();
  
  /* Délai d'attente pour éviter d'afficher trop de résultats à la seconde */
  delay(1000);
}

Pour l’utiliser avec le moniteur de série :

//load libraries
#include <VirtualWire.h>

const byte VW_SET_RX_PIN = 11;

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

  // Initialisation de la bibliothèque VirtualWire
  // Vous pouvez changez les broches RX/TX/PTT avant vw_setup() si nécessaire
  vw_setup(2000);
  vw_rx_start(); // On peut maintenant recevoir des messages

}

void loop() {
  float distance_mm;
  byte taille_message = sizeof(float);

  /* 
   La variable "taille_message" doit impérativement être remise à 
   la taille de la variable avant de pouvoir recevoir un message. 
   Le plus simple est d'utiliser une variable locale pour ne pas
   avoir à réassigner la valeur à chaque début de loop().
   */

  // On attend de recevoir un message
  vw_wait_rx();

  if (vw_get_message((byte *) &distance_mm, &taille_message)) {
    // On copie le message, qu'il soit corrompu ou non

   if (distance_mm >= 0 && distance_mm <= 400)
   { Serial.print("Cuve remplie à : 100%"); }
   else if (distance_mm >= 401 && distance_mm <= 540)
   { Serial.print("Cuve remplie à : 90%"); }
   else if (distance_mm >= 541 && distance_mm <= 680)
   { Serial.print ("Cuve remplie à : 80%"); }
   else if (distance_mm >= 681 && distance_mm <= 820)
   { Serial.print ("Cuve remplie à : 70%"); }
   else if(distance_mm >= 821 && distance_mm <= 960)
   { Serial.print ("Cuve remplie à : 60%"); }
   else if (distance_mm >= 961 && distance_mm <= 1100)
   { Serial.print ("Cuve remplie à : 50%"); }
   else if (distance_mm >= 1101 && distance_mm <= 1290)
   { Serial.print ("Cuve remplie à : 40%"); }
   else if (distance_mm >= 1291 && distance_mm <= 1400)
   { Serial.print ("Cuve remplie à : 30%"); }
   else if (distance_mm >= 1401 && distance_mm <= 1550)
   { Serial.print ("Cuve remplie à : 20%"); }
   else if (distance_mm >= 1551 && distance_mm <= 1700)
   { Serial.print ("Cuve presque vide : 10%"); }
   else if (distance_mm >= 1701 && distance_mm <= 2000)
   { Serial.print ("Cuve presque vide : 5%"); }
   Serial.println();   
  }
}

Pour l’utiliser avec Node-red (format Json) :

//load libraries
#include <VirtualWire.h>

const byte VW_SET_RX_PIN = 11;

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

  // Initialisation de la bibliothèque VirtualWire
  // Vous pouvez changez les broches RX/TX/PTT avant vw_setup() si nécessaire
  vw_setup(2000);
  vw_rx_start(); // On peut maintenant recevoir des messages

}

void loop() {
  int distance_mm;
  byte taille_message = sizeof(int);

  /* 
   La variable "taille_message" doit impérativement être remise à 
   la taille de la variable avant de pouvoir recevoir un message. 
   Le plus simple est d'utiliser une variable locale pour ne pas
   avoir à réassigner la valeur à chaque début de loop().
   */

  // On attend de recevoir un message
  vw_wait_rx();

  if (vw_get_message((byte *) &distance_mm, &taille_message)) 
    // On copie le message, qu'il soit corrompu ou non

  Serial.print("{\"HRC_04\":");
  Serial.print(distance_mm);
  Serial.println("}");

  delay(5000);
  
}

Pour ceux qui souhaite ensuite utiliser node-red ensuite avec la jauge plus haut :

Je me suis inspiré de ce tuto pour ceux qui voudrait une petit vidéo