Sujets

1

Vos projets / Une interface S88 pour LaBox.

« le: mai 22, 2025, 03:53:53 pm »

Bonjour.

Je vous propose une petite carte double entrée S88 à connecter à LaBox ainsi que le code source écrit par Xavier Bouillard et Philippe Chavatte du site http://lormedy.free.fr/S88.html (Autorisation de publication des auteurs)

Cet équipement permet de remonter les informations de détection via LaBox vers :
CDT3x, WDD,  DMC, CDM-Rail, JMRI et Rocrail.

Il est possible de connecter deux chaînes en parallèle de 32 modules à huit sorties, pour un total max. de: 2 x 32 x 8 = 512 capteurs.

Sur mon GitHub, vous trouverez :   https://github.com/Lebelge2/S88

-   Le fichier S88_Gerbert.zip pour la fabrication de l’interface.
-   Les fichiers  S88.cpp et S88.h  (simplifier) à joindre à ceux de LaBox.

Modif. LaBox :
-   Dans CommandStation-EX-LaBox, écrire : #include "S88.h"
-   A la fin du setup(), écrire :  S88::init() ;
-   A la fin du loop() , écrire :

Code: [Sélectionner]

if (S88::checkTime())           
        S88::check();

Configuration  S88.cpp

       Paramètre : N = nombre de carte de détection entre 2 et 64 (par pas de 2)
       Paramètre : DataFormat,  0, 1, 2 ou 3 suivant  logiciel de gestion des trains.

Plus d’info. sur le site de l’auteur :  http://lormedy.free.fr/S88.html

Je reste à votre disposition pour touts renseignements complémentaires.
Bien à vous.

2

Vos projets / Un écran plus grand pour Labox

« le: novembre 28, 2024, 03:39:47 pm »

Bonjour, Labox est dotée d'un écran OLED de 0,96 pouce.(SSD1306)

Je souhaite un écran plus grand, le OLED SH1106  1,3 pouce.
Son mode d’affichage est différent et nécessite une autre librairie.

Cependant, il est plus simple de modifier la librairie existante (Adafruit_SSD1306.cpp)

Modifications logicielles à effectuer dans la librairie Adafruit_SSD1306.cpp

-   Sur première ligne, écrire : #define SH1106
-   Dans la fonction : void Adafruit_SSD1306::display(void) ,  après la ligne :      uint8_t *ptr = buffer;
Insérer ce code :

Code: [Sélectionner]

#if defined (SH1106)
   for (int8_t i = 7; i >= 0; i--){
      ssd1306_command1(0xB0 + i);                           // Set row
      ssd1306_command1(0x02);                               // Set lower column address
      ssd1306_command1(SSD1306_SETHIGHCOLUMN);              // Set higher column address
     
      for (uint16_t j = SSD1306_LCDWIDTH; j > 0; j--){
        Wire.beginTransmission(i2caddr);
        WIRE_WRITE(0x40);
        for (uint8_t x=0; x<16; x++) {
          WIRE_WRITE(buffer[i * SSD1306_LCDWIDTH + SSD1306_LCDWIDTH - j]);
          j--;
        }
        j++;
        Wire.endTransmission();
      }
    }
  TRANSACTION_END
  return;
#endif

