El Mundo de Tatán

Hola de nuevo:

Uno de los asuntos que más me costó echar a andar fue el tema de los sonidos. Ya desde la inauguración de la maqueta, una amiga me había sugerido que hubiese sonidos de la estación y cosas así, y el reto me gustó. 4 meses más tarde logré los primeros resultados, pero una conexión errónea me quemó la placa. Cuando tuve repuestos volví a la carga y en diciembre pude llamar a quien me retó a que viese el resultado:



Estuve buscando por Internet varias posibilidades y hay fundamentalmente dos, paso a explicarlas brevemente y los resultados:

La primera es usar una MicroSD que debes leer desde el Arduino con un lector de tarjetas y es el mismo Arduino el que descodifica el archivo, que necesariamente tiene que estar en formato WAV. La tarjeta tiene que conectarse al Arduino por unos pines específicos, que dependen del modelo de Arduino que estemos usando. En el caso de la Mega 2560 son los 51-53. Hice bastantes pruebas y no conseguí reproducir ningún archivo, pero no debe ser imposible a juzgar por gente que lo ha hecho:
http://intelirobot.com.mx/blog/arduino/toca-sonidos-wav-en-arduino/
Para quien lo quera intentar las placas son éstas:
https://www.amazon.es/dp/B06XHJTGGC?ref_=ams_ad_dp_ttl

La segunda, que fue la solución adoptada, es mediante un reproductor MP3, el DFPlayer que se conecta con el Arduino mediante una conexión serie, es decir que en el caso del Arduino Mega 2560 se pueden usar cualquiera de los pares RX/TX de los que dispone: 0-1 (RX), 19-18 (RX1), 17-16 (RX2), 15-14 (RX3). La placa se puede adquirir en Amazon por poco dinero, como no es difícil quemarlas (yo me cargué 2 ó 3), las venden en packs de 3 ó de 5:
https://www.amazon.es/gp/product/B07911V1NL/ref=ppx_yo_dt_b_asin_title_o04_s00?ie=UTF8&psc=1
Para conectarlas conviene tener alguna placa protoboard:
https://www.amazon.es/gp/product/B071ZGC75Y/ref=ppx_yo_dt_b_asin_title_o09_s00?ie=UTF8&psc=1
Y para probarlo todo vale cualquier altavoz pequeño que tengamos a mano, pero si no disponemos de ninguno, estos altavoces son suficientes:
https://www.amazon.es/cylewet-di%C3%A1metro-ohmios-altavoz-est%C3%A9reo/dp/B06XT5ZHM3/ref=pd_bxgy_23_img_2/257-6594454-4287244?_encoding=UTF8&pd_rd_i=B06XT5ZHM3&pd_rd_r=19f4ce25-4853-11e9-80f5-471b8392310f&pd_rd_w=vWStL&pd_rd_wg=XyQCG&pf_rd_p=7b8b17e5-e2e0-413e-bf77-272aa9f4139c&pf_rd_r=MQZ4WQQ91ER711WGMVKM&psc=1&refRID=MQZ4WQQ91ER711WGMVKM

Este decodificador MP3 ya incluye un lector de tarjetas MicroSD (aunque las lee un poco a su aire, ya veremos), decodifica los MP3 y los envía, bien a un altavoz a través de un pequeño amplificador integrado de 3W, bien a un amplificador. El esquema de pines es el siguiente:



El esquema de conexión básico lo tomo prestado:



Aquí tengo que hacer algunas consideraciones: HAY que colocar dos resistencias de 1 kohm entre los conectores RX/TX en las conexiones RX Y TX como aparece en la figura, si no, salen unos ruidos horribles por los altavoces. Para que todo funcione bien HAY que conectar las dos masas (pines GND del DFPlayer con la masa del Arduino). En mi caso, también he conectado el pin BUSY a una entrada del Arduino para poder saber cuándo está reproduciendo un sonido y poder dar la orden de reproducir otro a continuación.

Para las pruebas el altavoz directo es suficiente, pero para colocar en la maqueta, el volumen es muy bajo. Por ello he añadido un mini-amplificador como el siguiente:
https://www.amazon.es/dp/B06XCC4F4F/ref=dp_cerb_3
que hay que soldar con cuidado y este amplificador no se conecta a la salida de altavoces, sino a los pines DAC_R y DAC_I del reproductor. A este amplificador es al que he puesto unos altavoces más apañados, que aun con todo les cuesta competir con el ruido producido por los trenes:
https://www.amazon.es/gp/product/B00JHERC8I/ref=ppx_yo_dt_b_asin_title_o08_s00?ie=UTF8&psc=1
Como se puede ver, son altavoces JVC diseñados para coche, por lo que las vibraciones de la maqueta no creo que los dañen.
Otro día os cuento de la programación de este dispositivo, pero ya os adelanto que tiene su propia librería y que mediante ella no os dará mayores problemas.
Saludos

