LOCODUINO

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

mardi 19 mars 2024

Visiteurs connectés : 31

Passage à niveau géré par Arduino (5)

Amélioration et résolution des problèmes

.
Par : Christian

DIFFICULTÉ :

Les quatre précédents articles nous ont permis de construire un passage à niveau automatique de type SAL 2 et de l’intégrer à un réseau de trains miniatures comme le réseau Train’ In Box. Cet article, le dernier de la série, va vous donner des pistes pour améliorer le montage et surtout vous montrer comment le dépanner si certains éléments devaient tomber en panne.

<

Article mis à jour le 17 octobre 2021 pour préciser que l’emploi de détecteurs d’occupation par consommation de courant simplifie grandement le programme pour déterminer l’état d’occupation de la zone du PN.

Il aura fallu quatre articles qui s’enchaînent pour arriver à bout de notre projet de passage à niveau reproduisant la réalité le plus fidèlement possible. Chaque article complétait le précédent afin de rajouter une fonctionnalité. On ne développe pas une application complète en une seule fois ; il faut opérer par petits bouts et toujours partir d’un montage qui fonctionne pour l’améliorer en lui ajoutant une nouvelle option.

Bien évidemment, au cours de notre développement, nous avons dû faire des choix qui n’étaient sans doute pas les meilleurs mais qui s’imposaient pour d’autres raisons :

  • Facilité d’intégration sur un réseau déjà monté
  • Facilité d’approvisionnement en matériaux ou composants
  • Facilité d’usinage des pièces mécaniques sans nécessiter de machines spécialisées
  • Possibilités d’évolution

Nous allons voir ici comment remettre en cause certains des choix qui ont été faits et comment améliorer notre passage à niveau.

Les améliorations possibles

La détection des trains
La première chose que nous pouvons améliorer est la détection des trains. Nous avons fait le choix de positionner des capteurs ponctuels à la périphérie de la zone de voies à surveillée, solution qui a le mérite de ne nécessiter aucun travaux sur les voies en elles-mêmes. Nous avons fait le choix d’utiliser des ILS mais ceux-ci ont des contacts mécaniques qui peuvent parfois se rompre ou rester collés (sans parler des problèmes de rebonds mais nous en avions tenu compte par une temporisation de 2 s). Il peut être intéressant de remplacer ces ILS par des capteurs à effet Hall qui réagissent également à la présence d’un champ magnétique ; ces capteurs sont faciles à trouver et bon marché. Le signal transmis à la carte Arduino doit rester compris entre 0 et 5 V. Pour plus d’informations sur la mise en oeuvre de capteurs à effet Hall, vous pouvez consulter l’article Capteurs à effet Hall.

Que ce soit des ILS ou bien des capteurs à effet Hall, il faut que les locomotives soient équipées d’un aimant, ce qui peut constituer une contrainte si vous voulez que vos amis viennent sur votre réseau avec leurs locomotives personnelles qui ne sont peut-être pas équipées d’aimant. On peut alors faire appel à des capteurs infra-rouge par réflexion qui vont également se fixer sous la voie entre deux traverses et qui restent relativement discrets. Encore une fois, le signal délivré à la carte Arduino doit rester compris entre 0 et 5 V et il faudra faire un traitement informatique car le capteur verra passer chaque wagon qu’il faudra ensuite reconstituer comme un seul et unique train. Ceci n’est pas très compliqué ; il suffit de mettre une temporisation pour filtrer le temps relativement court de non détection entre wagons.

Comme on l’a dit au début, le nec plus ultra est de faire de la détection d’occupation de voies par consommation de courant. On peut utiliser des détecteurs d’occupation du commerce ou bien monter ses propres détecteurs en s’inspirant de schémas trouvés sur internet ou sur notre forum. Le signal délivré doit être compris entre 0 et 5 V pour être envoyé à la carte Arduino ; si ce n’est pas le cas, on peut utiliser un coupleur optique comme on l’a fait pour le module son. Néanmoins, l’utilisation de détecteur d’occupation par consommation de courant nécessite de créer physiquement des zones de détection en coupant une file de rail aux endroits stratégiques. Les voitures et wagons doivent consommer du courant pour être détectés. Pour des voitures, c’est assez simple si elles sont éclairées et pour les wagons, il suffit de graphiter les essieux ou de mettre des feux de fin de convois.

La figure 1 montre en bleu la forme des zones de protection du PN pour chaque voie ainsi que le positionnement de certains accessoires (cliquez sur l’image pour l’agrandir). La distance "L" est la longueur du plus long train circulant sur le réseau. L’utilisation de ce genre de détecteurs est d’autant plus facile que le réseau a été conçu en ce sens, en créant par exemple des cantons pour que plusieurs trains puissent se suivre. Une fois le réseau monté, c’est plus compliqué d’intervenir dessus sans être pour autant impossible ; il suffit de couper les rails et de souder sur les flancs un fil électrique pour réalimenter la portion. Avec le décor en place, cela peut devenir assez sportif…

Figure 1
Figure 1
Zones de protection des voies avec des détecteurs d’occupation

Le gros avantage des détecteurs d’occupation par rapport aux capteurs ponctuels en périphérie de zone à protéger est qu’on n’a plus à tenir compte de conditions à respecter lors de l’initialisation. Si un détecteur envoie un signal, c’est que la zone est occupée et qu’un train approche du PN et il n’y a plus à se poser la question de l’état antérieur de la zone. Mais il faut aussi un minimum de tension sur la voie pour détecter un train arrêté en gare ; ceci ne concerne pas un réseau en DCC puisque la voie est toujours sous tension, même avec des trains à l’arrêt.

Il faut aussi se rappeler que la mise en parallèle de plusieurs capteurs sur une même entrée n’est possible que pour des contacts (ILS tels qu’ils ont été montés dans ce projet) ou bien des sorties à collecteur ouvert (capteurs à effet Hall ou détecteurs d’occupation par consommation de courant). Un peu d’électronique peut se révéler nécessaire pour traiter plusieurs capteurs. Dans le cas de la figure 1, il ne faut que deux détecteurs d’occupation (un sur chaque voie) qui peuvent alors être reliés aux entrées 2 et 3 de la carte Uno ; dans ce cas, l’entrée 3 travaille de la même façon que l’entrée 2 pour déterminer l’occupation globale du PN comme nous l’avons expliqué dans le premier article et le traitement de l’information n’est plus qu’un simple exercice de programmation.

Les programmes donnés dans cette série d’articles ont été conçus pour traiter des événements de courte durée (fermeture d’ILS) et ils surveillent la périphérie de la zone PN en faisant appel aux interruptions pour ne pas louper des événements. Les détecteurs d’occupation fournissent des signaux de longue durée (tant que la zone à surveiller est occupée) ; le programme est considérablement simplifié puisqu’il suffit de lire l’état des entrées reliées aux détecteurs en début de boucle loop pour déterminer l’état d’occupation de la zone du PN. Toutes les entrées sont utilisables à la condition que le signal fourni par le détecteur soit ramené dans l’intervalle 0-5 V.

Quatre feux de PN au lieu de deux
Il suffit de rajouter deux LED et une résistance de 470 Ω sur la sortie 5 (PWM) comme le montre la figure 2, et bien évidemment modifier le programme. Chaque ensemble de deux LED sera positionné d’un côté ou l’autre des voies et bien évidemment les LED d’un même ensemble seront positionnées de chaque côté de la route pour être vues par les automobilistes devant s’arrêter avant la barrière.

Figure 2
Figure 2
Montage pour quatre feux de passage à niveau

Concernant le programme, il suffit d’instancier un deuxième objet (feu2PN) avec LightDimmer. Chaque opération sur le premier objet est répétée sur le deuxième.

