Projet d'automatisation de renouvellement d'eau pour aquarium

J-M-L · February 22, 2022, 4:49pm

while ça veut dire "tant que"

donc vous dites "tant que l'eau est à moins de 4cm continuer la boucle"..

comme vous commencez à 12cm on ne va pas du tout rentrer dans la boucle

il faudrait dire "tant que l'eau est à plus de 4cm continuer la boucle"..

fishton · February 22, 2022, 4:56pm

je ne sais pas pourquoi je l'ai interprété à l'envers ... Je vais tester le code sur le terrain.

const byte trig = 2; //HC-SR04
const byte inwater = 4; //pin relais remplissage
const byte outwater = 5; //pin relais vidange
const byte bouton = 13; //pin bouton poussoir momentané

long lireDistanceCm() {
  digitalWrite(trig, HIGH);
  delayMicroseconds(10);
  digitalWrite(trig, LOW);
  return pulseIn(echo, HIGH) / 58;
}

void setup() {
  Serial.begin(115200); // 9600 c'était au millénaire précédent
  pinMode(inwater, OUTPUT);
  pinMode(outwater, OUTPUT);
  pinMode(bouton, INPUT_PULLUP);
  Serial.println(F("Système prêt"));
}

void loop() {
  if (digitalRead(bouton) == LOW) { //appui
    digitalWrite(outwater, HIGH); // déclenche la vidange
    long cm;
    do {
      cm = lireDistanceCm();
      Serial.print("Distance en cm :"); Serial.println(cm);
      delay(1000);  // attention c'est bloquant 1s
    } while (cm > 12) ;

    // ici on a atteint les 12cm
    digitalWrite(outwater, LOW); // fin de vidange
    
  }
    digitalWrite(intwater, HIGH); // déclenche le remplissage
    long cm;
  do {
      cm = lireDistanceCm();
      Serial.print("Distance en cm :"); Serial.println(cm);
      delay(1000);  // attention c'est bloquant 1s
    } while (cm > 3) ;

    // ici on a atteint les 3cm
    digitalWrite(inwater, LOW); // fin du remplissage

    // on attend la relâche du bouton
    while (digitalRead(bouton) == LOW) ; 
    delay(200);
  }
}

hbachetti · February 22, 2022, 5:00pm

C'est mieux, mais attention tes relais peuvent très bien fonctionner à l'envers.

  pinMode(outwater, OUTPUT);

Si le relais colle au setup(), c'est que c'est un relais activable avec un niveau LOW.
sinon :

  pinMode(outwater, OUTPUT);
  digitalWrite(outwater, HIGH);

Et il faut inverser la logique.

J-M-L · February 22, 2022, 5:46pm

attention il manque des trucs. echo n'est pas définie et surtout vous ne voulez faire le remplissage QUE si vous avez vidé. ➜ attention où vous mettez les accolades.

const byte ACTIF = LOW;
const byte INACTIF = HIGH; // ou (1 - ACTIF) si on veut frimer mais ce n'est pas super propre

const byte trig = 2; //HC-SR04
const byte echo = 3;
const byte inwater = 4; //pin relais remplissage
const byte outwater = 5; //pin relais vidange
const byte bouton = 13; //pin bouton poussoir momentané


long lireDistanceCm() {
  digitalWrite(trig, HIGH);
  delayMicroseconds(10);
  digitalWrite(trig, LOW);
  return pulseIn(echo, HIGH) / 58;
}

void setup() {
  pinMode(trig, OUTPUT);
  pinMode(inwater, OUTPUT);   digitalWrite(inwater, INACTIF);
  pinMode(outwater, OUTPUT);  digitalWrite(outwater, INACTIF);
  pinMode(bouton, INPUT_PULLUP);
  Serial.begin(115200); // 9600 c'était au millénaire précédent
  Serial.println(F("Système prêt"));
}

void loop() {
  if (digitalRead(bouton) == LOW) { //appui

    // *************  VIDANGE **************
    digitalWrite(outwater, ACTIF); // déclenche la vidange
    long cm;
    do {
      cm = lireDistanceCm();
      Serial.print("Distance en cm :"); Serial.println(cm);
      delay(1000);  // attention c'est bloquant 1s
    } while (cm < 12) ;
    digitalWrite(outwater, INACTIF); // fin de vidange
    // *************************************

    // ***********  REMPLISSAGE ************
    digitalWrite(inwater, ACTIF); // déclenche le remplissage
    do {
      cm = lireDistanceCm();
      Serial.print("Distance en cm :"); Serial.println(cm);
      delay(1000);  // attention c'est bloquant 1s
    } while (cm > 3) ;
    digitalWrite(inwater, INACTIF); // fin du remplissage
    // ********************************

    // on attend la relâche du bouton
    while (digitalRead(bouton) == LOW) ;
    delay(200);
  }
}

on peut mettre en début de code

const byte ACTIF = LOW;
const byte INACTIF = HIGH; // ou (1 - ACTIF) si on veut frimer mais ce n'est pas super propre

