problème pilotage relais.

bonjour à tous,

je me suis en tête de monter un projet avec mon aduino UNO.

j'ai une carte à deux relais, le relais 1 pilote une pompe de brassage, le relais 2 pilote une pompe doseuse.

donc dans mon idée, à la base, je voulais que pendant 1 minute, la pompe de brassage s'active, qu'au bout de X seconde que la pompe doseuse se mettent en route pendant X temps. Et qu'une fois tout ça fini, attendre 30 minutes.

malheureusement je n'ai pas réussi à trouver les bouts de code pour faire.

du coup je me suis rabattu sur une autre stratégie, le relais 1 active la pompe de brassage pendant 1 minute puis la met en pause pendant 30 minutes.

et de l'autre coté, dès que la pompe de brassage, la pompe doseuse se met en route pendant x seconde.

j'ai donc bidouillé ce code :

// constantes et variables 
const int LED = 13;    //   LED du pin 13
const int RELAY1 = 2;  // pin 2 commande la pompe de brassage
const int RELAY2 = 3;  // pin 3 commande la pompe doseuse

// mise sous tension

void setup(){                        
 pinMode (LED, OUTPUT);    // pin 13 est une sortie digitale
 pinMode (RELAY1, OUTPUT); //  pin 2 commande la pompe de brassage
 pinMode (RELAY2, OUTPUT); // pin 3 commande la pompe doseuse

}

// main loop
void loop(){
 digitalWrite (LED, HIGH);      // allume la led du pin 13
 digitalWrite (RELAY1, HIGH);   // relais 1 = activation pompe de brassage pendant 1 minute
 delay(30000);
 digitalWrite (LED, LOW);       // éteint la led du pin 13
 digitalWrite (RELAY1, LOW);    // relais 1 = désactivation pompe de brassage pendant 30 minutes
 delay(1800000);
 digitalWrite (LED, HIGH);      // allume la led du pin 13
 digitalWrite (RELAY2, HIGH);   // relais 2 = activation pompe doseuse pendant 15 secondes
 delay(15000);
 digitalWrite (LED, LOW);       // éteint la led du pin 13
 digitalWrite (RELAY2, LOW);    // relais 2 = désactivation pompe doseuse pendant 30 minutes
 delay(1800000);
}

mais voilà mon soucis, ça marche qu'a moitié.

quand je met l'arduino en route, ce dernier active direct le relais 2 et le temps de pause de ce relais en fin de cycle dure le double de temps que ce qu'il faudrait.

donc voilà je demande votre aide parce que la je suis un peu paumé.

d'autant qu'a tout celà je vais ajouter par la suite des capteurs de niveau hait et bah plus une autre entrée numérique (pour ça je reviendrais vers vous plus tard).

merci si vous pouvez m'aider à régler mon soucis voire à faire un code plus efficace.

Tu as besoin d'un scheduler, qui te permettrait de faire ce genre d'application plus facilement, et d'ajouter simplement des actions (lecture capteur, etc).

Essaye cette bibliothèque et regarde l'exemple SchedulerBlink.ino.

Le fonctionnement est tout simple : tu as 3 actions périodiques à faire pour clignoter 3 leds. Tu écris 3 couples de setup / loop qui correspondent à tes 3 actions. Et c'est parti.

Si une action n'est pas périodique mais n'est effectuée qu'une seule fois, tu mets tout dans son setup et sa loop est vide. Si elle doit démarrer en différé, tu mets un delay au debut du setup.

Dans ton cas :

je voulais que pendant 1 minute, la pompe de brassage s'active

void setup_brassage () {
  pinMode (RELAY1, OUTPUT); //  pin 2 commande la pompe de brassage
  digitalWrite (LED, HIGH);      // allume la led du pin 13
  digitalWrite (RELAY1, HIGH);   // relais 1 = activation pompe de brassage pendant 1 minute
  delay (60000);
  digitalWrite (LED, LOW);       // éteint la led du pin 13
  digitalWrite (RELAY1, LOW);
}

