decoder para desvíos fleischmann con arduino
#1
Saludos.
¿Sabríais decirme si es posible hacer un decoder para desvíos fleischmann con arduino?
Tengo un sólo desvío eléctrico sin decoder y si lo pudiera solucionar sin comprar uno hecho para mover varios me vendría muy bien.
Gracias.
Responder
#2
Yo tengo 24 desvíos en mi maqueta y con dos módulos Digikeijs gestiono 16 y los otros 8 con un Arduino Nano.
Diseñé y monté un circuito impreso, que adjunto en la imagen y no es complicado el invento.


Archivos adjuntos Miniatura(s)
   
Responder
#3
¿La placa la has hecho tu o es comprada? Si la has hecho tu parece de fábrica. Enhorabuena.
Yo tengo 19 desvíos de los cuales 18 están con tres módulos Lenz 150 para 6 desvíos cada uno. El que hace número 19 lo tengo sin decoder y me fastidia un poco comprar un deco para varios desvíos para utilizar uno solo.
Lo del arduino nano es fácil, claro, pero la placa ¿cómo me puedo hacer con ella) el programa del nano y la relación de los componentes de la placa?
Si me puedes echar una mano, bienvenida sea.
Gracias.
Responder
#4
La placa, una vez diseñada, se encargó a una empresa que las fabricó, para ello me ayudó un colega y no salieron mal de precio. Me quedan 4 unidades y eso si te parece lo tratamos por privado.
Con esta placa, lo mínimo a montar sería para dos desvíos, aunque solo lo necesites para uno
Si te interesa, te puedo pasar el sketch a cargar en el arduino y la lista de materiales.
Aquí te adjunto una foto de cuando la tenía montada para 4 desvíos.


Archivos adjuntos Miniatura(s)
   
Responder
#5
Pecetero, cuando acabes los negocios con el camarada pontedeume, ¿podrías hablar conmigo? Yo también estoy interesado. y tengo bastantes nanos
Responder
#6
Tampoco trato de hacer negocios, solo trato de ayudar y por eso dije lo de las 4 placas que tengo muertas de risa ya que he montado todas las placas que necesitaba, pues con ellas tambien realizo el alumbrado de las estaciones para poner en penumbra cuando no hay trenes y con iluminación total al llegar algún tren.
Responder
#7
A petición de Pontedeume 3000, pongo aquí la lista de materiales que se necesitan para la tarjeta que he comentado:

(Actualizado el 7/12/2018)
1 Arduino Nano
4 C.I. L293 ( 1 por cada 2 desvíos)
1 C.I. 6N137
1 Regulador R7805
1 Diodo led rojo (junto al pulsador)
1 Diodo led naranja (Junto a la entrada de la señal de la vía)
1 Diodo 1N4007
3 Res. 10K  1/4W (R2, R3 y R5)
2 Res. 4K7  1/4W (R1 y R4)
1 Res. 2k2  1/4w
9 Clemas de 3 contactos, paso 2,54mm (1 por cada desvío + 1 para alimentación)
1 Clema de 2 contactos, paso 2,54mm. (Conexión a las vías)


El regulador R7805 se puede sustituir por el 7805, pero deberá montarse con disipador.

.
Responder
#8
Se que no quieres hacer negocio. Fue una forma de hablar. Lo corrijo. Cuando termines de ayudar a pontedeume. Me gustaría poder ayudarte a gestionar alguna placa, si te queda en desuso.
Gracias
Responder
#9
Perfecto. Necesito la placa, el integrado L293 y el programa para el arduino.
Luego me dirás cómo se direcciona en la central.
Si estás de acuerdo, envíame tus datos para hacerte la transferencia. Yo te enviará mi dirección.
Y gracias, naturalmente.

Manuel
Responder
#10
Hola Pecetero, te mande un privado. Si no tienes mas placas no me importa hacerla. Lo que si necesito es el diseño y el codigo arduino. Mandame precio por la informacion y o material por privado y agradecido.

Un saludo

Enviado desde mi SM-G965F mediante Tapatalk
Responder
#11
(29-11-2018, 20:42)Pontedeume 3000 escribió: Perfecto. Necesito la placa, el integrado L293 y el programa para el arduino.
Luego me dirás cómo se direcciona en  la central.
Si estás de acuerdo, envíame tus datos para hacerte la transferencia. Yo te enviará mi dirección.
Y gracias, naturalmente.

Manuel

