LOCODUINO

Forum de discussion
Dépôt GIT Locoduino
Flux RSS

lundi 21 août 2017

25 visiteurs en ce moment

Un automatisme de Passage à Niveau

Avec un simple Pro Mini

. Par : Dominique, JPClaude

Un éminent membre de mon club butait depuis un certain temps sur un automatisme de passage à niveau à partir d’une logique à relais.

Il faut dire que ce passage supporte une double voie, dont une branche est en "Y". Le cahier des charges impose de ne lever les barrières que lorsque toute la zone est libre de trains.

J’ai décidé de relever le défi avec un Arduino et d’ajouter un ultime raffinement : le clignotement réaliste des feux rouges (coté route) à leds.

Voici les détails de la réalisation que vous pourrez certainement adapter à votre réseau.

Le cahier des charges

Le passage à niveau doit protéger une double voie, dont l’une des branches est en "Y". Il y a donc 5 sections de voies de part et d’autre du passage à niveau.

Sur chaque branche, sont disposés 2 détecteurs de type interrupteur à lame souple, "ILS".
Il y en a donc 10 au total.

Le plus proche du passage à niveau doit déclencher la fermeture des barrières lorsque le train va vers le passage.
Le plus éloigné du passage à niveau doit déclencher l’ouverture des barrières lorsque le train s’éloigne du passage. Attention toutefois, les barrières ne doivent pas s’ouvrir tant qu’il reste un autre train dans la zone comprise entre tous les détecteurs éloignés.

Tant que les barrières ne sont pas complètement ouvertes, les feux rouges de chaque coté, sur la route doivent clignoter. Comme dans la réalité, ce sont des lampes à incandescence qui s’allume et s’éteignent avec une certaine inertie, on reproduira cette inertie sur des Leds rouges, gräce aux commandes analogiques.

Enfin, l’ouverture et la fermeture des barrières est opéré par un moteur Fulgurex livré avec le passage à niveau. Ce moteur devra donc être alimenté dans un sens ou dans l’autre pendant 4 à 5 secondes environ. Les feux restent donc en service pendant cette manoeuvre.

Le matériel nécessaire

Compte tenu de ce cahier des charges, un Arduino Mini suffira. L’absence de port USB est compensée par le fait que je dispose d’interface "Bob" d’Elektor qui se raccordent facilement sur le Mini dont les pins sont sur un des petits cotés. On trouve également sur le web des interfaces USB-serie pour presque rien. Dernièrement j’ai même trouvé un Arduino Mini avec l’interface USB-série séparée, le tout pour 6€ environ (avec le chip original FT232 de FTDI).

Attention : il faut bien relier la sortie TxD de l’interface USB avec l’entrée RxD du Mini, ainsi que la sortie TxD du Mini avec l’entrée RxD de l’interface USB. Ensuite on relie le Vcc au Vcc, le Gnd au Gnd et la sortie DTR de l’interface USB à la patte marquée GRN sur le Mini (c’est ce qui permet à l’IDE Arduino de passer le Mini en mode programmation).

Arduino Pro-Mini

Les ILS sont raccordés directement sur 10 pins de l’Arduino, les communs des ILS étant regroupés sur le 0V.

Les feux sont réalisés avec 2 Leds rouges en série, sur une pin analogique (à sortie en PWM  ) du Mini.

Les commandes du moteur sont faites avec une carte à 2 relais qui se pilote par 2 sorties du Mini. J’ai choisi 2 pins analogiques, utilisées en digital.

Une extension à 2 relais unipolaires

Pour alimenter l’Arduino, les Leds et les relais, j’ai réalisé une petite alimentation régulée par un 7805, avec un pont de diode et quelques condensateurs. J’ai préféré cela au régulateur embarqué dans le Mini, qui me semble un peu sous-dimensionné pour alimenter les relais et les Leds.

Au total, on peut s’en sortir avec 10€ de matériel, sans les ILS ni le passage à niveau.

Le schéma

Sur ce schéma, la carte à 2 relais est représentée par seulement 2 relais, n’ayant pas le dessin de l’élément acheté qui se raccorde par 4 contacts : relai 1, relai 2, 5V et 0V.

Schéma du Passage à Niveau

