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.
J’ai réussi à créer via un arduino nano + capteur à ultrason HRC-04 et un émetteur 433Mhz un code pour récupérer la distance du haut de ma cuve au fond.
J’ai ensuite via le code du récepteur 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.
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!
tu feras deux heureux, je suis preneur aussi de ton montage/photos . 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 ^^
/*
* 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);
}
//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();
}
}
//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);
}
l’été dernier j’ai mis en place un fibaro double switch derrière un double interrupteur.
Interrupteur 1 : allumage de la pompe qui envoie l’eau vers le jardin
Interrupteur 2 : allumage de électrovanne qui permet de laisser passer l’eau pour l’arrosage automatique
Il faudrait que j’ajoute maintenant un système qui empêche d’allumage de la pompe s’il n’y a plus d’eau. Voilà où j’en suis, je pense m’y remettre au printemps comme ça je pourrai tester, là il fait trop froid
Plutôt qu’un arduino, un esp me semble parfaitement suffisant, mais je n’ai pas avancé plus que ça.
un code pour récupérer la distance du haut de ma cuve au fond.
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).
. 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 ^^
