Aide PCB, Imp.3D (Projet Arrosage Semi auto ESP32)

Bonjour à tous,

Je travaille sur un projet d’arrosage automatisé semi-manuel basé sur un ESP32 Wrover (uPesy DevKit v2.1).
L’objectif est d’actionner une pompe pour arroser manuellement plusieurs pots via des boutons poussoirs, tout en affichant les données sur un écran LCD.

:wrench: Matériel utilisé et leur utilité

  • ESP32 Wrover DevKit v2.1 → Cœur du projet, gère l’affichage, la lecture des boutons, et l’activation de la pompe (Modèle uPesy)
  • Écran LCD 20x4 I2C (Adafruit LiquidCrystal) → Affichage des informations (quantité d’eau écoulée, date du dernier arrosage, état du système)
  • Pompe submersible 12V 40W 3000L/H (Modèle Amazon) → Fournit l’eau aux plantes
  • Relais 10A 250V/AC → Alimentation de la pompe, Active/Désactive la pompe
  • Capteur de débit d’eau YF-S201 → Mesure le débit et la quantité d’eau écoulée
  • Boutons poussoirs (x3) :
    • Bouton 1 ("500mL") → Active la pompe pour délivrer 500mL d’eau
    • Bouton 2 ("ON") → Active la pompe en continu
    • Bouton 3 ("OFF") → Arrête la pompe immédiatement
  • LEDs d’indication :
    • Jaune (GPIO 17) → Pompe active via bouton 500mL
    • Verte (GPIO 5) → Pompe active via bouton ON
    • Rouge (GPIO 18) → Indique une erreur (ex : débitmètre défectueux)
  • Résistances 330Ω → Limitation du courant pour les LEDs

:bullseye: But du projet

  • Lancer l’arrosage via des boutons physiques (pas de cycle automatique)
  • Afficher en direct le débit et la quantité d’eau écoulée sur l’écran LCD
  • Sauvegarder la date et la quantité d’eau versée pour chaque pot (stockage prévu, mais actuellement sans carte SD) (c'est une partie qui peut être supprimée du code)
  • Possibilité de remettre à zéro la quantité d’eau versée via une combinaison de boutons

:light_bulb: Demande d’aide

  1. Câblage :
  • Mon Relais 10A 250V/AC est-il correct pour alimenter la pompe ?
  • Le capteur de débit doit-il être branché sur une entrée analogique ou digitale sur l’ESP32 ?
  • Dois-je ajouter des diodes de protection ou d’autres composants pour éviter d’endommager l’ESP32 ?
  1. Simulation sur Tinkercad :
  • Certains composants (ESP32 Wrover, capteur de débit, relais 10A) ne sont pas disponibles. Comment les ajouter ou par quoi les remplacer pour la simulation ?
  • Où trouver les informations détaillées (fichiers JSON, modèles 3D, ou bibliothèques) pour les intégrer à Tinkercad ?
  1. Alternative ESP32 :
  • J'ai un Elegoo UNO R3 venant de ce kit. Il est peut être plus judicieux de l'utiliser, ou d'autre élément de ce kit (Modèle Amazon)
  1. Un coup d'oeil au code
  • Pas d'erreur visible sur PlatformIO via VSCode

:scroll: Code du projet :

#include <Arduino.h>
#include <Wire.h>
#include <Adafruit_LiquidCrystal.h>
#include <RTClib.h>

// Pinout des boutons et LED
const int button500Pin = 15;   // Bouton pour 500 mL
const int buttonOnPin = 2;     // Bouton ON
const int buttonOffPin = 4;    // Bouton OFF
const int pumpPin = 16;        // Relais pour pompe
const int yellowLEDPin = 17;   // LED jaune
const int greenLEDPin = 5;     // LED verte
const int redLEDPin = 18;      // LED rouge

// Capteur de débit
const int flowSensorPin = 21;  // Capteur de débit
volatile int flowPulseCount = 0;
float calibrationFactor = 4.5; // Ajustez en fonction de votre capteur

// LCD I2C
Adafruit_LiquidCrystal lcd(0);

// RTC
RTC_DS3231 rtc;

// Variables globales
float totalFlow = 0; // Total d'eau écoulée dans la session actuelle

// Prototypes de fonctions
void startPumpForVolume(float volume);
void startPumpManual();
void stopPump();
void calculateFlowRate();
void displayFlowData();
void handleButtonPresses();

// Interruption pour le capteur de débit
void IRAM_ATTR flowPulseCounter() {
    flowPulseCount++;
}

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

    // Initialisation des broches
    pinMode(button500Pin, INPUT_PULLUP);
    pinMode(buttonOnPin, INPUT_PULLUP);
    pinMode(buttonOffPin, INPUT_PULLUP);
    pinMode(pumpPin, OUTPUT);
    pinMode(yellowLEDPin, OUTPUT);
    pinMode(greenLEDPin, OUTPUT);
    pinMode(redLEDPin, OUTPUT);

    // Pompe et LED éteintes au démarrage
    digitalWrite(pumpPin, LOW);
    digitalWrite(yellowLEDPin, LOW);
    digitalWrite(greenLEDPin, LOW);
    digitalWrite(redLEDPin, LOW);

    // Initialisation LCD
    lcd.begin(20, 4);
    lcd.setBacklight(1);
    lcd.setCursor(0, 0);
    lcd.print("Systeme d'arrosage");
    delay(2000);

    // Initialisation RTC
    if (!rtc.begin()) {
        lcd.setCursor(0, 1);
        lcd.print("Erreur RTC !");
        digitalWrite(redLEDPin, HIGH);
        while (1);
    }

    // Initialisation capteur de débit
    attachInterrupt(digitalPinToInterrupt(flowSensorPin), flowPulseCounter, RISING);
}

