El Mundo de Tatán

Hola a todos:

Abro este tema sobre la maqueta que he realizado durante el año 2018 y que ahora me atrevo a presentar ante vosotros. Para comenzar os presento un vídeo breve y después en siguientes posts iré explicando la historia, las características y trucos que contiene la maqueta.



Por dar algunos datos generales, se trata de material de Märklin H0 analógico adquirido en su mayor parte en los años 60, pero complementado con un sistema de Arduino (en concreto dos arduinos) que se dedican a controlar los desvíos, barreras, semáforos para tren, farolas, luces de los coches, semáforos de tráfico, display digital y sonidos.

La maqueta no es muy grande (2m x 1 m) y alberga 15 m de vías. Seguramente, si la hiciera ahora, le haría otro diseño completamente distinto de vías, pero es lo que hay. En cuanto a la decoración he de nombrar a mi colaborador Toño Menéndez, sin el cual nada hubiera sido posible.

Respecto al nombre, diré que se trata de un homenaje a mi padre, a quien de niño llamaban "Tatán".

Espero que lo habéis visto y leído os dé curiosidad para seguir este tema y sigáis el desarrollo de la maqueta que iré escribiendo aquí.

La maqueta se encuentra en Oviedo y estaré encantado de mostrarla a quien tenga interés en ella.

Un saludo

Miguel SSM

Hola de nuevo:

Creo que lo que más puede interesar a los lectores del foro es la parte de automatización de la maqueta utilizando Arduinos, por lo que voy a continuar por este aspecto.

El Arduino, para quien no lo conozca, es una placa controladora muy utilizada en proyectos de robótica y automatización en escuelas y colegios, es barata, muy sencilla de usar y muy fácil de programar. Podéis encontrar un montón de información (en inglés) acerca de Arduino en su web oficial: https://www.arduino.cc/

Por ser hardware de licencia libre existen en el mercado varias marcas de dispositivos plenamente compatibles, en concreto en Amazon venden la marca Elegoo fabricada en China y muy económica. Entre los distintos modelos disponibles yo he trabajado sobre la Mega 2560, que es la que dispone de más entradas y salidas digitales, por lo que me permite controlar más cosas con una sola placa. Veremos más adelante que al final tampoco ha sido suficiente una sola placa y he tenido que añadirle una segunda, auxiliar. La placa se puede adquirir en Amazon por 13,99 €: https://www.amazon.es/ELEGOO-Microcontrolador-ATmega2560-ATmega16U2-Compatible/dp/B06Y3ZHPWC/ref=sr_1_1_sspa?ie=UTF8&qid=1551012818&sr=8-1-spons&keywords=arduino+mega+2560+r3&psc=1

Arduino se puede programar de forma sencilla usando la plataforma propia, el IDE que se descarga gratuitamente y está disponible para Windows, Mac y Linux. Yo que soy linuxero estoy encantado con ello, aunque a veces me da problemas la conexión entre el PC y la placa por la tendencia de Linux a no permitir el acceso a los puertos, pero nada que no se pueda solucionar con un poco de paciencia.

Mi primera intención era un uso del Arduino muy limitado, tan sólo para abrir y cerrar unas barreras de tren con unos servo-motores, cosa que fue relativamente fácil de programar. Pero al poco de empezar llegó a mis manos el Manual de Control, Maniobra y Conducción de Märklin, un PDF maravilloso donde se explica toda la parte técnica de la marca. En este documento se explica cómo funciona el control electromagnético los desvíos, incluso de las vías más antiguas, las Vías M que yo tengo.

Haciendo pruebas detecté que usando una placa relés intermedios https://www.amazon.es/Prosperveil-M%C3%B3dulo-canales-protecci%C3%B3n-optoacoplador-LM2576/dp/B07N66QVMS/ref=sr_1_3?ie=UTF8&qid=1551013673&sr=8-3&keywords=placas+rele+16 y enviando un pulso de 1,5 décimas de segundo se consigue colocar el desvío en la posición deseada.

Usando un teclado mínimo de 16 teclas con un código de dos teclas (esto da para hacer 256 órdenes diferentes) conseguí controlar los 20 desvíos de mi maqueta, usando dos placas de relés.
En la foto se pueden ver el Arduino, las dos placas de relés iniciales y el teclado mínimo.

Las librerías para hacer que los servos y el teclado funcionen se pueden encontrar desde la misma plataforma IDE en la que se programa el Arduino.

Os adjunto un archivo comprimido con los programas de Arduino que usé para ir probando los distintos elementos: relés, servos y teclado.

En siguientes posts iré comentando los sensores de detección del tren (a pesar de que son bastante imperfectos), el display, los sonidos y otros elementos controlados por los Arduinos.

Saludos

Miguel SSM

Caramba Miguel, para H0 le has sacado buen partido a esos 2x1 metro de maqueta. ¡Enhorabuena! Y a disfrutarla.

Espero con impaciencia tus experiencias y soluciones con arduino. Porque, aunque el control de mi maqueta, pretendo caiga en mis manos y no en las de un ordenador, no descarto utilizar algún arduino, y se muy poco sobre ellos.

Saludos.

hola Miguel,
de entrada te comento que no tengo ni idea de arduino aunque estoy informándome todo lo posible por lo que al igual que comenta Rubio me parece muy interesante como controlas los servos,
los ajustas y activas con pulsador o botón? puedes dar mas detalles?
un saludo

Hola de nuevo:

Para responder a vuestras cuestiones debo de aportar un poco más de explicación previa. El esquema de vías y desvíos de la maqueta es como se muestra en la siguiente figura:

En color marrón aparece la "carretera" y por tanto B1a y B1b son las Barreras 1 y B2a y B2b las Barreras 2. La subida y bajada de las barreras está asociada a que desde el teclado (que no deja de ser un conjunto de 16 pulsadores) se modifique la posición inicial (circuito arriba cerrado, circuito abajo en un "0") y como resultado el tren pueda pasar por alguno de los tramos con barrera; es decir, si se pulsa "21" ó "14" en el teclado, se activa el cambio en ese tramo y se lanza la función CerrarBar1(), cuyo código es el siguiente:

