Messages récents

1

Vos projets / Re : Éclairage voitures

« Dernier message par pn200 le Aujourd'hui à 09:46:58 pm »

Bonsoir à tous les deux,
Je pense que le montage de LocoFred est bon. Je suis en N, pour mon ICE-T j'ai mis des rubans LEDs 12V. Je prends le DCC puis un pont et direct sur les rubans LEDs, ma centrale est alimentée entre 14 et 15V ça fonctionne correctement. Pour le fil vert une résistance de 10k et le 2N2907 il n'y a pas de raison que ça ne fonctionne pas.
Bernard

2

Vos projets / Re : LaBox" : Une Centrale DCC polyvalente et abordable

« Dernier message par trimarco232 le Aujourd'hui à 08:26:24 pm »

ah tu m'as grillé là , alors j'attends le résultat !
pour les security gaps , c'est définitivement non pour ce qui me concerne , vu que :
- personne n'a encore su me démontrer à quoi ça sert
- s'il y avait un décalage de synchro , il se manifesterait d'abord par des courts circuits en dehors du cutout
- avec un minimum de soin dans la synchro , le pouillème dont tu parles serait largement phagocyté par le dead-time de tout pont en H

3

Vos projets / Re : Éclairage voitures

« Dernier message par laurentr le Aujourd'hui à 08:16:04 pm »

Bonsoir Fred

Tu t'attaques a un "gros morceau".

Je pense que ton idée est valable mais qu'elle va se heurter à quelques déconvenues.
Aussi je pense te donner des indications pour éviter de "dérailler". Cela ne doit pas te décourager ou t empêcher de tester tes montages.

Théoriquement le concept 1 fil parait possible mais il n est pas recommandé car il y a des conditions très particulières pour que cela soit opérationnel. Il vaut mieux "oublier".

Dans mon montage tu as vu 2 transistors l un passe la puissance pour les bandeaux de leds ( je ne recommande pas les rubans 12v... mais ca reste une option valable)  l'autre les instructions de commande venant d un décodeur DCC.

Ces 2 montages n ont pas les mêmes entrées sorties et tensions c est la raison de la présence de ces 2 composants ( l un est un NPN (rouge noir)
l autre un NMOSFET type (BSS138 par exemple).
Le second pilote le 1er.

Chacun agissant dans une boucle (presque) dédiée en quelque sorte.

Les rectangles sont des résistances dont il faudra calculer les valeurs.

Le BUS a forcement 2 fils le + et le -.( départ et retour si tu préfères.)

Rassure toi il m'arrive toujours d'avoir des montages qui ne fonctionnent pas toujours comme attendus.
A défaut de maitriser des outils de simulation il faut tester "en live" et reprendre ce qui ne fonctionne pas comme attendu.

Tu as de quoi expérimenter!
Lance toi sur un montage a blanc sur un plaque d essai. Tu eprouveras ainsi mieux les solutions.

4

Vos projets / Re : Éclairage voitures

« Dernier message par LocoFred le Aujourd'hui à 07:17:49 pm »

Merci Laurent d'essayer de te mettre à ma portée... Ça n'est pas si facile la "vulgarisation" sans vulgarité... 

J'ai bien perçu certaines choses, mais pas totalement le schéma.
J'essaie de répondre à tes questions et à mes besoins :

simple jour/nuit sur une ligne de train? sur des voitures individuellement pilotées ? des leds individuellement pilotées?
Selon celui ci les solutions sont différentes.

Éclairage des voitures d'une rame (nuit), toutes en même temps, quelle que soit la composition de la rame.
+ Allumage des feux de fin de convoi, ou feux avant selon le sens de circulation pour une rame TGV par exemple (feux de fin de convoi et feux avant dans la fausse motrice).
Faire transiter le minimum de fils d'une voiture à l'autre...

Dans tous les cas il faut tenir compte de la consommation du montage car si tu veux éviter de faire chauffer ton convertisseur de tension il est recommandé de passer sur un convertisseur de type DC DC ( BUCK = abaisseur,) pour passer du level DCC ver 5V ou 3v3 par exemple)