/*******************************************************************************
 * PN_TIB_4Feux_Barrieres_SortieSon_InitFerme.ino
 * *****************************************************************************
 * Programme developpe pour le projet de PN pour Train In Box.
 * Il prend en compte l arrivee du train, le clignotement des feux en simulant 
 * une ampoule a filaments, un delai avant mouvement des barrieres,
 * le mouvements des deux barrieres sur 90° d amplitude (depend de 
 * la transmission adoptee).
 * Le programme s'initialise barrieres fermees, donc AVEC TRAIN EN GARE SUR TIB.
 * La LED_SON est allumee tant que sonnerie doit jouer ; cette sortie commande
 * le module sonore.
 * *****************************************************************************
 * Christian BEZANGER - 13 Novembre 2018 - 2 Juin 2019 - 29 mai 2020
 ******************************************************************************/

#include <LightDimmer.h>  // Bibliotheque pour gerer les feux du PN
#include <Servo.h>        // Bibliotheque pour gerer les barrieres du PN

const byte ILS=2; // entree des capteurs 
const byte LED=6; // sortie PWM pour deux feux du PN
const byte LED2=5; // sortie PWM pour deux autres feux du PN
const byte LED_SON=7; // sortie pour indiquer sonnerie
const byte S1=4; // sortie pour le servomoteur 1
const byte S2=8; // sortie pour le servomoteur 2
unsigned int compteur = 1;  // compteur d evenements (survol ILS)

// Variables utilisateur pour reglage du mouvement des barrieres
// -------------------------------------------------------------
unsigned long delaiFermeture = 0; // Regle le delai entre clignotement LED 
// et fermeture barrieres - entre 2000 et 8000 mais 0 sur TIB (pas de delai)
int speedServo = 30;  // Regle la vitesse de mouvement des barrieres

// Variables non utilisateur
// -------------------------
volatile static boolean etatZonePN = true; // true si la zone du PN est occupee
volatile static boolean old_etatZonePN = false; // etat anterieur de la zone
volatile static unsigned long old_top_debutISR;  // Date anterieure d appel ISR
unsigned long old_top = 0;  // variable pour afficher donnees utiles
int posServo = 90; // position courante a initialiser imperativement FERMEE
int posOuvert = 0;  // barriere a la verticale
int posFerme = 90; // barriere a l'horizontale (90° de la verticale)
unsigned long topAttente = 0; // top pris au début franchissement de la zone PN
boolean etatSon = false; // true si sonnerie doit retentir

// Instanciations
LightDimmer feuPN;
LightDimmer feu2PN;
Servo servo1;
Servo servo2;

void changeEtat() { // routine d'interruption (ISR)
  unsigned long top_debutISR = millis();  // date appel ISR
  if((top_debutISR - old_top_debutISR) > 2000) {
    // 2 secondes au moins entre execution ISR
    etatZonePN = !etatZonePN; // etat passe a etat oppose
    old_top_debutISR = top_debutISR;  // initialisation date anterieure d appel ISR
  }
} // fin de ISR

void setup() {
  // put your setup code here, to run once:
  Serial.begin(115200); // communication avec le moniteur
  pinMode (ILS, INPUT_PULLUP);  // entree capteur
  pinMode (LED_BUILTIN, OUTPUT);  // LED du module allumee si Zone PN occupee
  pinMode (LED, OUTPUT);  // sortie pour feux du PN
  pinMode (LED2, OUTPUT); // sortie pour autres feux du PN
  pinMode (LED_SON, OUTPUT);
  attachInterrupt (digitalPinToInterrupt(ILS), changeEtat, FALLING);
  digitalWrite (LED_BUILTIN, LOW);
  feuPN.begin(LED, HIGH); // LED s'allume avec etat haut
  feu2PN.begin(LED2, HIGH); // LED2 s'allume avec etat haut
  servo1.attach(S1);
  servo2.attach(S2);
  // initialisation des barrieres en position fermee
  servo1.write(posFerme); // barriere 1 FERMEE apres initialisation
  servo2.write(posFerme); // barriere 2 FERMEE apres initialisation
  delay(2000);
  digitalWrite (LED_BUILTIN, HIGH); // Indique fin de setup
}  // fin de setup

