[RESOLU]Sortie bloquée à l'état LOW, relais Elegoo 8 canaux

Bonjour à tous,

Dans le cadre d'un projet innovation pour le boulot, j'utilise un arduino Uno pour automatiser une tâche de maintenance courante. L'appareil est raccordé à la commande d'un disjoncteur haute tension pour récupérer certaines informations et envoyer certains ordres.

Ces ordres sont relayés par un module relais 8 canaux Elegoo :
lien fiche technique
Ce module fonctionne en logique inversée (LOW = 1, HIGH = 0). Et les électrovannes sont normalement fermées.

Dans mon étape d'initialisation, qui consiste en une purge, je demande à l'arduino d'ouvrir deux électrovannes l'une après l'autre et de fermer la deuxième une seconde après. Mais celle-ci reste ouverte. Donc le 3ème ordre n'est pas exécuté.

J'ai essayé le programme Blink qui fonctionne parfaitement sur cette sortie. Si je demande l'ouverture de la première électrovanne, tout fonctionne également. J'ai aussi tenté l'expérience sur un autre des 8 relais, sans succès.

Donc je pense qu'il ne s'agit pas d'un problème électronique ou de câblage (je me trompe peut-être) mais plutôt d'un problème de programmation, et c'est là que je suis perdu, probablement parce que débutant.

L'erreur est sûrement très bête et je vous demande pardon d'avance...

Pour information, c'est l'ordre commenté "fermer K3" qui ne fonctionne pas, mais l'affichage de la pression qui vient ensuite fonctionne.

const int disjoncteurFerme = A5;
const int disjoncteurOuvert = A4;
const int relaisOa = A3;
const int relaisSd = A2;
const int relaisVe = A1;
const int relaisCm = 2;
const int capteurPression = A0;
const int boutonDcy = 11;

int etatdisjoncteurFerme = 0;
int etatdisjoncteurOuvert = 0;
int etatrelaisOa = 0;
int etatrelaisSd = 0;
int etatrelaisVe = 0;
int etatrelaisCm = 0;
int etatBoutonDcy = 0;

const int electrovanneEntree = 3;   //équivalente de la vanne K2, fait entrer l'huile dans le mano à l'ouverture
const int electrovanneSortie = 7;  //équivalente de la vanne K3, crée une fuite à l'ouverture
const int coupurePompe = 10;
const int pontVe = 9;
const int pontCm = 8;
const int pontOa = 4;
const int ouvrirDj = 6;
const int fermerDj = 5;

int etatInitialisation;
int etatDemarragePompe;
int etatVerrouillageEnclenchement;
int etatOuvertureAutomatique;
int etatPregonflage;
int etatFermeturePendantVerrouillage;
int etatDeverouillageEnclenchement;
int etatArretPompe;
int etatConsoFermeture;
int etatConsoOuverture;
int etatConsoOfo;


float pression = (analogRead(capteurPression)/1024.0) * 600;

void setup() {
// DECLARATION DES ENTREES

pinMode(disjoncteurFerme, INPUT);
pinMode(disjoncteurOuvert, INPUT);
pinMode(relaisOa, INPUT);
pinMode(relaisSd, INPUT);
pinMode(relaisVe, INPUT);
pinMode(relaisCm, INPUT);
pinMode(capteurPression, INPUT);
pinMode(boutonDcy, INPUT);


// DECLARATION DES SORTIES

pinMode(electrovanneEntree, OUTPUT);
pinMode(electrovanneSortie, OUTPUT);
pinMode(coupurePompe, OUTPUT);
pinMode(pontVe, OUTPUT);
pinMode(pontCm, OUTPUT);
pinMode(pontOa, OUTPUT);
pinMode(ouvrirDj, OUTPUT);
pinMode(fermerDj, OUTPUT);

// TOUTES LES SORTIES A L'ETAT LOW

digitalWrite(electrovanneEntree, HIGH);
digitalWrite(electrovanneSortie, HIGH);
digitalWrite(coupurePompe, HIGH);
digitalWrite(pontVe, HIGH);
digitalWrite(pontCm, HIGH);
digitalWrite(pontOa, HIGH);
digitalWrite(ouvrirDj, HIGH);
digitalWrite(fermerDj, HIGH);

Serial.begin(9600);

}

