RailCom: Générateur de CutOut

[bobyAndCo]

Bonjour,

Merci tout d’abord pour ce partage. C’est effectivement un sujet qui en intéresse plus d’un à Locoduino à l’heure actuelle et principalement paracerque la Box qui est une super centrale par ailleurs ne dispose pas de Railcom.

Cette proposition est une réponse intéressante à ce problème. Personnellement je suggère de « redessiner » le PCB de la Box pour y inclure un µc entre les sorties de l’ESP32 et le L6203. Cela me semble la solution la plus « propre »,la moins compliquée et la moins couteuse aussi.

Le LMD18200, au-delà d’être une carte largement éprouvée n’offre ici comme avantage supplémentaire que l’exposition de la broche Brake.

Maintenant, un L6203 que l’on peut mettre en court-circuit le temps du cutout est sans doute plus intéressant qu’un LMD18200 (4A pour le premier contre 3A pour le second).

Je m’étais donné d’autres priorités, mais je pense que je vais tester très rapidement cette proposition.

Merci lebelge de continuer à nous alimenter de belles solutions comme celle-ci !

Christophe

[CATPLUS]

Merci pour le partage & ces explications
Je vais suivre avec intérêt vos évolutions.

[bobyAndCo]

Test et essais fait avec un Arduino Mega pour centrale et Nano pour insérer le CutOut.
Logiciel :  CommandStaion-EX et Base Station.

Au fait, a t'il fallu modifier le nombre de bits des preambles DCC-EX dans "DCCWaveform.h"
// Number of preamble bits.
const int   PREAMBLE_BITS_MAIN = 16;

et mettre une valeur supérieure ? Je pense que oui, donc quelle valeur ? 21 ?

[trimarco232]

ben si , tu peux mettre les 2 instructions en 1 seule , en écrivant dans PORTB ou PINB

pour LaBox version  L6203 , c'est faisable sans modifier le SW du générateur , vu que le L6203 accepte la commande :
L , L = Sink 1, Sink 2
mais il faudra charcuter ...

[lebelge2]

J’ai laissé le Préambule à 16, il n’en reste plus que 11 à la fin… ( Norme ; minimum 10)

Par contre, DCC-EX inverse le signal (voir trame n°1) et le programme ne fonctionne plus.
Heureusement on peut activer une sortie (signal_pin2) qui inverse de nouveau le signal (voir trame 2) donc on retrouve un signal DCC conforme et tout ok.
Trame 3 et 4 avec CutOut et préambule à 11 ou 12

Notes : BaseStation génère un signal correct (pas d’inversion)
Vais voir pour modifier le soft pour accepter aussi un signal inversé.

Et après réflexions....... Ce n’est pas la Centrale qui génère le CutOut, c’est le Booster…
En soit un Booster ce n’est pas compliqué, c’est un ou deux optocoupleurs et un Bridge Driver.
Un microprocesseur surveille les trames et insère un CutOut au moment opportun.

Juste ce que fait ce montage.

[bobyAndCo]

J’ai laissé le Préambule à 16, il n’en reste plus que 11 à la fin… ( Norme ; minimum 10)

Je croyais que le décodeur devait recevoir un préambule à au moins 14 bits pour répondre canal 1 et 16 bits pour avoir le canal 1 et le canal 2

[trimarco232]

le cutout fait , pour les 2 canaux , selon la norme , 500 us
Édit : précisément 442 us , mais pouvant aller jusqu'à 462 us
cela correspond à 500/116 = 4.3 bits 1 DCC , arrondi à 5
si on a un preamble de 16 bits , il doit en rester 11 , ce qui va bien pour (de mémoire) un minimum de 10
amha ça ne sert à rien d'en avoir + de 16 au départ

[CATPLUS]

@Mr LeBelge

Sur la photo que vous présenterz l'affichage du # de la loco est inscrite sur un LCD, pourriez-vous svp nous donner  des explications?
Soft, schéma, Nano, Uno, ESP.....

[bobyAndCo]

le cutout fait , pour les 2 canaux , selon la norme , 500 us
cela correspond à 500/116 = 4.3 bits 1 DCC , arrondi à 5
si on a un preamble de 16 bits , il doit en rester 11 , ce qui va bien pour (de mémoire) un minimum de 10
amha ça ne sert à rien d'en avoir + de 16 au départ