void loop() {
  // put your main code here, to run repeatedly:
  if(etatSon == false) {digitalWrite (LED_SON, LOW);}
  if(etatSon == true) {digitalWrite (LED_SON, HIGH);}
  if(etatZonePN == false) {
    old_etatZonePN = etatZonePN;
    digitalWrite (LED_BUILTIN, LOW); // eteint LED de controle de la zone PN
    etatSon = false;  // pas de sonnerie
    feuPN.stopBlink();  // arrete le clignotement
    feu2PN.stopBlink(); // arrete le clignotement
    feuPN.off();  // eteint les feux
    feu2PN.off(); // eteint les feux
    // ouverture barriere
    if(posServo > posOuvert) {
      posServo = posServo - 1;
      servo1.write(posServo);
      servo2.write(posServo);
      delay(speedServo);
    }  // fin du test sur position des servos
  }  // fin du test sur etat de la Zone du PN -> false
  if(etatZonePN == true) {
    if(etatZonePN != old_etatZonePN) {
      topAttente = millis();  // prend un top d'entree dans zone PN
      old_etatZonePN = etatZonePN;
      etatSon = true; // sonnerie
    }  // fin du deuxieme if
  digitalWrite (LED_BUILTIN, HIGH); // allume LED de controle de la zone PN
  feuPN.startBlink(); // commence le clignotement
  feu2PN.startBlink();  // commence le clignotement
  // fermeture barriere après attente
  if(millis() - topAttente > delaiFermeture) {
      if(posServo <= posFerme) {
        posServo = posServo + 1;
        servo1.write(posServo);
        servo2.write(posServo);
        if(posServo >= 89) {etatSon = false;}
        delay(speedServo);
      }  // fin du test sur position des servos 
    }  // fin du test sur delai avant ouverture
  }  // fin du test sur etat de la Zone du PN -> true
  LightDimmer::update();
  if(old_top_debutISR != old_top) { // Affichage pour chaque nouveau survol ILS
    Serial.print(compteur);
    Serial.print("     ");
    Serial.print(old_top_debutISR);
    Serial.print("     ");
    Serial.println(old_top_debutISR - old_top);
    old_top = old_top_debutISR; 
    compteur = compteur + 1;   
  }
}  // fin de loop

La bibliothèque LightDimmer permet de régler la fréquence de clignotement, les temps de montée et descente de la luminosité des ampoules pour reproduire l’inertie thermique des filaments. Les choix faits par défaut dans la bibliothèque reproduisent très bien un PN français de la SNCF, si bien qu’il n’est pas forcément nécessaire de les changer. Reportez-vous au fichier « readme » fourni avec la bibliothèque.

Mouvement des barrières
Comme on l’a dit, les barrières en plastique du PN Auhagen sont très fragiles et ce PN ne ressemble pas vraiment à ce qu’on trouve en France. On peut donc envisager d’autres marques mais si on veut appliquer la transmission du mouvement décrite dans cette série d’articles, la commande de la barrière doit se faire en tirant ou poussant une tige ou une corde à piano. Peu importe la valeur du déplacement, il suffit de modifier la forme de la came. Par contre, une corde à piano devra être rigidifiée comme on l’a fait pour le PN Auhagen. Parmi les candidats possibles, nous conseillons les barrières réalisées en impression 3D par NTrail45 ; l’avantage est que vous n’avez pas à monter la barrière car elle est livrée fonctionnelle, l’inconvénient est que le mouvement est limité à l’ouverture par le socle sur lequel vient buter le contrepoids. Il convient de limer un peu ce socle sur un côté. Il existe aussi des feux équipés d’une LED donc fonctionnels ; un ensemble de deux barrières et de deux feux vous coûtera un peu plus de 50 € (prix 2020) mais ceci vous évite quelques heures de travail.