Hola Miguel. Tu historia me ha parecido preciosa. En parte por que lo es, así, sin más, pero también porque me encanta ver cómo una y otra vez se repite "el ciclo de la vida" con trenes Märklin por el medio. Esto es así hasta el punto de que la propia marca de Goppingen sacó estas Navidades un anuncio basado en historias como la tuya (y la mía). Siendo yo, además, también asturiano, pues para qué te digo más.
Vaya por delante que soy un absoluto ignorante en cuestiones eléctricas/electrónicas/informáticas, hasta el punto de que mi maqueta es totalmente digital (todo se maneja con los dedos). Creo que fué Arthur C. Clarke quien dijo que "cualquier tecnología suficientemente avanzada es indistinguible de la magia". Y magia me parecen a mi las cosas que hacéis algunos en vuestras maquetas.
Sin embargo tus explicaciones son claras y detalladas y se ve que te apasiona lo que haces. Estoy seguro de que serán utilísimas para cualquiera que se quiera meter en el mundo del Arduino para trenes.
Otra cosa que me parece flipante es cómo unos juguetes que tienen casi (o sin casi) 60 años, puedan seguir funcionando como si tal cosa (y casi sin mantenimiento). Cada vez que saco una de las viejas locomotoras de mi abuelo y la pongo en la maqueta me asombro como la primera vez.

Y ahora viene la parte tocapelotas: ten muchísimo cuidado con tus viejos transformadores. Pueden ser peligrosos.
Se sabe desde hace algún tiempo que muchos de esos trafos azules de Märklin pueden tener un problema con su cableado interno: Al parecer, aunque el recubrimiento externo del cable de alimentación parezca estar en buen estado, puede estar deteriorado en su recorrido interior. En muchos casos el cable se ha terminado pelando del todo, dando salida a la tensión a la carcasa metálica externa, con el consiguiente riesgo eléctrico.
Te pongo un link al foro Märklin Users. Está en inglés, pero tiene buenas fotos que explican lo que te digo.

https://www.marklin-users.net/forum/posts/t25901-Older-Metal-Transformer-Danger

Ya nos contarás.
Gracias por tu hilo y a seguir disfrutando de tus viejos trenes.

Hola de nuevo:

Ante todo gracias a todos por vuestras sugerencias y buenos consejos. Los tendré en cuenta!

Completo hoy el asunto de los sonidos con un ejemplo de programación de Arduino Mega 2560 que utiliza el teclado de 16 teclas y el reproductor de MP3 con unos cuantos archivos para probarlo todo. Aquí va el código completo del programa:

Código: Seleccionar todo

// Programa de pruebas de sonido usando el keypad

#include "Arduino.h"
#include "SoftwareSerial.h"
#include "DFRobotDFPlayerMini.h"
#include <Keypad.h>  //Librería Keypad.h para el teclado

int serial1 = 19;
int serial2 = 18;

SoftwareSerial mySoftwareSerial(serial1, serial2); // RX, TX
DFRobotDFPlayerMini myDFPlayer;
void printDetail(uint8_t type, int value);

#define pilotorojo 13

#define BUSYP 36

int orden = 0;
int contador1 = 8;
unsigned long timer = 0;

int val1 = 0;
int val2 = 0;
int val4 = 0;
int val8 = 0;
int val16 = 0;
int ordensup = 0;
int musicasi = 0;
int estadoMUSIC = 0;
int playerbusy = 0;
int volumen = 20;

char codigo[2]; 
char modo01[]="01";
char modo02[]="02";   
char modo03[]="03";
char modo04[]="04";
char modo05[]="05";
char modo06[]="06";
char modo07[]="07";
char modo08[]="08";
char modo09[]="09";
char modo10[]="10";
char modo11[]="11";
char modo12[]="12";
char modo13[]="13";
char modo14[]="14";
char modo15[]="15";
char modo16[]="16";
char modo17[]="17";
char modo18[]="18";
char modo19[]="19";
char modo20[]="20";
char modo21[]="21";

char modoAA[]="AA"; // Modo subir volumen
char modoDD[]="DD"; // Modo bajar volumen

const byte ROWS = 4; //Numero de filas del teclado que se esta usando
const byte COLS = 4; //Numero de columnas del teclado que se esta usando
 
char hexaKeys[ROWS][COLS] =  //Aquí ponemos 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] = {4, 5, 6, 7}; //Seleccionamos los pines en el arduino donde van conectadas las filas
byte colPins[COLS] = {50, 48, 46, 44}; //Seleccionamos los pines en el Arduino donde van conectadas las columnas
 
