Sujets

1

Bus CAN / Le bus CAN normalisé LCC (Layout Command Control)

« le: décembre 26, 2023, 03:28:43 pm »

Bonjour,

Locoduino est fan du bus CAN, mais hélas son bus CAN n'est pas reconnu par les logiciels JMRI, RocRail, TrainController etc..
Le bus CAN est aussi aimé à l'étranger et particulièrement aux USA.

La National Model Railroad Association (Fédération nationale de modélisme ferroviaire), ou NMRA, 
L'association américaine travaillant pour le développement et la promotion du modélisme ferroviaire l'a adopté et standardisé en 2021.

Elle a choisi la norme LCC: Layout Command Control
https://openlcb.org/openlcb-and-lcc-documents/layout-command-control-lcc/
En fait, c'est le standard OpenLCB (Open Layout Control Bus) qui a été adopté et défini comme LCC.

Ce bus CAN normé Open Standard est reconnu par JMRI. Les autres logiciels ne devraient pas tarder à l'adopter aussi.
https://www.jmri.org/help/fr/html/hardware/can/index.shtml
JMRI reconnait également un autre bus CAN, le CBUS de source britannique: MERG (Model Electronic Railway Group)

Le site Sumida Crossing liste et compare l'offre actuelle des systèmes actuels de bus de contrôle:
http://www.sumidacrossing.org/LayoutControl/ControlBus/

Il existe déja plusieurs fournisseurs de cartes LCC (RRCirkits, cmOS Engineering) mais les amateurs de DIY (do it yourself) ne sont pas en reste.
https://openlcb.org/knowledge-base/

LCC est open source et il existe des librairies pour les dévellopeurs:
Open Model Railroad Network:
https://github.com/bakerstu/openmrn

OpenMRNLite Arduino Library:
https://github.com/openmrn/OpenMRNLite

Un exemple de projet de carte in/out à base d'ESP32:
https://github.com/atanisoft/esp32olcbio

Pour des modélistes qui envisagent un contrôle de leur réseau par ordinateur, LCC est une norme ouverte qui a de l'avenir.

Quelques liens:
http://www.sumidacrossing.org/Musings/files/151006_LCC_I_Layout_Command_Control.php
http://www.sumidacrossing.org/Musings/files/151018_LCC_II_How_It_Works_Physical.php
http://www.sumidacrossing.org/LayoutElectricity/microcontrollers/Arduinos/LCCforArduino/

2

JMRI et Arduino / Manette de commande WIFI pour JMRI

« le: décembre 15, 2021, 02:16:33 pm »

Bonjour,

J'ai fabriqué une manette de commande WIFI pour JMRI.
J'ai suivi le super tutoriel de Geoff Bunza décrit ici:

https://model-railroad-hobbyist.com/node/35652

C'est un vrai plaisir de pouvoir contrôler tactilement ses locomotives avec une manette sans fil dotée d'un gros potentiomètre. 
L'adresse de la loco peut facilement être choisie grâce à l'écran Oled.
La manette est basée sur un ESP32 qui se connecte automatiquement en WIFI à JMRI comme un smartphone.
J'ai téléchargé le code Arduino initial de Geoff avec un ajout simple de 2 lignes de code au début du loop:
client.println ("*");
client.flush ();
C'est pour l'envoi du "heartbeat" nécessaire à JMRI afin d'éviter toute déconnection intempestive.
La manette est alimentée par un accu NIMH de 9V.

3

Discussions ouvertes / Fabrication d'un décodeur DCC pour locomotive

« le: novembre 16, 2021, 06:24:03 pm »

Il existe plusieurs projets open source de décodeurs DCC au japon.
L'un des plus simple est le décodeur Nucky.
Pour traduire les sites japonais automatiquement, il faut utiliser le navigateur Chrome et cliquer dans la barre d'adresse à droite sur traduction.

https://web-nucky-jp.translate.goog/dcc/decoder6/onecoindecoder6.html?_x_tr_sl=ja&_x_tr_tl=fr&_x_tr_hl=fr&_x_tr_pto=nui,sc

image schéma nucky



J'ai voulu commander les circuits imprimés pour me lancer dans la fabrication, mais j'ai eu la réponse "No oversea": ils ne les vendent que au Japon.
Qu'à cela ne tienne, j'ai réalisé un clone du circuit imprimé avec Eagle. Et j'ai commandé les circuits chez JLCPCB.
Le circuit étant minuscule (22 x 10 mm), je me suis retrouvé avec la panelisation avec plus de 200 circuits dans la commande minimum...

image circuit



Comme pour tout décodeur DCC qui se respecte, il y a un pont de diodes, un microprocesseur et un driver plus une petite poignée de composants annexes.
Le tout en composants montés en surface bien sûr. Mais cela reste facile à souder avec un fer normal.
J'utilise des billes de soudure de 0.5mm pour souder les pates des composants.
 
https://www.ebay.com/itm/402921730943?hash=item5dd001b37f:g:60cAAOxy-1lRHqhJ&amdata=enc%3AAQAGAAACYPYe5NmHp%252B2JMhMi7yxGiTJkPrKr5t53CooMSQt2orsS%252BMKizvpuEDUfX4dvRWfUzfPaZMkatctZM94%252Fymexyg8xaWUZBA%252BIWZ%252B7AYYPqIy8k3sLxASn7iQO3ORSxFZ3o%252FoDRVDNKIDX%252FuUgBdGCUk6WUdnsnUaRq5YC%252BA3KarzO6%252F3sX7eZJ6JzCAVPcXY4%252FB21APXDm6vc3svncWkl0Z1YAx2Zy0dQh%252FUSvEXC9GPbMbtnAZDEkxZmzuZgYhgJohVCQWvSRNIbYRe8KFRKmbV4stWB5gOThGT18Wwm%252FshhSvkOa9h2S5OjkB9f%252FmvbXZYjX8m4moWJG9z02vl8zo7rokYj6g%252FLXhY1GhCkicmZX54JpjzxRaEZBZH18%252B0HWa2shk3z3BnBvj9qjNxE%252B7AgjrQpCrCSu8c2pRVSfKguJACP0gEbiLQOMj6uDNlOA6LUPfHn5JrXspJkNJ6wdwS5%252FqAkbbMNlLzL4Ok3jBbsehxTrd5UMc8BvnQYDZTcvTOb%252Bw%252FYzK65CwPmM2hLzwOAva3JriVd%252BOB35%252FhMaigQfc%252FqH3HFAEG8D%252FZ1%252BxQ%252FEpEXd2Vp5m7iikmV7ZZ4z4%252Fu1XthWYPzD%252B0w80YNzbHDEmSIDWUd1KAH5Xn3F8TNOaudKB%252FhbwSxkGN%252FaXJN1w%252BTfyjZNJ%252FlAbRGGF4o%252Fo78QBk7gJMfGbRaz4k7eFkILqGyentNfwMcbDkcAS0sIrRW4XA9U66o0qExGO%252FgdkcY3xGurHSOF60yciy%252FIi9gAh7j9i9o0fZLYgHWenl6LnoLbXtrUo%252BM4xmC6yVaHz6H%7Cclp%3A2334524%7Ctkp%3ABk9SR8zFjKSlXw





J'utilise un peu de patafix pour immobiliser les composants pendant la soudure.

https://www.amazon.fr/UHU-Pastilles-adhésives-repositionnable-décollable/dp/B001ANXKMG?th=1

Le microprocesseur est un PIC 12F1822 et j'ai utilisé un programmateur chinois PICkit2 pour le programmer. (une douzaine d'euros sur EBAY)
La dernière version du firmware du décodeur Nucky est la v0.92 sortie cet été. Disponible au téléchargement sur le site japonais.
Il y a 5 pads sur le circuit imprimé pour souder les 5 fils du programmateur.
Soudure temporaire, que le temps de la programmation.