void loop() {
    handleButtonPresses();
    calculateFlowRate();
    displayFlowData();
}

void handleButtonPresses() {
    if (digitalRead(button500Pin) == LOW) {
        digitalWrite(yellowLEDPin, HIGH);
        startPumpForVolume(500);
        digitalWrite(yellowLEDPin, LOW);
    } else if (digitalRead(buttonOnPin) == LOW) {
        digitalWrite(greenLEDPin, HIGH);
        startPumpManual();
    } else if (digitalRead(buttonOffPin) == LOW) {
        stopPump();
        digitalWrite(greenLEDPin, LOW);
    }
}

void startPumpForVolume(float volume) {
    totalFlow = 0;
    digitalWrite(pumpPin, HIGH);
    while (totalFlow < volume) {
        calculateFlowRate();
        displayFlowData();
    }
    stopPump();
}

void startPumpManual() {
    digitalWrite(pumpPin, HIGH);
}

void stopPump() {
    digitalWrite(pumpPin, LOW);
    lcd.setCursor(0, 3);
    lcd.print("Pompe stoppee     ");
}

void calculateFlowRate() {
    static unsigned long previousMillis = 0;
    unsigned long currentMillis = millis();

    if (currentMillis - previousMillis >= 1000) {
        previousMillis = currentMillis;
        float flowRate = (flowPulseCount / calibrationFactor); // L/min
        flowPulseCount = 0;

        float flowInMilliliters = (flowRate / 60.0) * 1000.0; // mL/s
        totalFlow += flowInMilliliters;
    }
}

void displayFlowData() {
    lcd.setCursor(0, 1);
    lcd.print("Debit: ");
    lcd.print(totalFlow);
    lcd.print(" mL      ");

    DateTime now = rtc.now();
    lcd.setCursor(0, 2);
    lcd.print("Dernier: ");
    lcd.print(now.timestamp(DateTime::TIMESTAMP_DATE));
}
  • Voici les librairies utilisées :
adafruit/Adafruit LiquidCrystal@^2.0.4
adafruit/RTClib@^2.1.4

Merci pour vos conseils et coup de main pour mon projet, je ne suis qu'un débutant dans le domaine, internet et des heures de test font ma formation :blush: merci pour l'indulgence :blush:

est-il pilotable en 3.3V ?

ça dépend du modèle. Vous avez la datasheet ?

Il faut s'assurer que le relai est capable de piloter une charge inductive mais la pompe a l'air d'être intégrée et protégée. (produit commercial fini)

A mon avis il vaut mieux viser le montage "en vrai"..

est-il pilotable en 3.3V ?

Il me semble oui, c'est le modèle HW 482

ça dépend du modèle. Vous avez la datasheet ?

Je crois que j'ai ma réponse dans le doc :
yf-s402 - datasheet.pdf (54,3 Ko)

A mon avis il vaut mieux viser le montage "en vrai"..

Yep j'imagine, mais j'avoue que je suis perdu un peu pour le montage et je me suis dis qu'avec un logiciel comme TinkerCad ça allait m'aider à le faire/comprendre/ et pas tout cramer

En tout cas merci pour votre retour :pray:

la référence semble en 5V si j'en crois ce lien

oui donc c'est un signal numérique.


Pour le montage il faut y aller doucement, par exemple vous ne mettez pas la pompe derrière le relai pour rester en courant faibles dans un premier temps.

le capteur de débit est un générateur de fréquence, il envoit X pulses par litre, le X en question est indiqué dans la doc du composant.

Donc dans l'idée, si tu es un as du codage, tu peux éventuellement crée un générateur de fréquence, avec un ESP32, juste pour ton simulateur, et tu le "câble" sur TinkerCad pour simuler le capteur de débit qui envoit ses pulses.

En ce moment, je cogite sur un "générateur de fréquence et rapport cyclique variables" avec un ESP32, mon petit truc marche et je m'en sers pour piloter un moteur.

Toi, le rapport cyclique, tu t'en fous tu n'a pas besoin qu'il varie.

Je peux te mettre ça sur TinkerCad.

Mais je crains que ce simulateur ait du mal à faire tourner en même temps 2 codes

Bonjour à tous,

Déjà merci pour les infos précédentes.
Voici mon projet terminé, ce n’est que le prototype,
Je vous donne le code (platformIO) ainsi que les schémas que j’ai faits via Fritzing.
Je suis preneur de tout avis et conseil

#include <Arduino.h>
#include <Wire.h>
#include <LiquidCrystal_I2C.h>

// Définition des broches
#define POMPE_RELAIS_ARRIVEE 27
#define POMPE_RELAIS_EVACUATION 14
#define BOUTON_ARROSAGE_AUTO 32
#define BOUTON_ARROSAGE_MANUEL 33
#define BOUTON_EVACUATION 25
#define BOUTON_RESET 26
#define DEBITMETRE 19

// Initialisation de l'écran LCD
LiquidCrystal_I2C lcd(0x27, 20, 4);

// Variables globales
volatile int pulses = 0;
float volumeEau = 0.0;
bool modeAuto = false;
bool modeManuel = false;
bool modeEvacuation = false;
bool etatPompeArrosage = false;
bool etatPompeEvacuation = false;
float quantiteVoulu = 100.0; // Exemple : 500mL
const float FACTEUR_CALIBRATION = 4.5; // Ajuster selon le capteur
float dernierVolumeEau = -1;
bool dernierEtatPompeArrosage = false;
bool dernierEtatPompeEvacuation = false;
bool dernierModeAuto = false;
bool dernierModeManuel = false;
bool dernierModeEvacuation = false;

// Gestion du débitmètre
void IRAM_ATTR compteurDebit() {
    pulses++; // Incrémentation des impulsions
}