La source d’alimentation est prise sur celle du moteur Fulgurex. Comme sa tension peut être comprise entre 8 et 15 volts, le régulateur externe 7805 tiendra bien le choc (la tension maximum est de 40V au lieu de 12V pour un Arduino Mini).

La réalisation

Une planchette en bois sert de support direct aux composants. Elle permet un étiquetage clair des connexions.

Les ingrédients sur une planchette

Petite anecdote : Lors d’un essai précédent, avant l’ajout de la petite alimentation 5V, j’avais utilisé le régulateur intégré de l’Arduino Mini. Résultat d’une erreur : le régulateur intégré est parti en fumée. Mais tout le reste de l’Arduino est intact : quel chance, mais aussi quelle robustesse ! C’est pour cela qu’on peut voir une zone noircie sur le Mini. Depuis, j’ai refait le montage avec un Mini tout neuf.

Les dominos ordinaires aurait pu être avantageusement remplacés par cette superbe plaque à borniers.

Le programme

C’est la partie la plus intéressante du projet !
Je précise tout de suite que ce n’est pas le meilleur programme possible : il ne couvre pas tous les cas possibles. Ca se coince parfois lors de manoeuvres spéciales.
Mais c’est un programme convenable pour les cas ordinaires et assez simple à comprendre pour les débutants.

Nous verrons plus loin que cet article aura une suite, justement pour explorer un peu plus cet automate qui n’est pas si trivial que ça en a l’air.

On commence donc par la déclaration des ports d’entrée et sortie :

  1. // Pins utilisées pour les connexions aux detecteurs Reed
  2. #define ReedA1 2 //RA1 = O1-29G
  3. #define ReedB1 3 //RB1 = F1-29G
  4. #define ReedC1 4 //RB2 = F1-29D
  5. #define ReedD1 5 //RD2 = O1-29D
  6. #define ReedA2 6 //RA2 = O2-30G
  7. #define ReedB2 7 //RB2 = F2-30G
  8. #define ReedC2 8 //RC2 = F2-3031D
  9. #define ReedD2 9 //RD2 = O2-3031D
  10. #define ReedA3 A2 //RA3 = O2-31G
  11. #define ReedB3 A3 //RB3 = F2-31G
  12.  
  13. // Pins utilisées pour la Led et le PAN
  14. #define LED 13 // on board
  15. #define Feux 11 // PWM ou digital OUT
  16. #define PANPWM 12 // not used
  17. #define PAN1 A0 //digital OUT IN2 relai
  18. #define PAN2 A1 //digital OUT IN1 relai
  19. #define PANMOVE 5000 // duree d'activation du moteur Fulgurex

Puis, pour éviter tout problème de contact au niveau des ILS, on utilise intensivement la bibliothèque Bounce.

  1. #include <Bounce2.h> // librairie de gestion des contacts Reed
  2.  
  3. // Instantie 8 objets Bounce avec une durée de 10 millisecond de debounce
  4. Bounce bounceA1 = Bounce();
  5. Bounce bounceB1 = Bounce();
  6. Bounce bounceC1 = Bounce();
  7. Bounce bounceD1 = Bounce();
  8. Bounce bounceA2 = Bounce();
  9. Bounce bounceB2 = Bounce();
  10. Bounce bounceC2 = Bounce();
  11. Bounce bounceD2 = Bounce();
  12. Bounce bounceA3 = Bounce();
  13. Bounce bounceB3 = Bounce();

Petit programme, donc peu de variables :

  1. // Variables
  2. boolean RA1, RA2, RB1, RB2, RC1, RC2, RD1, RD2, RA3, RB3 = false;
  3. int etat1, etat2 = 0; // libre
  4. boolean dir1, dir2 = false;
  5. boolean etat_PAN = true; // true=ouvert, false=fermé
  6. unsigned long TimerFeux, TimerPAN;
  7. int fadeValue; // valeur variable de la durée du fading des feux
  8. int fading = 10; // 10 croit/decroit ou 1000 allume/eteint
  9. int cycle = 0; // 0 eteint, 1 croit, 2 allumé, 3 decroit
  10. int panValue = PANMOVE; //durée impulsion ouverture et fermeture pour Fulgurex
  11. boolean Fulgurex = false; // true seulement pour envoyer le courant au moteur

