Piloter un relais bistable avec Arduino

// les états que l'automate de détection de train peut prendre
enum { ATTENTE, WAGON, ATTELAGE, ARRET };

const int pinsCapteur[4] = {2, 3, 4, 5};
byte etatTrain[4] = {ATTENTE, ATTENTE, ATTENTE, ATTENTE};
byte compteur[4];

const unsigned long dureeAttelage = 50;

// les états que l'automate d'aiguille peut prendre
enum { DEVIEE, DROITE, PULSE_DEVIEE, PULSE_DROITE };

byte etatAiguille[2] = {DROITE, DROITE};
byte compteurAiguille[2];
byte commandeAiguille[2] = {DROITE, DROITE};

// tableau permettant à une gare de connaitre la gare avec laquelle
// elle partage l'aiguille
const byte conjointDeGare[4] = { 1, 0, 3, 2 };

// tableau indexé par le numéro de gare qui donne la position de l'aiguille associée
const byte commandeDeGareAAiguille[4] = {DEVIEE, DROITE, DEVIEE, DROITE};

// tableau indexé par le numéro de gare qui donne la position de l'aiguille associée
// pour la procédure d'arret
const byte commandeDeGareAAiguilleArret[4] = {DROITE, DEVIEE, DROITE, DEVIEE};

const byte pinDroite[2] = {6, 8};
const byte pinDeviee[2] = {7, 9};

const unsigned long dureeImpulsion = 10; // valeur arbitraire, à ajuster

const byte pinPoussoir = 10;

// les états de l'automate du poussoir
enum { RELACHE, ENFONCE_REBOND, ENFONCE };
// La variable pour mémoriser l'état de l'automate
byte etatPoussoir = RELACHE;
// La variable pour mémoriser l'état du poussoir
byte poussoir = 0;

void setup()
{
  pinMode(pinPoussoir, INPUT);
  digitalWrite(pinPoussoir, HIGH);
  
  int gare;
  
  for (gare = 0; gare < 4; gare++) {
    pinMode(pinsCapteur[gare], INPUT);
  }
  
  int aiguille;
  
  for (aiguille = 0; aiguille < 2; aiguille++) {
    // les deux pins de commande sont mises à LOW
    digitalWrite(pinDeviee[aiguille], LOW);
    digitalWrite(pinDroite[aiguille], LOW);
    // les deux pins de commande sont mises en sortie
    pinMode(pinDeviee[aiguille], OUTPUT);
    pinMode(pinDroite[aiguille], OUTPUT);
    // et on met une impulsion sur la commande droite
    // pour mettre l'aiguille en position initiale connue
    digitalWrite(pinDroite[aiguille], HIGH);
    delay(dureeImpulsion);
    digitalWrite(pinDroite[aiguille], LOW);
  }
}

void loop()
{
  int gare;
  
  for (gare = 0; gare < 4; gare++) {
    
    byte capteur = digitalRead(pinsCapteur[gare]);
  
    switch (etatTrain[gare])
    {
      case ATTENTE:
        if (capteur == LOW) {
          etatTrain[gare] = WAGON;
        }
            else if (poussoir > 0 &&
                 etatAiguille[gare / 2] == commandeDeGareAAiguille[gare] &&
                 etatTrain[conjointDeGare[gare]] == ATTENTE)
        {
          etatTrain[gare] = ARRET;
          commandeAiguille[gare / 2] = commandeDeGareAAiguilleArret[gare];
          poussoir--;
        }
        break;
      case WAGON:
        if (capteur == HIGH) {
          etatTrain[gare] = ATTELAGE;
          compteur[gare] = 0;
        }
        break;
      case ATTELAGE:
        if (capteur == LOW) {
          etatTrain[gare] = WAGON;
        }
        else {
          if (compteur[gare] < dureeAttelage) {
            compteur[gare]++;
          }
          else {
            etatTrain[gare] = ATTENTE;
            // commande l'aiguille associée pour sélectionner la gare associée
            commandeAiguille[gare / 2] = commandeDeGareAAiguille[gare];
          }
        }
        break;
    }
  }
  
  int aiguille;
  
  for (aiguille = 0; aiguille < 2; aiguille++) {
    switch (etatAiguille[aiguille]) {
      case DEVIEE:
        if (commandeAiguille[aiguille] == DROITE) {
          // commande pour mettre l'aiguille DROITE
          compteurAiguille[aiguille] = 0;
          // commande pour mettre l'aiguille DROITE
          digitalWrite(pinDroite[aiguille], HIGH);
          // on va dans l'état PULSE_DROITE
          etatAiguille[aiguille] = PULSE_DROITE;
        }
        break;
      case DROITE:
        if (commandeAiguille[aiguille] == DEVIEE) {
          // commande pour mettre l'aiguille DEVIEE
          compteurAiguille[aiguille] = 0;
          // commande pour mettre l'aiguille DROITE
          digitalWrite(pinDeviee[aiguille], HIGH);
          // on va dans l'état PULSE_DEVIEE
          etatAiguille[aiguille] = PULSE_DEVIEE;
        }
        break;
      case PULSE_DEVIEE:
        if (compteurAiguille[aiguille] < dureeImpulsion) {
          // on reste dans PULSE_DEVIEE pendant dureeImpulsion ticks
          compteurAiguille[aiguille]++;
        }
        else {
          // transition vers l'état DEVIEE, on coupe le pulse
          digitalWrite(pinDeviee[aiguille], LOW);
          etatAiguille[aiguille] = DEVIEE;
        }
        break;
      case PULSE_DROITE:
        if (compteurAiguille[aiguille] < dureeImpulsion) {
          // on reste dans PULSE_DROITE pendant dureeImpulsion ticks
          compteurAiguille[aiguille]++;
        }
        else {
          // transition vers l'état DROITE, on coupe le pulse
          digitalWrite(pinDroite[aiguille], LOW);
          etatAiguille[aiguille] = DROITE;
        }
        break;
    }
  }  

  switch (etatPoussoir) {
    case RELACHE:
      if (digitalRead(pinPoussoir) == LOW) {
        etatPoussoir = ENFONCE_REBOND;
      }
      break;
    case ENFONCE_REBOND:
      if (digitalRead(pinPoussoir) == LOW) {
        etatPoussoir = ENFONCE;
        poussoir = 2;
      }
      else {
        etatPoussoir = RELACHE;
      }
      break;
    case ENFONCE:
      if (digitalRead(pinPoussoir) == HIGH) {
        etatPoussoir = RELACHE;
      }
      break;
  }  
  
  // attente de 10ms entre 2 analyses du système
  delay(10);  
}