DCC++ BaseStation

[Dominique]

Complément sur la mesure de courant de DCC++

Devant les difficultés de BobyAndCo, je pense utile de partager ce petit bricolage qui permet d’y voir plus clair dans la mesure de courant de DCC++.

Ce « petit bricolage » est fait uniquement dans ma version DCCpp_VV que je joins au présent post, et uniquement dans la fonction ReadCV_Main (PacketRegister.cpp) que j’ai ajoutée pour lire un CV sur la voie principale.

Attention : c'est une version de tests, je vous conseille de la renommer autrement !

Cette lecture est faite dans le Setup en envoyant les 3 commandes :
<1><r 1 123 123><0>
On y voit la mise sous tension du réseau, puis la lecture du CV, puis la mise hors tension du réseau

Sur le moniteur de l’IDE, on doit lire :

Code: [Sélectionner]

DCCpp-VV V0.1.3 (c) Dominique Bultez

<DCC++ BASE STATION FOR ARDUINO NANO / LMD18200 MOTOR SHIELD + MAX471: V-1.2.1-DB / Aug 30 2016 21:56:33>
<N0: SERIAL><p1><rm123|123|1 18>5 0 36 0 0 31 0 0 0 6 33 1
<p0>
adresse DCC : 18
Si ça se passe mal, on peut avoir :

Code: [Sélectionner]

<N0: SERIAL><p1><rm123|123|1 -1>0 0 0 0 0 0 0 0 0 0 15 0
<p0>
adresse DCC : -1 >>> erreur adresse DCC !

Pour ce faire, j’ai ajouté un enregistrement des valeurs de mesure de courant dans toutes les phases de ReadCV_Main (PacketRegister.cpp) et un affichage à la fin de la fonction. Comme cela, ça ne perturbe pas trop les timings.

Je rappelle que la fonction ReadCV envoie 8 fois une commande de lecture pour lire les 8 bits du CV, puis une 9ème commande pour obtenir un bit de vérification.
Aussitôt après chaque commande, le sketch se met en lecture du courant dans une boucle de 500 lectures (ACK_SAMPLE_COUNT qui doit correspondre grosso modo à au moins 6 millisecondes, je n'ai pas mesuré), au cours de laquelle il recherche une valeur qui dépasse le seuil égal au courant de base + 30 (ACK_SAMPLE_THRESHOLD). Si ce seuil est dépassé c’est un bit 1 sinon 0.

Evidemment, il faut UNE SEULE LOCO sur la voie principale et il ne faut pas que la loco roule pour faire cette mesure, moteur arrêté, car c'est en activant le moteur 9 fois pendant 6 ms que le décodeur va "passer son message".

Ces valeurs sont déduites de la norme NMRA http://www.nmra.org/sites/default/files/s-9.2.3_2012_07.pdf

Où il est écrit : Basic acknowledgment is defined by the Digital Decoder providing an increased load (positive-delta) on the programming track of at least 60 mA for 6 ms +/-1 ms. It is permissible to provide this increased load by applying power to the motor or other similar device controlled by the Digital Decoder.

La valeur du seuil (30 dans le soft) peut ou non correspondre à ces 60mA de delta consommation, c’est un truc à étalonner si ça ne marche pas du premier coup. De plus il est évident que c'est différent en N et en HO !?!

Voici l’explication des valeurs affichées à droite du « > », ici 5 0 36 0 0 31 0 0 0 6 33 1

5 =  courant de base mesuré avant lecture du premier bit (ou du dernier, c'est quasi pareil)
0 36 0 0 31 0 0 0 = courant lu - courant de base qui est ici supérieur au seuil de 30, pour 2 bits sur 8, ce qui correspond à 01001000, soit 12H donc 18 décimal.
6 = courant de base pour la verification
33 = courant lu pendant la vérification (>30)
1 = OK c’est bon (sinon 0)

Dans la fonction ReadCV_Main, on remarque qu’on a commenté cur[i+1]=d; et décommenté cur[i+1]=c;

Si on fait l’inverse, décommenter cur[i+1]=d; et commenter cur[i+1]=c; on obtient les bits de la réponse directement : 5 0 1 0 0 1 0 0 0 6 33 1

Conclusion : c’est raduc !!!

J'utilise le LMD18200 en série avec le Max471 qui fournit la mesure.
Le seuil étant de 30, on a de 31 à 36, mais c’est suffisant et reproductible

Quoi faire si ça ne marche pas :

Il y a au moins 2 pistes possibles :
1) En soft : réduire la valeur ACK_SAMPLE_THRESHOLD à 25, par exemple, en se basant sur les valeurs lues (si une valeur lue est négative, cela veut dire que la mesure est plus petite que le seuil)

On peut aussi répéter l'opération quelques fois en cas d'échec. Mais s'il y a trop d'échecs, c'est la solution suivante qu'il faut envisager.

2) en hard : augmenter la sensibilité de la mesure de courant. La solution, là est propre à chaque type d’interface choisie
Pour l’Arduino Shield et le Polulu Shield, ou le Max471 on ne peut que mettre un ampli extérieur.
Pour le LMD18200, il y a la résistance de conversion 377 μA/A en tension qui peut varier.