Código: Seleccionar todo

int CerrarBar1() {
  if (estbar1 == 1) {  //todo esto ocurre si la barrera está abierta, si no se queda como estaba.
     
    for (int pos = 75; pos <= 180; pos += 1) { // Va desde posición 70 (vertical) a 180 (horizontal) en pasos de un grado
      barrera1a.write(pos-5);    // Ese - 5 hubo que añadirlo para corregir una pequeña desviación del servo a respecto del b         
      barrera1b.write(pos);
      delay(15);                       // Espera para que el servo alcance la posición
    }
  }
  estbar1 = 0;
}


Lógicamente, para que todo esto funcione se debe usar la librería del los servos y definir los objetos y variables.

Código: Seleccionar todo

#include <Servo.h>  //Librería para controlar las barreras de los pasos a nivel

Servo barrera1a;   //Crean los objetos necesarios para controlar los servos

volatile int estbar1 = 1; // Define la variable del estado de la barrera 1
int barrera = 0;


En la parte del "setup" hay que incluir:

Código: Seleccionar todo

barrera1a.attach(8);  // Declara los pines de los servos para controlar las barreras, aquí sólo valen los pines 0-5 u 8-13


Para llamar a la función se escribe la línea siguiente:

Código: Seleccionar todo

barrera = CerrarBar1();


Los servos que yo utilicé son estos:
https://www.amazon.es/Servo-Motor-Control-Helic%C3%B3ptero-LKY66-UK-10/dp/B072J59PKZ/ref=sr_1_2?ie=UTF8&qid=1551110566&sr=8-2&keywords=servo+para+arduino

Como se puede ver en la imagen, tan sólo los pinté de gris y les añadí un palito de café pintado y con unas reflectantes rojas.



Espero que os haya ayudado.

La verdad es que el efecto combinado de cambio de desvío, barrera, semáforos de tráfico y sonidos es bastante sorprendente:


Saludos

Hola Miguel,
Gracias por la aclaración y vídeo. Lo que quería saber, sobre todo, son los componentes con los que actúas sobre las barreras, semáforos y, sobre todo, los desvíos. Es decir, que necesitaría y como conectar: teclado, placa arduino, etc.
Cómo ya he comentado, estoy iniciándome con el arduino y quisiera saber qué componentes necesitaría para comenzar
Otra cosa, y también muy importante es la programación, pero lo dejo para el segundo paso
Un saludo

Vale, vamos con ello:

Necesitas el Arduino, por si acaso y dado el precio yo te recomiendo el Elegoo Mega 2560 R3 ya citado más arriba. Vas a necesitar el teclado:

https://www.amazon.es/SODIAL-Teclado-Interruptor-Membrana-Arduino/dp/B00K6Y02BW/ref=sr_1_4?ie=UTF8&qid=1551132648&sr=8-4&keywords=teclado++4x4+arduino

La placa de relés: de 8 ó 16 según veas, únicamente debes saber que si quieres el de 16 tendrás que ponerle un alimentador externo de 9-12V porque el Arduino no es capaz de alimentarlo, el de 8 sí lo consigue alimentar directamente, aunque si pones varios también tendrás problemas. Has de tener en cuenta que cada desvío te requerirá dos relés, uno para cada dirección.

https://www.amazon.es/AptoFun-canales-Arduino-Raspberry-channels/dp/B01I41B8H0/ref=sr_1_2?ie=UTF8&qid=1551135456&sr=8-2&keywords=8+reles+arduino

Cables, bastantes:

https://www.amazon.es/Kuman-120pcs-Cables-Arduino-Raspberry/dp/B01BV3Z342/ref=sr_1_3?ie=UTF8&qid=1551133074&sr=8-3&keywords=cables+arduino

Una vez que reúnas los componentes, para cada desvío tienes un cable amarillo y dos azules. El amarillo va a la toma amarilla del transformador y los azules son los que se conectan cada uno a un relé. El relé lo activa el Arduino por el pin que selecciones. Se activa "por bajo" es decir, que si está HIGH la salida está desconectado y el relé está en la posición inicial, y sólo cuando está LOW se enciende la lucecita y se cambia de posición el conmutador que es el relé (se conecta la conexión central con una de un lado y cuando se activa con la del lado contrario). La de reposo se deja al aire y sólo conectas la lateral al cambio y la central a la conexión marrón (tierra).
Esta activación sólo se hará durante un tiempo corto, pues si mantienes la activación puedes correr el riesgo de cargarte el electroimán del desvío. Yo tengo puesto este pulso en 150 milésimas de segundo, es decir 0,15 segundos. Si el desvío está engrasado debe ser suficiente para cambiarlo de estado.

En cuanto esto último y lo del aceite, uno de los momentos más emocionantes del desarrollo técnico fue ver que desvíos que llevaban unos 40 años en cajas volvían a responder al ponerles un poco de aceite.

En el adjunto hay un programa de prueba de relés con el teclado creo que se puede usar con desvíos, pero pruébalo antes de conectarlo a los desvíos.

Las barreras son servos que se alimentan directamente desde el Arduino, por lo que un cable de 5V y otro de tierra se conectan al mismo. El tercer conector del servo se debe conectar a los pines 0-5, o entre 8-13 son los pines que permiten usar el estándar PWM que es el que necesita el servo. Tienes ejemplo de prueba de servos en el adjunto de mi post anterior.

Añado una foto de la conexión del desvío:


Espero haberme acercado a lo que necesitas.

Saludos

hola miguel,
gracias de nuevo por la explicación. lo iré viendo con detenimiento al mismo tiempo que hago las compras pertinentes para ir practicando
un saludo y perdona la interrupción en la descripción de tu maqueta que promete ser muy interesante

Voy a contar la génesis de todo el proyecto, y me vais a permitir que me ponga un tanto sentimental.