image brochage programmation



Si vous essayez de programmer le PIC12F1822 avec le logiciel V2.61 du programmateur PICKIT2,
il est probable que vous ayez le message "Unsupported Part".
Si c'est le cas, il faut mettre à jour le fichier de composants PK2DeviceFile.dat.
La version v1.62.14 du PK2DeviceFile.dat contient bien le PIC12F1822.
Je met le fichier en pièce jointe.

En commandant les composants par 10, le prix de revient est de moins de 7€ par décodeur.
Je met la liste BOM des composants en pièce jointe.

Si vous êtes intéressé par cette réalisation je peux vous fournir les circuits imprimés par 10 avec 10 diodes SS2040FL pour 7€. Contact en MP.
On trouve ces diodes par 100 sur Ebay, ce qui n'est pas très pratique.

Mes locos sont en HOe, mais vu la taille du décodeur, il peut être utilisé facilement en N.





Pour programmer l'adresse du décodeur, qui est 3 par défaut, J'ai utilisé DecoderPro de JMRI.
Comme Nucky ne figure pas dans la liste des décodeurs, J'ai utilisé le NMRA standard CV definitions (premier de la liste).

Inutile de vous dire la grosse satisfaction de faire tourner sa loco avec le décodeur qu'on a fabriqué soi même ! 

4

Le logiciel DCC++ / Mini centrale DCC++ pour banc nettoyage

« le: juillet 10, 2021, 01:08:54 pm »

Bonjour,

Je souhaiterais me faire une mini-centrale DCC++ pour faire juste tourner les roues de mes locos sur banc pour le nettoyage des roues.
Je pourrais tirer 2 fils DCC du réseau, mais ce ne serait pas très pratique car mon établi est éloigné du réseau.

J'envisage l'utilisation d'un UNO avec un shield pour faire quelquechose de compact.

Est-ce que ce shield conviendrait?
https://www.ebay.fr/itm/173648838897?hash=item286e4700f1:g:n44AAOSwfMlb8jOW

Il me permettrait de souder quelques boutons pour la commande.

Est-ce qu'une alimentation 12V suffirait pour des locos en HOe?
Ce qui permettrait d'alimenter aussi le UNO.

5

Le logiciel DCC++ / DCC++ EX

« le: août 16, 2020, 02:55:44 pm »

Bonjour,
Utilisez-vous DCC++ EX ?
Qu'en pensez-vous ?

https://dcc-ex.com/

6

Débuter / Ressources Arduino

« le: février 28, 2020, 11:35:53 pm »

Bonsoir,

Des tutoriels pour débutants et des cours complets sur l'arduino chez developpez.com:
https://arduino.developpez.com/cours/

7

Discussions ouvertes / condensateur et passage au DCC

« le: décembre 10, 2019, 08:27:43 am »

Bonjour,

Certaines locomotives analogiques sont équipées d'un petit condensateur aux bornes du moteur.
Faut-il laisser celui-ci en place lors de l'installation d'un décodeur DCC ?

8

JMRI et Arduino / Arduino en Entrées/Sorties pour JMRI

« le: septembre 19, 2018, 03:21:44 pm »

Bonjour,

Geoff Bunza de Model Railroad Hobbyist (MRH) vient d'écrire 2 articles dans son blog  pour relier des arduinos en
entrée ou en sortie à un PC JMRI.

Le principe est d'utiliser par exemple un arduino MEGA avec 68 entrées relié par USB au PC acceuillant JMRI.
On peut tout aussi bien utiliser un autre MEGA avec 68 sorties lui aussi relié à JMRI par USB.

Il suffit de lancer un script Python dans JMRI pour initialiser la reconnaissance des Arduinos.

C'est une solution ultra-économique pour étendre les possibilités de JMRI, logiciel gratuit qui s'interface avec DCC++.