A ce stade, j’avoue que la déclaration de plusieurs variables de même type sur la même ligne avec la dernière = 0, n’entraine pas nécessairement que la première (et les autres) soient aussi = 0

Le Setup

  1. // SETUP
  2. void setup() {
  3. // entrées
  4. pinMode(ReedA1,INPUT_PULLUP);
  5. pinMode(ReedB1,INPUT_PULLUP);
  6. pinMode(ReedC1,INPUT_PULLUP);
  7. pinMode(ReedD1,INPUT_PULLUP);
  8. pinMode(ReedA2,INPUT_PULLUP);
  9. pinMode(ReedB2,INPUT_PULLUP);
  10. pinMode(ReedC2,INPUT_PULLUP);
  11. pinMode(ReedD2,INPUT_PULLUP);
  12. pinMode(ReedA3,INPUT_PULLUP);
  13. pinMode(ReedB3,INPUT_PULLUP);
  14. // sorties
  15. pinMode(LED,OUTPUT);
  16. pinMode(Feux,OUTPUT);
  17. pinMode(PAN1,OUTPUT);
  18. pinMode(PAN2,OUTPUT);
  19. digitalWrite(PAN1, HIGH);
  20. digitalWrite(PAN2, HIGH);
  21. //définition des objets bounce
  22. bounceA1.attach(ReedA1);
  23. bounceB1.attach(ReedB1);
  24. bounceC1.attach(ReedC1);
  25. bounceD1.attach(ReedD1);
  26. bounceA2.attach(ReedA2);
  27. bounceB2.attach(ReedB2);
  28. bounceC2.attach(ReedC2);
  29. bounceD2.attach(ReedD2);
  30. bounceA3.attach(ReedA3);
  31. bounceB3.attach(ReedB3);
  32. bounceA1.interval(50);
  33. bounceB1.interval(50);
  34. bounceC1.interval(50);
  35. bounceD1.interval(50);
  36. bounceA2.interval(50);
  37. bounceB2.interval(50);
  38. bounceC2.interval(50);
  39. bounceD2.interval(50);
  40. bounceA3.interval(50);
  41. bounceB3.interval(50);
  42.  
  43. TimerFeux = millis();
  44. }

La boucle Loop contient 4 types d’actions :

  • La détection des ILS
  • La gestion de l’automate de clignotement des feux
  • La gestion du moteur Fulgurex (ouverture ou fermeture) pendant le temps défini par PANMOVE

Détections des ILS

Chaque détection est faite par la bibliothèque Bounce et entraîne une action spécifique à chaque ILS.

  1. // Update the debouncer
  2. bounceA1.update ( );
  3. bounceB1.update ( );
  4. bounceC1.update ( );
  5. bounceD1.update ( );
  6. bounceA2.update ( );
  7. bounceB2.update ( );
  8. bounceC2.update ( );
  9. bounceD2.update ( );
  10. bounceA3.update ( );
  11. bounceB3.update ( );
  12.  
  13. // Une transition de HIGH à LOW entraine une action (fonction)
  14. if ( bounceA1.fell() ) {
  15. action1();
  16. }
  17. if ( bounceB1.fell() ) {
  18. action2();
  19. }
  20. if ( bounceC1.fell() ) {
  21. action3();
  22. }
  23. if ( bounceD1.fell() ) {
  24. action4();
  25. }
  26. if ( bounceA2.fell() ) {
  27. action5();
  28. }
  29. if ( bounceA3.fell() ) {
  30. action5();
  31. }
  32. if ( bounceB2.fell() ) {
  33. action6();
  34. }
  35. if ( bounceB3.fell() ) {
  36. action6();
  37. }
  38. if ( bounceC2.fell() ) {
  39. action7();
  40. }
  41. if ( bounceD2.fell() ) {
  42. action8();
  43. }

On notera que les actions pour la branche déviée de l’"Y" sont les même que celles de la branche droite.

On verra le contenu de ces actions un peu plus loin.

L’automate des feux

Il est bien évidemment interdit d’utiliser l’instruction delay().

