Upgrade ICE 2

Messaggio

#1 Messaggio da **Fidax** » 5 febbraio 2019, 12:51

Buongiorno a tutti, in questo thread vorrei descrivere la procedura di upgrade a cui sto sottoponendo il mio ICE 2 36711 (dalle quello che ho letto è pressochè uguale al 36712, pertanto presumo che questa procedura possa essere applicata anche al 36712 senza particolari complicazioni) per per renderlo più simile al suo fratello ICE 1 di fascia superiore.
La procedura sarà divisa in fasi che verranno aggiunte nel tempo fino a quando il lavoro non sarà ultimato.
Vi ringrazio per la lettura e qualsiasi consiglio sarà ben accetto; memore dei danni fatti sulla BR81, ho deciso di fare ricorso il più possibile ai pezzi originali.

FASE 1: Sostituzione elettronica interna e nuovo Decoder mSD3
Cominciamo dalla locomotiva, al suo interno è presente un decoder motorola e un piccolo generatore sonoro con un "tromba" ed un "annuncio di stazione", il mio intento è quello di sostituirlo con un più efficiente mSD3.
Per iniziare smontiamo la locomotiva:
nella parte inferiore del telaio è presente una fessura proprio vicino al mantice

WP_20190205_09_48_49_Pro.jpg

prendiamo un piccolo cacciavite a punta piatta e spingendolo dentro la fessura

WP_20190205_09_49_06_Pro.jpg

andremo ad allontanare il mantice dal mantello

WP_20190205_09_49_26_Pro.jpg

fatto questo con le dita si sfila il mantice

WP_20190205_09_49_34_Pro.jpg

si solleva poi il mantello

WP_20190205_09_49_42_Pro.jpg

e avremo davanti l'elettronica della locomotiva

WP_20190205_09_49_47_Pro.jpg

Il kit che andrò ad utilizzare è il 60979. ( https://www.maerklin.de/en/products/det ... cle/60979/ )
Come è possibile vedere, la scheda del 60979 ha forma molto simile ed inoltre le viti sono posizionate nella medesima posizione

WP_20190205_09_52_02_Pro.jpg

Prima di procedere ho fatto due foto di "backup" per sapere dove erano posizionati i fili in partenza, se mai avessi bisogno di rimettere l'elettronica orginale:

WP_20190205_09_54_45_Pro.jpg

WP_20190205_09_57_16_Pro.jpg

Dopo le foto ho proceduto a dissaldare i fili provenienti dal pattino (filo rosso), dai carrelli (fili marroni), quelli che comandavano le luci (arancione e grigio) e quelli per l'altoparlante (rosso e nero); ho lasciato i fili che collegavano il decoder motorola al modulo sonoro perchè non ho intenzione di riutilizzare quei pezzi.

***NOTA: Il forum non mi permette di inserire più di 10 allegati, continuo nel messaggio successivo***

#2 Messaggio da **Fidax** » 5 febbraio 2019, 12:58

Ho proceduto poi a rimuovere l'altoparlante, con un cacciavite a punta piatta ho tolto la staffa che lo teneva fissato

WP_20190205_10_02_17_Pro.jpg

e ho poi provveduto ad alzare il vecchio altoparlante dal suo allogiamento

WP_20190205_10_02_27_Pro.jpg

WP_20190205_10_03_03_Pro.jpg

Ho poi svitato la scheda originale mantendo attaccato ad essa il motore

WP_20190205_10_04_46_Pro.jpg

WP_20190205_10_04_50_Pro.jpg

WP_20190205_10_13_50_Pro.jpg

WP_20190205_10_14_12_Pro.jpg

La nuova scheda posizionata nella locomotiva

WP_20190205_10_20_10_Pro.jpg

WP_20190205_10_21_15_Pro.jpg

per finire i fili bianchi dell'altoparlante sono stati portati nel futuro alloggiamento mediante il foro già presente

WP_20190205_10_22_00_Pro.jpg

***NOTA: continua nel messaggio successivo***

#3 Messaggio da **Fidax** » 5 febbraio 2019, 13:06

Un dettaglio sui fili bianchi già saldati di fabbrica sulla nuova scheda

WP_20190205_10_24_35_Pro.jpg

QUI HO INCONTRATO UN SERIO PROBLEMA:
la scheda seppur molto simile, una volta avvitata si è incurvata un poco e si è crepata vicino ad una vite (devo aver stretto troppo)

WP_20190205_10_24_46_Pro.jpg

WP_20190205_10_48_44_Pro.jpg

la crepa ha interrotto la pista elettrica che collegava il carrello anteriore al pin della massa, ho provveduto a sistemarla con un goccio di stagno

WP_20190205_10_49_13_Pro.jpg

Ho sostituito l'altoparlante con quello nuovo (cambiava l'impedenza)

WP_20190205_10_48_33_Pro.jpg

Infine ho risaldato i fili nelle nuove piazzole seguendo gli schemi nel manuale del 60979

WP_20190205_11_13_35_Pro.jpg

WP_20190205_11_13_52_Pro.jpg

Il progetto sonoro caricato sopra è quello dell' ICE 1 a cui ho tolto l'inversione delle luci in quanto questo modello non ha le rosse.

Testato sui binari il modello si comporta in maniera ottima, ho dovuto abbassare il volume dei suoni perchè tendeva un po' a gracchiare.

Fase 1 terminata.

Sergio Boaro · #4 Messaggio da **Sergio Boaro** » 5 febbraio 2019, 16:13

Salve hai fatto un buon lavoro, ma gli 8 Ohm del nuovo altoparlante devono coincidere con il finale del nuovo decoder altrimenti potresti avere delle sorprese, intanto hai fatto bene a diminuire il volume. Un controllo delle caratteristiche d'uscita audio del decoder è necessario, se sono predisposte per gli 8 Ohm tutto ok

saluti.

#5 Messaggio da **Fidax** » 5 febbraio 2019, 16:17

Il nuovo altoparlante era incluso insieme al decoder, inoltre gli mSD3 da specifica pilotano sia i 4 che gli 8Ohm

#6 Messaggio da **Fidax** » 6 febbraio 2019, 11:59

Piccolo aggiornamento della Fase 1
Ho notato dei comportamenti strani nelle luci.
Io ho saldato il filo grigio (da specifica marklin indica la luce anteriore) nella seconda piazzola come indicato nel manuale [Disegno di destra, piazzole in alto a sinistra]:

Screenshot (95).png

Tuttavia credo che questa scheda nelle locomotive per cui è realizzata (le start up 36xxx) venga montata invertita di 180 gradi, e pertanto collegando il filo grigio alla piazzola indicata, le luci che dovrebbero essere le "anteriori" si accendono con la direzione invertita, come se fossero luci "posteriori".
Nulla di grave, senza toccare il filo saldato basta ruotare di 90 gradi il ponticello 2:

Screenshot (96).png

WP_20190206_11_40_01_Pro.jpg

Infine è stato riscontrato un problema sull'intesità luminosa, le luci risultano molto "basse", ciò è dovuto ad una resistenza da 5,6KOhm inserita sulla pista delle luci.
La risolverò più avanti con l'aggiunta delle luci rosse ed il terzo faro indipendente

WP_20190206_11_40_07_Pro.jpg

#7 Messaggio da **Fidax** » 10 febbraio 2019, 9:49

E' online il video della fase 1:

fulvio · #8 Messaggio da **fulvio** » 10 febbraio 2019, 16:51

Mi piacciono molto i lavori che fai, sono anche ben spiegati, complimenti

Salutoni

#9 Messaggio da **Fidax** » 10 febbraio 2019, 16:58

Grazie Fulvio, detto da te che di lavori e piccole elaborazioni ne fai molte fa ancora più piacere.
Questa era la fase 1, ne ho preventivate 6 in totale, con un tempo di realizzazione di qualche mese, spero che alla fine il gioco sia valsa la candela

#10 Messaggio da **Fidax** » 14 febbraio 2019, 19:18

A poca distanza dalla fase 1 (in quanto portate avanti in parallelo), ecco la 2.

FASE 2: Illuminazione carrozze intermedie
Le carrozze presenti nel set sono sprovviste di illuminazione interna, inoltre gli interni sono semplificati; la fattura complessiva però è pregevole per il prezzo del set (circa 200€ per 4 elementi), pertanto reputo uno spreco lasciare queste carrozze buie.
NOTA: Le immagini sono state scattate durante i lavori alla carrozza di prima classe, per la carrozza ristorante la procedura è identica.

WP_20190208_11_36_54_Pro.jpg

Per lo smontaggio procediamo come per la locomotiva: con un cacciavite facciamo pressione nelle apposite fessure:

WP_20190208_11_37_24_Pro.jpg

rimuoviamo i mantici e tranquillamente con le dita allontaniamo il mantello dal sotto cassa

WP_20190208_11_38_05_Pro.jpg

il mantello si sfila poi verticalmente

WP_20190208_11_38_16_Pro.jpg

procediamo a rimuovere la base degli interni tramite gli appositi gancetti presenti alle estremità

WP_20190208_11_38_48_Pro.jpg

WP_20190208_11_38_57_Pro.jpg

Cominciamo dal sottocassa

WP_20190208_11_39_13_Pro.jpg

dobbiamo sostituire i ganci con quelli conduttori di corrente del fratello maggiore ICE 1

WP_20190208_11_42_51_Pro.jpg

togliamo la molla facendo attenzione nel riporla in un posto sicuro

WP_20190208_11_43_35_Pro.jpg

Per rimuovere il gancio è necessario sollevare le estremità e farlo ruotare su se stesso nel tentativo di farlo uscire dalla sede (l'immagine sarà più chiara)

WP_20190208_11_43_45_Pro.jpg

***NOTA: continua nel messaggio successivo***

#11 Messaggio da **Fidax** » 14 febbraio 2019, 19:36

Il nuovo gancio, con la molla rimessa nella sua sede si presenterà così:

WP_20190208_11_45_08_Pro.jpg

Inseriamo poi nel carrello lato bagno (useremo quello spazio per il circuito di alimentazione) la presa di corrente 72050

WP_20190208_11_48_26_Pro.jpg

rimontiamo il carrello e avremo il filo proveniente dalla molletta di massa che "sbucherà" nella carrozza

WP_20190208_11_48_32_Pro.jpg

A questo punto, prima di rimontare la base degli interni ho provveduto a ridipingerla, per i colori mi sono basato sulle foto reperite su questo sito: https://www.vagonweb.cz/fotogalerie/D/DB_402.php che dovrebbero essere state scattate proprio su un ICE 2.

WP_20190208_11_48_43_Pro.jpg

WP_20190208_11_48_45_Pro.jpg

Il circuito di alimentazione è così composto: ponte di diodi (dei due pin di input (caratterizzati dal simbolo della corrente alternata):un pin alla condotta di alimentazione passante, l'altro alla molletta di massa, è indifferente il collegamento, i pin di uscita invece avranno i simboli + e - ed essi vano rispettati), condensatore tampone da 470uf per 25v, connettore JST PH.

WP_20190208_11_48_56_Pro.jpg

Putroppo non avevo i fili del colore giusto e quindi ho usato quello che avevo in casa.
Stando a questo thread: https://www.marklin-users.net/forum/yaf ... post395999 guardando da dietro la locomotiva avremmo la condotta per le luci sulla destra e quella che porterà il pattino di coda a sinistra.
Ho quindi provveduto a collegare i due ganci nel lato di sinistra in maniera diretta con un filo bianco

WP_20190208_12_34_01_Pro.jpg

WP_20190208_12_34_04_Pro.jpg

l'altro lato invece sarà collegato con un filo verde al pin del ponte di diodi, quindi avremmo: gancio, ponte di diodi in cui finiscono entrambi i fili e poi l'altro gancio

WP_20190208_12_34_10_Pro.jpg

***NOTA: continua nel messaggio successivo***

#12 Messaggio da **Fidax** » 14 febbraio 2019, 19:57

ho utilizzato le sedi nelle paratie di fine carrozza per far passare i fili e tenerli tesi in modo tale che non si vedessero

WP_20190208_12_34_04_Pro - Copia.jpg

WP_20190208_12_34_13_Pro.jpg

Per unire il circuito al tetto ho usato un connettore JST PH, un po' ingombrante ma facile da gestire e da saldarci sopra, volendo è anche possibile usare un JST SH (lo stesso usato per i moduli SUSI) ma è molto più piccolo e avrebbe richiesto una grande bravura nell'esecuzione delle saldature.
Il connettore l'ho acquistato con i fili già crimpati (4€ 10 connettori completi: 10 maschi e 10 femmina con fili già crimpati) nel caso si avesse già la pinza crimpatrice è possibile fabbricarseli da sè.

femmina.jpg

maschio.jpg

Come organo luminoso ho usato una striscia da 12v Bianco Neutro/Naturale (è una gradazione diversa che ho scoperto da poco, diversa dal bianco freddo e dal bianco clado).
Come base su cui applicarla ho usato una striscia di plasticard, questo perchè il sottotetto ha degli spessori strutturali che non permettevano l'installazone direttamente sul mantello.
La striscia è stata messa lateralmente rispetto al plasticard, che a sua volta è decentrato, così la striscia risulterà abbastanza centrata e si avrà spazio per una resistenza di sicurezza.

WP_20190208_12_35_07_Pro.jpg

WP_20190208_12_35_10_Pro.jpg

Come resistenza ne ho usata una da 1KOhm per 2watt (il valore è a piacere, il "1KOhm" lo uso come standard e mi piace, per qualcuno potrebbe risultare troppo luminoso l'effetto finale, basterà alzare il valore della resistenza a piacere per rimediare).
La resistenza non ha un verso specifico, io l'ho inserita fra il filo positivo + e la piazzola del + nella striscia, il filo nero - è invece collegato alle piazzole negative della striscia.
ATTENZIONE: Qualcuno potrebbe dire che manca un regolatore di tensione 7812, in seguito ai test svolti, con una tensione a valle del ponte di diodi di circa 20v, alla striscia led grazie alla resistenza arrivano circa 10v (Più che sufficienti per accendere i 3 led in serie: essendo in serie hanno bisogno di 3 x 3v (caduta di tensione del singolo diodo) = 9v) facendo passare circa 10mA di corrente.

Non ci resta che connettere i connettori ed il lavoro è concluso.

***NOTA: continua nel messaggio successivo***

#13 Messaggio da **Fidax** » 14 febbraio 2019, 20:03

Nel video non si vede la carrozza ristorante ricolorata (la ricolorazione è avvenuta dopo le riprese), vi lascio qualche foto

WP_20190214_15_31_34_Pro.jpg

WP_20190214_15_31_45_Pro.jpg

scompartimento.jpg

WP_20190214_15_57_47_Pro.jpg

Di seguito delle foto della carrozza iluminata
NOTA: dalle foto la luce interna sembra gialla, ma è un gioco di luce dovuto alla stanza attorno che era "azzurrina" e la foto è venuta sbilanciata.

WP_20190214_17_13_24_Pro.jpg

WP_20190214_17_13_37_Pro.jpg

WP_20190214_17_13_51_Pro.jpg

La luce montata è la stessa della carrozza di prima classe, e dal video ne avrete la conferma, solo le foto sono venute "gialle"

#14 Messaggio da **Fidax** » 14 febbraio 2019, 20:05

Qui il video della FASE 2:

NOTA: Nel video la carrozza RIstorante non è ancora stata dipinta

#15 Messaggio da **Fidax** » 5 marzo 2019, 21:14

FASE 3a: Commutazione del pattino e predisposzione relè per l'illuminazione interna (Carrozza Pilota)
Per seguire la divisione con cui verranno pubblicati i video, la fase 3a riguarderà la carrozza pilota.

Si procede con lo smontaggio della stessa, procedura analoga a quella per le altre carrozze:

WP_20190214_22_06_05_Pro.jpg

attenzione al muso davanti, che va separato delicatamente dalla struttura sotto

WP_20190214_22_08_25_Pro.jpg

Avevo già tentato di realizzare un'illuminazione interna appoggiandomi all'elettronica originale, le seguenti foto sono solo di backup

WP_20190214_22_08_52_Pro.jpg

WP_20190214_22_09_23_Pro.jpg

Ho provveduto a dipingere gli interni seguendo le stesse foto (questa volta delle vetture di seconda classe) usate nella fase 2:

WP_20190218_14_03_56_Pro.jpg

WP_20190218_14_03_59_Pro.jpg

Iniziamo con l'elaborazione elettronica, ho rimosso tutti i circuiti originali (comprese le luci) e ho inserito un ponte di diodi, ed in serie un 7805 per avere una tensione di 5volt.
I colori sono:
- marrone (pin in alto a sinistra del ponte di diodi): collegamento alla massa
- fili bianco e nero (pin destra ponte di diodi): pattino che arriva dal carrello posteriore [il filo nero arriva dal carrello posteriore, il bianco porterà il pattino al relè].
- arancione: 18v in uscita dal ponte di diodi
- blu: gnd
Il filo arancione entra nel pin 1 del 7805, il filo blu nel pin 2; dal pin 3 esce una 5volt filo verde.

WP_20190218_15_42_24_Pro.jpg

Nella foto è visibile un Arduino Pro Mini, sarà lui a gestire le luci.
In questa fase 3 ha solo il compito di tenere il relè attivo per le luci interne.
Questo arduino (pagina ufficiale: https://store.arduino.cc/arduino-pro-mini ) è molto piccolo in quanto non ha il modulo USB-SERIALE da prendere a parte, per connettere questo modulo (sarà tutto ben visibile nel video) ho usato un connettore JST EH 6 per permettere una programmazione comoda.

Qui il circuito:

WP_20190221_17_17_42_Pro.jpg

WP_20190221_17_17_46_Pro.jpg

Il filo verde (la 5v) esce dal 7805 e si collega ad un condensatore da 1000uf per 6,3v e in parallelo a Arduino al pin VCC.
Immagine

[ATTENZIONE: Arduino Pro Mini esiste in due versioni: una a 5v (adatto al nostro scopo), una a 3,3v (NON adatta al nostro scopo).
Il pin VCC accetta solamente una tensione pari alla versione del modello (3,3 o 5v), il pin RAW invece accetta una tensione a 4 a 12v, il pin raw passando per un regolatore di tensione interno abbassa la tensione di circa 1v, quindi se avessi collegato la tensione del 7805 al pin raw Arduino avrebbe avuto 4v, andando a creare problemi all'oscillatore interno)]
Stessa cosa per il filo gnd: 7805 -> condensatore e arduino in parallelo.
Il filo verde finisce poi in un relè NO("normally open" = normalmente aperto: fa passare corrente solo se attivato): FRM18NA-5VDC.
Il - del relè (filo giallo) finisce poi in uno dei pin di arduino, il 6 in questo caso.

Nella zona sinistra del relè è visibile un filo bianco che arriva dal ponte di diodi (nonostante il colore sbagliato questo filo è un prolungamento del pattino!) entra nel relè ma si sdoppia e cambiando colore in marrone/bianco va verso il retro della carrozza, questo filo alimenterà la condotta di "servizio" (quella di sinistra guardando verso la locomotiva) per l'inversione del pattino; dal pin centrale del relè un filo bianco va alla condotta per le luci interne (condotta di destra).

Dettaglio della zona posteriore:

WP_20190222_12_20_23_Pro.jpg

Sono visibili i seguenti fili:
- nero: arriva dal pattino della carrozza e va al ponte di diodi nella zona anteriore
- arancione: arriva dal pin della massa del ponte di diodi, fornisce la massa al circuito che alimenta le luci interne
- marrone/bianco: arriva dal relè (pin in entrata, è un prolungamento del nero) alimenta la condotta di servizio per l'inversione del pattino
- bianco: arriva dal relè (pin in uscita dal relè) e serve per alimentare la condotta delle luci interne e le luci interne della carrozza stessa.
Sono poi visibili un altro ponte di diodi ed un altro condensatore per alimentare la striscia di led.
Fra il ponte di diodi e il relè ci sono un filo arancione ed uno blu e sono il + ed il - (stesso schema visto sulle carrozze intermedie).

Chiedo scusa per i colori non conformi allo standard, è difficile avere colori per tutti questi collegamenti; ho cercato di avere criterio utilizzando materiale di recupero.

FASE 3a TERMINATA

#16 Messaggio da **Fidax** » 5 marzo 2019, 21:27

FASE 3b: Commutazione del pattino (Locomotiva)
La locomotiva presenta un supporto inutilizzato nella zona posteriore,

WP_20190222_14_58_33_Pro.jpg

va rimosso per arrivare al sostegno del gancio (andrà modificato in quanto non avente contatti elettrici), su questo supprto nero è anche presente la molla (nella foto non visibile):

WP_20190222_14_58_41_Pro.jpg

anche lui si può rimuovere facendo delicatamente leva, si arriva al gancio, che senza il sostegno nero risulta solo appoggiato e si può sfilare senza difficoltà

WP_20190222_15_02_03_Pro.jpg

WP_20190222_15_02_09_Pro.jpg

Questa foto mostra come il gancio della locomotiva sia diverso da quello delle carrozze:

WP_20190222_15_02_17_Pro.jpg

Purtroppo il set 36711 ( temo anche 36712) hanno il telaio della locomotiva diverso da quello degli ICE 1, e anche il gancio della locomotiva è diverso, non esiste un gancio "originale" che abbia i contatti come servono a noi.
Niente panico, si può facilmente rimediare con l'utilizzo di una stampante 3D: si va a creare una "maglia" della forma del gancio, ma poco poco più grnade, quel tanto che basta per avere il gioco necessario ad infilarla sul gancio:

WP_20190225_11_44_33_Pro.jpg

Andiamo poi a rimuovere con l'ausilio di un cutter i contatti metallici da un gancio per vagoni

WP_20190225_11_54_49_Pro.jpg

e infiliamo i contatti sul gancio della locomotiva avvolti dalla "maglia"

WP_20190225_12_09_13_Pro.jpg

Si saldano i fili, in qusto caso mi interessava solo quello per il pattino, e ho dipinto la maglia con un color grigio metallizato per nasconderla

WP_20190225_12_16_34_Pro.jpg

Io ho utilizzato un pezzo stampato in 3d, ma credo sia una solzione altrettanto valida usare una guaina termorestringente che avvolga i contatti per tenerli in posizione.

***NOTA: continua nel messaggio successivo***

#17 Messaggio da **Fidax** » 5 marzo 2019, 21:49

Per ricavare spazio ho utilizzato della plasticard inserita come piattaforma rialzata nella zona anteriore: ha delle scanalature sui lati per permettere la chiusura della carrozzeria ed è rialzata per non interferire con l'albero di trasmissione

WP_20190223_17_57_19_Pro.jpg

e un'altra striscia di plasticard incollata sul sostegno bianco posteriore

WP_20190223_17_57_31_Pro.jpg

Nella zona posteriore ho posizionato un altro 7805 e un altro condensatore da 1000uf per i soliti 6,3v.
Per alimentare questi componenti, non volendo saldare sulla scheda logica, ho utilizzato il connettore SUSI che fornisce sia i 18v che il GND

WP_20190224_14_58_54_Pro.jpg

Dei 4 fili, i due della susi li ho momentaneamente isolati e bloccati sulla piattaforma anteriore

WP_20190224_14_59_06_Pro.jpg

ATTENZIONE: anche se questi due fili trasmettono una tensione logica a 5v, se dovessero toccare qualche componente potrebbero rovinare in maniera permanente il decoder! Vanno isolati e fissati saldamente.

Sui componenti posteriori ho portato il filo rosso (proveniente dalla SUSI, il +) al pin in ingresso del 7805, il filo bianco (proveniente dalla SUSI, è il GND) al pin centrale del 7805 (da qui esce come colore blu!) e sempre dal 7805 esce il 5v come filo verde

WP_20190224_14_59_19_Pro.jpg

Ho poi inserito un relè HF41F/005-ZS con configurazione "SPDT":

SPDT-relay-diagram.png

i relè SPDT hanno un pin "in comune" chiamato COM, e poi due pin che si alternano, il pin NC è quello a cui è connesso il com quando il relè non è alimentato, il pin NO invece viene a connettersi al com solo se il relè è alimentato; una volta che il relè viene disalimentato il com si ricollega al nc.
Questo serve perchè: al COM è connessa la scheda logica, al NC il pattino anteriore e al NO il pattino della carrozza pilota.
In una situazione normale il pattino anteriore è collegato alla scheda logica tramite il relè, quando il relè si attiva, viene sconnesso il NC (ossia il pattino anteriore) e connesso il NO (il pattino anteriore).
Se per caso il pattino posteriore dovesse perdere l'alimentazione, il decoder non venendo alimentato toglie corrente al relè che commutando sul NC prenderà momentaneamente corrente dal pattino della locomotiva facendo superare il pezzo di binario senza alimentazione.

Il relè sulla locomotiva:

WP_20190226_16_09_30_Pro.jpg

il pin di sinistra è collegato al gancio, il centrale è il com ed è connesso alla scheda logica, quello di destra arriva dal pattino anteriore.
Il relè viene controllato dalla AUX3 (filo marrone)

WP_20190226_16_09_36_Pro.jpg

qui i dettagli dei fili che passano accanto al motore:

WP_20190226_16_09_41_Pro.jpg

FASE 3b TERMINATA

#18 Messaggio da **Fidax** » 5 marzo 2019, 22:13

Riflessioni sulla FASE3
Il relè usato è di tipo monostabile alimentato a 5v, quindi va tenuto alimentato per mantenre la commmutazione, se questo sistema dovesse venire usato in plastici con sezioni di frenata tramite moduli di frenatura che modificano la tensione captata, e se la tensione scendesse sotto i 5v il relè si disattiverebbe facendo prendere corrente alla locomotiva ed ingonrando la tratta di blocco.
E' necessario allora usare un relè bistabile (per esempio questo: G6EK-134P-US-5DC , NOTA: questo modello è un esempio in quanto SDPT Bistabile alimentato a 5v, ma NON sono certo che si ci stia!) il quale ha bisogno di corrente solo nel momento in cui commuta, ma poi rimane nella posizione fino alla prossima commutazione, in modo tale che la locomotiva NON ignori la sezione frenante e si fermi correttamente.
Nei plastici digitali controllati dai pc e dove quindi la frenata è data lato software il relè che ho usato va bene e non intereferisce con il funzionamento.

Un'altra nota importante:
la commutazione del relè può avvenire tramite semplice inversione della direzione, oppure mediante una funzione.
Se dovessimo mappare la AUX3 come "attiva" quando si inverte la direzione, la locomotiva NON POTRA' GIRARE DA SOLA in quanto nel momento in cui dovesse girare da sola, se invertissimo la marcia senza carrozza pilota, il relè cercherebbe di far prendere corrente dal pattino posteriore, non trovandolo il decoder perderebbe l'alimentazione e il relè tornerebbe a riposo, riattivato il pattino anteriore, il decoder avendo la direzione invertita rialimenterebbe il relè provocando un loop infinito che danneggia relè e decoder.
Io ho adottato la soluzione di connettere il relè ad una funzione, se essa è attiva e la direzione è invertita il relè si attiva, se la funzione è disattivata, ma la direzione è invertita, il relè non si attiva permettendo alla locomotiva di girare isolata.

Sono considerazione che riguardano un numero isolato di casi, ma è bene far presente queste eccezioni.

Vi ringrazio per l'attnzione e vi comunicherò quando i video della Fase 3 saranno online, per ora inizio a lavorare alla fase 4: inversione delle luci tramite senso di marcia e luci Bianche e Rosse

fulvio · #19 Messaggio da **fulvio** » 6 marzo 2019, 18:39

Caspita che bel lavoro, complimenti anche per la descrizione molto accurata

non conosco Arduino ma penso di vedere in futuro.....
Salutoni

#20 Messaggio da **Fidax** » 6 marzo 2019, 20:39

Arduino ha molte potenzialità in quanto scrivendo il codice siamo noi a dirgli che cosa fare, nessun firmware pre impostato o simile.

Ha però delle limitazioni:

Dimensioni generose, anche con i Nano o i Pro Mini

Originali sono 20€ a scheda, io uso dei cloni a 5€ l'uno, ma il clone può avere problemi come:
- mancanza del bootloader (non si connette al pc per caricare sopra i programmi)
- convertitore USB-Seriale economico che può richiedere un driver speciale
- componenti usati non conformi alle specifiche (per esempio potrebbe non erogare i 40mA massimi dell'arduino originale)

Lavora a 5v (di solito, esistono anche versioni a 3,3v) quindi ci vuole un circuito di alimentazione che eroghi i 5v, e Arduino potrà pilotare direttamente solo carichi a 5v [E' possibile pilotare carichi più grandi usando transistor o relè, ma oltre ad una maggiore complessità del circuito, esso stesso diventa ingombrante e lo spazio è sempre poco

Non esistono librerie per tutto, un esempio è che non esiste (ad oggi mentre scrivo) una libreria che interpreti il segnale SUSI del decoder

Lavorando a 5v non può essere usato direttamente come decoder connesso alle rotaie, ma ne è in grado:
- esiste una community che usa arduino per il dcc, sia come centrale che come decoder (di quest'ultimo non ne sono certo)
- In rete ho trovato un progetto che permetteva di usare arduino come decoder motorola (NON MFX!!!), sarebbe curioso sapere se funziona

Per quanto siano presenti molte guide, il suo utilizzo implica conoscere le basi della programmazione informatica, non tutti possono avere voglia di studiarle

Non voglio in alcun modo spaventare o far ripensare coloro che erano interessati ad avvicinarsi a questo mondo, io stesso l'ho scoperto pochi mesi fa e ne sono rimasto affascinato dalle possibilità illimitate (sempre spazio permettendo) che offre.

#21 Messaggio da **Admin** » 7 marzo 2019, 0:07

Questo tutorial mi ha interessato parecchio. Non ho le competenze per eseguire tutte le fasi ma il prossimo autunno metterò in pratica perlomeno le fasi 1 e 2

GRAZIE

ps Luca : ricordo che hai fatto altri tutorial di questo genere, puoi, per cortesia, evidenziarli (anche solo con un messaggio generico) vorrei raggrupparli

#22 Messaggio da **Fidax** » 7 marzo 2019, 5:44

Grazie davvero, mi fa molto piacere stiate apprezzando o anche solo incuriosendo.

Ho cercato fra le discussioni e i due "tutorial" che mi sono sembrati degni di nota e curiosi sono i seguenti:

Convertire un'iscita logica in fisica (nei decoder 21mtc non Märklin): viewtopic.php?f=70&t=11490

Montare un pattino sotto le carrozze UIC-X (versione con carrelli fiat): viewtopic.php?f=64&t=11797

Ne avevo creato un altro su un lavoro di upgrade per una BR81 ma con risultati tutt'altro che buoni, avevo sottovalutato la cassa in metallo e un cortocircuito aveva rovinato il decoder, ho optato per tornare alle origini, non te lo riporterei.

#23 Messaggio da **eroncelli** » 7 marzo 2019, 15:00

Qui alcune applicazioni con Arduino:
https://forum.rocrail.net/viewforum.php ... 7a8d8ac696
https://www.marklin-user...ommand-station--Railuino (control station completa)

#24 Messaggio da **Admin** » 7 marzo 2019, 20:39

@Eugenio:

Questa ?
https://www.marklin-users.net/forum/pos ... --Railuino

#25 Messaggio da **eroncelli** » 8 marzo 2019, 9:03

Sì, purtroppo con link "lunghi" vengono fatti tagli di lettere "a caso" (misteri di fede dei SW)

#26 Messaggio da **Fidax** » 24 marzo 2019, 9:00

E' Online il video della Fase 3A:

#27 Messaggio da **Fidax** » 31 marzo 2019, 9:28

È online il video sulla Fase 3B:

Colgo l'occasione per avvisarvi per la fase 4 subirà un ritardo e pertanto salterà la regolare pubblicazione di "un video ogni 3 settimane".

fulvio · #28 Messaggio da **fulvio** » 31 marzo 2019, 18:23

Stai facendo degli ottimi lavori, complimenti, anche per il video

Salutoni

#29 Messaggio da **Fidax** » 31 marzo 2019, 19:16

Grazie Fulvio, faccio di tutto per essere all'altezza di questo forum!

A scopo dimostrativo voglio condividere un piccolo spoiler sulla Fase 4, appena sarà pronta la spiegherò il meglio possibile.

Screenshot (180).png

Screenshot (181).png

fulvio · #30 Messaggio da **fulvio** » 1 aprile 2019, 19:08

Aspettiamo, non abbiamo fretta

Salutoni

#31 Messaggio da **Admin** » 1 aprile 2019, 19:32

Ottimo. Molto ben fatto. GRAZIE

#32 Messaggio da **Fidax** » 4 giugno 2019, 9:28

La Fase 4 sta richiedendo più tempo del previsto per via dei tempi di spedizione lunghi...

Vorrei condividere con voi il prototipo del nuovo stampato per le luci.

WP_20190604_09_05_52_Pro.jpg

Il nuovo circuito andrà a sostituirsi all'originale permettendo di avere le luci rosse ed il terzo faro indipendente.

Ho provato ad appoggiare il PCB nella sede:

WP_20190604_09_06_12_Pro.jpg

Notate nella parte posteriore dei "rettangoli", sono delle zone che andranno rimosse per consentire il posizionamento corretto.

Parlo di "prototipo" perchè il circuito è stato realizzato per ospitare un LED bicolore (bianco caldo, rosso) di tipologia vecchia e non più in produzione a quanto sembra, e quindi dovrà aggiornarlo al nuovo standard.
Colgo così l'occasione per allargare nel progetto i fori di incastro (troppo piccoli nel prototipo) e aggiungere un collegamento (facoltativo) per poter mettere il terzo faro insieme alla luci bianche (nel caso non lo si volesse indipendente).
Rimpicciolisco magari i PAD per il collegamento dei fili che mi sembrano esagerati (quelli dell'originale sono quasi la metà).

Questa sera dovei riuscire a modificarne uno per per provarne il posizionamento.

Questi hanno le piste elettriche sbagliate e non possono essere utilizzati in nessun modo.

EDIT DELLA SERA (ore 23 circa)
Ho molato (con una normale mola da ferro) quei "rettangoli" e allargato i fori per l'incastro con una punta da 1,4mm.
Questo è come si presenta il PCB:

WP_20190604_22_42_17_Pro.jpg

Il foro è ancora piccolo e non permette al PCB di entrare fino in fondo, quindi lo aumenterò a 1.5mm, poi proverò a saldare dei led che non uso per capire come si comporta il gruppo ottico delle luci.

#33 Messaggio da **Fidax** » 4 luglio 2019, 9:14

ARRIVATI I NUOVI PCB
Ho modificato il cablaggio per usare dei led più recenti, aggiunto la possibilità di mettere il terzo faro insieme alle luci bianche e corretto la posizione dei fori.
Eccoli:

WP_20190704_08_35_31_Pro.jpg

WP_20190704_08_35_25_Pro.jpg

WP_20190704_08_36_27_Pro.jpg

Ho poi provveduto a saldare i led bianchi per capire se si chiude tutto (con il vecchio progetto i led erano alti e non si chiudeva la locomotiva)

WP_20190704_09_08_54_Pro.jpg

WP_20190704_09_09_02_Pro.jpg

Piccola curiosità, questa è la dimensione dei led usati

WP_20190704_08_51_11_Pro.jpg

Sergio Boaro · #34 Messaggio da **Sergio Boaro** » 4 luglio 2019, 15:02

Molto bravo complimenti, ci vuole anche molta cura, dedizione, buona vista e pazienza che io con il passare degli anni ho perso

#35 Messaggio da **Fidax** » 4 luglio 2019, 18:03

NUOVO PICCOLO AGGIORNAMENTO
Il circuito stampato della marklin per le loco 36xxx mi gioca un altro scherzo: sulla linea elettrica delle luci posteriori è presente una resistenza da 10Kohm, mentre su quella delle luci anteriori è da 6kOhm.
Non è necessario quindi mettere una resistenza per le luci rosse, ho allora ponticellato lo spazio per l'eventuale resistenza:

WP_20190704_17_46_40_Pro.jpg

ho allora chiuso la loco e questo è l'effetto:

WP_20190704_17_48_33_Pro.jpg

Il rosso nel terzo faro è dovuto al gruppo ottico, magari lo sistemerò in futuro, per adesso mi ritengo più che soddisfatto.

P.S. La foto non rende pienamente e ha i colori un po' alterati

#36 Messaggio da **Fidax** » 16 luglio 2019, 22:56

E LUCE FU!
Arrivate le resistenze ho potuto finalmente collegare i led alle uscite del decoder/arduino; breve riassunto:

Sulla locomotiva:
- Luci Bianche: aggiunta sul pcb delle luci una resistenza da 2,2KOhm
- Luci Rosse: non aggiunta nessuna resistenza
Sulla Carrozza Pilota:
- Luci Bianche: aggiunta sul pcb delle luci una resistenza da 2,2KOhm
- Luci Rosse: aggiunta sul pcb delle luci una resistenza da 2,2KOhm

Tutte le resistenza usate hanno standard 0805, ossia 0,8mm il lato lungo, e 0,5mm il lato corto; con potenza dissipante di 1/8w.

Ecco alcune immagini:

WP_20190716_22_12_28_Pro.jpg

WP_20190716_22_12_35_Pro.jpg

WP_20190716_22_12_58_Pro.jpg

WP_20190716_22_13_04_Pro.jpg

WP_20190716_22_24_36_Pro.jpg

WP_20190716_22_30_10_Pro.jpg

Alcune piazzole sono ancora vuote perchè serviranno per il terzo faro nella fase 5.
Non appena avrò ultimato la parte software provvederò a descrivere la fase 4 nei vari dettagli

fulvio · #37 Messaggio da **fulvio** » 17 luglio 2019, 19:04

Leggo con interessi i tuoi lavori, complimenti, possono sempre essere utili

Salutoni

#38 Messaggio da **Fidax** » 22 luglio 2019, 12:11

FASE 4: Inversione Luci Bianche e Rosse
Dopo diversi mesi di attesa, vi porto ufficialmente la fase 4.
In questo thread: viewtopic.php?f=51&t=11728 chiedevo come veniva eseguita l'inversione delle luci bianche/rosse sul modello ICE 1 il quale ha un solo decoder nella locomotiva, e supermoee mi spiegava come la marklin utilizzò un Interruttore ad Inerzia per questo compito.
Nel mio piccolo ho cercato di emulare tale dispositivo mediante un accelerometro: il MPU-6050 (GY-521)

WP_20190305_16_54_24_Rich.jpg

Tale dispositivo implementa un accelerometro a 3 assi, un sensore di temperatura ed un giroscopio a 3 assi.
Per comunicare usa il bus I2C il che richiede solo 2 fili (oltre all'alimentazione) da connettere ad Arduino: i fili SDA ed SCL.

Su questo modulo a noi interessano i pin: Vcc (il normale 5v), il GND, SCL ed SDA.
Riprendendo il pinout dell'Arduino Pro Mini vediamo che i pin SCL ed SDA sono gli A4 ed A5
Immagine

Pertanto sarà nostro compito collegare il 5v che alimenta arduino al VCC, il GND al GND e i pin SCL ed SDA dell'accelerometro ai rispettivi SCL ed SDA. NON VANNO INVERTITI.
Vi allego due immagini dei collegamenti fatti

WP_20190305_17_31_41_Rich.jpg

WP_20190305_17_31_47_Rich.jpg

Come dicevo nella fase 3, per programmare l'Arduino Pro Mini è necessario un modulo FTD232 esterno, in quest'immagine è ben visibile, ricordo che è connesso mediante un connettore JST EH 6 per favorire il collegamento con il modulo FTD232 per la programmazione.

WP_20190310_21_37_11_Rich.jpg

A questo punto iniziamo a lavorare su Arduino, come prima cosa dobbiamo assicurarci che l'accelerometro venga letto correttamente, tramite l'Arduino IDE (download gratuito sul sito ufficiale: https://www.arduino.cc/en/main/software ) andremo a caricare il seguente codice:

Codice: Seleziona tutto

// i2c_scanner
//
// Version 1
//    This program (or code that looks like it)
//    can be found in many places.
//    For example on the Arduino.cc forum.
//    The original author is not know.
// Version 2, Juni 2012, Using Arduino 1.0.1
//     Adapted to be as simple as possible by Arduino.cc user Krodal
// Version 3, Feb 26  2013
//    V3 by louarnold
// Version 4, March 3, 2013, Using Arduino 1.0.3
//    by Arduino.cc user Krodal.
//    Changes by louarnold removed.
//    Scanning addresses changed from 0...127 to 1...119,
//    according to the i2c scanner by Nick Gammon
//    http://www.gammon.com.au/forum/?id=10896
// Version 5, March 28, 2013
//    As version 4, but address scans now to 127.
//    A sensor seems to use address 120.
// 
//
// This sketch tests the standard 7-bit addresses
// Devices with higher bit address might not be seen properly.
//
 
#include <Wire.h>
 
void setup(){
	Wire.begin();
	Serial.begin(115200);
	Serial.println("\nI2C Scanner");
}
 
void loop()	{
	byte error, address;
	int nDevices;
 
	Serial.println("Scanning...");
 
	nDevices = 0;
	for(address = 1; address < 127; address++ ) {
		// The i2c_scanner uses the return value of
		// the Write.endTransmisstion to see if
		// a device did acknowledge to the address.
		Wire.beginTransmission(address);
		error = Wire.endTransmission();
	 
		if (error == 0) {
			Serial.print("I2C device found at address 0x");
			if (address<16) 
				Serial.print("0");
			Serial.print(address,HEX);
			Serial.println("  !");
	 
			nDevices++;
		}
		else if (error==4) {
			Serial.print("Unknow error at address 0x");
			if (address<16) 
				Serial.print("0");
			Serial.println(address,HEX);
		}    
	}
	if (nDevices == 0)
		Serial.println("No I2C devices found\n");
	else
		Serial.println("done\n");
 
	delay(5000);           // wait 5 seconds for next scan
}

Il codice si chiama I2C Scanner e permette di localizzare tutti i dispositivi connessi al BUS I2C.

Ecco un esempio, se avremo commesso degli errori o i collegamenti non fossero corretti riceveremo il seguente risultato:

Screenshot (61).png

in caso invece avessimo fatto tutto correttamente otterremmo l'indirizzo del dispositivo:

Fase 4.00_05_18_20.Immagine002.jpg

A questo punto ci spostiamo sul PCB Luci, mediante il software Circuit Maker (l'uso è gratuito a tempo indeterminato previo iscrizione e putroppo si può lavorare solo se connessi alla rete inernet, l'uso offline non è consentito da policy di contratto; https://circuitmaker.com/ ) ho realizzato i pcb.
NOTA: Sto ancora effettuando dei miglioramenti, con la fase 5 conto di avere (finalmente!) la versione definitiva.
Ho usato componenti con lo standard 0805: ossia 0,8mm il lato lungo e 0,5mm il lato corto.
Nonostante i valori possano spaventare, munendosi di una lente di ingrandimento e di una punta per il saldatore per componenti smd con diametro di 0,3mm è possibile fare queste saldature in maniera umana.

P.S. Aggiungo che è molto importante anche uno stagno di diametro 0,5mm, altrimenti diventa difficile gestirlo.
Qui il PCB:

Screenshot (62).png

Una piccola spiegazione dello stesso:

Le PIAZZOLE:
- - VCC: Piazzola a cui connettere il Vcc oppure il Common U+
- - LIGHTBEAM: Piazzola a cui collegare la aux del terzo faro
- - RED Ls: Red LEDs (led rossi): piazzola a cui collegare la aux per le luci posteriori rosse
- - WLs: Wihte LEDs (Led bianchi): piazzole a cui collegare la aux delle luci anteriori bianche
I LED:
- - RL: Red Left (Rosso Sinistro)
- - WL: White Left (Bianco Sinistro)
- - LB: LightBeam (Terzo Faro)
- - WR: White Right (Bianco Destro)
- - RR: Red Right (Rosso Destro)
Le RESISTENZE:
- - WLR: White Led Resistor (Resistenza Led Bianchi)
- - RLR: Red Led Resistor (Resistenza Led Rossi)
- - LBR1: LightBeam Resistor 1 (Resistenza n'1 Terzo Faro)
- - LBR2: LightBeam Resistor 2 (Resistenza n'2 Terzo Faro)
Le CONNESSIONI (per "modificare" il funzionamento)
- - CONN1: Connection1 (Connessione 1): Serve per mettere il terzo faro insieme alle luci bianche, nel caso non lo si volesse indipendente
I BYPASS:
- - BYPASS1: Permette di bypassare la LBR2 e di unire la LBR1 alla piazzola LightBeam
- - BYPASS2: Permette di bypassare la resistenza RLR

I Bypass sono stati necessari per permettere l'uso del circuito sia sulla locomotiva che sulla carrozza pilota:
Sulla locomotiva i led rossi NON HANNO BISOGNO di una resistenza in quanto già presente sulla board, quindi è necessario usare il bypass2, mentre sulla pilota va inserita la RLR.
Sulla carrozza pilota il Vcc è 5v e quindi per il terzo faro basta una resistenza (LBR1) e poi va usato il bypass1; sulla locomotiva (il Vcc é il Common a 18v) ed è quindi necessaria una seconda resistenza (LBR2, oltre ad una LBR1 uguale a quella usata sulla pilota) da 6,2KOhm (uguale a quella presente sulla board, nella pista elettrica delle luci bianche).
Il discorso Terzo Faro verrà spiegato meglio nella Fase 5.

***NOTA: continua nel messaggio successivo***

#39 Messaggio da **Fidax** » 22 luglio 2019, 12:19

Passiamo a montare il PCB sulla locomotiva:

WP_20190704_17_39_49_Pro.jpg

In questa immagine è visibile un filo giallo che, da specifiche marklin, saranno le luci rosse.
Ed eccolo collegato alla piazzola per le luci posteriori:

WP_20190704_17_39_52_Pro.jpg

Come dicevo, il pcb usato non è il definito e per bypassare la resistenza RLR ho dovuto usare una colata di stagno

WP_20190704_17_46_40_Pro.jpg

ed ecco la locomotiva con le luci rosse!

WP_20190704_17_48_33_Pro.jpg

Sulla pilota il circuito non trova difficoltà nell'essere montato

WP_20190704_12_00_12_Pro.jpg

ed eccolo con i fili collegati: il verde è il 5v, il bianco le luci bianche ed il rosso le luci rosse

WP_20190704_12_14_36_Pro.jpg

Eccole le resistenze inserite:
Sulla locomtovia, bypass della RLR ed inserita la WLR da 2.2KOhm

WP_20190722_11_04_30_Pro.jpg

Sulla pilota, sia RLR che WLR hano valore di 2.2KOhm e sono inserite

WP_20190722_11_05_22_Pro.jpg

Ho intenzione di modificare i gruppi ottici e lo farò quando avrò i PCB definitivi, per ora mi reputo più che soddisfatto.

Nel messaggio successivo il codice che gestisce l'inversione delle luci!

#40 Messaggio da **Fidax** » 22 luglio 2019, 13:15

Ed eccolo, colui che mi ha fatto tribulare per giorni...
NOTA: Il codice non è perfetto, e alcune volte "fallisce", per ora funziona bene circa il 80% delle volte (non è il massimo ma è già qualcosa), ve lo riporto prima per intero e poi lo riporto frammentato per spiegarvelo il meglio possibile.
Inoltre, buona parte del codice relativo all'accelerometro l'ho preso da esempi su internet e non è mio lavoro.

THE CODE!

Codice: Seleziona tutto

#include <Wire.h>

typedef struct {
  // register accelerometer MPU-6050 GY-521
  const int8_t MPU_I2C_ADDR = 0x68; // address of the MPU-6050 device
  const int8_t ACCEL_CONFIG = 0x1C; // Accelerometer Configuration
  const int8_t ACCEL_XOUT_H = 0x3B; // Accelerometer Measurements
  const int8_t PWR_MGMT_1   = 0x6B; // Power Management 1 register address
  // accelerometer variables
  int16_t AcX,AcY,AcZ,Tmp,GyX,GyY,GyZ;
  float AcXg, AcYg, AcZg, to_g_force, correction_AcYg;
  // accelerometer full scale modes
  const int8_t AFS_SEL_2G   = 0x00;
  const int8_t AFS_SEL_4G   = 0x08;
  const int8_t AFS_SEL_8G   = 0x10;
  const int8_t AFS_SEL_16G  = 0x18;

  public:void init() {
    Wire.begin();
    Wire.beginTransmission(MPU_I2C_ADDR);   // wake up the mpu-6050 unit
    Wire.write(PWR_MGMT_1);
    Wire.write(0);
    Wire.endTransmission();
    int8_t afs_sel = AFS_SEL_2G;   // select the accelerometer full scale
    Wire.beginTransmission(MPU_I2C_ADDR);   // set the accelerometer full scale
    Wire.write(ACCEL_CONFIG);
    Wire.write(afs_sel);
    Wire.endTransmission();
    to_g_force = 1. / (16384 >> (afs_sel >> 3 & 0x03));   // set the acceleration conversion factor
  }

  private:void ReadDATA() {
    Wire.beginTransmission(MPU_I2C_ADDR);
    Wire.write(0x3B);  // starting with register 0x3B (ACCEL_XOUT_H)
    Wire.endTransmission(false);
    Wire.requestFrom(MPU_I2C_ADDR,14,true);  // request a total of 14 registers
    AcX=Wire.read()<<8|Wire.read();  // 0x3B (ACCEL_XOUT_H) & 0x3C (ACCEL_XOUT_L)
    AcY=Wire.read()<<8|Wire.read();  // 0x3D (ACCEL_YOUT_H) & 0x3E (ACCEL_YOUT_L)
    AcZ=Wire.read()<<8|Wire.read();  // 0x3F (ACCEL_ZOUT_H) & 0x40 (ACCEL_ZOUT_L)
    Tmp=Wire.read()<<8|Wire.read();  // 0x41 (TEMP_OUT_H) & 0x42 (TEMP_OUT_L)
    GyX=Wire.read()<<8|Wire.read();  // 0x43 (GYRO_XOUT_H) & 0x44 (GYRO_XOUT_L)
    GyY=Wire.read()<<8|Wire.read();  // 0x45 (GYRO_YOUT_H) & 0x46 (GYRO_YOUT_L)
    GyZ=Wire.read()<<8|Wire.read();  // 0x47 (GYRO_ZOUT_H) & 0x48 (GYRO_ZOUT_L)

    AcXg = AcX * to_g_force;
    AcYg = AcY * to_g_force;
    AcZg = AcZ * to_g_force;
  }

  public:void AutocorrectionAcYg() {
    ReadDATA();
    correction_AcYg = AcYg;
  }

  private:void UpdateDATA() {
    ReadDATA();
    if(AcYg > 0)
      AcYg -= abs(correction_AcYg);
    else
      AcYg += abs(correction_AcYg);
  }

  private:void AverageAcYg() {
    float media;
    int valore = 5;
    for(int i = 0; i < valore; i++) {
      UpdateDATA();
      media += AcYg;
      delay(50);
    }
    AcYg = (media / valore);
  }

  public:bool Reverse () { //determina se la carrozza è in coda (reverse = true) oppure in testa (reverse = false) || il reverse è rispetto alla locomotiva = locomotiva in testa (reverse false), carrozza in coda (reverse true)
    AutocorrectionAcYg();
    AverageAcYg();
    if(AcYg < 0)
      return false; //carrozza in testa, luci bianche
    else
      return true; //carrozza in coda, luci rosse
  }

  public:bool DetectMotion() {
    AutocorrectionAcYg();
    AverageAcYg();
    if(abs(AcYg) > 0.01)
      return true;
    else
      return false;
  }
} MPU6050;

MPU6050 mpu6050;

typedef struct {
  uint8_t pin; //identifica il pin a cui è connessa la aux
  bool active; //determina se la aux è ativa o no

  public:void InitAUX(uint8_t pin_i, bool active_i) { //ricevo il nome della aux, il pin e il suo stato: se è attiva o no
    pin = pin_i;
    active = active_i;
    pinMode(pin,OUTPUT); //imposto il pin per essere un OUTPUT
    AUXLevelWrite();
  }

  private:void AUXLevelWrite() { // i leds hanno il '+' in comune (a Vcc), il '-' controlla le luci. | stato: HIGH (pin a Vcc) = led spento | state: LOW (pin a GND) = led acceso
    if(active) //se la AUX è attiva
      digitalWrite(pin, LOW); //metto la aux a GND (passa corrente)
    else //se la AUX è disattiva
      digitalWrite(pin,HIGH); //metto la AUX a VCC (non passa corrente);
  }

  public:void UpdateStatus(bool active_i) {
    active = active_i;
    AUXLevelWrite();
  }
} AUX;

typedef struct {
  bool reverse; //direzione del treno: se REVERSE == TRUE la carrozza è in testa, in caso contrario è in coda
  bool lights; //identifica se la carrozza ha le luci (Bianche, rosse & Terzo Faro) accese o spente
  bool motion; //determina se la carrozza è in movimento o no;
  bool motion_old;
  AUX WLs; //aux per le luci bianche (WhiteLights)
  AUX RLs; //aux per le luci rosse (RedLights)
  AUX LB; //aux per il terzo faro (LightBeam)
  AUX CL; //aux per la luce di cabina (CabLighst)
  AUX ILs; //aux per le luci interne del treno (InteriorLights)

  public:void InitWagon(bool reverse_i, bool lights_i, bool motion_i) { //inizializzo il vagone
    reverse = reverse_i;  //imposta come direzione quella passata
    lights = lights_i;    //imposto le luci come richiesto all'inizializzazione
    motion = motion_old = motion_i;
  }
} Wagon;

Wagon Pilot;

//codice per la gestione della carrozza
void setup() {
  Pilot.InitWagon(false, true, false); //inizializzo la carrozza come: in coda (Reverse false) e con le luci accese (lights true)
  //inizializzo la aux al rispettivo pin e imposto lo stato
  Pilot.WLs.InitAUX(3, false); //luci bianche spente
  Pilot.RLs.InitAUX(5, true);  //luci rosse accese
  Pilot.ILs.InitAUX(6, true);  //luci interne carrozze accese
  Pilot.CL.InitAUX(7, false);  //luce di cabina spenta
  Pilot.LB.InitAUX(10, false); //faro di profondità spento

	mpu6050.init(); //inizializzo l' Accelerometro
  while(mpu6050.DetectMotion() == false) {}
  Pilot.motion = true;
  Pilot.reverse = mpu6050.Reverse();
  UpdateLights();
}

void loop() {
  Pilot.motion = mpu6050.DetectMotion();
  if(Pilot.motion_old == false && Pilot.motion == true) {//il mezoz si mette in moto
	  Pilot.reverse = mpu6050.Reverse(); //richiamo l'accelerometro per determinre la direzione(REVERSE) in base alle accelerazioni che la carrozza subisce
    //Aggiorno lo stato delle luci (bianche, rosse, terzo faro, luce di cabina); le luci interne sono sempre accese
    UpdateLights();
  }
  Pilot.motion_old = Pilot.motion;
  delay(500);
}

void UpdateLights() {
  int wait = 200;
  if(Pilot.lights) {
    if(Pilot.reverse) {//Reverse è ATTIVO (carrozza in TESTA), sequenza luci: accensione Luce Cabina, spegnimento luci rosse, accensione luci bianche, accensione terzo faro
      Pilot.CL.UpdateStatus(true);
      delay(wait); //inserisco una pausa subito dopo l'accensione della luce di cabina
      Pilot.RLs.UpdateStatus(false);
      Pilot.WLs.UpdateStatus(true);
      Pilot.LB.UpdateStatus(true);
    }
    else { //Reverse è DISATTIVO (carrozza in CODA), sequenza luci: spegnimento terzo faro, spegnimento luci bianche, accensione luci rosse, spegnimento Luce Cabina
      Pilot.LB.UpdateStatus(false);
      Pilot.WLs.UpdateStatus(false);
      Pilot.RLs.UpdateStatus(true);
      delay(wait); //inserisco una puasa subito prima dello spegnimento della luce di cabina
      Pilot.CL.UpdateStatus(false);
    }
  }
  else {
    Pilot.CL.UpdateStatus(false);
    Pilot.RLs.UpdateStatus(false);
    Pilot.WLs.UpdateStatus(false);
    Pilot.LB.UpdateStatus(false);
  }
}

Andiamo con ordine:

Codice: Seleziona tutto

#include <Wire.h>

Permette di includere nel "programma" la libreria Wire che gestisce il Bus I2C, senza di essa non potremmo dialogare con il nostro accelerometro.

Ho poi fatto uso delle Struct, le struct sono un modo per "creare nuovi tipi"; vi faccio un esempio: il tipo "int" indica chiaramernte un numero intero.
Io ho creato un "nuovo tipo" detto AUX che al suo interno racchiude l'informazione del PIN a cui questa AUX è collegata e se essa è attiva o no.

La prima struct che incontreremo è quella del MPU6050:

Codice: Seleziona tutto

typedef struct {
  // register accelerometer MPU-6050 GY-521
  const int8_t MPU_I2C_ADDR = 0x68; // address of the MPU-6050 device
  const int8_t ACCEL_CONFIG = 0x1C; // Accelerometer Configuration
  const int8_t ACCEL_XOUT_H = 0x3B; // Accelerometer Measurements
  const int8_t PWR_MGMT_1   = 0x6B; // Power Management 1 register address
  // accelerometer variables
  int16_t AcX,AcY,AcZ,Tmp,GyX,GyY,GyZ;
  float AcXg, AcYg, AcZg, to_g_force, correction_AcYg;
  // accelerometer full scale modes
  const int8_t AFS_SEL_2G   = 0x00;
  const int8_t AFS_SEL_4G   = 0x08;
  const int8_t AFS_SEL_8G   = 0x10;
  const int8_t AFS_SEL_16G  = 0x18;

  public:void init() {
    Wire.begin();
    Wire.beginTransmission(MPU_I2C_ADDR);   // wake up the mpu-6050 unit
    Wire.write(PWR_MGMT_1);
    Wire.write(0);
    Wire.endTransmission();
    int8_t afs_sel = AFS_SEL_2G;   // select the accelerometer full scale
    Wire.beginTransmission(MPU_I2C_ADDR);   // set the accelerometer full scale
    Wire.write(ACCEL_CONFIG);
    Wire.write(afs_sel);
    Wire.endTransmission();
    to_g_force = 1. / (16384 >> (afs_sel >> 3 & 0x03));   // set the acceleration conversion factor
  }

  public:void AutocorrectionAcYg() {
    ReadDATA();
    correction_AcYg = AcYg;
  }

  private:void ReadDATA() {
    Wire.beginTransmission(MPU_I2C_ADDR);
    Wire.write(0x3B);  // starting with register 0x3B (ACCEL_XOUT_H)
    Wire.endTransmission(false);
    Wire.requestFrom(MPU_I2C_ADDR,14,true);  // request a total of 14 registers
    AcX=Wire.read()<<8|Wire.read();  // 0x3B (ACCEL_XOUT_H) & 0x3C (ACCEL_XOUT_L)
    AcY=Wire.read()<<8|Wire.read();  // 0x3D (ACCEL_YOUT_H) & 0x3E (ACCEL_YOUT_L)
    AcZ=Wire.read()<<8|Wire.read();  // 0x3F (ACCEL_ZOUT_H) & 0x40 (ACCEL_ZOUT_L)
    Tmp=Wire.read()<<8|Wire.read();  // 0x41 (TEMP_OUT_H) & 0x42 (TEMP_OUT_L)
    GyX=Wire.read()<<8|Wire.read();  // 0x43 (GYRO_XOUT_H) & 0x44 (GYRO_XOUT_L)
    GyY=Wire.read()<<8|Wire.read();  // 0x45 (GYRO_YOUT_H) & 0x46 (GYRO_YOUT_L)
    GyZ=Wire.read()<<8|Wire.read();  // 0x47 (GYRO_ZOUT_H) & 0x48 (GYRO_ZOUT_L)

    AcXg = AcX * to_g_force;
    AcYg = AcY * to_g_force;
    AcZg = AcZ * to_g_force;
  }

  private:void UpdateDATA() {
    ReadDATA();
    if(AcYg > 0)
      AcYg -= abs(correction_AcYg);
    else
      AcYg += abs(correction_AcYg);
  }

  private:void AverageAcYg() {
    float media;
    int valore = 5;
    for(int i = 0; i < valore; i++) {
      UpdateDATA();
      media += AcYg;
      delay(50);
    }
    AcYg = (media / valore);
  }

  public:bool Reverse () { //determina se la carrozza è in coda (reverse = true) oppure in testa (reverse = false) || il reverse è rispetto alla locomotiva = locomotiva in testa (reverse false), carrozza in coda (reverse true)
    AutocorrectionAcYg();
    AverageAcYg();
    if(AcYg < 0)
      return false; //carrozza in testa, luci bianche
    else
      return true; //carrozza in coda, luci rosse
  }

  public:bool DetectMotion() {
    AutocorrectionAcYg();
    AverageAcYg();
    if(abs(AcYg) > 0.01)
      return true;
    else
      return false;
  }
} MPU6050;

Al suo interno avremo la dichiarazione delle costanti e delle variabili, ossia "zone dove sono immagazzinati i dati".

Codice: Seleziona tutto

// register accelerometer MPU-6050 GY-521
  const int8_t MPU_I2C_ADDR = 0x68; // address of the MPU-6050 device
  const int8_t ACCEL_CONFIG = 0x1C; // Accelerometer Configuration
  const int8_t ACCEL_XOUT_H = 0x3B; // Accelerometer Measurements
  const int8_t PWR_MGMT_1   = 0x6B; // Power Management 1 register address
  // accelerometer variables
  int16_t AcX,AcY,AcZ,Tmp,GyX,GyY,GyZ;
  float AcXg, AcYg, AcZg, to_g_force, correction_AcYg;
  // accelerometer full scale modes
  const int8_t AFS_SEL_2G   = 0x00;
  const int8_t AFS_SEL_4G   = 0x08;
  const int8_t AFS_SEL_8G   = 0x10;
  const int8_t AFS_SEL_16G  = 0x18;

Tutte le righe precedute dal suffisso const sono costanti e una volta definite nel codice esse non possono essere cambiate, in questo caso sono gli indirizzi per i registri che controllano l'accelerometro.
Le righe uint16_t e float invece sono normali varibili.

Il primo metodo definito Init permette di inizailizzare l'accelerometro, serve a "richiamare la sua attenzione" e a dirgli "di stare in allerta per possibili richieste"; è mia l'idea di racchiuderlo in un metodo ma il codice è preso da internet.

Codice: Seleziona tutto

  public:void init() {
    Wire.begin();
    Wire.beginTransmission(MPU_I2C_ADDR);   // wake up the mpu-6050 unit
    Wire.write(PWR_MGMT_1);
    Wire.write(0);
    Wire.endTransmission();
    int8_t afs_sel = AFS_SEL_2G;   // select the accelerometer full scale
    Wire.beginTransmission(MPU_I2C_ADDR);   // set the accelerometer full scale
    Wire.write(ACCEL_CONFIG);
    Wire.write(afs_sel);
    Wire.endTransmission();
    to_g_force = 1. / (16384 >> (afs_sel >> 3 & 0x03));   // set the acceleration conversion factor
  }

Il secondo metodo ReadDATA permette di leggere le misurazioni fatte dal accelerometro, anche qui, codice da intermet metodo mio

Codice: Seleziona tutto

  private:void ReadDATA() {
    Wire.beginTransmission(MPU_I2C_ADDR);
    Wire.write(0x3B);  // starting with register 0x3B (ACCEL_XOUT_H)
    Wire.endTransmission(false);
    Wire.requestFrom(MPU_I2C_ADDR,14,true);  // request a total of 14 registers
    AcX=Wire.read()<<8|Wire.read();  // 0x3B (ACCEL_XOUT_H) & 0x3C (ACCEL_XOUT_L)
    AcY=Wire.read()<<8|Wire.read();  // 0x3D (ACCEL_YOUT_H) & 0x3E (ACCEL_YOUT_L)
    AcZ=Wire.read()<<8|Wire.read();  // 0x3F (ACCEL_ZOUT_H) & 0x40 (ACCEL_ZOUT_L)
    Tmp=Wire.read()<<8|Wire.read();  // 0x41 (TEMP_OUT_H) & 0x42 (TEMP_OUT_L)
    GyX=Wire.read()<<8|Wire.read();  // 0x43 (GYRO_XOUT_H) & 0x44 (GYRO_XOUT_L)
    GyY=Wire.read()<<8|Wire.read();  // 0x45 (GYRO_YOUT_H) & 0x46 (GYRO_YOUT_L)
    GyZ=Wire.read()<<8|Wire.read();  // 0x47 (GYRO_ZOUT_H) & 0x48 (GYRO_ZOUT_L)

    AcXg = AcX * to_g_force;
    AcYg = AcY * to_g_force;
    AcZg = AcZ * to_g_force;
  }

Il terzo metodo AutocorrectonAcYg permette di definire un valore di misurazione "sporca" (ossia quel valore che dovrebbe essere 0 ma non lo è a causa di errori e di disturbi) andando a leggere una misura (si ipotizza maggiore di 0) e memorizzarla nella variabile "correction_AcYg"

Codice: Seleziona tutto

  public:void AutocorrectionAcYg() {
    ReadDATA();
    correction_AcYg = AcYg;
  }

Quarto metodo UpdateDATA permette di aggiornare i valori memorizzati in arduino delle misurazioni ed inoltre corregge AcYg tramite il valore di correzione determinato nel metodo 3 (tale valore può essere sia > che < di 0, pertanto mi semplifico la vita facendo il valore assoluto di tale misura con la funzione abs()).

Codice: Seleziona tutto

  private:void UpdateDATA() {
    ReadDATA();
    if(AcYg > 0)
      AcYg -= abs(correction_AcYg);
    else
      AcYg += abs(correction_AcYg);
  }

Quinto metodo AverageAcYg(), una sola misura può contenere errori, quindi ho deciso di fare una media di 5 misure e tale media la salvo nella variabile AcYg

Codice: Seleziona tutto

  private:void AverageAcYg() {
    float media;
    int valore = 5;
    for(int i = 0; i < valore; i++) {
      UpdateDATA();
      media += AcYg;
      delay(50);
    }
    AcYg = (media / valore);
  }

Sesto metodo Reverse, come dice il nome permette di capire la direzione in cui si muove la carrozza

Codice: Seleziona tutto

  public:bool Reverse () { //determina se la carrozza è in coda (reverse = true) oppure in testa (reverse = false) || il reverse è rispetto alla locomotiva = locomotiva in testa (reverse false), carrozza in coda (reverse true)
    AutocorrectionAcYg();
    AverageAcYg();
    if(AcYg < 0)
      return false; //carrozza in testa, luci bianche
    else
      return true; //carrozza in coda, luci rosse
  }

Settimo metodo DetectMotion, anche qui, come dice il nome, permette di capire se la carrozza è in movimento

Codice: Seleziona tutto

  public:bool DetectMotion() {
    AutocorrectionAcYg();
    AverageAcYg();
    if(abs(AcYg) > 0.01)
      return true;
    else
      return false;
  }

Finita la struct, creo una varibile di tipo MPU6050 e gli assegno il nome mpu6050 (come fare "int somma", discorso identico).

Codice: Seleziona tutto

MPU6050 mpu6050;

Nuova struct, le AUX!

Codice: Seleziona tutto

typedef struct {
  uint8_t pin; //identifica il pin a cui è connessa la aux
  bool active; //determina se la aux è ativa o no

  void InitAUX(uint8_t pin_i, bool active_i) { //ricevo il nome della aux, il pin e il suo stato: se è attiva o no
    pin = pin_i;
    active = active_i;
    pinMode(pin,OUTPUT); //imposto il pin per essere un OUTPUT
    AUXLevelWrite();
  }

  void AUXLevelWrite() { // i leds hanno il '+' in comune (a Vcc), il '-' controlla le luci. | stato: HIGH (pin a Vcc) = led spento | state: LOW (pin a GND) = led acceso
    if(active) //se la AUX è attiva
      digitalWrite(pin, LOW); //metto la aux a GND (passa corrente)
    else //se la AUX è disattiva
      digitalWrite(pin,HIGH); //metto la AUX a VCC (non passa corrente);
  }

  void UpdateStatus(bool active_i) {
    active = active_i;
    AUXLevelWrite();
  }
} AUX;

Partiamo, due variabili, una che indetifica il pin, l'altra che identifica lo stato

Codice: Seleziona tutto

  uint8_t pin; //identifica il pin a cui è connessa la aux
  bool active; //determina se la aux è ativa o no

poi un metodo che "inizializza" la aux assegnado uno stato ed un pin:

Codice: Seleziona tutto

  public:void InitAUX(uint8_t pin_i, bool active_i) { //ricevo il nome della aux, il pin e il suo stato: se è attiva o no
    pin = pin_i;
    active = active_i;
    pinMode(pin,OUTPUT); //imposto il pin per essere un OUTPUT
    AUXLevelWrite();
  }

Tale metodo quando viene richiamato ha bisogno di due parametri, un intero senza segno (definito come tipo uint8_t) e un booleano che definisce lo stato (TRUE acceso, FALSE spento).

secondo metodo AUXLevelWrite permette di modificare il valore elettrico del pin in base allo stato: se lo stato è true allora il valore è GND (tutti gli utilizzatori hanno + in comune e - dedicato per ogni aux), se false il pin avrà valore HIGH, ossia uguale al VCC

Codice: Seleziona tutto

  private:void AUXLevelWrite() { // i leds hanno il '+' in comune (a Vcc), il '-' controlla le luci. | stato: HIGH (pin a Vcc) = led spento | state: LOW (pin a GND) = led acceso
    if(active) //se la AUX è attiva
      digitalWrite(pin, LOW); //metto la aux a GND (passa corrente)
    else //se la AUX è disattiva
      digitalWrite(pin,HIGH); //metto la AUX a VCC (non passa corrente);
  }

Terzo metodo UpdateStatus, permette di attivare o disattivare una funzione, riceverà il valore true o false e poi richiamerà il metodo 2 per spegnere o accendere il led

Codice: Seleziona tutto

public:void UpdateStatus(bool active_i) {
    active = active_i;
    AUXLevelWrite();
  }

a questo giro non creo variabili aux, perchè esse saranno create nella struct Wagon!
Procediamo!
Struct Wagon:

Codice: Seleziona tutto

typedef struct {
  bool reverse; //direzione del treno: se REVERSE == TRUE la carrozza è in testa, in caso contrario è in coda
  bool lights; //identifica se la carrozza ha le luci (Bianche, rosse & Terzo Faro) accese o spente
  bool motion; //determina se la carrozza è in movimento o no;
  bool motion_old;
  AUX WLs; //aux per le luci bianche (WhiteLights)
  AUX RLs; //aux per le luci rosse (RedLights)
  AUX LB; //aux per il terzo faro (LightBeam)
  AUX CL; //aux per la luce di cabina (CabLighst)
  AUX ILs; //aux per le luci interne del treno (InteriorLights)

  public:void InitWagon(bool reverse_i, bool lights_i, bool motion_i) { //inizializzo il vagone
    reverse = reverse_i;  //imposta come direzione quella passata
    lights = lights_i;    //imposto le luci come richiesto all'inizializzazione
    motion = motion_old = motion_i;
  }
} Wagon;

Dichiaro le variabili di stato del tipo wagon (per esempio se è in moto, che direzione ha), e poi tutte le aux che mi servono

Codice: Seleziona tutto

  bool reverse; //direzione del treno: se REVERSE == TRUE la carrozza è in testa, in caso contrario è in coda
  bool lights; //identifica se la carrozza ha le luci (Bianche, rosse & Terzo Faro) accese o spente
  bool motion; //determina se la carrozza è in movimento o no;
  bool motion_old;
  AUX WLs; //aux per le luci bianche (WhiteLights)
  AUX RLs; //aux per le luci rosse (RedLights)
  AUX LB; //aux per il terzo faro (LightBeam)
  AUX CL; //aux per la luce di cabina (CabLighst)
  AUX ILs; //aux per le luci interne del treno (InteriorLights)

infine un metodo che "inizializza" il vagone il quale permette di dire se le luci sono accese, che direzione ha all'inizio e se esso è in moto

Codice: Seleziona tutto

  public:void InitWagon(bool reverse_i, bool lights_i, bool motion_i) { //inizializzo il vagone
    reverse = reverse_i;  //imposta come direzione quella passata
    lights = lights_i;    //imposto le luci come richiesto all'inizializzazione
    motion = motion_old = motion_i;
  }

Adesso mi serve inizializzare una variabile di tipo wagon e la chiamo pilot

Codice: Seleziona tutto

Wagon Pilot;

Si passa alle void principali!
La void Setup viene eseguita solamente una volta all'avvio della scheda, quando essa riceve corrente.

Codice: Seleziona tutto

void setup() {
  Pilot.InitWagon(false, true, false); //inizializzo la carrozza come: in coda (Reverse false) e con le luci accese (lights true)
  //inizializzo la aux al rispettivo pin e imposto lo stato
  Pilot.WLs.InitAUX(3, false); //luci bianche spente
  Pilot.RLs.InitAUX(5, true);  //luci rosse accese
  Pilot.ILs.InitAUX(6, true);  //luci interne carrozze accese
  Pilot.CL.InitAUX(7, false);  //luce di cabina spenta
  Pilot.LB.InitAUX(10, false); //faro di profondità spento

	mpu6050.init(); //inizializzo l' Accelerometro
  while(mpu6050.DetectMotion() == false) {}
  Pilot.motion = true;
  Pilot.reverse = mpu6050.Reverse();
  UpdateLights();
}

Inizializzo il vagone passandogli i dati base, poi richiamo le aux assegnandogli il numero del pin e il loro stato.
Successivamente invoco il metodo che inizializza l'accelerometro e poi aspetto che il vagone si metta in moto, finchè rimane fermo rimarrò dentro il while.
Appena si metterà in moto modificherò lo stato del vagone dicendo che è in movimento Pilot.motion = true; e poi determinerò la direzione presa: Pilot.reverse = mpu6050.Reverse(); e di conseguenza accenderò le luci opportune.

Usciti dalla void Setup, si passa al loop, ossia quel codice che verrà eseguito all'infinito fino a quando non verrà tolta alimentazione.

Codice: Seleziona tutto

void loop() {
  Pilot.motion = mpu6050.DetectMotion();
  if(Pilot.motion_old == false && Pilot.motion == true) {//il mezoz si mette in moto
	  Pilot.reverse = mpu6050.Reverse(); //richiamo l'accelerometro per determinre la direzione(REVERSE) in base alle accelerazioni che la carrozza subisce
    //Aggiorno lo stato delle luci (bianche, rosse, terzo faro, luce di cabina); le luci interne sono sempre accese
    UpdateLights();
  }
  Pilot.motion_old = Pilot.motion;
  delay(500);
}

Come prima cosa controllo lo stato del vagone se è in moto o no, e aggiorno il valore della variabile Pilot.motion: Pilot.motion = mpu6050.DetectMotion();
A questo punto, grazie ad una variabile definita motion_old io capisco se mi sono fermato o messo in moto.
Esempio, vagone fermo, entrambe le motion sono a 0, nuovo ciclo e rilevo che motion è true ossia 1, se la motion_old è 0 significha che sono passato dall'essere fermo al movimento e devo controllare la direzione per capire quali luci accendere e quali no.

Codice: Seleziona tutto

  if(Pilot.motion_old == false && Pilot.motion == true) {//il mezoz si mette in moto
	  Pilot.reverse = mpu6050.Reverse(); //richiamo l'accelerometro per determinre la direzione(REVERSE) in base alle accelerazioni che la carrozza subisce
    //Aggiorno lo stato delle luci (bianche, rosse, terzo faro, luce di cabina); le luci interne sono sempre accese
    UpdateLights();
  }

Invoco perciò il metodo mpu6050.Reverse() ed infine lancio il metodo UpdateLights() che in base alla direzione determina quali luci accendere e quale ni.
Alla fine del ciclo aggiorno la variabile motion_old portandola al valore di motion, faccio una pausa di 500 millisecondi e riparto da capo.

Ultimo void, quello per l'accensione delle luci:

Codice: Seleziona tutto

void UpdateLights() {
  int wait = 200;
  if(Pilot.lights) {
    if(Pilot.reverse) {//Reverse è ATTIVO (carrozza in TESTA), sequenza luci: accensione Luce Cabina, spegnimento luci rosse, accensione luci bianche, accensione terzo faro
      Pilot.CL.UpdateStatus(true);
      delay(wait); //inserisco una pausa subito dopo l'accensione della luce di cabina
      Pilot.RLs.UpdateStatus(false);
      Pilot.WLs.UpdateStatus(true);
      Pilot.LB.UpdateStatus(true);
    }
    else { //Reverse è DISATTIVO (carrozza in CODA), sequenza luci: spegnimento terzo faro, spegnimento luci bianche, accensione luci rosse, spegnimento Luce Cabina
      Pilot.LB.UpdateStatus(false);
      Pilot.WLs.UpdateStatus(false);
      Pilot.RLs.UpdateStatus(true);
      delay(wait); //inserisco una puasa subito prima dello spegnimento della luce di cabina
      Pilot.CL.UpdateStatus(false);
    }
  }
  else {
    Pilot.CL.UpdateStatus(false);
    Pilot.RLs.UpdateStatus(false);
    Pilot.WLs.UpdateStatus(false);
    Pilot.LB.UpdateStatus(false);
  }
}

Aggiorno le luci

TUTTO IL MATERIALE SI TROVA NELLA SEGUENTE CARTELLA ZIP, COMPRESO IL "I2C SCANNER2"

UpGrade_Project_ICE2.zip

Sono presenti dei file txt con dei collegamenti alle immegini degli interni del treno (che ho usato per colorarlo) e ad una discussione sul cablaggio elettrico dell'ICE1.
Nella cartella MISC sono presenti esempi e test; sono anche presenti dei programmi in Visual Basic per leggere la porta seriale di arduino, è tutto modificabile e giocabile

FASE 4 TERMINATA.

#41 Messaggio da **Fidax** » 22 luglio 2019, 16:24

NOTA DI SERVIZIO
Se qualcun altro volesse cimentarsi in quest'opera, consiglio vivamente al posto di Arduino Pro Mini, lo Sparkfun Pro Micro (lo store ufficiale: https://www.sparkfun.com/products/12640 ), ha le stesse identiche dimensioni ma incorpora, grazie al chip diverso (Atmega32u4 sul Micro, Atmega328p sul Mini), il convertitotre USB - Seriale, il che rende la programmazione molto più comoda.

WP_20190722_10_55_44_Pro.jpg

Unico accorgimento importante, siate sicuri che lo compriate con il bootloader precaricato da chi ve lo vende! Altrimenti potreste avere delle rogne.
P.S. Il bootloader è una componente software presente sul chip che permette la programmazione tramite usb - seriale; di norma questi chip si programmano con programmatori ISP esterni.

#42 Messaggio da **Fidax** » 26 luglio 2019, 10:38

E' ONLINE IL VIDEO DELLA FASE 4

#43 Messaggio da **Fidax** » 26 luglio 2019, 12:18

Fase 4b: Piccole Migliorie & Correzioni
Portata avanti mentre finivo la fase 4, la 4b vede come protagonisti piccole modifiche e correzioni dei lavori già svolti; saranno 4 lavoretti da pochi minuti l'uno e ve li presenterò nello stesso ordine in cui verranno presentati nel video di questa fase.

Modifica 1: Calibrazione motore
I settaggi di default non mi soddisfavano, ho seguito i consigli che mi sono stati dati in questa discussione viewtopic.php?f=51&t=11870 e ho modificato la configurazione del motore con i seguenti parametri:

Screenshot (39).png

Screenshot (40).png

Screenshot (41).png

Modifica 2: Sostituzione altoparlante
L'altoparlante datomi in dotazione al decoder è un 8Ohm con 0.5W di potenza, lasciando il volume al massimo il suono gracchiava, abbassando il volume il suono migliorava di qualità ma veniva coperto dal suono meccanico del modello.
Grazie ai suggerimenti che mi sono stati dati in quest'altra discussione viewtopic.php?f=51&t=11928 sono riuscito a trovare uno speaker da 20mm (quindi stessa dimensione dell'originale) sempre 8Ohm ma da 2W di potenza, ricordo che gli mSD3 con speaker 8Ohm possono erogare massimo 1,75w.
Ho potuto quindi alzare il volumo a 240 su 255 e adesso la locomotiva ha un sound che non viene coperto dal rumore meccanico.
Nel video tale miglioramento sarà più apprezzabile.

WP_20190726_10_52_49_Pro.jpg

WP_20190726_10_52_37_Pro.jpg

Modifica 3: regolatori di tensione
Tale modifica riguarda il sistema di illuminazione delle carrozze,questo era il sistema realizzato nella Fase 2:
Immagine

Tale sistema prevedeva, dopo connettore con il ponte di diodi ed il condensatore, una semplice resistenza da 1Kohm e poi la striscia led.
Questa configurazione rende la luminosità variabile in base alla tensione presente sulle rotaie: con una tensione di 20v le luci sarebbero state più luminose rispetto ad una tensione di 16v.
Ho quindi modificato il circuito nel sotto tetto (solo quello!) inserendo un regolatore di tensione 7812.
Il nuovo circuito prevede il seguente cablaggio:

- Filo rosso connettore >>> Pin 1 (pin input) del 7812
- Filo nero connettore >>> Pin 2 (pin com) del 7812
- Pin 2 del 7812 >>> piazzola "-" della striscia
- Pin 3 (pin out) del 7812 >>> resistenza da 180 Ohm per 2W di potenza
- Altro capo della resistenza >>> piazzola "+" della striscia

WP_20190719_08_45_34_Pro.jpg

WP_20190719_08_56_47_Pro.jpg

WP_20190720_15_05_59_Pro.jpg

NOTA IMPORTANTE: il regolatore dissipa la differenza di tensione in calore, va incollato con la parte di materale metallico rivolta verso gli interni (materiale plastico a contatto con il tetto), altrimenti il calore della parte metallica potrebbe deformare la plastica.

Modifica 4: Nuovo connettore carrozza pilota
Tale modifica riguarda solamente il connettore per l'illuminazione della carrozza pilota.
Nella Fase 5 mi serviranno altri 2 fili da portare nel sotto tetto, è quindi necessario sostituire il connettore inserito nella fase 2, un JST PH 2, con un connettore JST PH 4.
Attenzione, per la fase 6, serviranno altri 4 fili! Pertanto ho voluto impiegare da subito un connettore JST PH 8.
Purtroppo la fase 6 è molto incerta a causa delle difficoltà che sto incontrando nell'interfacciare Arduino all'interfaccia SUSI, quindi vi invito ad aspettare la sua eventuale uscita prima di passare dal PH 4 al PH 8, il PH 4 invece è indispensabile per la fase 5 (oppure usate un altro PH 2 da mettere di fianco a quello già presente, a voi la scelta; io preferisco un unico connettore), inoltre la fase 5 è certa, richiederà solo del tempo per completarla.
Nelle seguenti immagini è presente il PH 8, i fili in più che temporaneamente sono visibili nella pilota verranno eliminati nelle nuove fasi.

WP_20190720_15_03_45_Pro.jpg

WP_20190720_16_09_30_Pro.jpg

#44 Messaggio da **Fidax** » 28 luglio 2019, 8:57

E' online il video della Fase 4b
Dopo il minuto 10 è presente uno spezzone di circa 3 minuti dove faccio correre il treno su un piccolo ovale di prova, saranno apprezzabili le migliorie sonore effettuate

#45 Messaggio da **Fidax** » 20 novembre 2020, 13:31

Dopo un anno di fermo ho ripreso in mano il progetto per aggiornarlo e concluderlo, rispetto ai proprositi iniziali ho deciso di rinunciare alle luci rosse in quanto non sono riuscito a trovare una configurazione che mi piacesse: il prisma non permette una buona divisione luminosa e di avere il terzo faro colorato di rosso nonostante delle maschere sullo stampato e nonostante abbia modificato il prisma tagliando ed isolando i vari lati non mi andava.
Ho colto l'occasione per rivedere l'illuminazione interna (modifiche ai componenti per abbassare i consumi ed il calore prodotto) e di ricrearla tramite PCB personalizzati su ogni carrozza, ad oggi manca solo la pilota.

IMG_20201120_114957.jpg

IMG_20201120_115515.jpg

IMG_20201120_115542.jpg

IMG_20201120_115603.jpg

E così è come si presentano le due vetture illuminate tramite PCB, la vettura pilota presenta ancora la configurazione delle fasi precedenti

IMG_20201120_115904.jpg

IMG_20201120_115912.jpg

IMG_20201120_115920.jpg

IMG_20201120_115926.jpg

IMG_20201120_115937.jpg

IMG_20201120_115940.jpg

luferr52 · #46 Messaggio da **luferr52** » 20 novembre 2020, 16:57

Bello, a questo punto manca solo qualche figurino luigi

fulvio · #47 Messaggio da **fulvio** » 20 novembre 2020, 22:57

Molto bello, mancano sì i passeggeri

Salutoni

#48 Messaggio da **Fidax** » 13 gennaio 2021, 12:21

Anche la carrozza pilota ha ricevuto un nuovo pcb per le luci interne.

IMG_20210113_115544.jpg

IMG_20210113_115704.jpg

IMG_20210219_120932.jpg

Per i collegamenti ho sfruttato la caratteristicha del circuitino di fabbrica di avere due piazzole per ogni rotaia: fili neri pattino (right), fili marroni presa di corrente (left)

IMG_20210113_120335.jpg

Questo il circuito per la vettura ristorante:

IMG_20210114_000631.jpg

IMG_20210114_001113.jpg

IMG_20210219_120928.jpg

Ed infine l'effetto con tutte le carrozze (tutte illuminate con PCB e led bianchi freddi):

IMG_20210113_120714.jpg

Mancano anche i condensatori powerpack che saranno dei 470uF per 50v per assicurare la compatibilità con il sistema AC Analogico.
Le luci di testa tornano quindi ad essere sempre accese, per ovviare si potrebbe mettere un decoder funzioni per spegnerle quando è in coda e con un relè si possono sezionare le luci interne ( interponendo il relè fra il filo nero che va su e il circuitino di fabbrica) per accederle solo quando necessario