void loop_brassage () {} // Si la pompe de brassage n'est plus activée par la suite

au bout de X seconde que la pompe doseuse se mettent en route pendant Y temps.

void setup_doseuse () {
  pinMode (RELAY2, OUTPUT); // pin 3 commande la pompe doseuse
  int X = 30; // mettons 30 secondes
  delay (60000+X*1000);    // la référence de temps est la même pour toutes les fonctions
  digitalWrite (LED, HIGH);      // allume la led du pin 13
  digitalWrite (RELAY2, HIGH);   // relais 2 = activation pompe doseuse pendant 15 secondes
  int Y = 15;
  delay(Y*1000);
  digitalWrite (LED, LOW);       // éteint la led du pin 13
  digitalWrite (RELAY2, LOW);    // relais 2 = désactivation pompe doseuse pendant 30 minutes
}

void loop_doseuse () {}

Et dans le setup global:

  pinMode (LED, OUTPUT);    // pin 13 est une sortie digitale
  Scheduler.start(setup_brassage, loop_brassage);
  Scheduler.start(setup_doseuse, loop_doseuse);

A tester...

L'avantage c'est que tu pourras créer de nouvelles actions, par exemple lecture d'un capteur toutes les 5 secondes

void setup_capteur () {
  pinMode (capt_pin, INPUT);
}

void loop_capteur () {
  int valeur = analogRead(capt_pin);
  Serial.print ("Lecture capteur : ");
  Serial.println(valeur);
  delay(5000);
}

MEEERRRRRCCCCCIIIIIIII

je me disais bien (même après la lecture et relecture minutieuse et assidu de mon arduino pour les nuls) que je loupais quelque chose.

et voilà tu as mis le doigts dessus.

sincèrement merci.

Eh bien, bonne chance !

Mince ça marche pas...

satané arduino UNO !!!

:o :o :o :o :o

bonsoir,

bon, j'ai fais une (ou plusieurs erreurs).

voiçi mon code

// constantes et variables
const int LED = 13;    //   LED du pin 13
const int RELAY1 = 2;  // pin 2 commande la pompe de brassage
const int RELAY2 = 3;  // pin 3 commande la pompe doseuse

void setup(){

pinMode (LED, OUTPUT);    // pin 13 est une sortie digitale

Scheduler.start(setup_brassage, loop_brassage);
Scheduler.start(setup_doseuse, loop_doseuse);

}

void setup_brassage () {
 pinMode (RELAY1, OUTPUT); //  pin 2 commande la pompe de brassage
 digitalWrite (LED, HIGH);      // allume la led du pin 13
 digitalWrite (RELAY1, HIGH);   // relais 1 = activation pompe de brassage pendant 1 minute
 delay (60000);
 digitalWrite (LED, LOW);       // éteint la led du pin 13
 digitalWrite (RELAY1, LOW);
}

void loop_brassage () {} // Si la pompe de brassage n'est plus activée par la suite

void setup_doseuse () {

 pinMode (RELAY2, OUTPUT); // pin 3 commande la pompe doseuse
 int X = 30; // mettons 30 secondes
 delay (60000+X*1000);    // la référence de temps est la même pour toutes les fonctions
 digitalWrite (LED, HIGH);      // allume la led du pin 13
 digitalWrite (RELAY2, HIGH);   // relais 2 = activation pompe doseuse pendant 15 secondes
 int Y = 15;
 delay(Y*1000);
 digitalWrite (LED, LOW);       // éteint la led du pin 13
 digitalWrite (RELAY2, LOW);    // relais 2 = désactivation pompe doseuse pendant 30 minutes
}

void loop_doseuse () {}

quelq'un pourrait-il m'aiguiller, parce que là je suis sec.

