LOCODUINO

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

Présentation de la norme DCC

.
Par : Dominique

DIFFICULTÉ :

Avec ses multiples entrées/sorties facilement programmables et ses processeurs dotés de fonctions analogiques et numériques, l’Arduino ne peut que bien se prêter aux applications dans le domaines des trains miniatures comme il l’est dans d’autres domaines comme l’aéromodélisme, par exemple.

Cette série d’articles a pour but de vous amener progressivement dans la réalisation pas à pas d’une mini-centrale de pilotage numérique de vos trains et accessoires, selon la norme DCC, ainsi que dans celle de décodeurs DCC pour piloter vos accessoires.

Elle a pour but de vous présenter les notions essentielles à connaitre pour vous permettre ensuite d’adapter ces connaissances à votre propre réalisation.

Qu’est ce que le DCC ?

DCC signifie « Digital Command Control », en français « Système de Commande Numérique ».

C’est un standard utilisé dans le modélisme ferroviaire pour commander individuellement des locomotives ou des accessoires de voie en modulant la tension d’alimentation de la voie.
Ce système défini par une norme du NMRA (National Model Railroad Association) a été ensuite adopté par le MOROP (Union Européenne des Modélistes Ferroviaires et des Amis des Chemins de Fer).
Les locomotives et leurs accessoires (feux, effets sonores des engins moteurs) ainsi que les accessoires du réseau (aiguillages, itinéraires) possèdent chacun une adresse unique. Le signal codé envoyé sur la voie donne des ordres aux équipements tout en fournissant la puissance.

Cette définition est un extrait de l’encyclopédie libre Wikipédia [1] que je vous invite à lire pour en connaitre les possibilités et aussi la complexité, ses avantages et inconvénients.

Lorsque j’ai voulu rénover le petit circuit qui dormait depuis plus de 15 ans dans le grenier, alimenté par un bête transformateur et son gros bouton de réglage de vitesse, j’ai décidé de m’orienter vers le DCC qui m’offre des possibilités d’évolutions indéniables (au début, on ne sait pas toujours exactement où l’on va !). Avec le recul, maintenant, je vois mieux l’intérêt du DCC et je ne regrette pas mon choix.

Mais à cause de cette alimentation spéciale qui combine la transmission de données sur la voie avec la fourniture de la puissance, il faut forcément un organe électronique : la centrale et son booster.

L’Arduino comme centrale DCC

La principale difficulté réside dans la production du signal DCC, conformément à la norme NMRA [2], [3], [4].

Ainsi que la version française du MOROP [5], [6]

Mais envoyer des 0 et des 1 à un rythme prédéfini correspond bien aux possibilités de ce micro-contrôleur.

Un bit 1 est constitué de 2 parties de durée égale à 58 micro-seconde (entre 55 et 61 selon la norme) et de polarité opposées. Un bit 0 est constitué de 2 parties de durée au moins égale à 100 micro-seconde et de polarité opposées.

C’est une sorte de tension alternative à 2 fréquences. Cela permet au décodeur placé dans une machine de redresser cette tension pour fournir l’énergie de traction au moteur à courant continu (12 à 18 V), ainsi que l’alimentation (3,3 ou 5 V) au micro-contrôleurs qui fera le décodage en détectant les fronts (montant ou descendant) du signal DCC et la durée entre 2 fronts consécutifs (58 ou 100 micro-secondes), ce qui restitue bien les 0 et les 1.

La seule vraie contrainte est de produire ce signal en tâche de fond, c’est à dire sans empêcher notre Arduino de faire des quantités d’autres tâches que nous verront plus loin, qui, réciproquement, ne doivent pas géner la production automatique de ce signal DCC.

On pourra se reporter, pour comprendre cela, à d’autres articles qui seront prochainement publiés sur les entrées-sorties, les interruptions, les automates, etc...

Quel est donc ce signal DCC ?

Voici 3 exemples simples de trame DCC couramment envoyées sur les rails, à destination des locomotives :

Une commande de vitesse est décrite par la succession de bits 0 et 1 suivants :

111111111111 0 0AAAAAAA 0 01DCSSSS 0 EEEEEEEE 1
.............. le temps s’écoule dans ce sens .................>

  • 111111111111 est le préambule qui doit contenir au moins 12 bits 1,
  • le 0 suivant marque le début de l’adresse qui suit,
  • 0AAAAAAA est l’adresse de la loco (par exemple pour l’adresse 55 : 00110111),
  • le 0 suivant marque le début de la commande qui suit,
  • 01DCSSSS est la commande de direction et vitesse :
  • D = 1 pour la marche avant, D = 0 pour la marche arrière
  • CSSSS est la vitesse codée en 28 pas dans chaque sens (par exemple pour la vitesse 6 en avant : 01110100),
  • le 0 suivant marque le début de la détection d’erreur,
  • EEEEEEEE est un OU Exclusif (XOR) des octets précédents (préambule excepté puisque ce n’est pas un octet) qui sert à verifier la bonne transmission de la commande : le décodeur va calculer le OU Exclusif des octets reçus (sauf celui-là) de son coté et si le résultat qu’il trouve est égal à cet octet reçu, alors il considère que la commande est bien transmise et il exécute la commande,
  • enfin, le dernier 1 termine la commande, une autre commande pouvant suivre.

