Temporisation sur interrupteur 3 positions

Bonjour,

Je me présente Philippe, je viens de m’inscrire sur le forum car j’aurais besoin de votre aide. Je ne suis pas du tout un expert en électronique mais je tente des choses.

J’ai réaliser un branchement d’une carte UNO avec 2 relai actionnés par un interrupteur 3 positions et le programme qui va avec tout marche bien. Le programme est le suivant:

 // Programme test interrupteur 2 positions avec 2 relais

// Noms des entrees et sorties
const int Inter01 = 2;     // Interrupteur position 1
const int Inter02 = 4;     // Interrupteur position 2
const int Relai01 = 7;     // Relai 1
const int Relai02 = 8;     // Relai 2

// Variable etat interrupteur
int etatInter01;
int etatInter02;

// Definition des entrees et sorties
void setup() 
{
 pinMode(Inter01, INPUT); // Interrupteur position 1 est une entree
 pinMode(Inter02, INPUT); // Interrupteur position 2 est une entree
 pinMode(Relai01, OUTPUT); // Relai 1 est une sortie
 pinMode(Relai02, OUTPUT); // Relai 1 est une sortie
 etatInter01 = LOW;
 etatInter02 = LOW;
 digitalWrite(7, HIGH); // Initialisation de la sortie relai 1 = 0
 digitalWrite(8, HIGH); // Initialisation de la sortie relai 2 = 0
}

// Boucle de programmation
void loop() 
{
 etatInter01 = digitalRead(Inter01);
 etatInter02 = digitalRead(Inter02);

 if(etatInter01 == HIGH)
 { 
   digitalWrite(7, HIGH); // Sortie relai 1 = 1
   digitalWrite(8, LOW); // Sortie relai 2 = 0
 }
 else if(etatInter02 == HIGH)
 {
   digitalWrite(7, LOW); // Sortie relai 1 = 0
   digitalWrite(8, HIGH); // Sortie relai 2 = 1
 }
 else
 {
   digitalWrite(7, HIGH); // Sortie relai 1 = 0
   digitalWrite(8, HIGH); // Sortie relai 2 = 0
 }
}

.

Ma question est la suivante:
Je souhaiterais que lorsque je passe de la position n°1 de mon interrupteur à la position n°2 (en passant par le centre de l’interrupteur bien sur), j’arrive à gérer le temps de déclanchement de mes relais.
Je m’explique, quand je vais basculer l’interrupteur, j’aurais forcement un delta de temps entre la coupure du premier relai et la mise en service du deuxième. Donc je voudrais pouvoir gérer ce temps de déclanchement. Je sais ce que je veux mais je ne trouve pas comment l’écrire dans mon programme.

En gros:

  • si inter 1 passe à zéro et que l’inter 2 passe à 1 en moins de 2 secondes, alors le relai 1 se ferme en le relai 2 s’ouvre en 0.1s(par exemple)
  • et inversement, - si inter 2 passe à zéro et que l’inter 1 passe à 1 en moins de 2 secondes, alors le relai 2 se ferme en le relai 1 s’ouvre en 0.1s(par exemple)

Voilà je sais pas si c’est clair mais j’ai besoin de votre aide
Merci par avance
Philippe

corrigez votre post ci dessus et rajoutez les code tags autour du code: [code][color=blue]// votre code ici[/color][/code].

ça doit ressembler à cela:// votre code ici (faites aussi ctrl-T (PC) or cmd-T (Mac) dans l'IDE avant de copier le code pour qu'il soit indenté correctement)


Ce que vous dites c'est que lorsque un inter passe de 1 à 0 avant d'éteindre le relais associé vous voulez attendre 1 seconde (donc votre commande n'apparaîtra jamais comme instantannée pour l'utilisateur) pour voir si par hasard l'autre inter ne va pas s'activer c'est ça? Et dans ce cas faire la transition des commandes des relais rapidement (en gros en même temps quelque microseconde près)

Pour cela il faut gérer des et mémoriser le moment où un inter passe de 1 à 0 pour gérer la seconde d'attente - si au bout d'une seconde vous n'avez pas vu l'autre inter passer à 1 alors vous éteignez seulement Le premier relais. sinon dès que le second inter déclenche vous faites Le switch.

un truc comme cela pourrait peut-être fonctionner (pas testé, tapé sans compiler)

// Programme test interrupteur 2 positions avec 2 relais

// Noms des entrees et sorties
const byte Inter01 = 2;     // Interrupteur position 1
const byte Inter02 = 4;     // Interrupteur position 2
const byte Relai01 = 7;     // Relai 1
const byte Relai02 = 8;     // Relai 2

// Variable etat interrupteur
byte etatInter01;
byte etatInter02;

// gestion des états et du timing
enum {REPOS, INTER1_ON, INTER2_ON, EN_ATTENTE_INTER1, EN_ATTENTE_INTER2} etat;
unsigned long dernierPassageRepos;
const unsigned long tempoMax = 1000ul; // délai max d'attente de bascule des relais
const unsigned long debouncePeriod = 15; // attente active sur les boutons pour faire du debounce