Keypad customKeypad = Keypad(makeKeymap(hexaKeys), rowPins, colPins, ROWS, COLS); //inicializa el teclado

int cont = 0;

void setup()
{
  mySoftwareSerial.begin(9600);
  Serial.begin(9600);

  pinMode(serial1, INPUT);
  pinMode(serial2, OUTPUT);

  pinMode(BUSYP, INPUT);

  Serial.println(F("Initializing DFPlayer ... (May take 3~5 seconds)"));
 
  if (!myDFPlayer.begin(mySoftwareSerial, false)) {  //Use softwareSerial to communicate with mp3.
    Serial.println(F("Unable to begin:"));
    Serial.println(F("1.Please recheck the connection!"));
    Serial.println(F("2.Please insert the SD card!"));
    delay(10);
  }
  Serial.println(F("DFPlayer Mini online."));
 
  myDFPlayer.setTimeOut(500); //Set serial communication time out 500ms
 
   
  myDFPlayer.volume(volumen);  //Set volume value. From 0 to 30
  myDFPlayer.play(1);  //Locución de Bienvenida

  pinMode(pilotorojo,OUTPUT);
  digitalWrite(pilotorojo,LOW);
 
}

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
    {
         
      if(codigo[0]==modo01[0]&&codigo[1]==modo01[1]) // Reproduce Sonido 1
      {
        myDFPlayer.play(1);
      }

      if(codigo[0]==modo02[0]&&codigo[1]==modo02[1]) // Reproduce Sonido 2
      {
        myDFPlayer.play(2);
      }

      if(codigo[0]==modo03[0]&&codigo[1]==modo03[1]) // Reproduce Sonido 3
      {
        myDFPlayer.play(3);
      }

      if(codigo[0]==modo04[0]&&codigo[1]==modo04[1]) // Reproduce Sonido 4
      {
        myDFPlayer.play(29);
      }

      if(codigo[0]==modo05[0]&&codigo[1]==modo05[1]) // Reproduce Sonido 5
      {
        myDFPlayer.play(30);
      }

      if(codigo[0]==modo06[0]&&codigo[1]==modo06[1]) // Reproduce Sonido 6
      {
        myDFPlayer.play(35);
      }

      if(codigo[0]==modo07[0]&&codigo[1]==modo07[1]) // Reproduce Sonido 7
      {
        myDFPlayer.play(19);
      }

      if(codigo[0]==modo08[0]&&codigo[1]==modo08[1]) // Reproduce Sonido 8
      {
        myDFPlayer.play(23);
      }

      if(codigo[0]==modo09[0]&&codigo[1]==modo09[1]) // Reproduce Sonido 9
      {
        myDFPlayer.play(38);
      }

      if(codigo[0]==modo10[0]&&codigo[1]==modo10[1]) // Reproduce Sonido 9
      {
        myDFPlayer.play(39);
      }
     
      if(codigo[0]==modoAA[0]&&codigo[1]==modoAA[1]) // Sube volumen en 1
      {
        volumen = volumen + 1;
        myDFPlayer.volume(volumen);
        Serial.print("Volumen: ");
        Serial.println(volumen);
      }

      if(codigo[0]==modoDD[0]&&codigo[1]==modoDD[1]) // Baja volumen en 1
      {
        volumen = volumen - 1;
        myDFPlayer.volume(volumen);
        Serial.print("Volumen: ");
        Serial.println(volumen);
      }
      delay(100);
      cont=0;  //resetear a 0 la variable cont
    }
   
   
  }
 
}

void printDetail(uint8_t type, int value){
  switch (type) {
    case TimeOut:
      Serial.println(F("Time Out!"));
      break;
    case WrongStack:
      Serial.println(F("Stack Wrong!"));
      break;
    case DFPlayerCardInserted:
      Serial.println(F("Card Inserted!"));
      break;
    case DFPlayerCardRemoved:
      Serial.println(F("Card Removed!"));
      break;
    case DFPlayerCardOnline:
      Serial.println(F("Card Online!"));
      break;
    case DFPlayerPlayFinished:
      Serial.print(F("Number:"));
      Serial.print(value);
      Serial.println(F(" Play Finished!"));
      break;
    case DFPlayerError:
      Serial.print(F("DFPlayerError:"));
      switch (value) {
        case Busy:
          Serial.println(F("Card not found"));
          break;
        case Sleeping:
          Serial.println(F("Sleeping"));
          break;
        case SerialWrongStack:
          Serial.println(F("Get Wrong Stack"));
          break;
        case CheckSumNotMatch:
          Serial.println(F("Check Sum Not Match"));
          break;
        case FileIndexOut:
          Serial.println(F("File Index Out of Bound"));
          break;
        case FileMismatch:
          Serial.println(F("Cannot Find File"));
          break;
        case Advertise:
          Serial.println(F("In Advertise"));
          break;
        default:
          break;
      }
      break;
    default:
      break;
  }
}