Marc, ce n'est pas exactement de cela que je parlais. On est d'accord sur la durée du cutout à environ 500 µS. Le minimum de 10, c'est la norme "hors Railcom". Ce que je dis, c'est que pour que le décodeur envoie le chanel 1 il faut qu'il ait reçu au minimum 14 bits de préambule et pour renvyer le canal 1 et le canal 2 il faut qu'il ait reçu 16 bits de préambule au moins. A 10 ou 11 bits on sera dans la norme mais le décodeur n'enverra pas ses infos Railcom

[lebelge2]

CATPLUS, c'est le montage de de Paco cañada

https://usuaris.tinet.cat/fmco/home_sp.htm

https://usuaris.tinet.cat/fmco/download/RailComDisplay_manual.pdf

[bobyAndCo]

Bonjour à tous,

J'ai réussi à faire fonctionner le montage avec un LMD18200. C'est tout ce que j'avais sous le coude. Les adresses de locomotives sont bien lue. Je n'ai essayé pour l'instant que avec DCC++ (version originale) qui génère 22 bits de préambule ! J'ai commencé à tester avec DCC-Ex mais je n'avais rien, certainement ce que lebelge soulevait à propos de DCC-Ex, du coup je n'ai pas poursuivis car un peu fatigué.

@lebelge

- LMD18200 :
     Je ne possède pas encore ce module mais d’après le datasheet, au moment du CutOut, il faut que Dir soit à 0 et Brake à 1, il faudra adapter le soft plus deux sorties supplémentaires dédiées à ce module.

J'ai effectivement utilisé une broche supplémentaire, la 6

Code: [Sélectionner]

#define PinIn1 3                              // Entrée signalDcc sans CutOut = Pin DIR du MEGA (pin 12 dans DCC++)
#define PinOut1 4                            // Sortie signal DCC avec CutOut =  Pin DIR du LMD18200
// La sortie 3 du MEGA (PWM) est reliée en direct au PWM du LMD18200
#define PinOut2 5                            // Sortie signal DCC inversé avec CutOut // Je ne l'utilise pas ici
#define PinBrake 6                           // Sortie signal BRAKE = Pin 6 du Nano dans pin BRAKE du LMD18200

et dans la fonction CutOut(), j'active la broche 6 en même temps que la 4

Code: [Sélectionner]

void CutOut(void) {
  delayMicroseconds(8);
  PORTD = PORTD | B01010000;
  PORTD = PORTD &= ~ B00100000;
  //
  delayMicroseconds(425);
  PORTD = PORTD | B00100000;
  PORTD = PORTD &= ~ B01010000;
}

Bon ça mérite encore un peu de travail sur le code mais le principe est bon. C'est une énorme avancée et de belles perspectives pour Railcom sur la Box dans des conditions simples et peu couteuses.

Je ne serai en effet pas étonné que l'on puisse à terme mettre un ATTiny (modèles récents) à moins d'1€.

Merci encore lebelge pour ce partage bénéfique.

PS : Je mesure environ 10% des trames DCC en dehors des spécifications NMRA, et encore de très peu en dehors. Ce qui pour moi est très acceptable et qui est déjà peut-être le cas en sortie directe de DCC++ ce que je pourrai mesurer plus tard.

Christophe

[CATPLUS]

Bonjour Christophe

Bravo, pourrais-tu stp nous faire un schéma de ton montage.

Marcel

[bobyAndCo]

Bonjour Marcel,

Je n'ai pas beaucoup de temps disponible aujourd'hui mais les équivalence de broche sont dans le commentaire en début du code modifié ci-dessous. Normalement tu vas t'y retrouver sans problème.

Le code ci-dessous est à copier sur un Nano par exemple. Sur le MEGA qui sert de centrale, j'ai copié le code original de DCC++ qui a 22 bits de préambule : https://github.com/DccPlusPlus/BaseStation

Je n'ai pas le temps de faire les tests avec moins de bits dans le préambule, à voir par la suite.

Je précise bien, mais ça ce voit dans le cablage, que le UNO est directement derrière le MEGA et avant le LMD. Cette solution ne convient pas derrière un booster. A voir par la suite.

Code: [Sélectionner]


// RailCom: Programme pour insérer un CutOut dans les trames DCC.  Arduino Uno, Nano, Micro.

// V.1.0.   24-04-24
// lebelge2@yahoo.fr

/*
Modifié pour LMD18200 le 26/04/24

Testé à partir de DCC++ version originale téléchargé sur Arduino MEGA : https://github.com/DccPlusPlus/BaseStation
Ce code téléchargé sur un Arduino Nano.

Cablage :

  MEGA 3 ------> LMD18200 PWM
  MEGA 12 -----> NANO 3
  NANO 4 ------> LMD18200 DIR
  NANO 6 ------> LMD18200 BRAKE
  MEGA GND ----> NANO GND
  MEGA GND ----> LMD18200 GND

*/

volatile uint8_t dccrecState;
volatile uint8_t tempByte;
#define WAIT_PREAMBLE    0
#define WAIT_START_BIT   1
#define WAIT_DATA        2
#define WAIT_END_BIT     3
#define MaxDccSize 6                         // DCC messages can have a length upto this valu
#define PinIn1 3                             // Entrée signalDcc sans CutOut
#define PinOut1 4                            // Sortie signal DCC avec CutOut
#define PinOut2 5                            // Sortie signal DCC inversé avec CutOut
#define PinBrake 6                           // Sortie signal brake

class DccMessage {
  public:
    volatile uint8_t size;
    volatile uint8_t data[MaxDccSize];        // The contents of the last dcc message received
} dccMessage;

struct {
  uint8_t bitCount;                           // Count number of preamble bits / if we have a byte
  volatile uint8_t tempMessage[MaxDccSize];   // Once we have a byte, we store it in the temp message
  volatile uint8_t tempMessageSize;           // Here we keep track of the size, including XOR
} dccrec;                                     // The received DCC message is assembled here

struct {
  uint8_t port;
  uint8_t bit;                                // Bitmask for reading the input Port
  volatile uint8_t *portRegister;
} dccIn;

void setup() {
  Serial.begin(115200);

  DDRD = DDRD | B01110000;  // pin 3 -> input, pin 4 à 6 -> output
  init_timer2();
  attachInterrupt(digitalPinToInterrupt(PinIn1), Dcc_Interrupt, CHANGE );
  Serial.println ("SetUp OK");
}

void loop() {}

void CutOut(void) {
  delayMicroseconds(8);
  PORTD = PORTD | B01010000;
  PORTD = PORTD &= ~ B00100000;
  //
  delayMicroseconds(425);
  PORTD = PORTD | B00100000;
  PORTD = PORTD &= ~ B01010000;
}
//----------------------------------------------------------------------------------------------------------
void init_timer2(void) {
#define T2_PRESCALER   8
#define T2_PRESCALER_BITS   ((0<<CS02)|(1<<CS01)|(0<<CS00))
#define T77US (F_CPU * 77L / T2_PRESCALER / 1000000L)
#if (T77US > 254)
#warning T77US too big, use either larger prescaler or slower processor
#endif
#if (T77US < 32)
#warning T77US too small, use either smaller prescaler or faster processor
#endif
  noInterrupts();              // disable all interrupts
  TCCR2A = 0;                  // should be zero for our purpose
  TCCR2B = 0;                  // 0 => timer is stopped
  TCNT2 = 256L - T77US;        // preload the timer
  TIMSK2 |= (1 << TOIE2);      // the timer is used in overflow interrupt mode
  interrupts();                // enable all interrupts
}
//----------------------------------------------------------------------------------------
void Dcc_Interrupt() {
  if ((PIND & 0x04) >> 2) {
    PORTD = PORTD | B00010000;
    TCCR2B |= (T2_PRESCALER_BITS);  // Start Timer 2
  }
  else {
    PORTD = PORTD &= ~ B00010000;
  }
}
//-----------------------------------------------------------------------------------
ISR(TIMER2_OVF_vect) {
  uint8_t DccBitVal = !(PORTD & (1 << 4));
  TCCR2B = 0;                                    // 0 => timer is stopped
  TCNT2 = 256L - T77US;                          // preload the timer
  dccrec.bitCount++;
  switch (dccrecState) {
    case WAIT_PREAMBLE:
      if (DccBitVal) {                           // a "1" bit is received
        if (dccrec.bitCount >= 10)
          dccrecState = WAIT_START_BIT;
      }
      else
        dccrec.bitCount = 0;                     // not a valid preamble.
      break;
    case  WAIT_START_BIT:
      if ( !DccBitVal ) {                        // a "0" bit is received
        dccrecState = WAIT_DATA;
        dccrec.tempMessageSize = 0;
        uint8_t i;
        for (i = 0; i < MaxDccSize; i++ )
          dccrec.tempMessage[i] = 0;
        dccrec.bitCount = 0;
      }
      break;
    case WAIT_DATA:
      if ( dccrec.bitCount == 8 ) {                 // byte is complete
        if (dccrec.tempMessageSize == MaxDccSize ) { // Packet is too long - abort
          dccrecState = WAIT_PREAMBLE;
          dccrec.bitCount = 0;
        }
        else
          dccrecState = WAIT_END_BIT;              // Wait for next byte or end of packet
      }
      break;
    case WAIT_END_BIT:
      if ( DccBitVal ) {                           // End of packet?
        CutOut();
        dccrecState = WAIT_PREAMBLE;
      }
      else                                         // Get next Byte
        dccrecState = WAIT_DATA;
      dccrec.bitCount = 0;                         // prepare for the next byte
  }
}


[trimarco232]

Bonjour ,
Bravo Christophe !

(...)
Je ne serai en effet pas étonné que l'on puisse à terme mettre un ATTiny (modèles récents) à moins d'1€.

on peut , ce serait un petit projet intéressant pour notre ami Laurent
(dans l'idéal , le "mégatiny" se verrait téléversé par une broche de l'ESP32 , on n'aurait pas besoin de connecteur ou programmateur spécial)
après , on a 3 approches :
1) faire générer par le mégatinny , à partir de la sortie DCC de l'ESP32 , les signaux pour le cutout , conformément au soft de lebelge2
2) faire générer au mégatiny toute la trame DCC (il le fera mieux que l'ESP32), à partir d'une liaison série de l'ESP32 , avec petit protocole local adhoc ; (on pourrait utiliser la même broche de l'ESP32 , pour le téléversement et la liaison série) ; c'est techniquement le mieux , mais ça nécessiterait de retoucher le soft de DCC-EX(
3) décoder , à la manière d'un sniffer , le DCC issu de l'ESP32 , puis le reproduire , (avec un packet de retard) , pourvu des signaux qui vont bien ; c'est ma préférence

le chois d'un megatiny n'est pas critique , on pourrait aussi envisager , dans le même format à 8 broches cms , un CH32V003 , ou même un STM32 (ce dernier n'ayant toutefois pas ma faveur , car il utilise ("bêtement") , 2 broches au lieu d'1 pour le téléversement

[bobyAndCo]

Merci Marc pour les perspectives que tu apportes.

Dans le cas de laBox qui s’adresse à un public sans compétences particulières, je pense qu’il ne faut pas modifier DCC-Ex. Je pense principalement aux MAJ, car on oublie vite que l’on avait changé tel ou tel paramètre, modifié telle ou telle configuration.

Par ailleurs, les trames générées par DCC-Ex sont parfaites !

L’idée de téléverser le soft à partir de l’ESP32 est vraiment intéressante. Pas certain qu’il faille utiliser la même broche pour le téléversement et la liaison série. Il faudra il est vrai ajouter du code dans DCC-Ex pour cela (avec les précautions de MAJ dont je parlais). Je vois bien une commande en synthaxe DCC++, <xx> qui lancerait le processus !!!

Je parle ATTiny ou AVR car c’est ce qui est le plus compatible avec l’environnement Arduino en programmation. Et celui dont je connais le mieux la manipulation des ports 

Il reste à adapter le programme du belge à l’ESP32 et surtout à DCC-Ex, j’avoue ne pas avoir bien compris l’histoire des trames inversées.

Il y a aussi une demande d’adaptation pour placer ce montage, non plus derrière une centrale sans booster, mais derrière un booster.