Non les trois fils sont sur les potentiomètres. Les inters n’ont qu’un fil de masse. Si l’inter n’est pas actif (rien ne passe au travers) l’entrée (pin) est à HIGH par la résistance PULLUP active. Quand l’inter est basculé, la masse est reliée est cela suffit à annuler l’effet du PULLUP et mettre l’état de la pin à LOw
Tu n’aurais pas pris des inters inverseurs ?
Si c’est le cas, alors connecter la broche du milieu et celle de droite au fil de masse et la broche de gauche à l’arduino.
ATTENTION, ton “inter” ne fonctionnera que dans un sens de bascule. Pour les test, ça peut le faire. Après il faudra les remplacer.
Phil,
Oui ce sont ces inters mais ça peut aussi être des 2 positions. Bien lire ce que j’ai écris. La pin de l’Arduino dont la PULLUP est activée correspond à un état HIGH, disons marche avant. Si la masse n’est pas reliée avec la pin cet état reste actif. Quand on commute l’inter, la masse est reliée et la pin bascule de l’état HIGH (marché avant) à l’état LOW (marche arrière)
Christophe
Est-ce que c’est cela?
T’inquiète, j’en ai de tous les modèles (et en quantité). C’est fou ce que l’on pouvait en gaspiller avec le jeunes…
Merci Phil.
Alain
Oui c’est ce principe mais tu n’as pas besoin de résistance externe (ni de liaison au 5V) Quand tu déclares la pin comme INPUT_PULLUP, ce mécanisme est interne à l’arduino
C’est ici dans le setup
for (byte i = 0; i < NB_LOCO; i++) {
loco[i].speedPin(t_speedPin[i]);
loco[i].dirdPin(t_dirPin[i]);
pinMode(loco[i].dirdPin(), INPUT_PULLUP);
loco[i].address(t_address[i]);
}
OK, je vois, c’est ce qu l’on a en ligne 161 :
for (byte i = 0; i < NB_LOCO; i++) {
loco[i].speedPin(t_speedPin[i]);
loco[i].dirdPin(t_dirPin[i]);
pinMode(loco[i].dirdPin(), INPUT_PULLUP);
loco[i].address(t_address[i]);
}
Bon, et bien il ne reste plus qu’à faire les essais, dès que possible.
Alain
1 « J'aime »
Bonjour Christophe,
Nous sommes le dimanche 09 mars 2025, et voici le résultat de l’expérimentation de ce matin :
- Le câblage de l’interrupteur en D8 ne pose aucun problème et son fonctionnement est bien pris en compte. Voici pour preuve la capture d’écran du moniteur série correspondante :
On voit très clairement au travers des valeurs alternées ( 1 et 2), les deux sens de la direction.
- Le potentiomètre est câblé en A5 et on voit par les captures suivantes,
Au point bas, une valeur qui oscille entre 0 et 10.
Au point milieu, une valeur qui oscille autour de 500.
Et pour finir, au point haut, une valeur qui oscille au voisinage de 1000.
Une photo du montage,
- Pour ce qui est des locomotives, j’en ai six en mfx, en principe avec un Identifiant compris entre 5 et 10 ; soit dans l’ordre, BR74, V200, BR24, T3, G12 et ES44AC.
Dont voici une photo, pour le “Fun”.
Sauf qu’aucune d’entres-elles (les coquines!) n’ont voulu participer; bien qu’elles soient toutes sur la voie.
Et bien j’en suis là.
Pour documenter, voici le fichier ino déguisé en pdf de ton code adapté :
Tabl_Orig.ino.pdf (8,2 Ko)
Bon dimanche.
Alain
1 « J'aime »
C’est sympa !
Pour les locos qui ne répondent pas, il faut que tu commences par vérifier que tu as bien mis du courant sur la voie en désactivant la touche STOP de la MS2. C’est une commande qui pourra être réalisée par programmation ensuite mais je ne l’ai pas encore fait.
Si cela ne donne toujours rien, modifies tes lignes de codes 186 et 187par ceci
frame.data[2] = 0x40;
frame.data[3] = loco[i].address() & 0x00FF;
Si cela ne fonctionne toujours pas, il faudra que j’écrive les lignes de codes qui permettent à la Gleisbox de reconnaitre l’Arduino. C’est la commande 0x1B (bootloader CAN) qui n’est malheureusement (bizarrement !!!) citée mais pas documentée dans le protocole publié.
Christophe
Bonjour à tous,
Je me rends compte que pour ce projet, il ne faut pas que je cherche à trop entrer dans les entrailles du protocole CAN de Marklin. Il y a un autre fil qui aborde cela en détail Comprendre et utiliser le protocole CAN de Marklin
Pour ce projet, dans l’idée d’avoir quelque chose qui fonctionne rapidement et facilement, je vais maintenant travailler avec la bibliothèque Railuino que j’avais réécrite et testée et dont j’avais parlé ici Railuino : La bibliothèque pour commander son réseau en DIY avec le protocole CAN de Marklin
Ce qui a été fait jusqu’ici dans ce fil n’aura pas été inutile puisque c’est à minima un moyen d’approcher le CAN de Marklin.
Mais le propre d’une bibliothèque étant de (grandement) simplifier la vie du programmeur amateur, je pense que ce sera nettement préférable ici.
Pour les fondus de programmation en bas niveau, il reste le fil Comprendre et utiliser le protocole CAN de Marklin
Je ne pourrais au mieux tester le code avec Railuino que demain ou mercredi. Je vous propose d’ici là de relire le fil sur Railuino dont je donne le lien ci-dessus. Ce que j’y ai présenté est vraiment sympa je crois et donne une bonne idée de ce que l’on peut faire avec le CAN de Marklin et une simple MS2.
PS : Je n’ai fait la réécriture de Railuino que pour ESP32 mais pas pour Arduino. C’est à la version Arduino que je vais devoir m’atteler. J’espère que Alain @DUPERCHE voudra toujours bien m’aider dans les tests
Des nouvelles très vite.
Christophe
Bonjour à tous,
Voici un premier résultat avec comme fourniture : un Arduino Uno ; un module Can-Bus, deux potentiomètres et deux interrupteurs de récupération ; des fils de jonction ; et le code de @bobyAndCo .
D’autres améliorations suivront.
A+
Alain
7 « J'aime »
Merci Alain pour cette démonstration et pour le temps passé pour les tests.
Cela m’a permis d’adapter Railuino à l’Arduino Uno mais aussi au Mega, ce qui est aussi une bonne chose.
Christophe
Merci pour les essais et la vidéo, Alain.
1 « J'aime »
Génial Alain.
En plus tu m’as fait bien rire avec tes 2 locos qui se rattrapent 
Bon, c’est sur que tout est en câblage volant, donc pas facile à manipuler.
En tout cas, bravo, et à Christophe aussi. 
1 « J'aime »
Nous allons préparer la version Méga pour prendre en compte les Six locomotives avec plus de fonctions. Cela va prendre un peu de temps.
C’est vrai que je me suis laissé déborder par les deux locos en me trompant de sens , d’où le rôle des potentiomètres rectilignes.
Il faut surtout remercier @bobyAndCo , moi je ne suis que l’assitant.
Un peu comme ce personnage 
3 « J'aime »
Bonjour à tous,
Voilà, je viens de finaliser la petite table de commande en utilisant la bibliothèque Railuino que j’ai remis à jour.
Le code de Railuino sur le Github https://github.com/BOBILLEChristophe/Railuino
Avec un Arduino Mega, il est possible de piloter au moins 6 locomotives, de changer le sens de circulation et d’activer 1 fonction. J’ai choisi ici le klaxon.
Railuino simplifie grandement le développement. Voici par exemple la seule page sur laquelle on a besoin d’intervenir. Vraiment très simple.
Voici le code de la page principale :
/*********************************************************************
Table de commande pour 6 locomotives (ou plus)
https://forum.3rails.fr/t/table-de-commande-pour-6-locomotives-ou-plus/28608
********************************************************************/
#include "Config.h"
#include "TrackController.h"
#include "Loco.h"
const uint8_t NB_LOCO = 6; // Nombre de locomotibes
Loco loco[NB_LOCO]; // Instances de locomotives
uint16_t t_address[NB_LOCO] = { ADDR_MFX + 7,
ADDR_MFX + 6,
ADDR_MFX + 5,
ADDR_MFX + 8,
ADDR_MFX + 9,
ADDR_MFX + 10 };
byte t_speedPin[NB_LOCO] = { A0, A1, A2, A3, A4, A5 }; // Broches pour chacun des potentiometres
byte t_dirPin[NB_LOCO] = { 3, 4, 5, 6, 7, 8 }; // Broches pour chacun des boutons inverseurs de direction
byte t_funcPin[NB_LOCO] = { 22, 23, 24, 25, 26, 27 }; // Broches pour chacun des boutons activation klaxon
byte t_funcKlaxon[NB_LOCO] = { 5, 3, 3, 3, 3, 3 }; // Numero de la fonction pour le klaxon
const bool DEBUG = true;
TrackController ctrl(0xDF24, DEBUG); // Instance de TrackController
void setup() {
Serial.begin(115200);
while (!Serial)
;
// Declaration et initialisation des broches
for (byte i = 0; i < NB_LOCO; i++) {
loco[i].speedPin(t_speedPin[i]);
loco[i].dirdPin(t_dirPin[i]);
pinMode(loco[i].dirdPin(), INPUT_PULLUP);
loco[i].funcPin(t_funcPin[i]);
pinMode(loco[i].funcPin(), INPUT_PULLUP);
loco[i].address(t_address[i]);
loco[i].setFunctKlaxon(t_funcKlaxon[i]);
}
ctrl.begin();
delay(1000);
Serial.println("Power on");
ctrl.setPower(true);
//Allume les feux et le son de toutes les locomotives
for (auto el : loco) {
ctrl.setLocoFunction(el.address(), 0, 1);
ctrl.setLocoFunction(el.address(), 3, 1);
}
Serial.println("Headlights on");
// Initialise direction en fonction de la position physique de l'interrupteur
for (byte i = 0; i < NB_LOCO; i++) {
byte direction = digitalRead(t_dirPin[i]);
switch (direction) {
case 0:
loco[i].setDirection(2);
break;
case 1:
loco[i].setDirection(1);
break;
}
ctrl.setLocoDirection(loco[i].address(), loco[i].getDirection());
}
} // end setup
void loop() {
for (byte i = 0; i < NB_LOCO; i++) {
if (loco[i].speed()) {
ctrl.setLocoSpeed(loco[i].address(), loco[i].getSpeed());
Serial.println(loco[i].getSpeed());
}
if (loco[i].direction()) {
ctrl.setLocoDirection(loco[i].address(), loco[i].getDirection());
ctrl.setLocoSpeed(loco[i].address(), loco[i].getSpeed());
Serial.println(loco[i].getDirection());
}
if (loco[i].function()) {
ctrl.setLocoFunction(loco[i].address(), loco[i].getFunctKlaxon(), loco[i].getFunction());
Serial.println(loco[i].getFunction());
}
}
} // end loop
Une petite vidéo où l’on voit bien sur l’écran de la MS2 que celle-ci se laisse piloter et qu’elle est mise à jour en temps réel.
Ce projet est téléchargeable dans son ensemble. Il faut enlever « .pdf » au nom de fichier et dézipper dans le dossier Arduino de votre ordinateur.
table_commande_locos_CAN-250316a.zip.pdf (14,4 Ko)
Ce petit projet laisse entrevoir les multiples possibilités d’animations qu’il est facile de réaliser de cette manière. Par exemple un va-et-vient avec des effets sonores.
Merci encore à Alain @DUPERCHE qui a fait un gros travail pour traquer les bugs.
Bonne fin de week-end à tous
Christophe
3 « J'aime »
Merci pour tes développements et pour le partage. Cette table de commande est un plus indéniable dans le plaisir de commander les trains manuellement, que ne permet pas la seule MS2.
Dès que mon réseau sera suffisamment développé, et que j’aurai un peu de temps, je m’y mets.
Merci Chistophe pour ta citation.
Je continue de mettre au point ma propre table et ne manquerais pas de te tenir au courant de mes avancées.
Alain
Bonjour,
juste une petite remarque :
je pense que beaucoup de personnes sont intéressées par ce montage génial, innovant et performant mais qu’un certain nombre ne connait pas (ou peu) arduino et l’electronique
Il serait donc pratique d’avoir un schéma de branchements. Par exemple :
Pour les potas :
n°1 : connecteur A (ou B) vers pin A0 de la carte, commecteur GND vers …, connecteur +5v …
n°2 : connecteur A (ou B) vers pin A1 de la carte, commecteur GND vers …, connecteur +5v …
…
n°6 : connecteur A vers pin A5 de la carte, commecteur GND vers …, connecteur +5v …
Interrrupteur 1 : 1 connecteur vers pin 22 de la carte, l’autre connecteur vers …
…
Interrrupteur 6 : 1 connecteur vers pin 27 de la carte, l’autre connecteur vers …
Inverseur 1 : 1 connecteur vers pin 3 de la carte, l’autre connecteur vers …
…
Inverseur 6 : 1 connecteur vers pin 3 de la carte, l’autre connecteur vers …
De ce que j’ai entendu avec quelques Märklinistes cela leur permetrait de se “lancer” plus facilement.
Juste une idée.
Et encore bravo pour le travail réalisé.
Je pense que je vais investir dans une MS en attendant de résoudre mon pb de CS 
JiPé
1 « J'aime »
Bonjour JiPé,
Je suis heureux de ce que tu dis car l’objectif est bien d’apporter plus de plaisir de jeu et tu confirmes que c’est le cas.
Nous allons détailler ce projet, je dis nous car je ne doute pas que Alain m’aider. Mais cela demande du temps, des schémas, des photos, des tests…
Je voudrais aussi faire évoluer le montage avec une solution à base de module CAN Niren qui est moins cher, moins encombrant et qui est suffisant pour le CAN de Marklin à 250 Kbps.
Je voudrais proposer aussi un shield que j’avais réalisé pour Arduino Mega qui supporte ce module CAN et permet surtout de souder les fils ce qui est beaucoup plus simple, fiable et économique que les câbles Dupont.
Juste pour info, pour ceux qui cherchent à comprendre les branchements, il faut analyser le début du programme :
const uint8_t NB_LOCO = 6; // Nombre de locomotives
comme le commentaire l’indique, NB_LOCO, c’est le nombre de locomotives que l’on souhaite piloter. Ici 6 mais on pourrait monter à 10 ou à 12
uint16_t t_address[NB_LOCO] = { ADDR_MFX + 7,
ADDR_MFX + 6,
ADDR_MFX + 5,
ADDR_MFX + 8,
ADDR_MFX + 9,
ADDR_MFX + 10 };
Pour ces 6 locomotives, il faut entrer leur adresse locale. En générale, cela commence à 1. Dans le code ci-dessus, ADDR_MFX + 7 correspond à l’adresse 7 pour le premier potentiomètre.
PS : Je suis en train de finaliser un petit programme pour lire facilement l’adresse d’une loco !
byte t_speedPin[NB_LOCO] = { A0, A1, A2, A3, A4, A5 }; // Broches pour chacun des potentiometres
byte t_dirPin[NB_LOCO] = { 3, 4, 5, 6, 7, 8 }; // Broches pour chacun des boutons inverseurs de direction
byte t_funcPin[NB_LOCO] = { 22, 23, 24, 25, 26, 27 }; // Broches pour chacun des boutons activation klaxon
Pour le code ci-dessus qui correspond aux broches de l’Arduino Mega, je crois que les commentaires du code se suffisent à eux-mêmes.
byte t_funcKlaxon[NB_LOCO] = { 5, 3, 3, 3, 3, 3 }; // Numéro de la fonction pour le klaxon
Dans ce tableau, on renseigne le numéro de la fonction que l’on souhaite activer avec le bouton poussoir. Pour ma première loco, le klaxon est la fonction 5. Il y a un autre klaxon en fonction 7. Chacun choisi ce qui lui correspond
C’est bien que vous posiez toutes ces questions car ça va aider à la mise au point du mode d’emploi.
Deux remarques
1° - J’ai déjà bien noté que tu es intéressé par une découpe laser du support. Je vais faire cela rapidement
2° - Comme tu es à l’aise avec l’Arduino, c’est vrai que tu peux faire plein de choses avec une MS2 + Gleisbox. D’une manière ou d’une autre, toutes les fonctions que l’on a dans une CS2, CS3 sont disponibles via le CAN. Je pense à la rétrosignalisation ou à la commande d’accessoires. La seule vraie limite de la Gleisbox est sa puissance limitée à 1,9 A environ.
Mais il ne t’as sans doute pas échappé que j’avais réalisé (sous l’impulsion de @gelit) une centrale MFX en DIY qui fonctionne jusqu’à 5A au besoin. Contrôler vos trains MFX depuis un Arduino Due SANS passer par la Gleisbox - #28 par bobyAndCo
Christophe
1 « J'aime »