Decoder DCC a N relais con Arduino

[ho_master]

Nel nuovo plastico del Museo del Treno di Montesilvano siamo arrivati al momento di gestire le varie sezioni. La scelta e' caduta su un sistema basato su RocRail, booster della Roco/Fleischmann, Multimaus e svariati sottosistemi autocostruiti.

In questo thread voglio descrivervi la gestione della stazione nascosta di cui mi sto occupando.

i 23 scambi sono gestiti da 4 decoder lenz ls150 pilotati ad itinerari da RocRail.

Per la gestione dell'alimentazione delle tratte isolate avrei potuto pilotare con 2 decoder ls150 11 relais per dare e togliere tensione, ma i costi sarebbero saliti troppo per cui ho voluto tentare la strada della autocostruzione riducendo pero'
al minimo l'uso del saldatore e puntando su una soluzione basata su Arduino.

Penso di aver testato tutto quello che c'e' sul Web a proposito di Arduino e DCC e alla fine ho scelto la soluzione che mi piaceva di piu'.

Per condividerla con voi in maniera semplificata vi mostrero' come costruire un decoder con 8 relais per alimentare o meno altrettanti sezionamenti.


Immagine:

126,37 KB

La scelta dei componenti e' caduta su un clone di Arduino che si trova in rete sotto i 10 Euro e su un modulo a 8 relais che si trova intorno ai 12/15 Euro.

L'unico circuito che occorre costruire e' quello che adatta il segnale DCC ai livelli richiesti da Arduino.

Nella foto seguente potete vedere i tre moduli e il loro collegamento

Immagine:

737,14 KB

All'indirizzo http://www.mynabay.com/arduino potrete trovare il circuito che ho impiegato, le librerie necessarie per il progetto e svariati esempi.

La costruzione dell'adattatore e' stata fatta in pochi minuti su una piastrina di Veroboard.

Nella foto seguente potete vedere il circuito, l'aspetto finale e come interrompere con il cutter alcune piste per realizzare il circuito.

Immagine:

390,49 KB

In un prossimo post vi mostrero' il programma di gestione .

Non so quanti di voi possano essere interessati alla realizzazione e soprattutto quanti di voi mastichino di Arduino per cui entrero in dettagli sempre piu' specifici solo su vostra sollecitazione per non annoiare gli altri.

A disposizione.

Antonello

[Docdelburg]

Grazie Antonello per la condivisione; spero possa interessare qualche utente così da avere maggiori dettagli.

[Digtrain]

Ciao Antonello,
io sono interessato al tuo progetto!!
Procedi pure con le spiegazioni.

Ciao Walter :geek:

[ho_master]

Post propedeutico per chi non ha mai sentito parlare di Arduino.

Per partire senza combattere con l'Inglese potete partire da qui http://it.wikipedia.org/wiki/Arduino_%28hardware%29.

Una volta compreso di che si tratta http://arduino.cc/
e' il punto d'ingresso al nuovo mondo.

Nella sezione Learning potrete capire a che serve la scheda e come si programma
attraverso vari esempi.

Nella sezione Download potrete trovare e scaricare tutto il SW necessario
per caricare i vostri programmi su Arduino e per testarli.

Il Forum e' la vera miniera di soluzioni per i campi piu' disparati e c'e' anche
una sezione in italiano http://forum.arduino.cc/index.php?board=34.0,
oggettivamente meno ricca.

Nel prossimo post passero' a trattare del SW che anima il Decoder
lo sketch come ora certamente saprete.

Antonello

[ho_master]

Ammettiamo che abbiate gia' acquistato i materiali, montato l'interfaccina Arduino/DCC e cablato i vari pezzi fra di loro secondo lo schema proposto: andiamo a commentare lo sketch che fara' funzionare il tutto.

Lo sketch puo' essere scaricato da qui http://www.apud.it/public/DCC/dec8rel/D ... le_v02.ino. Si tratta di una versione molto semplificata dell'analogo programma presente su Minabay, ritagliata solo per le mie attuali necessita'.

Potete scaricare la libreria con gli esempi nella versione da me utilizzata da qui http://www.apud.it/public/DCC/dec8rel/d ... der.v4.zip

"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
NB con alcuni clone di Arduino i driver presenti nel SW ufficiale non funzionano.

Quelli da me utilizzati possono essere scaricati da qui http://www.apud.it/public/DCC/dec8rel/CH341SER.ZIP
"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""

Antonello

[ho_master]

Codice: Seleziona tutto

#include <DCC_Decoder.h>

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

//Da compilare con versione aggiornata della libreria ( 0315 ) se si usano compilatori piu' recenti della 1.0.6

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Defines and structures
//
#define kDCC_INTERRUPT            0

typedef struct
{
    int               address;                // Address to respond to
    byte              output;                 // State of output 1=on, 0=off
    int               outputPin;              // Arduino output pin to drive
    boolean           isDigital;              // true=digital, false=analog. If analog must also set analogValue field
    boolean           isFlasher;              // true=flash output, false=no time, no flash.
    byte              analogValue;            // Value to use with analog type.
    int               durationMilli;          // Milliseconds to leave output on for.  0 means don't auto off
    
    unsigned long     onMilli;                // Used internally for timing
    unsigned long     offMilli;               // 
} DCCAccessoryAddress;


//"""""""""""""""""""""""""""   Definiamo le costanti del nostro Decoder   """""""""""""""""""""""""""""""""""""""""""""""""""""""""""
//"

DCCAccessoryAddress gAddresses[8];  // inserire fra parentesi quadre il numero massimo di relè da collegare a questo Decoder

int baseaddress = 700;          // indirizzo iniziale del Decoder
int mstot = 200;                // tempo di chiusura dei contatti del relè in millisecondi;  0 vuol dire sempre chiuso fino a nuovo comando
int firstpin = 3;               // primo pin di Arduino cui viene collegato il primo relè
  
//"
//""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""



