1/160 - Echelle N

Le Forum consacré à l'Echelle N
 
AccueilAccueil  PortailPortail  S'enregistrerS'enregistrer  Connexion  
JOYEUSES FÊTES DE FIN D'ANNÉE À TOUS !

Partagez | 
 

 Faire sa propre centrale DCC

Voir le sujet précédent Voir le sujet suivant Aller en bas 
Aller à la page : Précédent  1, 2, 3, 4, 5, 6 ... 11, 12, 13  Suivant
AuteurMessage
jlb
Membre
Membre


Masculin Age : 52
Localisation : Ici
Nombre de messages : 1465
Date d'inscription : 31/12/2011

MessageSujet: Re: Faire sa propre centrale DCC    Lun 24 Juin - 16:44

Si la loco se déplace à 1 m/s, une cible de 3 mm passe en 3 ms. C'est une impulsion qui est difficilement ratable. Il suffit que le micro lise son entrée toutes les 1,5 ms ou moins et il la voit forcément Smile

Concernant le CNY70, la datasheet donne one distance de 0,3mm. Ça marche quand même à plus longue distance ? jusqu'à combien ?
Revenir en haut Aller en bas
http://modelleisenbahn.triskell.org
SixtyFive
Membre
Membre


Masculin Age : 69
Localisation : 91340
Nombre de messages : 175
Date d'inscription : 21/12/2012

MessageSujet: Re: Faire sa propre centrale DCC    Lun 2 Sep - 21:46

Bonjour à tous,

Je reviens de vacances où j'ai pu cogiter sans mon circuit, ni train, mais avec mon TCO programmé en simulateur et les enfants destinataires du projet : très belle expérience (pour moi) et qui peut peut-être en intéresser certains (merci d'avance de votre retour).

Cette réflexion m'a permis de me forger une conviction sur les 2 sujets suivants :

1) Pilotage manuel ou automatique ?
2) Utilisation du digital DCC uniquement pour les locos (moteur, éclairage, son,..) ou pour TOUT le circuit (y compris les accessoires, aiguilles, signalisation, détecteurs, etc..) ?

Ma réponse est :
1) un mix manuel ET automatique (par exemple laisser tourner quelques trains pendant que j'en pilote un en manuel, mais en respectant la sécurité grâce aux automatismes)
2) piloter en DCC uniquement les trains, le reste étant sous contrôle direct d'un Arduino, ce qui simplifie bigrement le matériel et les coûts !

Je prépare l'explication !
A suivre ...
Revenir en haut Aller en bas
http://bultez.fr
gfaoplus
Membre
Membre


Masculin Age : 55
Localisation : Ile de France - Pontoise
Nombre de messages : 113
Date d'inscription : 01/03/2012

MessageSujet: Re: Faire sa propre centrale DCC    Mar 3 Sep - 7:11

Bonjour,

Est-ce que tu as trouvé les normes pour programmer les CV des décodeurs.
Sur le site du NMRA il y a bien quelque chose mais ce n'est pas très clair.
Sur le site du MOROP il n'y a rien sur la programmation des CV, uniquement sur la commande.

Merci
Revenir en haut Aller en bas
http://www.gpmfao.fr
SixtyFive
Membre
Membre


Masculin Age : 69
Localisation : 91340
Nombre de messages : 175
Date d'inscription : 21/12/2012

MessageSujet: Re: Faire sa propre centrale DCC    Mar 3 Sep - 8:26

gfaoplus a écrit:
Bonjour,

Est-ce que tu as trouvé les normes pour programmer les CV des décodeurs.
Sur le site du NMRA il y a bien quelque chose mais ce n'est pas très clair.
Sur le site du MOROP il n'y a rien sur la programmation des CV, uniquement sur la commande.

Merci
Bonjour,

Pour le moment, je ne cherche pas à programmer les décodeurs, seulement à piloter !
Désolé pour cette "non" réponse !
Pour programmer j'utilise une petite station MS2 de Marklin, minimale mais suffisante pour programmer les adresses des locos.

Plus tard, j'étudierai la question.
Mais j'ai peut-être quelques documents plus clairs que ceux du site NMRA. Si je les retrouve, je penserai à toi.
Cordialement
Revenir en haut Aller en bas
http://bultez.fr
SixtyFive
Membre
Membre


Masculin Age : 69
Localisation : 91340
Nombre de messages : 175
Date d'inscription : 21/12/2012

MessageSujet: Re: Faire sa propre centrale DCC    Mar 3 Sep - 22:01

Je reviens donc sur la réalisation de mon TCO, adapté, bien sûr, à mon petit circuit sur lequel je ne compte pas faire rouler plus de 4 trains à la fois.
Il n'y a pas de boucle de retournement, mais le circuit est fermé et permet de laisser tourner un train sans arrêt.
Du fait qu'il y a une grand portion de voie unique, qui va me permettre de m'éclater en décor, je dois veiller à éviter les collisions entre trains, d'où un découpage en cantons et un certain nombre de capteurs.



J'ai donc 4 aiguilles commandées par 4 clés, des leds vertes pour visualiser les chemins ouverts en fonction de la position des aiguilles, et le circuit est découpé en 8 cantons.
Pour piloter les trains j'ai 4 potentiomètres linéaires, 4 clés de direction et un bouton "magique" dont je parlerai plus loin !



J'en viens aux questions existentielles :

Manuel ou automatique ?
Je comprend bien les réactions que j'ai vues souvent sur le forum du N : un modéliste ne cédera jamais sa place de conducteur à une machine. Et pourtant il y a des centrales super perfectionnées avec pilotage par PC... vas comprendre ...
En fait, moi aussi je tiens à garder un pilotage manuel : c'est pour cela que le TCO à tout ce qu'il faut pour cela :
- un potar de vitesse et une clé de direction par train
- une clé (ou 2 boutons comme chez votre ami) pour chaque aiguille

Piloter 1 seul train ne peut être que manuel (sauf si on veut passer en mode démonstration automatique dans un club ou un salon).
Piloter plusieurs trains, ça se corse ! Soit on est plusieurs et alors il vaut mieux avoir plusieurs stations de commande individuelles (comme des Multimaus, par exemple, ou des MS2, avec un BUS d'intercommunication standard, donc cher et compliqué), car plusieurs mains sur un unique TCO, c'est pas simple. Soit on est obligé de mixer des trains automatiques et des trains à pilotage manuel, si on veut. C'est cette solution que je choisis.

Maintenant, il faut définir ce qu'on entend par automatique ...

Pilotage des aiguilles
Moi aussi j'ai des aiguilles à bobines et 3 fils (Fleichmann) : je vais les commander par des relais : un relai pour le sens droit/dévié et une commande de courant (relai ou transistor, boosté par un condensateur réservoir) pour éviter de laisser la tension en permanence sur les bobines des aiguilles, même si celles-ci ont un contact de fin de course. Je veux "rafraichir" l'état des aiguilles de temps en temps, pour éviter le type de déraillement de Brétigny !!
Je n'ai pas encore fait le schéma, mais je pense à un rafraichissement décalé dans le temps par l'Arduino. Je voudrais aussi piloter les signaux lumineux associés aux aiguilles ... il va falloir prévoir plusieurs 2560 !
Je ne compte pas utiliser de décodeur DCC car c'est plus cher et ça alourdi inutilement la tâche qui génère les trames DCC. Piloter une sortie d'un Arduino en 0/5v est quand même plus simple que de créer et émettre périodiquement une trame DCC ! Je ne suis pas un inconditionnel du DCC partout !

Dans mon cas, étant donné la longue voie unique, je mets un capteur RFID de chaque coté de la gare pour déterminer quel train "entre" et "sort" et  ensuite, seulement des barrières IR partant du principe que les positions ne peuvent pas s'inverser et que les aiguilles déterminent la place des trains sur les quais ou la voie de garage (même si je ne sais plus dans quel ordre sont les trains s'ils sont plusieurs sur la voie de garage, celle-ci étant plus commode à gérer ne mode manuel).

