Messages

1

Les réseaux / Re : Réseau Dominique

« le: janvier 13, 2022, 08:18:58 pm »

Bravo Dominique pour ce superbe réseau.

La structure et le décor sont superbes. Je suis aussi très impressionné par le TCO et l'alignement des autres modules de commande.

Je profite de te poser une question au sujet des moniteurs vidéo à droite. J'imagine que c'est pour surveiller la gare cachée. Quelle technologie as-tu employé ? webcam en USB ou un autre système ?

Bonne suite de réalisation.

2

Les réseaux / Re : Période de l'avent

« le: janvier 13, 2022, 08:14:53 pm »

Bonjour à tous,

Un tout grand merci pour tout ces compliments !

Je réfléchis aussi à la meilleure manière de décrire les développements électronique et C++ pour ce réseau. J'avais déjà commencé une série de posts sur le forum, mais elle n'est pas encore complète. Il manque les descriptions de la gare cachée, des itinéraires et du chef de gare qui coordonne le tout.

C'est avec plaisir que j'échangerai au sujet d'un projet d'article(s) sur ce sujet.

Bon début d'année et belles réalisations.

3

Présentez vous ! / Re : Présentation de Paxe04

« le: janvier 08, 2022, 11:15:10 pm »

Bonjour Serge et bienvenue parmi nous,

Tu es au bon endroit pour découvrir l'Arduino appliqué au modélisme ferroviaire. Prends bien le temps de lire les articles du site éditorial et commence par des projets simples tels que les animations lumineuses.

Meilleures salutations de Suisse romande. 

Marc-Henri

4

Les réseaux / Re : Période de l'avent

« le: décembre 20, 2021, 11:48:16 am »

Bonjour à tous,

J'ai le plaisir de vous annoncer que mon réseau hivernal a fait l'objet d'un article dans N-Bahn Magazin, édition de janvier 2022 qui vient de paraître, sous le titre Durch Schildburg im Schnee -
Kleine Winteranlage mit Magnorail-Busstrecke in hügeligem Umfeld (à Schildburg dans la neige - un petit réseau hivernal avec une ligne de bus Magnorail et des collines).

Mes prochains projets en modélisme ferroviaire sont un PN pour un ami et l'amélioration de la ligne à crémaillère de mon 1er réseau N. Il s'agit de 2 projets qui seront très certainement basés sur l'Attiny 45. Je créerai des sujets dans le forum pour présenter ces projets plus en détail.

Meilleurs voeux à tous.

5

Présentez vous ! / Re : Nouveau participant

« le: décembre 13, 2021, 01:43:54 pm »

..j'ai les bases (électronicien de formation) et l'expérirence professionnelle (logiciels embarqués), donc mise à part une vue de près beaucoup moins acérée ca devrait le faire!

Bonjour et bienvenue sur le forum Locoduino.

Tu verras que l'expérience du logiciel embarqué est très facilement transposable au monde l'Arduino et à son application au modélisme ferroviaire. J'étais dans le même cas que toi en 2009 lorsque j'ai abordé les microcontrôleurs AVR, ceux qui équipent la majorité des Arduino, pour mon 1er réseau. Mon expérience du logiciel embarqué et du C m'ont donné une très bonne base de départ.

Et l'électronique devrait te permettre de créer facilement les interfaces entre l'Arduino et un réseau miniature.

Bon succès dans tes réalisations et meilleures salutations.

6

Les réseaux / Période de l'avent

« le: novembre 30, 2021, 10:43:14 pm »

Bonjour à tous,

J'ai terminé la réalisation de mon réseau hivernal juste après Noël 2020, donc trop tard pour le dernier Noël, mais suffisamment tôt pour Noël 2021. 



En publiant à nouveau cette vidéo, j'aimerais vous souhaiter une belle période de l'avent et surtout de bien vous porter.

7

Les réseaux / Re : Mon mini réseau dans mon Village de Noël

« le: novembre 30, 2021, 10:34:53 pm »

Bravo pour ce réseau avec beaucoup d'animation. Il aurait sa place dans la vitrine d'un magasin de jouets.

8

Vos projets / Re : Re : Futur réseau en N

« le: novembre 09, 2021, 08:56:11 am »

Les cantons avec zone d'arrêt sont surtout faits pour un réseau analogique. Bien sûr, ils peuvent être utilisés sur un réseau numérique mais j'aurais tendance à dire que ce serait dommage de voir une motrice s'arrêter brusquement alors qu'on peut la faire décélérer progressivement jusqu'à arrêt complet devant le signal.

