Tres Carriles
  • INICIO
  • Talleres
    • Modelismo Ferroviario >
      • Como empezar
      • Fase de Diseño
      • CONSTRUCCION >
        • Trabajos prácticos
      • DECORACION >
        • Trabajos prácticos
    • Marklin >
      • Referencias Marklin
      • Repuestos Märklin
      • Locomotoras Marklin
      • Vagones Marklin
      • Cajas y Codigos
      • Eras del Ferrocarril
      • Guia de Compras
    • Señales Marklin
    • Mantenimiento >
      • Motores Marklin
      • Cinematica >
        • Bielas
      • Iluminacion
      • Transformaciones
      • CATENARIA
      • Locomotoras
    • Digitalización >
      • Dispositivos
      • Centrales Digitales
      • Booster
      • Retrocontacto S88
      • Decoder Locomotoras
      • Decoder Accesorios
      • Rotonda Marklin 7286
      • Faller Car
    • Control por PC
    • Electronica >
      • Curso Basico
      • Circuitos >
        • Cuentarrevoluciones
      • El Multimetro
    • Documentacion
    • Tus Trabajos
  • Maquetas
    • Sitios WEB socios >
      • Paco Centol
      • Fernando Escribano
      • José Luis Batres
      • Rafael Fontenla
      • JOSE ANTONIO LOPEZ
      • Alberto Lopez Vega
      • Javier Nieto
      • Miguel Perez S.
      • Javier Escribano
      • Manuel Carballo Muñoz
    • Videos
    • camara subjetiva
  • Noticias
  • LINKS
  • Foro
  • Socios
    • Asociacion
    • Módulos 3C
    • Blog
  • TREN REAL
    • Material Rodante
    • Construcciones ferroviarias >
      • Estaciones

Cuentarrevoluciones

Construcción de un cuentarrevoluciones y velocímetro para un banco de pruebas de locomotoras.

otros circuitos electronicos
Cuentarrevoluciones de Locomotoras con Arduino
Afinar los motores y decoder de nuestras locomotoras, a veces supone realizar muchos test de prueba y error. Ajustar un parámetro y hacer rodar la locomotora en la maqueta, volver a ajustar y así sucesivamente hasta encontrar el punto optimo, es una de las maneras de hacerlo.
Imagen
Märklin 7858
Otra es usar un banco de rodillos para no tener que mover la locomotora por la maqueta pero si además podemos medir de algún modo las revoluciones del motor, aunque sea indirectamente a través del banco de rodillos, esa sería una opción muy interesante.
Märklin ya desarrolló hace años un dispositivo (ref. 72600) para añadir a su banco de rodillos pero ha dejado de comercializarlo desde hace tiempo, así que hemos decidido fabricarnos uno parecido nosotros mismos.
Sólo necesitaremos un pocos componentes y  conseguiremos que nos salga incluso bastante más barato que el original de Märklin.
Imagen
Arduino Mega Duemilanove
Imagen
Sensor de efecto hall A3144 (switch)
Imagen
Bachmann - banco de 4 piezas de rodamientos
Vamos a utilizar Arduino. Este es un dispositivo electrónico muy versatil y pequeño. Es programable conectándolo a un puerto USB del PC y dispone de un número importante (según modelo) de pines de conexión que pueden programarse como entradas o salidas analógicas o digitales de acuerdo a lo que se necesite en cada caso. En este caso sólo vamos a usar una entrada digital y algunas salidas para alimentar un Display.

Precisamente éste es el segundo elemento que vamos a necesitar, un Display LCD de 16 caracteres por cada una de sus 2 líneas. Es el modelo LCD PC1602F-B.

El tercer elemento que necesitaremos será un sensor de efecto "hall" tipo digital switch que podéis ver descrito en nuestra sección de componentes electrónicos del taller de "Curso Básico de Electrónica". Este sensor lo conectaremos a una de las entradas digitales de Arduino.

Finalmente necesitaremos unos rodamientos con un mini imán de neodimio cuyo paso será detectado por el sensor. O un banco de rodamientos y medir las revoluciones sobre el propio motor

Circuito Electrónico
Este es el circuito electrónico para conectar el sensor y el display a nuestro Arduino:
Imagen
Circuito electrónico cuentarrevoluciones con Arduino - Tres Carriles
Ya veis que lo más sencillo de conectar es el sensor hall.
El sensor tiene 3 patillas, La alimentación de 5v (en rojo) y la masa central (en negro), las toma del propio Arduino (la masa se conecta a GND digital). La patilla Output que es la señal del sensor (en verde) la hemos conectado a la entrada digital número 10 de Arduino. Entre la patilla de 5v y la patilla output hay que poner una resistencia de 10K.
La conexión del display también es sencilla, basta seguir las conexiones del gráfico. Pincha en la imagen para ampliarlo.

Programa de control

A continuación necesitamos cargar un programa en Arduino que sirva para leer el estado del sensor, traducir sus señales en revoluciones, km/h, etc. y enviar el resultado a la pantalla. Existe un programa gratuito (Arduino IDE) para escribir código de programas, compilarlos y cargarlos en la memoria de Arduino mientras éste, está conectado al PC por el puerto USB.
Imagen
Tres Carriles - Código de programa
Una vez cargado el programa podemos desconectar Arduino del PC y ya funcionará de forma autónoma, simplemente alimentándolo con una batería de 9v a través de su conector DC. El programa que hemos preparado para este circuito es muy simple, unas pocas líneas de código sirven para hacer lo que queremos. El código completo y comentado puedes verlo y descargarlo al final de este artículo.

Mecánica

Para medir las revoluciones de nuestra locomotora, tenemos que hacerla funcionar sobre unos rodillos y uno de ellos debe tener el sensor y un imán en el eje para poder contar  el número de vueltas.
Imagen
Sensor hall cuentarrevoluciones
Hemos utilizado un juego de rodillos de Bachmann ref. 42901, pero además hemos construido otra pieza de rodamientos especial y hemos alargado el eje de uno de los rodamientos para insertar una rueda de plástico en la que hemos empotrado un imán de neodimio redondo de 1,5mm de diámetro por 0,5mm de espesor.

Hemos colocado el sensor a 1mm de distancia de esta rueda para que pueda leer el paso del imán con precisión en cada vuelta del eje. En realidad estamos midiendo el tiempo que tarda el eje en dar un giro completo.

En cada ciclo calculamos la formula (60000 miliseg. / perímetro del rodamiento del sensor), esto nos da las RPM. (Pincha en la imagen para verla con más detalle)
Imagen
Banco de rodillos con sensor
Imagen
Montaje cuentarrevoluciones Arduino
En la imagen podemos ver ampliadas una de las piezas de rodillos de Bachmann y la pieza de rodillos que hemos fabricado nosotros mismos para instalar el sensor.
En la pieza construida por nosotros hemos usado rodamientos 3x6x2 (diámetro int. x diámetro ext. x anchura) iguales a los de Bachmann. El rodamiento inferior derecha está empotrado en el soporte y hemos conseguido que gire el eje y se mueva solidario con la ruedecilla interior y la exterior. (La interior es un rodamiento bloqueado en el eje) y la ruedecilla exterior es de plástico y tiene empotrados los imanes de neodimio.
A continuación podemos ver la imagen de todo el conjunto. Una vez probado sólo tenemos que buscar una caja adecuada para meter todo dentro y dejar a la vista sólo el display y los tres hilos que conectan la pieza de rodillos con el sensor. Ahora ya podemos afinar a gusto nuestras locomotoras.

Componentes
- Arduino Mega Duemilanove (se puede usar otro modelo incluso el más simple)
- Display LCD PC1602F-B
- Sensor hall A3144
- Resistencia 10K
- Imanes de neodimio 2mm de diámetro x 0,5mm de espesor
- 4 Rodamientos 3x6x2 (y un eje de 3mm para construir la pieza especial de rodamientos)
- 1 Protoboard y sus cables de conexión para el test.
- Rodillos Bachmann ref. 42901 (u otro sistema banco de locomotoras)

Código del Programa "Cuentarrevoluciones" para Arduino

El programa que hemos preparado para este circuito es muy simple, unas pocas líneas de código sirven para hacer lo que queremos. El código no está muy depurado pero realmente su consumo de memoria y velocidad de proceso es muy bajo al ser tan simple. Para escribir el programa, compilarlo y cargarlo en Arduino, hemos usado el software gratuito ARDUINO (IDE) Nota: (Arduino y Arduino (IDE) son marcas registradas)  
Imagen
Midiendo RPM sobre el propio motor
Es importante decir que en realidad mediante los rodillos no medimos las revoluciones del motor, ni las revoluciones de la rueda de la locomotora, lo que se mide realmente es el número de vueltas del eje del rodamiento.

Un método para medir las revoluciones del motor, al menos en motores abiertos DC o los universales  como  los SFCM, LFCM , DCM  es simplemente poner un sensor a unos pocos milímetros sobre el motor sin necesidad de ningún imán ya que el propio motor genera el campo magnético. Luego habrá que dividir la lectura entre el número de polos del motor para obtener el número de vueltas ya que lo que lee el sensor es el campo magnetico de cada polo del motor cuando pasa frente al sensor. 
La información de Km/h que se muestra en el display si es real pero a escala 1:87. Aunque las RPM correspondan al eje del rodamiento y no  al motor directamente su información nos sirve igual para entender el funcionamiento y para optimizar el ajuste de los decoder y motores de nuestras locomotoras. 

A continuación comentamos el código para el sensor sobre los rodamientos. Para cargarlo en Arduino se puede copiar todo el texto en verde y pegar cada sección, una a continuación de la otra, en la pantalla de edición del software Arduino (IDE). Luego conectar Arduino al PC y pulsar "Subir" a Arduino desde el programa (IDE).

(Versión 1.1 - Dic 2015) : Tacómetro gráfico incluido

1º Declaramos las constantes del programa con el siguiente código:

// CONSTANTES: Aquí se declaran las constantes que no cambian de valor a lo largo del programa. Se usan para activar los pines y librerías:
#include <LiquidCrystal.h>;                     // Librería del display LCD:
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);          // declaración de los pines usados por el LCD;
 byte barra0[8] = { B00000, B00000, B00000, B00000, B00000, B00000, B00000, B00000 }; // defino el nuevo carácter 0 para el tacómetro
 byte barra1[8] = { B10000, B10000, B10000, B10000, B10000, B10000, B10000, B10000 }; // defino el nuevo carácter 1 para el tacómetro
 byte barra2[8] = { B11000, B11000, B11000, B11000, B11000, B11000, B11000, B11000 }; // defino el nuevo carácter 2 para el tacómetro
 byte barra3[8] = { B11100, B11100, B11100, B11100, B11100, B11100, B11100, B11100 }; // defino el nuevo carácter 3 para el tacómetro
 byte barra4[8] = { B11110, B11110, B11110, B11110, B11110, B11110, B11110, B11110 }; // defino el nuevo carácter 4 para el tacómetro
 byte barra5[8] = { B11111, B11111, B11111, B11111, B11111, B11111, B11111, B11111 }; // defino el nuevo carácter 5 para el tacómetro
const int hallPin = 10;                               // Número de pin usado por el sensor de efecto hall
const int ledPin =  13;                               // Número de pin del led testigo del sensor
const int rpmmax = 4000;                         // Número de revoluciones máximas para el tacómetro
const int revbarra = rpmmax/80;              // Numero de revoluciones por cada barra del tacómetro, hay 80 barras en una línea de lcd


2º Añadimos a lo  anterior la declaración de variables:
// VARIABLES: Aquí se declaran las variables que cambian de valor a lo largo del programa;
int hallState = 0;                                        // variable para leer el estado del sensor hall
unsigned long time = millis();                    // variable de tiempo
int RPM = 0;                                              // variable para guardar las revoluciones por minuto
int Limpiart1 = 0;                                       // variable para contar una vuelta completa del eje
int KMh = 0;                                              // variable para contar Kilómetros/hora
float perisensor = 6 * 3.1416;                   // perímetro del eje milímetros
float factorescala = perisensor * 87 *60 / 1000; // perímetro del sensor a escala 1:87 en metros/hora
long t1 = millis();                                     // variable para medir el tiempo al primer paso del eje por el sensor
long t2 = millis();                                     // variable para medir el tiempo al segundo paso del eje por el sensor
int barras = 0;                                         // variable para guardar el número de barras a imprimir en el tacómetro
int numcar = 0;                                       // Variable para guardar el numero de caracter a imprimir en el tacómetro