J'envisageais bien l'utilisation d'un buck DC-DC, 5v-30v en entrée, 12v en sortie... Correcte ?..

Pour éviter le scintillement tu vas aussi devoir ajouter une  réserve d'énergie: condensateur ou super condensateur dont tu dois réguler la charge et idéalement exploiter la tension de sortie pour compenser sa baisse progressive via un convertisseur DC DC de type BOOST cette fois ci.

J'avais bien envisagé également l'utilisation d'un power pack, par contre, je ne comprends pas le besoin du régulateur (le pont de diodes ne suffit pas ?), ni celle du convertisseur type boost ?
Avec mon montage, je serais en 12v, à priori parfait pour un ruban de led 12v non ?..

Tout cela va occuper un certain volume et il faut l'avoir en tête. Parallèlement le cout de mise en œuvre augmentera plus tu auras de composants à insérer.

Pour le volume, j'en suis bien conscient et c'est l'une des raisons pour lesquelles j'envisageais de placer le montage principal dans le wagon de queue, genre fourgon à bagages ou autre selon disponibilités.
Pour ce qui est du coût de la mise en œuvre, j'imagine aisément que selon les lois du marché, plus la commande est importante, plus le prix est élevé, mais tout ça est à mettre en perspective avec le montant de nos installations mais aussi celui de nos locomotives, voitures et wagons, sans parler des décors, accessoires et autres amusements qui ne devrait ramener le coût supplémentaire qu'à quelques fractions de pourcentage... Bien entendu, je chiffrerai ce coût dès que mon schéma sera validé.

Et enfin,

Pour ce qui est de la suppression du relais un transistor fera office d'interrupteur pour alimenter ou non la ligne de train si tu passes par cette solution.
Il faut juste dimensionner celui ci a la puissance à commuter.

Eh bien en voilà une bonne nouvelle ! J'ai essayé de refaire un schéma avec un transistor PNP, vu que la commande serait effectuée par le "-" du canal auxiliaire, j'avoue ne rien y connaître, mais avoir essayé de m'informer sur la toile... Ce nouveau schéma te semble-t-il correcte ?..
Idem pour le dimensionnement du transistor, mais le calcul pourra se faire ultérieurement si déjà le schéma de principe est validé...

L'idée serait donc de placer un décodeur spécifique (décodeur d'accessoires ou autre, mais pas le décodeur de la loco) dans un wagon de queue ou la fausse motrice d'un TGV.
La puissance électrique serait prise sur les rails par les essieux. Christophe n'a pas l'air de trouver la solution idéale, je regarde pour une alimentation indépendante par batterie.
Le décodeur serait en capacité de commander l'allumage des feux de fin de convoi du wagon de queue ou de la fausse motrice ou celui des feux avant de la fausse motrice.
En plus, il pourrait allumer l'éclairage intérieur de cette voiture en puisant l'énergie dans les rails et transmettre le signal de commande d'éclairage dans les autres voitures par le biais d'un seul fil...
Ainsi, seul le dispositif d'éclairage serait à reproduire dans chaque voiture (Pont, Buck, Diode 1N4148, Résistances, Transistor, Condensateur et Bandeau led).
Je n'ai pas l'impression que le dispositif soit très onéreux ?.. L'avantage serait de ne trimbaler qu'un seul fil entre chaque voiture, mais encore faudrait-il que vous me validiez la conception...



Je termine avec ton schéma Laurent :
Je te remercie encore d'avoir fait l'effort d'essayer de me faire comprendre, mais l'objectif n'est atteint qu'en partie...
Je ne comprends pas précisément la case "Transistors" au pluriel... Envisageais-tu l'utilisation de plusieurs transistors ?..
Je ne comprends pas non plus pourquoi cette case dispose de 4 pôles, alors qu'à ma connaissance, un transistor n'en dispose que de 3 ?..
Je ne comprends pas non plus ce que représentent les petits graffitis en bas de page même si je reconnais l'effort comme louable !..
10k j'imagine que c'est une résistance, mais le reste, je ne vois pas bien... Désolé...
Et enfin la case "Bus", j'imagine que ce serait le fil qui devrait transiter entre chaque wagon ?..