et ajuster à la bonne valeur selon les relais. dans le code on utilise alors ACTIF et INACTIF

PS: je m'étais trompé moi aussi sur < 12 pour la vidange

fishton · February 22, 2022, 6:31pm

Ca me rassure un peu alors ^^
Je viens de tester le code en serial j'obtiens ca en retour d'info:

contrairement au test que j'avais fait la première fois avec ce code:

int trig = 2;
int echo = 3;
long lecture_echo;
long cm;

void setup(){

pinMode(trig, OUTPUT);
digitalWrite(trig, LOW);
pinMode(echo, INPUT);
Serial.begin(9600);

}

void loop(){

digitalWrite(trig, HIGH);
delayMicroseconds(10);
digitalWrite(trig, LOW);
lecture_echo = pulseIn(echo,HIGH);
cm = lecture_echo /58;
Serial.print("Distance en cm :");
Serial.println(cm);
delay(1500);
}

Ou la les valeurs sont cohérentes:

J-M-L · February 22, 2022, 6:36pm

il manque le

pinMode(trig, OUTPUT);

dans les setup()

vérifiez que tout fonctionne avec

const byte trig = 2; //HC-SR04
const byte echo = 3;

long lireDistanceCm() {
  digitalWrite(trig, HIGH);
  delayMicroseconds(10);
  digitalWrite(trig, LOW);
  return pulseIn(echo, HIGH) / 58;
}

void setup() {
  pinMode(trig, OUTPUT);
  Serial.begin(115200); // 9600 c'était au millénaire précédent
  Serial.println(F("Système prêt"));
}

void loop() {
  long cm = lireDistanceCm();
  Serial.print("Distance en cm :"); Serial.println(cm);
  delay(1000);
}

fishton · February 22, 2022, 6:38pm

Oui la ca fonctionne !

J-M-L · February 22, 2022, 6:41pm

OK

un bon début donc !

fishton · February 22, 2022, 6:54pm

je teste le code et en profite pour faire un changement d'eau de l'aquarium pour l'instant ca vidange, jusqu'ici tout va bien, j'arrive bientôt à la consigne de remplissage.
Ca ma permis de voir que la sonde ultrason n'était pas forcément bien placé car elle se trouve dans le rejet de la pompe ce qui peut fausser la mesure.

fishton · February 22, 2022, 7:13pm

Ca marche parfaitement le seul hic c'est qu'il manque de précision, pour avoir le niveau haut parfait il me faudrait 1.5cm, l'idéal serait de passer en mm pour affiner.

fishton · February 22, 2022, 7:30pm

ca devrait être plus précis comme ça

const byte ACTIF = LOW;
const byte INACTIF = HIGH; // ou (1 - ACTIF) si on veut frimer mais ce n'est pas super propre

const byte trig = 2; //HC-SR04
const byte echo = 3;
const byte inwater = 4; //pin relais remplissage
const byte outwater = 5; //pin relais vidange
const byte bouton = 13; //pin bouton poussoir momentané


long lireDistanceEnmm() {
  digitalWrite(trig, HIGH);
  delayMicroseconds(10);
  digitalWrite(trig, LOW);
  return pulseIn(echo, HIGH) / 0.58;
}

void setup() {
  pinMode(trig, OUTPUT);
  pinMode(inwater, OUTPUT);   digitalWrite(inwater, INACTIF);
  pinMode(outwater, OUTPUT);  digitalWrite(outwater, INACTIF);
  pinMode(bouton, INPUT_PULLUP);
  Serial.begin(115200);
  Serial.println(F("Système prêt"));
}

void loop() {
long mm;
  if (digitalRead(bouton) == LOW) { //appui

    // *************  VIDANGE **************
    digitalWrite(outwater, ACTIF); // déclenche la vidange
    do {
      mm = lireDistanceEnmm();
      Serial.print("Distance en mm :"); Serial.println(mm);
      delay(1000);  // attention c'est bloquant 1s
    } while (mm < 110) ;
    digitalWrite(outwater, INACTIF); // fin de vidange
    // *************************************

    // ***********  REMPLISSAGE ************
    digitalWrite(inwater, ACTIF); // déclenche le remplissage
    do {
      mm = lireDistanceEnmm();
      Serial.print("Distance en mm :"); Serial.println(mm);
      delay(1000);  // attention c'est bloquant 1s
    } while (mm > 15) ;
    digitalWrite(inwater, INACTIF); // fin du remplissage
    // ********************************

    // on attend la relâche du bouton
    while (digitalRead(bouton) == LOW) ;
    delay(200);
  }
}

J-M-L · February 22, 2022, 8:09pm

Faudrait retourner un float même

fishton · February 22, 2022, 8:24pm

Yes la pour le moment al bidouille que j'ai faite fonctionne en entier mais c'est vrais que ce n'est pas conventionnel

J-M-L · February 22, 2022, 9:04pm

Je ne sais pas si le capteur est précis au mm de toutes façon

hbachetti · February 23, 2022, 9:16am

Le HC-SR04 mesure une distance minimale de 2cm

Il faut peut-être arrêter la pompe pendant le renouvellement ?

fishton · February 24, 2022, 11:38am

hello,
j'ai déplacé la sonde c'est bien mieux, elle est un plus moins proche du niveau max donc plus haute, elle est plus précise.
La sonde n'est pas précise au millimètre mais au 1/2 cm oui et même un petit peu plus, j'ai fait quelques tests.
Effectivement mettre l'alimentation à l'arrêt pendant le cycle améliorera la précision, je vais la câbler sur un relais en position normalement ouvert et l'arrêterai pendant le cycle de remplissage.

fishton · February 24, 2022, 11:43am

Je viens de modifier le code, en ajoutant un flotteur pour le niveau (une sécurité en cas de dysfonctionnement de la sonde) et l'arrêt de la pompe.

j'ai un doute sur le setup du flotteur INPUT_PULLUP est-ce ok dans ce cas également ?
Je ne connais pas la syntaxe exacte pour faire un OR dans le while de la boucle REMPLISSAGE:
} while (mm > 30) or ((digitalRead(flotteur) == LOW); //arrêt dés que 30 mm ou le flotteur est actionné

const byte ACTIF = LOW;
const byte INACTIF = HIGH; 

const byte trig = 2; //HC-SR04
const byte echo = 3;
const byte inwater = 4; //pin relais remplissage
const byte outwater = 5; //pin relais vidange
const byte pompe = 6; //pin relais arrêt pompe
const byte flotteur = 12; //pin flotteur niveau eau (sécutité en cas de défaillance de la sonde HC-SR04)
const byte bouton = 13; //pin bouton poussoir momentané


long lireDistanceEnmm() {
  digitalWrite(trig, HIGH);
  delayMicroseconds(10);
  digitalWrite(trig, LOW);
  return pulseIn(echo, HIGH) / 5.8;
}

void setup() {
  pinMode(trig, OUTPUT);
  pinMode(inwater, OUTPUT);   digitalWrite(inwater, INACTIF);
  pinMode(outwater, OUTPUT);  digitalWrite(outwater, INACTIF);
  pinMode(pompe, OUTPUT);  digitalWrite(pompe, INACTIF);
  pinMode(flotteur, INPUT_PULLUP);
  pinMode(bouton, INPUT_PULLUP);
  Serial.begin(115200);
  Serial.println(F("Système prêt"));
}

void loop() {
long mm;
  if (digitalRead(bouton) == LOW) { //appui

    // ************* VIDANGE **************
    digitalWrite(outwater, ACTIF); // déclenche la vidange
    do {
      mm = lireDistanceEnmm();
      Serial.print("Distance en mm :"); Serial.println(mm);
      delay(1000);  // attention c'est bloquant 1s
    } while (mm < 110) ;
    digitalWrite(outwater, INACTIF); // fin de vidange
    // *************************************

    // *************ARRET POMPE **************
    digitalWrite(pompe, ACTIF);
    //*************************************

    // ***********  REMPLISSAGE ************
    digitalWrite(inwater, ACTIF); // déclenche le remplissage
    do {
      mm = lireDistanceEnmm();
      Serial.print("Distance en mm :"); Serial.println(mm);
      delay(1000);  // attention c'est bloquant 1s
    } while (mm > 30) or ((digitalRead(flotteur) == LOW); //arrêt dés que 30 mm ou le flotteur est actionné
    digitalWrite(inwater, INACTIF); // fin du remplissage
    // ********************************

    // *************MISE EN ROUTE POMPE **************
    digitalWrite(pompe, INACTIF);
    //************************************************

    // on attend la relâche du bouton
    while (digitalRead(bouton) == LOW) ;
    delay(200);
  }
}

hbachetti · February 24, 2022, 11:45am

J'utiliserais plutôt le contact Normalement Fermé d'un relais, ainsi tu n'auras pas à alimenter la bobine en fonctionnement normal, mais seulement pendant le renouvellement d'eau.

fishton · February 24, 2022, 11:45am

oui erreur de ma part

hbachetti · February 24, 2022, 11:51am

Avec flotteur câblé entre entrée et GND c'est OK.

OR en C s'écrit ||, mais tu as besoin d'un AND
//remplir jusqu'à 30 mm ET flotteur non actionné
Plutôt :

Ici l'image d'un flotteur actionné (réservoir d'eau) :

Remarque que le flotteur (ILS) est actionné alors qu'il est environ à 40°. Il faut faire des tests.

Topic		Replies	Views
Projet - Gestion eau aquarium Français	68	33765	May 6, 2021
TPE : Connaitre sa consommation d'eau lors d'une douche Français	40	7160	May 6, 2021
calcul consommation/récupération eau Français	20	2974	May 6, 2021
domotisation cuve 1000L - modif mysensors Français	29	2315	May 6, 2021
changement d eau automatique par capteur de debit Français	7	1773	May 6, 2021

Projet d'automatisation de renouvellement d'eau pour aquarium

Related topics