-     Reste à ajuster l’offset verticale.
      Dans : static const uint8_t PROGMEM init2[]    Changer valeur  0  (// no offset)   à 1

Modification matérielle.
D’origine, sur le SH1106, les Pins Gnd et Vcc sont inversées par rapport au SSD1306.
Il faut déplacer deux pontages au dos de l’afficheur pour que toutes les broches soient compatibles avec celles de Labox.

3

Vos projets / Carte détecteur de présence 16 entrées RailCom

« le: novembre 09, 2024, 12:38:57 am »

Bonjour, ma dernière réalisation pour le suivi des trains dotés de la technologie RailCom ou non.
Détection de la présence de matériel roulant par consommation de courant et identification du numéro de loco. sur 16 canaux.

Le détecteur est composé d'une carte fille de chez Olimex  (processeurs Atmel ATXMEGA128A1) et de composants traversants.

C'est un clone du  GBM16T dont les plans, la construction et les fichiers sont libres de droits.

Pour les caractéristiques, je vous renvoie sur le site de l'auteur de la carte originale.
(16 entrées, faible insertion (0,3v), sensibilité ajustable, alimentation par DCC ou séparée, isolation galvanique des masses, etc…)

https://www.opendcc.de/s88/gbm_bidi/gbm_bidi_f.shtml

Je fournis le plan, la liste des composants, le fichier gerber (voir mon Github) ainsi qu’un support pour les interessés de cette réalisation.

https://github.com/Lebelge2/Carte-16-entrees-RailCom


La carte transmet les  rapports d'occupations et détection RailCom via son interface série isolée galvaniquement (9bits, 250.000 bauds)

Les messages peuvent être envoyés sur un logiciel de train tel que : CDM-Rail, JMRI, Rocrail ou LaBox.

La carte fille ATXMEGA128 est fournie sans Bootloader, un programmateur spécifique (PDI) est nécessaire. Voir la doc. (Programmer ATXMEGA128) sur mon Github.


Prix aproximatif des composants de la carte :

PCB carte mère (5 pièces JLCPCB)         5 €
ATXMEGA128 carte fille Olimex         15 €
1 ADUM 1201 (Isolateur magnétique)     1 €
33 diodes 1N5821 (lot de 50)                   4,15 €
32 résistances 1k (lot de 100)                   1,50 €
3 réseaux R1k (lot de 10)                          1,90 €
4 connecteurs mâles 2x10 (lot de 10)        2 €
20 LED 3mm (lot de 100)                         2 €
1 régulateur 7805 (lot de 10)                     1 €
21 borniers pich 5,08 (lot de 30)               3,40 €

Petit matériel
-----------------
1 transistor Mosfet BS170
2 condensateurs 22µF
2 condensateurs 100nF
1 diode Zener 3v3
1 résistance 100  Ohms
1 résistance 10K
1 résistance 20   Ohms 1W
1 Barette pico mâle et femelle 2,54

!!! Remarque :  Les frais de livraisons sont plus chères que le prix des pièces !!!

Démo. avec ce petit script à mettre dans le  void loop()  du  .ino
Affiche dans le moniteur les itinéraires  et numéros des locomotives.

Code: [Sélectionner]


unsigned long crT1 = 0;      // currentTime1
unsigned long pvT1 = 0;     // previousTime1
int DataTemp;
int Data[10];
int NbrData;
int i;

void setup() {   // Dans le setup configurer le sériél
  Serial1.begin(250000, SERIAL_8N1, 13, 14);   // Carte RailCom
//  Serial2.begin(250000, SERIAL_8N1, 15, 17);   // Carte RailCom
}

void loop() {  // A mettre à la fin du loop()

  if (Serial1.available()) {
    DataTemp = (Serial1.read());                 // Lit Data
    crT1 = millis();
    if ((crT1 - pvT1) > 10) {                    // >10ms,  Premier Data
      pvT1 = crT1;
      i = 0;                                     // Init tableau
      NbrData = DataTemp;                        // Nombre de Data dans trame
    }
    Data[i++] = DataTemp;                        // Mémorise les data
    if (i == NbrData + 1) {                      // Tous les Data reçus ?
      if (Data[1] == 2) {                        // Détection RailCom
        Serial.print("Loco n°");   Serial.print(Data[3]);
        if (Data[4] == 0)          Serial.print(" entre dans canton n°");
        else                       Serial.print(" entre à contre sens dans canton n°"); //0x80
        Serial.println(Data[2]+1);
      }
    }
  }
}

Bien à vous.

4

Vos projets / Une interface XpressNet pour LaBox.

« le: septembre 01, 2024, 04:43:48 pm »

XPressNet est un bus de commande utilisé par Atlas, Lenz, Hornby, OpenDCC (DIY), Paco Canada (DIY), ZTC Controls, Viessmann, et Roco. Il a été développé par Lenz.

Bonjour.
Pour être réellement polyvalente, il manque à LaBox les interfaces XpressNet, LocoNet, S88…

J’ai équipé la mienne d’une double interface XpressNet
Je vous fait pars de cette réalisation.

Si vous possédez du matériel XpressNet, souris ou autres, voici la possibilité de l’utiliser sur LaBox.

Le Software.

1) Placer les fichiers XpressNet.cpp et XpressNet.h dans le répertoire CommandStation-Ex-Labox