Voilà, j'en ai terminé avec mes questionnements du jour, espérant ne pas lasser tout le monde.

Merci de me donner vos impressions, avis, corrections, enfin tout ce que vous voudrez bien sur le nouveau schéma que je propose.
Et encore merci à tous pour vos contributions.
Sincèrement,
Fred.

5

Vos projets / Re : LaBox" : Une Centrale DCC polyvalente et abordable

« Dernier message par laurentr le Aujourd'hui à 01:03:54 pm »

C est la méthode que je teste actuellement. (sur un ATTINY826) ( avec la partie "logic", "event" n cie)

Dans l'ISR du TIMER affecté au décodage des trames DCC:

Code: [Sélectionner]


//------------------------------------------- ISR ----------------------------------------------------
ISR(DCC_TIMER_INT_vect) {

  DCC_TIMER.EVCTRL ^= TCB_EDGE_bm;                          // Change the event edge at which we trigger
  uint16_t  delta = DCC_TIMER.CCMP;                        // Delta holds the time since the previous interrupt
  uint8_t DccBitVal;

  if ((delta >= ONE_BIT_MIN) && (delta <= ONE_BIT_MAX)) {
    if (dccHalfBit & EXPECT_ONE) {                     // This is the second part of the 1 bit
      dccHalfBit = EXPECT_ANYTHING;
      DccBitVal = 1;
    }
    else if (dccHalfBit & EXPECT_ANYTHING) {           // This is the first part of the 1 bit
      dccHalfBit = EXPECT_ONE;
      return;
    }
    else {                                             // We expected a 1, but received 0 => abort
      DCC_TIMER.EVCTRL ^= TCB_EDGE_bm;                     // Likely J/K should be changed
      dccHalfBit = EXPECT_ANYTHING;
      dccrecState = WAIT_PREAMBLE;
      dccrec.bitCount = 0;
      return;
    }
  }
  else if ((delta >= ZERO_BIT_MIN) && (delta <= ZERO_BIT_MAX)) {
    if (dccHalfBit & EXPECT_ZERO) {                    // This is the second part of the 0 bit
      dccHalfBit = EXPECT_ANYTHING;
      DccBitVal = 0;
      }
    else if (dccHalfBit & EXPECT_ANYTHING) {           // This is the first part of the 0 bit
      dccHalfBit = EXPECT_ZERO;
      return;
    }
    else {                                             // We expected a 0, but received 1 => abort
      dccHalfBit = EXPECT_ANYTHING;
      dccrecState = WAIT_PREAMBLE;
      dccrec.bitCount = 0;
      return;
    }
  }
  else {
    // We ignore other halfbits, to avoid interference with orther protocols.
    // In case railcom would be implemented, here we could detect the cutout start (26..32us)
    return;
  } 


  dccrec.bitCount++;

  switch( dccrecState )
  {
    // According to NMRA standard S9.2, a packet consists of:
    // - Preamble
    // - Packet Start Bit
    // - Address Data Byte:
    // - Data Byte Start Bit + Data Byte [0 or more times]
    // - Packet End Bit

    case WAIT_PREAMBLE:
        // The preamble to a packet consists of a sequence of "1" bits.
        // A digital decoder must not accept as a valid, any preamble
        // that has less then 10 complete one bits
        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:
      // The packet start bit is the first bit with a value of "0"
      // that follows a valid preamble. The packet start bit terminates the preamble
      // and indicates that the next bits are an address data byte
      if( !DccBitVal )                                  // a "0" bit is received
      {
        dccrecState = WAIT_DATA;
        dccrec.tempMessageSize = 0;
        // Initialise all fields
        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:
      // The next bit is either a Data Byte Start Bit or a Packet End Bit
      // Data Byte Start Bit: precedes a data byte and has the value of "0"
      // Packet End Bit: marks the termination of the packet and has a value of "1"
 
      if(DccBitVal) // End of packet?
      {
        // Complete packet received and no errors
        // we are in a CUTOUT AREA NOW
        noInterrupts();
        //no new external event change the sequence actions queue above till queue is over,
        //just add ~500ms latency on any AC0 notifications by interrupt
       
          CUTOUT(bitRead(RAILCOM,0)); //proceed cutout till end of it
         
          //cutout is over now, continue

          dccrecState = WAIT_PREAMBLE; //next step will be at this state

        interrupts();   
     
      }
      else  // Get next Byte   
      {
        dccrecState = WAIT_DATA;
        dccrec.bitCount = 0;                              // prepare for the next byte 
      }   
   
    break;
  }
}


fonction CUTOUT:

Code: [Sélectionner]


void CUTOUT(bool RAILCOM_ACTIV_OR_NOT){
 
  if(RAILCOM_ACTIV_OR_NOT == false) //NO RAILCOM CUTOUT TO INSERT
  {
    //BY PASS CUTOUT: FORCE SOME PINS STATE ON:
    LOGIC_ENABLE_OUT_PIN_ON;
    LOGIC_CUTOUT_OUT_PIN_ON;

    return;
  }

  //RAILCOM ACTIV: NEED TO INSERT CUTOUT
 
  //TIMER B IS ALREADY STARTED AND CNT GO UP     
  if(DCC_TIMER.CNT < ENABLE_STOP_TIME) //< 26us
  {
    //ENABLE ON
    LOGIC_ENABLE_OUT_PIN_ON;
    while(DCC_TIMER.CNT < ENABLE_STOP_TIME) {;}; //WAIT TILL IS OVER
  }
  else if((DCC_TIMER.CNT < CUTOUT_START_TIME) && (DCC_TIMER.CNT >= ENABLE_STOP_TIME)) // >=26us & <30us
  {
    //ENABLE OFF
    LOGIC_ENABLE_OUT_PIN_OFF;
    while(DCC_TIMER.CNT < CUTOUT_START_TIME) {;}; //WAIT TILL IS OVER
  }
  else if((DCC_TIMER.CNT < CUTOUT_STOP_TIME) && (DCC_TIMER.CNT >= CUTOUT_START_TIME)) // >=30us & <484us
  {
    //MAKE CUTOUT:
    LOGIC_CUTOUT_OUT_PIN_ON;
    while(DCC_TIMER.CNT < CUTOUT_STOP_TIME) {;}; //WAIT TILL IS OVER
  }
  else if((DCC_TIMER.CNT < ENABLE_START_TIME) && (DCC_TIMER.CNT >= CUTOUT_STOP_TIME)) // >=484 us & < 488us
  {
    //STOP CUTOUT
    LOGIC_CUTOUT_OUT_PIN_OFF;
    while(DCC_TIMER.CNT < ENABLE_START_TIME) {;}; //WAIT TILL IS OVER
  }
  else if ((DCC_TIMER.CNT >= ENABLE_START_TIME)) // >=488us
  {
    //ENABLE PIN ON:
    LOGIC_ENABLE_OUT_PIN_ON;

    //CUTOUT IS OVER

  }
}




Comme tu le soulignes on a en fait une sortie cote ESP32 qui est une source DCC "universelle" ( voir non amplifiée)  qui peut ensuite être distribuée à tous les CPU effectuant le CUTOUT qui pilotent eux les ponts en H. (L6203 pour  mon cas)
On est alors aligné sur tous les segments.
Les sorties de l'ESP32 sont alors assimilables aux plots CD sur les centrales LENZ pour la synchro inter booster

Pour moi le Security Gap reste de mise pour écarter tout écart restant inter booster lorsqu'un véhicule reste à cheval puisque chaque électronique peut encore varier d'un pouillième...

Il y a donc bien une recomposition du signal entre l'émetteur (EP32) et tous les consommateurs (derrière le(s) pont(s) H) d'un un léger décalage mais qui est constant entre la source unique et tous les consommateurs.

6

Vos projets / Re : LaBox" : Une Centrale DCC polyvalente et abordable

« Dernier message par trimarco232 le Aujourd'hui à 10:18:12 am »

oui , mais ce n'est pas comme ça que je ferais ; si on utilise un MCU fiable pour seconder l'ESP32 , on peut :
1) décoder le packet , genre décodeur ou sniffer , méthode au choix , Aiko Prass , par exemple ; mettre le packet en RAM
2) ressortir le packet avec toutes les caractéristiques que l'on veut : timings précis , cutout , ceci en fonction du pont en H à commander