Yo solo te puedo suministrar la placa, que es lo que tengo, del resto de materiales te tienes que encargar tú.
A ver si mañana me da tiempo y cuelgo aquí el sketch que he usado para meterle al Nano.
Lleva un pulsador para programar la primera dirección de los 8 desvíos: Lo pulsas y tienes 5 segundos para introducir la dirección a través de la central. En mi caso, como ya tenía 16 desvios con módulos Digikeijs DR4018, le metí la dirección 17 y esa sería la direeción del desvío 1, sumándose 1 a cada desvío posterior.
Responder
#12
(29-11-2018, 22:10)peibol escribió: Hola Pecetero, te mande un privado. Si no tienes mas placas no me importa hacerla. Lo que si necesito es el diseño y el codigo arduino. Mandame precio por la informacion y o material por privado y agradecido.

Un saludo

Enviado desde mi SM-G965F mediante Tapatalk

Como le he dicho a Pontedeume 3000, yo solo poseo la placa, ya que tuve que hacer un pedido mínimo de 10 unidades y me quedan 4 que ya no voy a usar y el resto de materiales los tenéis que gestionar vosotros.

El esquema de la tarjeta no le tengo porque un amigo hizo el diseño partiendo de un circuito que publicaron en la web de ASALAF. He ido para poner el enlace, pero está cerrada hasta diciembre.

Como veo que esto se está convirtiendo en un mercadillo, voy a poner las 4 tarjetas a la venta en el foro de intercambio de material y así será todo más correcto.
Lógicamente tendréis preferencia vosotros.
Responder
#13
Pues como ya habéis acaparado las 4 tarjetas, no lo pondré en el foro de intercambio de material.
A ver si esta tarde puedo poner el Sketch para que se lo metáis al arduino Nano
Responder
#14
Aquí os dejo el Sketch que tendréis que meter al Arduino Nano para que funcione la tarjeta como decoder de desvíos tipo Fleischmann de bobina/solenoide.
Supongo que este programa no será perfecto y muy mejorable, pero es lo que conseguí elaborar para mis propósitos tras pegarme con él largas horas y sin conocer este lenguje de programación.

Tal y como está, si no se programase una nueva dirección, sería de la 33 a la 40 y los impulso de tensión a las bobinas, para accionar el desvío, de 450 ms.


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Arduino DCC Solenoid Switch Decoder.
// Author: Ruud Boer - January 2015
// Modificado por Pecetero - Julio 2018
// This sketch turns an Arduino into a DCC decoder to drive max 8 dual coil solenoid switches.
// The DCC signal is optically separated and fed to pin 2 (=Interrupt 0). Schematics: www.mynabay.com
// Many thanks to www.mynabay.com for publishing their DCC monitor and -decoder code.
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#include <DCC_Decoder.h>
#include <EEPROM.h>

#define kDCC_INTERRUPT 0
#define EEPROM_ADDRESS 2  // dode se guardara la direccion dcc
#define pulsador 3
#define aviso_tiempo 20

unsigned long Tprog_Milli;  // Tiempo de espera para programar
int direccion=33;
int bucle ;
int reset = 0;
const byte impulso=250;  // Se sumará 200 al valor definido

////////////////////////////////////////////////////////
//El numero de desvios que se van a controlar
const byte maxaccessories=8; 
///////////////////////////////////////////////////////