Il existe aussi de très beaux kits en laiton de barrières oscillantes manœuvrées par un ou une garde-barrières. Il fallait tourner une manivelle pour faire descendre ces barrières qui rebondissaient un peu en arrivant en bout de course. Ceux qui voudront reproduire ce mouvement de façon très réaliste auront intérêt à utiliser la bibliothèque SlowMotionServo de LOCODUINO qu’on trouve dans le gestionnaire de bibliothèques de l’IDE. Pour plus d’informations sur la bibliothèque SlowMotionServo, consultez l’article La bibliothèque SlowMotionServo.

Une autre amélioration possible est de construire un passage à niveau automatique SAL 4, c’est-à-dire avec quatre barrières. Il suffit de rajouter deux autres servomoteurs, d’alimenter tous les servos à part (parce que cela ferait trop pour votre carte Uno) et bien évidemment, modifier le programme. C’est un peu plus compliqué de fermer quatre barrières, car elles se ferment deux par deux, les unes après les autres. Par contre, elles s’ouvrent en même temps. La sonnerie s’arrête juste après la fermeture des deux premières barrières. Voilà donc un bel exercice de programmation !

La vidéo ci-dessous vous donne un exemple de PN SAL 4 :

Recherche de pannes

Vous avez installé le PN sur votre réseau, conformément à cette série d’articles et lors de la mise en route de la carte Arduino, ça ne fonctionne pas comme cela devrait. Voici quelques éléments de réponses aux questions que vous vous posez.

Lorsque la carte est branchée, rien ne se passe

Vérifiez que la carte Arduino est bien alimentée (sa LED ON doit être allumée).

Si elle l’est, vérifiez que la LED reliée à la sortie 13 est allumée après l’initialisation (la zone est supposée être occupée à l’initialisation).

Si oui, les LED du PN clignotent-elles ? Non, alors vérifiez qu’elles ne sont pas montées à l’envers et vérifiez aussi les connexions avec la carte Arduino. Cette partie du montage doit fonctionner sans problème.

Le train tourne mais rien ne se passe

Avez-vous pensé à mettre un aimant sous la locomotive ? Car sans aimant, pas de déclenchement des ILS !

Vérifiez que la carte Arduino est bien alimentée (sa LED ON doit être allumée).

Essayez de surpasser un ILS en pontant les fils qui en sortent au niveau du domino de connexion. Cette action équivaut à la fermeture des contacts de l’ILS et doit donc déclencher des actions au niveau de la LED de la carte Arduino, des LED de feux de PN, des mouvements de barrières.

Les barrières s’ouvrent quand elles devraient se fermer et se ferment quand elles devraient être ouvertes.

Cela peut être dû à une mauvaise initialisation de la carte Arduino. Amenez un train dans la gare du réseau TIB puis appuyez sur le bouton RESET de la carte Arduino. Attendez que l’initialisation se fasse ; les barrières doivent être fermées et les feux doivent clignoter. Faites démarrer le train et laissez-le tourner ; le comportement du passage à niveau doit être correct. Sinon, c’est qu’un ILS ne joue pas son rôle et ne détecte pas quand un train passe. La solution est de le changer. Pour tester tous les ILS, laisser le train tourner sur toutes les voies possibles.

La barrière n’est pas horizontale quand elle est fermée

Essayez de régler la rallonge de la tige de commande sans forcer.

La barrière est à moitié ouverte au lieu de complètement ouverte

La tige de commande ne redescend pas assez et ceci doit se voir car elle ne frotte plus sur la came. Changez l’élastique de rappel pour un plus petit qui exercera une force de rappel un peu plus grande.