cette méthode , a toutefois 1 inconvénient lié la désynchronisation : comme les timings en entrée ne sont pas les mêmes qu'en sortie , il faut ajuster
et 1 contrainte à respecter logiquement : si on veut mettre plusieurs booster , il faut les placer en aval du petit MCU ; cela rend alors inutile les security gaps

7

Vos projets / Re : LaBox" : Une Centrale DCC polyvalente et abordable

« Dernier message par laurentr le Aujourd'hui à 02:44:14 am »

C est plus clair comme cela:
 471 se retrouvent avec = (488 -454)/2 + 454

Avec les AVR on peut aller très précisément sur les plages en question grâce aux timer B.
Aussi voila le genre de trame que l'on doit pouvoir traiter pour le résultat qui nous intéresse mais qui requiert un AVR en plus de l'ESP32

Valeurs en accord avec les remarques portées sur le Security Gap d'OPEN DCC: https://www.opendcc.de/info/railcom/railcom_f.shtml

De plus on y inclus les marges des timings selon ce qui sera perçu en entrée.= et toujours conforme au respect de la norme.

Code: [Sélectionner]


// Values for half bits from RCN 210, section 5: http://normen.railcommunity.de/RCN-210.pdf
#define ONE_BIT_MIN                             F_CPU / 1000000 * 52
#define ONE_BIT_MAX                             F_CPU / 1000000 * 64
#define ZERO_BIT_MIN                            F_CPU / 1000000 * 90
#define ZERO_BIT_MAX                            F_CPU / 1000000 * 119