C'est pour cela que j'ai prévu un découpage en cantons selon ce schéma :



Et, de ce fait, je peux arriver à afficher le numéro de train dans chaque canton.
Partant de là, je doit pouvoir assurer la sécurité, c'est à dire éviter que les trains ne se tamponnent !

Je reviens donc sur le débat manuel-automatique, en ce qui concerne mon circuit :
- 1er impératif : détecter les trains et assurer la sécurité : en DCC, on ne peut piloter un train que si on connaît son adresse, d'ou la présence des 2 capteurs RFID.
Ensuite il faut suivre les trains de manière virtuelle en fonction de la position des aiguilles et des détections de passage par de simples barrières IR et juste vérifier l'adresse des trains au passage sur les capteurs RFID, donc avec un bon logiciel de suivi et prédiction/confirmation). Dans mon cas je vais faire un tel logiciel (dont le simulateur est un bon début, sans la gestion des capteurs).
- A partir du moment où cette base existe, passer un train en mode automatique consiste uniquement à le laisser tourner tout seul selon un scénario prédéfini : un circuit et des consignes de temps ou d'horaires. Mais la détection d'occupation et la gestion des ressources restent les même.
- De toute façon, pour avoir une chance de jouer avec les trains à Noel, je vais me contenter de développer d'abord le mode manuel avec la sécurité. Et je travaille à petite vitesse !!

Donc j'ai profité des vacances, sans circuit, ni trains, mais avec juste mon TCO câblé et équipé d'un Arduino 2560, et j'ai écrit ce simulateur dont voici le code :

Code:

#define VERSION "version 1.0b1 du 14/8/13 - Copyright D.Bultez"
#include "Arduino.h"

//TCO Pins

//Afficheurs 7 segments
// segment pins
#define SEGa 22
#define SEGb 23
#define SEGc 24
#define SEGd 25
#define SEGe 26
#define SEGf 27
#define SEGg 28
#define SEGdp 29

// digit pins
#define K1 37
#define K2 36
#define K3 35
#define K4 34
#define K5 33
#define K6 32
#define K7 31
#define K8 30

// leds aiguilles
#define AgD1 49
#define AgD2 48
#define AgD3 47
#define AgD4 46
#define AgD5 45
#define AgD6 44
#define AgD7 43

// clés aiguilles
#define AgC1 38
#define AgC2 39
#define AgC3 40
#define AgC4 41

//boutons de fonction
#define BIT 42          // bouton IT
#define BR 7            // bouton R
#define BStartStop 12   // poussoir STOP / START
#define BFunction 6     // poussoir Fonction

// LOCOS
#define BLoco4 5     // poussoir loco 4
#define BLoco3 4     // poussoir loco 3
#define BLoco2 3     // poussoir loco 2
#define BLoco1 2     // poussoir loco 1

#define LLoco4 53    // led loco 4
#define LLoco3 52    // led loco 3
#define LLoco2 51    // led loco 2
#define LLoco1 50    // led loco 1

// vitesse (pots)
#define VLoco1 A0    // loco 1
#define VLoco2 A2    // loco 2
#define VLoco3 A4    // loco 3
#define VLoco4 A6    // loco 4

// direction (clé)
#define Dir1 A1      // loco 1
#define Dir2 A3      // loco 2
#define Dir3 A5      // loco 3
#define Dir4 A7      // loco 4

// DCC
#define LDCC 13         // led DCC OK

#define DCC_PIN     10  // Arduino pin for DCC out
                        // this pin is connected to "DIRECTION" of LMD18200
#define DCC_PWM     11  // must be HIGH for signal out
                        // connected to "PWM in" of LMD18200


// --------------------------------------------------
//                  GLOBALS
// --------------------------------------------------

byte _seg[8] = { SEGa,SEGb,SEGc,SEGd,SEGe,SEGf,SEGg,SEGdp};  //pin number of segments
byte _allseg[64];                                            //segments states of 8 digits
byte _vide[8] = { 0,0,0,0,0,0,0,0 };
byte _zero[8] = { 1,1,1,1,1,1,0,0 };
byte _un[8] = { 0,1,1,0,0,0,0,0 };
byte _deux[8] = { 1,1,0,1,1,0,1,0 };
byte _trois[8] = { 1,1,1,1,0,0,1,0 };
byte _quatre[8] = { 0,1,1,0,0,1,1,0 };
byte _cinq[8] = { 1,0,1,1,0,1,1,0 };
byte _six[8] = { 1,0,1,1,1,1,1,0 };
byte _sept[8] = { 1,1,1,0,0,0,0,0 };
byte _huit[8] = { 1,1,1,1,1,1,1,0 };
byte _neuf[8] = { 1,1,1,0,0,1,1,0 };
byte _hexA[8] = { 1,1,1,0,1,1,1,0 };
byte _hexb[8] = { 0,0,1,1,1,1,1,0 };
byte _hexc[8] = { 1,0,0,1,1,1,0,0 };
byte _hexd[8] = { 0,1,1,1,1,0,1,0 };
byte _hexE[8] = { 1,0,0,1,1,1,1,0 };
byte _hexF[8] = { 1,0,0,0,1,1,1,0 };
byte _dig[8] = { K1,K2,K3,K4,K5,K6,K7,K8 };

int curdigit = 0;  // digit courant
int lastdigit;     // digit précédant

byte _led[12] = { AgD1,AgD2,AgD3,AgD4,AgD5,AgD6,AgD7,LLoco1,LLoco2,LLoco3,LLoco4,LDCC };  // leds

byte _canton[8] = { 0,0,0,0,0,0,0,0 }; // 0=C1, 1=C2, 2=C3, 3=C4, 4=C5,
                                       // 5=C6(garage), 6=Quai1, 7=Quai2

// locos

byte _loco1[8] = { 03,1,0,2,5,0,0,0 }; // 0=N° DCC de loco, 1=AV-1 ou AR-0, 2=vitesse 1..4 ou arret 0
byte _loco2[8] = { 04,1,0,2,5,0,0,0 }; // 3=temps restant canton en cours, 4=N° canton en cours
byte _loco3[8] = { 05,1,0,2,5,0,0,0 }; // 5=N° canton suivant, 6= reserved for futur use
byte _loco4[8] = { 06,1,0,2,5,0,0,0 }; // 7=Loco autorisee 1=START 0=STOP

byte locoAdr1 = 3;
byte locoAdr2 = 4;
byte locoAdr3 = 5;
byte locoAdr4 = 6;
byte vitesse;
byte dir;

int BLoco1cur;
int BLoco1state = LOW;
int BLoco1count;
int BLoco2cur;
int BLoco2state = LOW;
int BLoco2count;
int BLoco3cur;
int BLoco3state = LOW;
int BLoco3count;
int BLoco4cur;
int BLoco4state = LOW;
int BLoco4count;


// -----------------------------------------------------------------
//                          for DCC protocol
// -----------------------------------------------------------------

#define PREAMBLE 0    
#define SEPARATOR 1
#define SENDBYTE  2

//Timer frequency is 2MHz for ( /8 prescale from 16MHz )
#define TIMER_SHORT 0x8D  // 58usec pulse length
#define TIMER_LONG  0x1B  // 116usec pulse length

unsigned char last_timer=TIMER_SHORT;  // store last timer value  
unsigned char flag=0;  // used for short or long pulse
unsigned char every_second_isr = 0;  // pulse up or down
unsigned char state= PREAMBLE;
unsigned char preamble_count = 16;
unsigned char outbyte = 0;
unsigned char cbit = 0x80;