En los años 1930 Tatán vivía en una casa en Tudela-Veguín (un pueblo minero cercano a Oviedo) a escasos 200 m de las vías del tren. Cuando pasados los años Tatán ya era D. Sebastián, ingeniero y padre de familia numerosa, al fin adquiere un tren de juguete Märklin a finales de los años 50, principios de los sesenta. Ese tren se montó sobre un tablero (creo que de 2,44 x 1,22 m) y fue utilizado fundamentalmente por mi padre y sus amigos, y a mis hermanos (yo aún no existía) sólo les permitía mirar y como mucho encarrilar los vagones en caso de descarrilamiento. El el año 64 ese tablero, del que por desgracia no existe ningún documento gráfico de cómo era ese circuito, se desmonta y todo el tren se pone en cajas por traslado de la familia a un piso donde ya no había sitio para él. Y así comienza su estancia en cajas; tan sólo de modo muy esporádico se monta algún pequeño circuito temporal y se vuelve a las cajas. Tras varias vicisitudes y traslados de las cajas, en diciembre de 2017 mi hermano mayor, legítimo heredero del tren, decide ofrecerlo al hermano que se comprometa a hacer una maqueta.

Sin tener ni idea de dónde me metía, pero con ganas de hacer algo bonito en honor a mi padre, fallecido en el año 74, me comprometí a hacer esa maqueta, y así en enero de 2018 llegó el material a mi casa.

Cuando empiezo el diseño del circuito me planteo que tenga dos alturas y una rampa que las conecte, que ocupe un espacio que ya tengo reservado en mi casa que proporciona aproximadamente 2m de longitud máxima y que lleve algo de automatismo. Estudiando el material de vías pronto destaca un elemento sobre todos los demás: el cruce central del "ocho":



A partir de aquí el plano de vías de la zona baja queda prácticamente determinado, y tan sólo queda añadir la rampa y la zona superior, un cero con un elemento central que permita el cambio de sentido van a ser los que completen el trazado.



Ya sobre el tablero añadí también una línea con tope de vía para la estación:



Ya muy avanzada la maqueta e instalado (aunque de forma provisional) el puente en arco, decidí añadir una vía muerta en el hueco que quedaba.



La rampa sufrió una leve modificación cuando al adquirir el tercer transformador junto con él vinieron unas curvas de un radio mayor del que yo disponía hasta entonces, y son las que han quedado definitivamente.

El uso de tres transformadores me permite controlar independientemente la zona baja, la rampa y la zona superior y la zona de la estación. Para ésta última tuve que hacer una modificación en uno del cruces de vías: cortar la línea central a ambos lados y unir con soldadura las dos líneas interrumpidas, para mantener el control de la zona de la estación independiente del de la zona baja:



Finalmente, con el Arduino y un display digital añadido recientemente, el cuadro de mandos de la maqueta queda con el transformador original de mi padre (de 110 V, que requiere, claro, un transformador auxiliar) y los dos adquiridos por Internet para las otras dos zonas.



Espero no haber aburrido al personal con todo esto, pero así voy dejando registro (y memoria) de todo el trabajo realizado, ahora que aún lo tengo reciente.

Saludos

Allá dónde esté, Tatán se sentirá muy orgulloso de volver a sentir su tren rugir y circular de nuevo en su maqueta. Es una herencia preciosa que confío en que tus descendientes estimen en su valor sentimental y también histórico.

Un saludo, y gracias por compartir.

Gracias, Rubio, por tus palabras, me han encantado.

Voy a continuar con el relato del proyecto. Mientras se gestaba todo esto, en uno de mis paseos en bici, surgió la conversación y uno de mis compañeros, Toño Menéndez, se ofreció para ayudarme con la maqueta, sobre todo con la decoración. Acepté encantado la oferta y fue una de las mejores decisiones tomadas: Toño es un verdadero artista y a él se deben los logros de realismo que ha alcanzado la maqueta. A partir de ahora lo citaré a menudo, porque va a tomar verdadero protagonismo en la historia.

Las primeras pruebas de la maqueta las hago con los cables bajo las vías, pero sobre el tablero, hasta que llego a este punto de lío cableril que se aprecia en la imagen:



Si se echan cuentas, cada desvío lleva tres cables y tengo 10 desvíos controlados eléctricamente y que cada relé (hay 20) lleva uno hacia el Arduino, ya estamos, ya estamos en 80 cables, aunque eso es sólo el principio.

En la imagen también se aprecia la primera idea que me ofrece Toño: poner un muro de hormigón con graffitis en el escalón que queda atrás entre la parte superior y la parte inferior, los que veis y los definitivos son graffitis y murales reales fotografiados y texturizados sobre hormigón e impresos en láser color y encolados sobre una tabla de contrachapado, el resultado es muy convincente y el precio bien barato.

En esta época me sale un ćolico nefrítico que me deja de baja de un par de semanas. En ese momento decido que la piedra que me sacan del riñón formará parte de la maqueta...

Pasar los cables a la zona inferior fue un trabajo complejo, y lento, que se llevó también parte de un dedo:



Por suerte se pudo recuperar con paciencia y tiempo. Aquí me veis entre los caballetes auxiliares conectando unos cuantos de esos cables.



Otro de los objetos que pretendía controlar con el Arduino era detectar la posición y sentido del tren, y con mi formación en rudimentos de tecnología decidí hacerlo con sensores ópticos. Al principio lo intenté con sensores de barrera, lo cual implicaba un emisor a un lado de la vía y un receptor al lado contrario, como hay que alimentar el emisor y controlar el receptor, eso no se puede hacer con menos de 5 cables por puerta de control. Mi idea era poner seis puertas dos en cada nivel (incluyendo la rampa como nivel) para poder determinar no sólo la posición sino también el sentido de giro del tren.