Como puede verse, el programita incluye hasta cuatro librerías externas, una genérica, otra para la comunicación serie, otra para el reproductor y una última para el teclado.
En este sencillo programa se puede ver cómo se usa la función customKeypad.getKey() para leer una tecla del teclado y después una segunda tecla, cuando tenemos dos (se podría buscar una tercera y así trabajar con muchas más órdenes) se pasa a ejecutar el código que nos interese, marcado por la expresión if:

if(codigo[0]==modo05[0]&&codigo[1]==modo05[1])
{
// Aquí se ejecuta lo que queramos que haga con el código "05"
}

En esta caso lo que hace es reproducir el archivo de la SD "que se haya copiado en ella el nº 30":

myDFPlayer.play(30);

Sí, es un poco raro, pero el orden en el que se copian los archivos en la tarjeta es muy importante en esta librería. Por eso, además es recomendable que numeremos los archivos que queramos reproducir como "0001-loquesea.mp3"; "0002-otracancion.mp3", etc, porque así el sistema operativo los va a copiar en la carpeta usando este orden.
También recomiendo, cuando se quiera mantener un orden al añadir el nuevo archivo, renombrar, borrar toda la tarjeta y volver a copiarla, respetando la numeración. Es un poco latoso, pero funciona.
Espero que os valga para algo mi experiencia.
Un saludo

Dando un repaso el otro día a todo lo publicado en el hilo, gracias al interés de Juanma, he visto que han quedado algunos flecos por explicar, sobre todo en lo que se refiere al control de los sonidos y a la incorporación de los mismos en la "vida" de la maqueta, es decir, en su enganche con el resto de los controles del primer Arduino.

Lo primero aclarar que la conexión entre ellos la realicé por medio de un sencillo bus en paralelo, me pareció mucho más fácil de programar y con más posibilidades de éxito, y ha funcionado sin problemas prácticamente desde el principio.

Esta conexión en paralelo se realiza de forma directa entre los pines 14-17 del Arduino principal (que llamaré a partir de ahora Arduino 1) y los pines 2-5 del secundario que controla los sonidos (Arduino 2). Lógicamente, los del 1 tienen que definirse como Salidas y los del 2 como Entradas. Para facilitar el manejo, los he nombrado BUNO, BDOS, BCUATRO, BOCHO (en realidad léase b-1, b-2, b-4, b-8) de manera que son dígitos binarios, con lo que aparte del reposo (todos apagados) admiten quince combinaciones, es decir, 15 órdenes o comandos. Si se necesitasen más órdenes, necesitaríamos un BDIECISEIS y duplicaríamos la capacidad de órdenes.

Este bus no es especialmente rápido (tampoco se necesita que lo sea, en realidad). Voy a copiar un ejemplo de código de orden, la que va asociada al comando de abrir el semáforo de la estación, que simultanea el sonido de salida del tren regional:

Código: Seleccionar todo

        // Orden 7; Locución de Tren Regional
        digitalWrite(BUNO,HIGH);
        digitalWrite(BDOS,HIGH);
        digitalWrite(BCUATRO,HIGH);
        digitalWrite(BOCHO,LOW);     
       
        delay(500);

        digitalWrite(BUNO,LOW);
        digitalWrite(BDOS,LOW);
        digitalWrite(BCUATRO,LOW);
        digitalWrite(BOCHO,LOW);


Como se ve, la señal se mantiene en el bus durante 500 ms, aunque podrían ser menos, pero como no lo tengo parametrizado, no he hecho pruebas de hacer delays más cortos.

¿Y qué hace esta señal en el Arduino 2? Pues lo que hace fundamentalmente el Arduino 2 es comprobar constantemente el estado de sus entradas correspondientes BUNO-BOCHO, así:

Código: Seleccionar todo

void loop()
{
  //timer = millis();
 
 

  // Aqui está la detección de entradas desde el Arduino 1
 
  val1 = digitalRead(BUNO);
  val2 = digitalRead(BDOS);
  val4 = digitalRead(BCUATRO);
  val8 = digitalRead(BOCHO);
  //val16 = digitalRead(B16);
 
  delay(10);
 
  ordensup = val1 + 2*val2 + 4*val4 + 8*val8;  //Esta es la conversión de binario a decimal.

// Aquí vienen varios if, uno para cada orden 1-15. Sólo pongo el 7 que veíamos antes

if(ordensup==7) {
    // Locución Tren Regional
    myDFPlayer.volume(volUno);
    if (estadoSOUND == 1) {
      myDFPlayer.play(regional);
    }
   
    delay(400);
    regional = regional + 1;
    if(regional >= 18) {
      regional = 2;
    }
  }

}