// -------------------  buffer for DCC commands -------------------

struct Message {
   unsigned char data[7];
   unsigned char len;
} ;

#define MAXMSG  9

struct Message msg[MAXMSG] = {
    { { 0xFF,     0, 0xFF, 0, 0, 0, 0}, 3},    // idle msg
    { { locoAdr1, 0x3F,  0, 0, 0, 0, 0}, 4},   // 128 speed steps and direction (b7) in next byte
    { { locoAdr2, 0x3F,  0, 0, 0, 0, 0}, 4},   // 128 speed steps and direction (b7) in next byte
    { { locoAdr3, 0x3F,  0, 0, 0, 0, 0}, 4},   // 128 speed steps and direction (b7) in next byte
    { { locoAdr4, 0x3F,  0, 0, 0, 0, 0}, 4},   // 128 speed steps and direction (b7) in next byte
    { { locoAdr1, 0x80,  0, 0, 0, 0, 0}, 3},   // Function group 1 : 0x80 means light off
    { { locoAdr2, 0x90,  0, 0, 0, 0, 0}, 3},   // Function group 1 : 0x90 means light on
    { { locoAdr1, 0x80,  0, 0, 0, 0, 0}, 3},   // Function group 1 : 0x80 means light off
    { { locoAdr2, 0x90,  0, 0, 0, 0, 0}, 3}    // Function group 1 : 0x90 means light on
  };              
  // loco msg must be filled later with speed and XOR data byte
  // function msg command 0x80 or 0x90 is filled in "assemble_dcc_msglight()"
                                
int msgIndex=0;  
int byteIndex=0;

boolean debug = false;

unsigned long time;          // INTERNAL TIME FOR 1 SECONDE TEMPO


//------------------------------------------------------
//                    Setup Timer2
//------------------------------------------------------

//Configures the 8-Bit Timer2 to generate an interrupt at the specified frequency.
//Returns the time load value which must be loaded into TCNT2 inside your ISR routine.

void SetupTimer2(){
 
  //Timer2 Settings: Timer Prescaler /8, mode 0
  //Timmer clock = 16MHz/8 = 2MHz oder 0,5usec
  TCCR2A = 0;
  TCCR2B = 0<<CS22 | 1<<CS21 | 0<<CS20;

  //Timer2 Overflow Interrupt Enable  
  TIMSK2 = 1<<TOIE2;

  //load the timer for its first cycle
  TCNT2=TIMER_SHORT;
}

//------------------------------------------------------
//        Timer2 overflow interrupt vector handler  
//------------------------------------------------------

ISR(TIMER2_OVF_vect) {
  //Capture the current timer value TCTN2. This is how much error we have
  //due to interrupt latency and the work in this function
  //Reload the timer and correct for latency.  

  unsigned char latency;
  
  // for every second interupt just toggle signal
  if (every_second_isr)  {
     digitalWrite(DCC_PIN,1);
     every_second_isr = 0;    
    
     // set timer to last value
     latency=TCNT2;
     TCNT2=latency+last_timer;
    
  }  else  {  // != every second interrupt, advance bit or state
     digitalWrite(DCC_PIN,0);
     every_second_isr = 1;
    
     switch(state)  {
       case PREAMBLE:
           flag=1; // short pulse
           preamble_count--;
           if (preamble_count == 0)  {  // advance to next state
              state = SEPARATOR;
              // get next message
              msgIndex++;
              if (msgIndex >= MAXMSG)  {  msgIndex = 0; }  
              byteIndex = 0; //start msg with byte 0
           }
           break;
        case SEPARATOR:
           flag=0; // long pulse
           // then advance to next state
           state = SENDBYTE;
           // goto next byte ...
           cbit = 0x80;  // send this bit next time first        
           outbyte = msg[msgIndex].data[byteIndex];
           break;
        case SENDBYTE:
           if (outbyte && cbit)  {
              flag = 1;  // send short pulse
           }  else  {
              flag = 0;  // send long pulse
           }
           cbit = cbit >> 1;
           if (cbit == 0)  {  // last bit sent, is there a next byte?
              byteIndex++;
              if (byteIndex >= msg[msgIndex].len)  {
                 // this was already the XOR byte then advance to preamble
                 state = PREAMBLE;
                 preamble_count = 16;
              }  else  {
                 // send separtor and advance to next byte
                 state = SEPARATOR ;
              }
           }
           break;
     }  
 
     if (flag)  {  // if data==1 then short pulse
        latency=TCNT2;
        TCNT2=latency+TIMER_SHORT;
        last_timer=TIMER_SHORT;
     }  else  {   // long pulse
        latency=TCNT2;
        TCNT2=latency+TIMER_LONG;
        last_timer=TIMER_LONG;
     }  
  }
}

//---------------------------------------
//                  SETUP
//---------------------------------------

void setup(void) {
  int i;
// init PinMode for 8 segment displays
for (i = 0; i < 8; i++) {
  pinMode(_seg[i], OUTPUT);
  digitalWrite(_seg[i], HIGH);
  pinMode(_dig[i], OUTPUT);
  digitalWrite(_dig[i], HIGH); // all OFF
}

// init PinMode for leds
for (i = 0; i < 12; i++) {
  pinMode(_led[i], OUTPUT);
  digitalWrite(_led[i], HIGH);  // all ON
  }
  delay (500);
for (i = 0; i < 12; i++) {
  digitalWrite(_led[i], LOW);  // all OFF
  }
  
// init PinMode for switches
pinMode(AgC1, INPUT_PULLUP);
pinMode(AgC2, INPUT_PULLUP);
pinMode(AgC3, INPUT_PULLUP);
pinMode(AgC4, INPUT_PULLUP);

pinMode(BIT, INPUT_PULLUP);
pinMode(BR,  INPUT_PULLUP);
pinMode(BFunction,  INPUT_PULLUP);
pinMode(BStartStop,  INPUT_PULLUP);

// locos
pinMode(BLoco1,  INPUT_PULLUP);
pinMode(BLoco2,  INPUT_PULLUP);
pinMode(BLoco3,  INPUT_PULLUP);
pinMode(BLoco4,  INPUT_PULLUP);
pinMode(Dir1,  INPUT_PULLUP);
pinMode(Dir2,  INPUT_PULLUP);
pinMode(Dir3,  INPUT_PULLUP);
pinMode(Dir4,  INPUT_PULLUP);

// speed pots
pinMode(VLoco1,  INPUT);
pinMode(VLoco2,  INPUT);
pinMode(VLoco3,  INPUT);
pinMode(VLoco4,  INPUT);

// DCC pins
pinMode(DCC_PIN, OUTPUT);
pinMode(DCC_PWM, OUTPUT);

// init _allseg[64] & _hexseg[128]

for (i = 0; i < 64; i++) { _allseg[i] = 0; }

Serial.begin(9600);
delay(100);
Serial.println(VERSION);
  
//Start the timer
SetupTimer2();  
delay(100);
Serial.println("DCC ready");

//départ temps loop
time = millis();              // départ timer seconde
delay(100);
Serial.println("Second Timer started");

}            // end SETUP


//---------------------------------------
//                  LOOP
//---------------------------------------