En tout cas c'est important de savoir ce qui se passe dans les entrailles de notre DCC++ façon Locoduino et j'espère que cela vous aidera, si nécessaire.

[Tanguy]

Il me semble que le seuil de 60 mA est utilisé pour un  Basic acknowledgment uniquement.
Pour la lecture des CV c'est la section "Advanced Acknowledgment" qui me semble plus correspondre.

http://www.nmra.org/sites/default/files/s-9.3.2_2012_12_10.pdf :

2.2. RailCom – Transmitter in the Decoder
To transmit a “0”, the decoder must supply a current 1 of 30+4/-6 mA [...].
 To transmit a “1”, the current 1 must be at the most +/- 0.1mA.

2.3. The RailCom Detector
A detector must interpret a current of greater than 10mA during the middle 50% of the bit time as “0”
, a current smaller than 6 mA during the middle 50% of the bit time as “1”.

[Dominique]

Merci Tanguy,

J'avoue que je ne connais pas bien cette partie de la norme qui tient compte aussi de Railcom (avec des schémas de détecteurs).

La norme appliquée par Gregg est peut-être mentionnée quelque part dans le forum TrainBoard, mais il faut se farcir les 46 pages ...

En tout cas, la commande DCC envoyée est du type 0111 10VV 0 VVVVVVVV 0 1110 1BBB où V est le CV et B le bit testé.
Le format d'un Configuration Variable Access Instruction - Long Form est 1110 CCVV 0 VVVVVVVV 0 BBBBBB, où CC = 01 pour verify bit. Cela ne correspond pas !

Je ne trouve pas l'instruction utilisée par DCC++. Je vais continuer à chercher.
En tout cas j'ai trouvé une machine qui ne répond pas mais qui marche quand même.
Il est certain qu'il y a des divergences entre les décodeurs.

[Dominique]

Bonjour à tous,

Juste pour dire à la place de bobyAndCo que sa BaseStation dcc++ fonctionne maintenant correctement. Il a suffit de réinstaller tout tranquillement et maintenant les commandes fonctionnent.

