LOCODUINO

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

samedi 27 mai 2017

43 visiteurs en ce moment

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

A base de composants bon marché.

. Par : Dominique

Un premier article Calcul de la vitesse d’un train miniature avec l’Arduino a décrit comment mesurer la vitesse d’un train, ramenée en km/h à son échelle.

Un petit tour de l’avis des membres de mon club m’a fait découvrir une autre réalisation consistant à compter les tours d’essieu d’un wagon, avec un détecteur Hall et un compteur de vélo. Mais c’est trop gros pour du N !

Nous voulions quelque chose de discret, pas cher et précis à la fois, qui soit visible à coté de la console DCC   (une ECOS) pour permettre l’étalonnage des trains.

J’ai pris du plaisir à réaliser ce petit montage et j’y ai ajouté quelques astuces qui devraient vous plaire…

Le principe

Comme dans l’article précité, la mesure sera basée sur la mesure du temps qui sépare les passages devant 2 capteurs de position. Le plus petit Arduino, le Pro-Mini suffit à s’acquitter de cette tâche et un afficheur à 4 digits à Led permet de lire la vitesse avec une bonne luminosité.

Les capteurs devront être placés de part et d’autre de la console DCC  , là où le charcutage du décor est le moins critique. Il faudra donc un système de réglage de la distance prise en compte dans le logiciel pour le calcul de la vitesse, sans ajouter de clavier, ni obliger de brancher le PC/Mac . Vous allez voir comment !!

La liste des courses

J’ai commencé par une recherche sur eBay, auprès de mes vendeurs favoris (qui sont mentionnés dans l’article Où acheter ?.

Voici mes trouvailles :

  • Les capteurs de position

Capteur infrarouge à réflexion

Ce circuit tout fait pour 1,41€ [1] se connecte par 3 fils (+5V, masse et signal DO, actif a l’état bas).

Il mesure 1,5 x 3,5 cm et le capteur fait 0,5 x 1 cm. Un trou de 1,5 x 1,5 cm permet de le mettre en place avec le seul capteur TCRT5000L qui dépasse pour se situer en face du bas de caisse des voitures, à environ 1,5 cm.

  • L’afficheur 4 digits

Ce circuit tout fait pour 3,25€ [2] est équipé d’un circuit TM1637 qui fait tout le travail pour nous. Il se connecte avec seulement 4 fils (+5V, masse, signaux CLK et DIO). Une bibliothèque existe. Elle est fournie avec le code en fin d’article.

  • L’Arduino Pro Mini

C’est le moins cher, pour 1,47€ [3] et le plus petit, facile à oublier dans un coin du réseau.

Il se programme comme les autres à condition de connecter un circuit d’interface USB série, de préférence à base de FT232 (FTDI) dont le driver est déjà présent dans votre système Mac ou PC, donc le port est facilement reconnu par l’IDE Arduino.

  • L’adaptateur USB série

Cet adaptateur peut servir à programmer des quantités d’Arduino Pro Mini. Un seul suffit, pour 2,25€ [4]

Les 6 broches de ce circuit coincident exactement avec les 6 broches sur le coté droit de l’Arduino.

  • Les fils de câblage

Pour 0,50€ le cable [5] que je coupe en deux pour relier les 2 capteurs, la prise à 3 contacts allant sur un capteur et les fils à l’autre extrémité sont soudés directement sur l’Arduino.

Au total, la facture s’élève avec peine à 8 € (sans l’adaptateur FT232 que vous devez avoir déjà dans vos stocks), soit environ 10€ avec les quelques fils, soudure, et outils nécessaires.

Le schéma de câblage

En respectant ce schéma, il est impossible de se tromper !

Les 2 détecteurs et l’afficheur utilisent le 5V de l’Arduino (donc à relier à VCC et GND) : j’ai mesuré une consommation totale d’environ 50 mA (bien inférieure au 150 mA maximum que supporte le Pro Mini).

Les sorties des détecteurs sont à relier aux Pins 8 et 9 (ou toutes autres qui vous conviendrait mieux à condition de modifier le programme en conséquence).

L’afficheur utilise les 2 Pins 2 et 3 pour les signaux CLK et DIO respectivement.

Pour l’alimentation, il existe plusieurs options possibles :

  • Alimenter le montage directement en 5 V avec un petit chargeur pour USB par exemple : On raccordera l’alimentation directement sur les pins 5V et GND de l’Arduino.
  • Alimenter le montage à partir d’une tension plus élevée, sans excéder 12V. Comme on trouve souvent du 12V (voir un peu plus) sur nos réseaux, notamment pour l’alimentation des accessoires, j’ai pris l’habitude, par méfiance, d’intercaler un régulateur 9V. Dans ce cas il faut se raccorder sur les pins RAW (+9V) et GND.

Pour plus de détails, voir l’article Comment alimenter l’Arduino sans ordinateur ?.

On trouve de petits régulateurs en kit pour moins de 2€ [6].

Avant d’installer le montage sur le réseau, j’ai réalisé le montage sous forme "volante" comme on dit, j’ai écrit et mis au point le programme et l’ai testé avec un simple batterie LiPo comme source d’énergie.

Cela m’a permis de tester la distance entre les capteurs et les trains, déterminer la distance par rapport à la voie, avant de faire les trous dans le réseau :)))

