Pubblicato il 30 gennaio 2021
Abbiamo di recente visto quali siano il principio di funzionamento ed il cablaggio del ponte trasbordatore girevole di Minitrix, ed abbiamo anticipato che sarebbe stato facile realizzarne il pilotaggio tramite un microcontrollore della famiglia Arduino o ESP32. Come abbiamo più volte detto, noi preferiamo il secondo se non altro perché ha integrate le componenti necessarie per comandarlo via web, e quindi possiamo facilmente costruire delle interfacce utente grafiche per computer, smartphone o tablet. Il seguente video, già anticipato nella puntata precedente, dimostra il risultato:
Vediamo ora di capire come questo sia stato ottenuto.
Nell’esaminare il funzionamento della piattaforma Minitrix, abbiamo visto come il controllo sia logicamente partizionabile in due sottosistemi: uno per muovere il ponte (traslazione e rotazione) e l’altro per movimentare i rotabili sulla piattaforma e sui binari di accesso ad essa.
Affrontiamo quindi separatamente le due questioni, iniziando in questa nota dal movimento del ponte. In una prossima discuteremo della movimentazione dei rotabili, e della digitalizzazione.
Prima di addentraci però rivediamo quali siano le piedinature, e ricordiamo che guardando gli spinotti nella piattaforma numeriamo i pin da sinistra a destra, mentre per i binari di accesso contiamo dal basso verso l’alto, avendo gli spinotti nella parte inferiore della piattaforma.
Connettore rosso
1 | Non usato |
2 | Rotaia sinistra del binario sinistro nel letto del ponte |
3 | Rotaia destra del binario sinistro nel letto del ponte (Primo polo di alimentazione per il motore di traslazione) |
4 | Rotaia sinistra del binario centrale (e quindi rotaia superiore del ponte) |
5 | Tutte le rotaie inferiori dei binari di accesso sul lato sinistro |
6 | Tutte le rotaie inferiori dei binari di accesso sul lato destro |
7 | Rotaia destra del binario centrale (e quindi rotaia inferiore del ponte) |
8 | Secondo polo di alimentazione per il motore di traslazione, connesso con entrambe le rotaie del binario destro nel letto del ponte |
Connettore nero
1 | Ingresso segnale presenza per tutti i binari di accesso |
2 | Primo polo di alimentazione per il motore di rotazione |
3 | Secondo polo di alimentazione per il motore di rotazione, connesso anche con il pin 8 rosso |
4 | Segnale presenza binario 1 |
5 | Segnale presenza binario 2 |
6 | Segnale presenza binario 3 |
7 | Segnale presenza binario 4 |
8 | Segnale presenza binario 5 |
9 | Segnale presenza binario 6 |
10 | Segnale presenza binario 7 |
Rilevazione della posizione del ponte
Il primo tema che affrontiamo è come rilevare dove il ponte si trovi. Useremo per questo i pin 1 nero, e da 4 a 10 nero.
Nel polo 1 nero inseriremo la corrente HIGH del microcontrollore. Andremo poi a leggere ciclicamente i pin da 4 a 10: se in uno di essi troviamo il valore HIGH, vuol dire che il ponte si trova in corrispondenza del relativo binario (il pin x è relativo al binario x-3). Se nessuno di essi riporta il valore HIGH, allora il ponte si trova nello spazio intermedio tra due binari: per sapere quali terremo traccia dell’ultimo binario in corrispondenza del quale ne abbiamo rilevato la presenza e della direzione di traslazione del ponte. Naturalmente, dovremo prevedere anche il caso che un “deus ex-machina” abbia prelevato il ponte e lo abbia teletrasportato (manualmente) altrove.
Dobbiamo però garantirci che la lettura del segnale sui pin 4-10 abbia senso: se sono scollegati (cosa che avviene quando il ponte non si trova al binario) la lettura del segnale fluttua dando valori casuali, ed avremmo dei falsi positivi, ovvero troveremo il valore HIGH su binari a caso. Per evitarlo, dobbiamo collegare ciascuno dei pin da 4 a 10 permanentemente a terra con una resistenza molto elevata (noi abbiamo usato 47 kΩ), così che quando invece il ponte fa contatto la corrente che passa sulla resistenza sia trascurabile.
A questo punto possiamo scrivere un primo programmino che, usando il nostro microcontroller, faccia proprio le operazioni descritte e ogni secondo ci stampi in console la sequenza dei valori letti sui sette binari ed il numero del binario trovato, così da poter testare la prima parte del nostro sistema. Abbiamo per questo scelto arbitrariamente una lista di pin sul microcontrollore, che raccogliamo in un array che battezziamo bin.
Ricordiamo che i pin del microcontroller si chiamano GPIO, termine che useremo da qui in avanti: parleremo di pin per indicare quelli del connettore sulla piattaforma, e di GPIO per quelli del microcontrollore.
const int bin[8] = {13, 36, 39, 34, 35, 32, 33, 27}; // GPIO segnale [0] e binari [1-7]
//
void checkBridgePosition() {
int track = 0;
for (int i = 1; i < 8; i++) {
int value = digitalRead(bin[i]);
Serial.print(value);
if (value == HIGH) track = i;
}
Serial.print(" - found track ");
Serial.println(track);
}
void loop() {
checkBridgePosition();
delay(1000);
}
Traslazione del ponte
Il ponte si muoverà se noi forniamo una tensione continua (preferibilmente 5,5 V) sui pin 3 rosso e 8 rosso. La sorgente può essere un qualunque trasformatore usato per trazione: i due motorini che azionano la piattaforma sono gli stessi che troviamo nei modelli di motrici in scala N.
Tuttavia, ci può essere un problema: lo Zener tosatore scarica se si supera la tensione di circa 8,5 V. Questo può avvenire anche se nominalmente il trasformatore fornisce una continua inferiore a tale valore. Infatti la tensione nominale è media, e può avere fluttuazioni (il caso più clamoroso è quello di un PWM, che ha – by design -picchi di tensione molto elevati compensati da intervalli senza tensione). In questo caso lo Zener scarica quando viene superato il livello di soglia, e l’effetto netto è di avere periodici corto circuiti. Quindi tutto dipende da che alimentatore si usa, ma per evitare il problema abbiamo deciso di rimuovere il doppio Zener, dissaldandolo. E’un intervento semplice e assolutamente reversibile, quindi si può procedere con serenità, e stare poi più tranquilli.
Daremo inoltre la stessa polarità del pin 3 rosso anche al pin 2 rosso. Ricordiamo che 8 rosso alimenta le due rotaie del binario di destra su cui trasla il ponte (ovale verde destronell’immagine sotto), mentre 3 rosso alimenta la rotaia interna del binario di sinistra e 2 rosso la rotaia esterna dello stesso binario (ovale verde sinistro nella foto).
Ricordiamo anche che la rotaia esterna del binario sinistro ha, in corrispondenza di ciascun accesso, un piccolo diedro che solleva la molletta prendicorrente per permettere di fermare con precisione il ponte. Ne abbiamo discusso in dettaglio nella nota precedente.
Il nostro microcontrollore dovrà fare da interruttore sul filo che va dall’alimentazione ai pin 3 rosso e 2 rosso, mentre il pin 8 sarà costantemente sotto tensione. Quando vogliamo far movere il ponte, daremo (lo stesso polo di) corrente anche ai pin 2 e 3 rossi. Quando questo raggiunge la destinazione, staccheremo dapprima la corrente del pin 3, confidando che il diedro poi tolga meccanicamente il contatto anche sul binario connesso sul pin 2, fermando il ponte. Per sicurezza, dopo aver tolto la corrente al pin 3, la toglieremo anche al pin 2 dopo un tempo assai breve (un decimo di secondo sembra funzionare bene). In questo modo, se anche sull’abbrivio il ponte dovesse superare il diedro, lo fermeremo comunque: con meno precisione ma in modo che sia comunque transitabile.
Per ottenere questi risultati, il microcontrollore deve pilotare un relè: useremo un monostabile monopolare, usando il polo Normally Open: quando il microcontrollore darà sul GPIO dedicato al controllo del relè un valore HIGH, il relè chiuderà il circuito, facendo fluire la corrente, per tornare poi ad aprirlo quando il GPIO assumerà il valore LOW. Purtroppo la tensione logica fornita dal microcontrollore non è sufficiente a far scattare affabilmente un relè da 3,3 o da 5 V. Secondo il Data sheet dell’ESP32 i livelli LOW e HIGH valgono rispettivamente il 30% e il 70% del voltaggio di esercizio (pari a 3.3 V), ovvero 1 V e 2,3 V. HIGH è quindi troppo basso per azionare il relè, e abbiamo quindi bisogno di amplificare tale valore. Lo faremo con un semplice transistor.
Dato che questa operazione di amplificazione del segnale ci servirà più volte, ci costruiamo una batteria di amplificatori secondo quanto avevamo descritto in un precedente post. Attenzione però: questa volta invece che connetterla a GND la connettiamo a +5V: quando il microprocessore darà in segnale HIGH su un suo GPIO, il transistor “aprirà il rubinetto” e farà giungere al relè la tensione fornita (per l’appunto, +5V). Per i transistor usati e il valore della resistenza si veda quanto scritto nel post citato.
Siamo ora in grado di far partire e fermare la traslazione dando il valore HIGH o LOW ad un GPIO del nostro microcontrollore. Tuttavia a volte il ponte dovrà muoversi in una direzione, altre in quella opposta. Ci serve quindi un ulteriore elemento di controllo.
Controllo della direzione di traslazione
Questo è proprio facile: per invertire il movimento basta scambiare i poli. Dunque dobbiamo invertire le polarità che vanno ai pin 8 rosso e 2+3 rosso. Per farlo ci basta un relè bistabile a due canali. Avremo bisogno di due GPIO per dare gli impulsi di scambio (un set e un reset), e ci vorranno due transistor per portare correttamente il comando dato dai GPIO al relè.
Pertanto lo schema precedente viene modificato, includendo le componenti necessarie per l’inversione di direzione.
Il codice di test è molto semplice. Tre variabili definiscono i GPIO che useremo. Una la utilizziamo per ricordare la direzione in cui ci stiamo muovendo (assumerà valori +1 e -1).
La funzione setDirection fa si che il relè bistabile rifletta la posizione della direzione specificata come parametro.
La funzione invertDirection cambia le polarità.
La funzione test1 fa partire la traslazione e per 4 volte fa viaggiare il ponte per un secondo (la chiamata a delay attende per l’appunto un secondo senza fare nulla) e ne inverte poi la direzione. Quindi eseguendo il programma vedremo il nostro ponte fare un po’ di avanti e indietro.
const int pinTranslate = 21; // GPIO to enable translate
const int pinInverterSet = 4; // GPIO to set inverter
const int pinInverterReset = 17; // GPIO to reset inverter
int currentDirection = -1;
//
void invertDirection() {
Serial.println("inverting direction");
currentDirection=-currentDirection;
setDirection(currentDirection);
}
//
void setDirection(int d) {
Serial.print("set direction to ");
Serial.println(d);
if (d == 1) {
pulse(pinInverterSet);
} else {
pulse(pinInverterReset);
}
currentDirection = d;
lastOpMillis = millis();
}
void test1() {
// test alimentazione e inversione
digitalWrite(pinTranslate, HIGH); // avvia la traslazione
for (int i = 1; i <= 4; i++) {
delay(1000);
invertDirection();
}
digitalWrite(pinTranslate, LOW); // ferma la traslazione
}
setup(){
test1();
}
Esecuzione della traslazione fino ad un binario dato.
Ora possiamo mettere assieme i pezzi, e scrivere il codice che ci permetterà di spostare il ponte fino al binario desiderato. Se ne occuperà la funzione translate(int destination). Inizierà decidendo quale sia la direzione in cui muovere il ponte, poi farà partire la traslazione, ed entrerà in un ciclo infinito che nel quale continuerà a controllare (grazie alla checkBinari() che abbiamo scritto sopra) se ha raggiunto il binario di destinazione. Se si uscirà dal ciclo infinito (break) e sospenderà la traslazione. Sostanzialmente il corpo è il seguente:
const int pinTranslate = 21; // GPIO to enable translate
void translate(int destinazione) {
digitalWrite(pinTranslate, HIGH); // avvia la traslazione
while (1) {
if(checkBinari()==destination) break;
}
digitalWrite(pinTranslate, LOW); // ferma la traslazione
}
Fin qui abbiamo considerato il pin 3 rosso ma non il 2 rosso, che possiamo utilizzare per migliorare la precisione con cui il ponte si ferma in corrispondenza del binario. Farlo richiede poche variazioni: dovremo aggiungere un altro relè monostabile per controllare il flusso di corrente verso il pin 2 rosso, ed aggiungere un GPIO ed il relativo transistor per amplificare il segnale. Quando avviamo la traslazione diamo corrente su entrambi i pin, così tra l’altro la presa di corrente migliora. Quando raggiungiamo il binario di destinazione, dovrebbe essere sufficiente levare la corrente dal pin 3, perché al 2 dovrebbe pensarci il diedro che abbiamo discusso nel post precedente.
In realtà, come abbiamo già detto, può accadere che sull’abbrivio il ponte superi il diedro, e a quel punto continuerebbe a traslare. Per evitarlo, noi comunque leviamo corrente al pin 2 poco dopo averlo levato al 3: se si ferma grazie al diedro bene, altrimenti noi comunque lo fermiamo. Sperimentando un poco abbiamo visti che un ritardo di un decimo di secondo funziona bene. Il codice diventa allora il seguente:
const int pinTranslate = 21; // GPIO to enable translate
const int pinTranslateFine = 18; // GPIO to enable translate
void translate(int destinazione) {
digitalWrite(pinTranslate, HIGH); // avvia la traslazione dando corrente al pin 3
digitalWrite(pinTranslateFine, HIGH); // avvia la traslazione dando corrente al pin 2
while (1) {
if(checkBinari()==destination) break;
}
digitalWrite(pinTranslate, LOW); // ferma la traslazione
delay(100);
digitalWrite(pinTranslateFine, HIGH); // avvia la traslazione
}
Le cose in realtà sono leggermente più complesse: prima di avviare la traslazione debbiamo definire la direzione in cui ci muoveremo. Lo possiamo fare rilevando la posizione corrente e confrontandola con la destinazione. Se la rilevazione della posizione corrente non ha successo (perché siamo tra due binari di accesso) dobbiamo in qualche modo arrangiarci, ad esempio tenendo sempre traccia di quale sia l’ultimo binario che abbiamo incontrato. Se il ponte è stato spostato a mano nemmeno questo aiuta, e quindi non ci resta che “provare” e appena incontriamo un binario cercare di capire se stiamo andando nella direzione giusta oppure no, e in tal caso invertire la marcia.
Potremmo poi trovarci oltre i binari estremi, e in quel caso, anche se stiamo dando corrente ma siamo nella direzione sbagliata non succede nulla, perché un diodo nella piattaforma taglia la corrente: allora dobbiamo renderci conto di quale sia la situazione, ed invertire la marcia.
Il ponte potrebbe per qualche ragione (binari sporchi ad esempio) perdere contatto e stare fermo anche se noi diamo corrente: in questo caso dopo un po’ che non succede nulla meglio levare la tensione.
Tutto questo va riflesso nel codice, che quindi cresce abbastanza e non lo discutiamo qui in dettaglio.
Esecuzione della rotazione.
Per gestire la rotazione ci serve un ulteriore relè monostabile che controlli l’alimentazione del pin 3 nero: anche per questo useremo un GPIO ed un transistor. Mettendo il GPIO a HIGH la rotazione inizierà, e mettendolo a LOW terminerà. La faremo terminare quando rileveremo la presenza del ponte sul binario 4. Il codice somiglia quindi a quello della traslazione, ed è in linea di principio estremamente semplice.
const int pinRotate = 22; // GPIO to enable translate
void rotateToRestPosition() {
digitalWrite(pinRotate, HIGH); // avvia la rotazione
while (1) {
// controlla continuamente se il ponte è tornato in sede: se si esci dal ciclo
if (digitalRead(bin[4]) == HIGH) break;
}
digitalWrite(pinRotate, LOW); // ferma la rotazione
}
Anche qui ci sono alcune complicazioni. In primo luogo la rotazione va iniziata solo se il ponte è sul binario 4. Se si trova altrove, possiamo fare prima una traslazione sul 4, e poi avviare la rotazione.
Se però nel mezzo della rotazione avessimo un black out di corrente, il ponte si troverebbe in uno stato inconsistente. Per risolvere questo, scriviamo una funzione rotateToRestPosition che non controlla che il ponte sia sul binario 4 prima di partire (non può esserci, perché la piastra di rotazione è ruotata!) ed avvia comunque la rotazione fino alla posizione di riposo. Naturalmente, dato che è una procedura di emergenza, sarà nostra cura verificare che il ponte sia ben posizionato sulla piastra girevole prima di eseguirla.
Interfaccia utente
Il codice che abbiamo scritto funzionerebbe anche con un microprocessore diverso, come un Arduino, senza alcuna modifica (eccetto i numeri scelti per i GPIO). Potremmo costruire un interfaccia con dei pulsanti, uno per funzione. Arduino leggerebbe i pulsanti, ed eseguirebbe la funzione relativa. In questo modo avremmo riprodotto un equivalente del controllore originale.
Un’altra possibilità sarebbe di usare le funzioni di uno (o verosimilmente più) decoder digitale per generare il segnale che viene letto come comando dall’Arduino: potremmo allora usare una centralina digitale (Intellibox, o altro) per comandare il nostro ponte trasbordatore. Non approfondiamo questo aspetto.
Come detto, noi invece di un Arduino abbiamo scelto un ESP32, perché ha una interfaccia di rete wireless incorporata, e possiamo farlo diventare un server Web (per Arduino sarebbe possibile, ma occorrerebbe invece aggiungere dello hardware addizionale). Quindi i comandi possiamo darli da un browser su PC, tablet o smartphone, con una interfaccia che, per quanto non sia graficamente eccitante, fa il suo dovere, come si può vedere nel video con cui abbiamo aperto questa nota.
I vari comandi GO TO x servono per avviare la traslazione verso il binario x, ROTATE per effettuare la rotazione (preceduta, se necessario, da una traslazione che porti il ponte sul binario 4). RESET ROTATE è la procedura di emergenza per rimettere il cerchio rotante nella posizione di riposo. I due ON con frecce a sinistra e destra servono per dare corrente al binario attualmente sulla destra o sulla sinistra del ponte: quest’ultimo aspetto richiede però di definire delle componenti addizionali che discuteremo nella prossima puntata, quando di occuperemo del sottosistema ferroviario, mentre questa volta, come abbiamo detto in apertura, ci occupiamo solo di quello infrastrutturale.
La parte di codice per realizzare il server web e la relativa interfaccia non lo discutiamo qui: per chi vuole c’è un ottimo tutorial in proposito su randomnerd.
Invece il codice per azionare la piattaforma, completo di tutti i dettagli – inclusa la parte web – è a disposizione di chi lo vuol vedere: è scaricabile qua sotto. L’ unica modifica che è necessario apportare è l’inserimento di nome e password della rete wireless a cui ci si vuole collegare.
Per inciso, include anche una funzionalità di lampeggio di un led quando la piattaforma è in movimento: potrebbe essere utilizzato per una sorta di segnale di attenzione sul plastico.
Conclusione
Possiamo ora riassumere lo schema elettrico complessivo della parte infrastrutturale del nostro controller, mettendo assieme i vari pezzi descritti in precedenza.
Per non affollare troppo lo schema abbiamo inoltre omesso il collegamento al pin 1 Nero e i 7 collegamenti di GPIO ai pin 4-10 nero con la relativa messa a terra, che va fatta come segue. Mostriamo il pin 1 e nero ed il 4 nero. Lo schema del 4 va ripetuto per tutti i pin da 5 Nero a 10 nero.
Negli schemi la posizione dei collegamenti dei transistor al ESP32 non vanno presi “alla lettera”: il collegamento deve rispettare il GPIO dichiarato nel software. La selezione che abbiamo fatto noi nel nostro codice è ovviamente arbitraria: una diversa scelta va comunque fatta controllando la tabellina dei GPIO (non tutti sono infatti usabili per lettura e scrittura).
I relè che abbiamo usato sono i seguenti:
- Come bistabile bipolare ne utilizziamo uno a due avvolgimenti a basso voltaggio: “Bistable 5V Coil Latching Relay DPDT 2A 30VDC 1A 125VAC HFD2/005-S-L2-D” che abbiamo discusso in una nota di qualche tempo fa.
- come monostabile monopolare ne usiamo uno a 3,3 V: JCQ3F-03VDC-C, analogo a quelli che abbiamo usato per pilotare gli scambi di una stazione nascosta, ma a 3,3 V invece che a 12V. (per la verità noi usiamo una tensione a 5V che è quella necessaria per il bistabile: comunque non crea problemi su questi elementi a 3,3 V che abbiamo usato perché li avevamo già in casa).
Terminiamo ripetendo che quanto discusso riguarda il solo sottosistema di controllo del movimento del ponte. Ci resta da trattare la parte “ferroviaria” (anche se il relativo codice è già incluso in quello scaricabile sopra), ma questa sarà più semplice. Ne discutiamo nella seconda puntata: questa è già fin troppo lunga.
Note correlate:
- Ponti trasbordatori
- Ponti trasbordatori girevoli
- Ponte trasbordatore Minitrix: analisi dei cablaggi e della logica di controllo
- Realizzazione di un controllore per il ponte trasbordatore girevole Minitrix – parte 1 (questo articolo)
- Realizzazione di un controllore per il ponte trasbordatore girevole Minitrix – parte 2
Lascia un commento