Bonjour à tous,

Il y a aussi les zones d'arrêt ABC qui fonctionnent avec les décodeurs ESU, Lenz et probablement d'autres marques. Cette méthode permet les arrêts et redémarrages progressifs.

C'est ce que j'ai mis en oeuvre sur mon réseau hivernal. J'ai réalisé des cartes prenant en charge la détection ainsi que la commutation ABC qui rend le signal DCC asymétrique et déclenche le freinage. De cette manière, l'Arduino ne contrôle pas les trains individuellement, il les détecte et les arrête dans les gares visible et cachée. Cette approche convient pour un petit réseau, mais elle est peut-être trop limitée pour un plus grand.

Bonne suite de réalisation.

9

Vie du forum / Re : Re : Re : Pensez aux "Nuls", svp.

« le: novembre 05, 2021, 02:07:02 pm »

...Pourtant, il y a tout sur le site pour arriver à comprendre, sauf une chose : le goût de l'effort. Car cela ne se communique pas...

Bonjour Christian,

Je pense que tu as pointé un problème qui n'est malheureusement pas spécifique à notre domaine.

Fort heureusement, il y a aussi beaucoup de personnes qui ont l'esprit "Maker / FabLab" et donc parfaitement en phase avec la démarche Locoduino.

Je profite de ce message pour remercier tous les contributeurs de Locoduino (et de Loco Revue) pour cet important effort de partage de connaissances.

Bonne fin de semaine et meilleures salutations.

10

Trucs & astuces / Re : Re : Re : Techniques de mise au point

« le: novembre 03, 2021, 12:00:37 pm »

Suite à pas mal d'échanges avec plusieurs "anciens" utilisateurs, je crois que les débutants sont partis depuis longtemps.
Locoduino est désormais surtout utilisé par des "PROS".

C'est très positif pour le site, mais combien de passionnés de trains ne trouvent plus leur compte et vont chercher ailleurs les réponses à leurs questions.

Bonjour à tous,

S'il n'y a plus de débutant c'est peut-être qu'ils ont acquis suffisamment de connaissances et d'expérience. 

Parmi les passionnés de trains, les débutants prêts à passer du temps pour expérimenter et ainsi consolider leurs connaissances ont le plus de chance de faire aboutir leurs projets. Mais le chemin peut être long.

Peut-être que ceux qui ne trouvent pas leur compte pensent que l'Arduino n'est qu'une alternative aux systèmes du commerce qu'il suffit de brancher pour obtenir un résultat en faisant l'impasse sur le processus d'apprentissage.

Il semble donc nécessaire de bien décrire la démarche autour de l'Arduino et les étapes à suivre pour acquérir les connaissances.

Meilleures salutations.

11

Présentez vous ! / Re : Présentation de Julaye

« le: novembre 03, 2021, 08:13:01 am »

@Dominique,

Quelques recherches sur le web m'ont permis de voir que void main n'est pas standard, même si certains compilateurs l'acceptent. C'était le cas de la version d'avr-gcc utilisée lors du développement de ce projet, mais cela ne passe plus avec la version actuelle.