// Affichage sur LCD sans scintillement
void afficherEtat() {
    bool miseAJourNecessaire = false;

    if (volumeEau != dernierVolumeEau) {
        lcd.setCursor(5, 1);
        lcd.print("         ");  // Effacer avant d'écrire la nouvelle valeur
        lcd.setCursor(5, 1);
        lcd.print(volumeEau, 2);
        lcd.print(" mL");

        dernierVolumeEau = volumeEau;
        miseAJourNecessaire = true;
    }

    if (etatPompeArrosage != dernierEtatPompeArrosage || etatPompeEvacuation != dernierEtatPompeEvacuation) {
        lcd.setCursor(0, 2);
        lcd.print("                    "); // Effacer toute la ligne avant d'afficher
    if (modeEvacuation) {
         lcd.setCursor(0, 2);
         lcd.print("Pompe evac: ");
         lcd.print(etatPompeEvacuation ? "ON " : "OFF");
}   else {
        lcd.setCursor(0, 2);
         lcd.print("Pompe arrosage: ");
         lcd.print(etatPompeArrosage ? "ON " : "OFF");
}
        dernierEtatPompeArrosage = etatPompeArrosage;
        dernierEtatPompeEvacuation = etatPompeEvacuation;
        miseAJourNecessaire = true;
    }

    if (modeAuto != dernierModeAuto || modeManuel != dernierModeManuel || modeEvacuation != dernierModeEvacuation) {
        lcd.setCursor(0, 3);
        if (modeAuto)
            lcd.print("Mode : Automatique");
        else if (modeManuel)
            lcd.print("Mode : Manuel     ");
        else if (modeEvacuation)
            lcd.print("Mode : Evacuation ");
        else
            lcd.print("Mode : En attente");
        dernierModeAuto = modeAuto;
        dernierModeManuel = modeManuel;
        dernierModeEvacuation = modeEvacuation;
        miseAJourNecessaire = true;
    }
}

void setup() {
    Serial.begin(115200);
    lcd.init();
    lcd.backlight();
    
    pinMode(POMPE_RELAIS_ARRIVEE, OUTPUT);
    pinMode(POMPE_RELAIS_EVACUATION, OUTPUT);
    pinMode(BOUTON_ARROSAGE_AUTO, INPUT_PULLUP);
    pinMode(BOUTON_ARROSAGE_MANUEL, INPUT_PULLUP);
    pinMode(BOUTON_EVACUATION, INPUT_PULLUP);
    pinMode(BOUTON_RESET, INPUT_PULLUP);
    pinMode(DEBITMETRE, INPUT);
    
    attachInterrupt(digitalPinToInterrupt(DEBITMETRE), compteurDebit, RISING);
    
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print(quantiteVoulu, 2);
    lcd.print("mL");
    lcd.setCursor(0, 1);
    lcd.print("Eau: 0.00 mL");
    lcd.setCursor(0, 2);
    lcd.print("Pompe arrosage: ");
    lcd.setCursor(0, 3);
    lcd.print("Mode : En attente ");
}

void loop() {
    volumeEau = pulses / FACTEUR_CALIBRATION; // Conversion des impulsions en volume
    afficherEtat();

    if (digitalRead(BOUTON_RESET) == LOW) {
        volumeEau = 0;
        pulses = 0;
        modeAuto = false;
        modeManuel = false;
        modeEvacuation = false;
        etatPompeArrosage = false;
        etatPompeEvacuation = false;
        digitalWrite(POMPE_RELAIS_ARRIVEE, LOW);
        digitalWrite(POMPE_RELAIS_EVACUATION, LOW);
        afficherEtat();
        delay(500);
    }

    if (!modeManuel && digitalRead(BOUTON_ARROSAGE_AUTO) == LOW) {
        modeAuto = !modeAuto;
        modeEvacuation = false;
        etatPompeArrosage = modeAuto;
        digitalWrite(POMPE_RELAIS_ARRIVEE, etatPompeArrosage ? HIGH : LOW);
        afficherEtat();
        delay(500);
    }

    if (!modeAuto && digitalRead(BOUTON_ARROSAGE_MANUEL) == LOW) {
        modeManuel = !modeManuel;
        modeEvacuation = false;
        etatPompeArrosage = modeManuel;
        digitalWrite(POMPE_RELAIS_ARRIVEE, etatPompeArrosage ? HIGH : LOW);
        afficherEtat();
        delay(500);
    }

    if (digitalRead(BOUTON_EVACUATION) == LOW) {
        modeEvacuation = !modeEvacuation;
        modeAuto = false;
        modeManuel = false;
        etatPompeEvacuation = modeEvacuation;
        digitalWrite(POMPE_RELAIS_EVACUATION, etatPompeEvacuation ? HIGH : LOW);
        afficherEtat();
        delay(500);
    }

    if (modeAuto && etatPompeArrosage && volumeEau >= quantiteVoulu) {
        etatPompeArrosage = false;
        digitalWrite(POMPE_RELAIS_ARRIVEE, LOW);
        afficherEtat();
    }
}