Remarques pratiques : J’ai pris soin de faire en sorte que tous les éléments soient connectés à l’aide de mini-connecteurs pour pouvoir passer les câbles dans les trous. Attention à bien respecter les couleurs des fils : rouge pour le +5V et noir pour le GND, les signaux pouvant avoir la couleur que vous voulez.

Le programme

Le programme est un automate qui doit se dérouler de façon totalement fiable, dans n’importe quel sens de circulation, selon plusieurs phases :

  • détecter le passage d’un convoi devant l’un ou l’autre détecteur et initialiser la mesure du temps en enregistrant la valeur du temps système avec millis()  ;
  • détecter le passage du convoi devant l’autre détecteur et enregistrer à nouveau le temps système.
  • calculer le temps passé T entre les 2 détecteurs et en déduire la vitesse V du train selon la formule V = D / T où D est la distance entre les capteurs.
  • afficher le résultat sur l’afficheur pendant quelques secondes
  • retourner en attente d’une autre mesure.

Pour réaliser cet automate, on verra que j’ai utilisé une variable décrivant les différentes situations possibles. L’action qui en découle est conditionnée par un test de cette variable. C’est simple !

Pour définir et enregistrer la distance D exacte, j’ai évité de coder cette distance en dur dans le programme. Au contraire, j’ai imaginé une condition qui doit être réalisée à la mise sous tension pour appeler un sous-programme de réglage. Il utilise les 2 capteurs pour augmenter ou diminuer la valeur précédente (comme des boutons + et -) et pour enregistrer le résultat dans l’EEPROM de l’Arduino, sur 2 octets seulement (jusqu’à 65532 mm soit 65 m ce qui est largement suffisant, mais sans dépasser 65 cm toutefois dans le programme actuel à cause des types des variables de calcul)

Enfin, vous découvrirez quelques astuces qui vous seront peut-être utiles dans vos programmes.

Le SETUP

Définition des ressources nécessaires

  1. #define VERSION "Mesure Vitesse sur Pro-Micro V1.0 du 17/06/16 - Locoduino - Dominique"
  2.  
  3. #include <TM1637Display.h>
  4. #include <EEPROM.h>
  5.  
  6. // Tube module connection pins (Digital Pins)
  7. #define CLK 2
  8. #define DIO 3
  9.  
  10. TM1637Display display(CLK, DIO);
  11.  
  12. // detector pins
  13. #define DT0 8
  14. #define DT1 9

Nous avons 2 déclarations de bibliothèque :

  • TM1637Display qu’il faut télécharger [7] et installer dans l’IDE. Cette bibliothèque est fournie avec le programme dans l’archive jointe à la fin de l’article.
  • EEPROM est une bibliothèque intégrée à l’IDE

Déclaration des pattes de l’Arduino utilisées : 2 et 3 pour l’afficheur, 8 et 9 pour les capteurs.

Déclaration de l’afficheur avec ses 2 pins (création de l’objet "display").

Je n’ai pas trouvé nécessaire ni souhaitable d’ajouter d’autres périphériques (leds, boutons, ..). Je me suis dit qu’il faut faire avec les organes d’interface ci-dessus qui sont 2 entrées et une sortie. Nous verrons plus loin comment…

Définition des variables

  1. uint8_t data[] = { 0xff, 0xff, 0xff, 0xff };
  2. uint8_t blank[] = { 0, 0, 0, 0 };
  3. uint8_t lumin = 0x0f;
  4. unsigned long _time1, _time2, temps;
  5. byte dt0, dt1, odt0, odt1;
  6. bool debug = false;
  7. bool done;
  8.  
  9. // etat des capteurs de proximité
  10. // repos = tous les bits à 0 (etat=0)
  11. // dt0 = 0 si détection sur DT0 => P0=1
  12. // dt1 = 0 si détection sur DT1 => P1=2
  13. // 1ere detection sur DT0 : DP0 = 4
  14. // 1ere detection sur DT1 : DP1 = 8
  15. // affiche pendant _time2 : AFF = 16
  16. enum {Repos=0, P0=1, P1=2, DP0=4, DP1=8, AFF=16 };
  17. byte etat=Repos;
  18.  
  19. // distance entre capteurs 500 mm
  20. unsigned int distance=500;
  21. unsigned int VCM, VKM;
  22.  
  23. unsigned int val = 500;// distance par défaut en mm
  24. unsigned int delai = 5000;
  25. unsigned int k=0;
  26. byte V0,V1;

Nous avons maintenant les variables utilisées par le programme :

  • data[] et blank[] sont des affichages spéciaux ;
  • les variables de temps pour le calcul de vitesse, les instants de détection et des temporisations ;
  • les valeurs des capteurs,
  • des booleens debug pour des affichages sur la console (faux donc désactivé par défaut) et done pour sortir d’une boucle while dans la configuration de la distance ;
  • la variable d’état pour l’automate : elle est constituée de l’assemblage de bits correspondant aux divers événements. Les valeurs résultantes permettent de prendre les bonnes décisions ;
  • les variables pour le calcul de la distance ;
  • une valeur par défaut de la distance entre les capteurs : 50 cm ou 500 mm, la distance étant exprimée en mm pour une meilleure précision.

Remarque : la distance entre capteurs doit être inférieure à 655 mm pour ne pas dépasser la capacité des variables unsigned int VCM et VKM, à cause d’un facteur 100 utilisé pour augmenter la précision. Si ce devait être le cas, il faudrait changer leur type en unsigned long.

Le programme du setup

Il commence par l’ouverture du port série pour la console et l’envoi de la chaine de caractère VERSION. Cette pratique permet de savoir ce qu’il y a dans la mémoire de l’Arduino !

Ensuite il y a l’initialisation de l’afficheur avec un test d’affichage pendant 1 seconde (8888), l’initialisation des pins des détecteurs, la lecture des 2 premiers octets de l’EEPROM qui devraient contenir la distance D.

Si les valeurs lues sont 0xFF, cela signifie que l’EEPROM est vide : il faut donc ignorer cette lecture et prendre la valeur 500 définie plus tôt. Seule la procédure de réglage permettra d’écrire une valeur significative dans l’EEPROM. Alors, au démarrage suivant c’est cette valeur qui sera utilisée.

  1. // ----------------------------
  2. // SETUP
  3. // ----------------------------
  4.  
  5. void setup() {
  6.  
  7. Serial.begin(115200);
  8. while (!Serial) {
  9. ; // wait for serial port to connect. Needed for native USB port only
  10. }
  11.  
  12. Serial.println(VERSION);
  13. display.setBrightness(0x0f); // All segments on
  14. display.setSegments(data);
  15. delay(1000);
  16. Serial.println("init détecteurs");
  17. // init Pins détecteurs
  18. pinMode(DT0, INPUT_PULLUP);
  19. pinMode(DT1, INPUT_PULLUP);
  20. V0 = EEPROM.read(0);
  21. V1 = EEPROM.read(1);
  22. if ((V0!=0xFF)&&(V1!=0xFF)) {
  23. val = V0;
  24. val = val << 8;
  25. val = val | V1;
  26. }
  27. display.showNumberDec(val, false, 4, 0);
  28. distance=val;
  29. Serial.print("distance = ");Serial.println(distance);
  30. delay(2000);
  31.  
  32. odt0=digitalRead(DT0);
  33. odt1=digitalRead(DT1);
  34. if (!odt0 && !odt1) { // les 2 detecteurs sont excités
  35. reglage(); // reglage distance
  36. }
  37. _time1=millis();
  38. _time2=millis();
  39. etat=AFF;
  40. }

Pour déclencher la procédure de réglage, il faut placer un wagon devant chaque détecteur et mettre le montage sous tension. Voici ce que fait cette procédure :

  • L’affichage de la valeur initiale (soit 500, soit le contenu de l’EEPROM)
  • L’attente de la libération des 2 capteurs dans une boucle while qui bloque le programme en attendant
  • la lecture des 2 détecteurs, l’un pour augmenter, l’autre pour diminuer la valeur de la distance. Une tempo de 200 ms permet de rendre cette action "humaine".
  • Et si les 2 détecteurs sont à nouveau actifs en même temps, la nouvelle valeur est enregistrée en EEPROM.

Petite astuce nécessaire du fait que l’EEPROM ne peut stocker que des octets (byte) et que la distance est un entier (2 octets) : L’entier est recopié dans l’octet V1, perdant au passage les 8 bits de poids fort. Puis l’entier est décalé de 8 bits vers la droite, perdant ainsi ses 8 bits de poids faible et le résultat est copié dans V2. V1 et V2 sont ensuite stockés dans l’EEPROM avec la fonction update qui évite d’écrire si la valeur précédente était identique (cela augmente la durée de vie de l’EEPROM).

Une façon plus "moderne" de convertir 1 entier en 2 octets et 2 octets en 1 entier est d’utiliser les macros word(), lowByte() et highByte() :

  1. // au lieu de val = V0; val = val << 8; val = val | V1;//
  2. // tout simplement ://
  3. val = word(V0,V1);
  4.  
  5. // au lieu de V1 = val; V0 = val >> 8;//
  6. // tout simplement ://
  7. V0 = highByte(val);
  8. V1 = lowByte(val);

Le réglage de la distance entre les capteurs et l’enregistrement en EEPROM

  1. // ---------------------------
  2. // Reglage distance
  3. // ---------------------------
  4.  
  5. void reglage(void) {
  6. done = false;
  7. Serial.println("reglage distance");
  8. Serial.print("distance initiale = ");Serial.println(val);
  9. delay(2000);
  10. odt0=digitalRead(DT0);
  11. odt1=digitalRead(DT1);
  12. while ((!odt0 || !odt1)) {
  13. // attente détecteurs aux repos tous les 2
  14. odt0=digitalRead(DT0);
  15. odt1=digitalRead(DT1);
  16. }
  17. Serial.println("debut reglage");
  18. while (!done) {
  19. odt0=digitalRead(DT0);
  20. odt1=digitalRead(DT1);
  21. if (!odt0) { // augmente
  22. val++;
  23. display.showNumberDec(val, false, 4, 0);
  24. delay(200);
  25. }
  26. if (!odt1) { // diminue
  27. val--;
  28. display.showNumberDec(val, false, 4, 0);
  29. delay(200);
  30. }
  31. if (!odt0 && !odt1) { // enregistrement
  32. V1 = val;
  33. V0 = val >> 8;
  34. EEPROM.update(0, V0);
  35. EEPROM.update(1, V1);
  36. done=true;
  37. Serial.print("fin reglage distance = ");Serial.println(val);
  38. distance = val;
  39. }
  40. }
  41. }

