Block système manuel de voie unique

[François D]

Je vais essayer d'ouvrir un de mes BP pour voir si on peut accéder à la LED pour la changer.
Ils sont fabriqués en Chine à la chaine et apparemment complètement modulables selon les souhaits du client. Je dois bien arriver à en désosser un complètement.

[JeanMarc]

Bonjour,

La LED verte allumée au lieu du voyant de réponse au test est un bon compromis. Sur les armoires de block, la réponse positive au test est signalée par l'affichage d'une croix verte sur fond blanc par un voyant électromécanique (La durée d'apparition de cette "réponse au test" varie de 30 à 45s selon les postes, temps où l'ont peux commander à l'ouverture le carré ou sémaphore de sortie)

L'utilisation de voyants électromécanique sont d'usage également pour les voyants "annonce" et "reddition". Sur les armoires de block, bien-sur. Je pense qu'une simple LED allumé pour chaque est suffisant

Concernant Woincourt, pas de BMVU en effet

[ffayolle]

Bonjour,

Merci Jean-Marc...

J'ai décidé de reproduire visuellement un appareil de block type année 1960 pour les raisons suivantes:
1) appareil de block utilisé lors de la période de transition vapeur diesel
2) infographie permet de se rapprocher du prototype à moindre coût
3) composants électroniques de grande diffusion à prix très abordable

Mais rien n'empêche de faire une version miniaturisée même si la facture des composants électroniques (bouton poussoir carré lumineux) sera nettement plus élévée. Cf. https://docs-emea.rs-online.com/webdocs ... 0b35f8.pdf
Difficile par contre de trouver une version miniaturisée d'un commutateur rotatif à 2 positions

Ayant tenu compte de la remarque de Jean-Marc sur la non nécessité d'avoir un voyant blanc en sus de, voilà le résultat :

BMVU-Modélisme.jpg (41.91 Kio) Vu 2596 fois

La face avant d'une appareil de block fait 60 sur 90mm.
Par block, sachant qu'il y a 2 appareils, il faudra:
- 1 carte Arduino MEGA voire une carte Arduino UNO (cf. http://jurasecondairen.blogspot.com/p/5 ... er.html#54)
- 8 boutons poussoirs de couleur noir
- 2 interrupteurs 1RT avec capuchon rouge
- 6 supports de LED 3mm
- 2 LED 3mm couleur vert
- 2 LED 3mm couleur rouge
- 2 LED 3mm couleur bleu

"Icing on the cake" comme disent nos amis d'Outre-Manche, il reste à trouver une solution pour la sonnerie.
3 possibilités:
- connecter une cloche à la carte Arduino en utilisant certainement une carte Relais
- enregistrer la sonnerie réelle d'un appareil de block et utiliser un WTV020SD-16P (cf. http://www.modelrailway-online.com/ardu ... ecteur-mp3) ou un DFPlayer (CF. https://www.factoryforward.com/mp3-tf-1 ... -dfplayer/)
- non trouvée à l'instant T

A suivre...

Fabrice

[ffayolle]

[Eiffel]

Heu.........c'est pas vraiment ça!
Un peu trop violent.
Ne pas oublier que les boites de block se trouvent à l'intérieur du poste, donc dans un environnement contraint...

[ffayolle]

Enregistrement à revoir mais à me tromper, il y a des appareils de block installés à l'extérieur au niveau du quai. Vague souvenir de mino que j'étais...

[JeanMarc]

Bonjour à tous,

Pour la sonnerie d'annonce, c'est exactement ça Fabrice lorsque les appareils de block sont situées dans un poste à l'extérieur du BV (comme c'est souvent le cas dans les gares de VU).

Dans les cas où le poste est situé en extérieur du BV (Exemple ci-dessous pour la gare de Hermes-Berthecourt), les cloches d'annonce situées dans le poste sont différenciées selon l'origine de l'annonce. Ces sonneries d'annonce sont répétées à l’intérieur du BV. En effet, dans les gares où j'ai été en service, il y avait deux types d'annonce: une sonnerie "bois" (Sens Pair) et une sonnerie "métal" (Sens Impair) (Ceci permet de pouvoir connaître, à l'oreille, la provenance du (ou des, en cas de croisement) du train annoncé.)

A confirmer par les spécialistes (Service Electrique): Les appareils de block (année 50 et après 60) peuvent être située en extérieur (ex: Cires, Hermes, Mouy, Grandvilliers, ...) et en intérieur(ex: Tréport). Par contre, je n'ai jamais vu de block miniaturisé en extérieur .

Et voici quelques photos, j'ai choisis volontairement Hermes-Berthecourt

Le poste Y de la gare de Hermes-Berthecourt (VU Creil-Beauvais) est situé à l'extérieur du BV


Poste Y de Hermes-Berthecourt


Intérieur du Poste Y de Hermes-Berthecourt


Les voyants électromécaniques, sonneries et commandes du Poste Y.


Appareils de block côté Mouy-Bury


J'ajouterai quelques photos un peu plus tard, j'en ai encore en réserve sur d'autre gare

PS: Bonne fête Fabrice

[Eiffel]

Au temps pour moi, j'étais plus focalisé sur les boites réduites dont la sonnerie est plus proche du buzzer que de la cloche d'annonce.
Et à y réfléchir, c'est vrai que les appareils sont souvent groupés avec les commandes d'aiguilles et les divers voyants de contôle, donc en extérieur.
Méa culpa!

[JeanMarc]

Pas de soucis Fred De mon côté, je n'ai pas fait de cantonnement avec du block miniaturisé pour l'instant

[ffayolle]

Bonsoir,

Jean-Marc pour les photographies

Comme prévu, formation ce jour avec Eiffel ( à lui) sur le fonctionnement du BMVU avec des appareils de block de type Année 1960. Le séquencement étant maintenant connu (algorithme), il n"y a plus qu'à retranscrire le tout en langage Arduino.

Le programme ci-dessous n'est pas encore complet mais la logique du séquencement est là.

A suivre...

Fabrice

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())
  {

  }
}