Quelques remarques : la transmission est du type série, les bits sont émis un par un, bit de poids fort en tête, poids de poids faible en queue. Un bit 0 sert de séparateur entre 2 octets (8 bits) : il permet au récepteur de prendre le temps de mémoriser l’octet précédent juste avant de recevoir le suivant.
Quand l’adresse est codée sur un seul octet, cet octet commence par un 0 (donc la commande ne peut accéder qu’aux adresses inférieures à 128). Pour les adresses supérieures, le premier bit est à 1 et l’adresse est codée sur 2 octets. Les adresses 00, 126 et 127 sont interdites car réservées à des opérations spéciales.

L’exemple donnés correspond à ce qu’on appelle un paquet de base (un octet d’adresse + un octet de commande). Mais il existe d’autres structures dites paquet étendu dans lesquelles l’adresse est sur 1 ou 2 octets et la commande sur 1 à 3 octets.

On trouvera plus de détails en français dans le document du MOROP : NEM671 pour les commandes de base et dans le document de NMRA : RP-9.2.1 pour les paquets étendus.

Pour cette commande de base, cela donne le signal suivant, si l’on utilise un oscilloscope :

qui représente une commande de vitesse de valeur 6 en marche avant pour la loco 37.

Une commande de lumière est décrite par :

111111111111 0 0AAAAAAA 0 100L0000 0 EEEEEEEE 1

  • 111111111111 est le préambule,
  • le 0 suivant marque le début de l’adresse qui suit,
  • 0AAAAAAA est l’adresse de la loco (par exemple pour l’adresse 3 : 00000011),
  • le 0 suivant marque le début de la commande qui suit,
  • 100L0000 est la commande de lumière :
  • L = 1 pour allumée, L = 0 pour éteinte
  • le 0 suivant marque le début de la détection d’erreur,
  • EEEEEEEE est le OU Exclusif des octets précédents pour la détection d’erreur.

Une trame IDLE est émise quand il n’y a pas de trame de commande à envoyer, de façon à alimenter continuellement la voie :

111111111111 0 11111111 0 00000000 0 11111111 1

On comprend ainsi que l’adresse 255 est interdite !

Bien entendu il existe des quantités de commandes possibles, pour commander les diverses fonctions des locomotives, selon le décodeur qui y est installé, des commandes d’accessoires de voie (aiguilles, feux, passages à niveau, dételeurs, plaques tournantes, lumières de décor, etc..), là aussi selon les décodeurs installés. Sans oublier les commandes de programmation des CVs des décodeurs !!!

C’est d’ailleurs dans cette diversité de commandes que réside la complexité du DCC.

Une autre difficulté vient du fait que les informations sont transmises par les rails en même temps que la puissance. On sait tous que les mauvais contacts sont légion et une partie des commandes sont perdues (notamment lors de vérification du XOR de détection d’erreur).

La norme DCC recommande donc de répéter les commandes autant que possible, en laissant toutefois un petit délai de 5 milli-secondes entre commandes destinées à un même décodeur.
Cela correspond à 45 bits 1, c’est à dire bien plus qu’un préambule. Le mieux est donc d’intercaler des trames IDLE.

Quelle est la durée d’une commande DCC ?

Si on additionne les durées de bits 1 et 0 de l’exemple ci-dessus, on trouve 5900 micro-secondes.

Mais la durée des bits 0 et 1 peut varier d’une centrale à une autre (les décodeurs sont conçus pour s’y retrouver quand même) et les commandes n’ont pas le même nombre de 0 et de 1. Elles sont aussi souvent plus longues (par exemple pour le codage de vitesse en 128 pas).

Nous arrivons à une durée de commande comprise en 6 et 10 milli-secondes environ, ce qui se traduit par un nombre de 100 à 150 commandes par seconde au grand maximum !

Ce n’est pas énorme mais cela permet tout de même de piloter beaucoup de trains et d’accessoires sur la même voie. Cependant, plus le nombre d’éléments à piloter augmente, plus le risque augmente de voir un élément ne pas obéir ou agir à retardement, notamment parce que certaines commandes sont perdues lors des perturbations (mauvais contacts).

Il faudra donc en tenir compte pour les grands réseaux : On n’a pas forcément intérêt à faire passer TOUTES les commandes en DCC, les Arduino nous offrant d’intéressantes alternatives.

On verra plus loin qu’il existe aussi des outils permettant de voir et surveiller les transmissions DCC, lorsque le doute s’installe !

L’Arduino est-il capable de générer un signal DCC ?

La réponse est assurément OUI puisque ce signal consiste en une suite de 0 et de 1 séparés par une délai de 58 ou 116 microsecondes, ce qui correspond, au pire, à un signal "audio" de l’ordre de 10 KHz. Mais ne pensez pas tout de même qu’il suffit simplement d’utiliser l’instruction tone() !