Du coup il est en train (c'est le cas de le dire  ) de vous préparer un dossier très intéressant, dont je lui laisse le soin de vous faire la surprise 

[DDEFF]

Que de bonnes nouvelles!

Dominique : cela veut dire que ton système marche (ce dont je n'avais jamais douté, évidemment) et qu'il a été testé avec d'autres configurations.
C'est quand même une rétro-signalisation sans RailCom...
Bravo !

Christophe : on a un rédacteur supplémentaire. Bienvenue au Club ! 

[Dominique]

Que de bonnes nouvelles!

Dominique : cela veut dire que ton système marche (ce dont je n'avais jamais douté, évidemment) et qu'il a été testé avec d'autres configurations.
C'est quand même une rétro-signalisation sans RailCom...

Merci Denis,

Oui ça marche plutôt bien : j'ai un petit cercle dans mon bureau avec une centrale dcc++ en développement pour mon va et vient.

A tous les coups, quand je pose une loco inconnue sur la voie et que j'appuie sur le bouton de reset, elle démarre toute seule dans la seconde qui suit.

Le reste est maintenant une affaire d'automate que j'essaye d'intégrer avec le reste du logiciel dcc++ (et là, le c++ c'est puissant mais il faut l'apprendre un peu plus ...)

Cette solution de reconnaissance automatique peut être très utile aussi pour gérer des zones de ralentissement.
Mais apparemment Railcom a un avantage qui est qu'on peut récupérer des infos pendant que le train roule, alors qu'avec ma solution, le train doit être à l'arrêt.

Cela dit, du moment que la détection peut se faire à un endroit et un moment donné dans la circulation d'un train, la poursuite du train grâce au gestionnaire doit suffire à atteindre l'objectif qui n'est que de faire respecter la signalisation à la conduite des trains.

Peut-être arriverons-nous à intégrer la détection Railcom un de ces jours...

Suspense 

[bobyAndCo]

Bonjour à tous,

Il n’aura certainement pas échappé à ceux qui se sont intéressés à DCC++ que ce dernier permettait de communiquer par Ethernet en plus de la traditionnelle liaison série. L’un des nombreux points forts de DCC++ est qu’il fonctionne avec l’envoi de simples messages textuels structurés et ça fonctionne !

Dans ce post, je vais décrire comment paramétrer les réglages Ethernet et vous trouverez également en fin en téléchargement un petit "controller" pour piloter DCC++ avec un navigateur web ou pourquoi pas votre tablette ou votre smartphone en wifi 




DCC++ Base Station utilise les mêmes messages en communication série ou Ethernet. Ces messages qui sont en fait des commandes, sont envoyés au programme et doivent être placés entre ‘<’ et ‘>’. Ce que vous mettrez avant ‘<’ ou après ‘>’ sera ignoré par DCC++. Pour plus de détails sur les commandes : https://github.com/DccPlusPlus/BaseStation/wiki/Commands-for-DCCpp-BaseStation

Cette précision est importante car en communication Ethernet avec le protocole HTTP on envoie plus que cela et ce sont les ‘<’ et ‘>’  qui vont permettre d’identifier la commande à l’intérieur de tout le texte des requêtes.

Pour utiliser Ethernet vous devrez bien sûr disposer d’un Arduino MEGA (les autres ne sont pas supportés) d’un shield Ethernet. Pour le reste vous n’avez pratiquement besoin que de votre ordinateur et d’un réseau Ethernet « domestique » qui est fourni par votre box.

Dans DCC++, c’est dans le fichier Config.h que l’on sélectionne la communication par Ethernet. Ligne 34 : #define COMM_INTERFACE   à 1,2 ou 3 selon votre shield.

Code: [Sélectionner]

// DEFINE COMMUNICATIONS INTERFACE
//
//  0 = Built-in Serial Port
//  1 = Arduino.cc Ethernet/SD-Card Shield
//  2 = Arduino.org Ethernet/SD-Card Shield
//  3 = Seeed Studio Ethernet/SD-Card Shield W5200

#define COMM_INTERFACE   1

Il faudra également décommenter la ligne 41 : #define IP_ADDRESS { 192, 168, 1, 200 }

Code: [Sélectionner]

// DEFINE STATIC IP ADDRESS *OR* COMMENT OUT TO USE DHCP
//

#define IP_ADDRESS { 192, 168, 1, 200 }
Mais auparavant on va tout de même s’assurer que cette adresse IP 192.168.1.200 peut « s’insérer » dans votre réseau domestique. Sur Mac, ces informations sont disponibles dans « Préférences Système » -> Réseau.

Sur mon ordinateur, l’adresse IP est 192.168.1.31 ce qui veut dire que toutes les adresse IP de mon réseau domestique vont de 192.168.1.1 à 192.168.1.254, et que mon Arduino + Ethernet devrait pouvoir trouver sa place à l’intérieur avec l'adresse IP 192.168.1.200.

Pour ceux qui maîtrisent un peu plus ces questions, faites un PING en Mac avec « Utilitaire de réseau »



Sur PC, c'est  -> démarrer / exécuter / cmd/k ipconfig /all (je crois).

Dans le fichier confi.h, laissez le port HTTP tel qu’il est configuré à 2560. Voilà donc à quoi devrait ressembler notre code dans Config.h

Code: [Sélectionner]

Config.h
COPYRIGHT (c) 2013-2016 Gregg E. Berman

Part of DCC++ BASE STATION for the Arduino

**********************************************************************/

/////////////////////////////////////////////////////////////////////////////////////
//
// DEFINE MOTOR_SHIELD_TYPE ACCORDING TO THE FOLLOWING TABLE:
//
//  0 = ARDUINO MOTOR SHIELD          (MAX 18V/2A PER CHANNEL)
//  1 = POLOLU MC33926 MOTOR SHIELD   (MAX 28V/3A PER CHANNEL)

#define MOTOR_SHIELD_TYPE   0

/////////////////////////////////////////////////////////////////////////////////////
//
// DEFINE NUMBER OF MAIN TRACK REGISTER

#define MAX_MAIN_REGISTERS 12

/////////////////////////////////////////////////////////////////////////////////////
//
// DEFINE COMMUNICATIONS INTERFACE
//
//  0 = Built-in Serial Port
//  1 = Arduino.cc Ethernet/SD-Card Shield
//  2 = Arduino.org Ethernet/SD-Card Shield
//  3 = Seeed Studio Ethernet/SD-Card Shield W5200

#define COMM_INTERFACE   1

/////////////////////////////////////////////////////////////////////////////////////
//
// DEFINE STATIC IP ADDRESS *OR* COMMENT OUT TO USE DHCP
//

#define IP_ADDRESS { 192, 168, 1, 200 }

/////////////////////////////////////////////////////////////////////////////////////
//
// DEFINE PORT TO USE FOR ETHERNET COMMUNICATIONS INTERFACE
//

#define ETHERNET_PORT 2560

/////////////////////////////////////////////////////////////////////////////////////
//
// DEFINE MAC ADDRESS ARRAY FOR ETHERNET COMMUNICATIONS INTERFACE
//

#define MAC_ADDRESS {  0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xEF }

/////////////////////////////////////////////////////////////////////////////////////

ATTENTION : Il manque quelques lignes de code dans DCC++ Base Station qui utilise la bibliothèque Ethernet de l’Arduino. Dans le fichier SerialCommand.cpp il faudra ajouter à la ligne 66 :

Code: [Sélectionner]

INTERFACE.println("HTTP/1.1 200 OK");
      INTERFACE.println("Content-Type: text/html");
      INTERFACE.println("Access-Control-Allow-Origin: *");
      INTERFACE.println("Connection: close");
      INTERFACE.println();

et entre les lignes 73 et 74 (qui seront devenues 80 et 81)

Code: [Sélectionner]

client.stop();

Code complet :

Code: [Sélectionner]

#elif COMM_TYPE == 1

    EthernetClient client=INTERFACE.available();

    if(client){

      INTERFACE.println("HTTP/1.1 200 OK");
      INTERFACE.println("Content-Type: text/html");
      INTERFACE.println("Access-Control-Allow-Origin: *");
      INTERFACE.println("Connection: close");
      INTERFACE.println();
     
      while(client.connected() && client.available()){        // while there is data on the network
      c=client.read();
      if(c=='<')                    // start of new command
        sprintf(commandString,"");
      else if(c=='>')               // end of new command
        parse(commandString);                   
      else if(strlen(commandString)<MAX_COMMAND_LENGTH)    // if comandString still has space, append character just read from network
        sprintf(commandString,"%s%c",commandString,c);     // otherwise, character is ignored (but continue to look for '<' or '>')
      } // while
     
      client.stop();
     
    }

  #endif

Le code étant le même pour COMM_TYPE == 0 (communication série) assurez vous que vous l’avez bien recopié dans #elif COMM_TYPE == 1

Voilà pour la programmation de la carte. Si vous uploadez, vous devez avoir un message de ce type dans le moniteur série de l’IDE avec l’adresse IP en fin :
<iDCC++ BASE STATION FOR ARDUINO MEGA / ARDUINO MOTOR SHIELD: V-1.2.1+ / Aug 22 2016 15:52:06><N1: 192.168.1.200>

Une précision toute bête mais assurez-vous que votre shield Ethernet est bien relié à votre box par un câble RJ 45 ! Vous pourrez faire un nouveau ping toujours sur cette adresse 192.168.1.200 qui doit maintenant s’afficher.

Voilà pour la carte. Votre Arduino c’est transformé en petit serveur web qui va répondre aux requêtes HTTP sur son adresse IP.

La partie "client", c'est le Mini Controller DCC++ que vous allez trouver en fin de ce post. Mais pour que cette application fonctionne, il nous faut disposer d'un serveur web qui soit interne à notre réseau domestique et qui va héberger nos pages HTML, pages de programmation, feuilles de style et images.

Vous pouvez tout a fait utiliser votre box par exemple si elle fait serveur web ou si vous avez déjà un serveur web interne à votre domicile. Mais nous allons ici choisir d’installer ce serveur web sur notre propre ordinateur et pour cela, nous allons télécharger puis installer un logiciel gratuit mais très puissant qui est à la fois un serveur web, un serveur SQL et capable d’exécuter des scripts PHP (nous en aurons besoin assez rapidement quand notre application prendra de l’importance).

Ce logiciel s’appelle MAMP dans sa version Mac, WAMP dans sa version PC et XAMPP sous Linux. Choisissez la version gratuite largement suffisante. Voici les liens de téléchargement :

Mac : https://www.mamp.info/en/
PC : http://www.wampserver.com/
Linux : https://www.apachefriends.org/fr/download.html

Normalement, l’installation ne doit vous poser aucun problème car elle est vraiment très simple. Au besoin, consultez le tuto sur  OpenClassrooms

Sur votre ordinateur, vous devez déterminer un répertoire bien précis qui va être l’espace disque réservé pour votre serveur web. Choisissez par exemple de le « ranger » dans « Mes documents/mon_petit_train/dossier_web ».

Lancez maintenant l’application MAMP (ou WAMP, ou XAMPP) qui ouvre normalement automatiquement le serveur web et le serveur mySql, (cases en haut à droite de couleur verte).



Clickez sur le bouton « Préférences » à gauche au milieu

Sur la première fenêtre, sélectionnez tout de suite le répertoire que vous avez créé précédemment et qui va devenir la racine de votre serveur web. Pour cela cliquez sur l’icone à droite de « Document Root » et naviguez jusqu’à trouver votre dossier :




Dossier racine qui pour l’instant ne contient rien. Concernant les autres onglets en haut de la fenêtre MAMP, ne changez rien.



L’onglet Ports vous renseigne sur les paramétrages de ports que MAMP a programmés automatiquement. Ne changez rien. Par contre, notez que MAMP a attribué au Port Apache (c’est à dire au serveur web) le port 8888. Nous en aurons besoin par la suite.

Cliquez sur "annuler" pour sortir et vous vous retrouvez sur la fenêtre principale de MAMP que vous allez maintenant laisser travailler bien tranquillement en tâche de fond. Ne quittez pas MAMP car vous désactiveriez alors le serveur web.

Téléchargez le fichier joint : maPageTest.html.zip que vous allez dézipper et placer dans votre répertoire web, normalement « Mes documents/mon_petit_train/dossier_web ».

Dans votre navigateur, entrez l’url : http://localhost:8888/maPageTest.html et vous devriez voir apparaître dans la page : « Hello Locoduino ! »

Si oui, bravo, vous avez fini les paramétrages, sinon, retournez en arrière pour trouver où vous vous êtes probablement trompé.

Ca y est vous allez pouvoir maintenant piloter votre locomotive sur votre circuit. Téléchargez le fichier joint controller_mini_dccpp.zip et placez le contenu du dossier dans votre répertoire « Mes documents/mon_petit_train/dossier_web » puis clickez sur le lien http://localhost:8888/controller_mini_dccpp/controller.html ou tout simplement http://localhost:8888/

Attention : Si vous avez donné à votre Arduino MEGA une autre adresse IP que 192.168.1.200:2560 vous devrez modifier la ligne 14 du fichier « controller.js » qui se trouve dans le dossier « scripts » avec un éditeur de texte et entrer votre propre adresse IP.

Voilà un controller assez complet que vous allez personnaliser. En cliquant sur la petite flèche à droite de la fenêtre « paramétrages », vous allez entrer l’adresse de votre locomotive et valider. Profitez pour entrer son nom ainsi que les noms des fonctions pour votre loco. L’image de la loco est dans le dossier « image », vous pouvez placer votre propre image et entrer l’url « img/ma_belle_loco.jpg ». Vous pouvez même si vous le souhaitez trouver une image sur internet et entrer son url entière : http://www.leffondre.fr/_media/img/large/dsc-3385-rec.jpg.

Tous les CV’s peuvent être modifiés dans autres réglages. Attention cependant à ne pas entrer n’importe quoi. Au besoin, le CV 8 auquel on affecte la valeur 8 permet de retrouver les réglages usine. N’oubliez pas modifier ensuite l’adresse sur votre controller puisque la valeur usine est 3 par défaut.

Avec ce Mini Controller, vous allez pouvoir tester DCC++ Base Station avec une locomotive. Par la suite, je développerai comment réaliser un controller pour tout un parc de locomotive en HTML 5 en utilisant le framework AngularJS. Vous verrez ainsi comment vous pourrez "jouer" à plusieurs en WIFI avec des tablettes ou des smartphones.

N’hésitez pas à me faire part de vos remarques et questions ou si vous avez besoin d'aide.

J'espère qu'avec DCC++ et votre controller web, vous connaitrez des expériences intéressantes.

Christophe.

[Dominique]

Bravo 

C'est super nickel et ça marche (j'ai monté un sandwich avec un Mega, une carte ethernet et une carte moteurs, toutes les 2 d'origine Arduino) et ça marche.

Voilà un nouveau pan entier de possibilités qui nous sont offertes grâce à DCC++

Dominique

[DDEFF]

C'est vrai que ça ouvre des horizons ! 

Mais (je sais que je suis casse-pied) je l'aurais mis à la suite de ton post qui parlait déjà de l'Ethernet.
Parce que, là, il y en a maintenant à deux endroit ...

Mais ça ne retire rien à l'intérêt de ton post.

[bobyAndCo]

Oui mais ici, ça permet de tester DCC++ facilement, le controller est tout prêt !

Dans le fil sur Ethernet, je développerai la réalisation pas à pas d'un controller plus complet  dont on peut voir ici la version démo

[bobyAndCo]

Pour le câblage entre l'ARDUINO (UNO ou MEGA) avec Arduino Motor Shield ou Pololu MC33926 voir :

https://github.com/DccPlusPlus/Documentation/blob/master/Motor%20Shield%20Pin%20Mappings.pdf

Ne pas oublier de couper 4, 10 et 12 sous la carte Pololu MC33926 pour éviter tout conflit (avec Ethernet en particulier) et Brake Disable et V-IN Connect sur Arduino Motor Shield. C'est bien illustré dans le document ci-dessus.

Pour le câblage entre l'ARDUINO (UNO ou MEGA) avec LMD18200 + MAX471, voir image jointe. Attention, si vous souhaitez que la voie Main et la voie Prog soient toutes les deux câblées, il vous faudra 2 X LMD18200 et 2 X MAX471.

[ponponmvo]

Il y a plus d'un an, je me suis lancé dans la réalisation d'une centrale DCC à base d'Arduino UNO. La seule solution pratique à l'époque était d'utiliser la librairie CmdrArduino qui m'a fait beaucoup transpirer et qui n'était pas très pratique à mettre en œuvre.
Depuis, le DCC++ est arrivé et les choses se sont brusquement éclaircies grâce à toutes les contributions et astuces développées sur LOCODUINO.

Le réseau dont je dispose n'est encore qu'un réseau d'essai (pour la suite, on verra…) sur lequel roulent 4 locos ROCO que j'ai converties au DCC via des décodeurs Standard + de Lentz (réf. 10231 V1 et V2). Mes autres machines attendent patiemment leur conversion.

Ma solution fait appel au système DCC++ associé à un contrôleur basé sur une télécommande à infrarouge telle que celles utilisées pour les TV, chaines HiFi ou autres décodeurs. Elle convient e.a. pour de petits réseaux avec commande manuelle des appareils de voie et accessoires.

Les ordres émis par le contrôleur sous forme de messages standardisés DCC++ (ex. < t1 3 50 1>") sont transmis via l'interface série à la centrale qui se charge de les interpréter, de les mettre en forme et de les amplifier (module LMD18200) en direction de la voie.

La solution développée est semblable à celle décrite dans l’article de bobyAndCo (voir http://www.locoduino.org/spip.php?article185) sauf que le contrôleur est à base d’une télécommande à infrarouge.

Pour moi, l’utilisation de la télécommande offre deux avantages principaux :
-   La liaison est  sans fil;
-   La construction mécanique du contrôleur est réduite à sa plus simple expression : il n'y a pas de clavier, d’inverseurs mécaniques ou autres boutons rotatifs à prévoir.

Ce que fait ce contrôleur :

•   Inscription de CV sur la voie principale (donc pas sur voie de programmation);
•   Commande de vitesse (128 crans) et sens de marche des locos ;
•   Configurée pour 4 locos (mais extensible car cela dépend du nombre de boutons disponibles sur la TLC); attention, dans la version actuelle, les numéros de décodeurs associés à chaque loco sont codés 'en dur' dans le programme.
•   Conduite simultanée de plusieurs locos; chaque loco est appelée par un seul bouton de la TLC qui lui est dédié;
•   Coupure/activation du signal DCC sur la voie par la TLC;
•   Activation/désactivation d'une fonction via un bouton dédié (F0 = feux d'éclairage loco ON/OFF) ; une seule fonction est implémentée, mais on peut étendre car cela dépend du nombre de boutons disponibles sur la TLC);
•   Affichage des paramètres de la loco active (numéro, vitesse, sens de marche);
•   Commande de vitesse et sens de marche des locos en mode standard : flèche haut/bas = augmentation/diminution de vitesse;
•   Le contrôleur est équipé d'un autre mode de commande de vitesse : l'appui sur une des touches numériques de la TLC commande une vitesse correspondant à sa valeur en dizaine de km/h; un appui sur le chiffre 4 commande 40 km/h, sur le 9, 90 km/h et le zéro, l'arrêt. Un réglage fin est évidemment toujours possible en combinant avec les flèches haut/bas. Attention! En pratique, le contrôleur impose un cran de vitesse (0 à 127) déterminé; un réglage du décodeur de chaque loco est nécessaire pour assurer la correspondance avec la vitesse à l'échelle. Ce système présente l'avantage d'économiser les touches de la TLC tout en garantissant une exploitation facile (p. ex la touche 4 = vitesse sur un appareil de voie en position déviée, la touche 1 = vitesse d'approche avant attelage, etc.).

Ce que ce contrôleur ne fait pas :

•   Commander des aiguillages ou accessoires (quoique ce ne semble pas impossible à priori);
•   Lire les CV d'un décodeur ;

La solution (déjà expliquée par ailleurs voir e.a. http://forum.locoduino.org/index.php?topic=203.msg1804#msg1804) retenue pour la partie "centrale DCC++" est articulée autour de :

•   1 carte Arduino UNO;
•   1 booster à base de LMD 18200;
•   1 module convertisseur courant/tension MAX471.

Au sujet du module à base de LMD18200, je vous livre une petite astuce ; les commandes passées sur la baie ne permettent pas toujours de maîtriser parfaitement le matériel livré ; il peut arriver quelques surprises : sur le module qui m’a été livré, une partie des connections étaient  étaient repérées en … chinois ! Comme mes connaissances en cette langue sont (très, très) lacunaires, j’ai du procéder par déduction. Voici les correspondances obtenues :

Indications sur le module ->   correspondance
PWR ->   PWR
chinois ->   BRAKE
chinois ->   DIR
GND ->   GND
+5V   ->+5V



La carte Arduino est chargée avec le programme standard tel que développé par Gregg E. Berman (donc pas la version pour Nano modifiée par Dominique).

Pour le contrôleur, il faut :
•   1 carte Arduino UNO;
•   1 afficheur LCD 2 lignes 16 caractères I2C (display I2C/TWI LCD1602 de DFROBOT, article DFR0063/TOY0046);
•   1 capteur infrarouge TSOP 4838;
•   1 télécommande IR; j'ai utilisé la télécommande d'un ancien lecteur/enregistreur de DVD de marque PANASONIC; une autre peut également convenir, à condition qu'elle comporte suffisamment de boutons…
 

Le tout, à l'état de prototype, est actuellement monté sur une planche en MDF (voir la photo).

 


A l'avant-plan, on observe de gauche à droite le convertisseur courant/tension MAX471, le booster à base de LMD18200 et la carte "Centrale DCC++"; la carte contrôleur se situe derrière l'afficheur LCD. Le pupitre à l'extrême droite ne fait pas partie du projet.

En haut à gauche, un moteur et son décodeur qui servent de banc d'essai pour la centrale mais aussi pour les décodeurs et les machines.

Chaque carte est alimentée par sa propre source de tension. La puissance est fournie au booster par une alimentation de PC portable (U = 19,5 VDC) dont la fiche DC a été adaptée en conséquence.
L'alimentation de PC dispose de sa propre protection contre les courts-circuits et est particulièrement efficace mais elle me pose un problème de sélectivité; en effet, elle déclenche toujours en premier lieu avant que les détections par logiciel n'aient pu détecter le problème. Ce qui signifie que quand une loco talonne un aiguillage dont le cœur est alimenté électriquement tout s'arrête et il faut faire un reset général.

Je joins le sketch Arduino à téléverser dans la carte « contrôleur ».

Attention ! Une adaptation à votre télécommande est nécessaire car il y a fort à parier que les codes seront différents. Modifier les codes en regard de chaque instruction #define  du bouton correspondant.
Ainsi, si le code correspondant à « flèche haut » sur votre télécommande est, remplacer la ligne ‘#define arrow_up 3796283338’ par ‘#define arrow_up 4589652’.

Après avoir téléversé le sketch, activez le moniteur série de l’IDE et appuyez sur les différentes touches de votre télécommande ; vous verrez alors apparaître le code correspondant sur le moniteur.

La librairie à utiliser pour la télécommande peut être téléchargée en https://github.com/cyborg5/IRLib ; elle doit ensuite être installée en \libraries\ de votre IDE.

Attention ! Comme vous disposerez de deux cartes Arduino UNO reliées par la liaison série TX/RX, vous devez retirer cette liaison temporairement lors du téléversement des sketches sous peine d’obtenir une erreur en fin de compilation.

[bobyAndCo]

ponponmvo,

Je ne vois ni les photos dont vous parlez, ni votre sketch

[ponponmvo]

Oups!

Merci de l'information.

Mais je dois réduire la taille des images.

En attendant, je joins le sketch.

[ponponmvo]

Voici les photos manquantes.

Daniel.