// Definition des entrees et sorties
void setup()
{
  pinMode(Inter01, INPUT);    // Interrupteur position 1 est une entree avec PULL DOWN externe
  pinMode(Inter02, INPUT);    // Interrupteur position 2 est une entree avec PULL DOWN externe

  pinMode(Relai01, OUTPUT);   // Relai 1 est une sortie
  pinMode(Relai02, OUTPUT);   // Relai 2 est une sortie

  // Je suppose que les relais sont inactifs à LOW (pas toujous le cas)
  digitalWrite(Relai01, LOW); // Initialisation de la sortie relai 1 = 0
  digitalWrite(Relai02, LOW); // Initialisation de la sortie relai 2 = 0
  etat = REPOS;
}


void loop() {
  etatInter01 = digitalRead(Inter01);
  etatInter02 = digitalRead(Inter02);

  if (etat == REPOS) {
    if (etatInter01 == HIGH) {
      digitalWrite(Relai01, HIGH); // Sortie relai 1 = 1
      etat = INTER1_ON;
      delay(debouncePeriod); // pour faire un debounce au cas où...
    } else if (etatInter02 == HIGH) {
      digitalWrite(Relai02, HIGH); // Sortie relai 2 = 1
      delay(debouncePeriod); // pour faire un debounce au cas où...
      etat = INTER2_ON;
    }
  }

  if ((etat == INTER1_ON) && (etatInter01 == LOW) && (etatInter02 == LOW)) {
    // on éteint l'interrupteur 1 et passé au centre
    dernierPassageRepos = millis();
    delay(debouncePeriod); // pour faire un debounce au cas où...
    etat = EN_ATTENTE_INTER2;
  } else if ((etat == INTER1_ON) && (etatInter01 == LOW) && (etatInter02 == HIGH)) {
    // on éteint l'interrupteur 1 et passé à l'autre super vite!
    // On fait la bascule instantannée
    digitalWrite(Relai01, LOW);  // Sortie relai 1 = 0
    digitalWrite(Relai02, HIGH); // Sortie relai 2 = 1
    delay(debouncePeriod); // pour faire un debounce au cas où...
    etat = INTER2_ON;
  }

  if ((etat == INTER2_ON) && (etatInter01 == LOW) && (etatInter02 == LOW)) {
    // on éteint l'interrupteur 2 et passé au centre
    dernierPassageRepos = millis();
    delay(debouncePeriod); // pour faire un debounce au cas où...
    etat = EN_ATTENTE_INTER1;
  } else if ((etat == INTER2_ON) && (etatInter01 == HIGH) && (etatInter02 == LOW)) {
    // on éteint l'interrupteur 2 et passé à l'autre super vite!
    // On fait la bascule instantannée
    digitalWrite(Relai01, HIGH); // Sortie relai 1 = 1
    // (si on veut un petit délai entre les 2, rajouter un délai en dur entre les 2 commandes)
    // delay(100);
    digitalWrite(Relai02, LOW);  // Sortie relai 2 = 0
    delay(debouncePeriod); // pour faire un debounce au cas où...
    etat = INTER1_ON;
  }


  // On teste maintenant le timeout et on change l'état si nécessaire
  if  (((etat == EN_ATTENTE_INTER1) || (etat == EN_ATTENTE_INTER2)) && (millis() - dernierPassageRepos >= tempoMax)) {
    // on était en attente et on a trop attendu l'interrupteur est resté au milieu. on éteint
    digitalWrite(Relai01, LOW); // Initialisation de la sortie relai 1 = 0
    digitalWrite(Relai02, LOW); // Initialisation de la sortie relai 2 = 0
    etat = REPOS;
  }

  // ici si les conditions sur l'état == en attente est vraie c'est que le timout n'a pas été déclenché
  // si on a réactivé le même interrupteur ce sera pris au prochain passage en haut de la loop() après timeout

  if ((etat == EN_ATTENTE_INTER1) && (etatInter01 == HIGH)) {
    // On fait la bascule instantannée

    digitalWrite(Relai01, HIGH); // Sortie relai 1 = 1
    // (si on veut un petit délai entre les 2, rajouter un délai en dur entre les 2 commandes)
    // delay(100);
    digitalWrite(Relai02, LOW);  // Sortie relai 2 = 0
    delay(debouncePeriod); // pour faire un debounce au cas où...
    etat = INTER1_ON;
  }

  if ((etat == EN_ATTENTE_INTER2) && (etatInter02 == HIGH)) {
    // On fait la bascule instantannée
    digitalWrite(Relai01, LOW);  // Sortie relai 1 = 0
    // (si on veut un petit délai entre les 2, rajouter un délai en dur entre les 2 commandes)
    // delay(100);
    digitalWrite(Relai02, HIGH); // Sortie relai 2 = 1
    delay(debouncePeriod); // pour faire un debounce au cas où...
    etat = INTER2_ON;
  }
}

Attention à bien penser à utiliser vos noms de variables pour les pins des relais plutôt que des chiffres en dur dans le code (sinon à quoi ça sert de les déclarer!)

Attention aussi à vérifier si vos relais sont actifs à LOW ou à HIGH. dans le code ci dessus j'ai pris comme convention que c'est à HIGH, mais ce n'est généralement pas le cas

Merci pour la réponse, j'ai essayé c'est exactement ça. Il y a quelques lignes que je ne comprend pas mais je vais faire un message pour avoir plus de détail