Los sensores de barrera me dieron muchos problemas, y no sólo por su cableado, sino porque no encontré unos baratos que fueran fiables. Se puede ver en el vídeo una prueba con sensores de barrera dobles (un emisor y dos receptores) que no siempre funciona bien:



Al final tengo instalados unos sensores de reflexión mucho más discretos y eso sí, casi igual de inexactos, esa parte del programa tengo que depurarla mucho más si quiero que llegue a funcionar algún día. Se pueden adquirir en ebay por menos de 2 € cada uno.
https://www.ebay.es/itm/Infrarrojos-Detector-Pista-Tracker-seguidor-Sensor-5v-Shield-Para-Arduino-/263765295939?hash=item3d69a30343



Pero al menos son discretos. Lo único que me ha condicionado, es que había dos locomotoras que no reflejaban lo suficiente y tuve que añadirles unos reflectantes para que los sensores las detectaran.



Como en ese momento me "sobraban" cuatro relés y no tenía problemas de salidas del Arduino adquirí cuatro semáforos plenamente funcionales de dos aspectos para aprovechar la placa en Modelismo del Tren a un precio razonable:

https://www.modelismodeltren.com/semaforos-mdt-escala-h0/semaforo-2-aspectos-zf02-mdt-escala-h0.html

Estos van a 12 voltios, es decir, van conectados a la misma fuente de alimentación que la placa de 16 relés, y van conectados a los dos contactos laterales de los relés y el central a la toma de tierra. Decidí instalarlos en las entradas inferior y superior de la rampa, en la salida de la estación y en la entrada del túnel al lado de los mandos.





Los dos de la rampa van asociados al estado en que se encuentren los desvíos de acceso, sólo se ponen en verde si el desvío lleva a la rampa.

Los semáforos del tráfico se explicarán más adelante, pues van asociados al segundo Arduino. Paso a paso. Por hoy ya está bien.

Saludos

Voy a hacer ahora una introducción general a la programación en Arduino, pues veo que el tema ha suscitado cierto interés.

Como ya hemos dicho, lo habitual es programar el Arduino desde la plataforma libre y gratuita asociada al mismo: el IDE. Se puede descargar en el siguiente enlace:

https://www.arduino.cc/en/Main/Software

Como puede verse hay versiones para todas las plataformas, elegimos la adecuada a nuestro sistema y la descargamos. Si sois linuxeros, conviene además de la instalación ejecutar un complemento denominado arduino-linux-setup.sh para que las cosas funcionen correctamente con vuestra instalación.

Al arrancar el IDE nos presenta un programa en blanco que tiene un aspecto similar a éste:



Por cierto, comentar que el código se escribe técnicamente en texto plano que se guarda con la extensión .ino, la plataforma se encarga de generar una carpeta para cada proyecto con el mismo nombre que le demos. Este es un programa en blanco, pero vamos a estudiar la estructura general de un programa sencillo que ya hemos citado aquí: tecladoyreles.ino

Código: Seleccionar todo


#include <Keypad.h> //llama a la librería Keypad.h que va a hacernos la gestión del teclado
 

char codigo[2];            //Cadena donde se guardaran los caracteres de las teclas presionadas
int cont=0;          //variable que se incrementara al presionar las teclas
char modoa[]="A*";  //aquí escribimos el código de dos digitos Modo A
char modob[]="B*";  //aquí escribimos el código de dos digitos Modo B
char modoc[]="C*";  //aquí escribimos el código de dos digitos Modo C
char modod[]="D*";  //aquí escribimos el código de dos digitos Modo D
char modo0[]="0*";  //aquí escribimos el código de dos digitos Modo 0
char modo1[]="1*";  //aquí escribimos el código de dos digitos Modo 1
 
const byte ROWS = 4; //Numero de filas del teclado que se está usando
const byte COLS = 4; //Numero de columnas del teclado que se está usando
 
char hexaKeys[ROWS][COLS] =  //Aquí pondremos la disposición de los caracteres tal cual están en nuestro teclado
{
  {'1','2','3','A'},
  {'4','5','6','B'},
  {'7','8','9','C'},
  {'*','0','#','D'}
};
 
byte rowPins[ROWS] = {39, 41, 43, 45}; //Seleccionamos los pines en el arduino donde irán conectadas las filas
byte colPins[COLS] = {47, 49, 51, 53}; //Seleccionamos los pines en el arduino donde irán conectadas las columnas
 
Keypad customKeypad = Keypad(makeKeymap(hexaKeys), rowPins, colPins, ROWS, COLS); //inicializa el teclado,
     // así no nos tenemos que encargar de definir entradas ni salidas

#define DOS 2
#define TRES 3
#define CUATRO 4
#define CINCO 5
#define SEIS 6
#define SIETE 7
#define OCHO 8
#define NUEVE 9

int reposo = 0;

void setup()
{
  pinMode(13, OUTPUT); //Pin 13 como salida
  Serial.begin(9600); //inicializar puerto serie

  pinMode(DOS,OUTPUT);// Estas son las salidas a los relés (placa de 8 relés) se establecen como salida
  pinMode(TRES,OUTPUT);
  pinMode(CUATRO,OUTPUT);
  pinMode(CINCO,OUTPUT);
  pinMode(SEIS,OUTPUT);
  pinMode(SIETE,OUTPUT);
  pinMode(OCHO,OUTPUT);
  pinMode(NUEVE,OUTPUT);


  digitalWrite(DOS,HIGH);
  digitalWrite(TRES,HIGH);
  digitalWrite(CUATRO,HIGH);
  digitalWrite(CINCO,HIGH);
  digitalWrite(SEIS,HIGH);
  digitalWrite(SIETE,HIGH);
  digitalWrite(OCHO,HIGH);
  digitalWrite(NUEVE,HIGH);

  char codigo[]="0*";
 
 
}
 
void loop()
{
  char customKey = customKeypad.getKey(); //se guarda en la variable customKey el caracter de la tecla presionada
 
  if (customKey != NO_KEY || cont>=5)         //se evalúa si se presionó una tecla
    {
    codigo[cont]=customKey;          //se guarda caracter por caracter en la matriz codigo[]
    cont=cont+1;              //incrementamos la variable cont
    if(cont==2)          //si ya fueron presionadas 2 teclas se evalúa el código introducido
    {
      Serial.println(codigo);    //se imprime en el puerto serie el código introducido
      Serial.println(cont);
     
      if(codigo[0]==modoa[0]&&codigo[1]==modoa[1])
      {
 
        digitalWrite(DOS,HIGH);
        digitalWrite(CUATRO,HIGH);
 
        delay(150);                          // Espera 150 milésimas de segundo
        digitalWrite(DOS,LOW);
        digitalWrite(CUATRO,LOW);
       
       
        digitalWrite(13,!digitalRead(13));        //si la contraseña fue correcta se enciende o se apaga el led del pin13
      }

      if(codigo[0]==modob[0]&&codigo[1]==modob[1])
      {
        digitalWrite(DOS,HIGH);
        digitalWrite(TRES,HIGH);
        digitalWrite(CUATRO,HIGH);
        digitalWrite(CINCO,HIGH);
        digitalWrite(SEIS,LOW);
        digitalWrite(SIETE,LOW);
        digitalWrite(OCHO,LOW);
        digitalWrite(NUEVE,LOW);
        delay(150);
       
        reposo = ReposoReles();
       
        digitalWrite(13,!digitalRead(13));        //si la contraseña fue correcta se enciende o se apaga el led del pin13
      }
       if(codigo[0]==modoc[0]&&codigo[1]==modoc[1])
      {
        digitalWrite(DOS,HIGH);
        digitalWrite(TRES,LOW);
        digitalWrite(CUATRO,HIGH);
        digitalWrite(CINCO,LOW);
        digitalWrite(SEIS,HIGH);
        digitalWrite(SIETE,LOW);
        digitalWrite(OCHO,HIGH);
        digitalWrite(NUEVE,LOW);
        delay(150);
       
        reposo = ReposoReles();
       
        digitalWrite(13,!digitalRead(13));        //si la contraseña fue correcta se enciende o se apaga el led del pin13
      }     

       if(codigo[0]==modod[0]&&codigo[1]==modod[1])
      {
        digitalWrite(DOS,LOW);
        digitalWrite(TRES,HIGH);
        digitalWrite(CUATRO,LOW);
        digitalWrite(CINCO,HIGH);
        digitalWrite(SEIS,LOW);
        digitalWrite(SIETE,HIGH);
        digitalWrite(OCHO,LOW);
        digitalWrite(NUEVE,HIGH);
        delay(150);
       
        reposo = ReposoReles();
       
        digitalWrite(13,!digitalRead(13));        //si la contraseña fue correcta se enciende o se apaga el led del pin13
      }     

       if(codigo[0]==modo0[0]&&codigo[1]==modo0[1])
      {
        digitalWrite(DOS,HIGH);
        digitalWrite(TRES,HIGH);
        digitalWrite(CUATRO,HIGH);
        digitalWrite(CINCO,HIGH);
        digitalWrite(SEIS,HIGH);
        digitalWrite(SIETE,HIGH);
        digitalWrite(OCHO,HIGH);
        digitalWrite(NUEVE,HIGH);
        delay(150);
       
        reposo = ReposoReles();
       
        digitalWrite(13,!digitalRead(13));        //si la contraseña fue correcta se enciende o se apaga el led del pin13
      }     
      if(codigo[0]==modo1[0]&&codigo[1]==modo1[1])
      {
        digitalWrite(DOS,LOW);
        digitalWrite(TRES,LOW);
        digitalWrite(CUATRO,LOW);
        digitalWrite(CINCO,LOW);
        digitalWrite(SEIS,LOW);
        digitalWrite(SIETE,LOW);
        digitalWrite(OCHO,LOW);
        digitalWrite(NUEVE,LOW);
        delay(150);
       
        reposo = ReposoReles();
       
        digitalWrite(13,!digitalRead(13));        //si la contraseña fue correcta se enciende o se apaga el led del pin13
      }     
     cont=0;  //resetear a 0 la variable cont

    }
   
   }   
     
 
}


int ReposoReles() {

    digitalWrite(DOS,HIGH);
    digitalWrite(TRES,HIGH);
    digitalWrite(CUATRO,HIGH);
    digitalWrite(CINCO,HIGH);
    digitalWrite(SEIS,HIGH);
    digitalWrite(SIETE,HIGH);
    digitalWrite(OCHO,HIGH);
    digitalWrite(NUEVE,HIGH);
   
}


Un programa de Arduino tiene seis partes fundamentales: la primera es la inclusión de las librerías necesarias para que algunos complementos de Arduino funcionen correctamente. Podríamos ponernos a programarlos directamente, pero ya hay mucha gente que lo ha hecho por nosotros, y ¿para qué hacer un trabajo que ya está hecho y a nuestra disposición? En el caso del programa que veis sólo hay una librería implicada, la que maneja el teclado: Keypad.h
En Internet vamos a encontrar mucha información de las posibilidades de las librerías, sus funciones y sus aplicaciones (eso sí, casi siempre en inglés).

En total de mi programación he usado seis librerías, tres en el programa del primer Arduino y otras tres en el segundo. Son pocas, pero relevantes. Siempre van detrás de la etiqueta #include.

A continuación va la parte dedicada a la definición de variables. Aunque se pueden definir variables en medio del código, la etiqueta de programación recomienda que se declaren al principio. Hay muchos tipos de variables en Arduino, pero la más utilizada es del tipo int (entero), aunque en el ejemplo aparecen char (matriz de caracteres) y byte (octeto o byte). Aquí tienen una guía completa:

https://www.arduino.cc/reference/en/#variables

En este grupo también se incluyen las definiciones de constantes para nombrar los pines: ej. "#define SEIS 6" a partir de ahora nos referiremos al pin 6 como SEIS (es sensible a las mayúsculas).

El siguiente bloque de código viene el setup comienza con el código "void setup() {" y termina cuando se cierra esta llave. Este bloque sólo se ejecutará una vez, al principio, por lo que pondremos allí todas las tareas iniciales que necesitemos para dejar nuestro sistema preparado para el trabajo, es decir, para la siguiente parte que se ejecutará indefinidamente (el loop). En este bloque de setup se suele aprovechar a declarar el pin 13 como salida, pues este pin está ligado a un led del Arduino, por lo que es la primera realidad que podemos cambiar sin conectar nada a la placa, si conseguimos encender ese led, lo demás vendrá rodado!!
También se abre el puerto serie que servirá para monitorizar cuando lo necesitemos el comportamiento del Arduino desde la pantalla del ordenador. Esas son las dos primeras líneas de nuestro ejemplo.

El cuarto bloque es el loop, la parte del programa que se repite indefinidamente empiza en el código "void loop() {" y termina con la llave de cierre. Esa es la parte mollar del programa, lo que realmente queremos que haga, de lo que nos ocuparemos más adelante en otro capítulo.

El bloque que sigue es el de las funciones, trozos de código que en lugar de repetirlo en distintos puntos, se coloca al final, y se llama cuando es necesario, en nuestro caso ReposoReles() es una función que pone todos los relés en inactivos (recordemos que se desactivan por alto-> HIGH). para llamar una función hay que poner una orden muy rara: hay que definir una variable del mismo tipo que la función (int) y mandar a Arduino la siguiente orden:

reposo = ReposoReles();

Con esto se llama a la función, que se ejecuta y tras esto el programa retorna a la siguiente línea de código.

El bloque sexto y último es el de las interrupciones. Se denomina interrupción en informática a un evento habitualmente externo que determina que el sistema ejecute algún tipo de rutina, se usa por ejemplo para recibir las órdenes del teclado y los movimientos del ratón. En este caso no se usa para el teclado, que se detecta de otro modo, y en este programa no hay ningún uso, pero en el programa completo utilizo las interrupciones para detectar el paso de los trenes por los sensores:

Código: Seleccionar todo

void inte4() {  //Pin 19 Puerta 1b Superior trasera
  contp1b = contp1b + 1;
  contp1a = 0;
  contp2a = 0;
  contp2b = 0;
  contp3a = 0;
  contp3b = 0;
  if (millis() > tiempo1b + param1 && contp1b >= param2) {
    est_puerta1b = LOW;
    contp1b = 0;
    tiempo1b = millis();
    //Serial.println("Puerta 1B");
  }
}


Las interrupciones están directamente asociadas a unos determinados pines, no todos los pines del Arduino están preparados para establecer interrupciones, en el caso de la Mega 2560 sólo tiene seis y son los pines 2, 3, 18, 19, 20 y 21. Depende del modelo que se use, vamos a tener distintas posibilidades. Para mayor información ver la tabla siguiente:



Y estas son las seis partes que podemos distinguir en un programa de Arduino. Os dejo como ejercicio (¿se me nota la vena docente?) que encontréis cinco de los seis bloques citados en el siguiente programa:

Código: Seleccionar todo

#include <IRLremote.h>

#define LEDPIN 13


#define emisor1 30
#define puerta1a 18
#define puerta1b 19

int intpuerta1a = 5;
int intpuerta1b = 4;

volatile boolean est_puerta1a = HIGH, est_puerta1b = HIGH;
int estado = 0, lastStatea=0, lastStateb=0;       

volatile long tiempo1a = 0, tiempo1b = 0;

int estadotren = 0;
int estadoanterior = 0;
int vueltastrenarriba = 0;

void setup() {
  // initialize the LED pin as an output:
  pinMode(LEDPIN, OUTPUT);
  pinMode(emisor1, OUTPUT);
  // initialize the gate sensors pins as an interruption input:
 
  pinMode(puerta1a, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(puerta1a), inte5, HIGH);
  pinMode(puerta1b, INPUT_PULLUP);     
  attachInterrupt(digitalPinToInterrupt(puerta1b), inte4, HIGH);
  digitalWrite(puerta1a, LOW);
  digitalWrite(puerta1b, LOW);  // turn on the pullup
  digitalWrite(emisor1, HIGH);
  Serial.begin(9600);
}

void loop(){

  if (est_puerta1a == LOW && est_puerta1b == LOW) {

   if (tiempo1a + 50 < tiempo1b  && tiempo1a != 0) {
   
      estadotren = 2;
       
      Serial.println("SENTIDO ANTI-HORARIO");
      digitalWrite(LEDPIN, HIGH);
     
   }
   if (tiempo1b + 50 < tiempo1a && tiempo1b != 0) {
     estadotren = 3;
      Serial.println("SENTIDO HORARIO");
      digitalWrite(LEDPIN, LOW);
   }   
    est_puerta1a = HIGH;
    est_puerta1b = HIGH;
    tiempo1b = 0;
    tiempo1a = 0;
    vueltastrenarriba = vueltastrenarriba + 1;
    Serial.println(vueltastrenarriba);
    delay(4000);
    estadoanterior = estadotren;
  }

   
 

   delay(5);
 
 
}

void inte5() {
  if (millis() > tiempo1a + 500){
  est_puerta1a = LOW;
  tiempo1a = millis();
  Serial.println("Puerta A");
  }
}

void inte4() {
  if (millis() > tiempo1b + 500) {
  est_puerta1b = LOW;
  tiempo1b = millis();
  Serial.println("Puerta B");
  }
}


Espero haber contribuido a que vayáis comprendiendo mejor el Arduino y sus muchas posibilidades. Otro día, más.

Saludos

Buenas noches Miguel,
Vaya tutoríal!!! La verdad que tal y como lo explicas parece fácil.lo iré viendo poco a poco ya que me parece muy complicado
Muchas gracias por explicarlo
Un saludo

Buenas tardes Tatán
Hace unos días descubrí tu maravilloso Mundo y como, de una manera autodidacta has conseguido automatizar tu maqueta. No diré que la construcción esté plenamente lograda, tal y como yo la veo, pero desde luego le has puesto imaginación y a mi entender en estos temas, si persistes en el empeño será más que digna para verla y disfrutar de su uso. Te confesaré que quizá disfrutes mucho más con la construcción y sus dificultades y sus logros que con el uso. Yo estoy pasando por lo mismo. He leído tanto y he pensado en cada uno de los pasos a dar que ya llevo desde Mayo pasado y ahora comienzo a "levantar" las primeras vías. Si te digo esto, es porque aún no tengo claro como voy a automatizar (palabra mágica por ahora) mi diseño de Maqueta. Buscando lecturas sobre el tema y de "constructores" noveles te he encontrado y he leído tu Manual. Me parece estupendo lo que has logrado y con tu permiso, he copiado todo lo que has escrito sobre el tema. Todo, incluyendo los links.
Te diré que Creo que ya soy un devoto alumno tuyo. Comenzaré como he hecho con mi proyecto. Leer y leer. Pensar y repensar. He cumplido 70 años y he dirigido una de las mayores Ingenierias de Civil de España, ahora he decidido jubilarme y no tengo prisa, quiero disfrutar No solo de la Obra terminada, sino mucho del camino hasta conseguirlo. Pero he hecho pocas cosas, de manualidades, exceptuando un barco partiendo de su Plano escala 1:50 y una maqueta de Tren ARNOLD hace 34 años), partiendo de mi Diseño. Haré pues con la "automatización" lo que sé que debo hacer. Leer y releer todo lo que haya sobre el Arduino que mencionas, ( aunque tú has tenido que colocar dos Placas??) y ver de sus limitaciones y sus posibilidades (yo tengo que comandar 38 desvíos de dos posiciones y 3 de tres posiciones). Dispongo de 6 Trafos Fleischmann y no quiero que sea "digital" en sentido estricto. Tengo 14 locomotoras y ninguna es digital, quiero centrarme en las épocas I, II y III. Mi diseño hecho con el Programa SCARM lo he probado con el Subprograma Model Trains Simulator y me funciona en la visión en 3D. Dicho todo esto. Sigo siendo cauteloso con ponerme a montar las vías
Enhorabuena por tu trabajo y por la Generosidad en compartirlo. Sirvan estas letras para agradecerte el buen momento y espero disfrutar de todos y cada uno de los momentos buenos y malos que encontraré. No me asusta la Tecnología. Me encanta y me enfrento a ella con la ayuda de "otros" que ya han caminado por ella. Todo lo que escribas sobre el Tema lo leeré y cualquier idea que expongas la someteré a juicio por mi interés. DE NUEVO GRACIAS

Buenas tardes Miguel,
Me ha gustado mucho encontrar tu hilo y ver el uso que le has dado al Arduino para manejar los desvíos. Te comento brevemente, llevo con maquetas, interrumpidamente, desde los 15 años. Actualmente tengo 70, y llevo jubilado desde hace 5 años tiempo en el que he retomado la construcción de una maqueta que calculo definitiva. Me planteaba las siguientes condiciones básicas: analógica, tablero de mando esquemático, mínimo cableado, control de desvíos con interruptores on-on, indicador del estado del desvío visual por la palanca del interruptor sin necesidad de leds. La maqueta es escala N con vías Fleischmann sin balasto. Está construida en tres partes (que se fueron creando a medida que disponía de más espacio) cada una de las cuales tiene su propio tablero de mando. Dispone de seis cantones y tres zonas de maniobras independientes, cada uno de ellos con su controlador PWM y su Gaugemaster. Tiene forma de U invertida y está pensada, fundamentalmente, para hacer maniobras mientras circulan trenes en un óvalo exterior que pasa por dos estaciones ocultas de tres vías cada una automatizadas con Arduino. Visto de forma muy somera la situación te cuento lo de los desvíos con Arduino:

El programa del Arduino, de cada módulo, testea en forma ininterrumpida todos los interruptores del tablero de mando, cuando un interruptor cambia de estado posiciona el relé correspondiente a ese desvío en curva o recta (cada desvío tiene asociado un único relé, y luego activa un relé común durante 30 milisegundos que energiza los relés de los desvíos.
Todos los desvíos reciben entonces el impulso, pero éste es tan corto que no afecta las bobinas aunque no tengan fin de carrera. Sólo se moverá el que ha cambiado de estado, no volverán a recibir ningún impulso hasta que otro desvío cambie de estado.
El relé común proporciona 16Vca desde un transformador externo que es lo suficientemente potente para mover los espadines con seguridad y, al mismo tiempo, no ser dañino para las bobinas.
Los interruptores tienen un cable común (+5Vcc) a todos y otro único al Arduino, por lo que sólo hay un pin por desvío para detectar el interruptor y otro pin por desvío para manejar el relé, mínimo cableado.
El Arduino es un Arduino Mega 256 y la placa de relés es de 16 relés alimentada a 12 Vcc. Con dos de estas placas y un Arduino manejo en uno de los módulos 21 desvíos.
Adicionalmente el Arduino, basado en la posición de algunos desvíos, controla las señales.

Me permito adjuntar un esquema de lo dicho que seguro será más claro que mi descripción. Sólo intento compartir otra solución basada en el extraordinario mundo de posibilidades que da el Arduino.

En otro orden de cosas, he tenido los mismos problemas con los sensores IR. Tampoco me han gustado los sensores Reed o Hall que obligan a poner imanes en las máquinas. Actualmente estoy probando con muy buen éxito unos mini sensores laser de los que ya te comentaré en otro post, éste se está haciendo muy largo.

Hola jumacaba,
Al igual que el método de tatan, me parece muy interesante como accionas los desvíos con arduino, que en este caso lo has hecho con un mega pero supongo que con una placa arduino uno se podrá igual
Seguiré este hilo con atención ya que yo también sigo dándole vueltas a como accionar las agujas
Un saludo y mucho ánimo con el montaje

Hola chuko72
Efectivamente se puede utilizar tanto un Mega como un UNO, pero teniendo en cuenta las siguientes fórmulas para saber si tienes los pines necesarios disponibles.
En el caso de Tatan es: pines = desvíos * 2 + 7 (conexión del teclado, aunque hay teclados similares con sólo 3 conexiones que requieren un único pin de datos, los otros dos son Vcc y GND)
En mi caso: pines = desvíos * 2 + 1 (relé común)
Como vez, los requisitos son muy similares o idénticos. Con un Arduino UNO podemos manejar 6 desvíos, con un MEGA llegamos hasta los 25 desvíos. Siempre podemos usar más de un Arduino dividiendo los desvíos entre ellos. Pueden ser más si algunos funcionan en pares o hay establecimiento de rutas

buenos días jumacaba,
muchas gracias por la aclaración. lo iré viendo con tranquilidad
un saludo

Hola a todos:

Muchísimas gracias, Jumacaba, por tu aportación. Los autodidactas solemos encontrar una solución, pero está claro que no siempre es la mejor! Tiene que estar muy chulo ese cuadro de mandos con esquema físico de los desvíos y con sus interruptores indicando la dirección deseada en el desvío, y lo del relé único que alimenta los desvíos, todo un invento. Se podría pensar en añadir unos LED's indicadores en paralelo a la entrada de los relés, pues en las placas van con optoacopladores y consumen relativamente poco, si van alimentadas por otra fuente; se podría probar con unos LED acompañados en serie con una resistencia relativamente alta (10k quizás?) que evite consumos altos y asegure que el optoacoplador se va a excitar.

Otra cosa que me sorprende es el poquísimo tiempo que tienen de respuesta los desvíos: en mi software, fui probando y tras estar un tiempo en 200 milésimas, probé a ponerlos con 100 milésimas, y me pareció que algunos desvíos más viejos y "perezosos" no terminaban de colocarse en posición, por lo que puse ese parámetro en 150 milésimas, pero con lo que cuentas me han dado ganas de probar tiempos menores, pues lo tengo parametrizado en software, es decir, sólo lo tengo que cambiar en la asignación de variables al inicio, y se aplica en todo el programa.

En cuanto a las conexiones necesarias en mi montaje, debo decir que el teclado de 4x4 lleva ocho conectores al Arduino, eso sí, con códigos de dos teclas permite 256 órdenes y si se usase con tres teclas sería de 16³ = 4096 órdenes; y la conexión entre los dos Arduinos, que es manifiestamente mejorable, ahora mismo se hace por bus paralelo en bruto, es decir, me consume otros cuatro pines (15 posibles órdenes). Si viese que iba a necesitar más de 7 pines (es más o menos lo que me queda libre en el primero) se podría implementar una comunicación en serie, más compleja de programar, pero que sólo necesitaría dos pines como máximo, eso sí, de los específicos RX-TX:

https://iotguider.in/arduino/serial-communication-between-two-arduino-boards/

Otra cosa que me ha interesado mucho es lo de la existencia de teclados con conexiones más "económicas" en pines, lo cual me habría venido muy bien. Si algún día me animo a implementar cambios en eso, lo buscaré.

El segundo Arduino lo dedico a controlar los sonidos, mensajes de megafonía de la estación y música ambiental (toda relativa a los trenes), y a encender y apagar las farolas, las luces de los coches, y los semáforos de tráfico, que tengo dos grupos y cada uno lleva tres relés. En total cuento con 32 relés aprovechados todos ellos: 16 + 8 en el primer Arduino y 8 más en el segundo. Me muero sólo de pensar en controlar los 38 desvíos de dos posiciones y otros 3 de tres posiciones de Don Garo (ni idea de cómo van estos últimos) con mi sistema: seguramente me iría a dos Arduinos conectados en serie.

Adjunto un PDF con unos listados de las conexiones actuales de mis Arduinos.

De nuevo gracias por las aportaciones, Jumacaba y Don Garo
Un saludo

miguelssm escribió:

Hola a todos:
En cuanto a las conexiones necesarias en mi montaje, debo decir que el teclado de 4x4 lleva ocho conectores al Arduino, eso sí, con códigos de dos teclas permite 256 órdenes y si se usase con tres teclas sería de 16³ = 4096 órdenes; y la conexión entre los dos Arduinos, que es manifiestamente mejorable, ahora mismo se hace por bus paralelo en bruto, es decir, me consume otros cuatro pines (15 posibles órdenes). Si viese que iba a necesitar más de 7 pines (es más o menos lo que me queda libre en el primero) se podría implementar una comunicación en serie, más compleja de programar, pero que sólo necesitaría dos pines como máximo, eso sí, de los específicos RX-TX:

Hola Miguel
Muchas gracias por tus comentarios, yo también soy autodidacta en Arduino y le veo un enorme potencial en nuestro hobby pero actualmente estoy en pañales.
Me interesó este párrafo en el que hablas de las conexiones entre Arduinos. Efectivamente la solución óptima es la comunicación serial, pero he visto una posibilidad muy interesante con un sólo pin. El teclado de tres cables que te comentaba aplica esta solución. Tiene dos para su alimentación y sólo uno para trasmitir cual botón se pulsó. El truco es que tiene una resistencia diferente en cada botón lo que hace posible saber cual es sólo con una cascada de comparaciones con el valor recibido. Te dejo la imagen posterior del teclado en que muestra los posibles 16 valores para sabeer cual botón es.

basura.png (271.15 KiB) Visto 22803 veces

Creo que siguiendo la misma idea y aprovechando los pines PWM se podría hacer una comunicación entre Arduinos muy sencilla y muy económica en pines. Yo personalmente aún no la he probado, pero está en cola de espera de mis proyectos. Primero tengo previsto probar una pantalla táctil para dar órdenes a la estación oculta.

Un cordial saludo,
Juanma