3º Añadimos a lo anterior la  inicialización de Arduino:
// INICIALIZACION: Se inicializan todos los valores en Arduino para su calibración
void setup() {                                               
  lcd.begin(16, 2);                                    // se inicializa el display LCD
  lcd.print("Inicializando!");                      // se muestra un texto en pantalla
  lcd.createChar(0, barra0);                    // crea el carácter 0 en la memoria de Arduino
  lcd.createChar(1, barra1);                    // crea el carácter 1 en la memoria de Arduino
  lcd.createChar(2, barra2);                    // crea el caracter 2 en la memoria de Arduino
  lcd.createChar(3, barra3);                    // crea el carácter 3 en la memoria de Arduino
  lcd.createChar(4, barra4);                    // crea el carácter 4 en la memoria de Arduino
  lcd.createChar(5, barra5);                    // crea el carácter 5 en la memoria de Arduino
  lcd.setCursor(0, 1);                              // posiciona el cursor del display en la línea 2
          for (int x = 0; x < 16; x++){           // Bucle para imprimir 16 caracteres del tacómetro gráfico
          lcd.write (byte(5));                        // imprimir el carácter 5 que tiene 5 barras equivalente a un carácter completo
          }                                                    // fin del bucle
  pinMode(ledPin, OUTPUT);                 // Inicializar el pin del LED como SALIDA:
  pinMode(hallPin, INPUT);                    // Inicializar el pin del sensor como ENTRADA:
  Serial.begin(9600);                              // Establecer el puerto serie en 9600
  lcd.print("            ");                              // se borra el texto de "Inicializando":
  while (millis() < 5000) {}                       // Espera calibración durante 5 segundos
  time = millis();                                      // se toma el valor de tiempo del reloj de Arduino en milisegundos
  lcd.begin(16, 2);                                  // Se inicializa el display
  lcd.print("            ");                             // se envían espacios al LCD para borrar el texto anterior
}                                                             // Fin de la inicialización


4º Añadimos a lo anterior el bucle del programa que se ejecutará indefinidamente:
// BUCLE DEL PROGRAMA
void loop(){                                                    // Inicio del bucle sin fin (loop)
      hallState = digitalRead(hallPin);              // Leer el estado del sensor de efecto hall:
      if (hallState == LOW) {                             // si el estado del sensor detecta el imán, o sea es LOW, entonces:
         digitalWrite(ledPin, HIGH);                   // enciende el LED;   
          if (Limpiart1 == 1) {                              // si es la segunda vez que el eje pasa por el sensor, entonces:
            t2 = millis();                                        // tomar en t2 el valor del reloj interno en milisegundos,
            RPM = 60000 / (t2 - t1);                     // calcular las revoluciones por minuto
            barras = RPM / revbarra;                  // calcular cuantas barras hay que mostrar en el display
          KMh = RPM * factorescala / 1000;      // calcular los Kilómetros/hora a escala 1:87
          t1 = t2;                                                 // dejar en t1 el valor del reloj tomado antes en t2 para iniciar otra cuenta
          Limpiart1 = 0;                                      // poner a cero el contador de pasos del eje por el sensor
                                                           // Actualizar el display con los datos:  
                                                                      // Imprimir RPM;
                    lcd.setCursor(0, 0);                   // poner el cursor del LCD en el primer carácter de la primera línea del lCD
                    lcd.print("RPM ");                      // escribir el texto RPM
                    lcd.print(RPM);                         // escribir el valor de RPM
                    lcd.print("    ");                          // escribir espacios a continuación para borrar valores anteriores
                                                                     // Imprimir KMh;
                   lcd.setCursor(9, 0);                   // Ubicar el cusor del display en la posición 10 de la la linea 1 (el cero es posición 1)
                   lcd.print("Kmh ");                      // escribir el texto Kmh
                   lcd.print(KMh);                         // escribir el valor Kmh
                   lcd.print("   ");                           // escribir espacios a continuación para borrar valores anteriores
                                                                   // Imprimir barras del tacómetro
  lcd.setCursor(0, 1);                                   // poscicionar el cursor en linea posición 1 de la linea 2
  for (int x = 1; x < 17; x++){                        // Bucle para imprimir los 16 caracteres del tacómetro
    if (barras > (x * 5))                                  //  Si el número de barras a imprimir > el numero de caracter x * 5 barras por carácter, entonces:
    {
    lcd.write (byte(5));                                  // imprimir un caracter de 5 barras en la posición actual del display
    }
    else if (barras == 0)                               //  Si el número de barras a imprimir es igual a 0, entonces:
    {
     lcd.write (byte(0));                                // Imprimir el caracter en blanco (número 0) en la posición actual del display
    }
    else {                                                     //  Si el número de barras no es mayor que x * 5 ni igual a 0, entonces:
      numcar = barras - ((x - 1) * 5);            // el Nº de carácter a imprimir será 1, 2, 3 o 4 barras
      lcd.write (byte(numcar));                     // Imprimir el carácter que corresponda
      barras = 0;                                          // en adelante todos los caracteres serán 0 así que barras se iguala a 0.
          }
  }                                                              // fin del bucle para imprimir el tacómetro
          }                                                      // fin del if (Limpiart1...
          else {                                              // si el contador del eje aún no ha pasado 2 veces seguidas por el sensor, entonces:
          }                                                     // no hacer nada
      }                                                         // fin del if (HallState == LOW, o sea imán detectado
      else {                                                  // si el estado del sensor no ha detectado el imán, o sea el valor es HIGH, entonces:
          digitalWrite(ledPin, LOW);            // apagar el LED:
          Limpiart1 = 1;                                // poner el contador de paso del imán a 1, es decir, empieza el segundo giro del eje
      }                                                        // fin del else 
}                                                              // vuelta al loop infinito del programa