Arduino en entrée:
https://model-railroad-hobbyist.com/node/34392

Arduino en sortie:
https://model-railroad-hobbyist.com/node/34417

9

JMRI et Arduino / Carte 24 entrées 48 sorties pour JMRI

« le: avril 13, 2018, 09:40:38 am »

C'est une carte pilotée par un Arduino Nano et qui est l'équivalent d'une carte SMINI-C/MRI.
https://www.utrainia.com/65-arduinocmri-and-rs485



Elle peut commander par exemple des aiguillages, des éclairages ou des feux de signalisation.
On peut y connecter des modules de détection de cantons ou des boutons.

Elle est reliée au PC par un bus RS485 à 2 fils grâce à un adaptateur USB-RS485 (1€ sur Ebay)
On peut connecter ensemble plusieurs de ces cartes à JMRI en les chainant par ce bus.
Chaque carte est identifiée par un numéro de node dans JMRI.
http://jmri.org/help/fr/html/hardware/cmri/CMRI.shtml#iobits

La carte utilise 6 CI 74HC595 pour les 48 sorties et 3 CI 74HC165 pour les 24 entrées (pull-upées).
Ces registres à décalage 8 bits sont chainés et reliés par 2 x 3 fils au Nano.

J'ai utilisé Eagle pour la CAO du schéma et du PCB.





J'ai fait fabriquer par JLCPCB un PCB double face compact 100 x 100 mm. (2$ les 10 ! + 11€ de port)
Je fournis les fichiers en pièce jointe.
Pour commander des PCB chez JLCPCB il suffit d'uploader sur leur site Le fichier Arduino-CMRI_Gerber.zip
https://jlcpcb.com


Le programme du Nano est ultra simple grâce aux bibliothèques CMRI et Auto485 disponibles sur le site utrainia.
Il suffit de préciser le numéro de node affecté à la carte.

Code: [Sélectionner]

/**
 * C/MRI -> JMRI via RS485
 * =======================
 * Sets up an SMINI 24 inputs, 48 outputs with an Arduino Nano.
 * Uses an RS485 bus to transparently talk support multiple ArduinoCMRI nodes on one bus.
 * By passing in an Auto485 object to the CMRI constructor, we are able to automatically
 * control the DE and RE pins on our RS485 bus transceiver.
 * The PC with JMRI has an USB-RS485 adapter connected to the bus.
 *
 * IN control:
 * Nano pin:             74HC165 pin:
 *     9        LATCH ->     1
 *     13       SCK   ->     2
 *     12       MISO  ->     9
 *     
 *     
 * OUT control:   
 * Nano pin:             74HC595 pin:
 *     6      verrou ->     12
 *     7      donnee ->     14
 *     8     horloge ->     11
 *     
 *     
 * Change the CMRI_ADDR for each board.  Each node must have its own address.   
 * ====================================
 **/

#include <Auto485.h>
#include <CMRI.h>
#include <SPI.h>

#define CMRI_ADDR 0                  // select the CMRI node address
#define    DE_PIN 2                  // Arduino pin 2 -> MAX485 DE and RE pins

// pin 74HC165
const byte LATCH = 9;

// pins 74HC595
const byte verrou = 6;
const byte donnee = 7;
const byte horloge = 8;

Auto485 bus(DE_PIN);                 // RS485 bus transceiver
CMRI cmri(CMRI_ADDR, 24, 48, bus);   // sets up an SMINI. SMINI = 24 inputs, 48 outputs

void setup() {
  bus.begin(9600, SERIAL_8N2);       // open the RS485 bus at 9600bps
  pinMode(verrou, OUTPUT);
  pinMode(donnee, OUTPUT);
  pinMode(horloge, OUTPUT);
  SPI.begin ();                      // serial data protocol used to control 74HC165
  pinMode (LATCH, OUTPUT);
  digitalWrite (LATCH, HIGH);
}