//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Decoder Init 
//
void ConfigureDecoder()
{
    for(int i=0; i<(int)(sizeof(gAddresses)/sizeof(gAddresses[0])); i++)
    {

    gAddresses[0].address = baseaddress + i;
    gAddresses[0].output = 0;
    gAddresses[0].outputPin = firstpin + i;
    //gAddresses[0].isDigital = false;
    //gAddresses[0].isFlasher = false;
    //gAddresses[0].analogValue = 250;
    gAddresses[0].durationMilli = mstot;
    }
    
        // Setup output pins
    for(int i=0; i<(int)(sizeof(gAddresses)/sizeof(gAddresses[0])); i++)
    {
        if( gAddresses[i].outputPin )
        {
            pinMode( gAddresses[i].outputPin, OUTPUT );
        }
        gAddresses[i].onMilli = 0;
        gAddresses[i].offMilli = 0;
    }
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Basic accessory 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;
    
    for(int i=0; i<(int)(sizeof(gAddresses)/sizeof(gAddresses[0])); i++)
    {
        if( address == gAddresses[i].address )
        {
            Serial.print("Basic addr: ");
            Serial.print(address,DEC);
            Serial.print("   activate: ");
            Serial.println(enable,DEC);
            
            if( enable )
            {
                gAddresses[i].output = 1;
                gAddresses[i].onMilli = millis();
                gAddresses[i].offMilli = 0;
            }else{
                gAddresses[i].output = 0;
                gAddresses[i].onMilli = 0;
                gAddresses[i].offMilli = millis();
            }
        }
    }
    
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Setup
//
void setup() 
{ 
   Serial.begin(9600);
   DCC.SetBasicAccessoryDecoderPacketHandler(BasicAccDecoderPacket_Handler, true);
   ConfigureDecoder();
   DCC.SetupDecoder( 0x00, 0x00, kDCC_INTERRUPT );
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Main loop
//
void loop()
{
    static int addr = 0;
    
        ////////////////////////////////////////////////////////////////
        // Loop DCC library
    DCC.loop();
    
        ////////////////////////////////////////////////////////////////
        // Bump to next address to test
    if( ++addr >= (int)(sizeof(gAddresses)/sizeof(gAddresses[0])) )
    {
        addr = 0;
    }
    
        ////////////////////////////////////////////////////////////////
        // Turn off output?
    if( gAddresses[addr].offMilli && gAddresses[addr].offMilli<millis() )
    {
            // Clear off time
        gAddresses[addr].offMilli = 0;
        
            // Disable output
            digitalWrite( gAddresses[addr].outputPin, LOW);
                
        return;
    }
        
        ////////////////////////////////////////////////////////////////
        // Turn on output?
    if( gAddresses[addr].onMilli && gAddresses[addr].onMilli<=millis() )
    {
            // Clear off time
        gAddresses[addr].onMilli = 0;
        
            // Enable output
        
            digitalWrite( gAddresses[addr].outputPin, HIGH);
        
            // If still enabled and a flash type, set off time
        if( gAddresses[addr].durationMilli )
        {
            gAddresses[addr].offMilli = millis() + gAddresses[addr].durationMilli;
        }
        
        return;
    }
    
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

""" Carichiamo la libreria di Minabay

#include <DCC_Decoder.h>

""" Definiamo le costanti del nostro Decoder

""" inserire fra parentesi quadre il numero massimo di relè da collegare a questo Decoder; sono 16 per una scheda Arduino Uno; oltre 50 per una Arduino Mega

DCCAccessoryAddress gAddresses(8); fra parentesi quadre: qui sul forum viene una faccina !!!



""" indirizzo iniziale del Decoder a scelta sara' l'indirizzo del relè N. 1

int baseaddress = 700;

""" tempo di chiusura dei contatti del relè in millisecondi quando viene ricevuto un comando; 0 vuol dire sempre chiuso fino a nuovo comando

""" io, ad esempio ho scelto 3000 ovvero il binario rimane in tensione per 3 secondi

int mstot = 3000;

""" primo pin di Arduino cui viene collegato il pin N. 1 della scheda relè

int firstpin = 3;

""" Nella sezione seguente viene ripetuto N volte il ciclo di inizializzazione

// Decoder Init
//
void ConfigureDecoder()
{
for(int i=0; i<(int)(sizeof(gAddresses)/sizeof(gAddresses[0])); i++)
{

gAddresses[0].address = baseaddress + i;
gAddresses[0].output = 0;
gAddresses[0].outputPin = firstpin + i;
//gAddresses[0].isDigital = false;
//gAddresses[0].isFlasher = false;
//gAddresses[0].analogValue = 250;
gAddresses[0].durationMilli = mstot;
}

// Setup output pins
for(int i=0; i<(int)(sizeof(gAddresses)/sizeof(gAddresses[0])); i++)
{
if( gAddresses.outputPin )
{
pinMode( gAddresses.outputPin, OUTPUT );
}
gAddresses.onMilli = 0;
gAddresses.offMilli = 0;
}
}

""" Nella sezione seguente viene catturato il flusso delle informazioni DCC e trasformato in un formato comprensibile da noi e da Arduino

//
// Basic accessory 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;

<font color="red">"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
con il Multimaus occorre aggiungere 4 all'indirizzo trovato per far coincidere
l'indirizzo digitato con quello calcolato: verificare nel proprio sistema

address +=4;

"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""</font id="red">

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

for(int i=0; i<(int)(sizeof(gAddresses)/sizeof(gAddresses[0])); i++)
{
if( address == gAddresses.address )
{
Serial.print("Basic addr: ");
Serial.print(address,DEC);
Serial.print(" activate: ");
Serial.println(enable,DEC);

if( enable )
{
gAddresses.output = 1;
gAddresses.onMilli = millis();
gAddresses.offMilli = 0;
}else{
gAddresses.output = 0;
gAddresses.onMilli = 0;
gAddresses[i].offMilli = millis();
}
}
}

}

""" Il programma vero e proprio che fa scattare il relè al'indirizzo 700 + x con x compreso fra 0 e 7


//
// Setup
//
void setup()
{
Serial.begin(9600);
DCC.SetBasicAccessoryDecoderPacketHandler(BasicAccDecoderPacket_Handler, true);
ConfigureDecoder();
DCC.SetupDecoder( 0x00, 0x00, kDCC_INTERRUPT );
}


//
// Main loop
//
void loop()
{
static int addr = 0;

////////////////////////////////////////////////////////////////
// Loop DCC library
DCC.loop();

////////////////////////////////////////////////////////////////
// Bump to next address to test
if( ++addr >= (int)(sizeof(gAddresses)/sizeof(gAddresses[0])) )
{
addr = 0;
}

////////////////////////////////////////////////////////////////
// Turn off output?
if( gAddresses[addr].offMilli && gAddresses[addr].offMilli<millis() )
{
// Clear off time
gAddresses[addr].offMilli = 0;

// Disable output
digitalWrite( gAddresses[addr].outputPin, LOW);

return;
}

////////////////////////////////////////////////////////////////
// Turn on output?
if( gAddresses[addr].onMilli && gAddresses[addr].onMilli<=millis() )
{
// Clear off time
gAddresses[addr].onMilli = 0;

// Enable output

digitalWrite( gAddresses[addr].outputPin, HIGH);

// If still enabled and a flash type, set off time
if( gAddresses[addr].durationMilli )
{
gAddresses[addr].offMilli = millis() + gAddresses[addr].durationMilli;
}

return;
}

}

/

Le varie righe che contengono il comando Serial.Print e Serial.Println
servono per monitorare il funzionamento: possono essere commentate.

Giocando con le porte avanzate si potrebbero comandare 8 semafori in contemporane con gli 8 relè

A questo punto mi fermo in attesa delle inevitabili domande.

Antonello

[ho_master]

Un paio di note pratiche.

L'alimentatore della scheda relè deve essere diverso da quello di Arduino perche' quest'ultimo non sopporta la corrente necessariaa pilotare l'altra scheda.

Potendo meglio alimentare Arduino a 5 Volt.

I binari vanno collegati alla scheda in questa maniera

.

Antonello

[ho_master]

Versione aggiornata del codice:

Codice: Seleziona tutto

#include <DCC_Decoder.h>

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

//Da compilare con versione aggiornata della libreria ( 0315 ) se si usano compilatori piu' recenti della 1.0.6

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Defines and structures
//
#define kDCC_INTERRUPT            0

typedef struct
{
    int               address;                // Address to respond to
    byte              output;                 // State of output 1=on, 0=off
    int               outputPin;              // Arduino output pin to drive
    boolean           isDigital;              // true=digital, false=analog. If analog must also set analogValue field
    boolean           isFlasher;              // true=flash output, false=no time, no flash.
    byte              analogValue;            // Value to use with analog type.
    int               durationMilli;          // Milliseconds to leave output on for.  0 means don't auto off
    
    unsigned long     onMilli;                // Used internally for timing
    unsigned long     offMilli;               // 
} DCCAccessoryAddress;


//"""""""""""""""""""""""""""   Definiamo le costanti del nostro Decoder   """""""""""""""""""""""""""""""""""""""""""""""""""""""""""
//"

DCCAccessoryAddress gAddresses[8];  // inserire fra parentesi quadre il numero massimo di relè da collegare a questo Decoder

int baseaddress = 700;          // indirizzo iniziale del Decoder
int mstot = 200;                // tempo di chiusura dei contatti del relè in millisecondi;  0 vuol dire sempre chiuso fino a nuovo comando
int firstpin = 3;               // primo pin di Arduino cui viene collegato il primo relè
  
//"
//""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""



//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Decoder Init 
//
void ConfigureDecoder()
{
    for(int i=0; i<(int)(sizeof(gAddresses)/sizeof(gAddresses[0])); i++)
    {

    gAddresses[i].address = baseaddress + i;
    gAddresses[i].output = 0;
    gAddresses[i].outputPin = firstpin + i;
    gAddresses[i].durationMilli = mstot;

    }
    
        // Setup output pins
    for(int i=0; i<(int)(sizeof(gAddresses)/sizeof(gAddresses[0])); i++)
    {
        if( gAddresses[i].outputPin )
        {
            pinMode( gAddresses[i].outputPin, OUTPUT );
        }
        gAddresses[i].onMilli = 0;
        gAddresses[i].offMilli = 0;
    }
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Basic accessory 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;
 
// """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
    address +=4;     // utilizzato con Multimaus per far coincidere indirizzo digitato con indirizzo del decoder. Verificare su altri sistemi
// """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""

// """""""""""""""""""""""""""""""""""""""""""""""""""" Abilitare le righe seguenti per verificare il codice trasmesso """"""""""""""""""""""""""
            //Serial.print("Basic addr: ");
            //Serial.println(address,DEC);
            //Serial.println("""""""""""");
            //Serial.println("");
            
// """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""           
    
    boolean enable = (data & 0x01) ? 1 : 0;
    
        for(int i=0; i<(int)(sizeof(gAddresses)/sizeof(gAddresses[0])); i++)
    {
        if( address == gAddresses[i].address )
        {
            
// """""""""""""""""""""""""""""""""""""""""""""" Commentare queste righe una volta terminati i test """"""""""""""""""""""""""""""""""""""""""""          
            Serial.print("Basic addr: ");
            Serial.print(address,DEC);
            Serial.print("   activate: ");
            Serial.println(enable,DEC);
// """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""            
            if( enable )
            {
                gAddresses[i].output = 1;
                gAddresses[i].onMilli = millis();
                gAddresses[i].offMilli = 0;
            }else{
                gAddresses[i].output = 0;
                gAddresses[i].onMilli = 0;
                gAddresses[i].offMilli = millis();
            }
        }
    }
    
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Setup
//
void setup() 
{ 
   Serial.begin(9600);
   DCC.SetBasicAccessoryDecoderPacketHandler(BasicAccDecoderPacket_Handler, true);
   ConfigureDecoder();
   DCC.SetupDecoder( 0x00, 0x00, kDCC_INTERRUPT );
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Main loop
//
void loop()
{
    static int addr = 0;
    
        ////////////////////////////////////////////////////////////////
        // Loop DCC library
    DCC.loop();
    
        ////////////////////////////////////////////////////////////////
        // Bump to next address to test
    if( ++addr >= (int)(sizeof(gAddresses)/sizeof(gAddresses[0])) )
    {
        addr = 0;
    }
    
        ////////////////////////////////////////////////////////////////
        // Turn off output?
    if( gAddresses[addr].offMilli && gAddresses[addr].offMilli<millis() )
    {
            // Clear off time
        gAddresses[addr].offMilli = 0;
        
            // Disable output
            digitalWrite( gAddresses[addr].outputPin, LOW);
                
        return;
    }
        
        ////////////////////////////////////////////////////////////////
        // Turn on output?
    if( gAddresses[addr].onMilli && gAddresses[addr].onMilli<=millis() )
    {
            // Clear off time
        gAddresses[addr].onMilli = 0;
        
            // Enable output
        
            digitalWrite( gAddresses[addr].outputPin, HIGH);
        
            // If still enabled and a flash type, set off time
        if( gAddresses[addr].durationMilli )
        {
            gAddresses[addr].offMilli = millis() + gAddresses[addr].durationMilli;
        }
        
        return;
    }
    
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Scaricabile da http://www.apud.it/public/DCC/dec8rel/D ... le_v02.zip

[ho_master]

Per chi non se la sentisse di analizzare il codice sopra esposto spiego in poche righe il funzionamento del decoder.

Ogni relè collegato e' visto dal sistema come se fosse uno scambio con i due stati 0 ed 1
( esempio: corretto tracciato e deviata ).

Se quindi digito sul Multimaus 703 e il tastino di deviata il relè numero 3 scatta e da' tensione al binario corrispondente facendo partire il convoglio ivi in sosta.

Dopo tre secondi il relè numero 3 si diseciterà e il binario rimarrà di nuovo senza tensione bloccando il convoglio successivo.

Se avessi deciso di mettere a zero il tempo di eccitazione allora occorrerà premere il pulsante di corretto tracciato sul Multimaus sempre all'indirizzo 703.

Nel caso del nostro plastico sarà RocRail a mandare i segnali relativi ai vari relè nella sequenza prevista, automatizzando il traffico della stazione nascosta.

Antonello

[Digtrain]

Grazie Antonello per il materiale che hai messo a disposizione..... adesso lo passerò a mio figlio, che studia informatica all'università e a cui ho regalato Arduino Mega, Arduino Nano e una montagna di sensori acquistati in Cina!!!

Spero mi dia una mano!!!

Ciao Walter :geek:

[Edgardo_Rosatti]

Alcuni cloni di Arduino purtroppo non funzionano sotto Seven. O meglio è difficile trovare i driver giusti per farli funzonare tramite l'IDE.
Con Ubuntu invece non danno problemi. Per IOS non saprei...

Comunque grazie per la condivisione, qualsiasi progetto inerente ad Arduino è sempre molto apprezzato.

ciao

[ho_master]

L'indirizzo a cui facevo riferimento nel primo post e' diventato

http://www.mynabay.com/dcc_monitor/

Antonello

[Edgardo_Rosatti]

Graze per l'info Antonello, molto interessante.

Ed

[SteaMarco]

Tutto molto interessante ma per ora mi limito a leggere c'ho il barbecue che ha la carne che si brucia!

Comunque molto interessante, Marco

[ho_master]

I test vanno avanti. Questo e' lo schena elettrico definitivo della stazione nascosta del plastico di Fossacesia presso il Museo del treno di Montesilvano



Immagine:

331,35 KB

Antonello