Visualizzazione post con etichetta NMRA. Mostra tutti i post
Visualizzazione post con etichetta NMRA. Mostra tutti i post

domenica 7 giugno 2020

Decoder DCC e analogico per Servo con Arduino Nano

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à 115200), 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.





















sabato 11 aprile 2020

Decoder basic per motori a solenoide con Arduino Nano

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.













domenica 17 settembre 2017

FEEDBACK CON ARDUINO NANO



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!