void loop(void) {
  
  int i, j;
  
//multiplexage des afficheurs
digitalWrite(_dig[lastdigit], HIGH);      // éteint le digit allumé
for (j = 0; j < 8; j++) {
  digitalWrite(_seg[j], _allseg[j+8*curdigit]);    // recopie des segments pour le digit suivant
  }
digitalWrite(_dig[curdigit], LOW);      // allume le digit suivant durant toute la durée de loop()
lastdigit = curdigit;
curdigit = curdigit +1;
if (curdigit > 7) {curdigit = 0;}

//gestion des led aiguilles en fonction des clés  
  digitalWrite(_led[0] , digitalRead(AgC1)); // A1 droit
  digitalWrite(_led[2] , !digitalRead(AgC1)); // A1 devie
  digitalWrite(_led[3] , !digitalRead(AgC2)); // A2 devie
  digitalWrite(_led[1] , digitalRead(AgC2) & !digitalRead(AgC3));
  digitalWrite(_led[4] , digitalRead(AgC2) & digitalRead(AgC3));
  digitalWrite(_led[5] , !digitalRead(AgC4)); // A4 droit (entrée sortie de garage)
  digitalWrite(_led[6] , digitalRead(AgC4)); // A4 devie (boucle garage)
  
  
//gestion des taches toutes les secondes
if ((time+1000) < millis())  {
  time = time+1000;              // pour rattraper les secondes si ça dérape
  SR_second();
 }

// vitesse locos
  vitesse = (4L * analogRead(VLoco1))/1023;
  _loco1[2] = vitesse;
  vitesse = (4L * analogRead(VLoco2))/1023;
  _loco2[2] = vitesse;
  vitesse = (4L * analogRead(VLoco3))/1023;
  _loco3[2] = vitesse;
  vitesse = (4L * analogRead(VLoco4))/1023;
  _loco4[2] = vitesse;
  
// gestion des boutons hors locos
if (!digitalRead(BIT) ) {

  }

if (!digitalRead(BR) ) {

  }

if (!digitalRead(BStartStop) ) {
  Stop_loco1();
  Stop_loco2();
  Stop_loco3();
  Stop_loco4();
  delay(1000);
  }

 
// debug on console
if (!digitalRead(BFunction)) {
  if (debug) {
  Serial.print("LOCOS ");
  Serial.print(_loco1[0]);
  Serial.print(_loco1[1]);
  Serial.print(_loco1[2]);
  Serial.print(_loco1[3]);
  Serial.print(_loco1[4]);
  Serial.print(_loco1[5]);
  Serial.print(_loco1[7]);
  Serial.print(" ");
  Serial.print(_loco2[0]);
  Serial.print(_loco2[1]);
  Serial.print(_loco2[2]);
  Serial.print(_loco2[3]);
  Serial.print(_loco2[4]);
  Serial.print(_loco2[5]);
  Serial.print(_loco2[7]);
  Serial.print(" ");
  Serial.print(_loco3[0]);
  Serial.print(_loco3[1]);
  Serial.print(_loco3[2]);
  Serial.print(_loco3[3]);
  Serial.print(_loco3[4]);
  Serial.print(_loco3[5]);
  Serial.print(_loco3[7]);
  Serial.print(" ");
  Serial.print(_loco4[0]);
  Serial.print(_loco4[1]);
  Serial.print(_loco4[2]);
  Serial.print(_loco4[3]);
  Serial.print(_loco4[4]);
  Serial.print(_loco4[5]);
  Serial.print(_loco4[7]);
  Serial.print(" -CANTONS- ");
  Serial.print(_canton[0]);
  Serial.print(_canton[1]);
  Serial.print(_canton[2]);
  Serial.print(_canton[3]);
  Serial.print(_canton[4]);
  Serial.print(_canton[5]);
  Serial.print(_canton[6]);
  Serial.println(_canton[7]);
  delay(100);
  }
  }

    
if (Serial.available())  {
  char inByte = Serial.read();
  switch (inByte) {
   case '=' :
   for (i = 0; i<11; i++) {
     Serial.print(digitalRead(_led[i]));
   }
   Serial.println();
   break;
   case '@' :
   debug = !debug;
   break;
   default :
   break;
  }
}
  
}            // end LOOP

//------------------------------------
Code:

// -----------------------------------------------------------------------
//                 ROUTINE À CHAQUE SECONDE
// -----------------------------------------------------------------------