typedef struct
{
  int               address;         // Address to respond to
  byte              output;          // State of accessory: 1=on, 0=off (for internal use only)
  int               outputPin;       // Arduino output pin
  int               outputPin2;      // Arduino output pin2, used for solenoid junctions
  byte              highlow;         // State of outputpin: 1=HIGH, 0=LOW
  byte              highlow2;        // State of outputpin2: 1=HIGH, 0=LOW
  boolean           finished;        // Memory location that says the oneshot is finished
  boolean           finished2;       // Memory location that says the second oneshot (for solenoid) is finished
  int               durationMilli;   // ms flash time
  unsigned long     onMilli;         // for internal use
  unsigned long     offMilli;        // for internal use
  


DCCAccessoryAddress;
DCCAccessoryAddress accessory[maxaccessories];

void ConfigureDecoderFunctions() 
{
  accessory[0].address = direccion;
  accessory[0].durationMilli = impulso + 200;
  accessory[0].outputPin = 4;
  accessory[0].outputPin2 = 5;
  accessory[0].highlow = 0; // Do not change this value
  accessory[0].highlow2 = 0; // Do not change this value
  accessory[0].finished = false; // Do not change this value
  accessory[0].finished2 = true; // Do not change this value
  accessory[0].output = 0; // Do not change this value

  accessory[1].address = direccion + 1;
  accessory[1].durationMilli = impulso + 200;
  accessory[1].outputPin = 6;
  accessory[1].outputPin2 = 7;
  accessory[1].highlow = 0; // Do not change this value
  accessory[1].highlow2 = 0; // Do not change this value
  accessory[1].finished = false; // Do not change this value
  accessory[1].finished2 = true; // Do not change this value
  accessory[1].output = 0; // Do not change this value

  accessory[2].address = direccion + 2;
  accessory[2].durationMilli = impulso + 200;
  accessory[2].outputPin = 8;
  accessory[2].outputPin2 = 9;
  accessory[2].highlow = 0; // Do not change this value
  accessory[2].highlow2 = 0; // Do not change this value
  accessory[2].finished = false; // Do not change this value
  accessory[2].finished2 = true; // Do not change this value
  accessory[2].output = 0; // Do not change this value

  accessory[3].address = direccion + 3;
  accessory[3].durationMilli = impulso + 200;
  accessory[3].outputPin = 10;
  accessory[3].outputPin2 = 11;
  accessory[3].highlow = 0; // Do not change this value
  accessory[3].highlow2 = 0; // Do not change this value
  accessory[3].finished = false; // Do not change this value
  accessory[3].finished2 = true; // Do not change this value
  accessory[3].output = 0; // Do not change this value

  accessory[4].address = direccion + 4;
  accessory[4].durationMilli = impulso + 200;
  accessory[4].outputPin = 12;
  accessory[4].outputPin2 = 13;
  accessory[4].highlow = 0; // Do not change this value
  accessory[4].highlow2 = 0; // Do not change this value
  accessory[4].finished = false; // Do not change this value
  accessory[4].finished2 = true; // Do not change this value
  accessory[4].output = 0; // Do not change this value

  accessory[5].address = direccion + 5;
  accessory[5].durationMilli = impulso + 200;
  accessory[5].outputPin = 14;
  accessory[5].outputPin2 = 15;
  accessory[5].highlow = 0; // Do not change this value
  accessory[5].highlow2 = 0; // Do not change this value
  accessory[5].finished = false; // Do not change this value
  accessory[5].finished2 = true; // Do not change this value
  accessory[5].output = 0; // Do not change this value

  accessory[6].address = direccion + 6;
  accessory[6].durationMilli = impulso + 200;
  accessory[6].outputPin = 16;
  accessory[6].outputPin2 = 17;
  accessory[6].highlow = 0; // Do not change this value
  accessory[6].highlow2 = 0; // Do not change this value
  accessory[6].finished = false; // Do not change this value
  accessory[6].finished2 = true; // Do not change this value
  accessory[6].output = 0; // Do not change this value

  accessory[7].address = direccion + 7;
  accessory[7].durationMilli = impulso + 200;
  accessory[7].outputPin = 18;
  accessory[7].outputPin2 = 19;
  accessory[7].highlow = 0; // Do not change this value
  accessory[7].highlow2 = 0; // Do not change this value
  accessory[7].finished = false; // Do not change this value
  accessory[7].finished2 = true; // Do not change this value
  accessory[7].output = 0; // Do not change this value

  // Setup output pins
  for(int i=0; i<maxaccessories; i++)
  {
    if( accessory[i].outputPin )
{
      pinMode( accessory[i].outputPin, OUTPUT );
      digitalWrite( accessory[i].outputPin, LOW);
    }
    if( accessory[i].outputPin2 )
{
      pinMode( accessory[i].outputPin2, OUTPUT );
      digitalWrite( accessory[i].outputPin2, LOW);
    }
  }
  pinMode(aviso_tiempo,OUTPUT);
  
} // END ConfigureDecoderFunctions

//////////////////// DCC packet handler //////////////////////////////////////
void BasicAccDecoderPacket_Handler(int address, boolean activate, byte data)
{

  // Convert NMRA packet address format to human address
  address -= 1;
  address *= 4;
  address += 1;
  address += (data & 0x06) >> 1;

  boolean enable = (data & 0x01) ? 1 : 0;

/////////////////////////////////////////////////////////////////////////////
//========== lectura de direccion para guardar =============================//
  //Si estamos en modo programacion, se guarda la direccion                //
 
   if (bucle==1)   {
     while (millis()- (Tprog_Milli) < 5000) { 
        //digitalWrite(13, HIGH); //provisional
        digitalWrite(aviso_tiempo, HIGH);  
        EEPROM.update(EEPROM_ADDRESS,address%256);                
        EEPROM.update(EEPROM_ADDRESS+1,address/256);
        reset = 1;
     }
     bucle = 0;                              
   }
     if (reset==1) { 
       reset = 0;
       //digitalWrite(13, LOW); //provisional
       digitalWrite(aviso_tiempo, LOW);
       //declara función de reset @ address 0 
       void(* resetFunc) (void) = 0;
       resetFunc(); //Reset  
     }

//=========================================================================//  
/////////////////////////////////////////////////////////////////////////////

  for(int i=0; i<maxaccessories; i++)
{
    if( address == accessory[i].address )
{
      if( enable ) accessory[i].output = 1;
      else accessory[i].output = 0;
    }
  }
} // END BasicAccDecoderPacket_Handler

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Setup (run once)
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void setup() 


  DCC.SetBasicAccessoryDecoderPacketHandler(BasicAccDecoderPacket_Handler, true);
  ConfigureDecoderFunctions();
  DCC.SetupDecoder( 0x00, 0x00, kDCC_INTERRUPT );
  pinMode(2,INPUT_PULLUP); //Interrupt 0 with internal pull up resistor (can get rid of external 10k)
    
} //END setup

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Main loop (ejecucion continua)
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void loop()
{

if (digitalRead(pulsador)==HIGH) {  //pulsador de programación
    //digitalWrite(13, HIGH);  //provisional
    digitalWrite(aviso_tiempo, HIGH);
    Tprog_Milli = millis();
    bucle = 1;
  }
if(millis()- (Tprog_Milli) > 5000)   {
   //digitalWrite(13, LOW);  //provisional
   digitalWrite(aviso_tiempo, LOW); 
}
  static int addr = 0;

   DCC.loop(); // Loop DCC library
 
  if( ++addr >= maxaccessories ) addr = 0; // Bump to next address to test

  if (accessory[addr].output == 1)
{
if (!accessory[addr].highlow && !accessory[addr].finished)
{
accessory[addr].highlow = 1;
      accessory[addr].offMilli = millis() + accessory[addr].durationMilli;
}
if (accessory[addr].highlow && millis() > accessory[addr].offMilli)
{
accessory[addr].highlow = 0;
accessory[addr].finished = true;
}
accessory[addr].finished2 = false;
  }

  else // output==0
  {
accessory[addr].highlow = 0;
//accessory[addr].finished = false;
if (!accessory[addr].highlow2 && !accessory[addr].finished2)
{
accessory[addr].highlow2 = 1;
accessory[addr].offMilli = millis() + accessory[addr].durationMilli;
}
if (accessory[addr].highlow2 && millis() > accessory[addr].offMilli)
{
accessory[addr].highlow2 = 0;
accessory[addr].finished2 = true;
}
    accessory[addr].finished = false;
  }

  if (accessory[addr].highlow) digitalWrite( accessory[addr].outputPin, HIGH);
  else digitalWrite( accessory[addr].outputPin, LOW);
       
  if (accessory[addr].highlow2) digitalWrite( accessory[addr].outputPin2, HIGH);
  else digitalWrite( accessory[addr].outputPin2, LOW);

 } //END loop

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Responder
#15
Que crack. Muchas graciassss!!!!!