// Values for half bits from RCN 217,
#define ENABLE_STOP_TIME                        F_CPU / 1000000 * 26    // CUTOUT MIN START VALUE
#define ENABLE_START_TIME                       F_CPU / 1000000 * 488  // CUTPOUT MAX STP¨VALUE

// Values according OPEN DCC best practices:
#define CUTOUT_START_TIME                       F_CPU / 1000000 * 30   //4us security gap cutout at start
#define CUTOUT_STOP_TIME                        F_CPU / 1000000 * 484   //4us secutity gap cutout at stop




Code: [Sélectionner]

  //TIMER B IS ALREADY STARTED AND CNT GO UP     
  if(TCB0.CNT < ENABLE_STOP_TIME) //< 26us
  {
    //ENABLE ON
    LOGIC_ENABLE_OUT_PIN_ON;
    while(TCB0.CNT < ENABLE_STOP_TIME) {;}; //WAIT TILL IS OVER
  }
  else if((TCB0.CNT < CUTOUT_START_TIME) && (TCB0.CNT >= ENABLE_STOP_TIME)) // >=26us & <30us
  {
    //ENABLE OFF
    LOGIC_ENABLE_OUT_PIN_OFF;
    while(TCB0.CNT < CUTOUT_START_TIME) {;}; //WAIT TILL IS OVER
  }
  else if((TCB0.CNT < CUTOUT_STOP_TIME) && (TCB0.CNT >= CUTOUT_START_TIME)) // >=30us & <484us
  {
    //MAKE CUTOUT:
    LOGIC_CUTOUT_OUT_PIN_ON;
    while(TCB0.CNT < CUTOUT_STOP_TIME) {;}; //WAIT TILL IS OVER
  }
  else if((TCB0.CNT < ENABLE_START_TIME) && (TCB0.CNT >= CUTOUT_STOP_TIME)) // >=484 us & < 488us
  {
    //STOP CUTOUT
    LOGIC_CUTOUT_OUT_PIN_OFF;
    while(TCB0.CNT < ENABLE_START_TIME) {;}; //WAIT TILL IS OVER
  }
  else if ((TCB0.CNT >= ENABLE_START_TIME)) // >=488us
  {
    //ENABLE PIN ON:
    LOGIC_ENABLE_OUT_PIN_ON;

    //CUTOUT IS OVER

  }
}