void SR_second() {             // routine periodique (1 seconde)

/*
test et décrément durée dans canton de chaque loco et avancement au canto suivant si dispo
si la vitesse de la loco n'est pas = 0
- si durée = 0 avant décrément, la loco attend la disponibilité du canton suivant
- si durée = 0 après décrément, canto suivant (selon direction), sinon pas de changement
- au changement de canton, la nouvelle durée devient inversement proportionnelle à la vitesse
- si canton suivant non dispo (#0) clignotement du n° de loco
rappel :
byte _canton[8] = { 0,0,0,0,0,0,0,0 }; // 0=C1, 1=C2, 2=C3, 3=C4, 4=C5, 5=C6(garage), 6=Quai1, 7=Quai2
byte _loco1[8] = { 03,1,0,2,5,0,0,0 }; // 0=N° DCC de loco, 1=AV-1 ou AR-0, 2=vitesse 1..4 ou arret 0
byte _loco2[8] = { 04,1,0,2,5,0,0,0 }; // 3=temps restant canton en cours, 4=N° canton en cours
byte _loco3[8] = { 05,1,0,2,5,0,0,0 }; // 5=N° canton suivant, 6= reserved for futur use
byte _loco4[8] = { 06,1,0,2,5,0,0,0 }; // 7=Loco autorisee 1=START 0=STOP
*/

if (debug) {
Serial.print(time);
Serial.print(" cantons ");
}

// Gestion des boutons de fonction loco

BLoco1cur = digitalRead(BLoco1); //enfoncé = LOW
if (BLoco1cur == LOW && BLoco1count == 0)  { BLoco1count++; }  // attente seconde suivante
if (BLoco1cur == LOW && BLoco1count == 1)  {    //LOW > 1 seconde = debounced
  BLoco1count = 0;
  BLoco1state = !BLoco1state;
  if (BLoco1state == HIGH) { Start_loco1(); } else { Stop_loco1(); }
}

BLoco2cur = digitalRead(BLoco2); //enfoncé = LOW
if (BLoco2cur == LOW && BLoco2count == 0)  { BLoco2count++; }  // attente seconde suivante
if (BLoco2cur == LOW && BLoco2count == 1)  {    //LOW > 1 seconde = debounced
  BLoco2count = 0;
  BLoco2state = !BLoco2state;
  if (BLoco2state == HIGH) { Start_loco2(); } else { Stop_loco2(); }
}

BLoco3cur = digitalRead(BLoco3); //enfoncé = LOW
if (BLoco3cur == LOW && BLoco3count == 0)  { BLoco3count++; }  // attente seconde suivante
if (BLoco3cur == LOW && BLoco3count == 1)  {    //LOW > 1 seconde = debounced
  BLoco3count = 0;
  BLoco3state = !BLoco3state;
  if (BLoco3state == HIGH) { Start_loco3(); } else { Stop_loco3(); }
}

BLoco4cur = digitalRead(BLoco4); //enfoncé = LOW
if (BLoco4cur == LOW && BLoco4count == 0)  { BLoco4count++; }  // attente seconde suivante
if (BLoco4cur == LOW && BLoco4count == 1)  {    //LOW > 1 seconde = debounced
  BLoco4count = 0;
  BLoco4state = !BLoco4state;
  if (BLoco4state == HIGH) { Start_loco4(); } else { Stop_loco4(); }
}

// ----------------------------
//     avancement Loco1
// ----------------------------
if (_loco1[7] == 1) {              // si en cours de manoeuvre
 if (debug) { Serial.print(_loco1[4]); }  //position courante
  dir = digitalRead(Dir1);
  _loco1[1] = dir;
  _loco1[5] = CantonSuivant(_loco1[4]);
// décrément du temps restant si > 0
 if (_loco1[3] > 0) { _loco1[3]--; }
 // si le temps = 0 tentative de passer au canton suivant sinon arret
 if ((_loco1[3] == 0) & !(_loco1[5] == _loco1[4]) & (_canton[_loco1[5]] == 0))  {
  // test canton suivant # du canton en cours
  // et canton suivant libre
   _canton[_loco1[4]] = 0;       // liberation du canton quitté
   razdigit(_loco1[4]);          // raz du digit TCO
   _loco1[4] = _loco1[5];        // maj du canton en cours
   setdigit1(_loco1[4]);         // digit occupé marqué 1
   _canton[_loco1[4]] = 1;       // marquage du canton avec le N° de loco
   _loco1[3] = NewDureeCanton(_loco1[2]); // reinit duree dans le canton
 }
}

// ----------------------------
//     avancement Loco2
// ----------------------------
if (_loco2[7] == 1) {
 if (debug) { Serial.print(_loco2[4]); }  //position courante
  dir = digitalRead(Dir2);
  _loco2[1] = dir;
  _loco2[5] = CantonSuivant(_loco2[4]);
// décrément du temps restant si > 0
 if (_loco2[3] > 0) { _loco2[3]--; }
 // si le temps = 0 tentative de passer au canton suivant sinon arret
 if ((_loco2[3] == 0) & !(_loco2[5] == _loco2[4]) & (_canton[_loco2[5]] == 0))  {
  // test canton suivant # du canton en cours
  // et canton suivant libre
   _canton[_loco2[4]] = 0;       // liberation du canton quitté
   razdigit(_loco2[4]);          // raz du digit TCO
   _loco2[4] = _loco2[5];        // maj du canton en cours
   setdigit2(_loco2[4]);         // digit occupé marqué 2
   _canton[_loco2[4]] = 2;       // marquage du canton avec le N° de loco
   _loco2[3] = NewDureeCanton(_loco2[2]); // reinit duree dans nouveau canton
 }
}

// ----------------------------
//     avancement Loco3
// ----------------------------
if (_loco3[7] == 1) {
 if (debug) { Serial.print(_loco3[4]); }  //position courante
  dir = digitalRead(Dir3);
  _loco3[1] = dir;
  _loco3[5] = CantonSuivant(_loco3[4]);
// décrément du temps restant si > 0
 if (_loco3[3] > 0) { _loco3[3]--; }
 // si le temps = 0 tentative de passer au canton suivant sinon arret
 if ((_loco3[3] == 0) & !(_loco3[5] == _loco3[4]) & (_canton[_loco3[5]] == 0))  {
  // test canton suivant # du canton en cours
  // et canton suivant libre
   _canton[_loco3[4]] = 0;       // liberation du canton quitté
   razdigit(_loco3[4]);          // raz du digit TCO
   _loco3[4] = _loco3[5];        // maj du canton en cours
   setdigit3(_loco3[4]);         // digit occupé marqué 3
   _canton[_loco3[4]] = 3;       // marquage du canton avec le N° de loco
   _loco3[3] = NewDureeCanton(_loco3[2]); // reinit duree dans nouveau canton
 }
}

// ----------------------------
//     avancement Loco4
// ----------------------------
if (_loco4[7] == 1) {
 if (debug) { Serial.print(_loco4[4]); }  //position courante
  dir = digitalRead(Dir4);
  _loco4[1] = dir;
  _loco4[5] = CantonSuivant(_loco4[4]);
// décrément du temps restant si > 0
 if (_loco4[3] > 0) { _loco4[3]--; }
 // si le temps = 0 tentative de passer au canton suivant sinon arret
 if ((_loco4[3] == 0) & !(_loco4[5] == _loco4[4]) & (_canton[_loco4[5]] == 0))  {
  // test canton suivant # du canton en cours
  // et canton suivant libre
   _canton[_loco4[4]] = 0;       // liberation du canton quitté
   razdigit(_loco4[4]);          // raz du digit TCO
   _loco4[4] = _loco4[5];        // maj du canton en cours
   setdigit4(_loco4[4]);         // digit occupé marqué 4
   _canton[_loco4[4]] = 4;       // marquage du canton avec le N° de loco
   _loco4[3] = NewDureeCanton(_loco4[2]); // reinit duree dans nouveau canton
 }
}
 if (debug) { Serial.println(); }

} // fin de SR_second()
Code:


// ----------------------------
//         DUREE DANS UN CANTON
// ----------------------------

byte NewDureeCanton(byte vitesse)  {
  byte duree;
  switch (vitesse) {
    case 1:
      duree = 4;
      break;
    case 2:
      duree = 3;
      break;
    case 3:
      duree = 2;
      break;
    case 4:
      duree = 1;
      break;
    default:
      duree = 4;
      break;
  }
  return duree;
}

// ----------------------------
//         CANTON SUIVANT
// ----------------------------

byte CantonSuivant(byte canton)  {
  
  byte result = canton;  //sans changement par défaut
  
  switch (canton) {
    case 0: // depuis C1 > C2 ou quai 1 / 2 ou C5
      if (dir) {
        result = 1;
        } else {
          if (digitalRead(AgC2))  {
            if ((!digitalRead(AgC4) & digitalRead(AgC3))) { result = 5; }
            if (!digitalRead(AgC3)) { result = 6; }
          } else { result = 7; }
        }
      break;
      
    case 1: //depuis C2 > C3 ou C1
      if (dir) {result =  2;} else {result = 0;}
      break;
      
    case 2: //depuis C3 > C4 ou C2
      if (dir) {result =  3;} else {result = 1;}
      break;
      
    case 3: //depuis C4 > C5 ou C3
      if (dir) {result =  4;} else {result = 2;}
      break;
      
    case 4: //depuis C5 vers quai 1 / 2 suivant aiguille 1 ou C3
      if (dir) {
        if (digitalRead(AgC1))  {
          result =  6;  //quai 1
        } else {
          result =  7;//quai 2
        }
      } else { result = 3; }
      break;
      
    case 5:  //du garage vers C1 suivant aiguilles 2, 3 et 4
      if (dir) {
        if ((!digitalRead(AgC4) & digitalRead(AgC2) & digitalRead(AgC3))) {
          result =  0;
        } else {
          result = 5; //reste garage  
        }
      } else { result = 5; }
      break;
      
    case 6:  //depuis quai 1 > C1 ou C5
      if (dir) {
        if (digitalRead(AgC2) && !digitalRead(AgC3)) {
          result =  0; //C1
        } else {
          result = 6; // reste à quai 1
        }
      } else {
        if (digitalRead(AgC1))  {
          result =  4;  //C5
        }
      }
      break;
      
    case 7:  //depuis quai 2 > C1 ou C5
      if (dir) {
        if (!digitalRead(AgC2)) {
          result =  0;  //C1
        } else {
          result = 7; // reste à quai 2
        }
      } else {
        if (!digitalRead(AgC1))  {
          result =  4;  //C5
        }
      }
      break;
      
    default:
      result =  0;
      break;
  }
  return result;
}

// ----------------------------
//         RAZ DIGIT 7 SEGMENT
// ----------------------------

void razdigit(byte c)  {
  int s;
  for (s = 0; s < 8; s++) {
   _allseg[s+(8*c)] = _vide[s]; // insertion du carcatère hexa suivant à gauche  
 }
}

// ----------------------------
//         SET DIGIT 7 SEGMENT
// ----------------------------

void setdigit1(byte c)  {
  int s;
  for (s = 0; s < 8; s++) {
   _allseg[s+(8*c)] = _un[s]; // insertion du carcatère hexa suivant à gauche
 }
}

void setdigit2(byte c)  {
  int s;
  for (s = 0; s < 8; s++) {
   _allseg[s+(8*c)] = _deux[s]; // insertion du carcatère hexa suivant à gauche
 }  
}