void loop() {

Initialisation();
DemarragePompe();
VerrouillageEnclenchement();
OuvertureAutomatique();
Pregonflage();
FermeturePendantVerrouillage();
DeverouillageEnclenchement();
ArretPompe();
ConsoFermeture();
ConsoOuverture();
ConsoOfo();

}


//______________FONCTION INITIALISATION______________

int Initialisation(){
  while (digitalRead(boutonDcy) == LOW){
    delay(200);
  }
    digitalWrite(electrovanneEntree, LOW);         //Ouvrir K2, laisse entrer l'huile dans le contrôleur de pression
    delay(1000);
    digitalWrite(electrovanneSortie, LOW);         //Ouvrir K3 pour purger l'air
    delay(5000);
    digitalWrite(electrovanneSortie, HIGH);        //Fermer K3
    //Afficher la pression
    Serial.println("Pression (bars):");
    Serial.println(pression);

    int etatInitialisation = 1;
    return(etatInitialisation);

}

//______________FONCTION DEMARRAGE_POMPE______________

int DemarragePompe(){
  if (etatInitialisation == 1){
    digitalWrite(electrovanneSortie, LOW);        //ouvrir K3
    while (digitalRead (relaisCm) == LOW){
      Serial.println(pression);
      delay(1000);
    }
    digitalWrite(electrovanneSortie, HIGH);        //fermer K3
    digitalWrite(coupurePompe, LOW);               //ouvrir le ciruit bobine CM pour arrêter la pompe
    delay(1000);
    float pressionDp = (analogRead(capteurPression)/1024.0) * 600;
    Serial.println("Pression de démarrage pompe(bars):");
    Serial.println(pressionDp);
  }
  int etatDemarragePompe = 1;
  return (etatDemarragePompe);
}

//______________FONCTION VERROUILLAGE_ENCLENCHEMENT______________

int VerrouillageEnclenchement(){
  if (etatDemarragePompe == 1){
    digitalWrite(electrovanneSortie, LOW);        //ouvrir K3
    while (digitalRead (relaisVe) == LOW){
      Serial.println(pression);
      delay(1000);
    }
    digitalWrite(electrovanneSortie, HIGH);        //fermer K3
    delay(1000);
    float pressionVe = (analogRead(capteurPression)/1024.0) * 600;
    Serial.println("Pression verrouillage enclenchement(bars):");
    Serial.println(pressionVe);
  }
  int etatVerrouillageEnclenchement = 1;
  return (etatVerrouillageEnclenchement);
}

//______________FONCTION OUVERTURE_AUTOMATIQUE_____________

int OuvertureAutomatique(){
  if (etatVerrouillageEnclenchement == 1){
    digitalWrite(electrovanneSortie, LOW);        //ouvrir K3
    while (digitalRead (relaisOa) == LOW){
      Serial.println(pression);
      delay(1000);
    }
    digitalWrite(electrovanneSortie, HIGH);        //fermer K3
    delay(1000);
    float pressionOa = (analogRead(capteurPression)/1024.0) * 600;
    Serial.println("Pression d'ouverture automatique(bars):");
    Serial.println(pressionOa);
    if (digitalRead (disjoncteurOuvert) == 1){
      Serial.println("Disjoncteur Ouvert");
    }
  }
  int etatOuvertureAutomatique = 1;
  return (etatOuvertureAutomatique);
}

//______________FONCTION PREGONFLAGE_____________

int Pregonflage(){
  if (etatOuvertureAutomatique == 1){
    digitalWrite(electrovanneSortie, LOW);        //ouvrir K3
    while (pression>2){
      Serial.println(pression);
      delay(1000);
    }
    digitalWrite(electrovanneSortie, HIGH);        //fermer K3
    delay(1000);
    digitalWrite(coupurePompe, HIGH);          //refermer circuit bobine CM
    delay(2000);
    digitalWrite(coupurePompe, LOW);         //ouvrir circuit bobine CM
    float pressionPg = (analogRead(capteurPression)/1024.0) * 600;
    Serial.println("Pression de prégonflage(bars):");
    Serial.println(pressionPg);
  }
  int etatPregonflage = 1;
  return (etatPregonflage);
}

//______________FONCTION_FERMETURE_PENDANT_VERROUILLAGE_____________

int FermeturePendantVerrouillage(){
  if (etatPregonflage == 1){
    digitalWrite(coupurePompe, HIGH);         //fermer circuit bobine CM
    if (digitalRead(relaisCm) == HIGH){
      digitalWrite(fermerDj, HIGH);
      delay(500);
      digitalWrite(fermerDj, LOW);
    }
    if (digitalRead(disjoncteurFerme) == LOW && (disjoncteurOuvert) == HIGH){
      Serial.println("Essai fermeture pendant verrouillage enclenchement OK");
    }
  }
  int etatFermeturePendantVerrouillage = 1;
  return (etatFermeturePendantVerrouillage);
}

//______________FONCTION_DEVERROUILLAGE_ENCLENCHEMENT____________

int DeverouillageEnclenchement(){
  if (etatFermeturePendantVerrouillage == 1){
    while (digitalRead (relaisVe) == HIGH){
      Serial.println(pression);
      delay(1000);
    }
    digitalWrite(coupurePompe, LOW);         //ouvrir circuit bobine CM
    delay(1000);
    float pressionDe = (analogRead(capteurPression)/1024.0) * 600;
    Serial.println("Pression déverrouillage enclenchement(bars):");
    Serial.println(pressionDe);
  }
  int etatDeverouillageEnclenchement = 1;
  return (etatDeverouillageEnclenchement);
}

Merci pour votre patience et vos connaissances!

Bonjour,

Mets ton programme en entier, parce que là il n'y a pas de fonction setup() et on ne sais pas quelles sorties sont utilisées.

J'ai remis le début du programme: variables et setup!

Pour info, j'ai essayé 3 sorties différentes de l'arduino depuis l'apparition de ce problème!

Mettre cela au niveau de variables globales ne va pas vous donner une lecture mise à jour dans le code.float pression = (analogRead(capteurPression) / 1024.0) * 600;

vous n'avez pas besoin de variable intermédiaire pour faire

  int etatInitialisation = 1;
  return (etatInitialisation);

vous pouvez simplement écrirereturn (1);ce qui aussi me fait penser que vous avez une variable globaleint etatInitialisation; avec le même nom.... attention dans la fonction Initialisation() vous créez une variable locale, qui cache la globale et donc vous sortez de la fonction sans avoir mis la variable globale etatInitialisation à 1.

idem pour etatDemarragePompe, etatVerrouillageEnclenchement etc

si vous voulez affecter la valeur de la variable globale (ce que je pense puisque vous vous en servez pour enchaîner les commandes), il faut enlever int le devant dans la fonction.

const int disjoncteurFerme = A5;
const int disjoncteurOuvert = A4;
const int relaisOa = A3;
const int relaisSd = A2;
const int relaisVe = A1;
const int relaisCm = 2;
const int capteurPression = A0;
const int boutonDcy = 11;

int etatdisjoncteurFerme = 0;
int etatdisjoncteurOuvert = 0;
int etatrelaisOa = 0;
int etatrelaisSd = 0;
int etatrelaisVe = 0;
int etatrelaisCm = 0;
int etatBoutonDcy = 0;

const int electrovanneEntree = 3;   //équivalente de la vanne K2, fait entrer l'huile dans le mano à l'ouverture
const int electrovanneSortie = 7;  //équivalente de la vanne K3, crée une fuite à l'ouverture
const int coupurePompe = 10;
const int pontVe = 9;
const int pontCm = 8;
const int pontOa = 4;
const int ouvrirDj = 6;
const int fermerDj = 5;

int etatInitialisation;
int etatDemarragePompe;
int etatVerrouillageEnclenchement;
int etatOuvertureAutomatique;
int etatPregonflage;
int etatFermeturePendantVerrouillage;
int etatDeverouillageEnclenchement;
int etatArretPompe;
int etatConsoFermeture;
int etatConsoOuverture;
int etatConsoOfo;


void setup() {
  // DECLARATION DES ENTREES

  pinMode(disjoncteurFerme, INPUT);
  pinMode(disjoncteurOuvert, INPUT);
  pinMode(relaisOa, INPUT);
  pinMode(relaisSd, INPUT);
  pinMode(relaisVe, INPUT);
  pinMode(relaisCm, INPUT);
  pinMode(capteurPression, INPUT);
  pinMode(boutonDcy, INPUT);


  // DECLARATION DES SORTIES

  pinMode(electrovanneEntree, OUTPUT);
  pinMode(electrovanneSortie, OUTPUT);
  pinMode(coupurePompe, OUTPUT);
  pinMode(pontVe, OUTPUT);
  pinMode(pontCm, OUTPUT);
  pinMode(pontOa, OUTPUT);
  pinMode(ouvrirDj, OUTPUT);
  pinMode(fermerDj, OUTPUT);

  // TOUTES LES SORTIES A L'ETAT LOW

  digitalWrite(electrovanneEntree, HIGH);
  digitalWrite(electrovanneSortie, HIGH);
  digitalWrite(coupurePompe, HIGH);
  digitalWrite(pontVe, HIGH);
  digitalWrite(pontCm, HIGH);
  digitalWrite(pontOa, HIGH);
  digitalWrite(ouvrirDj, HIGH);
  digitalWrite(fermerDj, HIGH);

  Serial.begin(9600);

}

void loop() {

  Initialisation();
  DemarragePompe();
  VerrouillageEnclenchement();
  OuvertureAutomatique();
  Pregonflage();
  FermeturePendantVerrouillage();
  DeverouillageEnclenchement();
  ArretPompe();
  ConsoFermeture();
  ConsoOuverture();
  ConsoOfo();

}


//______________FONCTION INITIALISATION______________

int Initialisation() {
  while (digitalRead(boutonDcy) == LOW) {
    delay(200);
  }
  digitalWrite(electrovanneEntree, LOW);         //Ouvrir K2, laisse entrer l'huile dans le contrôleur de pression
  delay(1000);
  digitalWrite(electrovanneSortie, LOW);         //Ouvrir K3 pour purger l'air
  delay(5000);
  digitalWrite(electrovanneSortie, HIGH);        //Fermer K3
  //Afficher la pression
  float pression = (analogRead(capteurPression) / 1024.0) * 600;
  Serial.println("Pression (bars):");
  Serial.println(pression);

  etatInitialisation = 1;
  return (etatInitialisation);

}

//______________FONCTION DEMARRAGE_POMPE______________

int DemarragePompe() {
  if (etatInitialisation == 1) {
    digitalWrite(electrovanneSortie, LOW);        //ouvrir K3
    while (digitalRead (relaisCm) == LOW) {
      float pression = (analogRead(capteurPression) / 1024.0) * 600;
      Serial.println(pression);
      delay(1000);
    }
    digitalWrite(electrovanneSortie, HIGH);        //fermer K3
    digitalWrite(coupurePompe, LOW);               //ouvrir le ciruit bobine CM pour arrêter la pompe
    delay(1000);
    float pressionDp = (analogRead(capteurPression) / 1024.0) * 600;
    Serial.println("Pression de démarrage pompe(bars):");
    Serial.println(pressionDp);
  }
  etatDemarragePompe = 1;
  return (etatDemarragePompe);
}

//______________FONCTION VERROUILLAGE_ENCLENCHEMENT______________

int VerrouillageEnclenchement() {
  if (etatDemarragePompe == 1) {
    digitalWrite(electrovanneSortie, LOW);        //ouvrir K3
    while (digitalRead (relaisVe) == LOW) {
      float pression = (analogRead(capteurPression) / 1024.0) * 600;
      Serial.println(pression);
      delay(1000);
    }
    digitalWrite(electrovanneSortie, HIGH);        //fermer K3
    delay(1000);
    float pressionVe = (analogRead(capteurPression) / 1024.0) * 600;
    Serial.println("Pression verrouillage enclenchement(bars):");
    Serial.println(pressionVe);
  }
  etatVerrouillageEnclenchement = 1;
  return (etatVerrouillageEnclenchement);
}

//______________FONCTION OUVERTURE_AUTOMATIQUE_____________

int OuvertureAutomatique() {
  if (etatVerrouillageEnclenchement == 1) {
    digitalWrite(electrovanneSortie, LOW);        //ouvrir K3
    while (digitalRead (relaisOa) == LOW) {
      float pression = (analogRead(capteurPression) / 1024.0) * 600;
      Serial.println(pression);
      delay(1000);
    }
    digitalWrite(electrovanneSortie, HIGH);        //fermer K3
    delay(1000);
    float pressionOa = (analogRead(capteurPression) / 1024.0) * 600;
    Serial.println("Pression d'ouverture automatique(bars):");
    Serial.println(pressionOa);
    if (digitalRead (disjoncteurOuvert) == 1) {
      Serial.println("Disjoncteur Ouvert");
    }
  }
  etatOuvertureAutomatique = 1;
  return (etatOuvertureAutomatique);
}

//______________FONCTION PREGONFLAGE_____________

int Pregonflage() {
  float pression = (analogRead(capteurPression) / 1024.0) * 600;
  if (etatOuvertureAutomatique == 1) {
    digitalWrite(electrovanneSortie, LOW);        //ouvrir K3
    while (pression > 2) {
      pression = (analogRead(capteurPression) / 1024.0) * 600;
      Serial.println(pression);
      delay(1000);
    }
    digitalWrite(electrovanneSortie, HIGH);        //fermer K3
    delay(1000);
    digitalWrite(coupurePompe, HIGH);          //refermer circuit bobine CM
    delay(2000);
    digitalWrite(coupurePompe, LOW);         //ouvrir circuit bobine CM
    float pressionPg = (analogRead(capteurPression) / 1024.0) * 600;
    Serial.println("Pression de prégonflage(bars):");
    Serial.println(pressionPg);
  }
  etatPregonflage = 1;
  return (etatPregonflage);
}

//______________FONCTION_FERMETURE_PENDANT_VERROUILLAGE_____________

int FermeturePendantVerrouillage() {
  if (etatPregonflage == 1) {
    digitalWrite(coupurePompe, HIGH);         //fermer circuit bobine CM
    if (digitalRead(relaisCm) == HIGH) {
      digitalWrite(fermerDj, HIGH);
      delay(500);
      digitalWrite(fermerDj, LOW);
    }
    if (digitalRead(disjoncteurFerme) == LOW && (disjoncteurOuvert) == HIGH) {
      Serial.println("Essai fermeture pendant verrouillage enclenchement OK");
    }
  }
  etatFermeturePendantVerrouillage = 1;
  return (etatFermeturePendantVerrouillage);
}

//______________FONCTION_DEVERROUILLAGE_ENCLENCHEMENT____________

int DeverouillageEnclenchement() {
  if (etatFermeturePendantVerrouillage == 1) {
    while (digitalRead (relaisVe) == HIGH) {
      float pression = (analogRead(capteurPression) / 1024.0) * 600;
      Serial.println(pression);
      delay(1000);
    }
    digitalWrite(coupurePompe, LOW);         //ouvrir circuit bobine CM
    delay(1000);
    float pressionDe = (analogRead(capteurPression) / 1024.0) * 600;
    Serial.println("Pression déverrouillage enclenchement(bars):");
    Serial.println(pressionDe);
  }
  etatDeverouillageEnclenchement = 1;
  return (etatDeverouillageEnclenchement);
}

à tester... (tapé ici donc je ne sais pas si ça compile, c'est votre code juste un peu modifié)

Merci pour ces conseils, le code est effectivement plus clair maintenant!
Mais le relais ne veut toujours rien savoir. Je continue de chercher par essais.

c'est lequel qui ne fonctionne pas?

si vous avez un code du genre

...
    digitalWrite(electrovanneSortie, LOW);        //ouvrir K3
    while (digitalRead (relaisCm) == LOW) {
      float pression = (analogRead(capteurPression) / 1024.0) * 600;
      Serial.println(pression);
      delay(1000);
    }
    digitalWrite(electrovanneSortie, HIGH);        //fermer K3
...

et que la condition sur relaisCm reste LOW, vous ne fermerez jamais K3...

Le passage de LOW à HIGH de la sortie "electrovanneSortie" ne fonctionne pas. J'ai utilisé différentes pins de l'arduino, différents canaux du module relais, j'ai allongé le delay entre ces deux commandes mais rien n'y fait.

int Initialisation() {
  while (digitalRead(boutonDcy) == LOW) {
    delay(200);
  }
  digitalWrite(electrovanneEntree, LOW);         //Ouvrir K2, laisse entrer l'huile dans le contrôleur de pression
  delay(1000);
  digitalWrite(electrovanneSortie, LOW);         //Ouvrir K3 pour purger l'air
  delay(5000);
  digitalWrite(electrovanneSortie, HIGH);        //Fermer K3

Si vous testez cela (pas sur votre vrai système hein... :grin:)

const uint8_t electrovanneSortie = 7;

void setup()
{
  Serial.begin(115200);
  pinMode(electrovanneSortie, OUTPUT);
  digitalWrite(electrovanneSortie, LOW);         //Ouvrir K3 pour purger l'air
  delay(5000);
  digitalWrite(electrovanneSortie, HIGH);        //fermer K3
}

void loop() {}

ça fait quelque chose ?

Est ce que les contacts du relai bougent quand on applique un simple 5V sur l'entrée de commande du relai ? Est-ce qu'ils bougent dans le sens que tu as prévu ?

C'est un test rudimentaire qui a l'avantage de séparer le code du matériel et de ne chercher que d'un seul coté à la fois.
Avant de se faire des nœuds au cerveau il faut contrôler le matériel.

68tjs:
Est ce que les contacts du relai bougent quand on applique un simple 5V sur l’entrée de commande du relai ? Est-ce qu’ils bougent dans le sens que tu as prévu ?

C’est un test rudimentaire qui a l’avantage de séparer le code du matériel et de ne chercher que d’un seul coté à la fois.
Avant de se faire des nœuds au cerveau il faut contrôler le matériel.

c’est un bon point ! :slight_smile:

Il y a des choses à connaître sur les microcontrôleurs.
Au démarrage du micro toutes les E/S sont positionnées en entrée, donc équivalentes à une résistance de plus d'un million d'ohms.

Ensuite c'est le programme qui les prend en charge et active le mode "sortie" si besoin.
La notion de logique inverse ne me gêne absolument pas mais il faut faire attention au choix de l'état de repos des relais.

Dit autrement le système doit être en sécurité quand aucun relai n'est commandé et il te faudra peut être jouer avec les notions de contact "travail" ou contact "repos".

Pour ceux qui ne comprennent plus le français :
"Travail" correspond à un contact qui est ouvert quand le relai n'est pas commandé. Le contact se ferme sur une action de la bobine --> NO ou normaly open en angliche.
"Repos" correspond à un contact qui est fermé quand le relai n'est pas commandé. Le contact s'ouvre sur une action de la bobine ---> NC ou normaly closed en angliche.

Il existe des relais équipés de contact travail, repos, ou les deux et dans ce cas on parle volontiers d'inverseurs.

mattcttn:
Le passage de LOW à HIGH de la sortie "electrovanneSortie" ne fonctionne pas. J'ai utilisé différentes pins de l'arduino, différents canaux du module relais, j'ai allongé le delay entre ces deux commandes mais rien n'y fait.

int Initialisation() {

while (digitalRead(boutonDcy) == LOW) {
    delay(200);
  }
  digitalWrite(electrovanneEntree, LOW);        //Ouvrir K2, laisse entrer l'huile dans le contrôleur de pression
  delay(1000);
  digitalWrite(electrovanneSortie, LOW);        //Ouvrir K3 pour purger l'air
  delay(5000);
  digitalWrite(electrovanneSortie, HIGH);        //Fermer K3

Bonjour,

Le programme est très simple et doit fonctionner.
Une des choses qui pourrait le faire planter est les parasites générés par le commande de l’électrovanne. Il faudrait mettre un antiparasitage sur les contacts (condensateur ou snubber). Quelle est la tension de l’électrovanne?
.
Est ce que ça fait la même chose si l'électrovanne n'est pas branchée sur le relais?

@J-M-L, votre programme fonctionne effectivement, comme le programme Blink. Dois-je utiliser le setup pour exécuter tout mon programme?

@68tjs, excusez-moi, je veux dire que si la carte relais est juste alimentée, toutes ses leds coté Input sont allumées, donc tous les relais (qui sont des inverseurs) sont collés. Mes pins sont bien déclarés comme sortie pour contrôler ces relais. Et dans mon setup, j'ai dû mettre ces sorties à l'état HIGH pour laisser au repos les relais, d'où le terme peut-être mal employé de logique inversée, puisque LOW serait logique...

Si je me contente de déclarer les pins comme sorties sans préciser leur état dans le setup, les relais collent bien tous dès la mise sous tension. Il m'avait semblé important de le préciser, parce que n'étant pas habitué, ça me gênait.

Pour des raisons de sécurité, la partie commutée, les contacts, des relais est câblée sur NO car je détourne des circuits extérieurs, et en cas d'urgence, si je dois couper l'alimentation, je souhaite que ces contacts restent ouverts.

@kamill, pour l'instant je me contente de faire des essais à vide, les électrovannes en 24v ne sont pas raccordées. Par contre toute ma boîte est alimentée en 24v et parasite peut-être les entrées du module relais, non? J'ai mis une résistance en parallèle de chaque entrée sur l'arduino pour éviter le comportement erratique des entrées, devrais-je faire de même au niveau des entrées du module relais?

Dois-je utiliser le setup pour exécuter tout mon programme?

non - là c'était juste pour le faire une fois pour tester. Donc votre relais fonctionne comme il faut sur cette pin. faut chercher ailleurs les soucis

mattcttn:
@kamill, pour l'instant je me contente de faire des essais à vide, les électrovannes en 24v ne sont pas raccordées. Par contre toute ma boîte est alimentée en 24v et parasite peut-être les entrées du module relais, non? J'ai mis une résistance en parallèle de chaque entrée sur l'arduino pour éviter le comportement erratique des entrées, devrais-je faire de même au niveau des entrées du module relais?

Non, si les électrovannes ne sont pas connectées, ce n'est pas le problème auquel j'ai pensé.

je veux dire que si la carte relais est juste alimentée, toutes ses leds coté Input sont allumées, donc tous les relais (qui sont des inverseurs) sont collés.

Cette affirmation fait l'hypothèse qu'aucune mécanique des relais n'est défaillante.
Ben moi quand cela ne fonctionne pas je ne fie par à la brillance d'une Del, je prends un ohmmètre et je vérifie que les contacts sont bien dans la position où ils devraient être.

Le but de ma remarque était de rappeler que la sécurité doit être prise en compte avant d'acheter le matériel.
En matière de sécurité quand un seul des éléments essentiels n'est pas alimenté, OU pire n'est plus alimenté, il ne doit rien se passer d'inacceptable.

Je n'en dit pas plus.

Oui, j'ai bien sûr vérifié à l'ohmmètre la position réelle des contacts. Je pense effectivement après un certain nombre de tests et d'essais, que le module relais fonctionne bien. Plusieurs programmes activent et désactivent parfaitement cette sortie.

Après modification du programme, tout fonctionne. J'ai supprimé les variables "electrovanneEntree" et "electrovanneSortie", et j'utilise les numéros de pins (respectivement 3 et 7) à la place.
Je ne vois toujours pas le problème, il restait de la marge niveau mémoire, mais ça marche!

Merci à tous pour les pistes de réflexion!

Je peux vous assurer que ce n’était pas le problème - le compilateur a remplacé vos constantes directement dans le code et donc votre manip n’a rien changé de fondamental. Votre truc est « tombé en marche » , faut réfléchir à deux fois et creuser un peu.

Je pense que vous avez corrigé autre chose, outre ce que j’avais mentionné au début sur la portée des variables.

Par exemple quand je lis if (digitalRead(disjoncteurFerme) == LOW && (disjoncteurOuvert) == HIGH){ on voit bien qu’il manque après le && un digitalRead() (vous comparez un N° de pin avec HIGH) —> l’avez vous corrigé aussi ? Le compilateur est suffisamment smart pour voir que la seconde partie de & sera toujours fausse donc va carrément virer le code dans la partie vraie du if et ne même pas faire le test...

Au passage c’est pour cela qu’on recommande de mettre le mot ‘pin’ dans le nom des constantes référençant des pins, ça saute aux yeux alors à la lecture s’il vous aviez if (digitalRead(pinDisjoncteurFerme) == LOW && pinDisjoncteurOuvert == HIGH){

Si tout cela n’a pas changé (il y a au moins un bug alors) - il se peut que vous aviez aussi un fil de mauvaise qualité et que vous avez changé en rebranchant tout...

À mon avis faut chercher un peu mieux - postez le code qui « marche »

Le voici:

const int pindjf = A5;
const int pindjo = A4;
const int pinrOa = A3;
const int pinrSd = A2;
const int pinrVe = A1;
const int pinrCm = 2;
const int pincapt = A0;
const int pindcy = 11;

const int pineveI = 3;
const int pinevsO = 7;
const int ap = 10;    //arret pompe
const int pontVe = 9;
const int pontCm = 8;
const int pontOa = 4;
const int oDj = 6;    //ordre ouverture Dj
const int fDj = 5;    //ordre fermeture Dj


void setup() {
// DECLARATION DES ENTREES

pinMode(pindjf, INPUT);
pinMode(pindjo, INPUT);
pinMode(pinrOa, INPUT);
pinMode(pinrSd, INPUT);
pinMode(pinrVe, INPUT);
pinMode(pinrCm, INPUT);
pinMode(pincapt, INPUT);
pinMode(pindcy, INPUT);


// DECLARATION DES SORTIES

pinMode(pineveI, OUTPUT);
pinMode(pinevsO, OUTPUT);
pinMode(ap, OUTPUT);
pinMode(pontVe, OUTPUT);
pinMode(pontCm, OUTPUT);
pinMode(pontOa, OUTPUT);
pinMode(oDj, OUTPUT);
pinMode(fDj, OUTPUT);

// TOUTES LES SORTIES A L'ETAT LOW

digitalWrite(pineveI, HIGH);
digitalWrite(pinevsO, HIGH);
digitalWrite(ap, HIGH);
digitalWrite(pontVe, HIGH);
digitalWrite(pontCm, HIGH);
digitalWrite(pontOa, HIGH);
digitalWrite(oDj, HIGH);
digitalWrite(fDj, HIGH);

Serial.begin(9600);

}

void loop() {

initial();
dP();
verEnc();
ouvAuto();
preGonf();
fermPdtVer();
devEnc();
ArretPompe();
ConsoFermeture();
ConsoOuverture();
ConsoOfo();

}


//______________FONCTION INITIALISATION______________

int initial(){
  while (digitalRead(pindcy) == LOW){
    delay(200);
  }
    digitalWrite(pineveI, LOW);         //Ouvrir K2, laisse entrer l'huile dans le contrôleur de pression
    delay(1000);
    digitalWrite(pinevsO, LOW);         //Ouvrir K3 pour purger l'air
    delay(1000);
    digitalWrite(pinevsO, HIGH);        //Fermer K3
    //Afficher la pression
    float pression = (analogRead(pincapt)/1024.0) * 600;
    Serial.println("Pression (bars):");
    Serial.println(pression);

    return(1);

}

//______________FONCTION DEMARRAGE_POMPE______________

int dP(){
  if (initial == 1){
    digitalWrite(pinevsO, LOW);        //ouvrir K3
    while (digitalRead (pinrCm) == LOW){
      float pression = (analogRead(pincapt)/1024.0) * 600;
      Serial.println(pression);
      delay(1000);
    }
    digitalWrite(pinevsO, HIGH);        //fermer K3
    digitalWrite(ap, LOW);               //ouvrir le ciruit bobine CM pour arrêter la pompe
    delay(1000);
    float pressionDp = (analogRead(pincapt)/1024.0) * 600;
    Serial.println("Pression de démarrage pompe(bars):");
    Serial.println(pressionDp);
  }
  return (1);
}

//______________FONCTION VERROUILLAGE_ENCLENCHEMENT______________

int verEnc(){
  if (dP == 1){
    digitalWrite(pinevsO, LOW);       
    while (digitalRead (pinrVe) == LOW){
      float pression = (analogRead(pincapt)/1024.0) * 600;
      Serial.println(pression);
      delay(1000);
    }
    digitalWrite(pinevsO, HIGH);       
    delay(1000);
    float pressionVe = (analogRead(pincapt)/1024.0) * 600;
    Serial.println("Pression verrouillage enclenchement(bars):");
    Serial.println(pressionVe);
  }
  return (1);
}

//______________FONCTION OUVERTURE_AUTOMATIQUE_____________

int ouvAuto(){
  if (verEnc == 1){
    digitalWrite(pinevsO, LOW);        
    while (digitalRead (pinrOa) == LOW){
      float pression = (analogRead(pincapt)/1024.0) * 600;
      Serial.println(pression);
      delay(1000);
    }
    digitalWrite(pinevsO, HIGH);        
    delay(1000);
    float pressionOa = (analogRead(pincapt)/1024.0) * 600;
    Serial.println("Pression d'ouverture automatique(bars):");
    Serial.println(pressionOa);
    if (digitalRead (pindjo) == 1){
      Serial.println("Disjoncteur Ouvert");
    }
  }
  return (1);
}

Par contre j'ai ce message qui est apparu:

.ino:298:25: warning: ISO C++ forbids comparison between pointer and integer [-fpermissive]

   if (ConsoOuverture == 1){

                         ^