Forums LR PRESSE

Où il est question de trains, petits et grands

  • Advertisement

Les fiches pratiques de Loco-Revue sur Arduino

Toutes les discussions sur l'Arduino !

Modérateur: MOD

Les fiches pratiques de Loco-Revue sur Arduino

Publié: Lun 24 Avr 2017, 11:33 
Bonjour à tous,

Depuis quelques temps, vous trouvez des fiches pratiques dans la catégorie "Electronique" qui sont consacrées au monde d'Arduino :

N°835 - Février 2017 : Débuter facilement avec Arduino
N°836 - Mars 2017 : Arduino pour surveiller votre réseau
N°837 - Avril 2017 : Comment programmer le µC ATtiny45
N°838 - Mai 2017 : Avec Arduino, commandez un signal de B.A.L

J'espère que ces fiches vous seront utiles et vous donneront envie de découvrir la programmation des microcontrôleurs. Les exemples donnés sont forcément simples (ils doivent tenir sur deux pages) et les programmes sont très courts. Cependant, les contraintes de mise en page ne permettent pas de donner les programmes en excluant tout risque d'erreurs. De plus, pourquoi recopier un programme quand internet nous permet de les télécharger.

J'ai donc décidé de mettre ici, dans ce fil, les programmes des fiches pratiques. Ce fil sera aussi l'occasion d'un échange, réponse aux questions, suggestion de votre part, etc.

Enfin, si le virus d'Arduino vous a contaminé et que vous vouliez en savoir plus, je vous rappelle que le site http://www.locoduino.org est fait pour découvrir et apprendre tout ce qui concerne Arduino appliqué aux trains miniatures.

Et j'espère aussi vous rencontrer à Trainsmania puisque j'ai l'honneur d'y avoir été invité pour faire une conférence. Toute l'équipe de LOCODUINO sera présente et reconnaissable à un badge porté autour du cou : si vous en avez envie, n'hésitez pas à venir discuter d'Arduino avec nous, nous vous attendons.

Programme de la Fiche Pratique de Mars 2017 :

Code: Tout sélectionner
int ledState = LOW;
unsigned long previousMillis = 0;
const long interval = 500;

void setup() {
  pinMode(LED_BUILTIN, OUTPUT); // DEL reliée a broche 13
  pinMode(12, INPUT_PULLUP) ; // ILS d approche du train
  pinMode(11, INPUT_PULLUP) ; // ILS de sortie du train
}

void loop() {
  while(digitalRead(12)==HIGH){}
  while(digitalRead(11)==HIGH)
  {
    unsigned long currentMillis = millis();
    if (currentMillis - previousMillis >= interval) {
      previousMillis = currentMillis;
      if (ledState == LOW) {ledState = HIGH;}
      else {ledState = LOW;}
    digitalWrite(LED_BUILTIN, ledState);
   }
}
digitalWrite(LED_BUILTIN, LOW); // DEL sur OFF
}


Programme de la Fiche Pratique de Mai 2017 :

Code: Tout sélectionner
/***************************
* Signal_BAL - 30/11/2016 *
* *************************
* Ce programme simule le fonctionnement d un signal lumineux a trois
* feux d un B.A.L Block Automatique Lumineux. Il n assure pas
* l espacement des trains. Lorsque la loco declenche le premier ILS,
* le signal se met au rouge. Lorsque la loco declenche le deuxieme
* ILS, le signal se met a l orange pour une duree egale a celle du
* rouge, puis repasse au vert.
*/

/*  VARIABLES
  *  --------------------------------------------------------------
  *  debRouge : temps de debut du feu rouge
  *  finRouge : temps de fin du feu rouge
  *  dureeRouge ; duree du feu rouge
  *  debOrange : temps de debut du feu orange
  *  flagOrange : booleen 0 si feu orange eteint, 1 si allume
  */

  /* BRANCHEMENTS
   * --------------------------------------------------------------
   * ILS E (entree) sur 2
   * ILS S (sortie) sur 3
   * feu vert sur 4
   * feu rouge sur 5
   * feu orange sur 6
   */