void setdigit3(byte c)  {
  int s;
  for (s = 0; s < 8; s++) {
   _allseg[s+(8*c)] = _trois[s]; // insertion du carcatère hexa suivant à gauche
 }  
}

void setdigit4(byte c)  {
  int s;
  for (s = 0; s < 8; s++) {
   _allseg[s+(8*c)] = _quatre[s]; // insertion du carcatère hexa suivant à gauche
 }  
}


// ----------------------------
//         INIT LOCOS
// ----------------------------

boolean Start_loco1()  {
  boolean r=false;
  _loco1[2] = 1; //vitesse réduite = 1
  _loco1[3] = 4; //durée 4
  _loco1[4] = 6; //quai 1
  _loco1[5] = 0; //canton 1
  if (_canton[6] == 0) { //disponible
    _canton[6] = 1; // canton occupé
    _loco1[7] = 1;  // loco autorisée à rouler
    setdigit1(6);
    digitalWrite(_led[7] , HIGH);
    r = true;
    if (debug) { Serial.println("start loco 1");}
  } else { blinkLocoLed(7); }
}

boolean Start_loco2()  {
  boolean r=false;
  _loco2[2] = 1; //vitesse réduite = 1
  _loco2[3] = 4; //durée 4
  _loco2[4] = 7; //quai 2
  _loco2[5] = 0; //canton 1
  if (_canton[7] == 0) { //disponible
    _canton[7] = 2; // canton occupé
    _loco2[7] = 1;  // loco autorisée à rouler
    setdigit2(7);
    digitalWrite(_led[8] , HIGH);
    r = true;
    if (debug) { Serial.println("start loco 2");}
  } else { blinkLocoLed(8); }  
}

boolean Start_loco3()  {
  boolean r=false;
  _loco3[2] = 1; //vitesse réduite = 1
  _loco3[3] = 4; //durée 4
  _loco3[4] = 5; //garage
  _loco3[5] = 0; //
  if (_canton[5] == 0) { //disponible
    _canton[5] = 3; // canton occupé
    _loco3[7] = 1;  // loco autorisée à rouler
    setdigit3(5);
    digitalWrite(_led[9] , HIGH);
    r = true;
    if (debug) { Serial.println("start loco 3");}
  } else { blinkLocoLed(9); }  
}

boolean Start_loco4()  {
  boolean r=false;
  _loco4[2] = 1; //vitesse réduite = 1
  _loco4[3] = 4; //durée 4
  _loco4[4] = 5; //garage
  _loco4[5] = 0; //
  if (_canton[5] == 0) { //disponible
    _canton[5] = 4; // canton occupé
    _loco4[7] = 1;  // loco autorisée à rouler
    setdigit4(5);
    digitalWrite(_led[10] , HIGH);
    r = true;
    if (debug) { Serial.println("start loco 4");}
  } else { blinkLocoLed(10); }  
}

// ----------------------------
//         RESET LOCOS
// ----------------------------

boolean Stop_loco1()  {
  if (_loco1[7] == 1) {
  digitalWrite(_led[7] , LOW);
  _loco1[7] = 0;
  _canton[_loco1[4]] = 0;       // liberation du canton quitté
  razdigit(_loco1[4]);          // raz du digit TCO
  if (debug) { Serial.println("stop loco 1");}
  }
}

boolean Stop_loco2()  {
  if (_loco2[7] == 1) {
  digitalWrite(_led[8] , LOW);
  _loco2[7] = 0;
  _canton[_loco2[4]] = 0;       // liberation du canton quitté
  razdigit(_loco2[4]);          // raz du digit TCO
  if (debug) { Serial.println("stop loco 2");}
  }
}

boolean Stop_loco3()  {
  if (_loco3[7] == 1) {
  digitalWrite(_led[9] , LOW);
  _loco3[7] = 0;
  _canton[_loco3[4]] = 0;       // liberation du canton quitté
  razdigit(_loco3[4]);          // raz du digit TCO
  if (debug) { Serial.println("stop loco 3");}
  }
}

boolean Stop_loco4()  {
  if (_loco4[7] == 1) {
  digitalWrite(_led[10] , LOW);
  _loco4[7] = 0;
  _canton[_loco4[4]] = 0;       // liberation du canton quitté
  razdigit(_loco4[4]);          // raz du digit TCO
  if (debug) { Serial.println("stop loco 4");}
  }
}

void blinkLocoLed(int x) {
  for (int y = 0; y<4; y++) {
    digitalWrite(_led[x], HIGH);
    delay(100);
    digitalWrite(_led[x], LOW);
    delay(100);    
  }
}
Ce simulateur est avant tout ludique et c'est aussi une réflexion sur le code définitif.
Pour mettre un train en route, un appui sur le "bouton magique" (sous la clé de direction) et le train se positionne sur un quai de gare ou la voie de garage. Pour avancer, il suffit d'accélérer et on le voit se déplacer de canton en canton, son numéro d'affichant sur le tableau... mais avec des conditions :
- si les aiguilles sont bien positionnées,
- si le canton suivant est libre.

On a essayé les doublements de trains, les collisions par l'arrière ou frontales... impossible (après correction des bugs !)

A suivre, avec la réalisation du TCO interconnecté avec le circuit, les capteurs, etc..
Revenir en haut Aller en bas
http://bultez.fr
Kazaam
Membre


Masculin Age : 33
Localisation : Entre Nancy et Metz (France)
Nombre de messages : 75
Date d'inscription : 10/09/2013

MessageSujet: Re: Faire sa propre centrale DCC    Mar 10 Sep - 20:44

Hello

merci pour toutes ces infos, tests...

Je me posais la question pour le RFID et c'est bien ce que je craignais, mon idées etait de pencher le capteur pour offrir virtuellement une zone plus grande (capté plus tot du moins)

Sinon la ou je coince, c'est le booster, je ne trouve pas le booster marcmart ni de schema viable (ou simple vu le nombre necessaire) pour le LMD18200

merci
Revenir en haut Aller en bas
Trusty
Membre
Membre


Masculin Age : 54
Localisation : Melun
Nombre de messages : 767
Date d'inscription : 08/10/2012

MessageSujet: Re: Faire sa propre centrale DCC    Mar 10 Sep - 21:54

J'ai trouvé le mien ici.
http://www.ebay.com/itm/PWM-Adjustable-Speed-Motor-Driver-Module-LMD18200T-for-Arduino-Robot-Project-NIB-/330682492640?ssPageName=ADME:L:OC:FR:3160
C'est celui conseillé, mais je ne suis pas sûr du modèle. Je ne l'ai pas encore reçu....
Revenir en haut Aller en bas
http://www.lapajaparis.net
TRAINTRAIN95
Membre
Membre


Masculin Age : 57
Localisation : Argenteuil 95
Nombre de messages : 1289
Date d'inscription : 22/03/2013

MessageSujet: Re: Faire sa propre centrale DCC    Mar 10 Sep - 21:58

Fils tres interessant que je suivrais pas a pas
Revenir en haut Aller en bas
SixtyFive
Membre
Membre


Masculin Age : 69
Localisation : 91340
Nombre de messages : 175
Date d'inscription : 21/12/2012

MessageSujet: Re: Faire sa propre centrale DCC    Mar 10 Sep - 22:54

Trusty a écrit:
J'ai trouvé le mien ici.
http://www.ebay.com/itm/PWM-Adjustable-Speed-Motor-Driver-Module-LMD18200T-for-Arduino-Robot-Project-NIB-/330682492640?ssPageName=ADME:L:OC:FR:3160
C'est celui conseillé, mais je ne suis pas sûr du modèle. Je ne l'ai pas encore reçu....
C'est bien le même que le mien et jusqu'à présent je n'ai pas eu de problème.
Revenir en haut Aller en bas
http://bultez.fr
SixtyFive
Membre
Membre