void loop() {
  // 1: main processing node of cmri library
  cmri.process();
 
  // 2: update output
  digitalWrite(verrou, LOW);                                // on commence par mettre le verrou
  shiftOut(donnee, horloge, MSBFIRST, cmri.get_byte(5));    // on envoie la sixieme donnée d'abord
  shiftOut(donnee, horloge, MSBFIRST, cmri.get_byte(4));    // on envoie la cinquieme donnée ensuite
  shiftOut(donnee, horloge, MSBFIRST, cmri.get_byte(3));    // on envoie la quatrieme donnée ensuite
  shiftOut(donnee, horloge, MSBFIRST, cmri.get_byte(2));    // on envoie la troisieme donnée ensuite
  shiftOut(donnee, horloge, MSBFIRST, cmri.get_byte(1));    // on envoie la seconde donnée ensuite
  shiftOut(donnee, horloge, MSBFIRST, cmri.get_byte(0));    // et on envoie la première donnée
  digitalWrite(verrou, HIGH);                               // et on relache le verrou pour mettre à jour les données
   
  // 3: update inputs
  digitalWrite (LATCH, LOW);                                // pulse the parallel load latch
  delay(1);                                                 // wait while data loads
  digitalWrite (LATCH, HIGH);
  cmri.set_byte(0, ~(SPI.transfer(0)));
  cmri.set_byte(1, ~(SPI.transfer(0)));
  cmri.set_byte(2, ~(SPI.transfer(0)));
}

Il y a 2 jumpers sur la carte reliés à RX et TX.
Il faut les enlever pour la programmation du Nano et les remettre après celle-ci.

L'alimentation 5V se fait sur un bornier.
Il faut la déconnecter lors de la programmation du Nano par la prise USB.

Il y a 2 borniers de connection au bus RS485 pour faciliter le chainage des cartes.
Pas besoin de résistances de terminaison de 120 ohm pour le RS485 lorsque les liaisons ne font que quelques metres.

A noter qu'une carte SMINI en kit coute 100€ (160€ assemblée).
Celle-ci devrait vous couter moins de 10€ !

La liste des composants est dans le dossier Arduino-CMRI_Eagle.zip.
Ils se trouvent couramment sur Ebay.
Les connecteurs sont au pas de 3.5mm comme ceux-là:
https://www.ebay.fr/itm/262957982206

10

Discussions ouvertes / Balises img du forum

« le: avril 02, 2018, 11:46:22 pm »

Bonjour,

Quelqun pourrait-il m'expliquer le fonctionnement des balises img du forum ?

Lorsque j'insère une URL de la façon habituelle: [img)URL de l'image[/img) l'image n'est pas affichée.

(J'ai volontairement remplacé les parenthèses fermantes pour l'affichage de la phrase)

11

Vos projets / servotiny13

« le: mars 22, 2018, 08:14:24 pm »

Bonjour,

Je souhaite équiper mon réseau de sémaphores avec feux pour la signalisation.
L'idée est d'utiliser un petit ATtiny13 (1k Flash) pour commander le servo qui va contrôler chaque sémaphore.

Les librairies classiques de contrôle de servos ne peuvent pas être utilisées avec un ATtiny13 qui ne dispose que d'un seul timer (8bits).
J'ai donc reprogrammé le timer pour qu'il génère une base de temps compatible avec les impulsions classiques de commande de servos.

Ci-joint le code qui utilise moins de la moité de la Flash: 

Code: [Sélectionner]

/*
 servotiny13

 Permet le contrôle d'un servomoteur sur un ATtiny13 à 9.6 MHz.
 le programme configure le timer pour générer une interruption toutes les 10us soit à une fréquence de 100 kHz.
 Toutes les 20ms (50Hz) on active la sortie pour une durée d'impulsion comprise entre 1ms et 2ms.
 La fonction classique delay() n'est plus disponible puisqu'on a reprogrammé l'unique timer.
 Le programme utilise une fonction locale: delay_() pour ralentir les mouvements du servo.
 Cette fonction "attend" pendant un nombre de ticks multiple de 10us correspondant au délai souhaité.
*/


volatile unsigned int Tick;       // 100KHz pulse
volatile unsigned int sPulse;     // Servo pulse variable
volatile unsigned int Tick_10us;  // base time for delay_ function

void setup() {
  pinMode(3, OUTPUT);     // Servo pin on PB3 = pin 2 ATtiny
 
  cli();                  // Disable global interrupts
  TCCR0A = 0;             // Initialize timer 0 registers
  TCCR0B = 0; 
  TCCR0A |= (1<<WGM01);   // Configure timer 0 for CTC mode (Clear Timer on Compare Match)
  TIMSK0 |= (1<<OCIE0A);  // Enable CTC interrupt
  OCR0A = 95;             // Set CTC compare value for 100kHz interrupt
  TCCR0B |= (1<<CS00);    // No prescaler -> 9.6 MHz
  sei();                  // Enable global interrupts

  Tick = 0;
  sPulse = 100;           // 100 x 10us = 1 ms
  Tick_10us = 0;
 
}

ISR(TIM0_COMPA_vect)      // 100 KHz interrupt frequency
{
  Tick_10us += 1;
 
  if(Tick >= 2000)        // servo frame (20ms)
     {
        Tick = 0;
     }

  Tick += 1;
 
  if(Tick <= sPulse)        // Generate servo pulse
  {
    digitalWrite(3, HIGH);  // Servo pulse high
  }
  else
  {
    digitalWrite(3, LOW);   // Servo pulse low
  }
}


void loop() {
  for(int i=0; i<=100; i++)  // Servo test
    {
      sPulse = sPulse + 1;
      delay_(2000);          // delai 2000 x 10 us = 20 ms
    }

    sPulse = 200;

    for(int i=0; i<=100; i++)
    {
      sPulse = sPulse - 1;
     delay_(2000);
    }
    sPulse = 100;
}

  void delay_(int nombre)
  {
    Tick_10us = 0;                  // initialisation pour début de comptage
    while (Tick_10us < nombre) {}   // attend jusqu'à le nombre de ticks soit atteint
  }
 


12

Shields et Modules / Module de détection par induction pour canton DCC

« le: mars 14, 2018, 01:11:13 am »

Bonjour,

Les circuits classiques de détection  de consommation de courant à diodes ont 2 inconvénients:
La chute de tension de 0,7V inhérente à l'emploi de diodes et l'exposition de celles-ci en cas de court circuit.

J'ai donc opté pour la détection par induction qui utilise un petit transfo torique.
http://www.sumidacrossing.org/LayoutControl/TrainDetection/InductiveDetectionCircuit/

Le principe est de prélever une boucle du fil du circuit DCC qui alimente le canton et de l'enrouler autour du transfo.
Le circuit est donc parfaitement isolé du DCC.

J'ai utilisé le célèbre circuit de Paisley qui a fait ses preuves.
http://www.circuitous.ca/DccBODvt5.html#PCB

Les transfos AS-103 sont disponibles chez Radio-Spares:
https://fr.rs-online.com/web/p/transformateurs-de-courant/3997317/?searchTerm=AS-103&relevancy-data=636F3D3226696E3D4931384E4B6E6F776E41734D504E266C753D6672266D6D3D6D61746368616C6C7061727469616C26706D3D5E5B5C707B4C7D5C707B4E647D2D2C2F255C2E5D2B2426706F3D313326736E3D592673743D4B4559574F52445F53494E474C455F414C5048415F4E554D455249432677633D424F5448267573743D41532D313033267374613D41532D31303326

J'obtiens une sensibilité de 0,7 mA pour un circuit DCC de 15V (détection d'une résistance de 21,3 K Ohm dans le canton).