Como hay varias locuciones de tren regional, para que no se repitan las vamos cambiando, por eso aparece esa variable "regional" que se incrementa cada vez que se reproduce una locución.

Como se puede apreciar, lo único que necesita es ajustar el volumen con "myDFPlayer.volume(volUno);" y después ordenar que se reproduzca el sonido contenido en la tarjeta del índice correspondiente con "myDFPlayer.play(regional);". Lo de ajustar el volumen se debe a que también hay una rutina de activar música de fondo para poner canciones relacionadas con el tren, pero esas van a un volumen más bajo, para no aturullar a la gente.

El funcionamiento y la programación son más sencillos de lo que podría parecer a simple vista. Quedo a vuestra disposición para más aclaraciones y dudas sobre el Arduino y sus posibilidades.
Un saludo

Muchas gracias, Miguel. Muy interesante e ingeniosa la forma de conectar los Arduinos. Leeré el código con detenimiento, es una alternativa diferente a la que tenía pensada y, como esta está funcionando en tu maqueta y la mía es sólo teoría, quiero repensar la que tenía en mente. Tu hilo es muy instructivo y muestra una realidad en el uso del Arduino que despierta mucho la imaginación. Te agradezco mucho que compartas tu conocimiento y experiencia, un cordial saludo

Aunque de decoración de maquetas seguramente sabéis muchos muchísimo más que yo, espero poder desvelar algunos de los trucos que usamos Toño, mi maestro decorador, y yo en la decoración de la maqueta. Sin duda la parte técnica es importante, pero que la maqueta ofrezca este buen aspecto es sin duda gracias a Toño que tiene mano de artista.

En este primer post dedicado a la decoración me voy a centrar en las edificaciones, que son básicamente tres: la estación, la iglesia y la caseta de enclavamiento. La técnica utilizada en las tres fue de marquetería con contrachapado de 5 mm, del que disponía en cantidad y que podía trabajar en ese momento con una estupenda sierra de marquetería eléctrica similar a esta:

https://www.amazon.es/dp/B00EXO8A6K/ref=cm_sw_em_r_mt_dp_U_xljeFbF3KQ2SJ

En todos los casos me inspiré en edificios de mi entorno cercano: la vieja estación del tren minero de Loredo:



La iglesia de Argame:



La caseta de enclavamiento de la estación de Soto de Rey, una preciosa antigualla de los Ferrocarriles del Norte:





También se pueden contar como construcciones el toro de Osborne y el castillete de mina.

La idea más sencilla de hacer las piezas me la dio Toño, hacer fotos lo más perpendicular posible a las distintas fachadas y después escalar las imágenes a H0 y pegarlas sobre la madera, cortar y ensamblar. Dicho y hecho. El edificio de Loredo y la iglesia de Argame no supusieron ningún problema en esto, pues son bien accesibles, el problema me lo dio la caseta de enclavamiento, que está en una zona prohibida de la estación de Soto de Rey, a la que no tuve más acceso que las fotos que he podido poner aquí, y que hice más bien a base de deformar las perspectivas.

Para adaptarlas a mi mundo de Tatán, la estación debía ser la de Tudela-Veguín, por lo que me descargué en este foro las tipografías de RENFE y así pude colocar los carteles adecuados. también modifiqué con GIMP la placa que está encima de la puerta.







El tejado como se ve, es cartón al que se ha desmontado una de las hojas, nada que no esté inventado. Tiene muchos fallos, pero de lejos da el pego...

La Iglesia de San Miguel de Argame pasó a ser la Parroquia de San Julián de Box, de Tudela-Veguín.



Y la caseta de enclavamiento pasó de ser de ADIF a ser de la SSME:






El toro de Osborne lo hice en marquetería de la misma forma, y le añadí una estructura en la parte de atrás.



Si alguien se ha leído todo el hilo, recordará que sufrí un cólico nefrítico durante la construcción. La piedra que me extrajeron está debajo del toro:



La última construcción añadida fue el castillete de mina, me costó mucho encontrar los materiales adecuados, para los largueros compré 1000 palitos agitadores de café de bambú:

https://www.amazon.es/dp/B01N9Y7G03/ref=cm_sw_em_r_mt_dp_U_WbkeFbJS2XNJH

que han dado un resultado fantástico. Lo más complicado fueron las poleas, después de muchas vueltas y búsquedas en la red, encontré algo que podía simular perfectamente las poleas: dos rudas de carro de Playmobil, que encontré en ebay por cuatro perras.



Después hice sobre una tabla un patrón para hacer las cuatro caras de la torre:







Añadí un soporte para las poleas, a las que había hecho una pequeña canaladura con una lima.