De même, il n’est pas conseillé d’utiliser l’instruction delay comme dans l’exemple ci-dessous :

void bit_un(){              // génère un bit à 1
    digitalWrite(dcc_pin, LOW);   // dcc_pin à 0
    delayMicroseconds(58);        // pause de 55 microsecondes      
    digitalWrite(dcc_pin, HIGH);  // dcc_pin à 1
    delayMicroseconds(58);        // pause de 55 microsecondes  
}

void bit_zero(){           // génère un bit à 0
    digitalWrite(dcc_pin, LOW);   // dcc_pin à 0
    delayMicroseconds(116);       // pause de 100 microsecondes      
    digitalWrite(dcc_pin, HIGH);   // dcc_pin à 1
    delayMicroseconds(116);       // pause de 100 microsecondes
}  

car le processeur ne peut pas faire autre chose pendant ces delay.

L’utilisation des interruptions est de loin préférable.

L’article suivant, « Comment piloter trains et accessoires en DCC avec un Arduino (1) » va vous présenter deux méthodes permettant de produire ce signal DCC.
D’autres articles, ensuite vous permettront de mieux connaitre une librairie dédiée au DCC et de construire une mini-centrale avec quelques compléments nécessaires comme le Booster et quelques composants électroniques.

L’Arduino est-il capable de décoder un signal DCC ?

Comme on l’a expliqué plus haut, la forme du signal DCC se prête bien à un décodage des 0 et des 1 et ensuite des paquets (adresses et commandes).

D’autres articles vous présenteront comment construire un décodeur DCC universel, utilisant aussi une librairie dédiée. Dans ce domaine le champ d’applications est très large.
Ou encore comment voir les commandes DCC qui circulent sur les rails.

24 Messages

  • L’Arduino et le système de commande numérique DCC 11 juillet 2015 14:47, par Jean-Pierre Claudé

    Bonjour,
    je suis tout nouveau sur ce site et vraiment très intéressé car arduiniste et ayant un réseau en DCC. Vos articles sont passionnant.
    En lisant votre article, je ne comprends pas comment vous calculez les adresses et les commandes dans votre exemple :
    111111111111 0 0AAAAAAA 0 01DCSSSS 0 EEEEEEEE 1
    0AAAAAAA est l’adresse de la loco (par exemple pour l’adresse 37 : 00110111) => 0 : inférieure à 128, 0110111 = 55 ?? (37 = 0100101)
    de même, 01DCSSSS est la vitesse codée en 28 pas dans chaque sens (par exemple pour la vitesse 6 en avant : 01110100) => 01 = commande, D = 1 en avant, V = 10100 = 20 ?? (6 = 00110)
    Merci beaucoup pour la qualité de ce site et par avance pour votre réponse.
    Bien cordialement.

    Répondre

  • L’Arduino et le système de commande numérique DCC 11 juillet 2015 17:43, par Dominique

    Bonjour,

    Vous avez tout à fait raison !
    L’exemple cité est tiré de le NEM671 dont la valeur de vitesse est bien 55.

    Mais dans une Nième relecture de l’article, un moment de fatigue m’a fait décomposer l’octet en 2 quartets et c’est devenu 0011 = 3 et 0111 = 7.
    J’ai corrigé de 55 en 37 !
    Alors que 3*16+7 = 55.

    Je corrige l’article : merci d’avoir déniché la coquille, cela prouve que vous faites très attention !

    En ce qui concerne la vitesse, reportez-vous au tableau de la NEM671 où, pour la vitesse 6, SSSSC=01001, soit CSSSS=10100 comme dans l’article.
    J’avoue que je n’utilise pas la gradation de 28, mais plutôt celle de 128 qui est plus facile à coder.

    Dominique

    Répondre

    • L’Arduino et le système de commande numérique DCC 13 juillet 2015 16:25, par Jean-Pierre Claudé

      Merci beaucoup pour votre réponse.
      En effet le codage des vitesses me semble plus ésotérique, le bit C à l’air d’être à 1 pour les valeurs paires et 0 sinon, une même valeur S3S2S1S0 avec le bit C = 0 vaudra valeur +1 avec le bit C = 1. Il doit y avoir une raison à cela mais ça ne facilite pas le décodage.
      Bien cordialement.

      Répondre

  • L’Arduino et le système de commande numérique DCC 13 juillet 2015 20:26, par Dominique

    Merci de votre compréhension ;)
    La norme DCC n’est pas ce qu’il y a de plus clair. Je suis persuadé que nous les français ne nous sommes pas impliqués suffisamment pour en faire quelque chose de simple, précis et efficace.

    Donc il faut faire "avec" !

    Répondre

    • L’Arduino et le système de commande numérique DCC 25 juillet 2015 12:55, par Jean-Pierre Claudé

      Bonjour,
      j’ai étudié en détails la librairie CmdrArduino. Très gros travail et je pense y bricoler dedans. Pour cela j’ai besoin de connaitre l’ensemble des paquets possibles. J’ai regarder un peu partout mais on tourne très vite en rond. Je me permets donc de vous soumettre le résultat de mes recherches afin qu’un expert puisse me dire s’il manque des paquets, en particulier quid des paquets en mode POM ? Quand a-t-on des paquets de 6 octets ?
      Voici la liste que j’ai obtenue (j’ai enlevé les détails des contenus).

      Paquets multifonctions (locomotives)
      Préambule = minimum 14 bits à ‘1’
      Adresse courte
      Paquet reset : 3 octets
      |0|00000000|0|00000000|0|00000000|<1>
      Paquet vide : 3 octets
      |0|11111111|0|00000000|0|11111111|<1>
      Paquet vitesse/direction, 14 pas : 3 octets
      |0|0a6a5a4a3a2a1a0|0|01DXs3s2s1s0|0|e7e6e5e4e3e2e1e0|<1>
      Paquet vitesse/direction, 28 pas : 3 octets
      |0|0a6a5a4a3a2a1a0|0|01DCs3s2s1s0|0|e7e6e5e4e3e2e1e0|<1>
      Paquet vitesse/direction, 128 pas : 4 octets
      |0|0a6a5a4a3a2a1a0|0|00111111|0|Ds6s5s4s3s2s1s0|0|e7e6e5e4e3e2e1e0|<1>
      Paquet accessoires de la loco F0 à F4 : 3 octets
      |0|0a6a5a4a3a2a1a0|0|100F0F4F3F2F1|0|e7e6e5e4e3e2e1e0|<1>
      Paquet accessoires de la loco F5 à F8 : 3 octets
      |0|0a6a5a4a3a2a1a0|0|1011F8F7F6F5|0|e7e6e5e4e3e2e1e0|<1>
      Paquet accessoires de la loco F9 à F12 : 3 octets
      |0|0a6a5a4a3a2a1a0|0|1010F12F11F10F9|0|e7e6e5e4e3e2e1e0|<1>
      Adresse longue
      Paquet vitesse/direction, 14 pas : 4 octets
      |0|11a13..a8|0|a7..a0|0|01DXs3s2s1s0|0|e7e6e5e4e3e2e1e0|<1>
      Paquet vitesse/direction, 28 pas : 4 octets
      |0|11a13..a8|0|a7..a0|0|01DCs3s2s1s0|0|e7e6e5e4e3e2e1e0|<1>
      Paquet vitesse/direction, 128 pas : 5 octets
      |0|11a13..a8|0|a7..a0|0|00111111|0|Ds6s5s4s3s2s1s0|0|e7e6e5e4e3e2e1e0|<1>
      Paquet accessoires de la loco F0 à F4 : 4 octets
      |0|11a13..a8|0|a7..a0|0|100d4d3d2d1d0|0|e7e6e5e4e3e2e1e0|<1>
      Paquet accessoires de la loco F5 à F12 : 4 octets
      |0|11a13..a8|0|a7..a0|0|101d4d3d2d1d0|0|e7e6e5e4e3e2e1e0|<1>
      Paquet accessoires de la loco F13 à F20 : 5 octets
      |0|11a13..a8|0|a7..a0|0|11011110|0|F20..F13|0|e7e6e5e4e3e2e1e0|<1>
      Paquet accessoires de la loco F21 à F28 : 5 octets
      |0|11a13..a8|0|a7..a0|0|11011111|0|F28..F21|0|e7e6e5e4e3e2e1e0|<1>
      Paquets accessoires (décodeur d’accessoires)
      Paquet de base : 3 octets
      Préambule = minimum 14 bits à ‘1’
      |0|01a5a4a3a2a1a0|0|1a8a7a6CDDF|0|e7e6e5e4e3e2e1e0|<1>
      Paquet de service (programmation) : 4 octets
      Programmation sur voie de programmation
      Préambule = minimum 20 bits à ‘1’
      |0|01111Cv9v8|0|v7v6v5v4v3v2v1v0|0|DDDDDDDD|0|e7e6e5e4e3e2e1e0|<1>
      Quid de la Programmation en ligne (POM) ????

      Merci par avance de votre patience et de votre réponse.
      Bien cordialement.

      Répondre

  • L’Arduino et le système de commande numérique DCC 25 juillet 2015 19:18, par Dominique

    Très beau travail :)
    Mais une petite question avant de me plonger dans les documents : voulez-vous connaître tous les messages

    • dans la norme NMRA
      Ou
    • dans la bibliothèque CmdrArduino ?

    Et aussi, qu’est le mode POM ?

    Bien cordialement

    Répondre

  • L’Arduino et le système de commande numérique DCC 25 juillet 2015 20:09, par Jean-Pierre Claudé

    Merci de votre réponse j’avais un peu peur de vous effrayer avec ma question. Quant à tenter de faire les choses autant être le plus proche possible des normes. En fait j’ai descendu toute la bibliothèque CmdrArduino et il y a encore des choses que l’on peut améliorer ou ajouter. La première chose c’est d’être d’accord sur la structure des paquets mais en lisant il y a parfois quelques bits qui se promènent. par exemple dans DCCPacketScheduler::opsProgramCV il obtient un paquet 1110 11b9b8 etc.. alors que j’ai trouvé dans la doc plutôt 011111b9b8 en mode donnée !! Le POM est la programmation en ligne, il faut donc donner en plus l’adresse de la loco (dans ce cas on a pas accès à tous les cv en particulier au CV1).
    Je me permets de vous retransmettre la liste que j’ai complété avec les paramètres, cela vous facilitera peut être les choses.

    Bien cordialement.

    Structure des paquets DCC
    Paquets multifonctions (locomotives)
    Préambule = minimum 14 bits à ‘1’
    Adresse courte
    Paquet reset : 3 octets
    |0|00000000|0|00000000|0|00000000|<1>
    Paquet vide : 3 octets
    |0|11111111|0|00000000|0|11111111|<1>
    Paquet vitesse/direction, 14 pas : 3 octets
    |0|0a6a5a4a3a2a1a0|0|01DXs3s2s1s0|0|e7e6e5e4e3e2e1e0|<1>
    Adresse : a6-a0 : adresse de 1 à 127 de la locomotive
    Donnée : 01 : instruction de vitesse/direction
    D = 1 : marche avant, D = 0 : marche arrière
    X : non significatif
    s3s2s1s0 : graduation de vitesse sur 4 bits

    Valeur s3 s2 s1 s0 graduation Valeur s3 s2 s1 s0 graduation
    0000 stop 1000 7
    0001 Stop urgence 1001 8
    0010 1 1010 9
    0011 2 1011 10
    0100 3 1100 11
    0101 4 1101 12
    0110 5 1110 13
    0111 6 1111 14

    Paquet vitesse/direction, 28 pas : 3 octets
    |0|0a6a5a4a3a2a1a0|0|01DCs3s2s1s0|0|e7e6e5e4e3e2e1e0|<1>
    Adresse : A6-a0 : adresse de 1 à 127 de la locomotive
    Donnée : 01 : instruction de vitesse/direction
    D = 1 : marche avant, D = 0 : marche arrière
    C : bit le moins significatif de la graduation
    s3s2s1s0C : graduation de vitesse sur 5 bits

    Valeur s3s2s1s0C graduation Valeur s3s2s1s0C graduation
    00000 stop 10000 13
    00001 stop 10001 14
    00010 Stop urgence 10010 15
    00011 Stop urgence 10011 16
    00100 1 10100 17
    00101 2 10101 18
    00110 3 10110 19
    00111 4 10111 20
    01000 5 11000 21
    01001 6 11001 22
    01010 7 11010 23
    01011 8 11011 24
    01100 9 11100 25
    01101 10 11101 26
    01110 11 11110 27
    01111 12 11111 28

    Paquet vitesse/direction, 128 pas : 4 octets
    |0|0a6a5a4a3a2a1a0|0|00111111|0|Ds6s5s4s3s2s1s0|0|e7e6e5e4e3e2e1e0|<1>
    Adresse : A6-a0 : adresse de 1 à 127 de la locomotive
    Donnée1 : 00111111 : instruction de vitesse/direction en 128 pas
    D = 1 : marche avant, D = 0 : marche arrière
    s6s5s4s3s2s1s0 : graduation de vitesse sur 7 bits (0 à 127)

    Paquet accessoires de la loco F0 à F4 : 3 octets
    |0|0a6a5a4a3a2a1a0|0|100F0F4F3F2F1|0|e7e6e5e4e3e2e1e0|<1>
    Paquet accessoires de la loco F5 à F8 : 3 octets
    |0|0a6a5a4a3a2a1a0|0|1011F8F7F6F5|0|e7e6e5e4e3e2e1e0|<1>
    Paquet accessoires de la loco F9 à F12 : 3 octets
    |0|0a6a5a4a3a2a1a0|0|1010F12F11F10F9|0|e7e6e5e4e3e2e1e0|<1>

    fonction codage Fonction codage
    F0 100X0000 F7 10110X00
    F1 1000000X F8 1011X000
    F2 100000X0 F9 1010000X
    F3 10000X00 F10 101000X0
    F4 1000X000 F11 10100X00
    F5 1011000X F12 1010X000
    F6 101100X0 X= 0 arrêt X = 1 actif

    Adresse longue
    Paquet vitesse/direction, 14 pas : 4 octets
    |0|11a13..a8|0|a7..a0|0|01DXs3s2s1s0|0|e7e6e5e4e3e2e1e0|<1>
    Paquet vitesse/direction, 28 pas : 4 octets
    |0|11a13..a8|0|a7..a0|0|01DCs3s2s1s0|0|e7e6e5e4e3e2e1e0|<1>
    Paquet vitesse/direction, 128 pas : 5 octets
    |0|11a13..a8|0|a7..a0|0|00111111|0|Ds6s5s4s3s2s1s0|0|e7e6e5e4e3e2e1e0|<1>
    Paquet accessoires de la loco F0 à F4 : 4 octets
    |0|11a13..a8|0|a7..a0|0|100d4d3d2d1d0|0|e7e6e5e4e3e2e1e0|<1>
    Paquet accessoires de la loco F5 à F12 : 4 octets
    |0|11a13..a8|0|a7..a0|0|101d4d3d2d1d0|0|e7e6e5e4e3e2e1e0|<1>
    Paquet accessoires de la loco F13 à F20 : 5 octets
    |0|11a13..a8|0|a7..a0|0|11011110|0|F20..F13|0|e7e6e5e4e3e2e1e0|<1>
    Paquet accessoires de la loco F21 à F28 : 5 octets
    |0|11a13..a8|0|a7..a0|0|11011111|0|F28..F21|0|e7e6e5e4e3e2e1e0|<1>
    Paquets accessoires (décodeur d’accessoires)
    Paquet de base : 3 octets
    Préambule = minimum 14 bits à ‘1’
    |0|01a5a4a3a2a1a0|0|1a8a7a6CDDF|0|e7e6e5e4e3e2e1e0|<1>
    Adresse sur 9 bits : a8a7a6 : adresse de poids forts complémentées à 2
    C = 1 : active la sortie, C = 0 : désactive la sortie
    DD : groupe de sortie (00 = groupe1 à 11 = groupe4)
    F = 0 port de sortie A, F = 1 port de sortie B

    Paquet de service (programmation)
    Préambule = minimum 20 bits à ‘1’
    C = 1 : mode donnée, DDDDDDDD = valeur du CV
    C = 0 : mode bit, DDDDDDDD = 1111FBBB, F = valeur du bit, BBB = position du bit

    Programmation sur voie de programmation : 4 octets

    |0|01111Cv9v8|0|v7v6v5v4v3v2v1v0|0|DDDDDDDD|0|e7e6e5e4e3e2e1e0|<1>
    Programmation en ligne adresse courte (POM) : 5 octets
    |0|0a6a5a4a3a2a1a0|0|01111Cv9v8|0|v7v6v5v4v3v2v1v0|0|DDDDDDDD|0|e7e6e5e4e3e2e1e0|<1>
    Programmation en ligne adresse longue (POM) : 6 octets
    |0|11a13..a8|0|a7..a0|0|01111Cv9v8|0|v7v6v5v4v3v2v1v0|0|DDDDDDDD|0|e7e6e5e4e3e2e1e0|<1>

    Répondre

  • Bonjour,
    Je suis sur un projet de train miniature, et je dois envoyer des trames pour commander une plaque tournante, mais je ne sais pas qu’elle type de protocole utilisé ?
    cordialement

    Répondre

  • L’Arduino et le système de commande numérique DCC 7 avril 2016 10:36, par Dominique

    Bonjour,

    Difficile de vous répondre avec si peu d’information !

    Je ne connais pas les plaques tournantes, mais c’est un accessoire du réseau qui doit pouvoir se commander.

    La première chose à faire est de regarder la notice qui décrit forcément les interfaces avec le système de commande. Est-elle prévue pour des commandes analogiques (moteurs et capteurs) ou numérique (DCC ?).

    Avez-vous un schéma de branchement ?

    Et avez-vous l’intention d’y adjoindre un Arduino ?

    Répondre

  • Pour faire avancer et controller des petits véhicules sur une piste magnétique je souhaiterais
    utiliser les deux techniques suivantes déjà utilisées séparément mais pas encore liées entre elles :
    1 Alimentation de boucles magnetiques successives sur des voies en circuit imprimé
    par driver de moteur pas à pas trois phases
    2 Puis pilotage de ce driver par un décodeur DCC
    en fait il faudrait que je puisse utiliser la sortie Vitesse 8 bit d’un décoder diy pour piloter le driver du stepper

    l’objectif final etant que les ordres dcc envoyés au décodeur produisent le meme effet sur les aimants (avance acceleration frein arret ) qu’un décodeur dcc pour moteur dc produit sur une locomotive
    l’arduino pourrait il faire office de décodeur dcc ? ou ( sans doute plus simple° l’arduino POURRAIT IL permettre la traduction de la sortie moteur d’un décodeur dcc classique en instructions pour le stepper
    ex le changement de direction du sens de l’alim dc produit le changement de sens de la loco alors que pour un changement de sens des aimants c’est l’ordre des impulsions qui produit l’inversion
    de même en dc c’est le pwm qui controle la vitesse pour le stepper c’est le rythme d’envoi des pulses ....
    Comment verriez vous l’usage de l’arduino pour la réalisation de ce projet merci d’avance de votre aide patrick

    merci de vos indications et conseils

    Répondre

    • Bonjour et merci pour cette question qui va intéresser un grand nombre de modélistes : piloter des voitures miniatures comme des locomotives avec leur propre adresse DCC et des ordres de vitesse et direction.

      Pour vous rassurer, je réponds OUI c’est possible et je serais heureux de vous assister dans cette réalisation et en faire profiter la communauté des lecteurs de Locoduino.

      Tout d’abord il vous faut un peu de matériel : un Arduino Nano devrait suffire, et le montage de l’article Un moniteur de signaux DCC vous permettra de recevoir les signaux DCC.

      Ensuite il faudra réaliser le logiciel, à partir de la bibliothèque proposée aussi dans ce même article Un moniteur de signaux DCC mais en récupérant uniquement les commandes de vitesses dont la syntaxe est décrite plus haut dans le présent article (1er octet : adresse, 2ème octet = vitesse+direction, pour simplifier évidemment).
      Enfin il vous faudra convertir cette information de vitesse+direction pour votre propre système de commande de boucles magnétiques.

      Dites moi si ce DIY est à votre portée et éventuellement ce qu’il faudrait pour vous aider.

      Vous pouvez m’adresse un MP.

      Mais ce serait plus intéressant de développer ce projet sur le Forum Locoduino

      Bon courage

      Répondre

      • merci Dominique pour votre réponse rapide et encourageante
        l’objectif à terme est de pouvoir utiliser les logiciels prévus pour le pilotage de DCC (type i train , ou rocrail , pour contrôler les aimants dont le mouvement devrait être conforme aux commandes dcc envoyées )
        jE vais donc partir sur la première étape que vous m’indiquez mais mon probléme est aussi de savoir sous quelle forme les infos provenant de l’arduino sont restituées et surtout comment convertir cette information de vitesse+direction pour faire produire les effets désirés sur les aimants par le pilote du moteur pas à pas...

        Répondre

        • Reportez-vous à mon article Un moniteur de signaux DCC où je décris comment afficher sur un écran LCD les commandes envoyées aux locos :

           if (gPackets[i].data[0] != 255)
                        {
                          lcd.print(gPackets[i].count, DEC);   // count
                          lcd.print("@");                      // @
                          lcd.print(gPackets[i].data[0], DEC); // DCC address
                          switch (gPackets[i].data[1]) 
                          {
                            case 0x3F:  // Advanced Operation Instruction : speed & direction
                            if (gPackets[i].data[2] > 127)
                            {
                              lcd.print(">");
                              lcd.print(gPackets[i].data[2] - 128); //  > speed
                            }else{
                              lcd.print("<");
                              lcd.print(gPackets[i].data[2]);       //  < speed
                            }

          Vous voyez que gPacket[i].data[1] contient l’adresse DCC et gPacket[i].data[2] contient la vitesse+direction.

          Vous récupérez ces données dans vos propres variables et vous faites le traitement nécessaire de conversion vers vos propres commandes !!!

          Est-ce que ça vous rassure ?

          Cordialement
          Dominique

          Répondre

          • Merci Dominique
            J’ai bien vu les modalités de récupération des données dcc concernant la vitesse et la direction qui est la première étape du processus
            mais je sais pas comment utiliser ces données pour les traduire en terme de commande de mon alim moteur pas à pas (pour les boucles) :

            Lors d’une commande dcc d’augmentation de la vitesse tel qu’identifiée sur votre lecteur, il y a du soft et du hard dans le décodeur dcc qui traite l’info pour que sur les deux fils moteurs sortant du décodeur dcc soit envoyé un courant avec la modification appropriée de la pmw ( le moteur dc tourne plus vite)

            or pour ma route c’est l’augmentation de la fréquence des pulses pour faire changer plus rapidement le sens du champ magnétique dans chaque boucle (augmentation du rythme d’inversion du sens du courant) qui accelere le mouvement des aimants ce qui est un processus très différent … (j’ai trois fils à alimenter successivement en + - et off : plus la répétition de ce cycle est rapide plus les aimants avancent rapidement .)
            premier pulse : 1° fil alimenté en plus 2° en moins 3° off
            demi pulse 1° fil alimenté en plus , 2° en off 3° en moins
            pulse suivant 1° fil en off 2° en plus 3° en moins
            et répétition du cycle ….... Comment traiter l’info dcc ( avec quel soft ) pour obtenir une augmentation de la fréquence des pulses sur mon électronique de moteur pas à pas (alim successive des trois séries de boucles) ?
            idéalement j’aimerais pouvoir faire du microstepping pour obtenir un avancement le plus régulier possible des aimants à basse vitesse (mais c’est une autre histoire..)

            Répondre

            • La réponse est très simple si ces hypothèses sont vraies :

              • vous savez programmer l’Arduino, un peu (pas besoin d’être expert, mais quand même ...)
              • vous savez réaliser le matériel et le logiciel Arduino pour la commande de votre matériel pour les boucles magnétiques. Imaginons que vous ayez besoin d’une variable F pour la fréquence.
              • vous savez récupérer l’octets de vitesse+direction V de l’adresse DCC que vous avez choisie pour votre système.

              Si V est négatif c’est la marche avant, V positif la marche arrier, V =0 ou +-1 l’arrêt.
              La valeur absolue de V qui vous intéresse va de 2 à 126. Il faut donc trouver une relation entre F et V. Ça pourrait être tout simplement proportionnel F= k*V ou k est un coefficient à déterminer par expérience, mais je ne connais pas votre système.

              Est-ce ça va jusque là ?

              Sinon il faudra décrire votre système (ce qui doit être utile pour les autres modélistes) et votre niveau de réalisateur en DIY pour mieux déterminer ce dont vous avez besoin.

              Répondre

            • À partir du moment où vous saurez faire F=k*V, le microstepping sera un simple raffinement logiciel, tout à fait possible !

              Répondre

  • Vos réponses sont très éclairantes et je vois mieux les étapes à franchir
    Malheureusement Je n’ai jamais fait de programmation , et j ’ai bien compris qu’’il s’agissait d’une étape incontournable pour utiliser les possibilités de l’arduino mais c’est un long chemin …
    je pensais que l’alimentation des boucles pourrait être réalisée par arduino
    en effet il s’agit d’envoyer dans chaque fil une succession de pulses permettant de modifier le champ magnétique pour controler les mouvements des aimants sur la piste comme indiqué :
    premier pulse : 1° fil alimenté en plus 2° en moins 3° off 
    demi pulse 1° fil alimenté en plus , 2° en off 3° en moins 
    pulse suivant 1° fil en off 2° en plus 3° en moins 
    et répétition du cycle 

    c’est un générateur d’impulsions electriques qui alimente les boucles de manière sequentielle s’ agissant d’une base évolutive il est souhaitable dans un premier temps d’analyser les effets de la variation des différents parametres sur lesquels on peut jouer pour optimiser le résultat

    • V (entre 8 et 25 v en fonction de la longeur des voies, du nombre et de la nature des aimants )
    • intensité ( entre 400 ma et 2a , id )
    • forme du courant (sin )
    • PWM
    • nombre de pas
      si vous voyez d’autres variables intéressantes n’hésitez pas à les évoquer …...
      les objectifs et priorités entre les quelles un compromis devra être trouvé sont les suivants
    • Obtenir un avancement le plus régulier possible des aimants notamment aux basses vitesses
      ( d’où l ’intérêt du micro stepping )
    • Obtenir une force d’avancement suffisante pour tracter carrosseries et éventuel hard ware (RFID ) et favoriser les passages d’aiguillages qui vont comporter davantage de superpositions de boucles .
    • Minimiser la température des boucles , voire des aimants

    Il y a aussi certains parametres à traiter (retours de courants ,protections etc..)

    Aprés avoir déterminé les parametres les plus adaptés il ne resterait donc qu’à faire changer l’ordre d’envoi des +-0 sur les fils pour la direction et la fréquence des pulses pour la vitesse ;
    dans un décodeur dcc classique les cv 2 à 7 ; 23 à 25 et 67 0 94 ont une influence sur la vitesse mais avec la procédure que vous avez évoquée ces réglages ne seraient donc pas pris en compte et seule l’indication envoyée par la centrale déterminerait avec le multiplicateur k du F=kV la vitesse des aimants ...
    Pour le DIY j’ai réalisé pas mal de montages electroniques avec un plan et une liste de composants je peux réaliser (c’est au niveau programmation que j’ai tout à apprendre )

    A votre disposition pour plus d’informations (comment procéde t on pour transmission de coordonnées ? ) ps Voici une petite video montrant ce qu’il est possible de réaliser sur le principe (en application de microrobotique ) non pas sur unepiste bi directionnelle mais sur une grille comportant des boucles oblongues qui se croisent un gros soft pour le contrôle et un materiau diamagnétique entre les boucles et les aimants ....

    Voir en ligne : https://www.youtube.com/watch++cs_INTERRO++v=uL6...

    Répondre

  • L’Arduino et le système de commande numérique DCC 20 septembre 2017 14:55, par Julien

    Bonjour,
    J’ai parcouru votre site qui est super intéressant par contre ne n’ai pas trouvé une solution pour du DCC en 3 rails alternatif est ce possible avec un arduino ? Merci

    Répondre

    • L’Arduino et le système de commande numérique DCC 21 septembre 2017 00:24, par Dominique

      Bonjour,

      Il n’y a, pour le moment, pas de solution DCC pour du 3 voies (Marklin ?) que je ne connais pas du tout.

      Nous espérons que quelqu’un viendra combler cette lacune en expliquant ce que c’est, à partir de quoi on pourra dire si l’Arduino s’y trouvera à l’aise.

      A priori de pense que l’Arduino est bien partout !

      Répondre

      • L’Arduino et le système de commande numérique DCC 21 septembre 2017 05:49, par Julien

        Merci pour votre réponse, c’est du Marklin pour le moment j’ai une solution avec une interface CAN sur un arduino UNO qui fonctionne assez bien mais je voulais abstraire le boîtier de commande Marklin afin de me connecter directement sur les rails ... si je trouve une solution je reviens sur ce commentaire

        Répondre

Réagissez à « L’Arduino et le système de commande numérique DCC »

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 »

Les derniers articles

Les articles les plus lus