2) Dans CommandStation-Ex-Labox.ino, écrire :
Dans les défines

Code: [Sélectionner]

  #include "XpressNet.h"

A la fin de la fonction Void loop(), écrire :

Code: [Sélectionner]

#ifdef ENABLE_XPRESSNET
  XpressNet();
#endif

3) Dans le fichier "config.h"  (LaBox specific defines)

Code: [Sélectionner]

// Enable XpressNet
#define ENABLE_XPRESSNET

Avec cette première version (V.1.)  il est possible de contrôler les locomotives, vitesses et fonctions, les accessoires voies (aiguillages),  écrire et lire les CV.

Le Hardware.

Composée d’un Max 485 et d’un connecteur RJ11 (ou RJ12)
Elle doit aussi alimenter électriquement (12v) les périphériques (souris) connectés.
J’ai conçu une interface double avec alimentation des périphériques et protection par fusible.

ATTENTION, il y a deux types de connecteurs RJ11 (RJ12), avec les contacts côté PCB ou opposé au PCB, ils ne sont pas compatibles  j’ai réalisé deux interfaces différentes suivant le type de connecteur utilisé, les fichiers Gerber sont disponibles pour production.

Toute la doc. sur mon Github :    https://github.com/Lebelge2/XpressNet-pour-LaBox

5

Vos projets / Booster La Box

« le: juillet 21, 2024, 11:33:30 am »

Une voie de programmation et deux voies principales

Cette réalisation ne requière aucune modification matérielle de La Box.

Bonjour.

Le(s) concepteur(s) de La Box a (ont) eu la bonne idée de l’équiper d’un connecteur d’extension pour évolutions futures.

On peut donc y raccorder un module de puissance L298HN. 2 x 2A pour alimenter deux voies principales

La Box (L6203) devient la voie de programmation.

-   Détection des court-circuits
-   RailCom sur toutes les voies
-   Alimentation indépendante.(Entre 15 et 18Volts)
-   Module L298HN à un prix dérisoire.

Raccordement du module L298HN à La Box

La Pin 13 de l’ESP32  vers ENA et ENB du  module.
La Pin 12 de l’ESP32  vers IN1 et IN4 du module.
La Pin 14 de l’ESP32  vers IN2 et IN3 du module.
La Pin 25 de l’ESP32  vers Sense du module.
Raccorder les masses.
Voir le schéma fournis.

Modifications software.

Quatre fichiers sont à modifier ou à remplacer :
-   CommandStation-EX-LaBox.ino
-   DCCPRMT.cpp
-   DCCPRMT.h
-   config.h et/ou config.labox.h



Toute la doc. sur mon GitHub.

https://github.com/Lebelge2/Booster-La-Box

6

Vos projets / Upgrade de La Box pour compatibilité RailCom.

« le: juillet 18, 2024, 01:37:43 pm »

Bonjour.

Pour les détenteurs de la centrale DCC nommée : La Box, une légère modification hardware et software est possible pour la rendre compatible RailCom.

Les trames DCC produites par l’ESP32 sont d’une très grandes précisions grâce au module RMT.
Le CutOut est généré très précisément 29µs après le bit de stop.

Modification hardware.

La Box utilise un L6203 comme driver.
L’entrée IN1 reçois le signal DCC et l’entrée IN2 reçois le signal DCC inversé.
Les concepteurs de La Box ont utilisé un transistor pour inverser le signal, or ce signal inversé est disponible notamment sur la pin n°27 de l’ESP32.
On simplifie le montage en supprimant T1, R1, R2.  et relier la Pin n°27 à IN2. (voir schéma modifié et photo)

Modification software.

-   Créer le symbole RMT du CutOut et l’insérer dans la trame.
-   Utiliser un Timer en mode scheduler pour adapter les signaux de sorties.

Les fichiers suivants sont à modifier ou à remplacer :

-   CommandStation-EX-LaBox.ino
-   DCCPRMT.cpp
-   DCCPRMT.h
-   config.h

Toute la doc. pour upgrader votre Box se trouve sur mon GitHub :