Me voilà au point de la conception finale … et là je ne sais pas trop comment faire.

  • Auriez-vous des suggestions ?
  • Des raccords pour faciliter le câblage des pompes ?
  • Fabrication de PCB (je n’y arrive pas avec JLC et EasyEDA)
  • Des idées de boitiers pour impression 3D (je n’ai ni les logiciels, ni les compétences en dessin)

Enfin je suis un peu perdu pour cette partie finale. J’ai besoin de conseils

Merci à vous !!!

J’ai lu qu’il existait un module pour le simulateur Wokwi pour le couple vscode-platformIO.
C’est une information. Je n’ai jamais utilisé, ni même installé.

Jlcpcb et easyeda sont la même société, ce devrait etre simple.
Ce n’est pas plutôt le mécanisme général de la conception de circuit imprimé qui te pose problème ?
Il est vrai que ce n’est pas simple. Il faut commencer l’apprentissage avec des tutos très simples et ne pas chercher a aller plus vite que la musique.

Merci pour ton retour, en effet c’est plutôt la généralité de la conception finale qui bloque.
Le proto est là et fonctionnel, j’ai récupéré une plaque pour faire les soudures moi-même si il faut, vu la simplicité du projet je pense que c’est jouable.

Je pense faire un seul « boitier » comprenant la partie électronique et la gestion
Sachant que sur la plaque il n’y aura pas grand-chose de fixe ;

  • Les boutons seront « volant » pour être posés sur le boitier (je ne vais pas utiliser ceux présent sur la photo)
  • De même pour l’écran LCD
  • Le débitmètre sera lui à l’extérieur (au niveau des manipulations des vannes)

Je me demande si il y a des accessoires de plugins pour faciliter le montage et démontage, pour par exemple, déconnecter les 2 pompes et le débitmètre.

Je nage un peu :smile:

PS: bon effectivement il y a beaucoup de pont et de long chemin sur la breadboard mais c'était pour une meilleur visibilité perso du prototype.


Il y a le choix :grinning:
https://fr.aliexpress.com/w/wholesale-PCB-connecteurs.html?g=y&SearchText=PCB+connecteurs

Mais il faut préciser :

  • connecteur à combien de fils ? → 2, 3 4

  • un contact à visser serait-il possible ? C'est vraiment le plus simple.

  • quel courant passe dans les contects ?

Note :

Ton câblage est très bien.
Des fils à plat, des fils immobilisés, pas de filasse Dupont, disposée en vrac qui fait perchoir à mouche : c'est exactement ce qu'il faut.

Ton câblage définitif est quasiment défini.

Je reconnais la plaque sous l'emballage, en activité j'avais les mêmes : probablement provenance RS à 10 fois le prix de l'équivalent sur Ali.

idem, marque Veroboard :wink:

Les seules cartes RS que je regretterais si j'en avais encore l'utilité sont les cartes pastillées double-face et dont une face contient un plan de masse.

Le plan de masse est un peu du gruyère avec tous les trous pour les pastilles, mais quand la fréquence augmente, c'est bien efficace.

Il m'en reste une au fond d'un tiroir, je la garde précieusement pour le cas où.......

Merci pour vos retours !!!

Ton câblage est très bien.
Des fils à plat, des fils immobilisés, pas de filasse Dupont, disposée en vrac qui fait perchoir à mouche : c'est exactement ce qu'il faut.
Ton câblage définitif est quasiment défini.

Est ce que je peux le garder comme ça pour l'utilisation ou c'est préférable de faire un PCB définitif ?