Le coeur du programme étant le calcul de vitesse, nous y voici maintenant !

Après vérification que le temps n’est pas nul pour éviter une division par 0 qui planterait le programme, on calcule la vitesse réelle en millimetre/milliseconde (ou mètres/seconde) multipliée par 100 pour augmenter la précision (plus de chiffres significatifs).
Puis on applique le rapport 576/100 pour obtenir des km/h à l’échelle 1/160.

Rappel : on multiplie les m/s par 3600/1000 = 3,6 pour obtenir des km/h.
Puis on multiplie par 160 (échèle N), d’où le nombre 576 ci-dessus.

Le résultat est affiché pendant 5 secondes et la variable d’état devient égale à AFF pour que l’extinction soit effectuée plus loin dans la LOOP.

  1. // ---------------------------
  2. // Calcul de vitesse
  3. // ---------------------------
  4.  
  5. void calcul(void) {
  6. if (temps>0) {
  7. VCM=distance*100/temps;
  8. VKM=VCM*576/100;
  9. display.showNumberDec(VKM, false, 4, 0);
  10. Serial.print(", vitesse=");Serial.println(VKM);
  11. delay(delai);
  12. etat=AFF;
  13. _time2=millis();
  14. }
  15. }

La LOOP permet de faire du multitâche simplifié dans la mesure où ces tâches ne s’exécutent que si une condition particulière est réalisée.

Ici chaque condition est une ou plusieurs valeurs de la variable d’état état.

Nous avons donc successivement :

  • la lecture du 1er capteur
  • la lecture du 2eme capteur
  • le test du port série, si la console est connectée
  • le maintien de l’affichage du résultat pendant 5 secondes
  • et une animation durant l’inter-détection.

Le traitement des capteurs est le plus important :
Il est conditionné par l’état Repos ou une détection préalable sur l’autre capteur seulement.
Une première détection permet de positionner les bits de la variable d’état qui décrivent le capteur actif.
Une deuxième détection lance la procédure de calcul et d’affichage.

Dans tous les autres cas les lectures des ports DT0 ou DT1 sont ignorées. Cela a l’énorme avantage d’ignorer les détections parasites, les rebonds, etc..

