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.
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. |
Arduino Mega Duemilanove
Sensor de efecto hall A3144 (switch)
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:
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.
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.
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) |
Banco de rodillos con sensor
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)
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. |
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).
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
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.
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.
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.