D’abord il faut mettre ton code entre balises CODE, édité ton message, sélectionne le code et appuies sur le bouton </>

Il faut aussi mettre une loop. Prends celle de l’exemple le plus simple :

void loop () {
yield() ;
{

Et tu as oublié les accolades autour des instructions du setup.

#include <Scheduler.h>

// constantes et variables
const int LED = 13;    //   LED du pin 13
const int RELAY1 = 2;  // pin 2 commande la pompe de brassage
const int RELAY2 = 3;  // pin 3 commande la pompe doseuse

void setup(){

pinMode (LED, OUTPUT);    // pin 13 est une sortie digitale

Scheduler.start(setup_brassage, loop_brassage);
Scheduler.start(setup_doseuse, loop_doseuse);

}

void setup_brassage () {
 pinMode (RELAY1, OUTPUT); //  pin 2 commande la pompe de brassage
 digitalWrite (LED, HIGH);      // allume la led du pin 13
 digitalWrite (RELAY1, HIGH);   // relais 1 = activation pompe de brassage pendant 1 minute
 delay (60000);
 digitalWrite (LED, LOW);       // éteint la led du pin 13
 digitalWrite (RELAY1, LOW);
}

void loop_brassage () {} // Si la pompe de brassage n'est plus activée par la suite

void setup_doseuse () {

 pinMode (RELAY2, OUTPUT); // pin 3 commande la pompe doseuse
 int X = 30; // mettons 30 secondes
 delay (60000+X*1000);    // la référence de temps est la même pour toutes les fonctions
 digitalWrite (LED, HIGH);      // allume la led du pin 13
 digitalWrite (RELAY2, HIGH);   // relais 2 = activation pompe doseuse pendant 15 secondes
 int Y = 15;
 delay(Y*1000);
 digitalWrite (LED, LOW);       // éteint la led du pin 13
 digitalWrite (RELAY2, LOW);    // relais 2 = désactivation pompe doseuse pendant 30 minutes
}

void loop_doseuse () {}

bon voilà, comme tu peux le constater je débute.

vue comme j’arrête pas de me gourer, mon projet va finir par marcher du feu de dieu mdrrrr.

voilà ce que le logiciel me dit :

Arduino : 1.8.10 (Windows 10), Carte : “Arduino Uno”

ATTENTION : la bibliothèque Scheduler prétend être exécutable sur la (ou les) architecture(s) sam, samd et peut être incompatible avec votre carte actuelle qui s’exécute sur avr.
C:\Users\cyril\AppData\Local\Temp\ccStsnn1.s: Assembler messages:

C:\Users\cyril\AppData\Local\Temp\ccStsnn1.s:444: Error: constant value required

lto-wrapper.exe: fatal error: C:\Users\cyril\AppData\Local\Arduino15\packages\arduino\tools\avr-gcc\7.3.0-atmel3.6.1-arduino5/bin/avr-gcc returned 1 exit status

compilation terminated.

c:/users/cyril/appdata/local/arduino15/packages/arduino/tools/avr-gcc/7.3.0-atmel3.6.1-arduino5/bin/…/lib/gcc/avr/7.3.0/…/…/…/…/avr/bin/ld.exe: error: lto-wrapper failed

collect2.exe: error: ld returned 1 exit status

Plusieurs bibliothèque trouvées pour “Scheduler.h”
Utilisé : C:\Users\cyril\OneDrive\Documents\Arduino\libraries\Scheduler
Non utilisé : C:\Users\cyril\OneDrive\Documents\Arduino\libraries\Arduino-Scheduler-master
exit status 1
Erreur de compilation pour la carte Arduino Uno

Ce rapport pourrait être plus détaillé avec
l’option “Afficher les résultats détaillés de la compilation”
activée dans Fichier → Préférences.

Il ne prend pas la bonne bibliothèque, vire celle ci : C:\Users\cyril\OneDrive\Documents\Arduino\libraries\Scheduler Ou déplace la autre part.

Bonjour,

Mais pourquoi ne pas utiliser la boucle millis ?

Cela te permet de faire plusieur tache en même temps et de gérer tes actions.

De plus tu créer des variables afin de pouvoir ajuster des temps

Boucle d'une seconde que tu mets dans le loop

Tu peut en mettre une en seconde et une en minute

if (currentMillis2 - previousMillis2 >= 1000) { previousMillis2 = currentMillis2;

}

A toi de voir.

quand je met l'arduino en route, ce dernier active direct le relais 2 et le temps de pause de ce relais en fin de cycle dure le double de temps que ce qu'il faudrait.

Quel type de relais ? Avec un lien STP.

Ce cahier des charges n'est pas assez précis.

Ton code actuel se déroule de la manière suivante : - démarrage brassage - attente 30s - arrêt brassage - attente 30m - démarrage dosage - attente 15s - arrêt dosage - attente 30m

donc dans mon idée, à la base, je voulais que pendant 1 minute, la pompe de brassage s'active, qu'au bout de X seconde que la pompe doseuse se mettent en route pendant X temps. Et qu'une fois tout ça fini, attendre 30 minutes.

Ton code devrait se dérouler de la manière suivante : - démarrage brassage - attente Xs - démarrage dosage - attente Ys - arrêt dosage - attente 30m - arrêt brassage

void loop(){
  digitalWrite (LED, HIGH);      // allume la led du pin 13
  digitalWrite (RELAY1, HIGH);   // relais 1 = activation pompe de brassage
  delay(30000);
  digitalWrite (RELAY2, HIGH);   // relais 2 = après 30s activation pompe doseuse pendant 15 secondes
  delay(15000);
  digitalWrite (RELAY2, LOW);    // relais 2 = désactivation pompe doseuse
  delay(1800000);                    // 30 minutes de brassage
  digitalWrite (RELAY1, LOW);    // relais 1 = désactivation pompe de brassage
  digitalWrite (LED, LOW);       // éteint la led du pin 13
  // et ensuite ?
}

Si tes relais sont actifs à l'état bas (voir question #10) inverser LOW / HIGH.

et de l'autre coté, dès que la pompe de brassage [démarre / s'arrête], la pompe doseuse se met en route pendant x seconde.

C'est la même chose que précédemment sauf que tu supprimes l'attente Xs.

Tout ceci est parfaitement réalisable avec des delay().

voilà une autre façon de voire les choses qui me plaid.

pour les relais c'est ce modele : https://boutique.semageek.com/fr/1424-module-relais-5v-opto-isole-2-canaux-10a.html?search_query=relais+double&results=108

merci à vous tous pour vos contributions.

Malheureusement sur la page semageek rien n'est précisé.

Par contre ici : https://osoyoo.com/2017/07/31/arduino-lesson-2-channel-relay-module/

L'auteur précise :

IN1 – Controls relay 1, active Low! Relay will turn on when this input goes below about 2.0V

Cela confirme mon soupçon. Si ton relais 2 colle alors que tu lui envoies une commande LOW c'est qu'il fonctionne à l'envers.

  // dans setup()
 pinMode (RELAY1, OUTPUT); //  pin 2 commande la pompe de brassage
 digitalWrite (RELAY1, HIGH);   // relais OFF
 pinMode (RELAY2, OUTPUT); // pin 3 commande la pompe doseuse
 digitalWrite (RELAY2, HIGH);   // relais OFF

Ensuite dans la fonction loop tu remplaces : - HIGH par LOW pour activer - LOW par HIGH pour désactiver

Tu peux aussi ajouter en début de fichier :

#define RELAY_ON      LOW
#define RELAY_OFF     HIGH

Ensuite utiliser RELAY_ON pour activer RELAY_OFF pour désactiver. @+

d'autant qu'a tout celà je vais ajouter par la suite des capteurs de niveau hait et bah plus une autre entrée numérique (pour ça je reviendrais vers vous plus tard).

Attention, l'approche avec la fonction delay est certes plus simple mais n'autorisera pas facilement l'extension que tu imagines par la suite.

d'autant qu'a tout celà je vais ajouter par la suite des capteurs de niveau hait et bah plus une autre entrée numérique (pour ça je reviendrais vers vous plus tard).

Pas grave pour l'instant. On remplacera par millis() en temps voulu. Il faudrait d'abord qu'il précise s'il veut pouvoir consulter l'état des capteurs pendant le brassage, ce qui n'est pas évident.

je le devine.

seulement je viens de reprendre le code ligne par ligne, avec l'exemple du scheduler blink sous les yeux.

j'ai architecturé le bazar comme ça :

cheduler.start(setup_brassage, loop_brassage);
Scheduler.start(setup_doseuse, loop_doseuse);
}