Le fonctionnement des feux est correct mais les barrières ne bougent pas

Vérifiez la connexion des servomoteurs à la carte Arduino. Vérifiez aussi que la transmission mécanique ne soit pas coincée par un objet ou un élastique tirant trop fort sur la tige de commande. Au besoin, retirez les deux cames et regardez si les servomoteurs tournent correctement.

Vérifiez que les servomoteurs que vous avez utilisés ne consomment pas trop de courant par rapport à ce que peut délivrer la sortie 5 V de la carte Arduino ; au besoin, alimentez les servomoteurs avec une alimentation à part.

Une des deux barrières ne bouge pas

Vérifiez le fonctionnement de son servomoteur et que rien ne bloque la transmission mécanique.

Tout fonctionne sauf le son

Vérifiez que la carte Arduino du module sonore est bien alimentée (sa LED ON doit être allumée) et vérifiez les connexions avec la carte Uno de commande du PN.

Lors de l’initialisation de la carte Arduino du module sonore, vous devez entendre la sonnerie durant trois secondes ; est-ce le cas ?

Vérifiez les connexions du DFPlayer avec la carte Arduino du module sonore.

Vérifiez que vous avez bien inséré la carte SD et que celle-ci contient bien un fichier audio au format MP3.

Si cela ne fonctionne toujours pas, branchez la carte Arduino du module sonore à votre ordinateur, ouvrez le moniteur et regardez les messages envoyés par DFPlayer ; ils vous permettront de comprendre d’où peut venir le problème.

J’entends la sonnerie durant trois secondes, puis plus rien

Vérifiez la sortie son de la carte Arduino de commande du PN en branchant une LED entre cette sortie et la masse (GND) ; cette LED doit être allumée lorsque la sonnerie doit jouer.

Vérifiez alors la connexion de cette sortie son avec le module sonore.

Si vous entendez la sonnerie en reliant l’entrée 2 de la carte Arduino du module sonore à la masse (GND) de cette carte, alors le problème vient sans doute du coupleur optique ; remplacez-le.

Le fonctionnement de mon PN est erratique : un coup ça marche, puis ça ne marche plus

C’est certainement dû à des mauvais contacts dans le câblage. Vérifiez le câblage, les connecteurs Dupont utilisés. Remplacer les dominos d’électricien par de vraies soudures bien plus fiables.

Le programme ne veut pas se téléverser sur ma carte Arduino

Vérifiez que vous avez sélectionné le bon type de carte dans le menu Outils et que le port série utilisé est le bon ; au besoin, réglez ces paramètres.

Vérifiez que vous avez pensé à inclure la bibliothèque « LightDimmer » dans votre IDE ; sans cette bibliothèque, la compilation génère un message d’erreur (puisqu’il manque une « partie » du programme), ce qui empêche le téléversement.

Le programme a été modifié et depuis, plus rien ne marche

Visiblement, cette modification est la cause du dysfonctionnement. Il faut trouver pourquoi en demandant de l’aide sur notre forum.

Il est toujours possible de revenir en arrière, il suffit de téléverser à nouveau dans votre carte Arduino le programme publié dans cette série d’articles (ou l’avant dernière version que vous avez modifiée et qui fonctionnait).

Conclusion

Faire une recherche de panne n’a rien de compliqué, il suffit d’être méthodique. Souvent, on oublie de brancher quelque chose, parfois c’est un composant qui claque. Mais la plupart du temps, ce sont des mauvais contacts dus à des liaisons mal serrées ou à de mauvaises soudures. Le problème peut aussi se cacher derrière quelque chose qu’on ne remet pas en cause parce qu’on est persuadé d’avoir bien fait ; par exemple, vous êtes certain que votre carte SD contient bien un fichier MP3 car vous avez vous-même fait la copie de ce fichier mais êtes vous certain que cette copie n’a pas corrompu votre fichier ? Le diable se cache parfois dans les détails !

