Je viens vers vous car je sèche !
Voilà, j'ai des récupérateurs d'eau qui débordent avec la pluie, j'ai donc installé une vanne pilotée industrielle (3 fils) en 220V et un capteur (flotteur O/I).
Le principe est simple: Si le capteur d'eau est fermé alors on déclenche une LED, une écriture (Vanne:NF) sur LCD et déclenchement du relais 10 secondes afin que la vanne s'ouvre et stop.
Une fois le niveau descendu, le capteur passe en normalement ouvert, ce qui déclenche un deuxième relais 10 secondes pour fermer la vanne via le 3e fil.
Ça ne fonctionne pas ! Le relais reste ouvert et envois du jus pour ouvrir la vanne en continu, ce qui va endommager la vanne. Même soucis pour la fermeture de la vanne, le capteur envois en continu, le code ignore les délais de 10 secondes.
Je suis perdu et vous remercie d'avance pour l'aide que vous m'aurez apportée !
//---LCD---
#include <LiquidCrystal.h>
LiquidCrystal lcd(2, 3, 4, 5, 6, 7); // initialisation, on définit les ports pour RS, E et D4 à D7
//---SD---
#include <SPI.h>
#include <SD.h>
File myFile;
//Définition des entrées numériques
const int led_NO = 8;
const int capteur = 13;
const int r_vanne_o = 10;
const int r_vanne_f = 11;
// /------------\
//------------------------------| VOID SETUP |-------------------------------
// \------------/
void setup() {
Serial.begin(9600); //Initialisation de la communication avec la console
while (!Serial);
//Configuration des PIN numériques
pinMode(led_NO,OUTPUT); //indique que le pin 8 est une sortie
pinMode(capteur,INPUT); //indique que le pin 13 est une entrée
pinMode(r_vanne_o,OUTPUT); //indique que le pin 10 est une sortie
pinMode(r_vanne_f,OUTPUT); //indique que le pin 11 est une sortie
//Initialisation LCD
lcd.begin(16, 2); //indique le nombre de caractères (16) et de lignes (2)
lcd.print("Etat:");
lcd.setCursor(0,1); //on passe à la ligne suivante
lcd.print("Vanne:");
}
// /-----------\
//-------------------------------| VOID LOOP |-------------------------------
// \-----------/
void loop() {
//-------------------------ETAT VANNE-------------------------
if ((digitalRead(capteur)) > 0 )
{
digitalWrite(led_NO, HIGH); //Allume la led NO
lcd.setCursor(6,1); //Met le curseur sur le LCD après Vanne:
lcd.print("NF"); //Ecris NF sur le LCD après Vanne:
digitalWrite(r_vanne_o, HIGH); //Active le relais sur le pin 10 pour ouvrir la vanne
delay(10000); //Laisse le relais fermé 10 secondes pour la fermeture de la vanne
digitalWrite(r_vanne_o, LOW); //Désactive le relais du pin 10 pour arreter l'ouverture de la vanne
}
else
{
digitalWrite(led_NO, LOW); //Allume la led NF
lcd.setCursor(6,1); //Met le curseur sur le LCD après Vanne:
lcd.print("NO"); //Ecris NO sur le LCD après Vanne:
digitalWrite(r_vanne_f, HIGH); //Active le relais sur le pin 11 pour ouvrir la vanne
delay(10000); //Laisse le relais fermé 10 secondes pour la fermeture de la vanne
digitalWrite(r_vanne_f, LOW); //Désactive le relis du pin 10 pour arreter la fermeture de la vanne
}
//----------------------------AUTRE----------------------------
}
La fonction loop() s'exécute en permanence. Quand elle arrive à la fin, elle recommence au début donc:
tu testes l'état du capteur
tu actives le relais
tu attends 10 secondes
tu fais tomber le relais
tu arrives à la fin de la fonction donc retour au pas ①
En fait ton relais colle 10 secondes retombe pendant 1 millisecondes et recolle en boucle.
Il faut mémoriser l'état de la vanne et n'activer le relais que si l'état de celle-ci doit changer.
Admettons que tu ais une variable de type boolean qui s'appelle vanneOuverte.
Et que celle-ci soit à true lorsque la vanne est ouverte.
tu testes l'état du capteur
si le capteur indique un débordement et que vanneOuverte est false
alors tu ouvres la vanne
tu passes vanneOuverte à true
Si le capteur n'indique pas un débordement et que vanneOuverte est true
alors tu fermes la vanne
tu passes vanneOuverte à false
Comme on ne connait pas l'état de la vanne puisque l'on a aucun retour physique de son état, il faut au départ du logiciel faire une petite manipulation pour mettre en accord l'état de la vanne et l'état de la variable vanneOuverte
Dans le setup(), et de manière tout à fait arbitraire, il faut faire
fermer la vanne
mettre vanneOuverte = false
Une fois que le programme entrera dans loop() la vanne se rouvrira si nécessaire.
sinon je n'ai pas trop compris, il faudrait 2 capteurs non ? un pour un niveau haut et un pour un niveau bas ? (ou vous videz juste pendant 10s si le capteur détecte de l'eau ? )
Merci pour ton aide ! Alors j'ai un capteur flotteur qui à deux état, soit ouvert, soit fermé.
Donc si il est ouvert alors..., et si il est fermé alors...
Si il y à trop d'eau, la vanne s'ouvre pour baisser le niveau jusqu'à que le capteur soit en position normalement fermé.
Avec les intempéries actuels sur notre région c'est un comble de plus !
Si le niveau baisse d'un mm le capteur ne va plus rien détecter - les 10s servent à attendre assez longtemps c'est cela ? et les 10s après la fermeture de la vanne, c'est pour ne pas redéclencher tout de suite ??
La course du capteur est assez longue, j'ai 5cm de courses entre les deux état, les cuves étant assez grande, il faut plus de 10 secondes c'est pour ca que je veut automatiser ça en continue et en boucle afin que ça s'ajuste au poil ^^
Je suis très bon en hardware, soudures, création de PCB etc mais le codage, c'est pas ma tasse de thé, je me donne à fond mais purée ! que c'est dur !
la course importe peu, vous avez un capteur tout ou rien. il y a une goutte d'eau qui "fait déborder le vase" comme on dit.
si ça baisse d'un mm le capteur dira que la citerne n'est plus pleine - vous viderez donc pendant 10s
si la citerne se remplit, au moment où le capteur dit "cuve pleine" vous videz 10 secondes.
mais bon, la machine à état postée dans mon autre post devrait vous permettre de modéliser ce que vous voulez
Et pour simplifier votre gestion du détecteur, éventuellement utilisez une bibliothèque de boutons ( Button dans easyRun de @bricoleau ou OneButton de Matthias Hertel ou encore Toggle de @dlloyd). Il y a un tuto en français fait par Rémi (dans la partie tuto sur OneButton)
Il y a tellement de grosse pluies en ce moment que ça n'a même pas le temps de partir au trop plein et déborde, l'eau rentre dans mon sous-sol par capillarité.
Je souhaitais donc aide mettre un Y avant surpresseur afin de mettre une vanne industrielle gros diamètre pilotée pour faire partir l'eau bien plus vite et éviter le débordement.
L'eau vidangée va directement rejoindre une descente de gouttière.
j'ai un système un peu comme cela - une cuve de récupération d'eau sur une dépendance. quand elle est pleine je transfère une partie de son contenu vers une plus grosse citerne, mais uniquement si la grande n'est pas peine sinon ça part au trop plein.
Bien que ce soit majoritairement en gravitaire, Il me faut un coup de pompe pour amorcer le tuyau qui effectue la vidange car il a tendance à se désamorcer
Non pas nécessaire de se compliquer la vie.
Tu te contentes de mettre la vanne dans un état connu et la variable booléenne dans l'état correct correspondant.
Ensuite, c'est le programme derrière qui remettra tout dans l'état qui correspond à ce que détecte le capteur.
Effectivement, tu n'a pas de moyen de faire partir ton trop plein dans ta descente de gouttière du coup?
Du coup tu voudrais activer ton système uniquement par grosse pluie?
Si tu pouvais avoir une deuxième sonde, ca te permettrais d'activer ta vanne entre les deux sondes pour éviter un yoyo
J'ai un peu avancé, j'ai fait appel à un ami qui était avec moi en cours. Il se débrouille pas mal du tout, à deux ont a réussi à pas mal avancer, mais là, on bloque, même avec ChatGPT ! ...
Le programme fonctionne super bien, on a pris le temps de mettre les choses en forme et de faire un beau code lisible.
Donc dès que le capteur est en position normalement ouvert le relais se met en route 5 secondes afin d'ouvrir la vanne pilotée puis s'éteint afin que la vanne ne prenne pas du 220v le temps que ça coule. Le souci, c'est que quelques secondes après la vanne se ferme puis se rouvre, puis se referme etc et forme une boucle infinie. Si je mets le capteur en position normalement fermé, le programme sort de cette boucle la vanne se ferme bien et le programme se met en pause jusqu'au prochain débordement.
On ne comprend pas pourquoi cette boucle se forme dans cette partie du programme ...
On est proche du résultat souhaité, mais ce n'est pas encore satisfaisant !
Merci encore pour votre aide ! Vous êtes top !
const int capteurPin = 7; // Capteur sur le pin digital 7
const int relaisFermeturePin = 5; // Relais pour fermer la vanne sur le pin digital 5
const int relaisOuverturePin = 6; // Relais pour ouvrir la vanne sur le pin digital 6
bool vanneOuverte = false; // Variable pour suivre l'état de la vanne
void setup() {
pinMode(capteurPin, INPUT);
pinMode(relaisFermeturePin, OUTPUT);
pinMode(relaisOuverturePin, OUTPUT);
digitalWrite(relaisFermeturePin, LOW); // Désactiver le relais de fermeture au démarrage
digitalWrite(relaisOuverturePin, LOW); // Désactiver le relais d'ouverture au démarrage
Serial.begin(9600); // Démarrer la communication série pour la console
}
void loop() {
int etatCapteur = digitalRead(capteurPin);
if (etatCapteur == HIGH && !vanneOuverte) {
Serial.println("Citerne en train de déborder.");
digitalWrite(relaisOuverturePin, HIGH); // Activer le relais d'ouverture
delay(5000); // Activer le relais d'ouverture pendant 5 secondes
digitalWrite(relaisOuverturePin, LOW); // Désactiver le relais d'ouverture
vanneOuverte = true;
Serial.println("Vanne ouverte.");
}
if (etatCapteur == LOW && vanneOuverte) {
Serial.println("Citerne n'est plus en train de déborder. Attente pour fermer la vanne...");
delay(5000); // Attendre 5 secondes avant de vérifier à nouveau le capteur
if (digitalRead(capteurPin) == LOW) { // Vérifier à nouveau si le capteur est en position normalement fermée
Serial.println("La vanne va se fermer.");
digitalWrite(relaisFermeturePin, HIGH); // Activer le relais de fermeture
delay(5000); // Activer le relais de fermeture pendant 5 secondes
digitalWrite(relaisFermeturePin, LOW); // Désactiver le relais de fermeture
vanneOuverte = false;
Serial.println("Vanne fermée.");
} else {
Serial.println("Le capteur est encore en position ouverte. Attente...");
}
}
}
Le programme débute avec capteur en position LOW.
Je place le capteur en position HIGH
Le programme debute:
relaisOuverture qui s'active
S'éteint au bout de 5 seconde <--- Jusqu'ici c'est imppeccable !
<--- Le programe doit être en pause à cet instant jusqu'a que le capteur passe en LOW
relaisFermeture qui s'active <--- Et ici ça foire, la vanne ne devrait pas s'ouvrir !
S'éteint au bout de 5 seconde
relaisOuverture qui s'active
S'éteint au bout de 5 seconde
etc etc...
Je place le capteur en position LOW
relaisOuverture qui s'éteint au bout de 5 seconde
relaisFermeture qui s'allume
S'éteint au bout de 5 seconde
Programme en pause
Et repète la boucle sans soucis ! c'est juste que le programme tourne en boucle quand le capteur est soulevé par l'eau et par la suite il ferme la vanne, il la r'ouvre etc et etc...
Si je passe le capteur en LOW il ferme la vanne et colture la boucle jusqu'à que je passe le capteur en HIGH pour simuler un débordement.
