Le forum LOCODUINO est consacré aux discussions ayant trait à l'utilisation de l'Arduino dans les automatismes et les animations pour le train miniature. Nous avons eu récemment quelques inscriptions de personnes ayant des projets plus généraux mais surtout inapplicables au train miniature. Si votre projet ou vos questions ne concernent pas le modélisme ferroviaire, ne vous inscrivez pas, vous perdriez votre temps et nous aussi.
Voir les contributions
Cette section vous permet de consulter les contributions (messages, sujets et fichiers joints) d'un utilisateur. Vous ne pourrez voir que les contributions des zones auxquelles vous avez accès.
Evolution du soft , maintenant accepte les deux polarités.
Fonctionne aussi avec un Attiny85
- ne pas toucher au code DCC-EX , dès qu'il a assez de bits pour le préamble
- choisir un attiny412 (8 broches , récent) , prévoir le téléversement par l'ESP32 , mais aussi et d'abord par un connecteur externe , sur lequel on pourra brancher un convertisseur USB <-> série , que tout le monde a ; l'un ou l'autre composant supplémentaire nécessaire (résistance , diode) étant aussi à ajouter sur la carte
utiliser le code de lebelge2 , vu qu'il existe et qu'il fonctionne (le code) ; je n'ai pas non plus compris le problème de l'inversion du signal (l'opposé de l'inverse étant identique à la même chose)
3) décoder , à la manière d'un sniffer , le DCC issu de l'ESP32 , puis le reproduire
J'ai construis mon réseau sur Rocrail et je suis arrivé à le faire fonctionner avec sa centrale virtuelle. Le step suivant pour moi était de connecter la centrale DCC++ en Port série. J'y suis arrivé mais là tout se complique.
Pas évident de t'aider si tu es si peu précis sur les problèmes que tu rencontres.
// RailCom: Programme pour insérer un CutOut dans les trames DCC. Arduino Uno, Nano, Micro.
// V.1.0. 24-04-24
// lebelge2@yahoo.fr
/*
Modifié pour LMD18200 le 26/04/24
Testé à partir de DCC++ version originale téléchargé sur Arduino MEGA : https://github.com/DccPlusPlus/BaseStation
Ce code téléchargé sur un Arduino Nano.
Cablage :
MEGA 3 ------> LMD18200 PWM
MEGA 12 -----> NANO 3
NANO 4 ------> LMD18200 DIR
NANO 6 ------> LMD18200 BRAKE
MEGA GND ----> NANO GND
MEGA GND ----> LMD18200 GND
*/
volatile uint8_t dccrecState;
volatile uint8_t tempByte;
#define WAIT_PREAMBLE 0
#define WAIT_START_BIT 1
#define WAIT_DATA 2
#define WAIT_END_BIT 3
#define MaxDccSize 6 // DCC messages can have a length upto this valu
#define PinIn1 3 // Entrée signalDcc sans CutOut
#define PinOut1 4 // Sortie signal DCC avec CutOut
#define PinOut2 5 // Sortie signal DCC inversé avec CutOut
#define PinBrake 6 // Sortie signal brake
class DccMessage {
public:
volatile uint8_t size;
volatile uint8_t data[MaxDccSize]; // The contents of the last dcc message received
} dccMessage;
struct {
uint8_t bitCount; // Count number of preamble bits / if we have a byte
volatile uint8_t tempMessage[MaxDccSize]; // Once we have a byte, we store it in the temp message
volatile uint8_t tempMessageSize; // Here we keep track of the size, including XOR
} dccrec; // The received DCC message is assembled here
struct {
uint8_t port;
uint8_t bit; // Bitmask for reading the input Port
volatile uint8_t *portRegister;
} dccIn;
void setup() {
Serial.begin(115200);
DDRD = DDRD | B01110000; // pin 3 -> input, pin 4 à 6 -> output
init_timer2();
attachInterrupt(digitalPinToInterrupt(PinIn1), Dcc_Interrupt, CHANGE );
Serial.println ("SetUp OK");
}
void loop() {}
void CutOut(void) {
delayMicroseconds(8);
PORTD = PORTD | B01010000;
PORTD = PORTD &= ~ B00100000;
//
delayMicroseconds(425);
PORTD = PORTD | B00100000;
PORTD = PORTD &= ~ B01010000;
}
//----------------------------------------------------------------------------------------------------------
void init_timer2(void) {
#define T2_PRESCALER 8
#define T2_PRESCALER_BITS ((0<<CS02)|(1<<CS01)|(0<<CS00))
#define T77US (F_CPU * 77L / T2_PRESCALER / 1000000L)
#if (T77US > 254)
#warning T77US too big, use either larger prescaler or slower processor
#endif
#if (T77US < 32)
#warning T77US too small, use either smaller prescaler or faster processor
#endif
noInterrupts(); // disable all interrupts
TCCR2A = 0; // should be zero for our purpose
TCCR2B = 0; // 0 => timer is stopped
TCNT2 = 256L - T77US; // preload the timer
TIMSK2 |= (1 << TOIE2); // the timer is used in overflow interrupt mode
interrupts(); // enable all interrupts
}
//----------------------------------------------------------------------------------------
void Dcc_Interrupt() {
if ((PIND & 0x04) >> 2) {
PORTD = PORTD | B00010000;
TCCR2B |= (T2_PRESCALER_BITS); // Start Timer 2
}
else {
PORTD = PORTD &= ~ B00010000;
}
}
//-----------------------------------------------------------------------------------
ISR(TIMER2_OVF_vect) {
uint8_t DccBitVal = !(PORTD & (1 << 4));
TCCR2B = 0; // 0 => timer is stopped
TCNT2 = 256L - T77US; // preload the timer
dccrec.bitCount++;
switch (dccrecState) {
case WAIT_PREAMBLE:
if (DccBitVal) { // a "1" bit is received
if (dccrec.bitCount >= 10)
dccrecState = WAIT_START_BIT;
}
else
dccrec.bitCount = 0; // not a valid preamble.
break;
case WAIT_START_BIT:
if ( !DccBitVal ) { // a "0" bit is received
dccrecState = WAIT_DATA;
dccrec.tempMessageSize = 0;
uint8_t i;
for (i = 0; i < MaxDccSize; i++ )
dccrec.tempMessage[i] = 0;
dccrec.bitCount = 0;
}
break;
case WAIT_DATA:
if ( dccrec.bitCount == 8 ) { // byte is complete
if (dccrec.tempMessageSize == MaxDccSize ) { // Packet is too long - abort
dccrecState = WAIT_PREAMBLE;
dccrec.bitCount = 0;
}
else
dccrecState = WAIT_END_BIT; // Wait for next byte or end of packet
}
break;
case WAIT_END_BIT:
if ( DccBitVal ) { // End of packet?
CutOut();
dccrecState = WAIT_PREAMBLE;
}
else // Get next Byte
dccrecState = WAIT_DATA;
dccrec.bitCount = 0; // prepare for the next byte
}
}
- LMD18200 :
Je ne possède pas encore ce module mais d’après le datasheet, au moment du CutOut, il faut que Dir soit à 0 et Brake à 1, il faudra adapter le soft plus deux sorties supplémentaires dédiées à ce module.
#define PinIn1 3 // Entrée signalDcc sans CutOut = Pin DIR du MEGA (pin 12 dans DCC++)
#define PinOut1 4 // Sortie signal DCC avec CutOut = Pin DIR du LMD18200
// La sortie 3 du MEGA (PWM) est reliée en direct au PWM du LMD18200
#define PinOut2 5 // Sortie signal DCC inversé avec CutOut // Je ne l'utilise pas ici
#define PinBrake 6 // Sortie signal BRAKE = Pin 6 du Nano dans pin BRAKE du LMD18200
void CutOut(void) {
delayMicroseconds(8);
PORTD = PORTD | B01010000;
PORTD = PORTD &= ~ B00100000;
//
delayMicroseconds(425);
PORTD = PORTD | B00100000;
PORTD = PORTD &= ~ B01010000;
}
le cutout fait , pour les 2 canaux , selon la norme , 500 us
cela correspond à 500/116 = 4.3 bits 1 DCC , arrondi à 5
si on a un preamble de 16 bits , il doit en rester 11 , ce qui va bien pour (de mémoire) un minimum de 10
amha ça ne sert à rien d'en avoir + de 16 au départ
J’ai laissé le Préambule à 16, il n’en reste plus que 11 à la fin… ( Norme ; minimum 10)
Test et essais fait avec un Arduino Mega pour centrale et Nano pour insérer le CutOut.
Logiciel : CommandStaion-EX et Base Station.
le nombre de bits des preambles DCC-EX , c'est dans "DCCWaveform.h" :
// Number of preamble bits.
const int PREAMBLE_BITS_MAIN = 16;
const int PREAMBLE_BITS_PROG = 22;
l'assembleur , c'est juste en Anglais ce que la machine fait en réel , donc on ne peut pas aller + vite ; bien entendu , un truc mal écrit en assembleur pourra aller moins vite qu'un truc bien écrit en Basic ...
(...)- on ne peut pas aller + vite que l'assembleur , mais on peut écrire l'équivalent en C (me souviens plus comment)
Par exemple, je suis à peu près certain que cette commande écrite en partie en assembleur est malgré tout moins rapide en exécution qu’une écriture directe sur les ports.
- écrire directement sur le PORT , quelque soit la méthode , a pour inconvénient de modifier toutes les sorties du PORT , voir si c'est gênant ou pas
je crois le + rapide c'est :
PINB = 0b00110000 ; // on bascule les bits 4 et 5 sans toucher aux autres
, vous constaterez un signal carré cyclique dont la demi-période fait 53,5 µs au lieu de 50 µs comme le voulait le programmeur et parfois ce signal montre une demi-période de presque 60 µs. Comme il est dit sur la page du site d’Arduino, cette approximation est due à l’exécution de code qui a été rajouté par l’IDE.Je crois le + rapide c'est :
PINB = 0b00110000 ; //
et je regarde comment insérer le HW dans LaBox
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");
}
}