L’astuce consiste à détecter l’écoulement d’un laps de temps défini par la variable "fading" et à invoquer le fonction FeuxON(). C’est cette dernière qui réalise l’automate par une série d’états associés chacun à une valeur particulière de"fading", ce que nous verrons plus loin.

  1. digitalWrite(LED, etat_PAN );
  2. if ((TimerFeux + fading) < millis())
  3. {
  4. TimerFeux = TimerFeux + fading;
  5. if (!etat_PAN)
  6. {
  7. FeuxON();
  8. }
  9. }

Cette petite partie fait simplement avancer l’automate FeuxON() à chaque période définie par la variable fading dont la valeur change dans l’automate.

On peut obtenir ainsi un comportement sophistiqué de manière simple.

L’automate du moteur de barrière

Du même principe, il stoppe le moteur à la fin d’une tempo initialisée dans une des actions liées aux détections d’ILS.

  1. // commande de barrière (impulsion de duree panValue)
  2. if (Fulgurex)
  3. {
  4. FeuxON(); // le feu reste allume pendant la manoeuvre
  5. if ((TimerPAN + panValue) < millis()) // depassement timer
  6. {
  7. Fulgurex = false;
  8. digitalWrite(PAN2, HIGH); // arret relais Fulgurex
  9. digitalWrite(PAN1, HIGH);
  10. if (etat_PAN)
  11. {
  12. FeuxOFF(); // extinction feu à la fin de l'ouverture
  13. }
  14. }
  15. }

On notera que le feu rouge pour les voitures doit rester allumé pendant la manœuvre de la barrière.

Les actions en réponse aux détections ILS

L’état libre ou occupé des voies est représenté par les variables état1 et état2.
Pour tenir compte de la possibilité de la présence de plusieurs trains dans la zone, chaque entrée de train se traduit par l’incrémentation de la variable étatx.

La sortie des trains, par symétrie, se fait par décrémentation de cette variable.