J'ai réalisé un circuit imprimé simple face de 100 mm x 50 mm qui regroupe 4 circuits de détection indépendants.
Il s'alimente en 5V et les sorties sont au niveau bas pour une détection et au niveau haut en l'absence de détection.

Ci-joint les fichiers au format Eagle, ainsi que les fichiers Gerber pour la fabrication.

Si vous voulez faire fabriquer le circuit imprimé je vous recommande JLCPCB (Singapour) qui fait un travail soigné à des prix canons.
https://jlcpcb.com

Leur prix pour 5 circuits, port compris: 9€.
Livraison 15 jours après la commande.

13

Infos et bonnes affaires / ATtiny13 le mini ATtiny

« le: février 07, 2018, 05:04:31 pm »

Bonjour,

Le ATtiny13, c'est le junior dans la famille des ATtiny:
1 k de mémoire FLASH, 64 octets de RAM et 64 octets d'EEPROM

C'est pas énorme, mais suffisant pour des petites animations sur le réseau.

Il y a même plus petit dans la famille avec Les ATtiny4/5/9/10 à 6 pins.

Le prix non plus n'est pas énorme, 2.42€ les 10:
https://www.ebay.fr/itm/10PCS-MCU-IC-ATMEL-SOP-8N-ATTINY13A-SSU-TINY13A-SSU-ATTINY13A/272949032036?hash=item3f8d07b464:g:cYcAAOSwls5Y6JOw

C'est la version soic, composant soudé en surface.

Il peut être avantageusement soudé sur un petit PCB qui facilite sa programmation, comme ceux-ci vendus 1.12€ les 20:
https://www.ebay.fr/itm/20Pcs-SOP8-SO8-SOIC8-TSSOP8-MSOP8-to-DIP8-2-54mm-Adapter-PCB-Board-Converter/221769915062?hash=item33a2845ab6:g:u1AAAOSw3KFWej87

Pour la programmation spécifique ATtiny 13 (autre que ATtiny25/45/85) depuis l'IDE Arduino, il y a ce tutoriel:
http://www.instructables.com/id/Updated-Guide-on-How-to-Program-an-Attiny13-or-13a/

14

JMRI et Arduino / Bibliothèque C/MRI

« le: février 02, 2018, 09:33:37 pm »

Bonjour,

En cherchant des réalisations de commande de plaque tournante avec Arduino, je suis tombé sur cette vidéo:



Elle présente une plaque tournante controlée par Arduino et commandée à la souris depuis le layout PanelPro de JMRI.
Elle utilise pour cela la bibliothèque C/MRI (Computer Model Railway Interface)
https://github.com/k4kfh/turningTables

Cette interface est très interréssante, elle permet de relier des cartes d'entrées/sorties à un logiciel PC comme JMRI qui reconnait ce standard nativement.
http://jmri.org/help/fr/html/hardware/cmri/CMRI.shtml#iobits

La bibliothèque Arduino émule une de ces cartes à moindre coût et j'ai pu la tester avec succès avec JMRI.
https://github.com/madleech/ArduinoCMRI

15

Le logiciel DCC++ / Bug DCC++ dans fonction Sensor::check()

« le: février 01, 2018, 05:11:32 pm »

Bonjour,

J'ai trouvé un bug dans la fonction Sensor::check() du fichier Sensor.cpp

Cette fonction est appelée  par DCCpp::loop() pour transmettre les changements d'états des pins des sensors.

Telle qu'elle est définie elle ne transmet que sur l'interface ETHERNET.
Donc si on utilise une connection USB série les états des sensors ne sont jamais envoyés.

Pour remédier à cela, il suffit de commenter les lignes #if defined(USE_ETHERNET)  en 128, 132, 135 et 139

Avec cette correction l'état des sensors est bien transmis au PC et JMRI peut (enfin...) les prendre en compte.

Ce bug est dans la librairie DCCpp mais pas dans DCC++ sur GitHub.