Forum du Zéro

Code : Tout sélectionner

// Name
#define NAME  "BMVU"
#define NAME2 "Block Manuel de Voie Unique type SNCF"
#define NAME3 "IN1547 (Règlement S5C)"

// Version & Copyright
#define VERSION "Version 1.0 (Arduino Mega)"
#define COPYRIGHT "Copyright Fabrice Fayolle, Août 2019"

int SemaphoreX_IN;
int SemaphoreX_OUT;
int SemaphoreY_IN;
int SemaphoreY_OUT;

class Appareil
{
  private:
    int BN_BLOCAGE;
    int BN_ANNONCE;
    boolean VT_ANNONCE_ETAT;
    int VT_ANNONCE;
    int BN_REDDITION;
    boolean VT_REDDITION_ETAT;
    int VT_REDDITION;
    int BN_TEST;
    boolean VT_TEST_ETAT;
    int VT_TEST;
    int BN_SONNERIE;
  public:
    boolean SEMAPHORE_OUVERT;
    void Setup(int indice);
    boolean Blocage();
    boolean Test();
    boolean Voielibre();
    void Vt_Test();
    boolean Annonce();
    boolean Reddition();
    void Vt_Annonce();
    void Vt_Reddition();
}
;

void Appareil::Setup(int indice)
{

}

boolean Appareil::Blocage()
{
  boolean resultat = false;
  resultat = !digitalRead(BN_BLOCAGE);
  return resultat;
}

boolean Appareil::Test()
{
  boolean resultat = false;
  if (!digitalRead(BN_TEST))
  {
    delay(100);
    if (!digitalRead(BN_TEST))
    {
      while (!digitalRead(BN_TEST))
      {
      }
      resultat = true;
    }
  }
  return resultat;
}

boolean Appareil::Voielibre()
{
  boolean resultat = false;
  if (!VT_TEST_ETAT && !VT_ANNONCE_ETAT && !VT_REDDITION_ETAT && !SEMAPHORE_OUVERT)
  {
    resultat = true;
  }
  return resultat;
}

void Appareil::Vt_Test()
{
  VT_TEST_ETAT = !VT_TEST_ETAT;
  digitalWrite(VT_TEST, VT_TEST_ETAT);
}

boolean Appareil::Annonce()
{
  boolean resultat = false;
  if (!digitalRead(BN_ANNONCE))
  {
    delay(100);
    if (!digitalRead(BN_ANNONCE))
    {
      while (!digitalRead(BN_ANNONCE))
      {
      }
      resultat = true;
    }
  }
  return resultat;
}

void Appareil::Vt_Annonce()
{
  VT_ANNONCE_ETAT = !VT_ANNONCE_ETAT;
  digitalWrite(VT_ANNONCE, VT_ANNONCE_ETAT);
}

boolean Appareil::Reddition()
{
  boolean resultat = false;
  if (!digitalRead(BN_REDDITION))
  {
    delay(100);
    if (!digitalRead(BN_REDDITION))
    {
      while (!digitalRead(BN_REDDITION))
      {
      }
      resultat = true;
    }
  }
  return resultat;
}

void Appareil::Vt_Reddition()
{
  VT_REDDITION_ETAT = !VT_REDDITION_ETAT;
  digitalWrite(VT_REDDITION, VT_REDDITION_ETAT);
}

Appareil BlockX;
Appareil BlockY;

void setup()
{
  Serial.begin(9600);
  Serial.println(NAME);
  Serial.println(NAME2);
  Serial.println(NAME3);
  Serial.println("---------------------------------------------------------------------------");
  Serial.print(VERSION); Serial.print(", "); Serial.println(COPYRIGHT);
  Serial.println("---------------------------------------------------------------------------");
  Serial.println("");
  BlockX.Setup(1);
  BlockY.Setup(2);
}

void loop()
{
  unsigned long Temps;
  while (BlockX.Blocage() || BlockY.Blocage())
  {
  }
  if (BlockX.Test())
  {
    if (BlockX.Voielibre() && BlockY.Voielibre())
    {
      Temps = millis();
      BlockX.Vt_Test();
      //Possibilité d'ouvrir le sémaphore durant 5 secondes (5000 millisecondes)
      digitalWrite(SemaphoreX_OUT, LOW);
      while (((millis() - Temps) < 5000) || digitalRead(SemaphoreX_IN) == HIGH )
      {
        BlockX.SEMAPHORE_OUVERT = !digitalRead(SemaphoreX_IN);
        delay(100);
      }
      digitalWrite(SemaphoreX_OUT, HIGH);
      if (BlockX.SEMAPHORE_OUVERT)
      {
        // Attente de la confirmation de la fermeture du sémaphore (levier)
        while (digitalRead(SemaphoreX_IN)==LOW)
        {
        }
        // Attente de l'annonce de X à Y
        while (!BlockX.Annonce())
        {
        }
        BlockX.Vt_Annonce();
        BlockY.Vt_Reddition();
        // Activation de la sonnerie de Y tant que Y n'appuie pas sur le bouton Sonnerie
        // Attente de la reddition de Y
        while (!BlockY.Reddition())
        {
        }
        BlockY.Vt_Reddition();
        BlockX.Vt_Annonce();
        // Activation de la sonnerie de X durant x secondes
      }
    }
  }
  if (BlockY.Test())
  {

  }
}