Il plastico modulare di Stefano

  1. Facendo seguito all' articolo in cui ho descritto come pilorare gli scambi con Arduino Nano in un sistema basato sul protocollo Xpressnet©,ho sviluppato il progetto descritto in questo articolo che permette di realizzare un quadro comandi per scambi motorizzati dotati di decoder DCC per accessori.
    Il progetto è semplice, esso si basa su quanto già descritto nell' articolo precedente:




    il circuito permette di azionare gli scambi con indirizzo da 1 a 30 con una coppia di pulsanti normalmente aperti. La connessione dei pulsanti ai connettori P4 e P5 o P6 permetterà di individuare l' indirizzo dello scambio e la modalità di azionamento, dritto o deviato.
    I connettori P5 e P6 rappresentano i comando per dritto (P5 - Straight) e deviato (P6 - Diverged) e ogni contatto è relativo alla prima, seconda e terza decina. Il connettore P4 invece conta le unità.

    Con un esempio facciamo prima: per comandare lo scambio 7 dritto, collego il pulsante fra il primo contatto del connettore P5 - Straight (dritto) e il settimo contatto del connettore delle decine, per comandare lo scambio 14 deviato, collego il pulsante fra il secondo contatto del connettore P6 - Diverged (deviato) e il quarto contatto del connettore delle decine, infine per comandare lo scambio 20 in dritto collego il pulsante fra il pin 2 di P5 e il pin 10 di P4... credo adesso sia chiaro.

    Il progetto utilizza un Arduino Nano, data la semplicità del codice, esso è facilmente applicabile ad Arduino Uno o meglio ancora (vista la quantità di pin) Arduino Mega, con più pin a disposizione il numero di scambi da comandare può aumentare considerevolmente.
    Come negli altri progetti inerenti all' interfaccia Xpressnet© ho fatto uso delle librerie di Philipp Gahtow (http://pgahtow.de) al quale vanno i miei ringraziamenti.

    Nel codice l' indirizzo della periferica Xpressnet è codificato in una definizione fissa:

    #define XNetAddress 29 //Adress on XpressNet bus

    che ha valore 29, se si hanno altre periferiche con lo stesso indirizzo sul bus Xnet, questo valore va cambiato.

    Lo scketch ha commentate le righe per la seriale di servizio usate per il debug.
    Decommentare queste righe se necessario per avere una visualizzazione sul terminale seriale.

    Il funzionamento dello sketch è molto semplice, in effetti c' è la scansione continua di due tastiere associate ai pin dei connettori P4-P5 e P4-P6, viene rilevata la pressione di un tasto ed inviato un comndo di attivazione/disattivazione dello scambio associato al pulsante premuto.
    Lo schema ha  un pulsante collegato al pin A0 per usi futuri, così come il bus I2C (display ?) e due pin A6 e A7 che possono essere associati (nello sketch) ad itinerari precablati.
    Anche per questo progetto ho realizzato un PCB dall'ormai mio consueto fornitore cinese, le piastre sono arrivate in 4 settimane e sono di ottima qualità.
    Di seguito una foto del prototipo che ho montato. La versione del PCB che vedete è antecedente allo schema postato ma funzionalmente non ha alcuna differenza.

    Il circuito montato e cablato con Arduino Nano


    A presto!

    Di seguito i link per la realizzazione del progetto




    Per chi fosse interessato ai files gerber per la realizzazione del PCB ne faccia richiesta tramite il modulo di contatto del blog in Home Page, riceverete un link ai files necessari.

  2. L'utilizzo dei motori per servo comandi si è molto diffuso anche fra i fermodellisti per comandare scambi e più in generale piccoli automatismi, la diffusione di Arduino  come controllore a basso costo ha dato maggiore impulso a questa tendenza.
    Di progetti in rete per comandare servomotori ce ne sono diversi, in questo articolo ve ne presento uno che ha qualche caratteristica particolare: ogni servomotore può essere comandato da una centrale DCC e anche da un interruttore esterno direttamente connesso ad un pin di Arduino, in altre parole il decoder può essere usato anche senza una centrale DCC. Altra caratteristica è quella di regolare l' angolo di deviata del motore facendo muovere questi lentamente e scegliere la posizione ottimale, in questo modo è possibile regolare finemente la posizione che permette allo scambio di raggiungere la posizione desiderata con una buona precisione una volta montato il motore.
    Il progetto iniziale è stato pensato per i motori servo e tortoise, nella versione presentata è disponibile solo la funzione servo. Lo sketch è derivato da un'idea presente su un forum inglese da un ottimo modellista d'oltremanica, Dave Renshaw, che ringrazio pubblicamente per aver condiviso il programma che ho poi rivisitato aggiungendo alcune funzioni; nel file .ino ci sono i riferimenti delle fonti.
    Lo sketch utilizza la libreria DCC_Decoder.h disponibile a questo link, alla fine dell' articolo è possibile scaricare il file da caricare su Arduino. Esso contiene molti commenti ed è possibile modificarlo a piacimento.Lo schema elettrico è molto semplice, è composto dall' interfaccia DCC che rende disponibile il segnale digitale sul pin D2 di Arduino e da un semplice alimentatore per fornire la tensione ai motori e ad Arduino stesso.


    Come accennato, Arduino pilota i servomotori anche in analogico:  per poter muovere i servo occorre un semplice interruttore on-off (non un deviatore), cioè basta mettere il pin relativo (PAD 1-5) a massa (PAD 6) per cambiare la posizione.
    Per questo decoder ho disegnato un circuito stampato dalle dimensioni contenute: 52x58mm, alla fine dell' articolo sono disponibili i files gerber per la costruzione del PCB.
    All'avvio, collegando il monitor dell' IDE di Arduino alla porta USB di Arduino (velocità 9600), vengono visualizzati i parametri di configurazione, in particolare per ogni motore:
    - L' indirizzo
    - Il pin cui di Arduino cui è connesso il servo
    - Il pin cui collegare lo switch per il comando in analogico
    - L' angolo di delle posizioni dritto/deviata
    - L'ultima posizione memorizzata

    Il decoder all'accensione posiziona i servo secondo l' ultima configurazione salvata, ciò è possibile perchè lo sketch memorizza ogni movimento in EEPROM. Per ripristinare i valori di default basta digitare 'r' dal monitor dell' IDE e premer ENTER. Al riavvio il decoder caricherà la configurazione di default. Tale configurazione è modificabile tramite i valori inseriti nella stringa configData[] seguendo le istruzioni all' interno dello sketch.
    Un'altra caratteristica di questo decoder è lo "scollegamento" software del servo una volta che è stato comandato: in pratica, quando si invia un comando al servo, dopo che questo si è correttamente posizionato lo sketch "scollega" il servo dal in di Arduino conil comando:

    devices[i].servo.detach();

    ciò al fine di evitare i fastidiosi ronzii che possono verificarsi con alcuni modelli di motore. Il "detach time" è impostato a 1,2 secondi con la variabile:

    int ServoDetachTime = 1200;

    Programmazione indirizzo DCC
    L' indirizzo del decoder è l' indirizzo del servo nr.1 (connesso al pin D3), i successivi servomotori avranno indirizzi di valore successivo a questo, ovvero se il servo nr. 1 ha indirizzo 6, gli altri saranno 7, 8, 9, e 10.
    Per poter programmare l'indirizzo occorre eseguire i seguenti passi in DCC mode ovvero con il decoder connesso ad una centrale digitale:
    1. Accendere il decoder
    2. Collegare il segnale DCC della centrale
    3. Premere il pulsante reset di Arduino, premere il pulsante S1, il led al pin 13 si accende
    4. Inviare dalla Centrale DCC un comando scambi con l' indirizzo desiderato, dritto/deviata non è importante.
    5. Premere il pulsante S1
    6. Premere reset di Arduino

    A questo punto il decoder ha memorizzato l'indirizzo del comando che è stato inviato dalla centrale quale indirizzo del servo nr.1. E' importante notare che il nuovo indirizzo non deve rientrare nel range dell'indirizzo attuale dei 5 motori gestiti dal decoder, in altre parole se i servo hanno indirizzo ad esempio da 11 a 16, il nuovo indirizzo non deve avere come valori da 11 a 16.


    Regolare la posizione dei servo
    E' possibile regolare l'angolo di movimento del servo in entrambi i sensi, tale funzione è molto utile per una regolazione fine della deviata. La procedura è la medesima sia in DCC che in analogico.

    Per regolare la posizione dei servo si agisce in questo modo:
    1. Muovere il servo che si desidera regolare inviando un comando dalla centrale (DCC) o agendo sull' interruttore (analogico)
    2. Premere il pulsante S1, il servo si metterà nella posizione centrale e il led sul pin 13 lampeggia lentamente ad indicare che si è in fase di regolazione
    3. Premere nuovamente il pulsante S1, il led lampeggia più velocemente e il servo inizia a spostarsi lentamente verso un lato. Quando questo avrà raggiunto la posizione desiderata premere il pulsante S1
    4. Il servo si posiziona di nuovo al centro e inizierà a spostarsi lentamente nel verso opposto, il led lampeggia ancora più velocemente. Quando questo avrà raggiunto la posizione desiderata premere nuovamente il pulsante S1

    La procedura è terminata e le nuove posizioni sono memorizzate nella EEPROM, per verificare il corretto funzionamento provare a dare i comandi dritto/deviata, il servo dovrà muoversi secondo le nuove impostazioni.

     In figura la foto del prototipo montato e delle board ricevute dal produttore cinese (il primo ordine - 5 piastre - è veramente economico 😉 e la qualità è veramente alta!). Accanto al pulsante per la programmazione, si vede il connettore per il comando dei servo in analogico.





    Per chi fosse interessato ai files gerber per la realizzazione del PCB ne faccia richiesta tramite il modulo di contatto del blog in Home Page, riceverete un link ai files necessari.





















  3. Una volta descritto come impartire i comandi per gli scambi nell' articolo precedente, è ora di capire come attuare il comando vero o proprio, ovvero muovere gli aghi degli scambi.
    Di seguito è descritto un progetto per pilotare 4 motori a solenoide che utilizza Arduino Nano e un circuito a scarica capacitiva. Lo schema è derivato dagli innumerevoli circuiti che si trovano in rete, mentre lo sketch prende spunto dall'ottimo articolo pubblicato sul sito lucadentella.it ed utilizza le librerie NMRA.
    Il decoder ha funzioni minime per pilotare i motori, dal punto di vista della configurazione ha soltanto un parametro: l'indirizzo base del decoder. In pratica il decoder riceve il comando dalla centrale DCC e attiva l' uscita corrispondente all'indirizzo indicato dal comando. Altre funzioni e configurazioni per adesso non sono previste.
    Lo schema elettrico è il seguente:
    Lo schema è molto intuitivo, il segnale DCC in ingresso sul connettore X2 viene inviato ad Arduino sul pin D2 tramite un foto-accoppiatore 6N137. Per il funzionamento del decoder è necessaria una tensione esterna che può essere alternata dal valore di 12-13V AC, o anche continua di almeno 15V (connettore X1). L' alimentazione a 5V per Arduino  viene fornita da un IC stabilizzatore.
    Per ogni motore poi è prevista una coppia di MOSFET IRL540 che hanno la caratteristica di poter essere pilotati da tensioni di gate di valore 0-5V. I motori sono alimentati da un circuito a scarica capacitiva, esso è composto dalla resistenza R7 da 220ohm 5W e dalla coppia di condensatori da 2200uF che provvedono a fornire l' energia necessaria per muovere l' ago. Una volta scaricati, i condensatori impiegano circa 8-10 secondi per tornare alla piena carica e quindi pronti per ricevere un nuovo comando.
    Lo sketch è molto semplice,  come ho accennato è derivato dall'ottimo articolo pubblicato da Luca Dentella, cui vanno i miei ringraziamenti, che spiega come realizzare un semplice decoder accessori per pilotare un LED. Inoltre è illustrato molto chiaramente il metodo di indirizzamento MADA/PADA; un'ottima spiegazione è anche riportata nella wiki del noto software Rocrail© di Robert Versluis (link).
    Al link sottostante è possibile scaricare lo sketch de decoder al cui interno sono inseriti commenti per rendere il codice comprensibile e modificabile a piacimento.

    Il decoder ha un solo parametro di configurazione che è l' indirizzo base, (MADA - Module Accessory Decoder Address) ovvero l' indirizzo comune per le 4 porte del decoder. Tale indirizzo è calcolato con le formule:

    addr = (# - 1) / 4 + 1 
    port = (# - 1) modulo 4 + 1

    dove # è il numero indicante lo switch. Ad esempio lo switch 11: avrà indirizzo 3,5 e porta  3; prendendo le sole parti intere: indirizzo base 3, porta 3

    Di seguito una tabella esplicativa:

    Switch Number Indirizzo Base del decoder (MADA) Porta
    1 1 1
    2 1 2
    3 1 3
    4 1 4
    5 2 1
    6 2 2
    7 2 3
    8 2 4
    9 3 1
    10 3 2
    11 3 3
    12 3 4
    13 4 1
    14 4 2
    15 4 3
    16 4 4

    L' indirizzo di default del decoder è 1, ovvero il decoder pilota nativamente gli scambi con indirizzo da 1 a 4. Per cambiare indirizzo base basta premere il pulsante S1, il led di al pin 13 di Arduino Nano (quello montato sulla board di Arduino) lampeggierà
    ad indicare che il decoder aspetta di conoscere l' indirizzo base, a questo punto basta inviare un comando scambi con indirizzo base pari al valore desiderato per memorizzare il nuovo indirizzo nella EEPROM di Arduino. Se l' operazione è andata a buon fine il led 13 si spegnerà. Al riavvio il decoder avrà il nuovo indirizzo base.
    Collegando il cavo usb ad Arduino Nano e visualizzando il monitor all' interno dell' IDE, il decoder fornisce all' accensione i parametri di configurazione:
    La data e l'ora indicate sono quelle del caricamento del file dall'IDE, per gli switch gestiti dal decoder vengono indicati gli indirizzi e i pin di riferimento su Arduino.
    Per questo decoder ho disegnato anche un PCB dalle dimensioni 100x63mm a 2 layer:



    che ho successivamente ordinato ad un' azienda di Hong Kong. Le schede sono arrivate in 20-25 giorni e la qualità è veramente elevata. In basso a destra ho previsto un connettore (JP1) con le uscite del bus I2C per future connessioni di pulsanti e/o interruttore per la gestione manuale o degli itinerari.


    Di seguito le foto del prototipo montato:









    Per chi fosse interessato ai files gerber per la realizzazione del PCB ne faccia richiesta tramite il modulo di contatto del blog in Home Page, riceverete un link ai files necessari.













  4. Dopo la pubblicazione del palmare Multiloco per sistemi Xpressnet©, molti mi hanno chiesto di dotare lo stesso della capacità di poter pilotare gli scambi.
    L' esigenza del palmare multi loco, come ho avuto modo di spiegare nel primo articolo, è nata dal fatto di poter avere a disposizione i comandi "basic" a portata di mano per controllare più di una loco, su plastici medio piccoli, senza alcuna navigazione in menù o combinazioni di tasti.
    Dotare il Palmare Multiloco della funzionalità di comando scambi avrebbe un pò fatto venir meno questo principio per cui ho preferito venire incontro alle esigenze di qualche amico pensando ad un progetto ex-novo, ovvero un Arduino che avesse la possibilità di pilotare gli scambi tramite una serie di pulsanti.
    Il progetto che verrà descritto quindi è un controllore di scambi per sistemi basati sul protocollo Lenz Xpressnet©, qualcosa di simile a quanto già progettato e pubblicato da Paco Canada con il suo "XTCO".
    Il progetto utilizza un Arduino Nano, data la semplicità del codice, esso è facilmente applicabile ad Arduino Uno o meglio ancora (vista la quantità di pin) Arduino Mega.
    Anche in questo caso ho fatto uso delle librerie di Philipp Gahtow (http://pgahtow.de) che ancora una volta è stato molto disponibile nel fornire supporto e al quale vanno i miei ringraziamenti.

    Lo schema è il seguente:

    Schema di connessione


    Lo schema riporta solo 4 degli 8 pulsanti che sono stati configurati nello sketch, esso rappresenta effettivamente il prototipo che ho realizzato per le prove.
    Per connettersi al bus Xpressnet© è stata utilizzata l' interfaccia del palmare Multiloco con qualche lieve modifica per aggiungere un LED che indica la presenza della tensione 5V:






    Lo sketch da caricare su Arduino è molto semplice, in pratica viene letto in loop lo stato dei pulsanti e quando viene rilevata la pressione di uno di questi cambia lo stato dello scambio ad esso associato.




    Ogni pulsante quindi agisce da "toggle" per lo scambio cui è stato associato: premendo il pulsante lo scambio cambia stato, da corretto tracciato va in deviato o viceversa. La scelta di un solo pulsante per scambio (e non due pulsanti associati alle due condizioni, "corretto tracciato" e "deviato") è stata fatta per avere un numero sufficiente di scambi pilotabili da Arduino Nano che mette a disposizione un discreto numero di pin I/O (D3-D13 digitali, A0-A7 Analogici). Lo scketch proposto configura 8 pin come input:
    int turnout_pin[num_turnout] = { 3, 4, 5, 6, 7, 8, 9, 10};

    questa riga di codice elenca i pin associati ai pulsanti. Nulla vieta di aggiugere altri pin, occorre però ricordarsi anche di aggiornare la variabile di configurazione che indica il numero di scambi gestiti da Arduino:

    #define num_turnout 8


    Ad ogni scambio va poi associato un indirizzo che corrisponde all' indirizzo del decoder cui è connesso il motore dello scambio stesso.

    E' necessario fare una premessa: in ambito DCC, ci sono diversi modi di gestire l' indirizzamento dei decoder accessori (PADA, MADA etc), quello utilizzato dipende dalle varie centraline in commercio o autoscostruite che fanno parte del nostro impianto. Un'ottima spiegazione è riportata nella wiki del noto software Rocrail© di Robert Versluis (link).
    In pratica può capitare che uno stesso decoder sia visto con indirizzi diversi a seconda del dispositivo che lo piloti: ad esempio nel mio impianto, che è equipaggiato con la centralina NanoX di Paco Canada, uno stesso scambio ha indirizzi diversi se viene comandato dall' XTCO di Paco Canada o dal software RocRail©tramite interfaccia PC.

    Nello sviluppo dello sketch, utilizzando le librerie di Philipp Gahtow, ho riscontrato ancora una differenza: per muovere lo scambio programmato con indirizzo 2, ho dovuto indicare come indirizzo 5 e così via per tutti gli altri: esiste una differenza di "3" costante. Probabilmente ciò avviene perchè i vari costruttori/programmatori interpretano gli indirizzi di partenza da 0 o da 1 con logiche e principi diversi. L'unica cosa è... provare!

    Fatta questa premessa, l' indirizzo associato ai vari pulsanti/pin è contenuto nella variabile:

    int turnout_pin[num_turnout] =  { 3, 4, 5, 6, 7, 8, 9, 10};
    int turnout_add[num_turnout] = { 1, 2, 3, 4, 5, 6, 7,  8}; 

    l' array che contiene gli indirizzi segue quello che indica i pin, al pin 3 è associato l' indirizzo 1, al pin 4 indirizzo 2 etc.
    Per ovviare alla differenza di indirizzi che si può avere fra l' indirizzo del decoder e l'indirizzo che effettivamente viene inviato dallo sketch alla centralina è stata utilizzata la variabile:

    int address_offset = 3;

    tale valore viene somamto all' indirizzo programmato nella variabile turnout_add[num_turnout] e può essere cambiata a seconda delle esigenze. Come ho anticipato, occorre fare delle prove per definire l' esatto valore della variabile "address_offset".

    Arduino Nano dispone di una sola porta seriale e nel progetto descritto in questo articolo essa è utilizzata per scambiare messaggi sul bus Xpressnet tramite il chip MAX485. Allo stesso tempo però tale interfaccia è quella utilizzata da Arduino per caricare gli sketch da PC, poichè il MAX 485 se connesso ad Arduino non permette a questi di colloquiare con il PC tramite la porta USB, occorre disconnetterlo ogni volta che vogliamo caricare un nuovo sketch sul nostro Arduino Nano.

    Questa una foto del prototipo realizzato:














  5. Definite le funzionalità tecniche del palmare è ora di progettare una degna custodia per tutta l'elettronica.
    Per questo ho deciso di sfruttare le potenzialità della stampa 3D con tecnologia FDM, economica e flessibile. Dato che non ho trovato nulla che mi soddisfacesse nel cloud già pronto ho deciso di progettare l'enclosure ex novo.
    Per la realizzazione del disegno 3d ho utilizzato Autodesk Fusion 360, software molto potente di modellazione 3D che, per usi personali ed altre situazioni è gratuito. Consiglio di leggere i termini di licenza per verificare se ricadete nell'utilizzo gratuito del software.

    Per prima cosa ho disegnato un faceplate per verificare le finestre di alloggiamento della tastiera e del display e per avere un'indicazione di massima degli ingombri. Lanciata la stampa i risultati non si fanno attendere.




    Definito il posizionamento inizio a progettare la custodia, composta da due pezzi e con le apposite torrette di fissaggio per tutta l'elettronica.




    Bottom con le torrette di fissaggio dell'elettronica
    Elettronica in loco

    Bottom con le finestrature per i componenti



    I files .stl da stampare sono diponibili su Thingiverse cliccando sul collegamento qui sotto


  6. Nell'articolo precedente è stato presentato un Palmare Multiloco basato su Arduino Mega per sistemi digitali DCC Xpressnet© capace di controllare tre loco con tre manopole diverse e mettendo a disposizione i comandi essenziali, ovvero cambio dell' indirizzo DCC, direzione di marcia, luci. Oltre a ciò nella prima versione il palmare ha anche la funzione di lettura delle CV.

    Il presente articolo descrive la nuova release software che aggiunge la funzionalità di scrittura delle CV.

    Come descritto nell’articolo precedente, il palmare entra nella modalità “Service mode” premendo il tasto “D”. Il display mostrerà la schermata come in figura:
    Per leggere una CV occorre ruotare la manopola dell’encoder 1 per selezionare il numero della CV da leggere e poi premere il pulsante dello stesso encoder per attivare l’operazione di lettura vera e propria.
    Il valore letto sarà visualizzato come in figura.
    Per scrivere una CV occorre ruotare la manopola dell’encoder 2 per selezionare il numero della CV da leggere e la manopola dell’encoder 3 per selezionare il valore da programmare, successivamente premere il pulsante dell’encoder 2 per attivare l’operazione di scrittura.
    Il palmare visualizzerà il valore appena scritto nella riga dedicata alla lettura.
    Premendo il tasto 'D' si torna alla schermata di controllo.


  7. Il progetto descritto di seguito riguarda un palmare per sistemi digitali che utilizzano il protocollo Lenz Xpressnet© tipico dei sistemi Roco, basato su Arduino Mega.
    L’ idea parte dall’esigenza dei poter avere sottomano il controllo di più loco, ciascuna con la classica manopola dedicata. Tutti i palmari infatti hanno un solo potenziometro o encoder, e per poter controllare più loco occorre sempre scorrere un menù o cambiare indirizzo. Questo palmare invece mette a disposizione tre manopole dedicate e 4 tasti per ogni loco per i controlli essenziali della marcia (cambio di indirizzo, velocità, stop loco, cambio direzione, luci) in maniera diretta, i comandi cioè sono sempre disponibili. E' possibile inoltre leggere le CV del decoder.
    Il progetto prevede come anticipato l’utilizzo un Arduino Mega (ho usato un clone cinese con interfaccia seriale/USB basata sul chip CH340) a causa dell’elevato numero di I/O richiesti e per eventuali espansioni future, una tastiera 4x4, un display LCD a 4 righe e 20 colonne con interfaccia I2C, tre encoder rotativi e un semplice circuito di interfaccia per il bus RS485 per connettersi al bus Xpressnet©.
    Il software è molto semplice e intuitivo, esso utilizza le librerie messe a disposizione di Philipp Gahtow sul suo sito internet http://pgahtow.deal quale rinnovo i ringraziamenti per il supporto. Lo sketch può essere facilmente modificato per aggiungere altre funzioni, inserire altri encoder etc. Le funzioni della libreria di Philipp sono di facile comprensione una volta lette le direttive del protocollo.
    Lo schema dei collegamenti è il seguente:


    Lo schema dell’interfaccia con il busRS485 si basa sul chip MAX485 (o equivalente), anch’ esso molto comune in rete, è indicato nella figura seguente:

    Il circuito fornisce l’alimentazione ad Arduino e al display sfruttando la tensione +12V messa a disposizione dal bus Xpressnet©, i pin TX/RX vanno connessi all’ interfaccia seriale 1 di Arduino, il pin EN che abilita/disabilita la trasmissione al pin 25.
    Le connessioni con la tastiera e con gli encoder sono indicate all’ interno dello sketch. 
    Il codice come anticipato è molto semplice, dopo la parte di inizializzazione, il loop principale prevede ciclicamente le seguenti operazioni:
    I tasti del tastierino 4x4 sono organizzati in modo che ogni colonna numerica è relativa a ciascuna delle tre loco controllate dal palmare, mentre le righe rispettivamente controllano l’indirizzo della loco (prime due righe), la direzione (terza riga) e le luci (quarta riga). Il tasto “A” agisce come Stop di emergenza togliendo tensione ai binari, con il tatìsto "D" si entra in Service Mode per la lettura delle CV:
    Gli encoder regolano la velocità della loco, premendo la manopola a mo’ di pulsante (tutti gli encoder hanno la funzione “push-button”) la velocità passa istantaneamente a 0.

    Allo start-up il display visualizza la scritta di benvenuto e la data/ora della compilazione del file caricato su Arduino, un modo per tener traccia della versione sw caricata. Successivamente vengono visualizzate le info delle loco controllate:


    Per ogni loco sono visualizzate le seguenti info: indirizzo, direzione, stato delle luci e velocità. Sulla parte desta sono indicati gli step attualmente in uso e in basso lo stato di alimentazione dei binari.
    Il palmare utilizza di default la modalità a 28 step, tuttavia allo start-up tenendo premuto il tasto “D” è possibile cambiare gli step, il software infatti visualizza la schermata seguente:


    Agendo sui tasti “A” e “B” si possono scegliere le seguenti modalità:

    0  – 14 step

    1  – 27 step

    2  – 28 step (default)

    3  – 128 step

    Una volta scelto il numero di step con cui operare, premendo il tasto “D” il palmare va nella modalità operativa. La scelta degli step non è memorizzata in EEPROM.
    Il palmare permette anche la lettura delle CV se connesso alle centrali dotate di tale funzione (purtroppo il Lokmaus/Multimaus non forniscono feedback). Premendo il tasto “D” si entra in Service Mode:


    Agendo sul encoder 1, si potrà scegliere la CV da leggere e premendo la manopola a mo’ di pulsante verrà visualizzato il valore della CV:
    Una volta terminate le operazioni di lettura, premendo il tasto “D” si ritorna alla modalità operativa.
    Ecco l' elenco dei componenti:
    -  Arduino Mega (per il prototipo è stato usato un clone)
    -  Display LCD 20x4 con interfaccia I2C come questo
    -  Keypad 4x4  link
    -  Encoder rotativo KY-040 link

    Per l 'interfaccia con il bus Xpressnet, i componenti da assemblare sono i seguenti:
    - Connettore RJ-12
    - circuito integratro MAX485 o equivamente
    - circuito integrato LM7805  (case TO220)
    - 2 condensatori 100uF 25V
    - 1 diodo 1N4004 o equivalente

    Queste alcune foto della realizzazione del prototipo:




    Aggiornamento 19/03/2019

    Antonino ha aggiornato il suo palmare con una comodissima funzione per la scrittura delle CV, trasformando di fatto il palamre TriLok in una completa stazione DCC! Cliccate sul link qui sotto per leggere il post corrispondente.






    A presto!
      
  8. Tempo fa un editore di nome DelPrado mise ion commercio una collana chiamata "Locomotive del mondo", composta da 100 locomotive statiche in scala N 1:160. Tra le locomtive proposte spiccano quelle italiane, tra le quali troviamo anche la E402B in livrea di origine, la cassa devo dire appare ben fatta a parte i pantografi che delgi ATR90 FS hanno ben poco, e sono terribilmente grossolani.

    L'idea è quella di fornire una degna motorizzazione a questa loco per poterla finalmente vederla sfrecciare nel mio plastico.

    Innanzitutto occorre procurarsi la cassa DePrado reperibile sul mercato dell'usato, reperibile anche all'estero.


    Aperta la confezione ho rimosso la loco dalla base espositiva mediante una vitina sul fondo, quindi ho separato la cassa dal telaio folle, sempre mediante due viti poste sul fondo. A questo punto non rimane che fresare completamente tutto l'interno mediante un minitrapano ed una fresetta, per fare in modo che il telaio alloggi perfettamente nella cassa.

    Come motorizzazione ho scelto una BR120 su base Minitrix, ma va beniussimo anche Fleishmann. Lavorando di fresa e lima per rastremare le estremità il telaio calza perfettamente nella cassa.
    Dal telaio folle Delprado vanno recuperate le fiancate dei carrelli avendo cura di non romperle nella rimozione.




    Dal telaio motorizzato separare i due carrelli, con l'occasione procedere anche ad una accurata pulizia. L'obbiettivo è quello di rimuovere le fiancate originali e predisporre la sede per l'incollaggio delle fiancate precedentemente rimosse.


    fare attenzione a posizionare correttamente le boccole, anche se al vero il carrello ha un passo leggermente diverso dall'originale ma alla vista non si nota. Prestate attenzione perchè le fiancate DelPrado vanno accorciate in quanto altrimenti interferiscono con la cassa causando spiacevoli deragliamenti dovuti ad una non corretta rotazione del carrello stesso.

    Visto il buon dettaglio ho preferito lasciare la cassa in livrea di origine così come esce dalla confezione, tuttavia i pantografi sono veramente inguardabili, per questo mi sono procurato l'ottimo kit Lineamodelriproducente una coppia di pantografi ATR90, realizzato in fotoincisione di alpacca.

    Il kit si presenta abbastanza semplice ma date le dimensioni ad alcuni potrebbe fare un pò di timore.



    Per prima cosa occorre saldare la vite dii fissaggio M1 sulla base. a seguire si assemblano i bracci inferiori e superiori del pantografo, quindi la base porta-strisciante.


     



    a questo punto il pantografo va dipinto in Rosso Segnale ed applicato lo strisciante non verniciato.






    Ed ecco il modello finito pronto per essere utilizzato, avanti con i commenti!

    Modello terminato con pantografi Lineamodel

    Fari accesi sui binari prima di rimuovere i pantografi originali





  9. Piccolo video dimostrativo di una breve sessione di circolazione in modalità automatica con Rocrail, con gestione dei segnali luminosi e degli itinerari


  10. Arduino come si sa è una piattaforma estremamente diffusa, ha il vantaggio di aver costi molto contenuti e si presta ad applicazioni più disparate; ovviamente non mancano quelle che coinvolgono il modellismo ferroviario. Ho trovato in rete un’ interessante applicazione proposta da un utente del forum RocRail per realizzare un modulo feedback veramente a basso costo e dalla minima complessità hardware e software.
    L’ idea parte dal fatto che RocRail accetta una gran quantità di centrali e fra queste c’ è anche la centrale Marklin CS2. Questa centrale ha fra le interfacce gestite anche quella dei sensori S88 e può essere connessa sia in seriale che in ethernet al PC. Nel progetto proposto, Arduino emula questa centrale connessa in seriale leggendo lo stato dei pin e inviandolo a RocRail come se fosse, appunto, una CS2. Più difficile a dirsi che a farsi 😉
    Arduino mette a disposizione circa 19 pin, sufficienti per la gestione di una media stazione nascosta ma potrebbero essere pochi per un plastico casalingo, soprattutto se concentrati in un solo punto. Per questo ho modificato il codice trovato in rete in modo da poter prevedere schede satellite collegate tramite il bus I2C, così da espandere la capacità in termini di lettura di pin. Queste schedine sono basate sul chip PCF8574, hanno 8 pin I/O e un costo che va dagli 80€cent a 1,5€. Alla fine si hanno a disposizione 14 pin di I/O direttamente sulla scheda Arduino e il bus I2C per la connessione di schedine esterne.
    Lo schema di principio è il seguente:



    Per l’esperimento ho utilizzato Arduino Nano, ovviamente la soluzione si adatta anche alle altre versioni. Come schedina satellite ho provato quella in foto che ha il vantaggio di avere i connettori I2C “entra/esci” facilitando quindi il cablaggio, ma ce ne sono altre che possono essere utilizzate, come ad esempio quelle che pilotano i display LCD.
    Ogni schedina ha tre jumper per scegliere l’ indirizzo che dovrà presentare sul bus I2C, ovviamente in caso di più schede queste dovranno avere indirizzi differenti.
    Occorre fare attenzione alla versione del chip, gli indirizzi sono differenti a seconda che si tratti di PCF8574 e PCF8574A. Le tabelle seguenti indicano gli indirizzi per i le due versioni.



    Sul numero massimo di schede ci sono alcune considerazioni elettriche da fare: il bus I2C è nato per comunicazioni all’ interno dello stesso sistema, spesso sulla stessa scheda, ma comunque per distanze ravvicinate. Infatti i driver normalmente hanno una capacità di 400pf che equivalgono a qualche metro di cavo, quindi all’ interno di 2-3 metri di cavo possiamo avere due tre schede senza problemi. Oltre è necessario che il bus sia “potenziato” con un vero e proprio booster capace di raggiungere qualche decina di metri. Allo studio ci sono soluzioni; in figura la connessione fisica del bus I2C:
     In foto le varie board connesse usate per lo sviluppo del codice. Si vede Arduino Nano montato su una scheda con terminal boards. Arduino e schede satellite sono connesse ad un rilevatore di corrente a 4 ingressi.

    Il codice è composto da una parte iniziale dove sono dichiarate le variabili di ambiente, poi la parte eseguibile dove inizialmente (setup) il programma cerca sul bus I2C se ci sono schede, una volta memorizzati gli indirizzi viene inviato lo stato iniziale dei pin a RocRail. A questo punto ciclicamente viene letto lo stato dei pin e confrontato con lo stato precedente, se questo è cambiato (dopo aver campionato tre volte lo stato a distanza di 10 mS) viene inviato un messaggio a RocRail. Il software ha poi un periodo di debouncing settabile tramite la variabile “interval” (1sec) per evitare sfarfallamenti.
    Non c’ è bisogno di installare librerie esterne o di terze parti (a parte la libreria Wired per gestire I2C che fa parte dell’ambiente standard dell’ IDE), il codice è veramente semplice e parla da sé.
    La scheda di default invia i dati con indirizzo bus 1 (modificabile cambiando il valore della variabile bus_addr), i pin residenti su Arduino sono numerati da 1 a 14 secondo la tabella seguente.

    Address
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    Arduino Pin
    A1
     A2
     A3
    D12
    D9
    D8
    D7
    D6
    D5
    D4
    D3
    D2
    D10
    D11
    La sequenza dei pin può essere cambiata a piacimento variando l’ ordine dei pin nel codice alla riga:
    int sense[num_sensors] = {A1, A2, A3, 12, 9, 8, 7, 6, 5, 4, 3, 2, 10, 11};
    A seguire saranno conteggiati i pin delle schede satellite, se presenti: se ad esempio ci sono 2 schede connesse, scheda A con indirizzo 57 (dec) e scheda B con indirizzo 60, ai pin della scheda A verranno assegnati indirizzi da 15 a22 e quelli della scheda B da 23 a 30. Lo stato dei pin è normalmente alto (+5V).
    La connessione ad un sensore esterno, ad esempio un rivelatore di corrente, è semplice:

    Allo stesso modo avviene la connessione ai pin delle schede satellite.
    Il messaggio inviato a RocRail è conforme al protocollo seguito dalla centrale Marklin CS2 consultabile qui, esso è composto da 13 bytes ed ha la seguente struttura:
    Prio
    Command
    Resp.
    Hash
    DLC
    Byte0
    Byte 1
    Byte 2
    Byte 3
    Byte 4
    Byte 5
    Byte 6
    Byte 7
    2+2bit
    8 bit
    1 bit
    16 bit
    4 bit
    8 bit
    8 bit
    8 bit
    8 bit
    8 bit
    8 bit
    8 bit
    8 bit
    tx_msg0/tx_msg1
    tx_msg2
    tx_msg3
    tx_msg4
    tx_msg5
    tx_msg6
    tx_msg7
    tx_msg8
    tx_msg9
    tx_msg10
    tx_msg11
    tx_msg12





    num bytes

    bus number

    num_sensor

    sens_value


    0
    35

    59
    121
    8
    0
    1
    0
    X
    0
    X
    0
    0

    La configurazione della centrale in RocRail è anch’ essa semplice. Dalla schermata  in cui si configura la centrale:




    Occorre aggiungere una centrale del tipo MCS2 la cui configurazione è indicata in figura:


    Ricordate di selezionare il tipo di comunicazione “Serial” e baudrate 500000. Nel campo “Interface ID” va indicato un nome che poi va riferito nella configurazione dei sensori, è importante inoltre indicare correttamente la porta di comunicazione “Device” (COM per Windows, /dev/ttyXXX per i sistemi Linux) cui è connesso Arduino.

    Questo il link per scaricare l'ultima release dello sketch che include queste nuove funzioni:
    - risposta alla richiesta dello stato dei sensori "start of the day"
    - il Led 13 acceso indica la corretta connessione di schede satelliti I2C

    A presto!


Supporta le attività della nostra associazione con una piccola donazione.



Utilizziamo i cookie sul nostro sito Web. Alcuni di essi sono essenziali per il funzionamento del sito, mentre altri ci aiutano a migliorare questo sito e l'esperienza dell'utente (cookie di tracciamento). Puoi decidere tu stesso se consentire o meno i cookie. Ti preghiamo di notare che se li rifiuti, potresti non essere in grado di utilizzare tutte le funzionalità del sito.