// Poste d'aiguillage à 9 + 1 leviers incluant une table d'enclenchements
// Fabrice Fayolle, Septembre 2014
// Version 1.1
// Déclaration des entrées de E0 à E9 (port 19 à port 10)
const byte E0 = 19;
// Déclaration des sorties de S0 à S9 (port 0 à port9) 
const byte S0 = 0;
const byte E1 = 18;
const byte S1 = 1;
const byte E2 = 17;
const byte S2 = 2;
const byte E3 = 16;
const byte S3 = 3;
const byte E4 = 15;
const byte S4 = 4;
const byte E5 = 14;
const byte S5 = 5;
const byte E6 = 13;
const byte S6 = 6;
const byte E7 = 12;
const byte S7 = 7;
const byte E8 = 11;
const byte S8 = 8;
const byte E9 = 10;
const byte S9 = 9;
// Déclaration du nombre de leviers
const int Nb_levier = 10;
// Déclaration dans un tableau des noms des entrées
const byte Entree[Nb_levier]= {E0,E1,E2,E3,E4,E5,E6,E7,E8,E9};
// Déclaration dans un tableau des noms des sorties
const byte Sortie[Nb_levier] = {S0,S1,S2,S3,S4,S5,S6,S7,S8,S9};
// Déclaration dans un tableau du type de sortie
// 1 : Mise à l'état HIGH de la sortie
// 99 : Buzzer signalant une incompatibilité (facultatif)
const int Type_sortie[Nb_levier] = {1,1,1,1,1,1,1,1,1,99};
// Déclaration dans un tableau de la position de chaque levier
// false -> normal (correspond à un signal fermé (arrêt) ou à un aiguillage en position normale)
// La position "normal" est celle par defaut. 
// true -> reverse (correspond à un signal ouvert (voie libre) ou à une aiguillage en position deviee)
boolean etat_levier[Nb_levier] = {false,false,false,false,false,false,false,false,false,false};
// Déclaration dans un tableau de l'état verouillé ou non du levier
// 0 -> non verrouille
// 1 -> verrouille 1 fois
// x -> verrouille x fois
int verrou_levier[Nb_levier]={0,1,0,0,0,0,1,0,0,0};
// Déclaration dans une matrice de la table d'enclenchement
// 0 -> ne verrouille pas le levier
// 1 -> verrouille le levier (Lock)
// -1 -> déverouille le levier (Release)
// 1xx -> verrouille le levier si le levier xx est en position normal (LW (Lock When Normal))
// -1xx -> deverrouille le levier si le levier xx est en position normal (RW (Release When Normal))
// 2xx -> verrouille le levier si le levier xx est en position reverse (LW (Lock When Reverse))
// -2xx -> deverrouille le levier si le levier xx est en position reverse (RW (Release When Reverse))
const int table_enclenchement[Nb_levier*Nb_levier]={
// Levier 1
0,0,0,0,0,0,1,0,0,0,
// Levier 2
0,0,1,1,1,1,1,0,1,0,
//Levier 3
0,1,0,1,0,0,0,0,-206,0,
// Levier 4
0,-1,1,0,0,1,1,0,0,0,
// Levier 5
0,1,0,0,0,1,-1,0,0,0,
// Levier 6
0,1,0,1,1,0,1,0,103,0,
// Levier 7
1,1,1,1,1,0,0,0,1,0,
// Levier 8
0,0,0,0,0,1,0,0,0,0,
// Levier 9
0,1,1,0,0,103,1,0,0,0,
// Levier 10 (non utilisé si la sortie correspondante est utilisée en type 99 (dans ce cas, laisser toutes les valeurs a 0))
0,0,0,0,0,0,0,0,0,0};

void setup()
{
  // Initialisation des entrées (mise à l'état HIGH de chaque sortie)
  // Initialisation des sorties suivant type
  // (mise à l'état LOW de chaque sortie ce qui correspond à une position normale du levier (signal fermé, aiguille en position normale,...))
  for (int i=0;i<Nb_levier;i++)
  {
    pinMode( Entree[i], INPUT );
    digitalWrite( Entree[i], HIGH );
    pinMode( Sortie[i], OUTPUT );
    sortie_changer(i,Type_sortie[i],etat_levier[i]);
  } 
}

void loop()
{
  // Pour l'ensemble des leviers, si un changement est demandé alors
  // Si le changement est possible
  // le changement est effectué
  // Sinon une incompatibilité est signalée
  
  for (int i=0; i< Nb_levier; ++i)
  {
    if ( demande_changement(i))
    {
      if ( levier_changeable(i))
      {
        levier_changer(i);
      }
      else
      {
         sortie_changer(9,99,true);
      }
    }
  }
}