Je reconnais la plaque sous l'emballage, en activité j'avais les mêmes : probablement provenance RS à 10 fois le prix de l'équivalent sur Ali.

Je l'ai prise au travail et effectivement les connaissants ils ont dû acheter ça sur RS.
A défaut de faire un PCB je peux utiliser cette plaque et mes fils de connexions du proto ?
Bien sur en les soudant.

Parfaitement si cela fonctionne et que c'est soudé..

Nous sommes un certain nombre ici à utiliser ces cartes pastillées.

Petits trucs :
Si tu as des résistances à souder, ou des condensateurs, plutôt que de choisir des modèles antédiluviens avec des longues pattes, tu peux utiliser des CMS.
Par exemple pour le modèle CMS (smd) 0805 :
08 est la longueur en 1/100 d'inches. Soit 8 x 0,254 = 2 mm
05 est la largeur. Soit 5 x 0,254 = 1,27 mm
Je te dis ça parce qu'un format 0805 se câble très facilement entre deux pastilles disposées sur la grille à 2,54 mm

Pour les composants que tu voudrais récupérer ou sur lesquels tu as des craintes et que tu voudrais pouvoir changer facilement, il existe d'autres connecteurs que ceux qui sont livrés avec les modèles.

Barettes à tige carrée livrées :

Couples de barrettes mâles et femelle plus fines :


C'est un peu plus haut qu'avec les barettes livrées, mais c'est démontable.

Mes 5 cts.

Merci pour ces infos et le détails de ces composants,

J'ai une nouvelle question, peut être un peu bête ... comme la soudure électronique ce n'est pas du tout mon domaine, je ne voudrai pas faire n'importe quoi.

Je vais essayer d'être clair :grimacing:

Donc si je comprend bien je peux faire le même type de "câblage" (je sais pas si c'est le bon therme en électronique) mais sur ma carte pastillée Vero. En utilisant les câble de ponts du proto et autres barrettes à tige par exemple pour les relais.
Cela évite de faire une carte PCB en micro imprimé

La côté pratique des breadboards c'est les lignes de liaisons sur plusieurs pin (les GDN et VCC par exemple).
Comme on peut voir sur ma photo je les utilises (j'ai stabiloté quelques endroits). Mais sur la Vero il y en a pas. Comment les faire ? par cordon de soudure ? des barrettes spécifiques ?

Je retourne éplucher YouTube pour voir les différentes techniques (j'y trouverai peut être ma réponse en attendant votre retour. ) :smile:

Encore une fois merci :pray:

bonjour
sur alli on trouve des cartes pastillées avec lignes de vcc et gnd en plus le tracé permet en optimisant de gagner en liaison filaires

gros defaut la qualité plus que merdique de la backelite .. avantage un trait de cutter de chaque coté on plie et ca se decoupe

meilleuer qualité moins pratique

copie de la planche a pain ... :grinning:

Je fais le reproche de ne pas avoir des pastilles recto/verso


Qui dit pastilles recto/verso dit trou métallisé.

C'est important, surtout quand on débute, d'avoir des trous métallisés, car les pastilles (et les pistes quand il y en a) ne sont que collées sur le support epoxy.
Si on tremble un peu trop pendant l'opération de soudage, les pastilles peuvent se décoller.
Si elles sont recto/verso, elles sont renforcées mécaniquement par la métallisation du trou.

Sinon, plutôt que de chercher la bonne carte pastillé, pourquoi ne pas la dessiner sois même ?

Avec des logiciels comme easyEDA le dessin est très facile, et pour une quinzaines de plaque c'est tout a fait rentable...

Merci pour toutes ces infos,

J’ai préparé ma plaque, je pense que je suis OK pour les soudures.



J’ajouterais ensuite des raccords pour pouvoir pluguer facilement l’ESP et la sortie des relais.

Quand on n’a qu’un exemplaire a réaliser, qui plus est très simple, pourquoi utiliser un marteau pilon pour enfoncer une punaise ?

Je comprends bien le dicton mais ici ?
Je me complique trop ?