//constante relais 1 :

const int RELAY1 = 2;  // pin 2 commande la pompe de brassage 

void setup_brassage () 
{
 pinMode (RELAY1, OUTPUT); //  pin 2 est une sortie

}

// instructions relais 1 : 

void loop_brassage () 
{

digitalWrite (RELAY1, HIGH);   // relais 1 = activation pompe de brassage pendant 1 minute
delay (60000);

digitalWrite (RELAY1, LOW); //relais 1 = désactivation du brassage 
}
yield();
}

//constante relais 2 :

const int RELAY2 = 3;  // pin 3 commande la pompe doseuse 

void setup_doseuse ()
{
pinMode (RELAY2, OUTPUT); // pin 3 est une sortie
 }

//instructions relais 2 :
  
void loop_doseuse () 
{
 int X = 30; // mettons 30 secondes
 delay (60000+X*1000);    // la référence de temps est la même pour toutes les fonctions

 digitalWrite (RELAY2, HIGH);   // relais 2 = activation pompe doseuse pendant 15 secondes
 int Y = 15;
 delay(Y*1000);

 digitalWrite (RELAY2, LOW);    // relais 2 = désactivation pompe doseuse pendant 30 minutes
}
yield();
}

et ça fonctionne toujours pas.

j'ai viré la bibliothèque et toujours ce message d'erreur :