Il faut donc bien spécifier int comme type de retour. Je pense que c'est dû au fait qu'un programme en C écrit pour un ordinateur autre qu'un système embarqué doit retourner une valeur à l'issue de son exécution (0: tout s'est bien passé, autre valeur: erreur). Cela ne s'applique évidemment pas à nos programmes constitués d'une boucle principale ne se terminant pas, mais c'est exigé par la plupart des compilateurs.

Meilleures salutations.

12

Présentez vous ! / Re : Présentation de Julaye

« le: novembre 02, 2021, 11:56:23 am »

Bonjour Julaye,

À mon tour je te souhaite la bienvenue parmi nous.

@chris_bzg je choisi toujours l'outil et l'architecture la plus adaptée à ce que je souhaite programmer. Les objets sont un outil possible mais pas toujours le plus efficient. Pour l'embarqué sur du matériel comme le Nano, j'aime bien le C (de Ritchie), les machines à état fini et les co-routines.

Les machines à états finis sont très présentes dans les systèmes embarqués. Je les ai utilisées dans la plupart de mes développements pour le modélisme ferroviaire. Au début j'ai réalisé des projets directement en C sur des Attiny2313 et Atmega8, plus récemment je suis passé à l'Arduino pour plus de puissance et utiliser C++. Mon réseau hivernal est contrôlé par plusieurs classes C++ implémentant chacune une machine à états finis. Voir https://forum.locoduino.org/index.php?topic=763.msg13315#new.

Mais les coroutines sont intéressantes lorsque le traitement est majoritairement séquentiel. Une implantation très pratique des coroutines sont les protothreads dont la documentation se trouve ici: http://dunkels.com/adam/pt/. C'est simple à mettre en oeuvre et ne requiert que quelques includes, car implanté sous forme de macros du préprocesseur.
L'exemple ci-après est la gestion en C sur Attiny2313 d'un PN dont les barrières sont actionnées par des servo moteurs. Il y a 3 protothreads: 2 pour faire clignoter les signaux sur les 2 PN, 1 pour actionner les barrières de l'un des PN, l'autre n'en ayant pas.

Au plaisir d'échanger sur ces sujets.
Meilleures salutations.

Code: [Sélectionner]

//
//   PassageNiveau.c
//
//   Programme de contrôle du passage à niveau.
//
//   2010.06.12   MHP   Création.
//   2011.06.14   MHP   Premiers tests concluants de commande du servo-moteur.
//   2011.06.20   MHP   Utilisation des protothreads PC (Adam Dunkels, adam@sics.se).
//   2011.06.22   MHP   Premier essai des prothothreads AVR.
//   2011.06.24   MHP   Correction des timings ville et prise en compte du transistor de sortie (inverser PWM).
//   2011.07.06   MHP   Configuration des entrées/sorties définitive!
//   2011.07.07   MHP   Réglage des délais pour la ville.
//   2011.09.10   MHP   Raccourcissement de la période et attente avant de redécter le train au PN ville.
//   2011.12.20   MHP   Suppression de l'anti-rebond pour la détection des trains et ralentissement des mouvements
//            des barrières.
//   2012.04.01   MHP   Suppression du délai entre 2 détections PN ville car nouveaux circuits de détection unidirectionnels.
//
//   Directives de compilation: PC ou AVR.
//

// Includes standard: types, IO.
#ifdef PC
#include   <stdint.h>
#include   <stdio.h>
#endif

#ifdef AVR
#include <inttypes.h>
#include <avr/io.h>
#endif


// Protothreads.
#include "pt.h"

static struct pt ptGererSignalVille, ptGererBarrieresVille, ptGererSignalGare;


// Timers.
typedef uint16_t   tTimer;

static tTimer   tmrBaisserBarrieresVille, tmrBarrieresVille, tmrClignSignalVille, tmrMvtBarrieresVille;
static tTimer   tmrGareA, tmrGareB, tmrClignSignalGare;

// Tous les délais sont exprimés nombres de périodes de PERIODE millisecondes.
// Période en ms.
#define   PERIODE   10

// La durée durant laquelle le signal fonctionne est exprimée en nombre d'itérations
// plutôt qu'à l'aide d'un timer.
#define DELAI_CLIGN_VILLE   (300/PERIODE)

#define   DUREE_SIGNAL_VILLE   (14000/PERIODE)
#define   NB_ITER_SIGNAL_VILLE   (DUREE_SIGNAL_VILLE/(2*DELAI_CLIGN_VILLE)+1)
#define   DELAI_BAISSER_BARRIERES_VILLE   (400/PERIODE)

// La durée durant laquelle le signal fonctionne est exprimée en nombre d'itérations
// plutôt qu'à l'aide d'un timer.
#define DELAI_CLIGN_GARE   (300/PERIODE)
#define DUREE_SIGNAL_GARE   (8000/PERIODE)
#define NB_ITER_SIGNAL_GARE   (DUREE_SIGNAL_GARE/(2*DELAI_CLIGN_GARE))

// Le délai lorsque les barrières sont à nouveau levées est plus grand que le délai entre
// le début du signal de ville et la descente des barrières.
#define   DELAI_BARRIERES_VILLE   (DUREE_SIGNAL_VILLE - 5*DELAI_BAISSER_BARRIERES_VILLE)
#define   DELAI_SERVO      (60/PERIODE)


// Constantes communes PC et AVR


// Spécifique AVR.
#ifdef AVR

#define F_CPU 1000000UL
#include <util/delay.h>

// Configuration des ports
#define INPUT_VILLE   PD1
#define   INPUT_GARE_A   PD2
#define   INPUT_GARE_B   PD3
#define INPUT_ATTENTE_A   PD4
#define   INPUT_ATTENTE_B   PD5

#define   OUTPUT_SERVO   PB3
#define OUTPUT_SIGNAL_VILLE   PB1
#define   OUTPUT_SIGNAL_GARE   PB0


#define CONFIG_DDRB   (_BV(OUTPUT_SERVO)|_BV(OUTPUT_SIGNAL_VILLE)|_BV(OUTPUT_SIGNAL_GARE))

#define PASSAGE_VILLE   (!(PIND & _BV(INPUT_VILLE)))
#define PASSAGE_GARE_A   (!(PIND & _BV(INPUT_GARE_A)))
#define PASSAGE_GARE_B   (!(PIND & _BV(INPUT_GARE_B)))

#define   CONFIG_PULLUPD   (_BV(INPUT_VILLE)|_BV(INPUT_GARE_A)|_BV(INPUT_GARE_B)|_BV(INPUT_ATTENTE_A)|_BV(INPUT_ATTENTE_B))
#define CONFIG_DDRD   ~CONFIG_PULLUPD

#define   ATTENTE_A   (!(PIND & _BV(INPUT_ATTENTE_A)))
#define   ATTENTE_B   (!(PIND & _BV(INPUT_ATTENTE_B)))

#define   SetClignVille   (PORTB |= _BV(OUTPUT_SIGNAL_VILLE))
#define ClrClignVille   (PORTB &= ~_BV(OUTPUT_SIGNAL_VILLE))

#define   SetClignGare   (PORTB |= _BV(OUTPUT_SIGNAL_GARE))
#define   ClrClignGare   (PORTB &= ~_BV(OUTPUT_SIGNAL_GARE))
#endif

#ifdef PC
// Pour simuler le passage des trains.
static uint8_t   PASSAGE_VILLE, PASSAGE_GARE_A, PASSAGE_GARE_B, ATTENTE_A, ATTENTE_B;
#endif

#define   MIN_SERVO      1000
#define   MAX_SERVO      1900
#define   PAS_SERVO      20

#ifdef AVR

#define CONFIG_TCCR1A   (_BV(COM1A1)|_BV(WGM11))

// Pour le test, prescaler sur 1024.
#if 0
#define CONFIG_TCCR1B   (_BV(CS12)|_BV(CS10)|_BV(WGM12)|_BV(WGM13))
#endif
// Fonctionnement normal, prescaler sur 1.
#define CONFIG_TCCR1B   (_BV(CS10)|_BV(WGM12)|_BV(WGM13))

#define   PERIODE_SERVO      20000
#endif


static PT_THREAD(GererSignalGare(struct pt *pt))
{

   // On doit pouvoir traiter ces événements quelque soit l'endroit où
   // on se trouve dans le protothread.
   if (ATTENTE_A && (tmrGareA > 0))
   {
#ifdef PC
      printf("Train en attente gare A\n");
#endif
      tmrGareA = DUREE_SIGNAL_GARE;
   } // if

   if (ATTENTE_B && (tmrGareB > 0))
   {
#ifdef PC
      printf("Train en attente gare B\n");
#endif
      tmrGareB = DUREE_SIGNAL_GARE;
   } // if

   PT_BEGIN(pt);

   while (1)
   {
      PT_WAIT_UNTIL(pt, PASSAGE_GARE_A || PASSAGE_GARE_B);

      if (PASSAGE_GARE_A && (tmrGareA == 0))
      {
#ifdef PC
         printf("Passage gare A\n");
#endif
         tmrGareA = DUREE_SIGNAL_GARE;
      } // if

      if (PASSAGE_GARE_B && (tmrGareB == 0))
      {
#ifdef PC
         printf("Passage gare B\n");
#endif
         tmrGareB = DUREE_SIGNAL_GARE;
      } // if

      while ((tmrGareA > 0) || (tmrGareB > 0))
      {
#ifdef PC
         printf("Signal gare ON\n");
#endif
#ifdef AVR
         SetClignGare;
#endif

         tmrClignSignalGare = DELAI_CLIGN_GARE;
         PT_WAIT_UNTIL(pt, tmrClignSignalGare == 0);

#ifdef PC
         printf("Signal gare OFF\n");
#endif
#ifdef AVR
         ClrClignGare;
#endif
         tmrClignSignalGare = DELAI_CLIGN_GARE;
         PT_WAIT_UNTIL(pt, tmrClignSignalGare == 0);
      } // while
   } // while

   PT_END(pt);
} // GererSignalGare


static PT_THREAD(GererSignalVille(struct pt *pt))
{
static uint16_t   nIter;

   PT_BEGIN(pt);

   while (1)
   {
      PT_WAIT_UNTIL(pt, PASSAGE_VILLE);

      for (nIter = 0; nIter < NB_ITER_SIGNAL_VILLE; nIter++)
      {
#ifdef PC
         printf("Signal ville ON\n");
#endif
#ifdef AVR
         SetClignVille;
#endif
         tmrClignSignalVille = DELAI_CLIGN_VILLE;
         PT_WAIT_UNTIL(pt, tmrClignSignalVille == 0);

#ifdef PC
         printf("Signal ville OFF\n");
#endif
#ifdef AVR
         ClrClignVille;
#endif
         tmrClignSignalVille = DELAI_CLIGN_VILLE;
         PT_WAIT_UNTIL(pt, tmrClignSignalVille == 0);
      } // for

#ifdef PC
      printf("Fin signal ville\n");
#endif
   } // while

   PT_END(pt);
} // GererSignalVille


static PT_THREAD(GererBarrieresVille(struct pt *pt))
{
static uint16_t   nLen;   // Longueur de l'impulsion des servos.


   PT_BEGIN(pt);

   while (1)
   {
      PT_WAIT_UNTIL(pt, PASSAGE_VILLE);

#ifdef PC
      printf("Attendre pour baisser les barrières\n");
#endif

      tmrBaisserBarrieresVille = DELAI_BAISSER_BARRIERES_VILLE;
      PT_WAIT_UNTIL(pt, tmrBaisserBarrieresVille == 0);

#ifdef PC
      printf("Début baisser les barrières\n");
#endif
      tmrBarrieresVille = DELAI_BARRIERES_VILLE;

      nLen = MIN_SERVO;
      while (nLen <= MAX_SERVO)
      {
#ifdef PC
         printf("Baisser barrières, servo: %0d\n", nLen);
#endif
#ifdef AVR
         OCR1A = nLen;
#endif
         nLen += PAS_SERVO;

         tmrMvtBarrieresVille = DELAI_SERVO;
         PT_WAIT_UNTIL(pt, tmrMvtBarrieresVille == 0);
      } // while

#ifdef PC
      printf("Barrières baissées\n");
#endif
      PT_WAIT_UNTIL(pt, tmrBarrieresVille == 0);

      nLen -= PAS_SERVO;
      while (nLen >= MIN_SERVO)
      {
#ifdef PC
         printf("Lever barrières, servo: %0d\n", nLen);
#endif
#ifdef AVR
         OCR1A = nLen;
#endif
         nLen -= PAS_SERVO;

         tmrMvtBarrieresVille = DELAI_SERVO;
         PT_WAIT_UNTIL(pt, tmrMvtBarrieresVille == 0);
      } // while

#ifdef PC
      printf("Barrières levées\n");
#endif
   } // while

   PT_END(pt);
} // GererBarrieresVille


void main(void)
{
   // Initialiser les protothreads.
   PT_INIT(&ptGererSignalVille);
   PT_INIT(&ptGererBarrieresVille);
   PT_INIT(&ptGererSignalGare);

   // Configuration spécifique AVR.
#ifdef AVR
   DDRD   = CONFIG_DDRD;
   PORTD   = CONFIG_PULLUPD;
   DDRB   = CONFIG_DDRB;

   ICR1 = PERIODE_SERVO;
   OCR1A = MIN_SERVO;   
   TCCR1A = CONFIG_TCCR1A;
   TCCR1B = CONFIG_TCCR1B;
#endif

#ifdef PC
uint16_t   nIter;

   //PASSAGE_VILLE = 1;
   PASSAGE_GARE_A = 1;

   for (nIter = 0; nIter <= 1000; nIter++)
   {
      printf("Temps: %0000d\n", nIter * PERIODE);

      if (nIter == 2)
         PASSAGE_GARE_A = 0;

      if (nIter == 40)
      {
         printf("ATTENTE_A = 1\n");
         ATTENTE_A = 1;
      }
      if (nIter > 45)
         ATTENTE_A = 0;


      if (nIter == 50)
      {
         printf("PASSAGE_GARE = 1\n");
         PASSAGE_GARE_B = 1;
      }
      if (nIter > 50)
         PASSAGE_GARE_B = 0;
#endif

#ifdef AVR
   while (1)
   {
#endif
      // Mettre à jour tous les timers.
      if (tmrBaisserBarrieresVille > 0)   tmrBaisserBarrieresVille--;
      if (tmrBarrieresVille > 0)      tmrBarrieresVille--;
      if (tmrClignSignalVille > 0)      tmrClignSignalVille--;
      if (tmrMvtBarrieresVille > 0)      tmrMvtBarrieresVille--;
      if (tmrGareA > 0)         tmrGareA--;
      if (tmrGareB > 0)         tmrGareB--;
      if (tmrClignSignalGare > 0)      tmrClignSignalGare--;

      // Traiter les événements.
      GererSignalVille(&ptGererSignalVille);
      GererBarrieresVille(&ptGererBarrieresVille);
      GererSignalGare(&ptGererSignalGare);

#ifdef AVR
      _delay_ms(PERIODE);
#endif
   } // while, for
} // main



13

Débuter / Re : canton de commutation entre 2 boosters

« le: octobre 29, 2021, 11:55:45 am »

Bonjour à tous,

Je me demande si un tel montage est vraiment nécessaire.

Si un réseau comporte plusieurs boosters, ils sont probablement reliés à la même centrale. De ce fait, les signaux DCC issus de ces boosters doivent être en phase et il ne devrait y avoir aucun problème lorsqu'une loco franchit la limite entre les 2 sections alimentées chacune par un booster.

Comme mentionné par plusieurs sites web parlant de DCC, il est impératif d'isoler les 2 rails entre les sections alimentées par des boosters séparés. Il faut aussi s'assurer que les fils ne sont pas croisés afin d'éviter tout cour-circuit.

Bonne fin de semaine et meilleures salutations.

14

Discussions ouvertes / Re : Re : Locoduino, ILS et aimants

« le: octobre 04, 2021, 01:42:46 pm »

...avec les barrières IR, comment es-tu sûr de ne pas avoir perdu un wagon en cours de route et avoir complètement libéré le canton ?...

Pour gérer correctement ce point, l'ILS et un aimant sous le dernier wagon sont le plus adaptés. Il faut bien entendu que le logiciel gère les 2 impulsions.

La barrière IR ne permet pas cette fonction car il n'y a aucun moyen de distinguer le dernier wagon des autres. Pour compter les wagons, il faudrait un moyen de savoir combien de wagons doit comporter le train en cours de détection et donc avoir un moyen d'identifier les trains.

Cela dit, les avantages de la barrière IR en terme de fiabilité me semblent l'emporter sur l'impossibilité de vérifier la présence de tous les wagons.

15

Discussions ouvertes / Re : Locoduino, ILS et aimants

« le: octobre 04, 2021, 08:37:01 am »

Bonjour à tous,

Sur mon réseau hivernal, j'ai une ligne de bus animée par le système Magnorail. Initialement, j'utilisais des ILS pour détecter le passage du bus aux stations et déclencher la temporisation d'arrêt.

Ce n'était pas optimal, j'avais dû ajouter un aimant plus gros que ceux qui tiennent le bus et il empêchait le bon fonctionnement. J'ai finalement choisi des barrières infrarouge en me basant sur cet article du site éditorial Locoduino: https://www.locoduino.org/spip.php?article40. Le fonctionnement est impeccable.

J'ai adapté le schéma comme suit:



Les résistances sont prévues pour une alimentation Vcc de 12 V. Une led fonctionnant à 2 mA dans la base du 2ème transistor permet de positionner la led IR et la photodiode. Lorsqu'elles sont bien en face l'une de l'autre, cette led est éteinte. Elle s'allume en cas d'interruption du faisceau. Le collecteur du transistor de sortie attaque l'entrée trigger d'un monostable à 555 utilisé pour la temporisation. La résistance de tirage (pull-up) est déjà présente dans le montage monostable, d'où son absence ici. Elle n'est pas non plus nécessaire si le collecteur de ce transistor est relié à une entrée Arduino, pour autant qu'elle soit configurée en INPUT_PULLUP.

Moyennant une petite machine à états dans le logiciel, la détection infrarouge est capable de détecter tout le train. Selon la hauteur où la barrière est positionnée, le signal produit par la barrière sera plus ou moins intermittent. Il faut filtrer les cas où le faisceau est rétabli, par exemple entre 2 wagons et considérer que le train a complètement passé lorsque le faisceau est à nouveau rétabli "pendant un certain temps". 

Bon début de semaine.