Masculin Age : 69
Localisation : 91340
Nombre de messages : 175
Date d'inscription : 21/12/2012

MessageSujet: Re: Faire sa propre centrale DCC    Mar 1 Oct - 16:45

La construction et la programmation du TCO avancent bien, mais je reviens sur le détecteur RFID.
Celui-ci nécessitait un passage à vitesse lente lorsque le module ID12 est placé sous la voie et le transpondeur sous la loco (voir page 7) : environ 1/3 de la vitesse maxi !

J'ai testé un autre emplacement : sur le coté de la voie, avec le transpondeur à l'intérieur d'un wagon (scotché sur la paroi latérale située du coté du détecteur).
Et là les résultats sont plus qu'encourageants : la vitesse de détection est nettement meilleure et permet de dépasser allègrement les 50% de la vitesse maxi, c'est à dire pratiquement une vitesse normale.



Evidemment c'est laid et monstrueux !
Mais caché dans une maison, un mur, etc... ça devient acceptable Smile 



Avec ce principe, il est plus facile de chercher la meilleure position.
Je vous donnerai les résultats bientôt.
Revenir en haut Aller en bas
http://bultez.fr
Kazaam
Membre


Masculin Age : 33
Localisation : Entre Nancy et Metz (France)
Nombre de messages : 75
Date d'inscription : 10/09/2013

MessageSujet: Re: Faire sa propre centrale DCC    Mar 1 Oct - 22:01

Hello

c'est encourageant, mais 50% ca reste quand même contraignant.... mais mieux que 33 Very Happy 

Sinon je me penche sur le railcom
http://fr.digitrainworld.com/2012/10/railcom-railcom-plus-kesako/

La théorie semble prometteuse mais la liste de décodeurs compatible n'est pas simple à trouver, certains le sont d'origine, d'autres nécessitent une mise a niveau, mais qui rentre dans quelle catégorie?
Revenir en haut Aller en bas
jlb
Membre
Membre


Masculin Age : 52
Localisation : Ici
Nombre de messages : 1465
Date d'inscription : 31/12/2011

MessageSujet: Re: Faire sa propre centrale DCC    Mar 1 Oct - 22:11

Une remise à niveau Suspect 

Si j'ai bien compris l'article, Railcom permet à un décodeur de loco de causer sur le bus dans son créneau temporel. Le protocole DCC est modifié mais pas que. Car au niveau électronique, il faut que le décodeur ait des drivers de bus ce que n'aura pas un décodeur qui n'a pas été prévu à la base pour causer sur le bus. Donc il est nécessaire de faire une modification matérielle (ce qui me semble quasi impossible), et non pas simplement flasher un nouveau logiciel dans le décodeur.

Je me trompe ?
Revenir en haut Aller en bas
http://modelleisenbahn.triskell.org
jlb
Membre
Membre


Masculin Age : 52
Localisation : Ici
Nombre de messages : 1465
Date d'inscription : 31/12/2011

MessageSujet: Re: Faire sa propre centrale DCC    Mar 1 Oct - 22:20

Une idée que je lance comme ça pour détecter un identifiant de matériel : coller sous la loco une bande avec une série de points blanc (1) et noir (0) qui servent à coder un numéro. Ce message commence par un bit de start blanc et a une longueur fixe. Les quelques premiers bits sont alternativement des 1 et des 0 pour que la lecture connaisse la vitesse afin de se calibrer pour lire les bits suivant.

Avec une paire photodiode/phototransistor, on lit le message quand le train passe. faisable ?
Revenir en haut Aller en bas
http://modelleisenbahn.triskell.org
Kazaam
Membre


Masculin Age : 33
Localisation : Entre Nancy et Metz (France)
Nombre de messages : 75
Date d'inscription : 10/09/2013

MessageSujet: Re: Faire sa propre centrale DCC    Mar 1 Oct - 22:23

J'ai tenté mais sans succès, même un code barre n'est pas lisible avec fiabilité, du moins avec un simple lecteur "à led", il y a le système LISSY qui utilise un émetteur sous la loco pour envoyer des infos



Maitre de bus peut être pas, mais un envoi type "broadcast" de certaines infos comme le numero du train ou certains CV

Il faut surement du matériel, mais vu que certains genre ESU sont sur le projet de depuis 2006, ils ont du prevoir le necessaire depuis un moment mais sans l'utiliser, ce qui explique la possible reprog de certains decodeurs

On m'a parlé de ca il y a quelque temps mais ce n'était pas encore dans mes priorité (avant de savoir ou est la loco, il lui faut des voies pour rouler Very Happy)

Je lis des choses par ci par la mais ca manque de details
http://www.espacerails.com/modelisme/index.php?page=dosdigital

Ce que j'ai compris, c'est qu'un decodeur compatible peut envoyer des infos pendant un temps donné. En gros la centrale "appelle" le train, coupe l'alim (le booster se court circuite à la masse) et pendant un temps donné, la loco envoie des données.
Il suffit de recuperer ces données dans un secteur pour savoir ou est la loco
Revenir en haut Aller en bas
SixtyFive
Membre
Membre


Masculin Age : 69
Localisation : 91340
Nombre de messages : 175
Date d'inscription : 21/12/2012

MessageSujet: Re: Faire sa propre centrale DCC    Mer 2 Oct - 7:49

En réalité j'ai écris 50% par prudence, mais cela détecte à des vitesses plus grandes encore.

En poussant la vitesse à fond, l'attelage ne résiste pas aux zig-zag dans les aiguilles et le wagon se décroche avant d'arriver au capteur. Mais quand il résiste, le détecteur le voit toujours !!!

Je vais en mettre un en fin de ligne droite et voir jusqu'à quelle vitesse ça détecte, avec différentes locos car elles ne vont pas toutes aussi vite les unes que les autres (il faudra alors une table de correspondance pour la vitesse max à ne pas dépasser en fonction de la loco).

Je trouve cela très encourageant, d'autant qu'il est facile de régler la position de l'ID12 et la capsule transpondeur se loge facilement dans quasiment tous les wagons et ne craint plus les perturbations éventuelles du moteur et du décodeur. Et tout est bien protégé de la poussière.

Je suis assez sceptique sur la solution RailCom ci-dessus que je découvre (merci Kazaam). La bande code barre (merci jlb) existe dans d'autres projets, par exemple ici (decodebarre de Claude Prunet).