La seule précaution à prendre consiste à éviter d’inonder de lumière les capteurs, ce qui provoquerait des fausses mesures. Mais cela se verrait très vite.

  1. // ----------------------------
  2. // LOOP
  3. // ----------------------------
  4.  
  5. void loop() {
  6.  
  7. // lecture des capteurs de proximité
  8.  
  9. //enum etat {Repos=0, P0=1, P1=2, DP0=4, DP1=8, AFF=16 };
  10. dt0=digitalRead(DT0);
  11. if (!dt0) { // detection sur DT0 (niveau LOW)
  12. if (etat==Repos) { // =0 : premiere detection sur DT0
  13. etat = P0+DP0; // 5
  14. k=0;
  15. temps = millis();
  16. _time1=millis();
  17. if (debug) {Serial.print("etat=");Serial.println(etat);}
  18. } else { // sinon c'est une 2me detection
  19. if (etat == P1+DP1) { // bonne seulement après DT1
  20. temps = millis()-temps;
  21. if (debug) {Serial.print(" Temps=");Serial.print(temps); }
  22. if (debug) {Serial.print(", Distance=");Serial.print(distance);}
  23. calcul();
  24. }
  25. }
  26. }
  27.  
  28. //enum etat {Repos=0, P0=1, P1=2, DP0=4, DP1=8, AFF=16 };
  29. dt1=digitalRead(DT1);
  30. if (!dt1) { // detection sur DT1 (niveau LOW)
  31. if (etat==Repos) { // =0 : premiere detection sur DT0
  32. etat = P1+DP1; // 10
  33. k=0;
  34. temps = millis();
  35. _time1=millis();
  36. if (debug) {Serial.print("etat=");Serial.println(etat);}
  37. } else { // sinon c'est une 2me detection
  38. if (etat == P0+DP0) { // bonne seulement après DT0
  39. temps = millis()-temps;
  40. if (debug) {Serial.print(" Temps=");Serial.print(temps); }
  41. if (debug) {Serial.print(", Distance=");Serial.print(distance);}
  42. calcul();
  43. }
  44. }
  45. }

Le test de la console via le port série est très sommaire :
On lit un nombre entier et on le teste.

Si c’est une valeur positive non nulle, on considère que c’est la distance entre les capteurs en mm et on l’écrit dans l’EEPROM.

Si la valeur est égale à 0, comme il est interdit de diviser par 0 dans le calcul de vitesse, on utilise ce cas particulier pour permuter le booléen debug. S’il est vrai, quantité d’affichages apparaissent alors sur la console.

  1. while (Serial.available() > 0)
  2. {
  3. val = Serial.parseInt(); // lecture entier
  4. if (Serial.read() == '\n')
  5. {
  6. if (val==0) {debug = !debug;}
  7. else {
  8. V1 = val;
  9. V0 = val >> 8;
  10. EEPROM.update(0, V0);
  11. EEPROM.update(1, V1);
  12. Serial.print("distance entre capteurs : ");
  13. Serial.println(val);
  14. distance = val;
  15. }
  16. }
  17. }

La variable delai est initialisée à 5000 (5 secondes). Au bout de 5 secondes l’affichage est éteint et l’état Repos autorise une nouvelle mesure.

  1. if (_time2+delai > millis()) {
  2. if (etat==AFF) {
  3. etat=Repos;
  4. if (debug) {Serial.print("etat=");Serial.println(etat);}
  5. display.setSegments(blank);
  6. }
  7. }

Animation entre les détections du 1er et du 2ème détecteur

C’est juste pour faire joli : la condition dans l’if représente ce cas particulier. Tant que cette condition existe, on affiche un compteur k qui est incrémenté à chaque loop. Cela permet de se rendre compte de la vitesse d’exécution de l’Arduino !

  1. if ((etat==P1+DP1)||(etat==P0+DP0)) {
  2. display.showNumberDec(k, false, 4, 0);
  3. k++;
  4. }
  5. } // fin de LOOP

Le programme ne pèse que 6202 octets, soit 20% de la flash du Pro Mini, qui n’est donc pas surchargé !

Vous pouvez le télécharger ici (l’archive contient aussi la bibliothèque TM1637) :

L’installation sur le réseau

J’ai commencé par percer des trous carrés de 1,5 cm de coté aux emplacements des capteurs, sur une ligne droite passant devant la console DCC  . Dans chaque trou, j’ai glissé un capteur avec les diodes IR placées vers la voie, à un bon centimètre au dessus du sol pour viser sur le bas de la caisse des wagons, voitures et locos.

Ensuite un 3ème trou devant la console DCC est percé pour installer l’afficheur. celui-ci sera maintenu à environ 45° pour être bien orienté vers les yeux du conducteur.

Le câblage est ensuite réalisé sous le réseau, simplement en branchant les câbles (vérifiez plusieurs fois avant de brancher et avant de mettre sous tension que les connecteurs sont dans le bon sens et sur les bonnes pins, le montage "en l’air" ayant pour but des marquer les câbles avec des repères).

Après mise sous tension et l’affichage de "8888" puis "500", je teste le système en faisant passer un wagon ou une loco. Ca marche !

Il ne reste plus qu’à étalonner la distance en plaçant un wagon devant chaque détecteur et en redémarrant le système. On trouve très vite le capteur qui augmente et celui qui diminue ! Quand la valeur est bonne on place les 2 wagons devant les 2 capteurs en même temps et l’initialisation est terminée.

L’intégration dans le décor se fait en installant une cabane sur chaque capteur, quelques buissons et c’est beau comme sur les photos ci-dessus.

Merci d’avance pour vos commentaires et suggestions, ainsi que votre propre expérience (plutôt sur le Forum).

4 Messages

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

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)

La rétro-signalisation sur Arduino

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)

Réalisation d’un affichage de gare ARRIVEE DEPART

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

Un automatisme de Passage à Niveau

Un chenillard de DEL

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