Arduino : 1.8.10 (Windows 10), Carte : "Arduino Uno"

C:\Arduino\MES PROJETS\SchedulerBlink_essais_2\SchedulerBlink_essais_2.ino: In function 'void setup()':

SchedulerBlink_essais_2:7:17: error: 'setup_doseuse' was not declared in this scope

 Scheduler.start(setup_doseuse, loop_doseuse);

                 ^~~~~~~~~~~~~

C:\Arduino\MES PROJETS\SchedulerBlink_essais_2\SchedulerBlink_essais_2.ino:7:17: note: suggested alternative: 'setup_brassage'

 Scheduler.start(setup_doseuse, loop_doseuse);

                 ^~~~~~~~~~~~~

                 setup_brassage

SchedulerBlink_essais_2:7:32: error: 'loop_doseuse' was not declared in this scope

 Scheduler.start(setup_doseuse, loop_doseuse);

                                ^~~~~~~~~~~~

C:\Arduino\MES PROJETS\SchedulerBlink_essais_2\SchedulerBlink_essais_2.ino:7:32: note: suggested alternative: 'loop_brassage'

 Scheduler.start(setup_doseuse, loop_doseuse);

                                ^~~~~~~~~~~~

                                loop_brassage

C:\Arduino\MES PROJETS\SchedulerBlink_essais_2\SchedulerBlink_essais_2.ino: At global scope:

SchedulerBlink_essais_2:30:8: error: expected constructor, destructor, or type conversion before ';' token

 yield();

        ^

SchedulerBlink_essais_2:31:1: error: expected declaration before '}' token

 }

 ^

