Comment piloter trains et accessoires en DCC avec un Arduino
La bibliothèque CmdrArduino
.
Par :
DIFFICULTÉ :★★☆
Dans l’article précédent « Comment piloter trains et accessoires en DCC avec un Arduino (1) », nous avons introduit la bibliothèque CmdrArduino qui permet de disposer d’un ensemble de fonctions DCC sans avoir besoin de connaître tous les détails de la norme, ni la programmation des interruptions.
Dans le présent article, nous allons présenter cette bibliothèque.
Attention : Depuis la rédaction de cet article, de nouveaux logiciels DCC sont apparus comme DCC++ décrit dans l’article 182. Pour une réalisation de votre centrale, vous préférerez plutôt DCCpp qui est téléchargeable ici sur le Git de Locoduino.
On commence par récupérer le dossier de cette bibliothèque à cette adresse :
https://github.com/Railstars/CmdrAr...
Le dossier contient les éléments suivants :
Attention, sur Mac, on prendra soin de renommer le dossier "CmdrArduino-master" en supprimant l’extension "-master", sinon l’environnement de programmation Arduino refusera d’installer la bibliothèque à cause du signe "-".
Les détails d’installation d’une bibliothèque sont décrits sur le site Arduino et aussi dans l’article Installation de l’IDE Arduino.
Pour mémoire, il suffit de sélectionner le dossier CmdrArduino dans le menu Croquis/Importer Bibliothèque/ajouter Bibliothèque (mais pas le fichier CmdrArduino-master.zip téléchargé).
Pour avoir accès aux fonctions de la bibliothèque,
1) il faut placer les 3 fichiers d’entête (.h) en début de programme :
// LIBRAIRIE CMDRARDUINO
#include <DCCPacket.h> // types et données utilisées
#include <DCCPacketQueue.h> // cuisine interne
#include <DCCPacketScheduler.h> // fonctions pour notre programme2) il faut déclarer une variable globale qui sera manipulée par la librairie
// DCC handler
DCCPacketScheduler dps; // structure de donnée pour la bibliothèque3) il faut placer la fonction d’initialisation dans la fonction setup()
// init CmdrArduino
dps.setup(); // initialise les Pins 9 et 10Cette fonction va programmer les broches 9 et 10 d’un Arduino Uno, Nano, Mini ou les broches 11 et 12 d’un Arduino Mega 2560 (je complèterai dès que j’aurai testé la librairie sur Arduino Due), ces broches OC1A et OC1B étant différents sur les processeurs 328 et 2560. Elles sont toutes les deux associées au Timer 1, le plus précis (16 bits).
Il n’est donc pas nécessaire de les déclarer par des instructions de ce type :
pinMode(PinXX, OUTPUT);
D’autre part, seule la broche 9 (328) ou 11 (2560) est utilisée pour générer le signal DCC, mais l’autre broche (10/328 ou 12/2560) étant connectée au Timer 1, est inutilisable pour autre chose.
4) il faut placer la fonction d’actualisation des données de la bibliothèque dans la fonction loop()
// Execution CmdrArduino à chaque LOOP
dps.update();Cette fonction doit être appelée le plus souvent possible pour permettre au code de la bibliothèque de mettre à jour ses données internes, notamment la gestion de la file des paquets à émettre sous interruption, la répétition des paquets, c’est à dire toutes les 5 à 10 milli-secondes environ.
Il est donc important de ne pas gaspiller le temps dans la fonction loop();
Les fonctions qui nous intéressent sont déclarées seulement dans le fichier DCCPacketScheduler.h, dont en particulier :
void setup(void);void update(void);1) Commande de vitesse 14, 28 ou 128 pas
Dans la pratique, on n’utilisera qu’une seule des 3 fonctions suivantes, selon que les locos seront programmées en 14 ou 28 (par défaut sur les décodeurs neufs) ou 128 pas de vitesse.
bool setSpeed14(uint16_t address, uint8_t address_kind, int8_t new_speed, bool F0=true); //new_speed: [-13,13], and optionally F0 settings.
bool setSpeed28(uint16_t address, uint8_t address_kind, int8_t new_speed); //new_speed: [-28,28]
bool setSpeed128(uint16_t address, uint8_t address_kind, int8_t new_speed); //new_speed: [-127,127]
Les paramètres de chaque fonction sont :
address : l’adresse DCC de la locoaddress_kind : le type d’adresse DCC_SHORT_ADDRESS ou DCC_LONG_ADDRESSnew_speed : la vitesse, en sachant que :
F0 dans le seul cas de setSpeed14 pour commander l’éclairage en même temps que la vitesse : true ou false.bool eStop(void);
Cette fonction commandera un arrêt immédiat de tous les trains.
bool eStop(uint16_t address, uint8_t address_kind);
Cette fonction commandera un arrêt immédiat d’un seul train, désigné par son adresse DCC. Elle fait donc double emploi avec les commandes de vitesse ci-dessus.
2) Commandes des fonctions des locos
On a 3 fonctions différentes pour traiter les fonctions locos 0 (FL, éclairage) à 4, 5 à 8 et 9 à 12. On se reportera à la notice du décodeur pour savoir si les fonctions existent et à quoi elles correspondent.
Les paramètres de chaque fonction sont :
address : l’adresse DCC de la locoaddress_kind : le type d’adresse DCC_SHORT_ADDRESS ou DCC_LONG_ADDRESSfunctions : les valeurs des fonction (1 active, 0 inactive), chacune étant codée sur un bit situé dans les bits de poids faible de l’octet functions qui doit prendre la forme binaire 000SDDDD.bool setFunctions0to4(uint16_t address, uint8_t address_kind, uint8_t functions);
Cette command permet d’actionner 5 fonctions (fonctions FL and F1 à F4) du groupe 1 de la norme NMRA [1].
Les bits 0-3 (DDDD) définissent les fonctions F1-F4 où la fonction F1 est commandée par le bit 0 et la fonction F4 par le bit 3. Une valeur "1" indique que la fonction est "en service" tandis que "0" indique qu’elle est "hors service".
Si le bit 1 du CV29 a pour valeur "1" (en général il l’est par défaut), alors le bit 4 (S) commande la fonction FL (lumière), sinon il est ignoré par le décodeur.
Les deux instructions suivantes permettent de commander jusqu’à 8 functions auxiliaires (F5-F12) dites "Function du Groupe 2" [2].
bool setFunctions5to8(uint16_t address, uint8_t address_kind, uint8_t functions);
Les bits 0-3 (DDDD) de l’octet functions définissent les functions F5-F8 : F5 correspond au bit 0 et F8 correspond au bit 3. Une valeur "1" indique que la fonction est "en service" tandis que "0" indique qu’elle est "hors service".
bool setFunctions9to12(uint16_t address, uint8_t address_kind, uint8_t functions);
Les bits 0-3 (DDDD) de l’octet functions définissent les functions F9-F12 : F9 correspond au bit 0 et F12 correspond au bit 3. Une valeur "1" indique que la fonction est "en service" tandis que "0" indique qu’elle est "hors service".
3) Commandes d’accessoires
Activation
bool setBasicAccessory(uint16_t address, uint8_t function);
Désactivation
bool unsetBasicAccessory(uint16_t address, uint8_t function);
Les paramètres de ces fonctions sont :
address : l’adresse DCC de l’accessoire.function : les valeurs de la commande d’accessoire. On se reportera bien évidemment à la notice du décodeur d’accessoire visé, celui-ci permettant de piloter plusieurs organes en même temps (aiguilles, feux, etc..).4) Commande de programmation de CV
bool opsProgramCV(uint16_t address, uint8_t address_kind, uint16_t CV, uint8_t CV_data);
Les paramètres de cette fonction sont :
address : l’adresse DCC de la locoaddress_kind : le type d’adresse DCC_SHORT_ADDRESS ou DCC_LONG_ADDRESSCV : le numéro de CVCV_data : la valeurs du CV.Cette bibliothèque permet de piloter les fonctions principales de la norme DCC, mais elle n’est pas exhaustive. La norme DCC est complexe et couvre de nombreuses situations. Les constructeurs de décodeurs de locos et d’accessoires adaptent cette norme à leurs produits : il faut donc consulter la documentation soigneusement.
Lors de la mise au point d’un projet de modélisme ferroviaire basé sur cette bibliothèque (ou une autre), il est hautement recommandé de visualiser ce qui se passe en sortie de la centrale pour vérifier que ce qui sort correspond à ce qu’on espère.
Il existe une autre bibliothèque Arduino qui permet de décoder les paquets DCC : Il s’agit de DCC_Decoder qui se trouve ici [3] : DCC_Decoder
Une série d’article lui est consacré, décrivant un décodeur d’accessoire universel « Un décodeur d’accessoires universel (1) » et « Un décodeur d’accessoires universel (2) ». Un autre à venir, DCC Monitor permettra de voir les paquets DCC qui circulent sur les rails.
Après 3 articles principalement théoriques, il n’y a rien de mieux que la mise en pratique.
Dans l’article qui suit, nous allons construire une petite centrale qu’il vous sera facile d’adapter à votre réseau ou de faire évoluer selon vos besoins et votre expérience grandissante de l’Arduino !
Merci Dominique pour cet excellent sujet.
J’allais poser la question "oui, mais ça se branche où ?" quand j’ai lu la partie grisée en fin d’article :-)
On a hâte de voir la suite.
Bon courage !
Je viens de lire l’article et c’est très intéressant.
Cependant, je regrette qu’il n’est question que d’évoquer quelques fonctions de la librairie sans parler du principe de codage/décodage que cette dernière utilise.
Je me permet de reprendre ici un morceau du texte :
Cette fonction doit être appelée le plus souvent possible pour permettre au code de la bibliothèque de mettre à jour ses données internes, notamment la gestion de la file des paquets à émettre sous interruption, la répétition des paquets, c’est à dire toutes les 5 à 10 milli-secondes environ.
La gestion de la file de bits, octets et paquets DCC ne se fait-elle pas à chaque interruption ?
On peut deviner que la solution est identique à celle évoquée dans la partie 1 de l’article ( Comment piloter trains et accessoires en DCC avec un Arduino (1) ) mais j’avoue ne pas comprendre l’histoire des 5 à 10 millisecondes.
S’agit-il de la durée moyenne des paquets (trames) DCC qui sont envoyé en boucle ?
Ou bien, y a t-il un moment de ’pause’ pour envoyer l’ensemble des paquets pendant une période fixe ?
(genre 5 paquets toutes les 5 à 10ms et si ça prends moins de temps que prévu, on garde un état bas ou haut pour avoir une période de répétition identique).
De même, il est évoqué l’utilisation de deux broches associées au timer 1 (16 bits) mais une seule est utilisée pour le signal DCC. Quid de la broche non utilisée et pourquoi ?
D’autre part, seule la broche 9 (328) ou 11 (2560) est utilisée pour générer le signal DCC, mais l’autre broche (10/328 ou 12/2560) étant connectée au Timer 1, est inutilisable pour autre chose.
D’ailleurs, pourquoi évoquer que la broche inutilisée est ’associée’ au Timer 1, laissant sous entendre que la broche utilisée n’a rien à voir avec ce timer, alors qu’avant, il est dit clairement que ces deux broches sont bel et bien associées au Timer 1 :
... Elles sont toutes les deux associées au Timer 1, le plus précis (16 bits).
Je pense avoir cerné l’ensemble de la librairie, mais j’avoue avoir été perturbé par certaines phrases.
Je précise que cela ne retire en rien le travail remarquable effectué pour offrir ainsi ces articles passionnants.
Bonjour et merci pour ces nombreuses questions auxquelles j’espère répondre complètement :
1) Principe du codage/décodage (des trames DCC je suppose) : Le codage DCC est décrit dans l’article suivant :
L’Arduino et le système de commande numérique DCC
Il traite seulement de ce qui nous sert le plus dans notre hobby, mais, si vous voulez approfondir, des liens vous permettent de trouver tous les documents officiels sur le norme DCC.
2) L’appel périodique de la fonction dps.update() ; toutes les 5 à 10 ms n’a rien à voir avec la gestion de la file de bits sous interruption, ni avec le durée des trames. Cette interruption est effectivement automatique et fait à peu près le même boulot que ce qui est décrit dans le 1er article mais pour l’envoi des bits seulement. Ces bits doivent être préparés pour l’envoi au préalable.
La bibliothèque fait bien plus que ça et notamment elle prépare les trames DCC à envoyer et les enregistre dans une zone mémoire qui est utilisée ensuite par la routine d’interruption. Elle assigne aussi des priorités (change l’ordre d’émission des trames, gère la répétition des trames). Il peut y avoir quantités de trames différentes dans cette préparation, nous en verrons d’autres dans des articles futurs.
Entre l’appel d’une fonction "setSpeed128" , par exemple, et l’envoi automatique par la routine d’interruption, il y a pas mal de code à exécuter et il faut bien donner la main à la bibliothèque pour fonctionner.
C’est d’ailleurs un principe général à (presque) toutes les bibliothèques. Vous le verrez dans les autres articles concernant d’autres bibliothèques.
Si vous le pouvez, je vous encourage à jeter un coup d’oeil au codes de la bibliothèque CmdrArduino ! Son fonctionnement est décrit dans les commentaires, en anglais (attention, on ne peut pas ouvrir les fichiers avec l’IDE Arduino, il faut une éditeur externe).
3) En ce qui concerne les paires de broches 9-10 (328) ou 11-12 (2560) dont l’une n’est pas utilisable : C’est une question de matériel dans le microcontrolleur. 2 broches sont associées au Timer 1 quand il est initialisé, même si on n’a besoin que d’une seule broche.
Je vous conseille de lire l’article sur les Timers
On ne peut donc pas se servir de cette deuxième broche, dans le cas où on utilise cette bibliothèque, avec un booster de type LMD18200 qui n’a besoin que d’une seule broche de commande et que je recommande.
J’ai simplement voulu préciser qu’il ne faut pas tenter d’utiliser l’autre broche pour une entrée ou une sortie digitale (ne surtout pas l’initialiser), sinon la routine d’interruption de la bibliothèque CmdrArduino ne fonctionnerait plus.
Si vous avez d’autres questions n’hésitez pas. Mais beaucoup de ces questions trouveront progressivement leur réponse au fur et à mesure des publications à venir dans Locoduino.
Bon loisir !
Merci pour ce retour rapide qui m’éclaire mieux sur le sujet.
Lorsque je parle du codage/décodage de la trame DCC, je parlais de la méthode qu’utilise la bibliothèque. Pour ce qui concerne la norme, il existe en effet plusieurs documents qui en parle et j’ai déjà parcouru pas mal de ces derniers.
Je n’ai pas encore ’fouillé’ dans la bibliothèque mais je compte le faire. Cependant, j’aimerais avoir une sorte de confirmation que cette dernière utilise bien le même principe d’utilisation d’une valeur initiale précise du timer 1 (suivant la valeur du bit à transmettre) qui allait engendrer un overflow de ce timer après une durée équivalente à la demi-période.
De toute façon, en y réfléchissant, je ne vois pas d’autre méthode pour produire le signal DCC avec l’utilisation d’un timer. Je pense que je me suis donné moi même (par le biais de ce remarquable article également) la réponse à ma question.
Merci encore.
(attention, on ne peut pas ouvrir les fichiers avec l’IDE Arduino, il faut une éditeur externe).
c’est vrai, mais pour me simplifier la vie lorsque j’essaie de décortiquer un programme je place une copie des .h et .cpp dans le même répertoire que le sketch et l’éditeur Arduino me les propose sous de nouveaux onglets. Il y a sans doute des inconvénients mais je trouve cela pratique.
Merci pour ces articles qui m’ont permis de débuter en DCC.
Ce que vous faites est dangereux car, si la compilation se passe toujours bien, les mises à jour ultérieures de la bibliothèque ne seront plus prises en compte.
Je vous conseille quand même d’installer un éditeur de texte supplémentaire et d’usage général pour consulter ces fichiers.
Le plus simple est que vous alliez directement dans le fichier DCCHardware.c de la bibliothèque. Vous y trouverez le setup des registres du timer et la routine d’interruption.
... Attention : Lien DCC-Monitor cassé =>
http://www.mynabay.com/dcc_monitor/
https://github.com/MynaBay/DCC_Decoder
Voir en ligne : DCC Monitor
Bonjour,
J’ai bien lu avec attention les articles tournant autour du pilotage par DCC qui m’ont permis de comprendre comment tout cela fonctionnait.
J’aimerai mettre en œuvre une commande d’aiguillages par DCC au moyen d’un arduino envoyant les ordres, et un autre recevant les ordres.
je pense qu’il faut utiliser la bilbiothèque CmdrArduino, et le sketch CmdrArduino_accessory.ino pour envoyer les ordres, et le sketch cde_aiguillage_nano_dcc.ino pour réceptionner les ordres et actionner les aiguillages.
Cependant je n’arrive pas à comprendre comment utiliser la fonction setBasicAccessory() et UnsetBasicAccessory() du sketch CmdrArduino_accessory.ino
Auriez vous un exemple simple avec un Bouton Poussoir pour contrôler un aiguillage via DCC ?
Merci pour aide et ce site très bien documenté.
Bonjour,
Vous tombez bien !
Le nouvel article publié aujourd’hui : Réalisation de centrales DCC avec le logiciel libre DCC++ (1)
Et les sujets correspondant sur le Forum :
devraient répondre en partie à votre question, notamment pour ce qui est de l’envoi des commandes DCC.
Vous aurez compris qu’il vaut mieux, quand on part de zéro (ou pas), utiliser d’emblée DCC++, alors que CmdrArduino reste plus difficile à comprendre, d’autant que son auteur n’assure plus le suivi.
Pour recevoir et exécuter des ordres DCC via les rails, je vous renvoie vers article de Nicolas Zin ou ceux de Thierry.
Dites nous ce que vous voulez réaliser et nous pourrons peut-être vous orienter plus finement.
Cordialement.
je vais regarder l’article dcc++...
mais je ne souhaite pas contrôler tout par ordinateur pour l’instant.
dans un 1er temps, je souhaite utiliser des boutons poussoirs pour actionner mes aiguillages.
les boutons poussoirs sont sur un 1er arduino émettant les ordres DCC, les aiguillages sont répartis sur différents récepteur à base d’arduino utilsant DCC.
utiliser d’ambler le protocole DCC me permettra de basculer facilement au tout contrôler par ordinateur plus tard.
Il y a des choses que je ne comprend pas dans votre approche :
Je suis encore en tout analogique et j’aimerai passer progressivement en numérique.
L’idée d’utiliser tout de suite du DCC était de réduire le nombre de fils parcourant ma maquette.
J’utiliserai seulement 3 fils (12v, data, gnd) en dehors des rails alimentant encore en analogique mes locos.
J’ai vu qu’il y avait un sketch + typon pour commander directement des aiguillages mais ce n’est pas mon idée de départ.
Donc si vous connaissez les quelques fonctions d’une librairie DCC pour commander des aiguillages, je vous en remercie par avance.
J’ai déjà pas mal de connaissances en électronique et programmation Arduino, je me débrouillerai ensuite pour les boutons poussoirs et adapter le code.
« Je suis encore en tout analogique et j’aimerai passer progressivement en numérique. »
A bagou91 :
C’est bien, mais mon point de vue est que le DCC n’est indispensable QUE pour commander les locos mais PAS les accessoires comme les aiguilles. Lisez mes articles sur l’architecture des réseaux.
Si vous aviez déjà une centrale DCC du commerce, je comprendrais que vous cherchiez à décoder les commandes d’accessoires. Mais là, sans rien en digital, il me semble plus judicieux d’utiliser un réseau de type CAN (qui peut être grand - voyez les articles : il y en a plein pour vous rassurer) ou I2C si le réseau est petit.
Mais générer un signal de puissance en +/-15V sur 2 fils (pas 3) est particulièrement incongru, désolé !
Mais si vous y tenez absolument, en lisant déjà l’article sur DCC++ vous y trouverez les commandes d’accessoire (dont les d’aiguilles).
Si les explications dans cet article ne sont pas suffisantes, venez en discuter sur le forum dans le sujet DCC++. D’autres modélistes pourront participer à la discussion et vous aider.
Mais je pense sincèrement que vous auriez le plus grand bénéfice à passer en revue d’autres articles aussi, présentant divers points de vue.
Vous pouvez aussi m’envoyer un MP, si vous êtes dans le 91, je ne suis peut-être pas très loin.
Cordialement.
OK merci pour ce complément d’infos. Je vais lire les articles sur le bus CAN...
Si j’ai d’autres questions plus avancées sur la programmation, j’irai sur le forum.
Oh que oui vous n’êtes pas très loin... :)
J’ai habité Arpajon et déjà visité votre expo sous les combles lors d’une porte ouverte. Maintenant je suis à quelques kilomètres dans un village voisin. J’essaierai de passer un samedi.
"J’essaierai de passer un samedi"
Plutôt un lundi !! Merci.
Bonjour,
J’ai 2 décodeurs avec l’adresse 3. Est-ce que la bibliothèque CmdrArduino peut permettre de changer l’adresse d’une des 2 locomotives, par exemple loco 1 adresse 3 et loco 2 adresse 4 ? Pourriez vous alors détailler la méthode ? Sinon, comment faire avec Arduino ?
Merci.
La bibliothèque CmdrArduino permet peut-être de programmer les CV mais je n’ai pas exploré ces fonctionnalités et je lui préfère, maintenant, le logiciel DCC++.
Regardez l’article récent sur DCC++, ainsi que le sujet sur le Forum et vous trouverez comment programmer les adresses de vos locos.
Bonjour
J’ai commencé mon réseau avec une ECOS et 5 switchpilot-servos, mais depuis je fais tout par arduino.
Grace à vos articles j’ai fait le CAN-BUS, Les décodeurs servo pour aiguilles (70), le S88, les décodeurs 3 feux.
Le problème est que mon Ecos ne sait plus ce que je fais.
Je voudrais piloter au moins pour les accéssoires, mon ECOS. Est-ce une idée farfelue que de créer une mini-centrale qui recevraient des informations (via CanBus) pour envoyer des trames à l’Ecos via le SNIFFER ?
Connaissez-vous la valeur de "function" à utiliser pour bouger une aiguille avec la commande :
bool setBasicAccessory(address, function) ;
Merci
Jean-Claude
Bonjour Jean-Claude,
Vos efforts sont louables car vous avez bien introduit l’Arduino tout autour de l’Ecos autant que vous pouviez. Maintenant vous voulez faire participer l’’Ecos au système. Deux solutions possibles :
Merci Dominique.
Pour l’abandon de L’Ecos et faire une centrale Arduino, je ne me sens pas prêt. Mes compétences me le permettent pas.
Je vais regarder vers le sniffer mais il n’y a pas beaucoup d’articles sur le net à son sujet.
Je sais juste que l’on branche son ancienne centrale sur le sniffer (rails vers sniffer)....mais je ne sais pas comment réagit l’Ecos.
Du coup je pense faire une mini centrale pour des tests......premiers pas vers une central arduino ????.
merci
Bonjour Dominique
Pour info, sur un méga j’ai mis un Can-Bus et un LMD18200 que j’ai relié au sniffer de l’Ecos.
Quand des ordres sont envoyés dans le Can-Bus cette mini-centrale génère la trame de l’accessoire.
L’Ecos la décode bien, met à jour les icônes et envoie l’ordre.
Cela marche pour les décodeurs servos d’aiguilles et pour le décodeur 3 feux.
Quand j’aurai un peu de temps, je mettrai mon site à jour letraindejc.free.fr
Merci encore pour vos articles.
Merci Jean-Claude,
il y a une ECOS dans mon club. Je vais demander des infos sur ce « sniffer » pour comprendre !
Bonjour Jean-Claude,
C’était écrit discrètement : j’ai regardé votre site Le Train de JC qui montre votre immense projet soigneusement fait. Je vous proposerai bien de décrire votre réseau sur le Forum Locoduino (rubrique Les Réseaux)
En attendant, je regarde la doc de l’ECOS pour voir ce qu’on peut faire sur le port Sniffer qui est fait pour y brancher de "vielles" centrales. On pourrait donc se servir de l’Ecos comme un simple Booster.
Je pense qu’on peut brancher sur le sniffer un Arduino avec DCC++ (DCCpp) qui gère complètement quelques trains automatiques avec rétrosignalisation, tout en continuant à jouer avec d’autres trains avec l’Ecos directement, ainsi que gérer des routes pour ces autres trains.
Cordialement
Dominique
Je viens de lire la doc de l’Ecos sur le port Sniffer : effectivement on doit pouvoir faire pas mal de choses interessantes comme piloter des trains automatiques et des accessoires avec un Arduino pendant que l’Ecos continue à piloter d’autres trains et d’autres accessoires.
Ça ouvre des perspectives intéressantes pour ceux qui possèdent une Ecos !!
Bonjour Dominique
Je le pense aussi, paradoxalement je n’ai rien trouvé sur la toile..même en anglais.
Cela fonctionne, reste à l’intégrer dans mon installation. J’ai quelques modifications à faire.
Ok pour la rubrique "Réseaux".
bonne journée
Jean-Claude
Je viens d’ouvrir un nouveau sujet sur le Forum : L’Arduino et l’ECoS, une complémentarité à explorer.
Bonjour Dominique
Bien le sujet sur le forum, il transcrit bien l’idée.
Pour ma part j’ai mis à jour mon site.
Votre site m’a permis de mettre en oeuvre une idée. Mais comme je ne fais qu’adapter, je serai très intéressé par un "projet" sur le sniffer.
Cordialement
Jean-claude
Voir en ligne : http://letraindejc.free.fr
Bonjour,
Je suis actuellement en projet de terminale et ma locomotive répond à deux adresses DCC différentes. Mon objectif est de pouvoir diriger deux locomotives à l’aide d’une application mais une loco répond à l’adresse 0 et l’autre répond à l’adresse 0 et l’adresse 3.
Comme les adresses 0 sont en commun les deux locomotives réagissent au même ordre et je rencontre donc un problème pour les commander.
J’ai déjà cherché de mon coté mais je n’ai rien trouvé, serait-ce un problème de programme ?
Cordialement
C’est bizarre d’avoir des locos en adresse 0 !?! Changez les adresses de vos locos.
CV1 = Short Address (2 Digit Address) 1-127 is the actual NMRA range. Short Address "0" is not allowed to control a individual DCC decoder.
C’est justement le rôle de l’adresse 0 que de faire fonctionner deux locos accouplées en UM (unité multiple)
Voir en ligne : Consisting Explained
Oui j’avais vu ça sur les docs du booster de de la télécommande MultiMaus (en revanche je ne savais pas que son but était de contrôler plusieurs locos) En fait je n’avais pas accès au CV1 car la manette m’affiche l’erreur 4, qui signifie que je suis en mode POM.
En fait dans mon programme elles sont à l’adresse 0 mais quand je vérifie avec un booster pré-fait (le roco 10764 et une MultiMaus) je trouve qu’ils sont à l’adresse 10 (pour celle qui répond à l’adresse 0) et l’adresse 2 (pour celle qui répond au 0 et 3.
pour mon programme c’est juste pour le contrôle d’une locomotive grâce au bluetooth
/********************
* Centrale DCC minimum avec un potentiomètre de vitesse connecté
* sur le port analogique 0,
* un bouton poussoir connecté entre le 0V et l’entrée digitale 4
* Le signal DCC est délivré sur la Pin 9, et est capable de piloter
* un booster à base de LMD18200 directement.
********************/
#include <DCCPacket.h>
#include <DCCPacketQueue.h>
#include <DCCPacketScheduler.h>
DCCPacketScheduler dps ;
unsigned int analog_value ;
int state=0 ;
void setup()
Serial.begin(9600) ;
dps.setup() ; // initialisation de la librairie
void loop()
if (Serial.available() >0)
state = Serial.read() ;
if (state==0) // avancer
dps.setSpeed28(0,DCC_SHORT_ADDRESS, 60) ;
if (state==1) // stopper
dps.setSpeed28(0,DCC_SHORT_ADDRESS,0) ;
if (state==2) // reculer
dps.setSpeed28(0,DCC_SHORT_ADDRESS,-60) ;
if (state==3) // avancer
dps.setSpeed28(0,DCC_SHORT_ADDRESS,60) ;
if (state==4) // stopper
dps.setSpeed28(0,DCC_SHORT_ADDRESS,0) ;
if (state==5) // reculer
dps.setSpeed28(0,DCC_SHORT_ADDRESS,-60) ;
// Cet appel est impératif pour permettre à la librairie de faire son travail
dps.update() ;
Je pense que l’erreur viens du programme, j’ai setup la vitesse a 28 crans. En entrant une vitesse de 25 par exemple, la locomotive n’avance presque pas, contrairement a la vitesse 120. J’ai bien sur vérifié si elles avaient été programmées en 28 crans.
Il faut vous plonger dans les exemples des bibliothèques ...
Et ici, initialiser les variables nécessaires, dont les adresses des locomotives, faute de quoi, étant à 0, ce sera cette adresse qui sera émise.
Un petit tour sur le site éditorial vous donnera des bases.
Bonjour,
en première approximation, l’adresse 0 a un rôle particulier et ne devrait pas être utilisée. (revoir la norme NMRA)
il faudrait nous en dire plus sur votre programme de commande : sur quelle base matérielle, quel programme, respecte-t-il les normes NMRA ?
Cordialement
Cette bibiothèque est maintenant obsolète (voir en début d’article) "Attention : Depuis la rédaction de cet article, de nouveaux logiciels DCC sont apparus comme DCC++ décrit dans l’article 182. Pour une réalisation de votre centrale, vous préférerez plutôt DCCpp qui est téléchargeable ici sur le Git de Locoduino.
Oui j’avais pris connaissance de cette rubrique, mais nous devons pas utiliser d’ordinateur en direct, je dois uniquement avoir mon booster (sans interface) et commander ces trains avec une application bluetooth.
Je viens d’ailleurs de trouver la solution à mon problème, comme vous m’avez dit que l’adresse 0 commande TOUTES les locomotives. J’ai compris que j’ai été bête car les adresses vont de 1 à 127, je ne sais pas pourquoi mais je m’étais mis en tête que les adresses allaient de 0 à 5 (alors qu’elles se font sur 7 bits...) en modifiant mon programme avec l’adresse 10 ma
locomotive a avancé
"dps.setSpeed28(10,DCC_SHORT_ADDRESS, 120) ;"
En tout cas merci pour votre aide et vos réponses rapides.
Bonne journée
Timothée
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)
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)
Un décodeur DCC pour les plaques tournantes Fleischmann et Roco
Un programme pour régler facilement les servos moteurs avec un ESP32
Identifier et localiser vos trains avec le RFID/NFC et un bus CAN.
Automatisation du pont FLEISCHMANN 6152 (HO) avec un ESP32 (1)
L’Arduino au coeur des systèmes de pilotage analogiques ou numériques
Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO
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
Block Automatique Lumineux avec la carte shield "Arduino 4 relays"
,
,
,
Réalisation de centrales DCC avec le logiciel libre DCC++ (3)
Comment piloter trains et accessoires en DCC avec un Arduino (3)
Réalisation de centrales DCC avec le logiciel libre DCC++ (1)