const byte ILS_entree = 2;
const byte ILS_sortie = 3;
const byte feu_vert = 4;
const byte feu_rouge = 5;
const byte feu_orange = 6;
unsigned long debRouge = 0;
unsigned long finRouge = 0;
unsigned long debOrange = 0;
unsigned long dureeRouge;
boolean flagOrange = 0;

void setup() {
  pinMode(ILS_entree, INPUT_PULLUP);
  pinMode(ILS_sortie, INPUT_PULLUP);
  pinMode(feu_vert, OUTPUT);
  pinMode(feu_rouge, OUTPUT);
  pinMode(feu_orange, OUTPUT);
  // Initialisation du signal a anode commune, allume par LOW
  digitalWrite(feu_vert, LOW);
  digitalWrite(feu_rouge, HIGH);
  digitalWrite(feu_orange, HIGH);
  }

void loop() {
  // Surveillance de l ILS d entree
  while (digitalRead(ILS_entree) == HIGH)
  {
    // ILS E non declenche
    if (flagOrange)
    {
      if ((millis() - debOrange) > dureeRouge)
      {
        digitalWrite(feu_orange, HIGH);
        flagOrange = 0;
        digitalWrite(feu_vert, LOW);
      }
    }
   }
  // ILS E declenche
  digitalWrite(feu_vert, HIGH);
  digitalWrite(feu_orange, HIGH);
  flagOrange = 0;
  digitalWrite(feu_rouge, LOW);
  debRouge = millis();
  // Surveillance de l ILS de sortie
  while (digitalRead(ILS_sortie) == HIGH)
  {
    // ILS S non declenche, ne rien faire
  }
  // ILS S declenche
  finRouge = millis();
  dureeRouge = finRouge - debRouge;
  digitalWrite(feu_rouge, HIGH);
  digitalWrite(feu_orange, LOW);
  flagOrange = 1;
  debOrange = millis();

}


Au plaisir de vous écrire d'autres fiches pratiques en électronique.

Christian
Avatar de l’utilisateur
Arduino
Prolixe
 
Messages: 1634
Inscrit le: Mer 25 Sep 2013, 16:14

Re: Les fiches pratiques de Loco-Revue sur Arduino

Publié: Mar 25 Avr 2017, 15:09 
Excellente initiative Christian. Sois le bienvenu à Bravig'Lille, j'ai un excellent Jasnière qui sort des chais du Marquis de la Volière.
Gennevilliers Louvain 2018
Avatar de l’utilisateur
Bravigou
Intarissable !
 
Messages: 6455
Inscrit le: Mer 19 Déc 2012, 17:16

Re: Les fiches pratiques de Loco-Revue sur Arduino

Publié: Mar 25 Avr 2017, 16:49 
Je ne manquerai pas de te rendre visite. :wink:
Avatar de l’utilisateur
Arduino
Prolixe
 
Messages: 1634
Inscrit le: Mer 25 Sep 2013, 16:14

Re: Les fiches pratiques de Loco-Revue sur Arduino

Publié: Ven 02 Juin 2017, 14:40 
Le montage décrit dans la fiche pratique III.42 du numéro 838 de mai 2017 fait appel à un module UNO (ce qui est le plus facile pour ceux qui débutent), mais il peut être réalisé avec un microcontrôleur de petite taille comme l'ATtiny45.

Dans ce cas, le programme que vous trouverez un peu plus haut dans cette page écrit pour un module UNO doit simplement être adapté pour que les entrées-sorties soient numérotées de 0 à 4 (par exemple 0 à 2 pour les trois feux du signal et 3 et 4 pour les ILS E et S). Et bien entendu, ILS et signal à anodes communes doivent être reliés aux E/S 0 à 4 du microcontrôleur.

La vidéo ci-dessous montre l'effet obtenu, que ce soit avec un UNO ou un µC ATtiny45 :
https://vimeo.com/219999631

Ce montage est donc à réserver en priorité aux petits réseaux où un seul signal est installé à l'endroit le plus stratégique pour satisfaire l'observateur. :wink:
Avatar de l’utilisateur
Arduino
Prolixe
 
Messages: 1634
Inscrit le: Mer 25 Sep 2013, 16:14

Re: Les fiches pratiques de Loco-Revue sur Arduino

Publié: Sam 03 Juin 2017, 07:59 
Très sympathique ce petit montage.
Cordialement,

Christian.
Avatar de l’utilisateur
likiki
Causant
 
Messages: 257
Inscrit le: Dim 29 Avr 2012, 14:21
Localisation: Corbeil Essonne
Âge: 50
Echelle pratiquée: H0 3R
Prénom: Christian

Re: Les fiches pratiques de Loco-Revue sur Arduino

Publié: Dim 27 Août 2017, 17:42 
Suite à la demande de lecteurs, voici quelques modifications que vous pouvez apporter au montage de la fiche pratique III.42 du numéro 838 de mai 2017 :

Signal à cathode commune :

Le schémas ci-dessous montre comment modifier le montage si votre signal 3 feux est à cathode commune.

Image

Dans ce cas, voici le programme pour le module UNO :

Code: Tout sélectionner
/**************************
* Signal_BAL - 27/08/2017 *
***************************
* Ce programme simule le fonctionnement d un signal lumineux a trois
* feux d un B.A.L Block Automatique Lumineux. Il n assure pas
* l espacement des trains. Lorsque la loco declenche le premier ILS,
* le signal se met au rouge. Lorsque la loco declenche le deuxieme
* ILS, le signal se met a l orange pour une duree egale a celle du
* rouge, puis repasse au vert.
* PROGRAMME POUR SIGNAL A CATHODE COMMUNE
*/

/*  VARIABLES
  *  --------------------------------------------------------------
  *  debRouge : temps de debut du feu rouge
  *  finRouge : temps de fin du feu rouge
  *  dureeRouge ; duree du feu rouge
  *  debOrange : temps de debut du feu orange
  *  flagOrange : booleen 0 si feu orange eteint, 1 si allume
  */

  /* BRANCHEMENTS
   * --------------------------------------------------------------
   * ILS E (entree) sur 2
   * ILS S (sortie) sur 3
   * feu vert sur 4
   * feu rouge sur 5
   * feu orange sur 6
   */

const byte ILS_entree = 2;
const byte ILS_sortie = 3;
const byte feu_vert = 4;
const byte feu_rouge = 5;
const byte feu_orange = 6;
unsigned long debRouge = 0;
unsigned long finRouge = 0;
unsigned long debOrange = 0;
unsigned long dureeRouge;
boolean flagOrange = 0;

void setup() {
  pinMode(ILS_entree, INPUT_PULLUP);
  pinMode(ILS_sortie, INPUT_PULLUP);
  pinMode(feu_vert, OUTPUT);
  pinMode(feu_rouge, OUTPUT);
  pinMode(feu_orange, OUTPUT);
  // Initialisation du signal a cathode commune, allume par HIGH
  digitalWrite(feu_vert, HIGH);
  digitalWrite(feu_rouge, LOW);
  digitalWrite(feu_orange, LOW);
  }

void loop() {
  // Surveillance de l ILS d entree
  while (digitalRead(ILS_entree) == HIGH)
  {
    // ILS E non declenche
    if (flagOrange)
    {
      if ((millis() - debOrange) > dureeRouge)
      {
        digitalWrite(feu_orange, LOW);
        flagOrange = 0;
        digitalWrite(feu_vert, HIGH);
      }
    }
   }
  // ILS E declenche
  digitalWrite(feu_vert, LOW);
  digitalWrite(feu_orange, LOW);
  flagOrange = 0;
  digitalWrite(feu_rouge, HIGH);
  debRouge = millis();
  // Surveillance de l ILS de sortie
  while (digitalRead(ILS_sortie) == HIGH)
  {
    // ILS S non declenche, ne rien faire
  }
  // ILS S declenche
  finRouge = millis();
  dureeRouge = finRouge - debRouge;
  digitalWrite(feu_rouge, LOW);
  digitalWrite(feu_orange, HIGH);
  flagOrange = 1;
  debOrange = millis();

}


Signal carré à anode commune :

Pour ceux qui veulent allumer un carré à la place du rouge, il faut allumer deux LED rouges au lieu d'une seule. Comme on doit allumer soit une seule LED (jaune ou verte), soit deux LED (rouges), le mieux est de placer une résistance de 330 ohm sur chaque sortie afin de ne pas avoir de différence de luminosité entre le rouge et le jaune ou vert; la figure ci-dessous montre comment modifier le montage pour un signal 4 feux à anode commune :

Image

Dans ce cas, le programme publié dans la fiche pratique est utilisable, la séquence étant carré - jaune- vert. Avec 330 ohms, chaque LED est traversée par un courant de 10 mA à peu près, la sortie rouge donne 20 mA (car deux LED) ce qui correspond à ses possibilités.

Signal carré à cathode commune :

Ceux qui veulent faire la même chose avec un signal à 4 feux à cathode commune modifieront le montage selon le schéma ci-dessous et utiliseront le programme publié aujourd'hui :

Image

Encore une fois, la séquence sera carré - jaune - vert.

Vous avez tout en main pour adapter ce petit montage sans prétention à votre réseau en fonction de ce que vous voulez simuler (je rappelle que ce montage n'est qu'une simulation et n'assure pas la protection des circulations). :wink:
Avatar de l’utilisateur
Arduino
Prolixe
 
Messages: 1634
Inscrit le: Mer 25 Sep 2013, 16:14

Re: Les fiches pratiques de Loco-Revue sur Arduino

Publié: Lun 28 Août 2017, 09:37 
Signal de type Carré avec Œilleton :

Je rajoute au montage de la fiche pratique deux sorties : une pour le deuxième feu rouge et une pour l'œilleton. Le schéma qui suit donne le montage à effectuer pour un signal à anode commune. La résistance R1 vaut 220 ohms, mais en fonction de la luminosité de l'œilleton, on peut utiliser une valeur plus forte.

Image

Lors du passage du premier ILS, le signal passe au Carré, œilleton éteint.
Lors du passage du deuxième ILS, le signal passe au Sémaphore, un seul feu rouge allumé et œilleton allumé.
Ceci dure un certain temps dépendant de la durée du transit sur le canton, puis le signal passe à Avertissement (feu orange) pour la même durée, puis revient à Voie libre (feu vert) jusqu'au prochain train.

Voici le programme qui accompagne le montage.

Code: Tout sélectionner
/******************************************
* Signal_BAL_carre_oeilleton - 27/08/2017 *
*******************************************
* Ce programme simule le fonctionnement d un signal lumineux a quatre
* feux d un B.A.L Block Automatique Lumineux avec carre. Il n assure pas
* l espacement des trains. Lorsque la loco declenche le premier ILS,
* le signal se met au carre. Lorsque la loco declenche le deuxieme
* ILS, le signal se met au rouge (semaphore), puis a l orange (avertissement)
* pour des durees egales a celles du carre, puis repasse au vert (voie libre).
********************************************************
* UTILISE UN SIGNAL 4 FEUX + OEILLETON A ANODE COMMUNE *
********************************************************
*/

/*  VARIABLES
  *  --------------------------------------------------------------
  *  debCarre : temps de debut du signal carre
  *  finCarre : temps de fin du signal carre
  *  dureeCarre : duree du signal carre
  *  debRouge : temps de debut du signal rouge (semaphore)
  *  debOrange : temps de debut du feu orange (avertissement)
  *  flagRouge : booleen, false si feu rouge est eteint, true si feu est allume
  *  flagOrange : booleen, false si feu orange est eteint, true si feu est allume
  */

  /* BRANCHEMENTS
   * --------------------------------------------------------------
   * ILS E (entree) sur 2
   * ILS S (sortie) sur 3
   * feu vert sur 4 (voie libre)
   * feu rouge sur 5 (semaphore)
   * feu orange sur 6 (avertissement)
   * feu rouge sur 7 (carre)
   * oeilleton blanc sur 8
   */

const byte ILS_entree = 2;
const byte ILS_sortie = 3;
const byte feu_vert = 4;
const byte feu_rouge = 5;
const byte feu_orange = 6;
const byte feu_carre = 7;
const byte oeilleton = 8;
unsigned long debCarre = 0;
unsigned long finCarre = 0;
unsigned long debRouge = 0;
unsigned long debOrange = 0;
unsigned long dureeCarre;
boolean flagRouge = false;
boolean flagOrange = false;

void setup() {
  pinMode(ILS_entree, INPUT_PULLUP);
  pinMode(ILS_sortie, INPUT_PULLUP);
  pinMode(feu_vert, OUTPUT);
  pinMode(feu_rouge, OUTPUT);
  pinMode(feu_orange, OUTPUT);
  pinMode(feu_carre, OUTPUT);
  pinMode(oeilleton, OUTPUT);
  // Initialisation du signal a anode commune, allume par LOW
  // feu vert et oeilleton allumes
  digitalWrite(feu_vert, LOW);
  digitalWrite(feu_rouge, HIGH);
  digitalWrite(feu_orange, HIGH);
  digitalWrite(feu_carre, HIGH);
  digitalWrite(oeilleton, LOW);
  }

void loop() {
  // Surveillance de l ILS d entree
  while (digitalRead(ILS_entree) == HIGH)
  {
    // ILS E non declenche
    if (flagRouge)
    {
      if ((millis() - debRouge) > dureeCarre)
      {
        digitalWrite(feu_rouge, HIGH);
        flagRouge = 0;
        digitalWrite(feu_orange, LOW);
        flagOrange = 1;
        debOrange = millis();
      }
    }
    if (flagOrange)
    {
      if ((millis() - debOrange) > dureeCarre)
      {
        digitalWrite(feu_orange, HIGH);
        flagOrange = 0;
        digitalWrite(feu_vert, LOW);
      }
    }
   }
   
  // ILS E declenche, on allume le carre
  digitalWrite(feu_vert, HIGH);
  digitalWrite(feu_orange, HIGH);
  flagOrange = false;
  digitalWrite(feu_rouge, LOW);
  digitalWrite(feu_carre, LOW);
  digitalWrite(oeilleton, HIGH);
  debCarre = millis();
 
  // Surveillance de l ILS de sortie
  while (digitalRead(ILS_sortie) == HIGH)
  {
    // ILS S non declenche, ne rien faire
  }
  // ILS S declenche, on eteint le carre et on allume le rouge
  finCarre = millis();
  dureeCarre = finCarre - debCarre;
  digitalWrite(feu_carre, HIGH);
  digitalWrite(oeilleton, LOW);
  digitalWrite(feu_rouge, LOW);
  flagRouge = 1;
  debRouge = millis();

}


Ce programme a été testé sur une platine d'essai. N'étant pas spécialiste en signalisation SNCF, je me suis inspiré d'une doc éditée sur par un forumiste de ce forum, donc j'espère que le fonctionnement de ce signal est conforme à la réalité.

Ceux qui ont un signal à cathode commune pourront s'inspirer des autres exemples pour adapter ce qui est posté aujourd'hui.

Bon modélisme à tous. :wink:
Avatar de l’utilisateur
Arduino
Prolixe
 
Messages: 1634
Inscrit le: Mer 25 Sep 2013, 16:14

Re: Les fiches pratiques de Loco-Revue sur Arduino

Publié: Lun 28 Août 2017, 10:37 
Arduino a écrit:...Lors du passage du premier ILS, le signal passe au Carré, œilleton éteint.
Lors du passage du deuxième ILS, le signal passe au Sémaphore, un seul feu rouge allumé et œilleton allumé...

Bonjour,

Si l'oeuilleton est bien éteint quand c'est le carré qui est affiché, il me semble qu'un carré n'est pas un élément de BAL (Bloc Automatique Lumineux) : un carré protège un endroit dangereux (aiguille, croisement, etc...) et signifie arrêt absolu.
Donc, quand le carré s'efface, c'est le jaune qui s'allume si le prochain signal qui sera rencontré est rouge, ou le vert dans le cas contraire.

Indépendamment du fonctionnement réel d'un signal ou d'un BAL, et en ce qui me concerne, le but des fiches Pratiques de Loco-Revue sur Arduino est atteint avec tous ces exemples que vous développez pour faire avancer nos connaissances sur la programmation et l'utilisation de l'Arduino. :applause:

J'attends donc impatiemment la prochaine fiche :D

Jean-Michel
Jeanmi67
Membre AFAN
Avatar de l’utilisateur
jeanmi67
Papotier
 
Messages: 109
Inscrit le: Mar 06 Déc 2011, 00:06
Localisation: PACA
Âge: 64
Echelle pratiquée: N

Re: Les fiches pratiques de Loco-Revue sur Arduino

Publié: Mar 29 Août 2017, 09:17 
Promis, je vais en écrire d'autres !
Mais il y a aussi le site LOCODUINO où tous ceux qui s'intéressent à Arduino (pour le train miniature) peuvent trouver des idées. La rentrée va être très riche de nouveaux articles. :wink:
Avatar de l’utilisateur
Arduino
Prolixe
 
Messages: 1634
Inscrit le: Mer 25 Sep 2013, 16:14

Re: Les fiches pratiques de Loco-Revue sur Arduino

Publié: Mar 29 Août 2017, 09:22 
jeanmi67 a écrit:
Si l'oeuilleton est bien éteint quand c'est le carré qui est affiché, il me semble qu'un carré n'est pas un élément de BAL (Bloc Automatique Lumineux) : un carré protège un endroit dangereux (aiguille, croisement, etc...) et signifie arrêt absolu.
Donc, quand le carré s'efface, c'est le jaune qui s'allume si le prochain signal qui sera rencontré est rouge, ou le vert dans le cas contraire.


Jean-Michel


C'est exact, un carré est là pour signaler un endroit dangereux.
Ce que j'ai développé répond aux besoins d'un modéliste qui souhaitait cette séquence : carré - rouge- jaune - vert qui a d'ailleurs été décrite dans une doc publiée sur ce forum et dont je me suis inspiré. J'ai donc voulu en faire profiter le plus grand nombre.
Il y a maintenant assez d'exemples pour que chacun choisisse la séquence qu'il veut mais effectivement, un B.A.L fait appel à des signaux trois feux, comme ce qui a été décrit dans la fiche pratique.
Si un spécialiste des signaux SNCF peut nous donner son avis sur le carré et sa séquence d'allumage, ce n'est pas de refus...
Avatar de l’utilisateur
Arduino
Prolixe
 
Messages: 1634
Inscrit le: Mer 25 Sep 2013, 16:14

Re: Les fiches pratiques de Loco-Revue sur Arduino

Publié: Mar 29 Août 2017, 18:50 
Bonsoir

Sans prétendre être spécialiste, il est tout à fait possible qu'un carré s'ouvre sur un sémaphore.
Je le constate souvent lorsque j'attend mon train à Versailles Chantiers. Les voies à quai B et C convergent en sortie de gare sur la voie 2bis. Etant donné le trafic important, les trains sont reçus alternativement sur voie B et voie C.
La séquence est la suivante :
- Départ d'un train voie B. Fermeture du carré voie B
- Dès que celui-ci a quitté la zone d'aiguilles, l'itinéraire voie C - Voie 2bis est tracé pour le train suivant.
- Une fois les aiguilles en place, il n'y a plus de point dangereux à protéger, mais le canton est toujours occupé. Donc le signal voie C affiche alors le sémaphore
- Puis avec l'éloignement du train précédent on a la séquence avertissement - > jaune cli (cantons courts) -> VL (ou annonce ralentissement 60 si le train est dirigé vers la voie 2 à la bifur de Porchefontaine)

On a donc tous les aspects possibles en une séquence sur ces signaux !
Avatar de l’utilisateur
Gugus
Fécond
 
Messages: 582
Inscrit le: Jeu 15 Oct 2009, 18:50
Localisation: Versailles (78)
Âge: 32
Echelle pratiquée: HO

Re: Les fiches pratiques de Loco-Revue sur Arduino

Publié: Mar 29 Août 2017, 21:18 
Merci pour ces précisions, du vécu en plus.
C'est ce que j'avais trouvé sur la doc éditée par Greg84, mise à jour de février 2016.
Ceci dit, le signal de type Carré est plutôt à réserver pour une zone d'aiguillages, en pleine voie, le B.A.L utilise des signaux à 3 feux.
Chacun pourra donc adapter la fiche pratique (complétée par ce qui vient d'être publié) à la configuration de son réseau et aux signaux dont il dispose.
Avatar de l’utilisateur
Arduino
Prolixe
 
Messages: 1634
Inscrit le: Mer 25 Sep 2013, 16:14

Re: Les fiches pratiques de Loco-Revue sur Arduino

Publié: Mer 30 Août 2017, 21:01 
Bonsoir,
Il y a un article sur Massimo Banzi, le co-inventeur d'Arduino dans Le Monde daté du 30 août 2017 (supplément sciences & médecine).
Vapeur en vrai & modélisme
Avatar de l’utilisateur
Nicolas Novel-Catin
Éloquent
 
Messages: 357
Inscrit le: Sam 28 Mars 2015, 19:39
Echelle pratiquée: H0 et H0e
Prénom: Nicolas
Club: CFBS, VFV, APPEVA et ARF

Re: Les fiches pratiques de Loco-Revue sur Arduino

Publié: Jeu 31 Août 2017, 16:25 
Arduino a écrit:Ceci dit, le signal de type Carré est plutôt à réserver pour une zone d'aiguillages, en pleine voie, le B.A.L utilise des signaux à 3 feux.

Bonjour

Je suis actuellement en vacances à coté de la ligne Nice-Menton, les sémaphores de BAL à 3 feux sont plutôt rares, pour différentes raisons :
- présence de jonctions d'IPCS (Installations Permanentes de Contresens) à Beaulieu
- les gares de Nice, Monaco et Menton
- des embranchements dans les gares de Beaulieu et de Roquebrune-Cap-Martin
- des filets de détection de chutes de pierres dans plusieurs endroits imposant un carré à la place du sémaphore pour arrêter automatiquement les trains

Finalement sur cette portion de ligne (un peu particulière j'en conviens) :
- peu de sémaphores de pleine voie à 3 feux
- pas mal de sémaphores de pleine voie avec ralentissement (2 feux jaunes en plus) en amont des carrés avec rappel de ralentissement
- pas mal de sémaphores de pleine voie qui sont des carrés, 4 feux
- pas mal de sémaphores qui sont des carrés protégeant des aiguilles (avec ou sans rappel de ralentissement), 4 feux ou 6 feux

La SNCF sur le terrain ce n'est pas toujours aussi simple que l'on veut bien le dire !

Amicalement

Pierre
Avatar de l’utilisateur
Pierre59
Papotier
 
Messages: 146
Inscrit le: Dim 07 Mars 2010, 09:17
Localisation: Villeneuve d'Ascq (59650)
Âge: 74
Echelle pratiquée: HO
Club: Lille Modélisme

Re: Les fiches pratiques de Loco-Revue sur Arduino

Publié: Jeu 31 Août 2017, 16:57 
Bonjour,
Merci pour les tutos :applause:
@+
12035
Avatar de l’utilisateur
12035
Loquace
 
Messages: 1023
Inscrit le: Lun 08 Déc 2008, 13:20

Suivant

Retour vers Arduino

Qui est en ligne ?

Utilisateur(s) parcourant actuellement ce forum : Aucun utilisateur inscrit et 3 invité(s)