Enviado desde mi SM-G965F mediante Tapatalk
Responder
#16
Mil gracias
Responder
#17
Una aclaración sobre el circuito impreso ...

La alimentación debe ser a 12-16V y no es necesario alimentar a 5V ni poner el jumper ya que eso estaba pensado para otras posibilidades que aún no he desarrollado.
Responder
#18
Muchas gracias. He estado mirando el circuito impreso principal. el L293 es muy interesante ya que puede funcionar como un relé de hasta 1,2 A y hasta 36 v
Responder
#19
(06-12-2018, 00:38)Ficusrex escribió: Muchas gracias. He estado mirando el circuito impreso principal. el L293 es muy interesante ya que puede funcionar como un relé de hasta 1,2 A y hasta 36 v

Es que los desvíos Fleischmann, en el impulso de accionamiento, consumen de 500 a 600 mA. y lógicamente había que ponerle al Arduino un circuito driver ya que esa corriente no es capaz de suministrarla.
Responder
#20
En el post 7, de este hilo, he corregido la lista de materiales ya que había una pequeña confusión con las resistencias.
Os ruego que me disculpéis, pero hice tantas pruebas que me hice un lío.
Responder


Posibles temas similares...
Tema Autor Respuestas Vistas Último mensaje
  Comprovar decoder. leptrain 3 308 03-09-2019, 11:08
Último mensaje: krokodiland
  Deo para KOF leptrain 1 274 10-07-2019, 15:08
Último mensaje: artinu
  decoder desvios cantina 0 347 29-05-2019, 17:22
Último mensaje: cantina
  Decoder Zimo Next 18 tigrin 10 1,497 27-05-2019, 13:09
Último mensaje: artinu
  Sera el decoder? leptrain 6 580 03-05-2019, 22:17
Último mensaje: artinu
  Iconos para RocRail?. jorsan 9 1,248 16-03-2019, 20:00
Último mensaje: jorsan
  Decoder Marklin J Gonzalo Afonso M 0 510 01-03-2019, 05:13
Último mensaje: J Gonzalo Afonso M
  Decoders para Mabar 1000 H66-85353 Juan B. 17 2,661 10-02-2019, 23:51
Último mensaje: Juan B.
  Novato Arduino y servos ray269 8 3,474 22-01-2019, 19:17
Último mensaje: Pochy
  Funciones decoder zimo quisn 1 756 10-01-2019, 11:40
Último mensaje: Telamon

Salto de foro:


Usuarios navegando en este tema: 2 invitado(s)