boolean levier_changeable(int levier)
{
  // Fonction levier_changeable vérifie si le levier n'est pas bloqué
  // Valeur true renvoyée si le levier n'est pas bloqué
  // Valeur false renvoyée si le levier est bloqué
  boolean result;
  result = (verrou_levier[levier] == 0);
  return result;
}

void levier_changer(int levier)
{
  // Fonction levier_changer applique ou désapplique la table d'enclenchement à l'ensemble des leviers
  // Si un l'enclenchement est conditionnel, utilisation de la fonction condition_enclenchement
  // Fonction levier_changer change la position du levier
  int decalage = levier * Nb_levier;
  if (!etat_levier[levier])
  {
    for (int i = 0; i <Nb_levier;i++)
    {
      switch (table_enclenchement[decalage+i])
      {
        case -1 :
        verrou_levier[i] += table_enclenchement[decalage+i];
        break;
        case 0 :
        break;
        case 1 :
        verrou_levier[i] += table_enclenchement[decalage+i];
        break;
        default :
        verrou_levier[i] += condition_enclenchement(table_enclenchement[decalage+i]);
      }    
    }
    sortie_changer(levier,Type_sortie[levier],true);
  }
  else
  {
    for (int i = 0; i <Nb_levier;i++)
    {
      switch (table_enclenchement[decalage+i])
      {
        case -1 :
        verrou_levier[i] -= table_enclenchement[decalage+i];
        break;
        case 0 :
        break;
        case 1 :
        verrou_levier[i] -= table_enclenchement[decalage+i];
        break;
        default :
        verrou_levier[i] -= condition_enclenchement(table_enclenchement[decalage+i]);
      }
    }
    sortie_changer(levier,Type_sortie[levier],false);
  }
  etat_levier[levier]=!etat_levier[levier];
}

int condition_enclenchement (int enclenchement)
{
  // Fonction condition_enclenchement applique ou désapplique l'enclenchement si la condition est remplie
  // 1xx -> verrouille le levier si le levier xx est en position normal (LW (Lock When Normal))
  // -1xx -> déverrouille le levier si le levier xx est en position normal (RW (Release When Normal))
  // 2xx -> verrouille le levier si le levier xx est en position reverse (LW (Lock When Reverse))
  // -2xx -> déverrouille le levier si le levier xx est en position reverse (RW (Release When Reverse))
  int centaine = enclenchement / 100;
  int result = 0;
  switch (centaine)
  {
    case 1 :
    if (!etat_levier[enclenchement - 101])
    {
      result = 1;
    }
    break;
    case -1 :
    if (!etat_levier[-enclenchement - 101])
    {
      result = -1;
    }
    break;
    case 2 :
    if (etat_levier[enclenchement - 201])
    {
      result = 1;
    }
    break;
    case -2 :
    if (etat_levier[-enclenchement - 201])
    {
      result = -1;
    }
    break;
  } 
  return result;
}


void sortie_changer(int levier, int type, boolean action)
{
  // Fonction sortie_changer modifie l'état de la sortie
  // Type 1 -> mise à l'état HIGH ou LOW de la sortie (permet par exemple d'alimenter un étage de puissance pour alimenter des moteurs de type Tortoise)
  // Type 99 -> type reservé au buzzer (clignotement d'une LED)
  switch (type)
  {
    case 1:
    if (action)
    {
      digitalWrite(Sortie[levier],HIGH);
    }
    else
    {
      digitalWrite(Sortie[levier],LOW);
    }
    break;
    case 99:
    boolean Etat_sortie = HIGH;
    for (int i=0;i<6;i++)
    {
      digitalWrite(Sortie[levier],Etat_sortie);
      delay(250);
      Etat_sortie = !Etat_sortie;
    }
    break;
  } 
}

boolean demande_changement(int levier)
{
  // Fonction demande_changement vérifie si le bouton poussoir est appuyé (mise à LOW de l'entrée)
  // Boucle d'attente permet d'éviter le phenomène de rebond
  // Valeur true si le bouton poussoir a été appuyé
  boolean result = false;
  if (digitalRead(Entree[levier]) == LOW)
  {
    delay( 100 );
    while ( digitalRead(Entree[levier]) == LOW )
    {
      delay( 100 );
    }
    result = true;
  }
  return result; 
}