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>
#endif

Où 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ébogage

Ce 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émoire

Cette 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éception

On 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 CV18

Pour 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.