Ce montage n’est pas seulement un montage électronique ; il y a aussi une partie de pure mécanique qui peut gripper ou casser, mais ce genre de panne n’arrive qu’au bout d’un certain temps de fonctionnement. Par exemple, un élastique peut devenir cassant avec le temps. Il est donc important de bien surveiller les organes mécaniques de ce passage à niveau.

Enfin rassurez-vous : les montages bien construits peuvent aussi fonctionner parfaitement et ne jamais connaître de panne !

39 Messages

Réagissez à « Passage à niveau géré par Arduino (5) »

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 »

LaBox, Une Centrale DCC polyvalente et abordable (1)

LaBox, Une Centrale DCC polyvalente et abordable (2)

LaBox, Une Centrale DCC polyvalente et abordable (3)

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)

La carte Satellite V1 (1)

La carte Satellite V1 (2)

La carte Satellite V1 (3)

La carte Satellite V1 (4)

La carte Satellite V1 (5)

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

Automatisation du pont FLEISCHMANN 6152 (HO) avec un ESP32 (1)

Identifier et localiser vos trains avec le RFID/NFC et un bus CAN.

Etude d’un passage à niveau multivoies

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

Ménage à trois (Ordinateur, Arduino, réseau)

Réalisation d’un va-et-vient automatique et réaliste

Souris et centrale sans fil

Communications entre JMRI et Arduino

Annonces en gare avec la RFID

Une croix de pharmacie animée avec Arduino UNO

Réalisation d’un wagon de mesure (distance et vitesse)

Une manette simple et autonome pour LaBox

Éclairer le réseau (1)

Éclairer le réseau (2)

Block Automatique Lumineux à 8 cantons analogiques

Un décodeur DCC pour les plaques tournantes Fleischmann et Roco

Éclairer le réseau (3)

Éclairer le réseau (4)

Éclairer le réseau (5)

JMRI pour Ma première centrale DCC

Rocrail pour Ma première centrale DCC

CDM-Rail pour Ma première centrale DCC (1)

CDM-Rail pour Ma première centrale DCC (2)

Banc de test pour les décodeurs DCC

Ma première manette pour les aiguillages DCC

Mon premier décodeur pour les aiguillages DCC

Boitier 3D pour la station DCC minimale

Va-et-vient pour deux trains

Un programme pour régler facilement les servos moteurs avec un ESP32

Affichage publicitaire avec Arduino (1)

Affichage publicitaire avec Arduino (2)

TCO Web interactif avec des ESP32 et des ESP8266 (1)

TCO Web interactif avec des ESP32 et des ESP8266 (2)

TCO Web interactif avec des ESP32 et des ESP8266 (3)

TCO Web interactif avec des ESP32 et des ESP8266 (4)

TCO Web interactif avec des ESP32 et des ESP8266 (5)

Les derniers articles

LaBox, Une Centrale DCC polyvalente et abordable (3)


Thierry

LaBox, Une Centrale DCC polyvalente et abordable (1)


Thierry

LaBox, Une Centrale DCC polyvalente et abordable (2)


Dominique, msport, Thierry

Un programme pour régler facilement les servos moteurs avec un ESP32


bobyAndCo

TCO Web interactif avec des ESP32 et des ESP8266 (5)


utpeca

TCO Web interactif avec des ESP32 et des ESP8266 (4)


utpeca

TCO Web interactif avec des ESP32 et des ESP8266 (3)


utpeca

TCO Web interactif avec des ESP32 et des ESP8266 (2)


utpeca

TCO Web interactif avec des ESP32 et des ESP8266 (1)


utpeca

Affichage publicitaire avec Arduino (2)


catplus, Christian

Les articles les plus lus

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

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

Mon premier décodeur pour les aiguillages DCC

La rétro-signalisation sur Arduino

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

Chenillard de DEL

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

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

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

LaBox, Une Centrale DCC polyvalente et abordable (1)