Descodificador DCC para 8 señales con Arduino

Norber escribió:

Ofrecemos en la web de la Asociación Salmantina de Amigos del Ferrocarril un sencillo montaje para construir un descodificador DCC de accesorios que controla hasta 8 señales de dos aspectos con encendido y apagado lento.

Como siempre, si alguien se anima a probarlo, le agradecemos que informe de los resultados por aquí.

ASALAF eliberia.es

Gracias.

El adjunto ASALAF_deco_8_Signals.png ya no está disponible

Hola Norber,
Monté el circuito y me funcionó correctamente y contento con la experiencia, pero se me ocurrió utilizar el mismo circuito, poniendo en las salidas el circuito L293 para poder manejar desvíos con solenoide, como los de Fleischmann, haciendo un programilla sencillo y resulta que a veces me funcionaba y a veces no, volviéndome loco.
Finalmente me dí cuenta que solo funcionaba en una posición determinada de las entradas de la señal de las vías J-K y revisando el esquema me dí cuenta que vosotros atacáis el optoacoplador con una resistencia de 10K y un diodo LED y en los esquemas localizados por internet siempre lo hacen con resistencia de 1K y un diodo 1N4148.
Ha sido poner estos últimos valores en vuestra placa y todo funciona perfectamente, tanto control de señales como de desvío independientemente de la posición de los cables J-K.

Con haber cambiado la resistencia habría bastado.
Pide menos de 10 kohm. Últimamente monto 2k2 pero depende del optoacoplador [Edito: y probablemente de la tensión que dé la central a las vías]

Muchas gracias por la información!!

Una consulta, Norber ....

Es viable añadir al Sketch la posibilidad de definir la primera dirección del decoder a través del programa que usemos para gestionar la maqueta, como puede ser el RocRail?

Me explico : El Skectch definiría una dirección por defecto, pero una vez montado el circuito en la maqueta, si necesito modificar esa dirección, decirle al arduino que la próxima orden que reciba por las vías J-K, será la dirección inicial que debe guardar y las siguientes serán consecutivas.

Es como funcionan los módulos de Digikeijs, que accionas el pulsador que llevan y la dirección que envías por J-K es la que asume como primera dirección y al resto de señales se las asigna correlativamente a la que hemos definido.

Es relativamente fácil de programar, pero habría que poner un interruptor en la placa en algún sitio porque no se me ocurre ninguna alternativa para decirle al Arduino cuándo le vamos a cambiar las direcciones. Es una opción que descarté porque modificar las direcciones en el código del programa era lo más sencillo.

Efectivamente, habría que poner un pulsador en la placa para que, al pulsarse, abriese una ventana de tiempo de unos segundos para que la direeción que enviemos en ese período de tiempo la grabe y la tenga como referencia.

Lógicamente es modificarlas en el sketch y volver a reprogramar el arduino es sencillo, pero a veces el sistema del pulsador es útil, sobre todo cuando estamos haciendo pruebas en la maqueta o redistribuyendo las direcciones cuando incorporamos más elementos y aparte, en mi caso, tengo un par de amigos a los que les suministro estos "engendros electrónicos y ellos no tienen los conocimientos para trabajarse el arduino.

Estoy probando lo que te pongo más abajo, pero en el sketch del descodificador con el que abres este hilo, no se por donde meterle mano, por lo que si me indicas en que lugar sería más adecuado, te lo agradecería.

/////////////////////////////////////////////////////////////////////////////
//========== lectura de direccion para guardar==========
//Si estamos en modo programación, se guarda la dirección
Tprog_Milli = millis();
if (digitalRead(pulsador)==HIGH) { //pulsador de programación
digitalWrite(13, HIGH);
if (millis()- (Tprog_Milli) < 5000) {
EEPROM.write(EEPROM_ADDRESS,address%256);
EEPROM.write(EEPROM_ADDRESS+1,address/256);
}
digitalWrite(13, LOW);

//declara función de reset @ address 0
void(* resetFunc) (void) = 0;
resetFunc(); //Reset
}
else {
// Si estamos en modo normal, se continúa con el proceso
}
//==========================================
/////////////////////////////////////////////////////////////////////////////

Pecetero escribió:

Hola Norber,
Monté el circuito y me funcionó correctamente y contento con la experiencia, pero se me ocurrió utilizar el mismo circuito, poniendo en las salidas el circuito L293 para poder manejar desvíos con solenoide, como los de Fleischmann, haciendo un programilla sencillo y resulta que a veces me funcionaba y a veces no, volviéndome loco.
Finalmente me dí cuenta que solo funcionaba en una posición determinada de las entradas de la señal de las vías J-K y revisando el esquema me dí cuenta que vosotros atacáis el optoacoplador con una resistencia de 10K y un diodo LED y en los esquemas localizados por internet siempre lo hacen con resistencia de 1K y un diodo 1N4148.
Ha sido poner estos últimos valores en vuestra placa y todo funciona perfectamente, tanto control de señales como de desvío independientemente de la posición de los cables J-K.

Hola, lo que comentas, ¿serviria para los desvios de fleischmann piccolo?

Gracias


Enviado desde mi iPhone utilizando Tapatalk

maab2413 escribió:

Hola, lo que comentas, ¿serviria para los desvios de fleischmann piccolo?

Gracias


Enviado desde mi iPhone utilizando Tapatalk

Supongo que sí, este invento sirve para los motores de desvíos que son bobinas y necesitan un impulso de tensión, pero no para aquellos que utilizan servos.

Pecetero escribió:

Supongo que sí, este invento sirve para los motores de desvíos que son bobinas y necesitan un impulso de tensión, pero no para aquellos que utilizan servos.

Gracias, probare a montar uno.

Hola Norber,
no me puedes echar una mano en lo que te comento un par de post anteriores a este?

http://www.forotrenes.com/foro/viewtopic.php?p=647048#p647048

Para que el programa sea sensible a un cambio de dirección como el que propones hay dos opciones:

A) Pedirle que vigile constantemente el estado del pin al que se conectaría un pulsador, y que cuando se detecte la pulsación utilice la primera dirección de accesorio que entre por DCC para modificar la lista de direcciones a las que es sensible.

B) Activar una interrupción para que ocurra lo mismo que antes pero sin tener que consultar constantemente el estado del pin. La interrupción se ejecutaría en cuanto se produjera sin importar qué estuviera haciendo en ese momento el micro.

Yo creo más sencilla la primera opción, mejorada con algún sistema 'anti rebote' para no inducir una respuesta anómala del software. Producida la pulsación se conmuta una variable auxiliar tipo chivato (en inglés sería 'flag') y luego, en la función 'loop', se vigilaría el estado de ese chivato. Si está 'encendido' entonces se deriva el flujo normal del 'loop' hacia la escucha de DCC y, si llega una dirección en un tiempo pre establecido, grabación de esa dirección en la EEPROM. Y al conseguirlo, o al superarse el tiempo de escucha DCC, se vuelve a dejar el chivato como estaba para que el programa recupere el funcionamiento normal.

No es complicado pero no es evidente. Suerte!

Hola Norber,
He añadido las siguientes líneas al programa inicial:

#include <EEPROM.h>
#define EEPROM_ADDRESS 2 // we store our dcc address
#define PULSADOR 3
#define aviso_tiempo 20


void setup() {

attachInterrupt(1, pulsador, RISING); // pin 3 = HIGH

//resto como estaba

}


void pulsador() {

int reset = 1;
unsigned long Tprog_Milli;
Tprog_Milli = millis();
digitalWrite(13, HIGH);
digitalWrite(aviso_tiempo, HIGH);

while (millis() - (Tprog_Milli) < 5000) {
EEPROM.write(EEPROM_ADDRESS, address % 256);
EEPROM.write(EEPROM_ADDRESS + 1, address / 256);
}

digitalWrite(13, LOW); //provisional
digitalWrite(aviso_tiempo, LOW);
if (reset == 1) {
reset = 0;
//declara función de reset @ address 0
void(* resetFunc) (void) = 0;
resetFunc(); //Reset
}

}


Pero no consigo ni que se encienda el led de la salida 13 del nano

El código me resulta un poco difícil de entender. Así, en frío, veo lo siguiente:

1. La interrupción puede no estar bien asignada. No sé de memoria cómo va lo de 'attachInterrupt' pero podrías estar cometiendo ahí algún error pues no veo que uses 'PULSADOR' ni que definas 'pulsador'...

2. Tampoco veo la configuración del pin 3 como INPUT-PULLUP ni la del pin 13 como OUTPUT. Esto se hace en 'setup' pero dices que '//resto como estaba' y te faltarían esas configuraciones.

3. Si solucionas lo anterior y realmente se ejecuta la función asignada a la interrupción al pulsar, el led de la placa asociado al pin 13 se encenderá, y unos 5 s después debería apagarse. En este intervalo, el programa estará grabando en la EEPROM continuamente el valor que hubiera en 'address'. Grabar unas 1500 veces en el mismo sitio cada vez que usas el pulsador te machaca innecesariamente la memoria y estropea el Arduino. Aquí te especifican que esto no se debe hacer. Luego agradece que no hayas visto encender el led 13 nunca, porque eso ha salvado tu EEPROM de cierto maltrato por parte del código.

4. No olvides que, a causa del rebote del contacto del pulsador, tu código podría intentar llamar a la función 'void pulsador()' decenas o centenares de veces con cada pulsación. Hay que prever cómo lidiar con este tipo de asuntos.

5. Se aconseja que la interrupción dure el mínimo tiempo imprescindible. Tal y como la tienes concebida durará 5 s al menos, lo que es generalmente demasiado.

6. Lo del uso de la variable 'reset' no lo entiendo. Es una manera de programar en C++ muy avanzada que no conozco, lo siento.

Tienes razón, quise acortar el mensaje y creo que lo que acorté fué la información, de modo que más abajo pego el sketch completo tal y como lo tengo, pero te comento ...
He designado la entrada 3 como conexión al pulsador con resistencia de 10K a OV y el pulsador cierra el circuito a +5V.

La función reset la he añadido para que una vez que se ha grabado la dirección, se resetee y lea esa dirección para trabajar.

El tiempo lo bajaré a 3 segundos, mientras busco otra solución.

Mientras realizo las pruebas, para tener visión de la temporización, uso la entrada 13 para el led, pero cuando pase a ser utilizable, la 13 será una salida hacia un semáforo y será la entrada la 20 la que usaré para conectarle un led.



/* 2 x 8 dimming LEDs with Arduino Nano DCC decoder
By German Trinidad and Norber, Spain, December 2015
Añadidos de Pedro Campos, enero 2018
Freely distributable for private, non commercial, use

Attach led anodes (+) to #1 to #8 outputs
Attach all led catodes (-) to GNDs
Don't forget to add serial resistors! */

//============ mio ====================================
#include <DCC_Decoder.h>
#define kDCC_INTERRUPT 0

#include <EEPROM.h>
#define EEPROM_ADDRESS 2 // we store our dcc address
#define aviso_tiempo 20
int direccion = EEPROM.read(EEPROM_ADDRESS) + (EEPROM.read(EEPROM_ADDRESS + 1) * 256);
int address = (direccion);


#define ADR_MMAUS_01 (address) // Assign here your addresses
#define ADR_MMAUS_02 (ADR_MMAUS_01+1)
#define ADR_MMAUS_03 (ADR_MMAUS_01+2)
#define ADR_MMAUS_04 (ADR_MMAUS_01+3)
#define ADR_MMAUS_05 (ADR_MMAUS_01+4)
#define ADR_MMAUS_06 (ADR_MMAUS_01+5)
#define ADR_MMAUS_07 (ADR_MMAUS_01+6)
#define ADR_MMAUS_08 (ADR_MMAUS_01+7)

int comb[][4] = {
//Address , Port , Pin-√ , Pin--
{((ADR_MMAUS_01 - 1) / 4) + 128, ((ADR_MMAUS_01 - 1) % 4), 4 , 5 },
{((ADR_MMAUS_02 - 1) / 4) + 128, ((ADR_MMAUS_02 - 1) % 4), 6 , 7 },
{((ADR_MMAUS_03 - 1) / 4) + 128, ((ADR_MMAUS_03 - 1) % 4), 8 , 9 },
{((ADR_MMAUS_04 - 1) / 4) + 128, ((ADR_MMAUS_04 - 1) % 4), 10 , 11 },
{((ADR_MMAUS_05 - 1) / 4) + 128, ((ADR_MMAUS_05 - 1) % 4), 12 , 20 }, //Cambiar a 13
{((ADR_MMAUS_06 - 1) / 4) + 128, ((ADR_MMAUS_06 - 1) % 4), 14 , 15 },
{((ADR_MMAUS_07 - 1) / 4) + 128, ((ADR_MMAUS_07 - 1) % 4), 16 , 17 },
{((ADR_MMAUS_08 - 1) / 4) + 128, ((ADR_MMAUS_08 - 1) % 4), 18 , 19 },
};

#define PULSADOR 3
#define DCC_INT 2
#define SI 0
#define NO 1
#define TICKS 215 // Prescaler 8 -> Timer pulse every 0.5 µs -> 200 ticks are 100 µs
#define FREQ 120 // 15 ms aprox
#define DELTA 3 // PWM
#define TO_OFF 20
#define PAUSE 30
#define TO_ON 40

volatile byte buf_dcc[6];
volatile byte pinPWM_1, pinPWM_2;
volatile boolean varyingLed = false;
volatile int duty = FREQ - 1;
volatile byte state = TO_OFF;

void setup() {

for (int i = 4; i < 20; i++) {
pinMode(i, OUTPUT);
if (i & 0x01) digitalWrite(i, LOW); // Green leds at odd pins start off
else digitalWrite(i, HIGH); // Red leds at even pins start on
}
pinMode(DCC_INT, INPUT);
pinMode(PULSADOR, INPUT_PULLUP);
pinMode(13, OUTPUT); //provisional
Serial.begin(9600);
Serial.print("Iniciando...");
Serial.println();
Serial.print("Direccion inicial: ");
Serial.print(direccion);
Serial.println();
Serial.print("Direccion de trabajo: ");
Serial.println(address);
Serial.println();


attachInterrupt(1, pulsador, RISING); // pin 3 = HIGH

attachInterrupt(0, dcc_int, CHANGE); // pin 2 = DCC externalInterrupt 0

cli();
TCCR0A = 0;
TCCR0B = 0;
TCCR0B |= (1 << CS01); // Set CS01 bit for 8 prescaler (0.5 µs) on Timer0 - DCC
TCCR2A = 0;
TCCR2B = 0;
TCCR2B |= (1 << CS21); // Set CS21 bit for 8 prescaler (0.5 µs) on Timer2 - Dimming
TIMSK2 = 0;
TIMSK2 |= (1 << TOIE2); // Enable Timer2 Overflow interrupt
sei();

}


void pulsador() {

int reset = 1;
unsigned long Tprog_Milli;
Tprog_Milli = millis();
digitalWrite(13, HIGH); //provisional
digitalWrite(aviso_tiempo, HIGH);
while (millis() - (Tprog_Milli) < 3000) {

// EEPROM.write(EEPROM_ADDRESS, address % 256);
// EEPROM.write(EEPROM_ADDRESS + 1, address / 256);

EEPROM.update(EEPROM_ADDRESS, address % 256);
EEPROM.update(EEPROM_ADDRESS + 1, address / 256);

}
digitalWrite(13, LOW); //provisional
digitalWrite(aviso_tiempo, LOW);
if (reset == 1) {
reset = 0;
//declara función de reset @ address 0
void(* resetFunc) (void) = 0;
resetFunc(); //Reset
}

}

void dcc_int() { // ISR(INT0_vect) External interrupt routine for signal on pin2
static int tmp_pulse; // German is a genius!
static byte bit_dcc;
static byte preamb;
static byte aux_dcc, x_or, idx, num_bits;

if (PIND & (0x04)) TCNT0 = 0;
else {
tmp_pulse = TCNT0;
if (tmp_pulse > TICKS) bit_dcc = 0;
else bit_dcc = 1;
if (preamb == SI) {
if (bit_dcc) {
if (num_bits) num_bits--;
}
else {
if (!num_bits) {
preamb = NO;
num_bits = 9;
x_or = 0;
idx = 0;
}
else num_bits = 10;
}
}
else {
if (--num_bits) aux_dcc = aux_dcc * 2 + bit_dcc;
else {
if (!bit_dcc) {
buf_dcc [idx++] = aux_dcc;
x_or ^= aux_dcc;
num_bits = 9;
}
else {
preamb = SI;
num_bits = 10;
if (x_or == aux_dcc) { // Data received OK!
Serial.print(buf_dcc[0]);
// buf_dcc[0] is Address
// buf_dcc[1] is Port and command
if (!varyingLed) { // While commuting, ignore commands
byte port = (buf_dcc[1] & 0x06) >> 1; // 0x06 = B0000 0110
for (int i = 0; i < 9; i++) {
if ((buf_dcc[0] == comb[i][0]) && (port == comb[i][1])) { // It's ours
if (buf_dcc[1] & 0x01) {
pinPWM_1 = comb[i][2]; // Pin to dim off
pinPWM_2 = comb[i][3]; // Pin to dim on
}
else {
pinPWM_1 = comb[i][3];
pinPWM_2 = comb[i][2];
}
if (digitalRead(pinPWM_1)) { // Needs to be dimmed off indeed
varyingLed = true;
duty = 255;
state = TO_OFF;
}
return;
}
}
}
}
}
}
}
}
}

ISR(TIMER2_OVF_vect) { // Timer2 Overflow interrupt every 128 µs for dimmming leds
if (varyingLed == true) {
static int cont;
cont++;
switch (state) {
case TO_OFF:
if (cont == FREQ) { // High pulse starts when 'cont' reaches FREQ
digitalWrite(pinPWM_1, HIGH);
cont = 0;
duty = duty - DELTA;
}
if (cont == duty) {
digitalWrite(pinPWM_1, LOW); // And ends when 'cont' reaches 'duty'
if (duty < DELTA) state = PAUSE;
}
break;
case PAUSE:
if (cont == 5 * FREQ) { // Small dramatic pausae
state = TO_ON;
duty = DELTA;
cont = 0;
}
break;
case TO_ON:
if (cont == FREQ) {
digitalWrite(pinPWM_2, HIGH);
cont = 0;
duty = duty + DELTA;
if (duty > 255 - DELTA) varyingLed = false; // We're done
}
if (cont == duty) {
digitalWrite(pinPWM_2, LOW);
}
break;
}
}
}

void loop() {
}

Norber escribió:

3. Si solucionas lo anterior y realmente se ejecuta la función asignada a la interrupción al pulsar, el led de la placa asociado al pin 13 se encenderá, y unos 5 s después debería apagarse. En este intervalo, el programa estará grabando en la EEPROM continuamente el valor que hubiera en 'address'. Grabar unas 1500 veces en el mismo sitio cada vez que usas el pulsador te machaca innecesariamente la memoria y estropea el Arduino. Aquí te especifican que esto no se debe hacer. Luego agradece que no hayas visto encender el led 13 nunca, porque eso ha salvado tu EEPROM de cierto maltrato por parte del código.

Hola Norber,
En el post anterior he modificado las líneas donde se escribe la EEPROM el comando "write" por "update" de modo que solo escriba en la EEPROM si la dirección que queremos guardar es distinta a la que ya está almacenada y de ese modo no maltratamos la EEPROM con multiples grabaciones.

Lo que si te agradecería es que me echases una mano, porque por más vueltas que le doy, no consigo que funcione el invento.

1. Yo me centraría en conseguir encender y apagar el led de la placa (pin 13) con la interrupción que estás intentando usar.

2. Cuando lo consigas, estudia la función while{} porque no funciona como creo que tu piensas: tal y como la tienes ahora, estás 'atrapando' el código en un bucle que lee continuamente (ya no escribirá más que la primera vez desde que has cambiado 'write' por 'update') la misma dirección EEPROM durante 3 s. Y al cabo de esos 3 s saldrá y seguirá ejecutando el resto del código. Esto es inútil así.

El diodo ya se ilumina cuando acciono la interrupción con el pulsador de la entrada A3, pero se queda contínuamente en el bucle do - while y siempre me escribe el mismo tiempo de millis(), como si no corriese en ese bucle y ahí se queda, pero no entiendo el por qué.


void pulsador() {

int reset = 1;
unsigned long Tprog_Milli;
Tprog_Milli = millis();
digitalWrite(13, HIGH); //provisional
digitalWrite(aviso_tiempo, HIGH);

Serial.print("Tiempo inicial: ");
Serial.print(Tprog_Milli);
Serial.print(" ");
Serial.print(millis());
Serial.println();

do {
Serial.print(millis());
Serial.print(" --- ");
Serial.print(millis() - (Tprog_Milli));
Serial.println();
EEPROM.update(EEPROM_ADDRESS, address % 256);
EEPROM.update(EEPROM_ADDRESS + 1, address / 256);
} while (millis() - (Tprog_Milli) < 3000);

digitalWrite(13, LOW); //provisional
digitalWrite(aviso_tiempo, LOW);
if (reset == 1) {
reset = 0;
digitalWrite(13, LOW); //provisional
digitalWrite(aviso_tiempo, LOW);
//declara función de reset @ address 0
void(* resetFunc) (void) = 0;
resetFunc(); //Reset
}

}

Por lo que cuentas has conseguido superar ya con éxito los pasos 1. 2. y 3. que te indiqué en un mensaje anterior de este hilo.

Ahora tienes que conceder la mayor importancia al paso 5. En la función que se ejecuta durante la interrupción hay que hacer lo menos posible. Prácticamente nada. Dedícala a dejar señales preparadas para que luego el programa principal, en la función loop(), resuelva lo que la función pulsador() de deja de 'herencia'. Me explico:

Imagina una variable chivato llamada 'suceso'. Suele definirse como boleana: boolean suceso = false;
La función pulsador() simplemente cambia la variable a true y ahí se acaba. Eso es cumplir mi indicación nº 5.
Luego, en loop(), verifica al principio el valor de 'suceso', y si resultara if (suceso==true) { entonces escucha la señal DCC durante los segundos que te parezca, graba la EEPROM si llega alguna dirección de accesorio, y no te olvides, al final de ese if de volver a cambiar el chivato haciendo suceso=false.

Esto sí te funcionará. ¿La razón? Pues la regla del paso nº5. Puedes profundizar leyendo sobre qué se le permite hacer al micro cuando está ejecutando una función de interrupción, y verás que es prácticamente nada. Y eso es lo que hace el tuyo ahora: durante la interrupción, nada de lo que a ti te gustaría. Pero es que te pasas de exigente .

Ánimo!!

Hola Norber,
He montado los dos circuitos con común positivo y negativo y todo funciona correctamente con Roco.
Pero cuando utilizo la central de Lenz no funciona, es como si no entendiera las ordenes.
Un saludo
Paco

Prueba a cambiar la resistencia que se explica algo más arriba. Podría ser por eso.

Hola:
No es un problema del nivel de entrada al opto, el problema esta en el soft.
He intentado varias soluciones pero mi fuerte no es la programación.
Un saludo
Paco