Pintura, tirantes y unas tuercas colgando para que los cables queden tensos. Algunos operarios de mantenimiento ayudaron a dar realismo.



Y ya colocado:



Otro día más. Saludos!!

Siguiendo con la decoración, hablaré hoy de los puentes. Los puentes también están inspirados en dos de mi entorno asturiano: el puente de la carretera sobre el rio Caudal de Soto de Rey,



y el puente de la vía de FEVE sobre el mismo río en Ablaña.



Para el el puente en arco hice una primera versión con un doble arco, pero quedaba demasiado mazacote:



Por ello, a sugerencia de un hermano mío, procedí a aligerar el arco por su parte central:



Con lo que colocados los tirantes y en su emplazamiento nos quedó así:



El puente en celosía fue muy delicado pues hacer tantos vanos en una pieza de contrachapado de 3mm es algo peligroso, nunca se sabe por dónde se puede romper. Con mucho cuidado y una jornada que tuve pocas interrupciones, fue la que dediqué a las piezas:



Que presentadas en la maqueta quedaban así:



El resultado final con la pintura es el que se ve a continuación. Por cierto, los remates de los tirantes están hechos con trocitos de pajitas de beber cortados.

Quiero terminar con el tema de los sonidos y el Arduino explicando la última función añadida: la música ambiente.

Una vez puesta en marcha la posibilidad de reproducir sonidos, se me ocurrió que como complemento, a volumen mas bajo que los sonidos propios del ferrocarril (megafonía de la estación y alarma de las barreras), se podía añadir una música ambiental de canciones relacionadas con los trenes. Dando una vuelta a mis recuerdos y consultando con la familia, hemos elaborado una lista no muy larga, pero sí muy variada, de temas musicales del ferrocarril:



Os pongo la lista de las trece canciones en sus archivos originales, como veréis es importante el nombrado de los archivos con numeración, pues va a importar a la hora de reproducirlos.

La orden desde el Arduino 1 se transmite an Arduino 2 donde tan sólo se cambia una variable ("musicasi") de valor 0 a valor 1.
más abajo, en el bucle hay este fragmento de código:

Código: Seleccionar todo

  playerbusy = digitalRead(BUSYP);
  if (musicasi == 1 && playerbusy == 1 && estadoSOUND == 1){
    myDFPlayer.volume(volDos);
    digitalWrite(pilotorojo, HIGH);
    musica = random(26, sonidoBarrera);
    if (estadoSOUND == 1) {
      myDFPlayer.play(musica);
    }
   delay(400);
  }


Lo que hace es comprobar que la música está activa, los sonidos están activados (se pueden desactivar todos ellos, para evitar molestar con las alarmas de barreras, etc.) y que el reproductor está desocupado (la señal BUSYP es activa por bajo, es decir, si está ocupado manda un 0 y si está libre manda un 1), si todo esto se da, pone el volumen del reproductor un poco más bajo (Los sonidos del tren van a 22 sobre 30 y la música va a 16 sobre 30) y calcula un valor aleatorio entre 26, que es el número de archivo en el directorio de la primera canción (las 25 primeras son locuciones) y el último archivo que es el sonido de las barreras. Ese número es el que se pasa al reproductor como número del directorio para ser reproducido hasta que esté libre otra vez, que se genera un nuevo número y se reproduce a su vez.

Esto se ha hecho así para poder incorporar fácilmente nuevas canciones a la lista aunque cada vez que las incorporo debo regrabar toda la tarjeta MicroSD y reprogramar estos parámetros del código.

Dicho esto, y aunque es complicado añadir canciones, dejo abierto el tema de las colaboraciones y aportaciones a las "músicas ferroviarias".

En el siguiente post "técnico" os explicaré el manejo del Display Digital, que tras algunas mejoras recientes ha quedado más que aceptable.

Saludos

Lo prometido es deuda y afronto aquí mi última lección de Arduino, el uso del Display LCD que la verdad, viendo todo lo anterior, resulta de lo más sencillo. En mi caso he usado un display de 4 líneas y 20 caracteres por línea, lo que se conoce como 2004, existe otro modelo similar de 2 líneas y 16 caractertes, que se conecta de modo similar. Utilicé uno como éste de 13 €:

https://www.amazon.es/SunFounder-Interfaz-Display-Arduino-Mega2560/dp/B01GPUMP9C/ref=sr_1_20?__mk_es_ES=%C3%85M%C3%85%C5%BD%C3%95%C3%91&dchild=1&keywords=display+i2c&qid=1612293666&sr=8-20

La gracia de usar un módulo I2C es que las conexiones son muy simples y el resultado es de gran vistosidad:



Lo primero es conectar el display, uno puede pensar que esto va a ser más bien complicado, pero la verdad es que no, pues estos displays vienen con un pequeño procesador propio que nos va a liberar del trabajo de gestionar los caracteres y las muchas conexiones que requiere un display de ese tamaño y tan solo lleva ¡2 conexiones y la alimentación! En el caso del Arduino Mega 2560 las conexiones de datos son: la conexión SDA del display a la salida 20 del Arduino y la conexión SCL a la salida 21 del Arduino. Después otros dos cables para alimentación, a 5V y a GND (tierra). Y ya.

Una vez conectado, es posible que no se vea nada, no nos pongamos nerviosos, hay que cargar un programita en el Arduino para encender la luz de retroiluminación y tras esto regular la intensidad de la misma luz en el potenciómetro que lleva el módulo I2C.



En la foto, que he tomado de este enlace, se puede ver el potenciómetro en azul, que se regula al gusto con un pequeño destornillador.
https://www.naylampmechatronics.com/blog/35_Tutorial--LCD-con-I2C-controla-un-LCD-con-so.html

El programa en el Arduino debe incorporar la librería para manejar el I2C y su inicialización, al final va a ser como escribir en una caja de 4 filas x 20 columnas.

Código: Seleccionar todo

#include <LiquidCrystal_I2C.h> // Librería para controlar la pantalla 20 x 4



Después irá la definición del objeto lcd:

Código: Seleccionar todo

LiquidCrystal_I2C lcd(0x27,20,4);  //Crear el objeto lcd  dirección  0x27 y 20 columnas x 4 filas


Para ello usaremos la dirección por defecto o la que nos aparezca en las instrucciones del módulo I2C, que es ese parámetro 0x27.

Código: Seleccionar todo

void setup()    //Rutinas de Inicialización
{
 
  lcd.init(); // Inicializar el LCD
  lcd.backlight(); //Encender la luz de fondo.

  // Escribimos el Mensaje en el LCD.
  lcd.print(" El Mundo de Tatan");
  lcd.setCursor(0,2);
  lcd.print("Circuito inicial    ");
  lcd.setCursor(0,3);
  lcd.print("Rampa cerrada       ");
  timeStamp2 = millis();
  borrarLinea2 = 5000;
}


La inicialización y el encendido de la luz posterior están en las dos primeras líneas, después se ve lo fácil que es escribir en el LCD, (mejor no aventurarse a poner tildes, lo intenté, pero confieso aquí mi fracaso, aunque quizá vuelva a intentarlo) y después la escritura lcd.print(" ... "); y el posicionamiento del cursor: lcd.setCursor(columna, fila);
Las dos últimas líneas se usan para hacer un temporizador, guardo el instante en que un mensaje se presenta: timeStamp2 = millis(); y a continuación establezco el tiempo a partir del cual ese mensaje debe ser borrado, las líneas de borrado están en la parte del final del loop.

Código: Seleccionar todo

if (borrarLinea2 != 0 && millis()> timeStamp2 + borrarLinea2) { // Comprueba si hay alguna info que borrar en línea 2 y la borra
        lcd.setCursor(0,2);
        lcd.print("                    ");   
 
}


Nótese que para borrar lo que se hace es "imprimir" 20 caracteres en blanco.

Hay un grupo de líneas similar para la línea 1, pues se me olvidó citar que las líneas y las columnas empezan en 0, 0. De modo que en mi caso la línea 0 siempre tiene " El Mundo de Tatan" y la última fila (la 3) siempre tiene la información del estado de la rampa, por ser este un elemento bastante crítico de la maqueta.







Otra parte interesante (y la principal razón por la que puse el display) es comprobar si se ha pulsado correctamente el teclado (tener un feedback de que ha sido correctamente detectada la pulsación de cada tecla). Por ello, el uso del display se entrevera con la recepción de comando desde el teclado, como se puede ver en el siguiente fragmento de código:

Código: Seleccionar todo

