Cet article peut paraitre surprenant surtout à la suite du salon d’Orléans ou les solutions "tout automatique" ou "tout informatisé" présentées au magnifique stand Locoduino ont eu un énorme succès.
Il est vrai qu’il est très plaisant de voir circuler des trains en toute sécurité en les suivant à l’écran de son Smartphone, de sa tablette ou de son ordinateur, mais on peut aussi trouver beaucoup de plaisir à "jouer" manuellement avec une ou plusieurs machines, tout au moins sur une partie de son réseau.
L’originalité du projet tient entre autre dans le stockage maximum de 59 locos dans la souris, ce qui permet de travailler avec sa propre souris à la maison ou dans son club en ayant toutes ses machines sous la main (sous conditions d’avoir la même centrale au club).
Souris et centrale sans fil
.
Par :
DIFFICULTÉ :★★☆
Historique
En fréquentant des clubs de modélisme ferroviaire il est apparu que les souris utilisées ne convenaient pas toujours à tout le monde. L’idée d’en faire une sur mesure a germé et c’est en prenant en main le boitier HAMMOND que j’ai décidé de me lancer dans ce projet, tant ce boitier est agréable à manipuler. Le cahier des charges a été défini avec l’aide des membres de mon club. La demande était, entre autres, de pouvoir suivre en toute liberté son convoi tout au long du réseau, qui peut être très vaste dans certains clubs, ce qui m’a orienté vers le sans fil.
Après de longues semaines de tests avec les "pointures" du club, le projet est enfin abouti et prêt à être mis en ligne.
Depuis que j’utilise ce type de souris "liberté" il me serait difficile de revenir à une souris classique.
De plus aucun article sur ce sujet n’a jamais été présenté sur le site Locoduino (à ma connaissance en tous cas).
Cette souris/centrale sera facilement intégrable dans n’importe quelle configuration présentée sur Locoduino grâce à la présence d’un bus CAN dans la centrale.
Voici celle que je vous propose de réaliser :
En quoi consiste le projet ?
Il s’agit de réaliser une centrale 100% DCC (pas d’analogique) commandée par une ou plusieurs souris avec liaison radio (30 et plus sont tout à fait envisageables).
Les caractéristiques sont les suivantes :
La souris :
- Boitier ergonomique, robuste et esthétique équipé d’un clavier alphanumérique.
- Afficheur OLED 1,54’’ très lisible.
- Mise en mémoire (dans la souris) de 59 machines avec leur adresse et leur nom sur 12 caractères.
- Une "liste du jour" de 10 locos sélectionnables directement par appui de la touche * suivi de 0 à 9 du clavier. Chaque loco garde sa vitesse et ses fonctions en mémoire.
- 28 fonctions standards vers DCC et 72 fonctions programmables envoyées sur le bus CAN de la centrale. La fonction lumière affiche une petite ampoule, les autres sont affichées dans la dernière ligne du bas.
- Menu complet avec Liste triée sur nom, Liste triée sur adresse, Création nouvelle loco, Programmation de CVs.
- Programmation automatique des adresses longues et courtes (ce qui modifie automatiquement les CV1, CV29, 17 et 18).
- Programmation en mode POM possible.
- Utilisation 24H en continu sans recharge selon la batterie installée.
La mémoire EEPROM de la souris comporte une "bibliothèque" de 59 locos avec un N° d’ordre, une adresse DCC et un nom. Il est possible de créer très rapidement une "liste du jour" de 10 locos maximum (parmi les 59), c’est avec cette liste qu’on va "jouer". Si le N° d’ordre de la loco est inférieur à 10 la loco est dans la liste du jour.
Je vous propose de feuilleter le mode d’emploi ci-dessous pour vous donner une idée plus précise de ses caractéristiques.
La centrale :
La centrale est équipée de base :
- d’un module Bluetooth (commande par Smartphone possible, programme Android disponible)
- d’un module radio acceptant 6 souris (extensible par modules de 6 souris)
- d’un bus CAN permettant toutes les extensions possibles
- d’une sortie DCC voie MAIN 43A protégée selon les besoins du réseau
- d’une sortie DCC voie de PROGRAMMATION de 3A.
La centrale garde en mémoire les vitesses et fonctions même en cas de coupure de la tension DCC.
Aucune commande ne se trouvant sur la centrale, celle-ci peut être cachée sous le réseau.
Est-il compliqué à réaliser ?
La réalisation de cet ensemble, et principalement de la souris, demande une grande rigueur mécanique, principalement au niveau de la découpe du boitier. Tous les gabarits de découpe, les plans, les schémas, les films CI, les sketchs et la liste des composants sont disponibles sur le site à la fin de cet article. Un circuit imprimé double face+trous métallisés+vernis épargne (pour la souris et pour la centrale) est également disponible sur simple demande.
Au niveau des sketchs, beaucoup "d’anciens" (ayant pratiqué l’assembleur) vont retrouver leur manière de programmer car je ne maîtrise absolument pas, à mon grand regret, le "monde des objets" si cher à Locoduino (à juste titre). Ce sera donc une programmation pas à pas avec un maximum de commentaires pour guider au mieux les utilisateurs.
Le coût de l’ensemble se situe aux alentours de 50€ pour la centrale et 40€ pour la souris.
Réalisation de la souris :
Commençons par le plus difficile, la souris.
Choix du matériel :
- Ecran Oled pour sa qualité d’affichage.
- Codeur incrémental avec bouton poussoir pour garder les vitesses de chaque loco en mémoire.
- Clavier alphanumérique pour saisir facilement les noms des locos.
- Arduino PRO/MINI 3,3V pour pouvoir utiliser une batterie de 3,7V très économique.
- Module radio NRF24L01 pour ses 6 tampons mémoires émission/réception.
Voici le schéma complet de la souris ; ne figure pas les condensateurs de découplages conseillés sur l’alimentation du NRF24L01 ni les liaisons GND de certains composants :
L’écran Oled et le NRF24L01 sont tous les deux contrôlés par le bus SPI du PRO/MINI, avec les bits A1, A2 et A3 pour sélectionner l’écran et les bits 9 et 10 pour sélectionner le NRF.
On utilise l’interruption 0 pour lire les rotations du codeur.
L’entrée A6 a la double fonction de lire le niveau de tension de la batterie à travers le pont de résistances 10K/20K et de lire l’état du bouton d’arrêt d’urgence Stop.
Je me suis gardé les bits 1 et A5 pour pouvoir éventuellement ajouter une mémoire EEPROM (SPI) extérieure de grosse capacité pour les personnes qui possèdent plus de 59 machines à mettre en mémoire.
Le programme de la souris :
J’ai laissé en tête de croquis plusieurs commentaires et liens qui m’ont permis de concevoir ce dernier. N’hésitez pas à consulter ces liens très enrichissants.
Voici les liens pour télécharger les différentes librairies :
Pour l’afficheur : https://github.com/olikraus/u8glib
Pour le NRF24L01 : https://github.com/nRF24/RF24
Pour l’anti-rebonds des touches : https://github.com/thomasfredericks...
Pour le clavier : http://www.arduino.cc/playground/up...
Je ne vais pas commenter le sketch complet, ce serait très vite rébarbatif, je vais juste présenter les blocs principaux avec leurs fonctions.
Les dix premières lignes permettent de modifier rapidement quelques comportements du programme (Attention ! Les N° de lignes ne correspondent pas forcément au programme).
const char version[] = "1.10"; // changer ce numéro pour version
#define tempo_alpha 700 // millisecondes pour touches alphanumériques (700)
#define tempo_touche 500 // millisecondes pour touches fonctions (500)
#define tempo_loco 1000 // millisecondes pour touches locos (500)
#define palier_1 9 // 1er palier de changement d'incrément
#define inc_palier_1 2 // incrément après 1er palier
#define palier_2 20 // 2è palier de changement d'incrément
#define inc_palier_2 5 // incrément après 2è palier
#define palier_3 50 // 3è palier de changement d'incrément
#define inc_palier_3 12 // incrément après 3è palier
// si on veut autoriser la programmation en mode POM, dé-commenter la ligne suivante
// #define aff_pom 1 tempo_alpha permet de modifier la tempo entre 2 appuis successifs des touches alphanumériques
tempo_touche est la tempo maximum pour la saisie de la seconde valeur des touches de fonction qui se fait sur 1 ou 2 chiffres.
tempo_loco idem mais pour la saisie d’une loco dans la liste du jour avec la touche *
Les différents paliers permettent d’incrémenter ou de décrémenter plus rapidement la vitesse de la loco selon la valeur des 3 paliers. Si on ne veut pas utiliser de palier il suffit de mettre palier_1, palier_2 et palier_3 à 128.
Si l’on désire autoriser la fonction "POM" (programmation sur la voie principale), il faut dé-commenter la ligne qui définit "aff_pom". Cela rajoute une option sur la page de programmation des CVs.
Les #include :
#include <Arduino.h>
#include "U8glib.h"
#include <nRF24L01.h>
#include <RF24.h>
#include <Bounce2.h>
#include <EEPROM.h>
#include <Keypad.h> Si vous avez déjà travaillé avec un écran Oled, vous serez certainement surpris du choix de la librairie U8glib.h qui est une ancienne librairie qui n’est plus maintenue et dont l’auteur propose de se rabattre sur la nouvelle version qui est U8g2lib.h.
Ce choix s’est imposé à moi car, d’après mes essais, c’est la librairie qui consomme le moins de mémoire vive et qui permet malgré tout de beaux graphismes. Par contre cela impose une gymnastique un peu particulière pour l’affichage d’une page car à chaque ajout de texte il faut entièrement rafraîchir cette dernière. Une petite explication (en anglais) ici : https://github.com/olikraus/u8glib/...
Les constantes :
// menu
#define MENU_ITEMS 5
const char *menu_strings[MENU_ITEMS] = { "Liste par nom", "Liste par adresse", "Nouvelle Loco", "Gestion CVs", "Quitter" };C’est le menu qui vous est proposé en appuyant la touche # .
Les canaux radio :
// il y a 10 canaux possibles
const uint64_t pipes[] = {0xB3B4B5B601LL, 0xB3B4B5B612LL, 0xB3B4B5B623LL, 0xB3B4B5B634LL, 0xB3B4B5B645LL, 0xB3B4B5B656LL, 0xB3B4B5B667LL, 0xB3B4B5B678LL, 0xB3B4B5B689LL, 0xB3B4B5B69ALL};Pourquoi 10 canaux et non pas 6 comme l’exige le NRF24L01 ?
Au club la centrale est équipée d’une carte radio supplémentaire avec 4 canaux en plus ce qui permet d’utiliser 10 souris en même temps.
Le choix du canal se fait en fonction de la valeur num_souris lue dans l’EEPROM et modifiable par appui de la touche grise (mise en route DCC) au moment de l’allumage de la souris puis la saisie d’un chiffre de 0 à 9. Ce N° s’affiche pendant 2s à l’allumage ainsi que la version du programme.
Les touches alpha-numériques :
const char lettre[10][4] = {
{'Z','Q','-','0'},
{' ',':','+','1'},
{'A','B','C','2'},
{'D','E','F','3'},
{'G','H','I','4'},
{'J','K','L','5'},
{'M','N','O','6'},
{'P','R','S','7'},
{'T','U','V','8'},
{'W','X','Y','9'},
};Ce tableau permet de modifier éventuellement les caractères utilisés pour les noms des locos ; chaque ligne correspond à son chiffre en fin de ligne.
Avant le setup se trouvent les différents sous-programmes d’affichage de pages et quelques fonctions utilisées plus loin dont la très courte routine d’interruption du codeur :
// routine interruption du codeur
void routineInterruption () {
if (digitalRead(PinA)) {
up = !digitalRead(PinB);
}
else {
up = digitalRead(PinB);
}
mouvement = true;
}ou la routine d’affichage de la page "jeu" assez complexe :
void draw_Jeux() { // affiche la page en position JEU
u8g.setFont(u8g_font_6x13);
u8g.setFontRefHeightText();
u8g.setFontPosTop();
// Afficher la ligne d'état
sprintf(ligne1, " Ordre:%d Adr:%d", ordre, adresse_loco);
u8g.drawStr(0, 0, ligne1);
// Afficher le nom de la loco ou Loco ? si choix loco en cours
u8g.setFont(u8g_font_helvB12); // hauteur 12 pixels GRAS 64%
if (choix == 0) {
for (i = 0; i < 16; i++) {
ligne1[i] = nom_loco[i]; // initialiser avec la loco 0
}
d = ((128 - u8g.getStrWidth(ligne1)) / 2);
u8g.drawStr(d, 28, ligne1);
}
else {
u8g.drawStr(42, 28, "Loco ?"); // Afficher le nom de la loco ou Loco ? si choix loco en cours
}
// Afficher ampoule si fonction 0 activée
if (fonction[ordre][0]) {
u8g.drawCircle(centre_co, centre_li, 4);
u8g.drawLine(15, centre_li - 8, 15, centre_li - 6);
u8g.drawLine(15, centre_li + 6, 15, centre_li + 8);
u8g.drawLine(centre_co - 8, centre_li, centre_co - 6, centre_li);
u8g.drawLine(centre_co + 6, centre_li, centre_co + 8, centre_li);
u8g.drawLine(centre_co - 7, centre_li - 6, centre_co - 5, centre_li - 4); // "\"
u8g.drawLine(centre_co + 5, centre_li - 4, centre_co + 7, centre_li - 6); // "/"
u8g.drawLine(centre_co - 7, centre_li + 6, centre_co - 5, centre_li + 4); // "/"
u8g.drawLine(centre_co + 5, centre_li + 4, centre_co + 7, centre_li + 6); // "\"
}
// Afficher la vitesse
if (tension == 1) {
cpt = crans[ordre]; // crans[] = crans réels envoyés, cpt = crans affichés à l'écran
sens[ordre] = 1;
if (crans[ordre] > 0) {
sprintf(buf, "%3d >", cpt + 2);
d = ((128 - u8g.getStrWidth(buf)) / 2) + 10;
}
else if (crans[ordre] == 0) {
sprintf(buf, "%3d", 0);
d = ((128 - u8g.getStrWidth(buf)) / 2);
}
else if (crans[ordre] < 0) {
cpt = - crans[ordre];
sprintf(buf, "< %d", cpt + 2);
sens[ordre] = 0;
d = ((128 - u8g.getStrWidth(buf)) / 2) - 6;
if (d < 0) {
d = 0;
}
}
}
else if (tension == 0) {
sprintf(buf, "%s", "STOP");
d = 40;
}
else {
sprintf(buf, "%s", "DISJONCTE");
d = 9;
}
u8g.drawStr(d, 46, buf);
// afficher niveau batterie
u8g.setFont(u8g_font_6x13);
u8g.setFontRefHeightText();
u8g.setFontPosTop();
u8g.drawFrame(106, 38, 22, 9);
if (moyenne > 0) {
byte volt = 0; //(0 = 1 barre, 5 = 6 barres)
if (moyenne > 850) { // 6 barres
volt = 5;
}
else if (moyenne > 829) { // 5 barres
volt = 4;
}
else if (moyenne > 808) { // 4 barres
volt = 3;
}
else if (moyenne > 787) { // 3 barres
volt = 2;
}
else if (moyenne > 766) { // 2 barres
volt = 1;
}
else if (moyenne > 745) { // 1 barre
volt = 0;
}
for (byte i = 0; i <= volt; i++) {
u8g.drawLine((i * 3) + 109, 40, (i * 3) + 109, 44);
}
}
// Afficher les fonctions
d = 0; // au départ afficher à partir de gauche
if (w > 128) {
d = -(w - 128); // si ligne trop longue, décaler à gauche
}
u8g.drawStr(d, 54, ligne2); // n'afficher que la fin de la ligne des fonctions
}Le setup :
//Serial.begin (9600); // Initialisation du port série
ordre = EEPROM.read(1020); // lire la dernière loco utilisée en EEPROM
contraste = EEPROM.read(1021); // récupérer dernier contraste en EEPROM
num_souris = EEPROM.read(1022); // lire le numéro de souris en EEPROM
PTXpipe = pipes[num_souris]; // récupérer le canal correspondant
rech_loco_ordre(ordre); // chercher les infos de la dernière loco utilisée
attachInterrupt (0,routineInterruption,CHANGE);
pinMode(btn_STOP,INPUT_PULLUP);
pinMode(btn_START,INPUT_PULLUP);
pinMode(PinA,INPUT_PULLUP);
pinMode(PinB,INPUT_PULLUP);
pinMode(btn_codeur,INPUT_PULLUP);
boun_btn_codeur.attach(btn_codeur);
boun_btn_codeur.interval(10);
radio.begin();
radio.setPALevel(RF24_PA_MAX); //RF24_PA_MIN, RF24_PA_LOW, RF24_PA_HIGH and RF24_PA_MAX
radio.setChannel(108); //canal 108 au dessus des canaux WiFi (de 0 à 125)
radio.setDataRate( RF24_250KBPS ) ; // 250Kbps pour max distance
radio.openReadingPipe(0, PTXpipe); // ouvrir le canal PTXpipe en réception
radio.openWritingPipe(PTXpipe); // ouvrir un canal en émission avec même adresse
radio.stopListening(); // se mettre en émission
crans[ordre] = 0;
mouvement = false;
// Lecture niveau batterie, RAZ du tableau d'échantillons
for (int i = 0; i < nEchantillons; i++) {
echantillon[i] = 0;
}
u8g.begin();
u8g.setContrast(contraste); // mettre le contraste qui a été lu en EEPROM
dateDernierAffichage = - 52000; // forcer affichage niveau batterie après 8s
// créer la liste des locos non triée
for (int i = 0; i < nb_max_enr; i++) {
listeTriee[i] = i;
}
// Test si bouton gris appuyé au démarrage pour réglage numéro souris
if (analogRead(btn_START) < 20) {
type_affichage = 8;
menu = 8;
}Le Serial.begin est supprimé pour gagner de la place en mémoire flash et RAM.
Il peut être remis en service à des fins de débogage en supprimant momentanément la police "u8g_font_helvB12" en mettant toutes les lignes qui l’utilisent en commentaire ce qui libère pas mal de mémoire.
Le NRF24L01 est utilisé de façon un peu particulière en lui attribuant le même canal pour l’émission et la réception. C’est ce qui permet d’utiliser 6 souris (avec une centrale de base sans l’extension radio).
Le setup configure l’interruption pour le codeur, les bits E/S, le module radio NRF24L01 et récupère toutes les infos sauvegardées en EEPROM : Le N° de canal de la souris, la dernière loco utilisée et le dernier contraste affiché.
La loop :
Désolé pour les explications un peu (voire très) succinctes de la partie la plus conséquente du programme mais vue la longueur (encore le monde des objets qui manque) je ne me vois pas commenter ces 748 lignes de code, et n’en faire qu’une petite partie ne vous apporterait pas grand chose. Je suis à votre disposition pour répondre à toutes vos demandes à la fin de cet article ou via le Forum.
En voici en tous cas les blocs principaux :
Ligne 636 à 673 : Boucle d’affichage selon la valeur de la variable "type_affichage".
Ligne 676 à 699 : On teste si une trame radio est détectée, suivi de l’envoi d’une éventuelle réponse.
Ligne 701 à 836 : Test et actions en fonction de la rotation du codeur incrémental. Les commentaires vous orienteront si besoin.
Ligne 837 à 863 : On n’envoie les commandes DCC que toutes les 500 ms.
Ligne 869 à 929 : Test des boutons STOP (rouge).
Ligne 931 à 974 : Test des boutons START (gris).
Ligne 977 à 1200 : Très long test du bouton du codeur avec actions correspondantes selon la page dans laquelle on se trouve.
Ligne 1204 à 1343 : Test du clavier alphanumérique et actions selon page.
Ligne 1345 à 1355 : Test de la tempo pour la saisie des différents caractères des touches du clavier.
Ligne 1357 à 1360 : Test de la tempo pour les touches de fonction.
Ligne 1362 à 1370 : Test de la tempo pour les touches de choix de loco.
Ligne 1373 à 1384 : Lecture du niveau batterie avec moyenne glissante, sujet très intéressant à voir ici: : http://arduino.blaisepascal.fr/inde...
Les ligne 977 à 1343 représentent Le gros du programme avec une tripotée de "if" que j’ai essayé de remplacer par des "case" mais sans que cela ne fasse gagner de la mémoire, donc abandonné. C’est dans cette partie que tout se passe pour gérer l’appui des touches, afficher un "pseudo" curseur ( il n’existe pas de curseur dans la bibliothèque U8glib.h), limiter le nombre de caractères saisis, annuler ou valider une action, etc. L’orientation se fait principalement en fonction de la variable "menu" qui est définie par la validation d’une des lignes du menu.
La aussi les commentaires sont nombreux et peuvent éclairer votre route.
La fabrication de la souris
Voici les dimensions du boitier :
Un des objectifs pour la fabrication de la souris était de mettre tous les composants sur un seul circuit imprimé avec le clavier, l’écran et le microcontrôleur sur picots enfichables pour en faciliter le remplacement en cas de panne. Cela impose 2 types de picots pour une question d’encombrement vertical et que vous retrouverez sur la liste des pièces.
La partie la plus difficile car la plus précise, sera la préparation du boitier avec toutes les découpes nécessaires pour accueillir cet unique circuit imprimé qui sera bloqué entre les 2 demis-coques du boitier sans aucune fixation. Il faudra suivre scrupuleusement le gabarit de découpe fourni.
Pour la fabrication proprement dite j’avais commencé par mettre toutes les photos et tous les commentaires directement dans cet article mais pour une plus grande lisibilité j’ai préféré tout intégrer dans le document PDF ci-dessous.
Attention ! Très important. Il faut impérativement souder une capa de 10µF/16V directement sur les pins du NRF24L01, si vous la mettez sous le PCB il n’y a aucune amélioration. Cette modification est également valable pour la centrale.
Le câblage du circuit imprimé
Il faut bien respecter les hauteurs des différents composants pour que le boitier se ferme sans forcer. Pour cela le microprocesseur PRO/MINI 3,3V ne peut pas être monté avec les picots mâles prévus pour le support bas profil.
Dans le document PDF ci-après vous trouverez l’explication pour son montage un peu particulier. Je voulais surtout éviter de le souder directement sur le CI pour faciliter son remplacement en cas de panne.
Liste des pièces
J’ai mis la liste des pièces dans un fichier Excel qui facilite la récupération des liens correspondants aux pièces principales.
Le circuit imprimé est disponible dans ce zip au format Gerber et Excellon mais aussi au format Sprint-Layout6.0 pour lequel il existe un lecteur gratuit ici : https://www.electronic-software-sho...
Pour ma part je travaille depuis pas mal de temps avec https://jlcpcb.com/ pour la qualité des circuits et leur prix, sauf pour les frais de port où il ne faut surtout pas choisir DHL sinon gare aux frais de douane. J’ai toujours utilisé l’option ePacket avec 0€ de frais de douane.
Je peux également vous faire parvenir par courriel les fichiers au format bmp.
Vous pouvez aussi obtenir le circuit imprimé en qualité professionnelle en me contactant en MP (messagerie privée). Si le montage vous semble hors de portée vous pouvez me contacter de la même manière.
La Centrale
Nous abordons ici la partie la plus facile et la plus libre de l’article.
Comme je vous l’ai déjà précisé plus haut, cette centrale tel qu’elle est conçue, ne fonctionne qu’en DCC avec le logiciel DCCpp de Thierry dont vous trouverez un article ici : https://www.locoduino.org/spip.php?.... Libre à vous de la modifier pour l’utiliser en analogique.
Vous trouverez une documentation complète de cette bibliothèque dans le dossier \libraries\DCCpp\extras\Doc\ et en cliquant sur index.html.
Voici son schéma :
Elle est basée sur un Arduino MÉGA car il est impossible d’utiliser le bus SPI d’un UNO puisque le bit 12 (Miso) est utilisé pour le DIR du booster de la voie principale, voir ici : http://www.locoduino.org/spip.php?a...
Ce MÉGA gère une carte NRF24L01 pour l’émission/réception radio, une carte CAN pour l’ouvrir à toutes sortes d’extensions, une carte Bluetooth et commande les 2 boosters DCC.
Pour la voie principale j’ai fait le choix d’un module BTS7960B qui est capable de supporter 43A mais que le programme va bien sûr limiter à une valeur bien plus réaliste et que vous pourrez adapter à votre réseau, ceci grâce à ses sorties R_IS et L_IS envoyées sur l’entrée analogique A0 et qui donne une valeur proportionnelle au courant consommé.
Cette entrée n’est plus géré par le logiciel DCCpp (qui est le cœur du programme) mais par une routine personnelle qui me permet de traiter les courts-circuits d’une façon un peu particulière. A la détection d’un court-circuit, la centrale va se rallumer automatiquement 3 fois de suite avec un intervalle de 200ms (ajustable avec une constante en début de programme) afin d’absorber les petits courts-circuits qui peuvent se produire au passage de certaines aiguilles selon les locos ou wagons. Cette spécificité a trouvé un grand succès auprès des membres du club qui étaient obligés de remettre en marche très souvent leur ancienne centrale du fait de l’usage de machines parfois assez exotiques.
Attention ! Il semblerait que la tension renvoyé pour la mesure de courant du BTS7960B soit très variable d’un module à un autre. Le mieux est de décommenter la ligne 642 pour afficher les valeurs réelles lues puis d’adapter la consigne "Courant_Max" en ligne 2 avec une marge confortable.
Pour la voie de programmation le booster est un produit beaucoup plus traditionnel puisqu’il s’agit du LMD18200 suivi d’un MAX471 pour la lecture du courant. Je précise, pour les débutants, que cette mesure de courant a énormément d’importance car c’est grâce à elle que la centrale peut lire les informations des CVs.
L’Arrêt d’urgence peut vous paraitre assez originale puisque je force le MÉGA à faire un reset. J’ai fait ce choix car il permet dans tous les cas, même après un "plantage" du programme de repartir avec les sorties DCC à 0.
Attention ! Très important. Il faut impérativement souder une capa de 10µF/16V directement sur les pins du NRF24L01, si vous la mettez sous le PCB il n’y a aucune amélioration.
Le programme
Attention ! Le cœur du programme est DCCpp comme déjà annoncé, mais j’ai du faire une modification au niveau de la librairie que vous trouverez ici : https://github.com/Locoduino/DCCpp/...
Dans config.h ligne 23 : MAX_MAIN_REGISTERS passe de 12 à 24
En tête du programme vous trouverez quelques paramètres pour adapter le programme à votre usage.
// Version = 1.00;
#define Courant_Max 1000 // courant maximum avant disjonction
#define Boucle_Lec_Courant 2 // boucle de lecture courant
#define tempo_CC 200 // nb de millisecondes avant rétablissement tension DCC
#define YESICAN // à commenter si pas de module CAN installéCourant_Max comme son nom l’indique est la valeur maximum autorisée avant de couper le DCC.
Boucle_Lec_Courant est le nombre de boucle que l’on autorise avec une valeur de courant dépassée avant de couper le DCC.
tempo_CC est le temps avant rétablissement automatique de la tension DCC (3 fois)
Il faudra jongler avec ces 3 paramètres pour adapter la gestion des courts-circuits à votre réseau.
Les #include :
#include "DCCpp.h"
#ifndef USE_TEXTCOMMAND
#error To be able to compile this sample,the line #define USE_TEXTCOMMAND must be uncommented in DCCpp.h
#endif
#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>
#ifdef YESICAN
#include <mcp_can.h>
#endifOù trouver les librairies :
Pour la carte CAN : https://github.com/Locoduino/CAN_BU...
Pour le NRF24L01 : https://github.com/nRF24/RF24
Les constantes :
const unsigned int ad_reception_carte1= 0x100;
const unsigned int ad_reception_carte2= 0x101;
const unsigned int ad_emission_carte1 = 0x200;
const unsigned int ad_emission_carte2 = 0x300;
const unsigned int nb_char_recu = 1; // nombre de caractères à reçevoir
const unsigned int nb_char_emis = 1; // nombre de caractères à emettre
boolean _dumpCan = true; // mode débogageCe sont les constantes utilisées pour les échanges avec le bus CAN. Il faudra bien sûr les adapter à votre "philosophie" personnelle.
const uint64_t pipes[] = {0xB3B4B5B601LL, 0xB3B4B5B612LL, 0xB3B4B5B623LL, 0xB3B4B5B634LL, 0xB3B4B5B645LL, 0xB3B4B5B656LL};
Contrairement à la souris, la centrale n’autorise que 6 canaux radio différents. Si l’on désire augmenter le nombre de canaux il faudra ajouter une carte optionnelle qui va gérer les 4 canaux supplémentaires. Description et CI sur simple demande.
// locos
#define nb_max_locos 12 // Nb de locos max mises en mémoireCette valeur ne doit pas être modifiée car elle est liée à la valeur MAX_MAIN_REGISTERS de DCCpp. Nous utilisons 12 registres pour la mise en mémoire des vitesses de 12 locos et 12 registres pour la mise en mémoire des fonctions de ces 12 locos. Alors pourquoi MAX_MAIN_REGISTERS = 24 ce qui ferait 25 registres ? Tout simplement parce que le registre 0 ne peut pas être utilisé de la même façon. Je vous reparlerai de ce sujet (sensible) plus loin.
Le setup :
void setup()
{
Serial.begin(9600);
Serial1.begin(9600);
Serial.println("OK pour connecter CAN!");
START_INIT:
if (CAN_OK == CAN.begin(CAN_250KBPS)) { // init can bus : baudrate = 250k
if (_dumpCan) {
Serial.println("CAN BUS Shield init ok!");
}
}
else {
if (_dumpCan) {
Serial.println("CAN BUS Shield init fail");
}
delay(100);
goto START_INIT;
}
/*
configurer mask & filter du bus CAN
*/
CAN.init_Mask(0, 0, 0b11111111111); // Il y a 2 masques à initialiser dans le mcp2111
CAN.init_Mask(1, 0, 0b11111111111); // on teste tous les bits
CAN.init_Filt(0, 0, ad_reception_carte1); // Réception possible : que 2 adresses
CAN.init_Filt(1, 0, ad_reception_carte1); // idem
CAN.init_Filt(2, 0, ad_reception_carte1); // idem
CAN.init_Filt(3, 0, ad_reception_carte2); // idem
CAN.init_Filt(4, 0, ad_reception_carte2); // idem
CAN.init_Filt(5, 0, ad_reception_carte2); // Idem
// configurer l'interruption
attachInterrupt(2, MCP2515_ISR, FALLING); // interrupt 2 (pin 21)Si vous n’installez pas la carte CAN, il faudra commenter la ligne (5 dans le programme) pour éviter de boucler sur la configuration du module CAN.
// lancement radio
radio.begin();
radio.setPALevel(RF24_PA_MAX); //RF24_PA_MIN, RF24_PA_LOW, RF24_PA_HIGH and RF24_PA_MAX
radio.setChannel(108); //canal 108 au dessus des canaux WiFi (de 0 à 125)
radio.setDataRate( RF24_250KBPS ) ;
// ouvrir 6 canaux de réception radio
radio.openReadingPipe(0, pipes[0]);
radio.openReadingPipe(1, pipes[1]);
radio.openReadingPipe(2, pipes[2]);
radio.openReadingPipe(3, pipes[3]);
radio.openReadingPipe(4, pipes[4]);
radio.openReadingPipe(5, pipes[5]);
radio.startListening(); // passer en réceptionOn configure les 6 canaux radio
// Lancement DCC
DCCpp::begin();
DCCpp::beginMain(UNDEFINED_PIN, DCC_SIGNAL_PIN_MAIN, 3, UNDEFINED_PIN ); //en mettant UNDEFINED_PIN à la place de A0,plus de test de courant par DCC, il y a une routine spécifique dans le loop
DCCpp::beginProg(UNDEFINED_PIN, DCC_SIGNAL_PIN_PROG, 11, A1);
Serial.println("SerialDcc OK");On lance DCCpp en supprimant le test de courant par A0 avec le UNDEFINED_PIN puisque nous voulons utiliser notre propre routine de lecture de courant.
// mise à 0 des tableaux de fonctions et adresses locos
for (int nb_loc = 0; nb_loc < nb_max_locos; nb_loc++) {
adr_loc[nb_loc] = 0;
tab_fonc_B0_4[nb_loc] = 128;
tab_fonc_B5_8[nb_loc] = 176;
tab_fonc_B9_12[nb_loc] = 160;
tab_fonc_B0_43_2[nb_loc] = 0;
tab_fonc_B0_28_2[nb_loc] = 0;
}Nous initialisons 1 tableau pour les adresses des 12 locos et 5 tableaux pour la sauvegarde des fonctions de ces 12 machines.
Peut-être l’avez-vous remarqué si vous utilisez déjà DCCpp, mais en cas de mauvais contacts sur les rails ou de coupure de la tension DCC, les fonctions de toutes les locos sont remises à 0 ce qui est très gênant surtout si l’on fait circuler plusieurs convois en même temps.
// envoyer l'info tension coupée sur les souris
//start_DCC(); // si demande de tension DCC à l'allumage, dé-commenter cette ligne
envoi_etat();
}Dans l’état actuel du programme, à l’allumage de la centrale, la tension DCC est à 0. Si vous préférez avoir du DCC à l’allumage il suffit de dé-commenter la ligne "start_DCC() ;".
La loop :
La ligne 283 lance le rafraîchissement des routines DCCpp
De 288 à 389 on teste la réception radio qui appelle quelques commentaires.
if (radio.available(&pipeNum)) { // tester si une trame est arrivée,
char c_cv[2];
radio.read(&dcc_receive, sizeof(dcc_receive)); // sizeof(dcc_receive) est toujours à 8
if(dcc_receive[0] == '<') { // ne traiter que si trame commence par <
if(dcc_receive[1] == 1) { // "1" = trame allumer DCC
start_DCC(); // utiliser de ce programme pour allumer DCC
cpt_cc = 0; // permettre à nouveau 3 CC de 0,5s
old_etat = 10; // pour forcer l'envoi de l'état
delay(100); // laisser le temps à la souris de passer en réception
}
else if(dcc_receive[1] == 0) { // "0" = trame couper DCC
stop_DCC(); // utiliser de ce programme pour couper DCC
old_etat = 10; // pour forcer l'envoi de l'état
delay(100); // laisser le temps à la souris de passer en réception
}
else {
if(dcc_receive[1] == 't') { // 't' = trame vitesse
adr_loco_H = dcc_receive[2];
adr_loco_L = dcc_receive[3];
adresse_loco = restaure_adr(); // restaure l'adresse complète à partir de HI et LOW
crans = dcc_receive[4]; // non utilisé pour l'instant
sens = bitRead(dcc_receive[5], 7); // le sens est déterminé par le bit 7 de vitesse
vitesse = dcc_receive[5] & 0b01111111 ; // mettre bit 7 à 0
enregistre_loc(); // enregistre la nouvelle loco ou récupère son ID si existe
// ici on change de registre de vitesse selon loco, ne pas utiliser registre 0 donc +1
DCCpp::setSpeedMain(ordre_loc + 1, adresse_loco, 128, vitesse, sens);
}
else if(dcc_receive[1] == 'W') { // "W" = trame écriture CV sur voie de programmation
envoi[pipeNum] = true; // pour forcer un retour du résultat
adr_cv[pipeNum] = dcc_receive[2];
// assembler les 2 bytes pour refaire valeur INT
adr_loco_H = dcc_receive[3];
adr_loco_L = dcc_receive[4];
don_cv = restaure_adr(); // restaure valeur complète à partir de HI et LOW
if(adr_cv[pipeNum] == 1 and don_cv < 128) {
// c'est une adresse courte pour cv1
DCCpp::writeCvProg(adr_cv[pipeNum], don_cv, 100, 200); // écriture de CV1
// mettre bit 5 de CV29 à 0 pour adresse courte
byte cv_29 = DCCpp::readCvProg(29, 100, 200);
bitWrite(cv_29, 5, 0);
DCCpp::writeCvProg(29, cv_29, 100, 200);
}
else if(adr_cv[pipeNum] == 1) {
// c'est une adresse longue pour cv1, donc on calcul les valeurs de CV17 et CV18
int deb=0;
int fin=0;
int res=0;
int cv17=192; // laisser cv17 à 192 pour calcul
int cvres=0;
for (int i = 0;i <= 9984;i = i + 256) {
deb = i;
fin= i + 255;
if ((don_cv >= deb)&&(don_cv <= fin)){
res = don_cv - i;
cvres = cv17;
}
cv17 = cv17 + 1;
}
// mettre bit 5 de CV29 à 1 pour adresse longue
byte cv_29 = DCCpp::readCvProg(29, 100, 200);
bitWrite(cv_29, 5, 1);
DCCpp::writeCvProg(29, cv_29, 100, 200);
DCCpp::writeCvProg(17, cvres, 100, 200); // écriture de CV17
DCCpp::writeCvProg(18, res, 100, 200); // écriture de CV18
}
else { // pour tous les autres cv, envoyer trame
DCCpp::writeCvProg(adr_cv[pipeNum], don_cv, 100, 200);
}
}
else if(dcc_receive[1] == 'R') { // "R" = trame lecture CV
adr_cv[pipeNum] = dcc_receive[2];
envoi[pipeNum] = true; // la lecture se fait dans test envoi[pipeNum]
}
else if(dcc_receive[1] == 'f') { // "f" = trame fonctions locos
adr_loco_H = dcc_receive[2];
adr_loco_L = dcc_receive[3];
adresse_loco = restaure_adr(); // restaure l'adresse complète à partir de HI et LOW
etat_fct = bitRead(dcc_receive[4], 7); // le sens est déterminé par le bit 7 de vitesse
num_fct = dcc_receive[4] & 0b01111111 ; // mettre bit 7 à 0
if(num_fct < 29) { // n'envoyer sur loco que les 28 premières fonctions
enregistre_loc(); // enregistre la nouvelle loco ou récupère son ID si existe
// envoyer la fonction
if (etat_fct) {
gLocoFunctions[ordre_loc].activate(num_fct);
} else {
gLocoFunctions[ordre_loc].inactivate(num_fct);
}
// MAJ registre loco
DCCpp::setFunctionsMain(ordre_loc + 13, adresse_loco, gLocoFunctions[ordre_loc]);
}
else { // les fonctions > 28 sont envoyées sur bus CAN avec bit 7 en l'état
ordres_carte1 = dcc_receive[4];
}
}
else if(dcc_receive[1] == 119) { // "w" = trame programmation POM
adr_cv[pipeNum] = dcc_receive[2];
don_cv = dcc_receive[3];
DCCpp::writeCvMain(adr_cv[pipeNum], don_cv, 100, 200);
}
}
}
}Tout d’abord on n’accepte que des trames délimitées par < et >
Les trames <0> et <1> coupent ou mettent en route la tension DCC.
Les trames commençants par "t" sont les trames de réglage de vitesse que l’on va sauvegarder dans les registres 1 à 12. Pour ce faire on va enregistrer l’adresse de chaque nouvelle loco mise sur les rails (dont on reçoit une commande) dans un tableau dont le pointeur va s’incrémenter de 0 à 11, c’est le tableau adr_loc[]. Si on dépasse les 12 locos sans avoir initialisé la centrale les 6 tableaux (adresses et fonctions) sont remis à 0.
Puis on utilise ce pointeur (ordre_loc) pour enregistrer l’adresse, les crans, la vitesse et le sens dans les registres 1 à 12 :
DCCpp::setSpeedMain(ordre_loc + 1, adresse_loco, 128, vitesse, sens);
Les trames commençants par "W" sont les trames d’écriture de CV sur la voie de programmation. On oriente le programme différemment s’il s’agit d’une adresse longue (supérieure à 127) ou courte. Pour le CV1 on réécrit le CV29 puis les CV17 et 18 selon les normes NMRA et on positionne un drapeau (envoi[]) pour signaler qu’un retour d’information est à envoyer à la souris :
envoi[pipeNum] = true; // pour forcer un retour du résultat
DCCpp::writeCvProg(29, cv_29, 100, 200);
DCCpp::writeCvProg(17, cvres, 100, 200); // écriture de CV17
DCCpp::writeCvProg(18, res, 100, 200); // écriture de CV18Pour les autres CVs on positionne le même drapeau et on écrit la valeur demandée :
envoi[pipeNum] = true; // pour forcer un retour du résultat
DCCpp::writeCvProg(adr_cv[pipeNum], don_cv, 100, 200);Les trames commençants par "w" sont les trames d’écriture de CV sur la voie principale en mode "POM". Cette programmation ne permet pas de retour d’information :
DCCpp::writeCvMain(adr_cv[pipeNum], don_cv, 100, 200);
Les trames commençants par "R" sont les trames de lecture de CV sur la voie de programmation. Cela se fait ici en positionnant aussi le drapeau de retour :
adr_cv[pipeNum] = dcc_receive[2];
envoi[pipeNum] = true; // la lecture se fait dans test envoi[pipeNum]Les trames commençants par "f" sont les trames de fonctions que l’on va sauvegarder dans l’un des 5 registres.
Si ce sont des fonctions standards de 0 à 28, on les envoie à DCCpp par :
DCCpp::setFunctionsMain(ordre_loc + 13, adresse_loco, gLocoFunctions[ordre_loc]);
Si la fonction est supérieure à 28 on va l’envoyer sur le bus CAN, information qui sera récupérée par l’une des cartes connectée sur le bus et qui fera l’action que vous aurez programmé ; cela peut être une animation quelconque, un son (parmi plusieurs) fourni par une carte que je suis entrain de développer, une commande d’aiguille etc...
Retour d’information
if (envoi[pipeNum] and etat) { // récupérer la donnée à lire à l'adresse adr_cv et l'envoyer par radio mais que si loco sous tension (etat = true)
char text[7];
if (adr_cv[pipeNum] == 1) { // si on lit le CV1, tester si adresse longue ou non
int CV_29 = DCCpp::readCvProg(29, 101, 101);
int CV_17 = DCCpp::readCvProg(17, 101, 101);
int CV_18 = DCCpp::readCvProg(18, 101, 101);
if (bitRead(CV_29, 5) == 1) { // on est en adresse longue
sav_don_cv[pipeNum] = ((CV_17 - 192) * 256 ) + CV_18; // reconstruire adresse longue
sprintf(text, "R%d", sav_don_cv[pipeNum]); // on renvoi l'adresse longue lue
}
else {
int monINT = DCCpp::readCvProg(adr_cv[pipeNum], 101, 101); // lecture CV1 (adr courte)
sprintf(text, "R%d", monINT); // réponse bonne ou fausse
}
}
else { // si on lit les autres CV, retourner simplement sa lecture
int monINT = DCCpp::readCvProg(adr_cv[pipeNum], 101, 101); // lecture du CV demandé
sprintf(text, "R%d", monINT); // réponse bonne ou fausse
}
radio.stopListening(); // passer en émission
radio.openWritingPipe(pipes[pipeNum]); // utiliser le canal de celui qui a envoyé la demande
radio.write(&text, sizeof(text));
delay(5);
radio.startListening(); // passer en réception
envoi[pipeNum] = false;
}Si le drapeau relatif à la loco N° [pipeNum] est à true on renvoie la lecture du ou des CVs vers la souris.
Gestion du Bluetooth
while (Serial1.available()>0) { // Tant que données série arrivent
char c = Serial1.read();
if (c == '<') { // début de la trame
cmdBlue[0] = 0;
}
else if (c == '>') { // fin de la trame
TextCommand::parse(cmdBlue); // on envoie traiter la trame
}
else if (strlen(cmdBlue) < MAX_COMMAND_LENGTH) { // s'il reste de la place dans le tableau
sprintf(cmdBlue, "%s%c", cmdBlue, c); // continuer jusqu'au >
}Le module Bluetooth est relié sur l’entrée Serial1 du MÉGA. Si une information arrive par ce biais on l’envoie directement vers DCCpp.
Pour l’instant je ne traite pas la mise en mémoire des informations venues par le Bluetooth mais il est tout à fait possible de les gérer de la même manière que les informations venants de la souris. Avis aux amateurs.
Le reste du programme me semble suffisamment commenté pour ne pas rallonger inutilement cet article. N’hésitez pas à me contacter à la fin de cet article ou sur le forum si vous avez des questions.
La fabrication de la centrale
Pour la fabrication de la centrale toutes les possibilités existent selon le boitier, le budget, la présentation que vous souhaitez etc...
Pour câbler les différents composants vous pouvez utiliser un Protoshield MÉGA sur lequel vous implantez le module NRF24L01, le module Bluetooth, le transistor inverseur, éventuellement la carte CAN ainsi que tous les connecteurs nécessaires pour relier le 0 et 5V, les boosters, les entrées lecture courant, le bouton STOP et la sortie CAN.
Les boosters et le MAX471 sont montés séparément.
Pour ma part j’ai fait faire un circuit imprimé qui regroupe tous ces éléments ce qui facilite énormément le montage. Ce circuit est disponible de la même manière que celui de la souris.
J’ai facilement intégré tous les éléments dans ce boitier dont le lien est dans la liste des pièces et qui fait 180x135x55mm :
Option
Comme je vous l’ai signalé plus haut, il est possible d’étendre le nombre de souris avec un module additionnel.
Ce module comporte un Arduino NANO, une carte NRF24L01 et un module CAN et voici son circuit imprimé (également disponible en fichiers ou physiquement) :
Je vous laisse approfondir cet article et me poser toutes les questions que vous jugerez utiles ; je suis également ouvert à toutes les améliorations ou suggestions qui feraient évoluer ce produit.
Plusieurs personnes ayant eu des soucis avec la librairie de l’afficheur U8glib, voici celle que j’utilise te qui est fonctionnelle.
55 Messages
-
Souris et centrale sans fil 25 novembre 2018 15:34, par msport
Bravo Tony pour cette réalisation de niveau professionnel.
Beaucoup d’excellentes idées à prendre même si on ne la fait pas telle que, en raison de choix structurants antérieurs.
Et bien sur merci pour le partage et à Locoduino qui l’a permis.-
Merci à toi Michel pour ce bel encouragement,
un premier article est toujours un peu stressant mais j’espère qu’il apportera beaucoup de satisfaction aux courageux lecteurs qui vont réaliser ce projet.
-
-
Souris et centrale sans fil 25 novembre 2018 22:38, par petitrain
Bravo, pour cet énorme travail et bravo pour le partage....
Nul doute que cette nouvelle centrale va faire bien des heureux avec les fêtes de fin d’année qui approchent....-
Merci aussi à toi Gérard qui a vu naitre le bébé au fil des semaines,
tes encouragements m’ont beaucoup aidés dans les moments de doute, et surtout n’oublie pas que tu es le grand responsable de la naissance de ce projet...
Maintenant on va en profiter pour "jouer au train"
-
-
Souris et centrale sans fil 28 novembre 2018 14:59, par bobyAndCo
Voici une nouvelle façon de profiter de l’excellent DCC++ ! Merci Tony.
Plein de choses également dont on peut tirer profit dans cet article au delà de la commande des trains : du CAN, du Bluetooth...
Pour ma part, je suis intéressé pour savoir comment tu utilises le BTS7960B. Sur ton schéma on voit que tu as ajouté quelques composants dont un transistor, mais la définition de l’image ne permet pas de distinguer suffisamment.
Est-ce que tu pourrais fournir un schéma plus grand et la liste des composants.
Bien amicalement
Christophe
-
Bonjour Christophe,
je suis très content d’apporter à mon tour un peu quelque chose à notre site préféré.
Pour le schéma de mon booster, je te l’envoie en MP car je ne sais pas comment le faire sur cette page. Par contre je te mets le lien qui m’a permis de le réaliser. J’utilise ce montage depuis mes tout début en DCC et en suis enchanté.
Amicalement
AntoineVoir en ligne : Booster avec BTS7960B
-
-
Souris et centrale sans fil 3 décembre 2018 14:46, par bagou91
Très bon article !
Je m’empresse d’acheter les composants pour réaliser cette centrale :)J’essaierai également de reproduire le boitier de la souris en fichier 3D et le mettrai en partage.
-
Bonsoir bagou91,
merci pour votre appréciation, le boitier en impression 3D est une excellente idée, je viens moi-même de m’en acheter une mais n’en suis qu’au tout début, surtout pour le logiciel.
Je précise à nouveau que les 3 circuits imprimés sont disponible pour ceux qui ne veulent pas les fabriquer.
-
-
Souris et centrale sans fil 10 décembre 2018 18:41, par tony04
On vient de me signaler que le gabarit de perçage était manquant ;
c’est corrigé, vous le trouverez en téléchargement sous l’image "Gabarit de découpe", désolé pour ceux qui le cherchaient désespérément. -
Souris et centrale sans fil 10 décembre 2018 18:50, par tony04
Une petite nouveauté sur cet ensemble pour ceux qui seraient intéressés par un fonctionnement en 28 crans très utile pour des petites machines qui ne roulent pas très vite.
Une demande m’a été faite pour cet option et j’ai développé une version 1.20 qui permet de configurer les machines en 28 ou 128 crans. Il est également possible de changer de mode pendant le jeu et cela pour n’importe quelle loco avec mise en EEPROM de l’info.
Si cette option vous intéresse contactez moi en MP pour que je puisse vous l’envoyer. -
Souris et centrale sans fil 21 décembre 2018 13:56, par tony04
Plusieurs personnes m’ont signalé l’impossibilité d’utiliser la librairie U8glib que j’ai proposé avec le lien plus haut.
J’ai rajouter tout à la fin de l’article la librairie que j’ai utilisé en fichier zip à télécharger.
Il faudra penser à bloquer la mise à jour des librairies dans l’IDE pour ne pas se retrouver avec la dernière version.-
Il semblerait que le lien de téléchargement du fichier zip ne fonctionne pas alors que dans la page de rédaction tout est OK.
Vous pouvez me joindre en messagerie privée pour que je puisse vous envoyer cette librairie en PJ.
Désolé pour ces petits désagréments indépendants de ma volonté.
-
-
Souris et centrale sans fil - mode simplifié 28 décembre 2018 18:57, par Thierry72
Bonsoir Tony.
Depuis que j’ai des petits-enfants et que je suis passé au LGB, je cherche un système comme celui que tu as développé.
Cependant, je voudrais savoir s’il est possible de le simplifier : une souris par loco par petit (ou grand) - enfant, avec quelques fonctions activées chacune par un bouton (phares, éclairage de la loco, fumigène, dételage par servo ).
Qu’en penses-tu ?
Cordialement
Thierry -
Souris et centrale sans fil 6 janvier 2019 01:00, par tony04
Attention ! Il s’est glissé une petite erreur de lien dans la liste des pièces détachées.
Il faut commander un PRO/MINI 3,3V 16MHz pour la souris et non un 5V.
La liste a été corrigée ce 6 janvier.Toutes mes excuses
-
Bonjour
Très bon article !
J’ai commandé toutes les pièces sauf la pro mini 3,3 v 16 mhz. Je trouve facilement 3,3V 8mhz ou 5V 16 mhz mais pas 3,3v 16mhz même chez le fournisseur conseillé.
Y a t’il d’autres fournisseurs ?
Je suis aussi intéressé par 3 circuits imprimés de souris sans fil seulement m’indiquer la démarche.
Merci.
Bien amicalement.-
Bonjour Patrick,
la PRO/MINI 3,3V en 8MHz fonctionne aussi, je vous contacte pour les PCB.
Merci pour vos commentaires, vous commencez à être nombreux à utiliser cet ensemble, cela me fait bien plaisir.
Bien cordialement
Antoine
-
-
-
Souris et centrale sans fil 6 janvier 2019 18:56, par Pierre
Bonjour Tony,
Bravo à vous pour cet article !
Je suis intéressé par la réalisation des circuits PCB de la centrale ainsi que de la souris. Que puis-je faire pour vous contacter ?Merci d’avance.
-
Bonsoir Pierre,
merci pour l’intérêt que vous portez à mon article, vous pouvez me contacter par messagerie privée en vous inscrivant sur Locoduino si ce n’est pas déjà fait.
A bientôt donc
-
-
Souris et centrale sans fil 22 février 2019 10:17, par Juan
Tout d’abord, félicitations pour votre article sur la souris. J’ai déjà préparé tous les éléments, ainsi que la plaque, pour commencer à la construire un de ces jours.
Cependant, j’ai un doute sur ce qui me semble être un "défaut" important, à savoir que la souris ne gère que les locos, et je pense qu’il serait très nécessaire de gérer aussi les aguillages. Avez-vous l’intention de modifier la souris de cette façon ?
Je vous remercie beaucoup,
Juan.Traduit avec www.DeepL.com/Translator
-
Bonjour,
rassurez-vous, cette souris peut commander bien plus que les locos comme des aiguilles, des sons, des lumières, des feux etc… Tout dépend de votre configuration.
Pour en parler le mieux est de me contacter par messagerie privée.
Merci pour votre message.
Antoine-
C’est super, demain, je commencerai à construire la souris.
Comment puis-je vous contacter au sujet de mes nombreuses questions ?
Merci encore une fois.
Salutations,
Juan.
-
-
-
Souris et centrale sans fil 15 mars 2019 09:36, par Papymoujo
Bonjour
Est ce obligatoire de réaliser la centrale ?
Puis je utiliser un Uno avec LMD18200 ?
Merci-
Bonjour Papy,
un Papy à un autre Papy :-), oui il faut réaliser cette centrale pour pouvoir utiliser la souris sans fil, mais rassurez-vous elle est très facilement réalisable ce qui n’est pas le cas de la souris. Les PCB(souris ou centrale) sont disponibles au prix de 3€ unitaire + port.
En fait il vous faut surtout un MEGA pour gérer le NRF24L01(récepteur radio indispensable), le bus CAN (si vous voulez des extensions), le module Bluetooth (si vous voulez commander la centrale avec votre smartphone).
Par contre rien ne vous oblige à utiliser un booster 43A, le LMD18200 fera très bien l’affaire, aussi bien pour la voie normale que la voie de programmation.
L’avantage de cet ensemble est surtout le sans fil, les possibilités illimitées de la souris(regardez le mode d’emploi) et le fait de pouvoir relier sans fil jusqu’à 6 souris simultanément.
Rien ne vous empêche par contre d’utiliser JMRI ou CDMRAIL.Bon Week-end
Cordialement
Antoine
-
-
Souris et centrale sans fil 15 mars 2019 14:46, par Papymoujo
Bonjour Antoine
Merci pour les infos.
Je pensais réaliser les circuits de la centrale moi même.
Faut’il obligatoirement les acheter ?
merci -
Souris et centrale sans fil 15 mars 2019 14:49, par tony04
Bien sûr..................... que non, je peux te faire parvenir les typons en .bmp si tu me communiques ton adresse de courriel par messagerie privée (MP)
-
Souris et centrale sans fil avec Rocrail 4 avril 2019 20:12, par Juan
Bonsoir
Commenter simplement un problème que j’ai trouvé avec la centrale : elle marchait avec les codes DCC++, mais pas avec Rocrail.
Mais grâce à Antoine, le problème est résolu : il faut modifier dans le sketch de la centrale la ligne 210 comme ceci : Serial.begin(115200).
Et c’est tout, maintenant tout est en ordre.
Merci encore, Antoine.
-
Souris et centrale sans fil 9 décembre 2019 10:46, par Zaki
Hai Tony,
I’m interested in your project, there are a few that I want to ask :
1. can I replace "Alphanumeric Keypad" with Alphanumeric Membrane ?
2. Does this match with dcc ++ with ethernet shield ? I have Mega + ethernet shield + motor shield
thank you
RegardsZAKI
-
Amélioration souris et centrale 21 mars 2020 16:19, par Tony04
Bonjour à tous,
voici 2 modifications utiles pour un meilleur fonctionnement de l’ensemble.
Pour la souris et la centrale :
Rajouter une capa de 10µF 16V directement sur les pins du NRF24L01, si vous la mettez sous le PCB cela n’apporte rien.Pour la centrale seule :
Mettre une résistance de 10K en parallèle avec une capa de 1 à 2,2µF/16V entre la masse et AN0 du MEGA en vue d’une mesure de courant bien plus propre. Attention ! Il semblerait que les tensions de mesure du courant sur les booster 43A soient très variables selon le booster. Le plus simple est de rajouter une ligne dans le sketch après "int iCurrent = analogRead(A0) ;" pour renvoyer cette valeur sur la console série et d’adapter la valeur "Courant_Max" de la ligne 2 avec une bonne marge de sécurité.Cordialement
Antoine-
Bonjour Antoine,
Le mieux est d’ajouter (pour les nouveaux) cette modif dans le texte de l’article. Je le fais si tu me montre où.-
Ok Dominique, je vais essayer par moi-même et te recontacte si je n’y arrive pas.
-
-
Bonjour
Je trouve votre projet fantastique et j’aimerais le réaliser. Est-il possible d’avoir le schéma électrique du panneau de commande ? De la photo ne se voit pas bien.
Je m’excuse pour mon français.
Merci
Roberto
-
-
Souris et centrale sans fil 16 juin 2020 11:12, par Roberto
Bonjour
Je trouve votre projet fantastique et j’aimerais le réaliser. Est-il possible d’avoir le schéma électrique du panneau de commande ? De la photo ne se voit pas bien.
Je m’excuse pour mon français
Merci
Roberto-
Souris et centrale sans fil 16 juin 2020 12:07, par Antoine (tony04)
Bonjour Roberto,
merci pour votre message. Je veux bien vous faire parvenir tous les documents par courriel mais cela ne peut pas se faire par cette page ni par le forum car les fichiers sont trop lourds.
Si vous me faites un message par messagerie privée sur le forum, vous pourrez m’envoyer votre adresse de courriel grâce à laquelle je vous ferais parvenir tous les documents nécessaires.
Si vous le désirez je peux aussi vous livrer les PCB ou les composants (au prix coutant) et même les PCB semi-montés ou totalement montés, y compris le boitier souris détouré par fraiseuse numérique.
Cordialement
Antoine
-
-
Souris et centrale sans fil 18 juin 2020 10:28, par Juan
Bonjour
En relisant votre article, j’ai vu que dans le schéma de la centrale il y a quelques modifications, à part la capa 10uF pour le NRF24, mais je ne les vois pas bien. Pourriez-vous commenter ces modifications, et peut-être m’envoyer le schéma ?
Merci beaucoup.Juan.
-
Souris et centrale sans fil 18 juin 2020 11:13, par Antoine (tony04)
Bonjour Juan,
pouvez vous préciser ce que vous avez lu ?
Cordialement
Antoine-
Antoine,
En fait, je n’ai rien lu, j’ai juste vu que dans le schéma de la centrale il y a deux nouvelles plaques qui ne figuraient pas dans l’ancien schéma que j’ai construit. Et je n’arrive pas à savoir ce qu’ils sont. Si je le pouvais, je vous enverrais le schéma avec les deux nouvelles plaques marquées.
-
-
Souris et centrale sans fil 18 juin 2020 17:48
Il s’agit tout simplement de 2 versions de boosters et 2 versions de capteurs de courant selon ce que vous avez chez vous.
-
Souris et centrale sans fil 12 mars 2021 16:09, par Pierre
Bonjour Antoine,
La centrale est-elle compatible avec les logiciels de contrôle suivants :
Train Controller ?
I Train ?
Roc Rail ?
JMRI ?
CDMRail ?Pierre
-
Bonjour Pierre,
tu as raison de poser ta question au travers de cet article car d’autres lecteurs se posent peut-être la même.
Je ne peux te répondre que pour JMRI car personne ne m’a jamais informé sur les autres programmes.
La seule condition pour JMRI c’est que la vitesse du port série soit à 115200 bauds, ce qui est le cas dans la dernière version que je t’envoie sur ton mail privé.Cordialement
Antoine-
Bonsoir à tous,
à priori c’est la question de la compatibilité de ces systèmes avec DCC++ :
Train Controller : non
I Train : non
Roc Rail : oui
JMRI : oui
CDMRail : oui
Voir les sites des dits sytèmes.
Antoine, peux-tu confirmer que c’est DCC++ qui est à la base de ta centrale ?
Cordialement-
Souris et centrale sans fil 12 mars 2021 20:17, par Antoine (tony04)
Bonsoir Michel,
ma centrale est basée sur la librairie DCCpp de Locoduino, mais pas de la dernière version qui a crée des problèmes dans les derniers crans de la vitesse.
J’avais participé a un fil dédié à DCCpp sur le forum resté sans confirmation par d’autres utilisateurs.
https://forum.locoduino.org/index.p...Des essais sont donc à faire si on veut utiliser cette dernière version.
Bonne soirée à tous.
Antoine-
Merci à tous pour vos réponses claires et rapides !
-
-
Bonjour à tous,
Concernant Windigipet, il semble que DCC++ soit compatible (https://www.windigipet.de/foren/ind...). Dois-je en conclure que la centrale et souris d’Antoine fonctionneront sous Windigipet ?
Bonne journée...
-
Il n’est pas inutile de consulter le forum de Windigipet qui dit :
1. https://www.windigipet.de/foren/ind...
Propriétés du système numérique DCC ++en relation avec Win-Digipet :
Journal de suivi Adresses des locomotives Adresses des solénoïdes Fonctions spéciales par adresse
DCC 1 à 9999 1 -2048 f0 - f28Le système numérique DCC ++ est un projet de bricolage basé sur un Arduino (UNO / MEGA) en conjonction avec un soi-disant blindage moteur. Un simple centre numérique DCC peut être assemblé à un prix abordable avec seulement quelques composants.
Le système numérique peut être connecté via une interface USB ou via un réseau Ethernet.
Il existe des vidéos sur Internet qui expliquent la structure et l’utilisation de ce système numérique.
Vous trouverez de plus amples informations sur DCC ++ sur le site Web : https://github.com/DccPlusPlus/Base...Système de rétroaction : Entrées logiques
Nombre de retours : dépend de la carte Arduino
Interface : Ethernet / USB
Prise en charge de Win-Digipet-Version : 2018.12. https://www.windigipet.de/foren/ind...
Bonjour,j’ai enfin essayé DCCpp sous WDP 2018.2b.
Fonctionne très bien !
Vraiment génial pour une simple carte de test DCC
avec quelques aiguillages et quelques RM.
Je dois encore essayer de programmer les locomotives.Merci pour la mise en œuvre.
MfG
vik
-
-
-
-
-
Souris et centrale sans fil 9 avril 2021 11:40, par tony04
Bonjour Pierre,
ne connaissant absolument pas Windigipet, je ne saurais te répondre.
La base de ma centrale est bien DCCpp, il y a juste l’échange entre la souris et la centrale qui est perso.
Cordialement
Antoine-
Merci pour ta réponse Antoine.
Bonne journée !
-
-
Souris et centrale sans fil 19 décembre 2022 17:24, par ClB91
Bonjour Antoine,
Je suis tombé sur votre article et ai décidé d’implementer votre souris sans fil. Jusqu’à present pas trop de problèmes avec la mécanique. Par contre côté soft, j’ai une question à cent sous concernant l’initialisation de l’EEPROM lors de la première mise à feu de la souris. Avez vous une recommandation comme une remise à zero par exemple ?
Claude-
Je t’ai envoyé le sketch d’initialisation par mail.
Antoine
-
-
Souris et centrale sans fil 13 août 2023 17:40, par dhedin franck
Bonjour je suis desireux pour realiser votre central jai trouve dans l"article les fichier gerber pour la souris mais je ne trouve pas ce de la centrale pouvez vous me les envoyer merci mr Dhedin
-
Souris et centrale sans fil 13 août 2023 19:17, par Antoine (Tony04)
Bonjour,
je peux vous fournir les PCB souris et centrale à 3€ pièce + port, mais si vous préférez les gerber, pas de problème, donnez moi votre adresse de courriel en rajoutant des caractères devant et derrière par sécurité, ou par messagerie privée sur le forum pour Tony04.Attention ! Les sketchs ont pas mal évolués et je vous les ferai parvenir en même temps.
Cordialement
Antoine -
Souris et centrale sans fil 13 août 2023 21:51, par dhedin Franck
Bonsoir je vous commanderai de quoi réaliser une centrale avec deux souris mon adresse mail est ((franckdh @ hotmail.fr)) merci Mr dhedin