Utilisation Switch case et void error : void does not name a type

Bonjour,
a partir d'une entrée, je cherche a piloter un petit moteur DC avec 4 relais 2 pour marche avant et 2 en inversant polarité pour la marche arrière.
au changement d'entrée d'un détecteur magnétique, il y a fonctionnement jusqu’à détection dufin de course et arrêt pour rester en phase repos jusqu'au prochain changement de l'entrée du détecteur magnétique .


// le detecteur est connecté a la borne 2 de la carte
const int DET = 2;
int state_det = LOW;
// le fin de course sur verin connecté a la borne 3
const int FDC = 3;
int state_fdc = LOW;
// sorties commande relais fermeture verin aux bornes 4 pour le + et 5 pour le -
const int Rfermpos = 4;
const int Rfermneg = 5;
// sorties commande relais ouverture verin aux bornes 6  et 7 tension inversée -
const int Rouvpos = 6;
const int Rouvneg = 7;
// variable pour switch case dans loop
int etat_sequence = 1; //identification sequence


_______________________________________________________________________

void setup() {

  pinMode(DET, INPUT); // entree detecteur avec pullup
  //interne inswitch entre broche et masse
  digitalWrite (DET, HIGH);
  pinMode(FDC, INPUT); // entrée fin de course avec pullup
  //interne inswitch entre borne et masse
  digitalWrite(FDC, HIGH);
  // block 4 relais pour commande moteur piloté par entrée bas niveau
  pinMode(Rfermpos, OUTPUT); //sortie relay fermeture positif
  //digitalWrite (Rfermpos, HIGH); //condition initiale relais off
  pinMode(Rfermneg, OUTPUT); // sortie relay fermeture negatif
  //digitalWrite (Rfermneg, HIGH);//condition initiale relais off
  pinMode(Rouvpos, OUTPUT); // sortie relay ouverture positif
  //digitalWrite (Rouvpos, HIGH);//condition initiale relais off
  pinMode(Rouvneg, OUTPUT); // sortie relay ouverture negatif


  state_det = digitalRead(DET); // variable etat du bouton
  state_fdc = digitalRead(FDC);


}
_________________________________________________________________________



void loop() {

  // les fonctions
  repos ();
  verin_repli ();
  verin_ouv ();
  
  // enchainement des sequences du verin
  switch (etat_sequence) {
    case 0:
      if (digitalRead (DET) == HIGH ) {
        delay (2000);
        verin_ouv ();
      }
      break;
    case 1:
      if (digitalRead (DET) == LOW )
      }
  delay (2000);
  verin_repli ();
}
break;




}

// functions pour le deroulement de chaque etape
void repos () {

  digitalWrite (Rfermpos, HIGH);// tous les relais au repos
  digitalWrite (Rfermneg, HIGH);
  digitalWrite (Rouvpos, HIGH);
  digitalWrite (Rouvneg, HIGH);
  etat_sequence = 0;
}

// conditon etat verin if (digitalRead (DET) == LOW; // porte fermée
void verin_repli () {

  digitalWrite (Rfermpos, LOW); // activation relai de fermture verin
  digitalWrite (Rfermneg, LOW);
  delay ( 2000);// attente que fin de course sorte de  position repos
  if (digitalRead (FDC) == LOW) {
    delay (500); // stabilisation contact
    digitalWrite ( Rfermpos, HIGH);
    digitalWrite ( Rfermneg, HIGH);
  }
  etat_sequence = 1;
}

// conditon  etat verin if (digitalRead (DET) == HIGH; // porte ouverte
void verin_ouv () {

  digitalWrite (Rouvpos, LOW);// activation relai d'ouverture verin
  digitalWrite (Rouvneg, LOW);
  delay ( 2000);// attente que fin de course sorte de position repos
  if (digitalRead (FDC) == LOW) {
    delay (500);// stabilisation contact
    digitalWrite (Rouvpos, HIGH);
    digitalWrite (Rouvneg, HIGH);
  }
  etat_sequence = 2;
}




these lines need to be comments

// _______________________________________________________________________

the above is incorrectly formatted.
Looks like it should be

        case 1:
        if (digitalRead (DET) == LOW ) {
            delay (2000);
            verin_repli ();
        }
        break;
    }
}

Veuillez utiliser la langue anglaise dans les sections anglaises du forum. Votre sujet a été déplacé vers la section française du forum.

en fait je ne vois pas la difference entre section francaise et anglaise, ou se trouve l'option pour changer, et dans quelle section suis-je enregistré ?

Soit tu te déplaces dans le forum francophone AVANT de créer un nouveau topic
Soit tu changes dans la fenêtre d'édition

OK, je suis ou maintenant, dois recréer un post?

Non, @sterretje a dit qu'il avait déplacé ton post dans la section francophone.

la programmation par machine à états (cf mon tuto éventuellement) serait une bonne approche…

Tu t'es un peu mélangé les pinceaux dans ton switch case, je te l'ai corrigé et ça compile:

	switch (etat_sequence) {
		case 0:
			if (digitalRead(DET) == HIGH) {
				delay(2000);
				verin_ouv();
			}
			break;
		case 1:
			if (digitalRead(DET) == LOW) {
				delay(2000);
				verin_repli();
			}
			break;
	}

Pas sûre que ces 3 lignes soient utiles:

	repos();
	verin_repli();
	verin_ouv();

Mets les en remarque.

Je n'ai pas essayé ton programme mais, une façon de faire pour "voir" son fonctionnement est de mettre des print un peu partout, ainsi:
Dans setup:
Serial.begin(115200);
Par exemple, dans repos:

void repos() {
	Serial.println("Verin repos");

et ainsi de suite.
Tu mets ta console à 115200:
image

et tu verras "fonctionner" ton programme.

A+
Cordialement
jpbbricole

Bonjour,

merci pour la réponse et effectivement avec correction des erreurs, la séquence fonctionne correctement sauf que je n'arrive pas a faire prendre en compte le fin de course pour arrêter mon vérin alors qu'il s’arrête avec la commande delay, ce qui ne me vas pas, je veux garder ce délai en back-up du fin de course mais utiliser le fin de course pour arrêter le fonctionnement du moteur du vérin.

a force de tester différents emplacements et conditions, je rends le code de plus en plus confus et j'ai du mal a suivre le déroulement des étapes. J'ai inséré des println, et biens qu'ils s'affichent pour les séquences, ouverture et fermeture, le println ne fait jamais afficher le changement d’état du fin de course FDC quelque soit son emplacement

d'autre part, je suis retourné sur le forum pour poster ce message, mais après avoir sélectionné "reponse", je n'ai pas réussi a valider et poster mon message.

je suis d'une géneration ancienne ou le numérique n'existait pas lors de mes études, et a passé 72 ans, j'ai vraiment du mal a suive des interfaces d'applications qui me semblent sans logique et sans ergonomie codifiée.

merci pour votre aide

cordialement

jp caytan


// le detecteur est connecté a la borne 2 de la carte
const int DET = 2;
// variables pour detecter changement d'etat du detecteur de port
int etat_det ;
int etat_det_precedent ;

// le fin de course sur verin connecté a la borne 3
const int FDC = 3;
int etat_fdc = LOW;
// sorties commande relais fermeture verin aux bornes 4 pour le + et 5 pour le -
const int Rfermpos = 4;
const int Rfermneg = 5;
// sorties commande relais ouverture verin aux bornes 6 et 7 tension inversée -
const int Rouvpos = 6;
const int Rouvneg = 7;
const int Chgt_etat = 8;
// variable pour switch case dans loop
int etat_sequence ; //identification sequence
boolean verin_repos;
boolean verin_ferme;
boolean verin_ouvert;
//_______________________________________________________________________

void setup() {

pinMode(DET, INPUT); // entree detecteur avec pullup
//interne inswitch entre broche et masse
digitalWrite (DET, HIGH);
pinMode(FDC, INPUT); // entrée fin de course avec pullup
//interne inswitch entre borne et masse
digitalWrite(FDC, HIGH);
// block 4 relais pour commande moteur piloté par entrée bas niveau
pinMode(Rfermpos, OUTPUT); //sortie relay fermeture positif
digitalWrite (Rfermpos, HIGH); //condition initiale relais off
pinMode(Rfermneg, OUTPUT); // sortie relay fermeture negatif
digitalWrite (Rfermneg, HIGH);//condition initiale relais off
pinMode(Rouvpos, OUTPUT); // sortie relay ouverture positif
digitalWrite (Rouvpos, HIGH);//condition initiale relais off
pinMode(Rouvneg, OUTPUT); // sortie relay ouverture negatif
pinMode (etat_fdc, OUTPUT);

etat_det = digitalRead(DET); // variable etat du bouton
etat_fdc = digitalRead(FDC);
// initialisation au repos verin ouvert et relais tombés
verin_ouv ();
repos ();
}
//_________________________________________________________________________

// functions pour le deroulement de chaque etape
void repos () {

digitalWrite (Rfermpos, HIGH);// tous les relais au repos
digitalWrite (Rfermneg, HIGH);
digitalWrite (Rouvpos, HIGH);
digitalWrite (Rouvneg, HIGH);
etat_sequence = 0;
verin_repos = 1;
verin_repos = 1;
verin_ouvert = 1;
verin_ferme = 0;
etat_sequence = 0;
verin_repos = 1;
}

// conditon etat verin if (digitalRead (DET) == LOW); // porte fermée
void verin_repli () {

digitalWrite (Rfermpos, LOW); // activation relai de fermture verin
digitalWrite (Rfermneg, LOW);
delay ( 5000);// attente que fin de course sorte de position repos
//if (digitalRead (FDC) == HIGH) {
delay (500); // stabilisation contact
digitalWrite ( Rfermpos, HIGH);
digitalWrite ( Rfermneg, HIGH);
verin_ferme = 1;
// }
etat_sequence = 1;
}

// conditon etat verin if (digitalRead (DET) == HIGH); // porte ouverte
void verin_ouv () {

digitalWrite (Rouvpos, LOW);// activation relai d'ouverture verin
digitalWrite (Rouvneg, LOW);
delay ( 5000);// attente que fin de course sorte de position repos
//if (digitalRead (FDC) == LOW) {
delay (500);// stabilisation contact
digitalWrite (Rouvpos, HIGH);
digitalWrite (Rouvneg, HIGH);
verin_ouvert = 1;
//}
etat_sequence = 2;
}

void loop() {

// enchainement des sequences du verin
switch (etat_sequence) {
case 0:

// detection changement d'etat et porte ouverte pas de detection mag

etat_det = digitalRead (DET);
if ( digitalRead (DET) == LOW && verin_ouvert == 1)
{
verin_repli ();
digitalWrite (Chgt_etat, HIGH);
etat_det_precedent = etat_det;
verin_ferme = 1;
}

break;

case 1:

// detection changement d'etat et porte fermée

etat_det = digitalRead (DET);
if ( digitalRead (DET) == HIGH && verin_ferme == 1 ) {

verin_ouv ();
digitalWrite (Chgt_etat, HIGH);
etat_det_precedent = etat_det;
verin_ouvert = 1;

}// fin changement d'etat

break;

case 3:

//detection du find de course

etat_det = digitalRead (FDC);
if ( digitalRead (FDC) == LOW ) {

repos ();

etat_det_precedent = etat_det;
}

}// retour switch
}// fin boucle loop

Bonjour,

en complement au message precedent, j'ai essaye une autre structure qui semble marcher mais mon fin de course n'est pas pris en compte pour arrêter le moteur quelque soit l'emplacement et les condition rentrées pour tester le fin de course.je joints aussi ce code

encore une fois merci pour votre aide.

cordialement

JP Caytan

(attachments)

verin_assistance_porte_van_version_n__infini.ino (3.66 KB)

Tu ne peux pas utiliser un if dans ce cas là. Tu ne passes dans celui-ci qu'une fois et ensuite tu sors de la fonction.
Il faut créer une boucle dans laquelle tu vas rester tant que le fin de course ne sera pas détecté

// conditon etat verin if (digitalRead (DET) == LOW); // porte fermée
void verin_repli () {

digitalWrite (Rfermpos, LOW); // activation relai de fermeture verin
digitalWrite (Rfermneg, LOW);
 // on reste dans le while tant que le contact est ouvert
while (digitalRead (FDC) == HIGH);
digitalWrite ( Rfermpos, HIGH);
digitalWrite ( Rfermneg, HIGH);
verin_ferme = 1;

etat_sequence = 1;
}

Si tu veux avoir en plus un temps limite, il faut utiliser millis() pour comptabiliser le temps écoulé.

// conditon etat verin if (digitalRead (DET) == LOW); // porte fermée
void verin_repli () {
long temps;

digitalWrite (Rfermpos, LOW); // activation relai de fermeture verin
digitalWrite (Rfermneg, LOW);
temps = millis();  // on mémorise le temps du départ
// on reste dans le while tant que le contact est ouvert  et que TEMPS_LIMITE n'est pas atteint
while (digitalRead (FDC) == HIGH && (millis() - temps) < TEMPS_LIMITE);  
digitalWrite ( Rfermpos, HIGH);
digitalWrite ( Rfermneg, HIGH);
// ici il faut ajouter un test pour indiquer si on sort avec un verin en position
// ou un verrin bloqué
// par exemple
if(millis() - temps < TEMPS_LIMITE){
    verin_ferme = 1; // ici on sort sur fin de course activé
} else {
    verin_ferme = 0; // ici on sort sur hors temps
}

etat_sequence = 1;
}

Merci pour ces information,
il s'avère que je ne maitrise pas les subtilités les conditions et les limites dans lesquelles choisir un if plutot qu'un while, ou encore un switch case. la reference du langage arduino en Francais n'est pas suffisante pour que je comprenne ces differences d'utilisation.

j'ai fait differemment les loops dans 2 versions differentes du programme.
dans l'une j'utilise switch case, et dans l'autre in if
dans la première le programme bloque après 3 switchs et je ne comprends pas pourquoi, et dans le second avec if, il semble fonctionner comme attendu, c. a. d. basculer en replis ou extension systematiquement a la detection du detecteur magnetique de porte DET

dans quel cas utiliser switch case ou ou se trouve mon erreur dans son application ?

en fait dans la loop avec les switch / case, j'avais inversé les états donc je rappelais le même état quand la condition changeait ce qui fait que le changement de sens du vérin ne se faisait pas,
c'est comme quand on cherche ses clefs, le cerveau fonctionne comme une hallucination...:slight_smile:

je vous remercie pour vos contributions et votre temps
votre aide a été précieuse, car ce truc est vraiment un bouffeur de temps, et l'on se retrouve avec mémée qui râle...oui, j'en suis a passé 3/4 de siècle...

je poste la prose ici, et encore merci;


// le detecteur est connecté a la borne 2 de la carte
const int DET = 2;
// variables pour detecter changement d'etat du detecteur de port
int etat_det ;
int etat_det_precedent ;

// le fin de course sur verin connecté a la borne 3
const int FDC = 3;
int etat_fdc = LOW;

// sorties commande relais fermeture verin aux bornes 4 pour le + et 5 pour le -
const int Rfermpos = 4;
const int Rfermneg = 5;
// sorties commande relais ouverture verin aux bornes 6  et 7 tension inversée -
const int Rouvpos = 6;
const int Rouvneg = 7;

// variable pour definir le temps de fonctionnement des verins en back-up du fin de course
int TEMPO = 3000;

// variable pour switch case dans loop
int etat_sequence ; //identification sequence utilisée pour sortir de "switch / case" dans l'etat souhaité
int verin_repos;
int verin_ferme;
int verin_ouvert;
//_______________________________________________________________________

void setup() {

  pinMode(DET, INPUT); // entree detecteur avec pullup
  //interne inswitch entre broche et masse
  digitalWrite (DET, HIGH);
  pinMode(FDC, INPUT); // entrée fin de course avec pullup
  //interne inswitch entre borne et masse
  digitalWrite(FDC, HIGH);
  // block 4 relais pour commande moteur piloté par entrée bas niveau
  pinMode(Rfermpos, OUTPUT); //sortie relay fermeture positif
  digitalWrite (Rfermpos, HIGH); //condition initiale relais off
  pinMode(Rfermneg, OUTPUT); // sortie relay fermeture negatif
  digitalWrite (Rfermneg, HIGH);//condition initiale relais off
  pinMode(Rouvpos, OUTPUT); // sortie relay ouverture positif
  digitalWrite (Rouvpos, HIGH);//condition initiale relais off
  pinMode(Rouvneg, OUTPUT); // sortie relay ouverture negatif
  pinMode (etat_fdc, OUTPUT);




  etat_det = digitalRead(DET); // variable etat du bouton
  etat_fdc = digitalRead(FDC);
  // initialisation au repos verin ouvert et relais tombés

  digitalWrite (Rfermpos, HIGH);// tous les relais au repos
  digitalWrite (Rfermneg, HIGH);
  digitalWrite (Rouvpos, HIGH);
  digitalWrite (Rouvneg, HIGH);
}
//_________________________________________________________________________

// functions pour le deroulement de chaque etape

// conditon etat verin if (digitalRead (DET) == LOW); // porte fermée
void verin_repli () {
  long temps; // pour la temporisation du temps de fonctionnement du verin

  digitalWrite (Rfermpos, LOW); // activation relai de fermture verin
  digitalWrite (Rfermneg, LOW);
  temps = millis () ; // on memorise le temps de depart de la tempo
  while (digitalRead (FDC) == HIGH && (millis () - temps ) <= TEMPO);

  digitalWrite ( Rfermpos, HIGH);
  digitalWrite ( Rfermneg, HIGH);
  if ( millis () - temps <= TEMPO || digitalRead (FDC) == HIGH ) {
    digitalWrite ( Rfermpos, HIGH);
    digitalWrite ( Rfermneg, HIGH);

    etat_sequence = 1;// pour lancer le scrutement de DET dans loop  pour etat/ case 1 suivant soit verin_ouv
  }
}


// conditon  etat verin if (digitalRead (DET) == HIGH); // porte ouverte
void verin_ouv () {
  long temps; // pour la temporisation du temps de fonctionnement du verin

  digitalWrite (Rouvpos, LOW);// activation relai d'ouverture verin
  digitalWrite (Rouvneg, LOW);
  delay ( 2000);// attente que fin de course sorte de position repos
  //if (digitalRead (FDC) == LOW) {
  temps = millis () ; // on memorise le temps de depart de la tempo
  while (digitalRead (FDC) == HIGH && (millis () - temps ) <= TEMPO);

  digitalWrite ( Rouvpos, HIGH);
  digitalWrite ( Rouvneg, HIGH);
  if ( millis () - temps <= TEMPO || digitalRead (FDC) == HIGH ) {
    digitalWrite ( Rouvpos, HIGH);
    digitalWrite ( Rouvneg, HIGH);

  etat_sequence = 0; //pour lancer le scrutement de DET dans loop  pour etat / case 0 suivant soit verin_repli

    }
}


void loop() {

  // enchainement des sequences du verin
  switch (etat_sequence) {

    case 0:
      // detection changement d'etat et porte fermée mag DET tiré a la masse LOW
      //etat_det = digitalRead (DET);
      if ( digitalRead (DET) == LOW  ) {
        verin_repli ();

        //etat_det_precedent = etat_det;
      }

      break;


    case 1:
      // detection changement d'etat et porte ouverte DET en pull up interne

      //etat_det = digitalRead (DET);
      if ( digitalRead (DET) == HIGH  ) {
        verin_ouv ();

      }// fin changement d'etat


      break;

    default:
      break;


  }// retour switch
}// fin boucle loop
  • if ... else, c'est si on gère des alternatives

    • Si une condition est remplie faire ceci
    • Sinon faire cela
  • switch ... case, c'est plutôt si on gère des choix qui peuvent être encodés dans une valeur numérique
    on passe une variable en argument à switch et en fonction de la valeur de cette variable on fait telle ou telle action

  • while et for, c'est pour faire des boucles
    La différence entre for et while c'est qu'avec for la condition de maintient dans la boucle est vérifiée à la fin de la boucle alors qu'avec while la condition de maintient est vérifiée avant d'entrer dans la boucle. Donc avec for même si la condition de sortie est remplie on exécutera toujours la boucle au moins une fois.

merci fdufnews, pour ton aide, et les éclaircissements sur les fonctions
bonne soirée, je vais pouvoir prendre du temps maintenant pour mon voilier et profiter du beau temps ici a Denia
cordialement
jp caytan

après câblage du vérin sur le van je m'aperçois que cela ne marche pas comme prévu
avant coller mon programme je rappelle le fonctionnement recherché
un aimant sur la porte permets de définir si la porte est fermée, et dans ce cas l'"ils" du vérin (DET) actionne le moteur réducteur a came du vérin pour le replis et plaquer la porte laterale et il doit s’arrêter au bout de quelques secondes si le fin de course n'est pas détecté avant.
nota: le fin de course n'est pas actif de suite il est d'abord ouvert, puis il monte sur la came ferme le contact pour ensuite quand il retombe de la came c'est la fin de course quand le contact s'ouvre, et le moteur doit s'arreter.
detection porte fermée => le moteur du verin se mets en marche , le contact sur came se ferme apres quelques tours du moteur, et le fin de course arrete le moteur en fin de course, et le verin reste au repos jusqu'a ce que l'aimant de porte ne soit plus detecté, quand on ouvre la porte et la le verin doit s'ouvrir sur la meme sequence attente que le fin de course monte sur la came pour ensuite arreter le moteur et attendre un changement de detection de l'aimant de la porte

ci apres mon code, mais les fonctions verin_ouv et verin _repli ne semblent pas fonctionner malgré la fonction while pour initier une boucle dans ces fonctions.
j'ai essayé de multiples if et while a differents emplacements mais je n'arrrive pas a faire fonctionner le système


// le detecteur est connecté a la borne 2 de la carte
const int DET = 2;
// variables pour detecter changement d'etat du detecteur de porte ils et aimant de porte


// le fin de course sur verin connecté a la borne 3
const int FDC = 4;


// sorties commande relais positif et negatif du moteur fermeture verin aux bornes 4 pour le + et 5 pour le -
const int Rfermpos = 7;
const int Rfermneg = 8;
// sorties commande relais ouverture verin aux bornes 6  et 7 tension inversée -
const int Rouvpos = 9;
const int Rouvneg = 10;

// variable pour definir le temps de fonctionnement des verins en back-up du fin de course

unsigned long temps; // pour la temporisation du temps de fonctionnement du verin

// variable pour switch case dans loop
int etat_sequence ; //identification sequence utilisée pour sortir de "switch / case" dans l'etat souhaité

//_______________________________________________________________________

void setup() {

  pinMode(DET, INPUT); // entree detecteur avec pullup
  //interne inswitch entre broche et masse
  digitalWrite (DET, HIGH);
  pinMode(FDC, INPUT); // entrée fin de course avec pullup
  //interne inswitch entre borne et masse
  digitalWrite(FDC, HIGH);
  // block 4 relais pour commande moteur piloté par entrée bas niveau
  pinMode(Rfermpos, OUTPUT); //sortie relay fermeture positif
  digitalWrite (Rfermpos, HIGH); //condition initiale relais off
  pinMode(Rfermneg, OUTPUT); // sortie relay fermeture negatif
  digitalWrite (Rfermneg, HIGH);//condition initiale relais off
  pinMode(Rouvpos, OUTPUT); // sortie relay ouverture positif
  digitalWrite (Rouvpos, HIGH);//condition initiale relais off
  pinMode(Rouvneg, OUTPUT); // sortie relay ouverture negatif
  



  // initialisation au repos verin ouvert et relais tombés

  digitalWrite (Rfermpos, HIGH);// tous les relais au repos
  digitalWrite (Rfermneg, HIGH);
  digitalWrite (Rouvpos, HIGH);
  digitalWrite (Rouvneg, HIGH);
}
//_________________________________________________________________________

// functions pour le deroulement de chaque etape

// conditon etat verin if (digitalRead (DET) == LOW); // porte fermée
void verin_repli () {
unsigned int TEMPO = 5000;
unsigned int ATTENTE = 1000;
  digitalWrite (Rfermpos, LOW); // activation relai de fermture verin
  digitalWrite (Rfermneg, LOW);
 // attente que le fin de course monte sur la came et ferme
  temps = millis () ;
  // on memorise le temps de depart des temporisations
  while ( millis () - temps < TEMPO );{ // boucle pour que les tempos se deroulent
  if (millis () - temps > ATTENTE) { // 
    
  if (digitalRead (FDC) == LOW) { //le fin de ccourse tombe en fin de repli

  digitalWrite ( Rfermpos, HIGH);
  digitalWrite ( Rfermneg, HIGH);// arret verin 
 
 temps = millis () ;// reinitialise le temps
  }
  }
  }
   etat_sequence = 1;// pour lancer le scrutement de DET dans loop  pour etat/ case 1 suivant soit verin_ouv
   
  }
  



// conditon  etat verin if (digitalRead (DET) == HIGH); // porte ouverte
void verin_ouv () {
unsigned int TEMPO = 6000;
unsigned int ATTENTE = 1000;
  digitalWrite (Rouvpos, LOW);// activation relai d'ouverture verin
  digitalWrite (Rouvneg, LOW);
// attente sue le fibn de course monte sur la came 
  temps = millis () ; // on memorise le temps de depart de la tempo
  
  while (  millis () - temps < TEMPO );{
  if ( millis () - temps > ATTENTE ) {
   if ( digitalRead (FDC) == LOW ) { 
   
  digitalWrite ( Rouvpos, HIGH);
  digitalWrite ( Rouvneg, HIGH); 
 temps = millis () ;
   }
  }
  }
    etat_sequence = 0;//pour lancer le scrutement de DET dans loop  pour etat / case 0 suivant soit verin_repli
    
  }
 


void loop() {

  // enchainement des sequences du verin
  switch (etat_sequence) {

    case 0:
      // detection changement d'etat et porte fermée mag DET tiré a la masse LOW
     
      if ( digitalRead (DET) == LOW  ) {
        verin_repli ();

        
      }

      break;


    case 1:
      // detection changement d'etat et porte ouverte DET en pull up interne

      
      if ( digitalRead (DET) == HIGH  ) {
        verin_ouv ();

      }// fin changement d'etat


      break;

    //default:
     // break;


  }// retour switch
}// fin boucle loop