A eprouver encore par quelques tests de validation.

8

Vos projets / Re : LaBox" : Une Centrale DCC polyvalente et abordable

« Dernier message par trimarco232 le mai 18, 2024, 11:17:27 pm »

(oui , ce truc n'est pas si évident , on a vite fait de se planter)
si j'ai bien interprété le dessin , concernant le cutout , au niveau de la CS (génération du DCC) , on doit se conformer à 2 valeurs , qui comme toutes les autres , sont mesurées depuis le front montant de ce qui aurait été le 1er bit du preamble , et qui sera donc tronqué :
- Cutout Start : TCS  : 26µs à 32µs // soit 29us pour qui sait faire des timings précis 
- Cutout End :  TCE   : 454µs à 488µs // soit 471us         ii                        ii
la durée du cutout est donc l'heure de sa fin , 471us , moins celle de son début , 29us , ce qui donne "mes"   442us

"mes" 7us , ce n'est pas bien important ; si on prend "mes" valeurs pour le cutout , et que la CS continue de générer des pulses à 58us comme si de rien était , le cutout se terminerait 7us avant le fin du 4ème bit du preamble (largement amputé , du coup) ; ces 7us peuvent varier pour les CS ne respectant pas les 58us (comme certains ne se gênent pas d'en faire)
pour ma part , je laisse tomber ces 7us : je recommence un bit 1 entier , 1er bit du vrai preamble , dès la fin du cutout

je voulais parler des 442us , notamment vis à vis du programme de lebelge2 , où j'ai lu :  delayMicroseconds(412);  ?

9

Vos projets / Re : Éclairage voitures

« Dernier message par laurentr le mai 18, 2024, 01:38:56 pm »

Voila pour illustrer la version la plus basique

10

Vos projets / Re : Éclairage voitures

« Dernier message par laurentr le mai 18, 2024, 01:02:31 pm »

Bonjour Fred

Je vais reformuler:

A/Quel est le besoin:
simple jour/nuit sur une ligne de train? sur des voitures individuellement pilotées ? des leds individuellement pilotées?
Selon celui ci les solutions sont différentes.

Sans tous les cas il faut tenir compte de la consommation du montage car si tu veux éviter de faire chauffer ton convertisseur de tension il est recommandé de passer sur un convertisseur de type DC DC ( BUCK = abaisseur,) pour passer du level DCC ver 5V ou 3v3 par exemple)

Si tu insères un microprocesseur de type AVR ( Arduino) tu vas ajouter de 10 à 15ma et probablement un peu plus pour un ESP32.

Pour éviter le scintillement tu vas aussi devoir ajouter une  réserve d'énergie: condensateur ou super condensateur dont tu dois réguler la charge et idéalement exploiter la tension de sortie pour compenser sa baisse progressive via un convertisseur DC DC de type BOOST cette fois ci.

Tout cela va occuper un certain volume et il faut l'avoir en tête. Parallèlement le cout de mise en œuvre augmentera plus tu auras de composants à insérer.

Pour ce qui est de la suppression du relais un transistor fera office d'interrupteur pour alimenter ou non la ligne de train si tu passes par cette solution.
Il faut juste dimensionner celui ci a la puissance à commuter.