Otras Opciones:
Este programa podría ampliarse fácilmente con el control de una botonera que permita cambiar algunas opciones de configuración como por ejemplo, medir 2 sensores a la vez; uno sobre el motor y otro sobre los rodamientos para encontrar la relación de giro del motor y su desmultiplicación. Cambiar el modo de visualización para ver las RPM de los dos sensores a la vez o ver cada uno por separado, etc. También podríamos cambiar la unidad de medida Km/h por Millas/hora, metros/h con corrección de escala o sin ella. Cambiar la escala H0 por otra distinta, etc. Añadir esta botonera no supone ningún coste extra ya que Arduino aún tiene entradas libres de sobra para leer las pulsaciones de los botones que nos servirían para cambiar de modo o incluso hay displays 16x2 que incluyen una botonera de 5 botones que nos serviría para ello sin complicar la parte electrónica y sólo modificando el programa de control.

Costes del proyecto
Realmente los costes de este proyecto no son muy altos comparado con las posibilidades que nos ofrece Arduino para experimentar no sólo con este proyecto sino con otras cosas útiles para el modelismo ferroviario. Los costes indicados a continuación son aproximaciones a fecha de hoy (Dic-2015):
- Un Arduino similar el que yo he usado (que hoy equivaldría al arduino UNO) cuesta unos 18 o 20€
- El display LCD PC1602F-B o uno más moderno con botonera incluida por unos 12€
- 5 sensores A3144 menos de  3€
- Un protoboard está en unos 5 o 6€
- Un juego de 65 cables con puntas para el protoboard y Arduino unos 4€
- La resistencia, algunos céntimos...
- 4 rodamientos sueltos 3x6x2 unos 4€ por "ebay"
- 1 juego de 4 rodamientos banco de pruebas Bachmann ref. 42901, 58€. (no  son imprescindibles pero si muy recomendables)

El coste total en piezas sería de unos 48€ sin considerar el juego de rodamientos Bachmann.

Fernando Escribano (Nov-2015)


otros circuitos electrónicos
3C - Tres Carriles ©

trescarriles@gmail.com


Imagen
Colabora con nosotros al  mantenimiento de la web y el  foro de

Tres Carriles con tu aportación económica



PAGO SEGURO - [Aportaciones desde 5€]
Síguenos en:

Hazte Socio
de
Tres Carriles
 


En todo momento respetamos el copyright de las marcas mencionadas en esta web. Cuando hacemos mención a las mismas, lo hacemos con carácter meramente informativo sin intención alguna de suplantación de copyright ni tampoco para hacer publicidad de las mismas. Algunos de los trabajos e imágenes publicados en nuestra web son públicos, otros son propiedad de 'Tres Carriles' , otros son de propiedad privada o de su autor, en cuyo caso hemos recibido autorización de uno u otro para su publicación. En cualquier caso siempre mencionamos al autor para respetar sus derechos. También respetamos escrupulosamente el derecho a la privacidad por lo que las personas, propiedades o datos. que puedan ser identificados en nuestra web, se han publicado con su autorización. Si por error, y siempre sin intención, descubrimos que algún componente de la página no cumple estos requisitos lo subsanaremos inmediatamente. Ayúdanos a mantener el respeto por los derechos de autor, de propiedad y de privacidad comunicándonos por escrito cualquier incumplimiento o recomendación a nuestra dirección de correo Trescarriles@gmail.com
Tres Carriles no permite la reproducción total o parcial del contenido publicado en esta Web salvo autorización expresa. Los interesados deben solicitarlo poniéndose en contacto por correo electrónico con Tres Carriles. Los enlaces electrónicos a cualquiera de nuestras páginas si están autorizados.
Los artículos de la web se han realizado con el mayor cuidado posible tanto para respetar la legalidad en cuanto a derechos de propiedad, derechos de autor y privacidad de datos como para para evitar errores que puedan causar daños, sin embargo no podemos asegurar que tanto la redacción como la aplicación de los contenidos en la práctica esté totalmente exenta de fallos por lo que el usuario de la Web es el único responsable de los efectos que se deriven de su puesta en práctica.
Nuestra página usa cookies para mejorar tu experiencia. Puedes controlar las cookies ajustando la configuración de tu navegador o dispositivo. Al acceder a nuestro sitio web autorizas a que usemos cookies.