J'ai choisi d'expérimenter le RFID parce que c'est facile à intégrer à un projet Arduino et qu'il n'y a pas de carte électronique à développer.
De plus on n'a pas besoin de beaucoup de détecteurs.
J'en ai prévu 2 seulement et pour le moment je n'en utilise qu'un seul car dès que je branche le 2ème, ils ne fonctionnent plus du tout ensemble alors qu'ils fonctionnent bien individuellement (je dois avoir un gros bug, c'est la vie mais je vais trouver, d'autant que j'ai questionné le fabricant ID-innovation qui n'a pas daigné me répondre ..). A ce propos, ils ont sorti un nouveau module ID12LA qui semble plus intéressant (plus grande plage de tension d'alimentation), mais toujours à 30$.
C'est quand même compétitif par rapport aux autres solutions !
Revenir en haut Aller en bas
http://bultez.fr
Kazaam
Membre


Masculin Age : 33
Localisation : Entre Nancy et Metz (France)
Nombre de messages : 75
Date d'inscription : 10/09/2013

MessageSujet: Re: Faire sa propre centrale DCC    Mer 2 Oct - 7:55

Cool c'est encore plus encourageant, moi aussi je penchais pour le RFID avec l'arduino. Apres on est rarement a fond les locos etant souvent trop rapide pour faire "reel"

merci pour le lien du decodebarre, en fait j'ai abandonné a cause du probleme de lumiere, n'etant pas en zone sombre dans tous les cantons

Revenir en haut Aller en bas
jlb
Membre
Membre


Masculin Age : 52
Localisation : Ici
Nombre de messages : 1465
Date d'inscription : 31/12/2011

MessageSujet: Re: Faire sa propre centrale DCC    Mer 2 Oct - 8:08

Une piste pour s'affranchir des problèmes de lumière est de faire de l'impulsionnel avec une bonne pêche dans la diode IR.

Merci pour le lien sur le lecteur de séquence de bits Wink
Revenir en haut Aller en bas
http://modelleisenbahn.triskell.org
Kazaam
Membre


Masculin Age : 33
Localisation : Entre Nancy et Metz (France)
Nombre de messages : 75
Date d'inscription : 10/09/2013

MessageSujet: Re: Faire sa propre centrale DCC    Mer 2 Oct - 21:28

@TRAINTRAIN95 : merci je n'avais pas vu la signature

reste à attendre le satané booster, une fois arrivé il passe au banc pour refaire son schéma afin de le reproduire "maison"

Revenir en haut Aller en bas
jlb
Membre
Membre


Masculin Age : 52
Localisation : Ici
Nombre de messages : 1465
Date d'inscription : 31/12/2011

MessageSujet: Re: Faire sa propre centrale DCC    Jeu 3 Oct - 4:43

Il y a un schéma et un typon de booster ici :

http://www.opendcc.de/elektronik/booster/booster.html

Ça demandera moins de travail que de faire du reverse engineering Smile
Revenir en haut Aller en bas
http://modelleisenbahn.triskell.org
Trusty
Membre
Membre


Masculin Age : 54
Localisation : Melun
Nombre de messages : 767
Date d'inscription : 08/10/2012

MessageSujet: Re: Faire sa propre centrale DCC    Jeu 3 Oct - 6:04

Le booster cité plus haut, je l'ai commandé le 29/08 et je l'attend toujours. Ils disent entre 4 et 7 semaines dans le pire des cas... On en est à cinq. Patience...

Ça me permet en tout cas d'apprendre à utiliser Atmel Studio pour programmer une librairie Arduino pour décoder de manière humainement lisible le signal DCC. Le décodeur vient de mynabay mais il n'affiche que des champs de bits. Je veux convertir en liste de matériels pilotés avec leur état à l'instant T, et mettre tout ça sur un écran LCD déjà reçu. Ça me permettra à terme de vérifier le type de signal émis par l'Arduino, une sorte d'auto-contrôle.
Revenir en haut Aller en bas
http://www.lapajaparis.net
SavignyExpress
Membre
Membre


Masculin Age : 53
Localisation : Savigny
Nombre de messages : 1534
Date d'inscription : 10/10/2010

MessageSujet: Re: Faire sa propre centrale DCC    Jeu 3 Oct - 6:26

Pour reprendre l'idée d'une lecture d'adresse, le site ptitrain présentait une solution à base d'ILS et aimants collés sous le matériel roulant, reprise d'un article de Loco Revue. En collant plusieurs aimants on génère autant d'impulsions qui peuvent ensuite être détectées pour en déduire l'adresse du matériel roulant. Ptitrain montre 3 aimants sous une voiture voyageur N. Avec 3 aimants, on a 2^3 adresses possibles, soit 8 adresses. Il y a plusieurs ILS le long de la voie, mais je pense que ce n'est pas indispensable.

Ci-après, l'image reprise du site Ptitrain.

Revenir en haut Aller en bas
http://savignyexpress.wordpress.com
Kazaam
Membre


Masculin Age : 33
Localisation : Entre Nancy et Metz (France)
Nombre de messages : 75
Date d'inscription : 10/09/2013

MessageSujet: Re: Faire sa propre centrale DCC    Jeu 3 Oct - 8:48

Légèrement plus compliqué ce petit schema, il y en a plein sur le net dont celui la
http://www.spickles.org/projects/lmd18200/

Reste a savoir si cela est vraiment adapté à nos besoins
Revenir en haut Aller en bas
Trusty
Membre
Membre


Masculin Age : 54
Localisation : Melun
Nombre de messages : 767
Date d'inscription : 08/10/2012

MessageSujet: Re: Faire sa propre centrale DCC    Jeu 3 Oct - 9:01

Pour le coup, je ne connaissais pas celui là et il me semble quasiment identique à celui commandé sur la baie.
Moi ce qui m'embête dans ces schémas, au delà de la construction proprement dite qui n'est pas mon fort (doux euphémisme...), c'est que le prix des composants est trois ou quatre fois plus élevé que le produit de la baie... Je me doute que les produits chinois utilisent des composants locaux bas de gamme, voire des contrefaçons, mais quand on commande ce genre de chose à ce prix là, il faut bien être conscient des limites de la mondialisation et comprendre que la qualité ne sera forcément pas au rendez-vous. Une fois averti, c'est plutôt un bon plan. Enfin, si on reçoit le produit un jour Sleep .
Revenir en haut Aller en bas
http://www.lapajaparis.net
jlb
Membre
Membre


Masculin Age : 52
Localisation : Ici
Nombre de messages : 1465
Date d'inscription : 31/12/2011

MessageSujet: Re: Faire sa propre centrale DCC    Jeu 3 Oct - 9:06

À mon sens, utiliser un driver de pont en H intégré est le meilleur choix pour générer un signal DCC. C'est même quasiment fait pour ça. Il existe plusieurs composants comme le LMD18200 sur le lien que tu donnes. Le booster d'OpenDCC utilise un L6203. Un autre choix est le L298.

Pour ce dernier, on trouve des shields Arduino vraiment pas cher : http://dx.com/p/l298n-stepper-motor-driver-controller-board-for-arduino-120542 qui peuvent servir comme point de départ.

Le L298 intègre 2 ponts en H qui feront donc un double booster de 2A par canal.
Revenir en haut Aller en bas
http://modelleisenbahn.triskell.org
Kazaam
Membre


Masculin Age : 33
Localisation : Entre Nancy et Metz (France)
Nombre de messages : 75
Date d'inscription : 10/09/2013

MessageSujet: Re: Faire sa propre centrale DCC    Jeu 3 Oct - 9:29

Je vais voir pour le L298, je connaissais le L293, ca doit etre assez proche.

La solution au problème du prix du composant de base, c'est le "free sample" qu'il est possible d'obtenir chez des fabricants comme TI.

Un simple formulaire à remplir (avec comme société : "independant designer" sur conseil de TI vu que nous ne sommes pas des sociétés) permet d'obtenir 3x le LMD18200 pour 0€ ainsi que d'autres composants.

edit : un comme celui la pourrait le faire? en europe donc livré rapidement
http://www.ebay.fr/itm/L298N-236-Dual-H-Bridge-DC-Stepper-Motor-Drive-controleur-Board-Module-Arduino-/310674779162?pt=FR_YO_MaisonJardin_Bricolage_ElectroniqueComposants&hash=item4855a8ec1a
Revenir en haut Aller en bas
 
Faire sa propre centrale DCC
Voir le sujet précédent Voir le sujet suivant Revenir en haut 
Page 5 sur 13Aller à la page : Précédent  1, 2, 3, 4, 5, 6 ... 11, 12, 13  Suivant
 Sujets similaires
-
» Faire son propre Café-Tricot
» [Aide]Comment faire sa propre bootanimation?
» Faire sa propre rom wm6.5 (WWE)
» peut-on faire nos propre dies ?
» Faire ses propre décalques

Permission de ce forum:Vous ne pouvez pas répondre aux sujets dans ce forum
1/160 - Echelle N :: Exploitation :: Le numérique-
Sauter vers: