Page 1 sur 2

Les fiches pratiques de Loco-Revue sur Arduino

MessagePublié: Lun 24 Avr 2017, 11:33
par Arduino
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

Re: Les fiches pratiques de Loco-Revue sur Arduino

MessagePublié: Mar 25 Avr 2017, 15:09
par Bravigou
Excellente initiative Christian. Sois le bienvenu à Bravig'Lille, j'ai un excellent Jasnière qui sort des chais du Marquis de la Volière.

Re: Les fiches pratiques de Loco-Revue sur Arduino

MessagePublié: Mar 25 Avr 2017, 16:49
par Arduino
Je ne manquerai pas de te rendre visite. :wink:

Re: Les fiches pratiques de Loco-Revue sur Arduino

MessagePublié: Ven 02 Juin 2017, 14:40
par Arduino
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:

Re: Les fiches pratiques de Loco-Revue sur Arduino

MessagePublié: Sam 03 Juin 2017, 07:59
par likiki
Très sympathique ce petit montage.

Re: Les fiches pratiques de Loco-Revue sur Arduino

MessagePublié: Dim 27 Août 2017, 17:42
par Arduino
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:

Re: Les fiches pratiques de Loco-Revue sur Arduino

MessagePublié: Lun 28 Août 2017, 09:37
par Arduino
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:

Re: Les fiches pratiques de Loco-Revue sur Arduino

MessagePublié: Lun 28 Août 2017, 10:37
par jeanmi67
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

Re: Les fiches pratiques de Loco-Revue sur Arduino

MessagePublié: Mar 29 Août 2017, 09:17
par Arduino
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:

Re: Les fiches pratiques de Loco-Revue sur Arduino

MessagePublié: Mar 29 Août 2017, 09:22
par Arduino
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...

Re: Les fiches pratiques de Loco-Revue sur Arduino

MessagePublié: Mar 29 Août 2017, 18:50
par Gugus
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 !

Re: Les fiches pratiques de Loco-Revue sur Arduino

MessagePublié: Mar 29 Août 2017, 21:18
par Arduino
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.

Re: Les fiches pratiques de Loco-Revue sur Arduino

MessagePublié: Mer 30 Août 2017, 21:01
par Nicolas Novel-Catin
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).

Re: Les fiches pratiques de Loco-Revue sur Arduino

MessagePublié: Jeu 31 Août 2017, 16:25
par Pierre59
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

Re: Les fiches pratiques de Loco-Revue sur Arduino

MessagePublié: Jeu 31 Août 2017, 16:57
par 12035
Bonjour,
Merci pour les tutos :applause: