Messages

1

Présentez vous ! / Re : Carte Mega WiFi R3 Atmega2560 et motor shield DCCEX-8874 & Rocrail

« le: Aujourd'hui à 09:53:03 am »

J'ai construis mon réseau sur Rocrail et je suis arrivé à le faire fonctionner avec sa centrale virtuelle. Le step suivant pour moi était de connecter la centrale DCC++ en Port série. J'y suis arrivé mais là tout se complique.

Ok, ça se complique mais qu'est-ce qui ce complique à part tout Pas évident de t'aider si tu es si peu précis sur les problèmes que tu rencontres.

RocRail est pourtant simple à configurer avec DCC++ : https://wiki.rocrail.net/doku.php?id=dccpp:dccpp-fr

Je l'utilise également en 3R avec CC-Schnitte relié à l’un des ports USB et à une Geiltsbox de Marklin : https://forum.3rails.fr/t/homemade-marklin-creation-dun-circuit-intelligent/13574/25

Et ça fonctionne très bien.

Est-ce que tu as lu l'article de Michel ? : https://www.locoduino.org/spip.php?article306

Merci d'envoyer précisions et copies d'écrans où il y a des problèmes

Christophe

2

Vos projets / Re : RailCom: Générateur de CutOut

« le: Aujourd'hui à 09:17:26 am »

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 (digitalRead(PinIn1) == true) {
    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
  }
}


3

Vos projets / Re : RailCom: Générateur de CutOut

« le: avril 25, 2024, 11:52:21 pm »

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

4

Vos projets / Re : RailCom: Générateur de CutOut

« le: avril 25, 2024, 04:34:53 pm »

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

5

Vos projets / Re : Re : RailCom: Générateur de CutOut

« le: avril 25, 2024, 03:06:02 pm »

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

6

Vos projets / Re : Re : RailCom: Générateur de CutOut

« le: avril 25, 2024, 01:24:55 pm »

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 ?

7

Vos projets / Re : RailCom: Générateur de CutOut

« le: avril 25, 2024, 01:12:42 pm »

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

8

Vos projets / Re : RailCom: Générateur de CutOut

« le: avril 25, 2024, 12:24:42 pm »

le nombre de bits des preambles DCC-EX , c'est dans "DCCWaveform.h" :
// Number of preamble bits.
const int   PREAMBLE_BITS_MAIN = 16;
const int   PREAMBLE_BITS_PROG = 22;

Bon d'origine on est trop court avec 16 bits que l'on fasse du Railcom Chanel 1 simplement ou Chanel 1 et 2 bien sûr. Heureusement c'est modifiable mais attention aux MAJ de DCC-Ex comme je le disais plus haut.

l'assembleur , c'est juste en Anglais ce que la machine fait en réel , donc on ne peut pas aller + vite ; bien entendu , un truc mal écrit en assembleur pourra aller moins vite qu'un truc bien écrit en Basic ...

Bon Christian nous raconte de con**ries ! Je lui en parlerai quand je vais le voir !

9

Vos projets / Re : RailCom: Générateur de CutOut

« le: avril 25, 2024, 11:54:22 am »

(...)
Par exemple, je suis à peu près certain que cette commande écrite en partie en assembleur est malgré tout moins rapide en exécution qu’une écriture directe sur les ports.

- on ne peut pas aller + vite que l'assembleur , mais on peut écrire l'équivalent en C (me souviens plus comment)
- écrire directement sur le PORT , quelque soit la méthode , a pour inconvénient de modifier toutes les sorties du PORT , voir si c'est gênant ou pas
je crois le + rapide c'est :
PINB = 0b00110000 ; // on bascule les bits 4 et 5 sans toucher aux autres

Si on peut aller plus vite que l'assembleur quand on travaille avec l'IDE Arduino. C'est le cas ici et le fichier a bien comme extension .ino. Christian explique précisément cela dans son article : https://www.locoduino.org/spip.php?article280

Timing d’une fonction
Dans certains cas, l’IDE d’Arduino ne permet pas d’obtenir ce qu’on veut. Consultez la page du site Arduino qui décrit la fonction delayMicroseconds() et examinez le petit programme fourni en fin de page et repris dans la figure 3.

Selon Arduino, ce programme tout simple ne donnera pas le résultat escompté.
Si vous examinez à l’oscilloscope le signal obtenu sur la sortie (ici broche , vous constaterez un signal carré cyclique dont la demi-période fait 53,5 µs au lieu de 50 µs comme le voulait le programmeur et parfois ce signal montre une demi-période de presque 60 µs. Comme il est dit sur la page du site d’Arduino, cette approximation est due à l’exécution de code qui a été rajouté par l’IDE.

Il en est de même pour digitalRead() ou digitalWrite() dont on estime le temps d'exécution entre 16 et 20 fois supérieur à l'écriture ou la lecture directe du port.

Voir également : https://docs.arduino.cc/retired/hacking/software/PortManipulation/

Je crois le + rapide c'est :
PINB = 0b00110000 ; //

Nous sommes d'accord.

Ceux qui commence à s'attaquer à ce type de programmation ne sont pas des perdreaux de l'année, ils savent adapter les ports selon la platelorme. Et rien n'empèche de mettre des #define en début de programme selon les µc.

10

Vos projets / Re : RailCom: Générateur de CutOut

« le: avril 25, 2024, 11:29:59 am »

Oui je veux bien que tu regardes si tu peux. Selon moi, ce doit être proche du "minimum syndical" mais probablement pas plus de 16.

En modifiant très légèrement DCC-Ex cela est certainement modifiable... mais attention à l'occasion de mises à jour !

et je regarde comment insérer le HW dans LaBox

Pas comprendre HW ?

Merci

Christophe

11

Vos projets / Re : RailCom: Générateur de CutOut

« le: avril 25, 2024, 10:10:07 am »

Au niveau du soft, j’ai aussi quelques interrogations quant à certains choix.

Par exemple, je suis à peu près certain que cette commande écrite en partie en assembleur est malgré tout moins rapide en exécution qu’une écriture directe sur les ports.

Code: [Sélectionner]

void Dcc_Interrupt() {
  if (digitalRead(PinIn1) == true) {
    asm("cbi 0x0B, 5");
    asm("sbi 0x0B, 4");
    TCCR2B |= (T2_PRESCALER_BITS);  // Start Timer 2
  }
  else {
    asm("cbi 0x0B, 4");
    asm("sbi 0x0B, 5");
  }
}
Et que le digitalRead() aurait pu être très avantageusement remplacé par une lecture du port !!!

Ceci n’est pas très important à ce stade mais pourra faire partie des réflexions d’évolution

12

Vos projets / Re : RailCom: Générateur de CutOut

« le: avril 25, 2024, 09:53:23 am »

Bonjour Marc,

Merci d’apporter des éclairages. Je ne suis pas aussi sûr que toi que les centrales du commerce génèrent (beaucoup) plus de bits de préambule que nécessaire soit 12, 14 ou 16.

Sait-on par exemple combien de bit de préambules sont générés dans DCC-Ex, soft qui est à la base de la Box ?

Oui pour obtenir le signal de DIR soit les 1 (HIGH) soit les 0 (LOW), baiser en tension l’un des conducteurs du signal DCC, sans doute une bonne idée. Comment procèderais-tu pour « tenir » dans un 5V max ?

Il est plus facile à implanter directement en sortie du µcontroleur. Ce qui est désigné sur le schéma comme « entrée DCC » serait en fait la sortie DIR. C’est elle qui génère soit les 1 (HIGH) soit les 0 (LOW).

Pour le court-circuit, tu penses que mettre EN1 et EN2 en cc suffit ! cad. 1/0 = 1/0 , 0/1 = 0/1 et , pour le cutout , 1/1 = 0/0 Tu as certainement raison, je ne suis pas ici dans ma zone de confort pour ce qui est de mes compétences.

Merci de nous permettre à tous de mieux appréhender ce sujet.

Christophe

13

Vos projets / Re : RailCom: Générateur de CutOut

« le: avril 24, 2024, 11:54:39 pm »

Bonjour lebelge,

Je suis très intéressé et en même temps certaines choses m'étonnent.

Je comprends bien le principe adopté pour insérer le cutout à la place de certains bits du préambule. Mais encore faut il qu'il y ait assez de bits ! Si la centrale ne génère que 16 bits de préambule, ou 14 ? Avec une centrale en DIY, on peut générer le nombre de bits que l'on veut, mais une centrale du commerce ?

Par ailleurs, pour activer le transfert, il faut que le booster court-circuite la sortie pour que le décodeur envoie un courant dans la boucle ainsi créée. Or je ne vois pas comment tu réalises cela ici ? Avec un LMD18200 qui dispose d'une entrée BRAKE, c'est très simple. Sur un L603 je crois que l'on peut le faire avec la pin ENABLE1 et  ENABLE1 (mais je ne vois pas cela dans ton montage). Et avec un L298N ?

Merci pour tes réponses.

Christophe

14

Vos projets / Re : Les SATELLITES AUTONOMES : Une solution simple pour la gestion de réseaux.

« le: avril 18, 2024, 12:15:49 pm »

Bonjour à tous,

René (alias rNé) a réalisé un nouveau dessin de la carte satellite plus compact mais aussi moins chère à fabriquer puisqu'elle tient maintenant dans un format de 100 mm X 100 mm qui chez JLCPCB revient à 3,99€ port compris pour 5 exemplaires soit 80 centimes pièce !

Deux ou trois corrections ou améliorations (sérigraphie...) et le prochaine version sera en production.

Quelques photos pour vous faire patienter :

15

Aide / Re : ma première centrale ne fonctionne pas avec ARDUINO MOTOR SHIELD: V-1.2.1+ ?

« le: avril 16, 2024, 07:25:31 am »

Non bien sûr, cela n'est pas normal dans la mesure où l'objet de la centrale est d'assurer le roulage des locomotives !

Maintenant, tu apportes deux informations cruciales qui permettent de mieux isoler la cause. Il y a un courant de +/- 18 à 20 volts sur la voie, suffisant donc pour des décodeurs en HO et les trames DCC sont globalement dans les "clous" pour que le décodeur les interprète.

Je commencerais par m'assure que la locomotive a bien pour adresse "3" quand j'envoie <t 1 3 20 1>. Eventuellement, je ferais le test avec une autre locomotive dont je suis assuré de l'adresse et dont je sais qu'elle fonctionne.

Sinon, c'est un problème de soft dans la centrale mais c'est peu probable si tu n'as rien modifié.

Commence par cela et reviens nous dire quelque soit l'issue !

Christophe