https://github.com/Lebelge2/Upgrade-La-Box

7

Le logiciel DCC++ / Logiciel DCC BaseStation avec fonction RailCom

« le: mai 09, 2024, 02:08:47 pm »

Bonjour.

J’ai modifié légèrement ce logiciel pour qu’il insère un CutOut  à la fin des trames.
Donc maintenant compatible RailCom.

Fonctionne sur Mega et Uno.

Dans DCCpp_Uno, chercher l’interruption :  ISR(TIMER1_COMPB_vect)  (Ligne 457)
Remplacer la par le code  ci-dessous.

Code: [Sélectionner]

///////////////////////////////////////////////////////////////////////////////
// NOW USE THE ABOVE MACRO TO CREATE THE CODE FOR EACH INTERRUPT

/* Suivant votre configuration matériel, modifier les Ports et Pins
 *  Dans cet example, L298N et L6203 entrées, IN1=>PB5 =>11.  IN2=>PB7=>13 (Mega)
 *  LMD18200 entrée DIR=>PB6=>12.  Brake=>PB4=>10 (Mega)
 *  Ne pas omettre les Pins en sorties.
*/
bool EndBit;
bool CutOut;
ISR(TIMER1_COMPB_vect) {
  if (CutOut == false) {
    PORTB = PORTB | B10000000;               // PB7 IN1 niveau haut
    PORTB = PORTB &= ~ B00100000;            // PB5 IN2 niveau bas
  } else                                     // CutOut:
    PORTB = PORTB | B10110000;               // IN1, IN2 et Brake (PB4)niveau haut
  DCC_SIGNAL(mainRegs, 1);                   // Vers chargement du timer1
  if (mainRegs.currentBit == 2) {            // Fin Bit Stop
    OCR1B = 450;                             // Le Bit suivant aura un niveau bas de 30µs,
    OCR1A = 7107;                            // puis un niveau haut de 418µs.
    EndBit = true;                           // Validation
  }
}

ISR(TIMER1_COMPA_vect) {
  PORTB = PORTB &= ~ B10000000;              // PB7 IN1 niveau bas
  PORTB = PORTB | B00100000;                 // PB5 IN2 niveau haut
  if (CutOut == true) {
    PORTB = PORTB &= ~ B10110000;            // Fin CutOut, pins IN1, IN2, Brake (PB4) niveaux bas
    EndBit = false;
    CutOut = false;
  }
  if (EndBit == true)
    CutOut = true;
}

Il faut activer la nouvelle interruption. (ISR(TIMER1_COMPA_vect))
A la ligne 309, écrivez :   bitSet(TIMSK1,OCIE1A);   

Testé avec Mega, Uno et L298N, doit fonctionner avec L6203
Je viens de recevoir un LMD18200 mais il est défectueux, pas testé

Bien à vous.

8

Le logiciel DCC++ / Logiciel DCC CommandStation –EX-master avec fonction RailCom

« le: mai 07, 2024, 02:23:55 pm »

Bonjour.

J’ai modifié légèrement ce logiciel pour qu’il insère un CutOut  à la fin des trames.
Donc maintenant compatible RailCom.

Fonctionne sur Mega et Uno.

Restrictions :

Pour le Mega; Dans MotorDriver.h  la Pin 9 est imposée.
    ex: new MotorDriver(7, 9, UNUSED_PIN, UNUSED_PIN, A0, 2.99, 2000, UNUSED_PIN),
Pour l'Uno; Dans MotorDriver.h  la Pin 12 est imposée.
    ex: new MotorDriver(7, 12, UNUSED_PIN, UNUSED_PIN, A0, 2.99, 2000, UNUSED_PIN),

Trois nouvelles sorties pour les signaux (Out1, Out2, CutOut/Brake) sur PC0, PC1, PC2
 (sur Mega 35 36 37, Uno A0 A1 A2)
Bien entendu que toutes les sorties d’origines fonctionnent toujours mais sans CutOut.
Le code est extrêmement simple, les bidouilleurs pourront modifier toutes les sorties.

La modification logiciel :

Tout ce passe dans l’interruption du Timer1 :ISR(TIMER1_OVF_vect)   dans DCCTimerAVR.cpp
Il faut la remplacer par le code que je propose ci-dessous avec les défines et variables.

Code: [Sélectionner]

#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)  // MEGA
#define PINx   PINH             // Pin numéro 9 sur Mega (PH6)     
#define PinIn  6                // new MotorDriver(7, 9, UNUSED_PIN, UNUSED_PIN, A0, 2.99, 2000, UNUSED_PIN),
#define PORTx  PORTC            // Pin de sorties des signaux Out1, Out2, Brake/CutOut sur port C
#define Etat1  B00000100        // -_-_-_   Direct   Pin 35  (In1 pour type L298N, L6203, Dir pour type LMD18200)
#define Etat2  B00000010        // _-_-_-   Inversé  Pin 36  (In2 pour type L298N, L6203, Dir pour type LMD18200)
#define CutOut_ON  B00000111    // __----__          Pin 37  (BraKe Pour Type LMD08200)
#define CutOut_OFF B00000000    // ________
#else                                                           // UNO
#define PINx  PINB              // Pin numéro 12 sur Uno (PB4)
#define PinIn  4                // new MotorDriver(7, 12, UNUSED_PIN, UNUSED_PIN, A0, 2.99, 2000, UNUSED_PIN),
#define PORTx  PORTC
#define Etat1  B00000100
#define Etat2  B00000010
#define CutOut_ON  B00000111
#define CutOut_OFF B00000000
#endif

int i;
int temps;
int oldtemps;
int bitt;
uint8_t bitCount;
uint8_t DccBitVal;
volatile uint8_t dccrecState;
ISR(TIMER1_OVF_vect) {     // ISR called by timer interrupt every 58uS
  temps = (bitRead(PINx, PinIn));
  if (temps == 1)
    PORTx = Etat1;
  else
    PORTx = Etat2;
  interruptHandler();
 temps = (bitRead(PINx, PinIn));
  i++;
  if ((i % 2) == 0) {
    if (temps != oldtemps) {
      bitt += 1;
      DccBitVal = 0;
    }
    else {
      bitt += 2;
      DccBitVal = 1;
    }
    oldtemps = temps;
    if (bitt > 1) {
      bitt = 0;
      bitCount++;
      switch (dccrecState) {
        case 0:
          if (DccBitVal) {
            if (bitCount >= 10)
              dccrecState = 1;
          }
          else {
            bitCount = 0;
          }
          break;
        case  1:
          if (!DccBitVal ) {
            dccrecState = 2;
            bitCount = 0;
          }
          break;
        case 2:
          if (bitCount == 8 ) {
            dccrecState = 3;
          }
          break;
        case 3:
          if ( DccBitVal ) {
            dccrecState = 4;
          }
          else
            dccrecState = 2;
          bitCount = 0;
          break;
        case 4:
          dccrecState = 0;
          PORTx = CutOut_ON;
          delayMicroseconds(420);
          PORTx = CutOut_OFF;
      }
    }
  }
}


Dans le void setup()   (CommandStation-EX), placer le code ci-dessous.

Code: [Sélectionner]

#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)  // MEGA
  pinMode(35, OUTPUT);         // OUT 1  PC0
  pinMode(36, OUTPUT);         // OUT 2  PC1
  pinMode(37, OUTPUT);         // BRAKE  PC2
#else                                                           // UNO
  pinMode(A2, OUTPUT);         // OUT 1  PC0
  pinMode(A1, OUTPUT);         // OUT 2  PC1
  pinMode(A0, OUTPUT);         // BRAKE  PC2
#endif

Testé avec Mega, Uno et L298N, doit fonctionner avec L6203
Je viens de recevoir un LMD18200 mais il est défectueux, donc rien testé

Cablage :
Mega  =======> Bridge  Driver                 
    35  =======> In1  (Dir pour type LMD18200)
    36  =======> In2
    37  =======> Brake, seulement pour type LMD18200

  Uno  =======> Bridge  Driver                 
    A2  =======> In1  (Dir pour type LMD18200)
    A1  =======> In2
    A0  =======> Brake, seulement pour type LMD18200

Bien à vous.

9

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

« le: avril 24, 2024, 02:26:08 pm »

Bonjour.
Certaines centrales DCC notamment les DIY ne sont pas compatibles RailCom car ne génèrent pas le CutOut.
Ce petit montage à base, seulement d’un Arduino Uno, Nano ou Micro s’insère entre la centrale et le Booster.
Il génère le CutOut  afin de la rendre compatible RailCom.
Testé sur un Booster L298N et L6203.
Si dessous, le code et le schéma.
Bien à vous.

Code: [Sélectionner]

// RailCom: Programme pour insérer un CutOut dans les trames DCC.  Arduino Uno, Nano, Micro.
// Testé avec Bridge Driver L6203 et L298N
// V.1.0.   24-04-24
// lebelge2@yahoo.fr

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

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(9600);
  pinMode(PinIn1, INPUT);
  pinMode(PinOut1, OUTPUT);
  pinMode(PinOut2, OUTPUT);
  init_timer2();
  attachInterrupt(digitalPinToInterrupt(PinIn1), Dcc_Interrupt, CHANGE );
  dccIn.port = digitalPinToPort(PinIn1);
  dccIn.bit = digitalPinToBitMask(PinIn1);
  dccIn.portRegister = portInputRegister(dccIn.port);
  Serial.println ("SetUp OK");
}

void loop() {

}

void CutOut(void) {
  delayMicroseconds(8);
  asm("sbi 0x0B, 4");
  asm("sbi 0x0B, 5");
  delayMicroseconds(425);
  asm("cbi 0x0B, 4");
  asm("cbi 0x0B, 5");
}
//----------------------------------------------------------------------------------------------------------
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) {
    asm("cbi 0x0B, 5");
    asm("sbi 0x0B, 4");
    TCCR2B |= (T2_PRESCALER_BITS);  // Start Timer 2
  }
  else {
    asm("cbi 0x0B, 4");
    asm("sbi 0x0B, 5");
  }
}
//-----------------------------------------------------------------------------------
ISR(TIMER2_OVF_vect) {
  uint8_t DccBitVal;
  DccBitVal = !(*dccIn.portRegister & dccIn.bit);
  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
  }
}

10

Vos projets / Décodeur de locomotive multifonctions économique

« le: août 04, 2023, 10:37:08 pm »

Bonjour, cette réalisation s’inspire des travaux de Geoff Bunza .

https://forum.mrhmag.com/post/sma20-low-cost-17-channel-dcc-decoders-ver-6-01-with-soundtriggered-soundstepperdual-motorled-and-12201920

Fabrication :

Sur base d’un Arduino Pro Mini ou Micro :
On lui adjoint dos à dos une « Shield board » comprenant les composant CMS nécessaires pour réaliser un décodeur multifonctions de locomotive économique.

Caractéristiques:
- Dimensions : 33mm x 18mm
- Adresses courtes et longues
- 14, 28 ou 128 pas de vitesses
- 28 Fonctions
- Animations lumineuses.
- Module sonore MP3 externe.
- Servos (max 5)
- 2 Entrées trigger
- RailCom.
- Accélération, décélération.
- Tension de démarrage et maximale.
- Table de vitesse.
- Freinage ABC
- Modification des CV avec centrale ou moniteur série.

 .ino, fichier Gerber, liste des composants, photos etc. sur GitHub

https://github.com/Lebelge2/Loco-Decoder


lebelge2@yahoo.fr

11

Présentez vous ! / Présetation

« le: juin 20, 2023, 09:04:15 pm »

Bonjour.
Electronicien de formation,  mon hobby est le modélisme ferroviaire.
Mon réseau  mesure  +/-  3 mètres sur deux, constitué de 32 cantons entièrement RailCom.
L’électronique du réseau (Booster,  rétro signalisation) est de marque méconnue en France,  c’est du matériel allemand OpenDCC.
La signalisation BAL  3 feux est gérée par un automate Arduino Uno,.
Grâce au RailCom, les locomotives peuvent déclencher des évènements aux entrées ou sorties des cantons, par ex. allumage des phares à l’entrée des tunnels, ralentissement de vitesse au passage dans les gares, positionnement des aiguillages suivant son itinéraire programmé etc.
Ce qui m’intéresse le plus dans modélisme ferroviaire, c’est la partie électronique.
Bien à vous.