Plusieurs bibliothèque trouvées pour "Scheduler.h"
Utilisé : C:\Users\cyril\OneDrive\Documents\Arduino\libraries\Arduino-Scheduler-master
exit status 1
'setup_doseuse' was not declared in this scope

Ce rapport pourrait être plus détaillé avec
l'option "Afficher les résultats détaillés de la compilation"
activée dans Fichier -> Préférences.

ce qui me fait suer, c'est quand je prends l'exemple schedulerblik il n'y a pas d'erreur, je part de ce dernier pour construire mon code et bim...erreur.

Cela semble clair pourtant :

undefined reference to `loop'

Comme tu sembles franchement débutant il serait sage de laisser tomber scheduler pour l'instant. Tu reproduis les mêmes erreurs que dans ton premier sketch :

loop_brassage : - activation relais - attente 60s - désactivation relais

loop doseuse : - attente Xs - activation relais - attente 15s - désactivation relais

loop_brassage va s'exécuter avant loop doseuse donc ce n'est pas adapté. Je pense que ce que tu veux est démarrer le dosage X secondes après le démarrage du brassage, ceci pendant 15 secondes.

loop_brassage : - activation relais brassage

loop doseuse : - attente 30s - activation relais doseuse - attente 15s - désactivation relais doseuse - attente 60s - désactivation relais brassage

Si tu laisses tomber scheduler, dans une loop toute simple :

  • activation relais

loop : - activation relais brassage - attente 30s - activation relais doseuse - attente 15s - désactivation relais doseuse - attente 60s - désactivation relais brassage

Cela revient au même. C'est le code proposé en #11.

Ensuite si tu as besoin de faire des choses pendant le brassage on peut remplacer facilement delay() par autre chose : cela s'appelle millis().

scheduler n'apporte rien ici.

RAPPEL : tu ne sembles pas tenir compte des remarques de #13 : tes relais fonctionnent à l'envers.

ça te semble clair peut-être, mais pas forcement pour tout le monde...

tient lis ça dans ma langue d'origine :

När du läser detta ord verkar det alltid så enkelt.

suite à ton explication, j'ai très bien compris le fonctionnement de mes relais, simplement pour l'heure le but est de comprendre le sens de ce que je fais, une fois le sens saisie y a plus qu'a adapter.

j'ai également bien compris qu'il est plus simple d'utiliser ta solution, d'ailleurs as-tu remarqué que je ne pose de question sur ce que tu as proposé (peut-être par ce que ça marche et que j'ai compris).

effectivement je débute, d'ailleurs mon projet est simple.

maintenant pour que je m'en sorte, il suffit peut être simplement de faire ce que mon ami google est incapable de faire, m'expliquer comment fonctionne scheduler et comme celà s'architecture.

celà m'aidera bien quand je vais complexifier mon projet.

Comme je disais précédemment :

Ton code devrait se dérouler de la manière suivante : - démarrage brassage - attente Xs - démarrage dosage - attente Ys - arrêt dosage - attente 30m - arrêt brassage

Or actuellement tu fais ceci :

loop_brassage : - activation relais brassage - attente 60s - désactivation relais brassage

loop doseuse : - attente Xs - activation relais doseuse - attente 15s - désactivation relais doseuse

C'est à dire que tu fais tourner brassage 60 secondes puis tu arrêtes brassage, puis tu fais tourner dosage pendant 15 secondes (sans brassage).

Je ne pense pas que c'est ce que tu veux que ton système fasse :

donc dans mon idée, à la base, je voulais que pendant 1 minute, la pompe de brassage s'active, qu'au bout de X seconde que la pompe doseuse se mettent en route pendant X temps. Et qu'une fois tout ça fini, attendre 30 minutes.

Que tu le fasses avec scheduler ou pas n'a rien à voir. Simplement scheduler ne permet pas d'exécuter les différentes loops en parallèle comme tu sembles le croire.