void loop()     //Rutina de Bucle
{
  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[]
    lcd.setCursor(0,1);
    lcd.print("Comando: ");
    lcd.setCursor(10+cont,1);
    lcd.print(codigo[cont]);    //se presenta el código introducido en el display
    lcd.setCursor(11+cont,1);
    lcd.print(" ");
    timeStamp1 = millis();
    borrarLinea1 = 6000;
    cont=cont+1;              //incrementamos la variable cont
    if(cont==2)          //si ya fueron presionadas 2 teclas se evalúa el código introducido
    {
           
       if(codigo[0]==modo77[0] && codigo[1]==modo77[1]) { //Programa para Encender NOCHE
        if (estadoNN == LOW) {
          estadoNN = HIGH;
          lcd.setCursor(0,0);
          lcd.print(" El Mundo de Tatan");
          lcd.setCursor(0,2);
          lcd.print("Farolas encendidas  ");
          timeStamp2  = millis();
          borrarLinea2 = 5000;
         
          // Orden 5: Encendido Luces Farolas
          digitalWrite(BUNO,HIGH);
          digitalWrite(BDOS,LOW);
          digitalWrite(BCUATRO,HIGH);
          digitalWrite(BOCHO,LOW);
 
 
          delay(500);
          digitalWrite(BUNO,LOW);
          digitalWrite(BDOS,LOW);
          digitalWrite(BCUATRO,LOW);
          digitalWrite(BOCHO,LOW);
 
        }
        else
        {
          estadoNN = LOW;
          lcd.setCursor(0,0);
          lcd.print(" El Mundo de Tatan");
          lcd.setCursor(0,2);
          lcd.print("Farolas apagadas    ");
          timeStamp2 = millis();
          borrarLinea2 = 5000;
         
          // Orden 6: Apagado Luces Farolas
          digitalWrite(BUNO,LOW);
          digitalWrite(BDOS,HIGH);
          digitalWrite(BCUATRO,HIGH);
          digitalWrite(BOCHO,LOW);
 
 
          delay(500);
          digitalWrite(BUNO,LOW);
          digitalWrite(BDOS,LOW);
          digitalWrite(BCUATRO,LOW);
          digitalWrite(BOCHO,LOW);
 
 
        }
       
      }



En este fragmento se van escribiendo los caracteres que se introducen por el teclado, y después, como el código 77 representa el encendido o apagado de las farolas, se informa por el LCD y se actúa sobre el relé correspondiente. En las variables timeStamp1 y timeStamp2 se almacenan temporalmente los instantes en los que se presenta en pantalla cada mensaje, para ser borrados pasados unos segundos. En esta caso se complica un poquito más la orden al relé, porque este está conectado al segundo Arduino y se le pasa al mismo como orden por el bus paralelo de 4 pines.

Espero que os haya gustado la explicación y os animéis a aventuraros en este mudillo apasionante del Arduino, que nos puede dar muchas satisfacciones a un precio muy reducido.
Un saludo a todos.

Miguel SSM
El Mundo de Tatán, Oviedo.

Mensaje repetido por error.

Me veo en la dulce obligación de hacer un apéndice a mi post de ayer. Hoy volví sobre el tema de los caracteres especiales para poner la tilde a la "a" de "Tatán" y al fin lo he conseguido.

Voy con el código necesario: Lo primero declarar en una variable de tipo matriz el "dibujo en 0's y 1's" de nuestro carácter:

Código: Seleccionar todo

byte acento[8] = {
  0b00000010,
  0b00000100,
  0b00001110,
  0b00000001,
  0b00001111,
  0b00010001,
  0b00001111,
  0b00000000,
};


Se puede ver que es una copia de la letra "a" con un par de puntos añadidos en las filas superiores, para hacer la tilde. Si no se maneja uno bien con esto en esta dirección podéis encontrar un Generador de caracteres en que uno se centra en el diseño y él genera el código.

https://maxpromer.github.io/LCD-Character-Creator/

Y ahora la inicialización, la asignación del carácter como el número 0 (admite 8 que van del 0 al 7) y la impresión del carácter especial, que utiliza la orden lcd.write():

Código: Seleccionar todo

   lcd.init(); // Inicializar el LCD
   
  lcd.backlight(); //Encender la luz de fondo.
  lcd.createChar (0, acento);
 
  // Escribimos el Mensaje en el LCD.
  lcd.setCursor(0,0);
  lcd.print(" El Mundo de Tat");
  lcd.write(0);     // La orden para imprimir los caracteres especiales es write en lugar de print
  lcd.print("n ");


Y ¡voilà!



"La paciencia todo lo alcanza". Santa Teresa de Jesús.

Me alegra que retomaras el hilo. Siempre interesantes tus aportaciones. Muchas gracias y un saludo, Juanma

jumacaba escribió:

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.

Imagen1.png

Muy interesante esta forma de manejar otros tipos de desvíos. Que todo lo que he visto con Arduino y agujas son servos.
Podría poner un poco de código de cómo conseguí mover un desvío, y más que nada por el espacio de tiempo que ha indicado.
Gracias.
Un saludo

Ya sé que es antiguo, pero es una lástima que las fotos no se vean dado que que es super interesante.

mabumu escribió:

Ya sé que es antiguo, pero es una lástima que las fotos no se vean dado que que es super interesante.

Hola:

Las fotografías están alojadas en un servidor externo (en concreto en http://www.fotosycosas.es), normalmente están accesibles, y en este momento son visibles, pero si no te funcionan te las puedo enviar a la dirección de correo o por la vía que te venga mejor.
Un cordial saludo

miguel@fotosycosas.es
El Mundo de Tatán