Il faut qu’elle passe à zéro pour constater que la zone est libre !

  1. void action1() // detecteur loin a gauche du PaN voie 1
  2. {
  3. /*- RA1 - O1-29G
  4.   -> si etat1=false, alors etat1=true, dir1=ADroite (entrée par la gauche de la voie 1, direction vers droite)
  5.   -> si etat1=true, alors etat1=false, (sortie par la gauche de la voie 1)
  6.   et -> si etat2=false (voie 2 libre), alors etat_PAN=ouvert (ouverture PAN autorisée)
  7. */
  8.  
  9. if (etat1 == 0) // etat libre, entrée par la gauche voie 1
  10. {
  11. etat1++; // voie 1 occupée
  12. dir1=true; // vers la droite
  13. } else { // sinon pas libre donc c'est une sortie vers la gauche
  14. // ou une autre entree par la gauche
  15. if (!dir1) // sortie
  16. {
  17. if (etat1 > 0)
  18. {
  19. etat1--; // voie 1 libre
  20. }
  21. } else { // entree
  22. etat1++;
  23. dir1=true;
  24. }
  25.  
  26. if ((etat1 == 0) && (etat2 == 0)) // si voies 1 et 2 libres
  27. {
  28. etat_PAN=true; // ouverture si l'autre voie est libre
  29. FeuxON();
  30. OuvreBarriere();
  31. }
  32. }
  33. }
  34. /////////////////////
  35. void action2() // detecteur pres à gauche du PaN voie 1
  36. {
  37. // RB1 - F1-29G
  38. // -> si etat1>0 et dir1=ADroite alors etat_PAN = ferme (fermeture PAN)
  39.  
  40. if (etat1 && dir1 && etat_PAN) // vers la droite 2e détecteur à gauche du PaN
  41. {
  42. etat_PAN=false; // fermeture
  43. FeuxON();
  44. FermeBarriere();
  45. }
  46. }
  47. /////////////////////
  48. void action3() // detecteur près à droite du PaN voie 1
  49. {
  50. //- RC1 - F1-29D
  51. // -> si etat1>0 et dir1=AGauche alors etat_PAN = ferme (fermeture PAN)
  52.  
  53. if (etat1 && !dir1 && etat_PAN) // vers la gauche 2e détecteur à droite du PaN
  54. {
  55. etat_PAN=false; // fermeture
  56. FermeBarriere();
  57. FeuxON();
  58. }
  59. }
  60. /////////////////////
  61. void action4() // detecteur loin a droite du PaN voie 1
  62. {
  63. /*- RD1 - O1-29D
  64.   -> si etat1=false, alors etat1=true, dir1=AGauche (entrée par la droite de la voie 1, direction vers gauche)
  65.   -> si etat1=true, alors etat1=false (sortie par la droite de la voie 1)
  66.   et si etat2=false (voie 2 libre), alors etat_PAN=ouvert (ouverture PAN)
  67. */
  68.  
  69. if (etat1 == 0) // etat libre, entrée par la droite voie 1
  70. {
  71. etat1++; // voie 1 occupee
  72. dir1=false; // vers la gauche
  73. } else { // sinon pas libre donc c'est une sortie vers la droite
  74. // ou une nouvelle entree par le droite
  75. if (dir1) // sortie
  76. {
  77. if (etat1 > 0)
  78. {
  79. etat1--;
  80. }
  81. } else { // sinon entree
  82. etat1++;
  83. dir1=false;
  84. }
  85. if ((etat1==0) && (etat2==0))
  86. {
  87. etat_PAN=true;
  88. FeuxON();
  89. OuvreBarriere();
  90. }
  91. }
  92. }
  93. /////////////////////
  94. void action5()
  95. {
  96. /*- RA2 ou RA3
  97. - O2-30G -> si etat2=false, alors etat2=true, dir2=ADroite (entrée par la gauche de la voie 2, direction vers droite)
  98. - O2-31G -> si etat2=true alors etat2=false (sortie par la gauche de la voie 2)
  99.   et -> si etat1=false (voie 1 libre), alors etat_PAN=ouvert (ouverture PAN)
  100. */
  101.  
  102. if (etat2 == 0) // voie 2 libre, entree par la gauche
  103. {
  104. etat2++;
  105. dir2=true;
  106. } else { // sinon pas libre donc c'est une sortie vers la gauche
  107. // ou nouvelle entree par la gauche
  108. if (!dir2) // sortie
  109. {
  110. if (etat2 > 0)
  111. {
  112. etat2--;
  113. }
  114. } else { // sinon entree
  115. etat2++;
  116. dir2=true;
  117. }
  118. if ((etat1==0) && (etat2==0))
  119. {
  120. etat_PAN=true;
  121. OuvreBarriere();
  122. }
  123. }
  124. }
  125. /////////////////////
  126. void action6()
  127. {
  128. //- RB2 ou RB3 - F2-30G ou F2-31G
  129. // -> si etat2=true et dir2=ADroite alors etat_PAN = ferme (fermeture PAN)
  130.  
  131. if (etat2 && dir2 && etat_PAN)
  132. {
  133. etat_PAN=false;
  134. FeuxON();
  135. FermeBarriere();
  136. }
  137. }
  138. /////////////////////
  139. void action7()
  140. {
  141. //- RC2 - F2-3031D
  142. // -> si etat2=true et dir2=AGauche alors etat_PAN = ferme (fermeture PAN)
  143.  
  144. if (etat2 && !dir2 && etat_PAN)
  145. {
  146. etat_PAN=false;
  147. FeuxON();
  148. FermeBarriere();
  149. }
  150. }
  151. /////////////////////
  152. void action8()
  153. {
  154. /*- RD2
  155. - O2-3031D
  156.   -> si etat2=0, alors etat2=true, dir2=AGauche (entrée par la droite de la voie 2, direction vers gauche)
  157.   -> si etat2=true alors etat2=false (sortie par la droite de la voie 2 et )
  158.   et -> si etat1=false (voie 1 libre), alors etat_PAN=ouvert (ouverture PAN)
  159. */
  160.  
  161. if (etat2 == 0) //entree par la droite, direction vers gauche
  162. {
  163. etat2++;
  164. dir2=false;
  165. } else { // sinon sortie vers la droite
  166. // ou nouvelle entree
  167. if (dir2)
  168. {
  169. if (etat2 > 0)
  170. {
  171. etat2--;
  172. }
  173. } else {
  174. etat2++;
  175. dir2=false;
  176. }
  177. if ((etat1==0) && (etat2==0))
  178. {
  179. etat_PAN=true;
  180. FeuxON();
  181. OuvreBarriere();
  182. }
  183. }
  184. }

Les fonctions d’ouverture et fermeture de la barrière

Le fait de passer la variable Fulgurex à true va démarrer le décomptage du temps dans la loop.

  1. void OuvreBarriere()
  2. {
  3. digitalWrite(PAN1, LOW); // commande relai sens ouvrir
  4. TimerPAN = millis();
  5. Fulgurex = true;
  6. }
  7.  
  8. void FermeBarriere()
  9. {
  10. digitalWrite(PAN2, LOW); // commande relai sens ouvrir
  11. TimerPAN = millis();
  12. Fulgurex = true;
  13. }

Le clignotement réaliste des feux

Cette partie peut être réutilisée dans beaucoup d’animations lumineuses réalistes.

On considère 4 phases dans l’allumage des feux :

  • une phase de luminosité croissante pendant 1/10e de seconde
  • une phase de luminosité maximum pendant 1 seconde
  • une phase de luminosité décroissante pendant 1/10e de seconde
  • une phase de luminosité nulle pendant 1/2 seconde

On passe d’une phase à l’autre à l’écoulement de la variable fading, initialisée à la phase précédente et testée avec le temps système dans la loop.

  1. void FeuxON()
  2. {
  3. switch (cycle)
  4. {
  5. case 0: //éteint >> démarrage croissance
  6. cycle = 1;
  7. fading = 10;
  8. fadeValue = 10;
  9. break;
  10. //
  11. case 1: //croissance
  12. analogWrite(Feux, fadeValue);
  13. fadeValue = fadeValue + 10;
  14. if (fadeValue > 255)
  15. {
  16. fading = 1000;
  17. cycle = 2;
  18. }
  19. break;
  20. //
  21. case 2: //allumé >> démarrage décroissance
  22. cycle = 3;
  23. fading = 10;
  24. fadeValue = 255;
  25. break;
  26. //
  27. case 3: // decroissance
  28. analogWrite(Feux, fadeValue);
  29. fadeValue = fadeValue - 10;
  30. if (fadeValue < 0)
  31. {
  32. fading = 500;
  33. cycle = 0;
  34. }
  35. break;
  36. }
  37. }

L’extinction des feux

  1. void FeuxOFF()
  2. {
  3. analogWrite(Feux, 0); // éteint
  4. }

Le code complet

On trouvera dans le document joint le code complet du passage à niveau.

Dans ce code j’ai ajouté une fonction de DEBUG qui utilise la console de l’IDE Arduino pour afficher un message à chaque événement et l’état des principales variables.

Il y a aussi une possibilité de simuler les détections d’ILS en tapant des chiffres au clavier.

On peut faire disparaître du code l’ensemble de la fonction de DEBUG en mettant la définition au début en commentaire.

  1. //#define DEBUG // a mettre en commentaire pour enlever les echanges avec la console

Le sketch du Passage à Niveau (version 0.9 du 1/03/2015)

L’installation in situ a eu lieu et le montage fonctionne bien… dans presque tous les cas… sauf quelques uns ;(.
Comme toujours dans un projet, il y a quelques améliorations que je ne manquerai pas de vous donner dans un prochain article.

Mais en réalité c’est une nouvelle manière de raisonner et un nouvel automate qui vous sera présenté par Jean-Pierre très prochainement, car le passage à niveau est un cas d’école !!!

Ensuite, nous y ajouterons l’incontournable sonnerie qui accompagne toujours la fermeture de la barrière. Le tout dans notre Mini, avec un lecteur de carte SD en plus : OUI il arrive à tout faire !

Enfin, nous espérons vous proposer une nouvelle réalisation avec un circuit imprimé.

Donc ne ratez pas les prochains articles !

3 Messages

Réagissez à « Un automatisme de Passage à Niveau »

Qui êtes-vous ?
Votre message

Pour créer des paragraphes, laissez simplement des lignes vides.

Lien hypertexte

(Si votre message se réfère à un article publié sur le Web, ou à une page fournissant plus d’informations, vous pouvez indiquer ci-après le titre de la page et son adresse.)

Rubrique « Projets »

Un chenillard de DEL

Enseigne de magasin

Feux tricolores

Multi-animations lumineuses

L’Arduino et le système de commande numérique DCC

Un décodeur d’accessoire DCC versatile basé sur Arduino

Un moniteur de signaux DCC

Une barrière infrarouge

Un capteur RFID

Un TCO xpressnet

Une animation sonore

L’Arduino au coeur des systèmes de pilotage analogiques ou numériques

Calcul de la vitesse d’un train miniature avec l’Arduino

La génèse d’un réseau 100% Arduino

Une horloge à échelle H0

Simulateur de soudure à arc

Un automatisme de Passage à Niveau

La rétro-signalisation sur Arduino

Décodeur pour aiguillage à solénoïdes sur Arduino

Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO

Etude d’un passage à niveau universel

Réalisation pratique d’un système de mesure de vitesse à l’échelle N

Une Passerelle entre le bus S88 et le bus CAN pour la rétro signalisation

Un décodeur DCC pour 16 feux tricolores

Block Automatique Lumineux avec la carte shield "Arduino 4 relays"

Réalisation d’un affichage de gare ARRIVEE DEPART

Comment piloter trains et accessoires en DCC avec un Arduino (1)

Comment piloter trains et accessoires en DCC avec un Arduino (2)

Comment piloter trains et accessoires en DCC avec un Arduino (3)

Comment piloter trains et accessoires en DCC avec un Arduino (4)

SGDD : Système de Gestion DD (1)

SGDD : Système de Gestion DD (2)

SGDD : Système de Gestion DD (3)

La PWM : Qu’est-ce que c’est ? (1)

La PWM : Qu’est-ce que c’est ? (2)

La PWM : Qu’est ce que c’est ? (3)

La PWM : Qu’est ce que c’est ? (4)

Mise en oeuvre du Bus CAN entre modules Arduino (1)

Mise en oeuvre du Bus CAN entre modules Arduino (2)

Un gestionnaire en C++ pour votre réseau (1)

Un gestionnaire en C++ pour votre réseau (2)

Un gestionnaire en C++ pour votre réseau (3)

Un gestionnaire en C++ pour votre réseau (4)

Réalisation de centrales DCC avec le logiciel libre DCC++ (1)

Réalisation de centrales DCC avec le logiciel libre DCC++ (2)

Réalisation de centrales DCC avec le logiciel libre DCC++ (3)

Contrôleur à télécommande infrarouge pour centrale DCC++

Gestion d’une gare cachée (1)

Gestion d’une gare cachée (2)

Gestion d’une gare cachée (3)

Les derniers articles

La PWM : Qu’est ce que c’est ? (4)


Jean-Luc

Block Automatique Lumineux avec la carte shield "Arduino 4 relays"


Christian Bézanger

Réalisation d’un affichage de gare ARRIVEE DEPART


Gilbert

Contrôleur à télécommande infrarouge pour centrale DCC++


Daniel

La PWM : Qu’est ce que c’est ? (3)


Jean-Luc

Réalisation de centrales DCC avec le logiciel libre DCC++ (3)


bobyAndCo

Un gestionnaire en C++ pour votre réseau (4)


Pierre59

Un décodeur DCC pour 16 feux tricolores


Dominique, JPClaude, Thierry

Réalisation de centrales DCC avec le logiciel libre DCC++ (2)


bobyAndCo

Réalisation de centrales DCC avec le logiciel libre DCC++ (1)


Dominique

Les articles les plus lus

La PWM : Qu’est-ce que c’est ? (1)

L’Arduino et le système de commande numérique DCC

Comment piloter trains et accessoires en DCC avec un Arduino (1)

Réalisation de centrales DCC avec le logiciel libre DCC++ (3)

Comment piloter trains et accessoires en DCC avec un Arduino (3)

L’Arduino au coeur des systèmes de pilotage analogiques ou numériques

Décodeur pour aiguillage à solénoïdes sur Arduino

Mise en oeuvre du Bus CAN entre modules Arduino (2)

La rétro-signalisation sur Arduino

Calcul de la vitesse d’un train miniature avec l’Arduino