Jump to content

Idea! NXT Automazione Treni


Post raccomandati

INTRODUZIONE<br />Visto le recenti domanda sul Forum nuovo, ma anche i vari Post aperti su quello vecchio, cerco di aprire una piccola discussione sull'automazione Treni. Come già pronunciatomi nei vari Topic sono più propenso a un'automazione tramite NXT e non RCX. Perché questa scelta? proviamo a dare i pro e i contro all'utilizzo dei vari Brick Intelligenti (BI):<br /><br />RCX<br />Pro: <br />BI più conveniente (prezzi BL dai 35€ ai 50€)<br />Sensori 9V più convenienti<br /><br />Contro:<br />Può lavorare solo sui treni 9V agendo sul voltaggio dei binari<br />Si possono comandare solo motori e treni 9V<br />Non si possono comandare più treni appartenenti allo stesso tracciato in modo differente<br /><br />NXT<br />Pro:<br />Si può comandare sia motori 9V che PF<br />Si possono utilizzare anche i sensori per RCX<br />Si possono comandare più treni in modo diverso appartenenti allo stesso tracciato<br />Può comandare sia treni PF che 9V<br /><br />Contro:<br />BI intelligente costoso (dai 70€ su BL ai 161,99€ sullo S@H)<br />Sensori NXT costosi (dai 18€ ai 50€)<br />Portata del segnale ristretta<br />Segnale solo con 8 canali (quindi massimo 8 treni)<br /><br />COSA SERVE PER INIZIARE?<br />Beh a questa domanda non c'è una risposta vera e propria, tutto dipende da quanti treni si vogliono comandare, come è il tracciato, se ci sono passaggi a livello, binari morti ecc...ma si può iniziare con una piccola stima. Prima di tutto dobbiamo capire che treni pilotare, se treni PF o treni 9V. Perché? semplice, se si pilota i treni 9V bisogna agire sul voltaggio dei binari, se si parla di treni PF si dovrà agire con un segnare sul ricevitore. Partiamo dal più semplice...<br /><br />NXT > 9V<br />INVENTARIO<br />nxt.jpg + x1676.gif + 5306c01.gif<br />Mindstorms NXT<br />Prezzo Bricklink: 70-160€<br />Prezzo S@H: 161,99€<br /><br />Cavo convertitore NXT > 9V<br />Prezzo Bricklink: dai 3,5€ ai 10€ (x1)<br />Prezzo S@H: 10,99€ (x3)<br /><br />Connettore per binari 9V<br />Prezzo Bricklink: dai 3 ai 18€<br /><br />SPIEGAZIONE<br />Il collegamento l tutto è molto facile, si collega al BI il cavo convertitore NXT > 9V, successivamente al cavetto convertitore si collega il connettore per l'alimentazione dei binari 9V. Comandare poi il treno è abbastanza facile, l'NXT pensa che collegato all'uscita ci sia un motore, quindi aumentando la potenza si aumenta la velocità del treno, viceversa di rallenta il treno. Unica pecca è che tutto questo dura quanto la durata delle batterie stilo del nostro BI, per questo vi consiglio di comprare la batteria al litio (cosa non necessaria in caso ti utilizzo treni PF) per l'NXT, ovvero:<br /><br />bb495.jpg<br />Batteria al litio<br />Prezzo Bricklink: 50€<br />Prezzo S@H: 57,99€<br /><br />Con tutto questo (batteria al litio a parte) si possono comandare i treni 9V, unico difetto è che se ci sono più treni sullo stesso tracciato, rallentando un treno si rallenta anche il secondo, il terzo e così via, questa è la problematica ti utilizzare i treni 9V, tutti hanno la stessa sorgente di energia.<br /><br />NXT > PF<br />Qui la storia cambia e...si inizia subito a capire le potenzialità del nostro NXT. Come ben sappiamo tutti i treni PF hanno la propria "sorgente di energia", quindi ogni treno ha il suo pacco batteria. Questo cosa vuol dire? che se agisco sulla potenza di un treno, anche gli altri treni non subiscono lo stesso comando. Iniziamo a dire cosa serve, poi entriamo nel merito...<br /><br />INVENTARIO<br />nxt.jpg + 55806.gif + nxtirlink.jpg<br />Mindstorms NXT<br />Prezzo Bricklink: 70-160€<br />Prezzo S@H: 161,99€<br /><br />Cavo connessione NXT<br />Prezzo Bricklink: dipende dalla lunghezza del cavo che cercate...<br />Prezzo S@H: 10,99€ (x7 - varie lunghezze)<br /><br />NXT IRLink Sensor<br />Prezzo S@H: 48,99€<br />Prezzo HiTechnic: 54,95€<br /><br />SPIEGAZIONE<br />E adesso ci divertiamo  8) ...<br /><br />Il collegamento è semplice, NXT > cavetto > IRlink. Che cos'è l'IRlink? beh diciamo che non è altro che un sensore che permette di comandare tutto ciò che è collegato a un ricevitore IR. l'IRlink permette anche di pilotare anche i treni 7897 & 7898. Il sensore e creato dalla HiTechnic, società certificata da TLG per la produzione di sensori e accessori per l'NXT. Comprato il sensore scaricatevi sulla apposita pagina (http://www.hitechnic.com/downloadnew.php?category=13) i vari blocchi aggiuntivi per il programma. All'inizio con i primi blocchi c'erano problemi a pilotare i vari treni, a differenza del telecomando dei treni, il segnale tramite l'IR doveva essere inviato costantemente, cosa che non avviene con il telecomando, basta l'invio di un segnale e il treno va all'infinito. Notato questo problema, e ringrazio Giancarlo Saba per i vari test, il buon Pix ha contattato HiTechnic. Devo dire che capito il problema i programmatori hanno rilasciato l'aggiornamento del block in pochissimo tempo, questo mi fa dedurre di non essere stato l'unico a richiedere "delle modifiche". Il blocco da utilizzare è questo qui (vedi immagine)...<br /><br />bloccoirlink.jpg<br /><br />Port: Sono le porte di uscita dell'NXT, selezionate quella a cui collegare l'IRlink<br />Channel: Canale selezionato per il treno<br />Output: Su quale uscita del ricevitore avete collegato il motore del treno (blu o rosso per intenderci)<br />Power: Beh qui selezionate la potenza, la direzione ecc..<br />Brake: Nel caso volete fermate "di botto" il treno senza decelerazioni<br /><br />Fino a qui tutto chiaro, o almeno penso...perché qui ho spiegato come comandare i treni ma...quando li comando? beh, li comando quando uno o più sensori vengono sollecitati. Ovvero, esempio semplice, posso dire al mio NXT di fermare il treno quando un sensore di contatto viene schiacciato, l'NXT riceve il segnale della pressione sul sensore e da in uscita tramite l'IRlink il segnale che voglio dare, che può essere di arresto, partenza, fermata ecc...<br /><br />QUALI SENSORI POSSO USARE?<br /><br />9V<br />nxt.jpg + x1676.gif + 2982c01.gif - 879.gif<br /><br />Sensore di Luce<br />Prezzo Bricklink: dai 3€ ai 16€<br /><br />Sensore Touch<br />Prezzo Bricklink: dai 1,50€ ai 10€<br /><br />NXT<br />nxt.jpg + x1676.gif + nxtsensor.jpg - nxtlight.jpg - nxttouch.jpg<br /><br />Per i sensori dell'NXT consiglio di prenderli sullo S@H, sia perché i prezzi non cambiano di molto, ma nel caso avete una sicurezza in più che vengano sostituiti nel caso di mal funzionamento (visto quanto costano...)<br />s@H NXT Mindstorm: http://shop.lego.com/en-IT/Robotics-ByCategory<br /><br />Ora collegando i vari sensori ai vari ingressi del nostro NXT si possono pilotare i vari treni.<br /><br />Nulla ci vieta di comandare anche l'automazione degli scambi, motorizzandoli a dovere (come già parlato in un altro Post) si può anche modificare il percorso del o dei nostri treni. Qui possiamo utilizzate i sia i motori 9V che PF. Attenzione solo una cosa, se dobbiamo pilotare motori 9V, basta solo il cavetto NXT > 9V, se dobbiamo pilotare i motori PF dobbiamo aggiungere il cavetto PF (ovviamente).<br /><br />Esempio Motori 9V<br />nxt.jpg + x1676.gif + 2838c01.gif<br /><br />Esempio Motori PF<br />nxt.jpg + x1676.gif + 60656.gif + pfmotor.jpg<br /><br /><br /><br />CONSIDERAZIONI PERSONALI E FINALI<br />Considerazioni finali un pò sparse...vediamo da dove iniziare...io consiglio di utilizzare i sensori 9V, sono più facili da nascondere e funzionano perfettamente utilizzando il cavetto convertitore NXT > 9V. Ricordatevi che utilizzando un sensore di luce è consigliato proiettarlo su una fonte di luce (e di non basarci sulla luce presente dell'ambiente del diorama), così da aver una maggior escursione e semplicità di lettura durante il passaggio de treno. Personalmente fino ad ora ho utilizzato sensori Ultrasonic e Touch 9V senza nessun problema. Posizionate sempre l'IRlink in una posizione abbastanza alta o su un punto dove può comunicare con il treno può avvenire in un tratto molto lungo, il contro del sensore è che non ha una portata illimitata (se avessero usato il wireless come i playmobil  :( ), quindi meglio posizionarlo in punti strategici, su una stazione, su un ponte segnaletico ecc, ecc...<br /><br />Ricordatevi una cosa molto importante, tutti i treni che andrete a pilotare dovranno aver il ricevitore IR!!!<br />ricevitore.jpg<br /><br />Penso di aver spiegato in modo semplice le basi dell'automazione utilizzando l'NXT. Se Giancarlo vuoi aggiungere qualcosa ben venga  ;) ...<br /><br />ESEMPIO<br />Ecco qui l'esempio della prima prova che ho fatto: Video YouTube
Link to comment
Condividi su altri siti

Non ho sottomano uno scambio PF per controllare, ma se mentre lo scambio è per esempio settato su "dritto" io sposto l'ago e lo rilascio, l'ago torna in posizione dritta?

 

Se così fosse (in gergo ferroviario si dicono "scambi tallonabili") un treno può entrare nel cappio (il percorso a goccia) e uscirne ripassando dallo scambio senza che questo sia manovrato.

 

Ovviamente entra sempre nello stesso senso. In pratica l'azionamento degli scambi è inutile (sempre se l'ago dello scambio torna a posto da solo per via del suo molleggio)

Link to comment
Condividi su altri siti

Allora, dato che Pix ha manifestato una certa qual vaga incomprensione della mia idea (se leggete la mia bacheca su FB lo leggete nelle sue stesse parol(acc)e medesime), rispiego in termini più semplici così lo capisce pure lui nonstante l'età avanzata :D

 

Allora: supposto che l'ago dello scambio, una volta messo in posizione (dritto o curvo) resti elasticamente in tale posizione (cioè se lo sposto col dito poi torna al suo posto), io sostengo che sia inutile muovere lo scambio quando il treno percorre la racchetta (o cappio o goccia, che dir si voglia).

 

Se lo scambio è in posizione "dritto", il treno parte dal rettilineo in fondo, viene verso di noi, percorre lo scambio (continuando dritto poiché lo scambio è su "dritto"), percorre la curva a 180° e torna indietro, ripercorrendo lo scambio (ma stavolta arriva dalla direzione "curva"). E' inutile predisporre lo scambio su "curva" prima che il treno lo attraversi, tanto le ruote del treno spostano elasticamente l'ago che poi ritorna in posizione "dritto" subito dopo.

 

Capito?

Link to comment
Condividi su altri siti

Complimenti Pix, sono rimasto veramente colpito dalle incredibili possibilità di automazione che hai descritto. Io e il mio bimbo (6 anni) stiamo costruendo una piccola città con tanti treni, binari e scambi.

Ho solo un piccolo problema, già finora il budget di acquisto veicoli è stato allucinante, il solo pensiero di spendere ancora così tanto per creare degli automatismi mi ha fatto passare la voglia.

Mi sa che aspetterò che la ns. fabbrica dei sogni produca dei set preconfezionati per le automazioni più semplici.

Il tuo rimane comunque un buon lavoro, che terrò presente per le future evoluzioni del ns. tracciato.

Jack75

Link to comment
Condividi su altri siti

...Capito?

 

Caro Sig. Poldo, trovo non sensata questa domanda, ma le scrivo lo stesso una risposta. Lei automatizzando il tutto non è obbligato a tenere uno scambi diritto o "scambiato" per modificare il percorso del treno. Lei può fare ciò che vuole, può anche programmare lo scambio che si attivi solo al passaggio del treno e poi torni allo stato di partenza. Spero di essere stato chiaro..."ago" Poldo.

 

:D

 

Complimenti Pix, sono rimasto veramente colpito...il solo pensiero di spendere ancora così tanto per creare degli automatismi mi ha fatto passare la voglia.

 

Grazie Jack! ti posso solo dire una cosa, la spesa è davvero grossa, lo ammetto, tutto il materiale che ho preso per automatizzare il mio tracciato è costato sui...TANTO(!). Però...sai che figata poi comandare tutto da fermo? ti puoi creare una plancia comando mettendo tutti gli NXT in serie e i vari interruttori. Quasi quasi diventa un "diorama ferroviario" professionale...peccato che, come già detto, non sia wireless...

Link to comment
Condividi su altri siti

Con tutto questo (batteria al litio a parte) si possono comandare i treni 9V, unico difetto è che se ci sono più treni sullo stesso tracciato, rallentando un treno si rallenta anche il secondo, il terzo e così via, questa è la problematica ti utilizzare i treni 9V, tutti hanno la stessa sorgente di energia.

Questo problema si può risolvere molto facilmente: è sufficiente dividere il tracciato a 9V in due o più sezioni isolandole elettricamente tra loro. Ogni sezione dovrà però essere alimentata e comandata separatamente. Solo il treno presente in quella sezione risponderà ai comandi remoti. Un

Link to comment
Condividi su altri siti

Fantastica presentazione e utilissima!!!

Una cosa, dato che sono giovane (di lego) :D il ricevitore Ir http://www.bricklink.com/catalogItemPic.asp?P=58123c ha 2 connessioni, una rossa e una blu, ma che differenza c'è tra le 2?

Per attacare la trazione del treno non cambia niente, l'una vale l'altra?

 

Per Jack75, anch'io sono nella tua stessa situazione.... ma con calma credo di poter fare il tutto, non bisogna aver fretta, l'importante e che ci sia Pix e gli altri ad illustrarci come fare ;D

 

Grazie

Tommaso

Link to comment
Condividi su altri siti

...una rossa e una blu, ma che differenza c'è tra le 2?

Per attacare la trazione del treno non cambia niente, l'una vale l'altra?

 

Esatto! le uscite sono totalmente uguali! blu e rosso sono solo lo "sdoppiamento" del canale che utilizzi. Se hai un Emerald Night motorizzato puoi capire il tutto.

Link to comment
Condividi su altri siti

Oh mama, cerco di rispondere a tutto Helos ;) ...

 

Allora, parto dalla più semplice: è vero che i BI posso essere massimo 4, ma i canali dei treni sono massimo 8, quindi avresti, come dici tu, la possibilità di pilotare altri treni, ed è giusto l'esempio che fai, un pò controllati tramite IRlink e un pò tramite i binari 9V, ma qui c'è il problema della durate delle batterie...a Sk

Link to comment
Condividi su altri siti

Oh mama, cerco di rispondere a tutto Helos ;) ...

Beh?!? Che fai? Lanci il sasso poi nascondi la mano? :D

Per un tracciato piccolo o medio che uno può costruirsi in casa, le applicazioni di cui sopra bastano e avanzano. Se valutiamo invece la possibilità di automatizzare un circuito importante per dimensioni e numero di convogli da far girare in simultanea bisogna riferirsi almeno un po

Link to comment
Condividi su altri siti

Secondo me l'idea valida è quella di settori indipendenti che controllano gli scambi ed i treni, ad esempio:

 

Settore stazione a due binari, con una logica di questo tipo:

- lo scambio di arrivo si posiziona per il binario 1

- quando arriva il treno toglie la corrente (rallenta e frena)

- scambia l'arrivo al binario 2

se arriva un altro treno lo frena al 2

altrimenti il treno 1 riparte dopo 10 secondi

 

In questo caso mi piacerebbe l'RCX con:

2 ingressi:

- sensore luce inizio tratta

- sensore luce fine tratta

2 uscite:

- scambio ingresso

- scambio uscita

 

 

 

 

Un settore antitamponamento diviso in due parti con due sensori all'inizio e alla fine del secondo tratto, lungo abbastanza per contenere un convoglio

- inizialmente corrente a tutte le tratte

- quando il treno fa scattare il sensore del tratto 2 toglie corrente all'1 (magari ci mettiamo un semaforo?)

- quando esce dal 2 ridà corrente al tratto 1

 

In questo caso mi piacerebbe l'RCX con:

2 ingressi:

- sensore luce inizio tratta

- sensore luce fine tratta

2 uscite:

- binario+luce verde semaforo

- luce rossa semaforo

 

 

In questo caso i 9V non avrebbero problemi di alimentazione, cambio batterie od altro e sarebbero indipendenti

Gli RCX 1 alimentati dal trasformatore vanno benissimo anche loro senza spreco di batterie

 

 

PS: Si nota che i treni a batteria non mi piacciono? ;)

 

 

Link to comment
Condividi su altri siti

Guarda Helos, ti dirò...dipende tutto da cosa vuoi fare in che modo ecc, ecc. Certo che le potenzialità sono notevoli con l'NXT. Per il fatto che l'IRlink ha una portata bassa e che questo sia un pregio, beh, mi sa che hai ragione. Almeno ogni NXT comanda una parte di tracciato.

 

Io ti parlo da coordinatore (assieme a Matteo&Giuliano) del DC, e sai anche che a ogni evento che noi seguiamo il tracciano non è mai lo stesso, per di più non abbiamo mai fatto automazione ma solo grandi "ovali" (anche se ovali non sono) per intenderci, dove il treno girava e via. Io è da due anni che sto lavorando a una stazione a binari morti con automazione integrata, cosa deve fare?

 

Treno 1

arriva > rallenta > stop

Treno 2

parte > fa il giro > arriva > stop

 

Per iniziare a far vedere al pubblico un pò di automazione, un pò di diversità, cioè treni che si fermano, ripartono ecc.

 

Vorrei farti, ovviamente farvi, vedere questo video:

Ho contattato ancora un anno fà chi fece queste prove, per scambiarci idee discussioni ecc, poi lui ha accantonato il tutto per mancanza di tempo (ma forse anche di voglia).

Link to comment
Condividi su altri siti

Il fatto è questo, quando uno ha un Diorama personale, è molto più facile, il tracciato è quello, è statico e può essere modificato o ampliato di rado o con piccoli accorgimenti. Quando si parla di Eventi, il discorso è diverso e più complicato, il tracciato di rado è sempre lo stesso (anzi, mai) e studiare un'automazione porta via settimane e settimane di lavoro.

Link to comment
Condividi su altri siti

Gli scambi #7895 sono effettivamente "tallonabili".

 

Questo mi ha permesso di realizzare qualche circuito in cui è possibile coprire tutti i "rami" semplicemente comandando al treno la direzione opposta (generalmente mi regolo così: percorrendo l'anello più esterno in senso antiorario, si resta sull'anello esterno; andando invece in senso orario si affrontano gli scambi in modo da entrare nei tracciati interni). Senza toccare gli scambi, si può creare un tracciato unico percorribile in due direzioni, riservando perciò l'automazione di terra solo a semafori e passaggi a livello Link a qualche mio video.

 

Almeno uno dei miei scambi ha il leggero difetto di non chiudere bene la rotaia di uscita, per cui sono costretto a usarlo solo in un verso (se infatti lo chiudo in modo da far proseguire sulla direzione alternativa, quando il treno entra veloce deraglia perché lo scambio non "chiude" bene). Lo scatto dello scambio è un po' troppo "deciso" e visto che lo scambio è "tallonabile", a meno di voler avere binari morti penso che non sia il caso di affannarsi troppo ad automatizzarlo.

 

La rotella del telecomando ha al centro uno slot a croce per un "axle". Dunque in teoria si potrebbe usare un singolo NXT (!!) per pilotare 3 treni PF (coi tre motori NXT su due telecomandi) dando accelerazioni e frenate progressive, e leggendo dai 4 sensori le posizioni (tipo "ingresso in stazione") salvo ulteriori ardite macchinazioni (un motore potrebbe fungere da braccio e uno da selettore rotella velocità ma non credo sia il caso di complicarsi la vita).

 

 

Link to comment
Condividi su altri siti

Secondo me l'idea valida è quella di settori indipendenti che controllano gli scambi ed i treni, ad esempio:

 

Riporto in auge questo argomento perchè a Cavallino abbiamo automatizzato un semaforo in pochi minuti con l'RCX ed il treno di Paolo.

 

 

Dietro gentile richiesta ecco il listato NXT per BrickxCC:

 

/*------------------------------------------------------------------------------
; File          : semaforotreno.nxc
; Description   : Semaforo per il treno
; Programmed by : Rudy
; ports:
: A  luce rossa
; B  luce verde
; C  treno
; 1  sensore luce dell'RCX con una lampadina di fronte
; 2
; 3
; 4
;-----------------------------------------------------------------------------*/

void print(int riga,string testo,int numero)
{
    // stampa stringa e numero sulla riga
    // calcola il valore della riga (0 in basso a sinistra)
    int lnum=(8-riga)*8;
    ClearLine(lnum);
    TextOut(0, lnum, testo);
    if (numero) NumOut(6*strlen(testo), lnum, numero);
}

task main()
{
 // disabilita lo spegnimento automatico dell'NXT
 SetSleepTime(0) ;

 // seleziona come tipo il sensore luce RCX
 SetSensorType(S1,SENSOR_TYPE_LIGHT);
 SetSensorMode(S1,SENSOR_MODE_RAW);

 // accende il semaforo
 OnFwd(OUT_A,100);

 // treno e luce di riferimento
 int maxspeed=70;
 OnFwd(OUT_C,maxspeed);


 // lettura del sensore luce
 int light_max;



 int x,luce;
 while (true) {
   luce=Sensor(S1);
   print (2,"Test: ",light_max);
   print (4,"Luce: ",luce);

   // regolazione automatica della soglia per la luce
   // varia con la luce ambiente e le macchine fotografiche in giro
   light_max--;
   if (luce>light_max)
     light_max=luce;


   if (luce<(light_max-10)) {
     // frena il treno
     Float(OUT_C);
     Wait(3000);
     // luce verde
     OnFwd(OUT_B,100);
     Off(OUT_A);
     // partenza
     for (x=1 ; x<maxspeed ; x=x+10 ) {
       OnFwd(OUT_C,x);
       Wait(500);
     }
     OnFwd(OUT_C,maxspeed);
     Wait(500);
     // luce rossa
     OnFwd(OUT_A,100);
     Off(OUT_B);
   }
 }
}


 

 

Versione per RCX:

/*------------------------------------------------------------------------------
; File          : trainstation
; Description   : Semaforo per il treno
; Programmed by : Rudy
; ports:
: A  luce rossa
; B  luce verde
; C  treno
; 1  sensore luce
; 2
; 3
; 4
;-----------------------------------------------------------------------------*/

task main()
{
 SetSleepTime(0) ;
 SetSensorType(SENSOR_1,SENSOR_TYPE_LIGHT);
 SetSensorMode(SENSOR_1,SENSOR_MODE_RAW);
 // semaforo
 SetPower(OUT_A,8);
 SetPower(OUT_B,8);
 OnFwd(OUT_A);

 // leggo il sensore luce
 int light1_down = SENSOR_1;

 // treno
 int maxspeed=5;
 SetPower(OUT_C,maxspeed);
 OnFwd(OUT_C);

 int x;
 while (true) {
   int luce=SENSOR_1;
   // regolazione automatica della soglia per la luce
   // varia con la luce ambiente e le macchine fotografiche in giro
   light1_down++;
   if (luce<light1_down)
     light1_down=luce;

   if (luce>(light1_down+9)) {
     // frena il treno
     Float(OUT_C);
     Wait(300);
     // luce verde
     OnFwd(OUT_B);
     Off(OUT_A);
     // partenza
     for (x=1 ; x<maxspeed ; x++ ) {
       SetPower(OUT_C,x);
       OnFwd(OUT_C);
       Wait(100);
     }
     SetPower(OUT_C,maxspeed);
     OnFwd(OUT_C);
     Wait(100);
     // luce rossa
     OnFwd(OUT_A);
     Off(OUT_B);
   }
 }
}

 

Spiegazione del modulo:

 

L'NXT dà corrente alla rotaia sulla porta C con il cavo adattatore

A destra del binario c'è il sensore, a sinistra la lampadina alimentata dal binario (il treno passa in mezzo)

Vicino all'NXT c'è il semaforo con due luci collegate con i cavi adattatori

Si possono usare anche i sensori luce dell'NXT

 

La logica:

- accende il semaforo rosso

- accende il treno

- ciclo continuo:

-- controlla il sensore

-- se il sensore rileva qualcosa:

--- frena il treno

--- aspetta x secondi

--- spegne il rosso

--- accende il verde

--- fa partire dolcemente il treno

--- aspetta x secondi

--- spegne il verde

--- accende il rosso

- fine ciclo

 

 

 

Link to comment
Condividi su altri siti

Salve a tutti i fermodellisti Legosi... continuo con le idee di automazione ferroviaria per il diorama.

 

Sostengo la mia opinione, testata a Cavallino:

- binari 9V

- RCX 1.0 (con attacco per il trasformatore dei treni)

 

Vantaggi:

- si attacca il trasformatore e l'automazione va avanti da sola per tutte le giornate dell'evento con meno problemi del GBC :D

- i costi sono nettamente inferiori all'NXT con pacco ricaricabile e trasformatore (vedo su Bricklink che l'RCX 1 costa dai 20 ai 30 Euro, lo stesso per la torretta USB per il collegamento ed il trasformatore che si usa è quello dei treni che probabilmente avete già ;) Invece NXT + pacco ricaricabile + trasformatore = 100+50+15, costa quasi tre volte di più

- il sensore luce RCX costa dai 4 euro in su mentre il sensore luce NXT costa dai 12 euro in su

- si possono usare i motori PF con l'adattatore

 

Inoltre se ci si coordina sulle specifiche (tipo altezza del binario in entrata ed uscita) ciascuno può automatizzare un modulo (penso anche ad esempio a mucche che girano la testa al passaggio del treno...) e poi si montano in sequenza nel diorama senza diventare matti per gestire una caterva di scambi

 

Mi sono attrezzato acquistando a Cavallino il mio primo treno 9V quindi sono disponibile a scrivere il software per i test su... rotaia ;D

 

 

Un'ultima cosa: Paolo mi ha fatto notare che col 9V non puoi ad esempio far aprire le porte al treno.

 

Ci ho pensato: una possibile soluzione è motorizzare solo le porte con il PF, e motorizzare il comando PF come se fosse uno scambio, così le batterie vengono usate pochissimo e possono durare giorni interi.

 

Per cortesia qualcuno sa se si può usare l'IR-link (che non ho) con il cavo convertitore sull'RCX? Grazie

 

[edit] ho scoperto che i PF si possono guidare direttamente con l'RCX

 

[edit] qui lo zip per BrickOS (così so dove recuperarlo, ignoratelo pure)

 

[edit] esiste il codice per pilotare il PF per BrickxCC?

 

[edit] Questo è tutto quello che ho trovato sulla trasmissione dati dell'RCX in BrickxCC (roba da nerd, non leggetela):

 

3.5.2 SerialRCX2, Spy

The RCX2, Swan, and Spybotics can transmit serial data out the IR port. Prior to transmitting any data, the communication and packet settings must be specified. Then, for each transmission, data should be placed in the transmit buffer, then sent using the SendSerial() function.

For the RCX2 and Swan the communication settings are set with SetSerialComm. This determines how bits are sent over IR. Possible values are shown below.

OptionEffect

SERIAL_COMM_DEFAULTdefault settings

SERIAL_COMM_48004800 baud

SERIAL_COMM_DUTY2525% duty cycle

SERIAL_COMM_76KHZ76kHz carrier

SERIAL_COMM_RCXsame as default

SERIAL_COMM_RC4800/76kHz/25%

SERIAL_COMM_SPYBOT4800/76kHz/25%

SERIAL_COMM_96009600 baud (Swan)

The default is to send data at 2400 baud using a 50% duty cycle on a 38kHz carrier. To specify multiple options (such as 4800 baud with 25% duty cycle), combine the individual options using bitwise or (SERIAL_COMM_4800 | SERIAL_COMM_DUTY25).

The RCX2 and Swan allow you to set the packet settings with SetSerialPacket. This controls how bytes are assembled into packets. Possible values are shown below.

OptionEffect

SERIAL_PACKET_DEFAULTno packet format - just data bytes

SERIAL_PACKET_PREAMBLEsend a packet preamble

SERIAL_PACKET_NEGATEDfollow each byte with its complement

SERIAL_PACKET_CHECKSUMinclude a checksum for each packet

SERIAL_PACKET_RCXstandard RCX format (preamble,

negated data, and checksum)

Note that negated packets always include a checksum, so the SERIAL_PACKET_CHECKSUM option is only meaningful when SERIAL_PACKET_NEGATED is not specified. Likewise the preamble, negated, and checksum settings are implied by SERIAL_PACKET_RCX.

The transmit buffer can hold up to 16 data bytes. These bytes may be set using SetSerialData, then transmitted by calling SendSerial. For example, the following code sends two bytes (0x12 and 0x34) out the serial port:

SetSerialComm(SERIAL_COMM_DEFAULT);
SetSerialPacket(SERIAL_PACKET_DEFAULT);
SetSerialData(0, 0x12);
SetSerialData(1, 0x34);
SendSerial(0, 2);
Spybotics uses a different mechanism for configuring the serial transmission parameters. Use SetSerialType to specify the transmission type with the constants described in the following table.

OptionEffect

SERIAL_TYPE_SPYBOTSpybotics type

SERIAL_TYPE_RCXRCX type

SERIAL_TYPE_RCRC type

SERIAL_TYPE_USERUser-defined type

Use SetSerialBaud to specify the baud rate with the constants described in the following table.

OptionEffect

SERIAL_BAUD_24002400 baud

SERIAL_BAUD_48004800 baud

SERIAL_BAUD_96009600 baud

Use SetSerialChannel to specify the transmission channel with the constants described in the following table.

OptionEffect

SERIAL_CHANNEL_IRIR channel

SERIAL_CHANNEL_PCPC channel (visible light)

Use SetSerialPreamblePos to specify the position of the preamble in the 16 bytes of serial data. Use SetSerialPreambleLen to specify the length of the preamble. Use SetSerialChecksum to specify the checksum type with the constants described in the following table.

OptionEffect

SERIAL_CHECKSUM_NONENo checksum

SERIAL_CHECKSUM_SUMSum checksum

SERIAL_CHECKSUM_ZERO_SUMZero sum checksum

Use SetSerialBiPhase to specify the bi-phase mode with the constants described in the following table.

OptionEffect

SERIAL_BIPHASE_OFFNo bi-phase

SERIAL_BIPHASE_ONUse bi-phase

SetSerialComm(settings)Function - RCX2
Set the communication settings, which determine how the bits are sent over IR

SetSerialComm(SERIAL_COMM_DEFAULT);
SetSerialPacket(settings)Function - RCX2
Set the packet settings, which control how bytes are assembled into packets.

SetSerialPacket(SERIAL_PACKET_DEFAULT);
SetSerialData(n, value)Function - RCX2, Spy
Set one byte of data in the transmit buffer. N is the index of the byte to set (0-15), and value can be any expression.

SetSerialData(3, x); // set byte 3 to x
SerialData(n)Value - RCX2, Spy
Returns the value of a byte in the transmit buffer (NOT received data). N must be a constant between 0 and 15.

x = SerialData(7) ; // read byte #7
SerialPacket()Value - RCX2
Returns the packet data formatting configuration.

bit 0 : Preamble (0x55 0xFF 0x00)

bit 1 : Negated (incl. negated checksum)

bit 2 : Checksum (if not negated)

x = SerialPacket(); // read packet configuration
SerialComm()Value - RCX2
Returns the UART transmit parameter configuration. 

bit 0 : Baudrate (0 == 2400 baud, 1 == 4800 baud)

bit 1 : Carrier freq (0 == 38 kHz, 1 == 76 kHz)

bit 2 : Dutycycle (0 == 50 %, 1 == 25 %)

x = SerialComm(); // read UART transmit parameters 

SendSerial(start, count)Function - RCX2, Spy
Use the contents of the transmit buffer to build a packet and send it out the IR port (according to the current packet and communication settings). Start and count are both constants that specify the first byte and the number of bytes within the buffer to be sent.

SendSerial(0, 2); // send first two bytes in buffer
InitSpybotComm()Function - RCX2
Use this function to configure the serial communication registers in preparation for sending messages using the Spybot protocol.

InitSpybotComm(); // prepare to send IR using Spybot protocol
SendSpybotMsg()Function - RCX2
Use this function to send a 7 byte Spybot message which was previously set via a call to SetSpybotMessage.

SendSpybotMsg(); 
SetSpybotMessage(mode, myID, addr, cmd, hi, lo)Function - RCX2
Use this function to set the contents of a Spybot message. The message can then be sent repeatedly via calls to SendSpybotMsg.

SetSpybotMessage(MSG_BROADCAST, 9, 0, CMD_FIRE_LASER, 1, 100); 
SendSpybotMessage(mode, myID, addr, cmd, hi, lo)Function - RCX2
Use this function to send a 7 byte Spybot message. This function calls InitSpybotComm, SetSpybotMessage, and SendSpybotMsg in sequence.

SendSpybotMessage(MSG_BROADCAST, 9, 0, CMD_FIRE_LASER, 1, 100);
SendSpybotCtrlMsg()Function - RCX2
Use this function to send a 2 byte Spybot controller message which was previously set via a call to SetSpybotCtrlMessage.

SendSpybotCtrlMsg(); 
SetSpybotCtrlMessage(nMyID, nMsg)Function - RCX2
Use this function to set the contents of a Spybot controller message. The message can then be sent repeatedly via calls to SendSpybotCtrlMsg.

SetSpybotCtrlMessage(ID_CTRL_1, SPY_CTRL_BTN_1); 
SendSpybotCtrlMessage(nMyID, nMsg)Function - RCX2
Use this function to send a 2 byte Spybot controller message. This function calls InitSpybotComm, SetSpybotCtrlMessage, and SendSpybotCtrlMsg in sequence.

SendSpybotCtrlMessage(ID_CTRL_1, SPY_CTRL_BTN_1);
SendSpybotCtrlPingMsg()Function - RCX2
Use this function to send a 2 byte Spybot controller ping message which was previously set via a call to SetSpybotCtrlPingMessage.

SendSpybotCtrlPingMsg();
SetSpybotCtrlPingMessage(nID)Function - RCX2
Use this function to set the contents of a Spybot controller ping message. The message can then be sent repeatedly via calls to SendSpybotCtrlPingMsg.

SetSpybotCtrlPingMessage(ID_CTRL_1); 
SendSpybotCtrlPingMessage(nID)Function - RCX2
Use this function to send a 2 byte Spybot controller ping message. This function calls InitSpybotComm, SetSpybotCtrlPingMessage, and SendSpybotCtrlPingMsg in sequence.

SendSpybotCtrlPingMessage(ID_CTRL_1);
SendSpybotPingMsg()Function - RCX2
Use this function to send a 4 byte Spybot ping message which was previously set via a call to SetSpybotPingMessage.

SendSpybotPingMsg();
SetSpybotPing(nLinkID, nMyID, nInfo)Function — RCX2
Use this function to set the contents of a Spybot ping message. The message can then be sent repeatedly via calls to SendSpybotPingMsg.

SetSpybotPingMessage(ID_CTRL_1, ID_MIN_BOT+1, 10);
SendSpybotPing(nLinkID, nMyID, nInfo)Function - RCX2
Use this function to send a 2 byte Spybot ping message. This function calls InitSpybotComm, SetSpybotPingMessage, and SendSpybotPingMsg in sequence.

SendSpybotPingMessage(ID_CTRL_1, ID_MIN_BOT+1, 10);
InitRCComm()Function - RCX2
Use this function to configure the serial communication registers in preparation for sending messages using the Spybot RC protocol.

InitRCComm(); // prepare to send IR using RC protocol
SendRCMsg()Function - RCX2
Use this function to send a 4 byte RC message which was previously set via a call to SetRCMessage.

SendRCMsg();
SetRCMessage(nChannel, nLeft, nRight)Function - RCX2
Use this function to set the contents of a Spybot RC message. The message can then be sent repeatedly via calls to SendRCMsg.

SetRCMessage(RC_CHANNEL_2, RC_CMD_FWD, RC_CMD_FWD);
SendRCMessage(nChannel, nLeft, nRight)Function - RCX2
Use this function to send a 2 byte Spybot ping message. This function calls InitRCComm, SetRCMessage, and SendRCMsg in sequence.

SendRCMessage(RC_CHANNEL_2, RC_CMD_FWD, RC_CMD_FWD);
DefaultSerialComm()Value - Swan
Returns the default UART transmit parameter configuration.

x = DefaultSerialComm(); // read the default UART transmit config
DefaultSerialPacket()Value - Swan
Returns the default packet data formatting configuration.

x = DefaultSerialPacket(); // read the default packet config
SetDefaultSerialComm(settings)Function - Swan
Set the default communication settings, which determine how the bits are sent over IR

SetDefaultSerialComm(SERIAL_COMM_DEFAULT);
SetDefaultSerialPacket(settings)Function - Swan
Set the default packet settings, which control how bytes are assembled into packets.

SetDefaultSerialPacket(SERIAL_PACKET_DEFAULT);
SerialType()Value - Spy
Returns the type of the serial transmission.

x = SerialType(); // SERIAL_TYPE_USER ??
SetSerialType(type)Function - Spy
Sets the type of the serial transmission. 

SetSerialType(SERIAL_TYPE_USER); // set type to user
Use one of the following constants: SERIAL_TYPE_SPYBOT, SERIAL_TYPE_RCX, SERIAL_TYPE_RC, SERIAL_TYPE_USER. 

SerialBaud()Value - Spy
Returns the baud rate of the serial transmission.

x = SerialBaud(); // SERIAL_BAUD_2400 ??
SetSerialBaud(baud)Function - Spy
Sets the baud rate of the serial transmission. 

SetSerialBaud(SERIAL_BAUD_2400); // set baud to 2400
Use one of the following constants: SERIAL_BAUD_2400, SERIAL_BAUD_4800, SERIAL_BAUD_9600. 

SerialChannel()Value - Spy
Returns the transmission channel.

x = SerialChannel(); // SERIAL_CHANNEL_PC ??
SetSerialChannel(channel)Function - Spy
Sets the transmission channel. 

SetSerialChannel(SERIAL_CHANNEL_IR); // set channel to IR
Use one of the following constants: SERIAL_CHANNEL_IR, SERIAL_CHANNEL_PC. 

SerialPreamblePos()Value - Spy
Returns the preamble position within the serial data buffer.

x = SerialPreamblePos();
SetSerialPreamblePos(n)Function - Spy
Sets the position of the preamble within the serial data buffer. 

SetSerialPreamblePos(12); // set preamble pos to 12
SerialPreambleLen()Value - Spy
Returns the preamble length.

x = SerialPreambleLen();
SetSerialPreambleLen(n)Function - Spy
Sets the length of the preamble. 

SetSerialPreambleLen(3); // set preamble length to 3
SerialChecksum()Value - Spy
Returns the transmission checksum type.

x = SerialChecksum(); // SERIAL_CHECKSUM_SUM ??
SetSerialChecksum(check)Function - Spy
Sets the transmission checksum type. 

SetSerialChecksum(SERIAL_CHECKSUM_SUM); // use Sum checksum
Use one of the following constants: SERIAL_CHECKSUM_NONE, SERIAL_CHECKSUM_SUM, SERIAL_CHECKSUM_ZERO_SUM. 

SerialBiPhase()Value - Spy
Returns the transmission bi-phase mode.

x = SerialBiPhase(); // SERIAL_BIPHASE_OFF ??
SetSerialBiPhase(mode)Function - Spy
Sets the transmission bi-phase mode. 

SetSerialBiPhase(SERIAL_BIPHASE_OFF); // no bi-phase
Use one of the following constants: SERIAL_BIPHASE_OFF, SERIAL_BIPHASE_ON. 

Link to comment
Condividi su altri siti

Salve a tutti i fermodellisti Legosi... continuo con le idee di automazione ferroviaria per il diorama.

Sostengo la mia opinione, testata a Cavallino:

- binari 9V

- RCX 1.0 (con attacco per il trasformatore dei treni)

 

Più che d'accordo! Ho accumulato una decina di RCX per questo, purtroppo solo uno con alimentazione esterna :'(

 

Non sono molto ferrato in programmazione, ho realizzato un tram a 9 V, vorrei farlo fermare nei pressi di una banchina, sostare per x secondi, ripartire.

Poi magari dopo la sosta ripartire in senso inverso.....

 

Parliamone.... :P

Link to comment
Condividi su altri siti

Non sono molto ferrato in programmazione, ho realizzato un tram a 9 V, vorrei farlo fermare nei pressi di una banchina, sostare per x secondi, ripartire.

 

Questo lo fa il programma del semaforo postato qui

 

Poi magari dopo la sosta ripartire in senso inverso.....

 

Se il tratto è dritto e ti serve un avanti-indietro hai bisogno di due sensori luce di "fine corsa" ai due estremi meno la lunghezza del treno (serve spazio per frenare).

 

Quindi se il treno viene da sinistra la sequenza è binario - sensore - banchina - fine del binario, e l'altra stazione è simmetrica.

 

Il sensore funziona meglio se ha una luce davanti, va bene anche se la alimenti direttamente dalle rotaie.

 

Per far funzionare il programma, metti il treno in mezzo tra le due stazioni e lo fai partire

 

Listato per BrickxCC ed RCX

/*------------------------------------------------------------------------------
; File          : tram.nqc
; Description   : tram che va avanti e indietro su rotaia dritta
; Programmed by : Rudy
; ports:
: A
; B
; C  treno
; 1  sensore luce
; 2  sensore luce
; 3
; 4
;-----------------------------------------------------------------------------*/

task main()
{

;-----------------------------------------------------------------------------*/
 // da regolare a seconda del tracciato e del treno:
 // soglia a cui scatta il sensore (treno presente)
 int soglia = 10;
 // velocità massima del treno (minimo 1, massimo 7)
 int maxspeed=5;
;-----------------------------------------------------------------------------*/



 // disabilita lo spegnimento automatico dell'RCX
 SetSleepTime(0) ;

 // setta i sensori come sensori luce
 SetSensorType(SENSOR_1,SENSOR_TYPE_LIGHT);
 SetSensorMode(SENSOR_1,SENSOR_MODE_RAW);
 SetSensorType(SENSOR_2,SENSOR_TYPE_LIGHT);
 SetSensorMode(SENSOR_2,SENSOR_MODE_RAW);


 // variabili per le letture dei sensori luce
 int light1,light2;
 int light1_max = SENSOR_1;
 int light2_max = SENSOR_2;

 // accende il treno
 int verso=1;
 SetPower(OUT_C,maxspeed);
 OnFwd(OUT_C);

 int x;
 while (true) {
   // legge i sensori luce
   light1 = SENSOR_1;
   light2 = SENSOR_2;
   // regolazione automatica della soglia per la luce
   // varia con la luce ambiente e le macchine fotografiche in giro
   light1_max++;
   if (light1<light1_max)
     light1_max=light1;
   light2_max++;
   if (light2<light2_max)
     light2_max=light2;

   // controlla se il treno ha fatto scattare il sensore
   if (light1>(light1_max+soglia) || light2>(light2_max+soglia)) {
     // frena il treno
     Float(OUT_C);
     // aspetta x centesimi di secondo
     Wait(300);
     // riparte
     if (verso) {
       // riparte indietro
       OnRev(OUT_C);
     } else {
       // riparte avanti
       OnFwd(OUT_C);
     }
     // cambia verso per la prossima volta
     verso=1-verso;
     // aspetta x centesimi di secondo che il treno si levi dal sensore
     Wait(300);
   }
 }
}


Link to comment
Condividi su altri siti

 

Sostengo la mia opinione, testata a Cavallino:

- binari 9V

- RCX 1.0 (con attacco per il trasformatore dei treni)

 

 

Anche io ho questa soluzione testata e funzionante (almeno da Ballabio 2010), con tanto di scambi automatizzati.

 

Purtroppo non riesco mai a farla lavorare a pieno alle esposizioni, perché integrandomi nel Diorama City i circuiti non sono proprietà di un'unica persona, quindi se non ci si coordina anche sull'automazione si rischia la fine di Trenitalia... 8)

 

 

Inoltre se ci si coordina sulle specifiche (tipo altezza del binario in entrata ed uscita) ciascuno può automatizzare un modulo (penso anche ad esempio a mucche che girano la testa al passaggio del treno...) e poi si montano in sequenza nel diorama senza diventare matti per gestire una caterva di scambi

 

 

Propongo un gruppo di lavoro per scrivere le specifiche e mi ci butto dentro a pesce! Ci sei Rudy?

Link to comment
Condividi su altri siti

Propongo un gruppo di lavoro per scrivere le specifiche e mi ci butto dentro a pesce! Ci sei Rudy?

 

Forse non l'hai notato, ma questo è il gruppo di lavoro... ;D e tu ormai ci sei dentro 8)

 

Per favore parlaci di come funziona la tua automazione e cerchiamo di capire come mai non si è potuta integrare nel diorama.

 

Propongo la prima specifica: il percorso nel diorama deve essere ad ovali concentrici, ciascuno con un treno (oppure più treni nel caso di moduli con doppio binario)

 

 

Link to comment
Condividi su altri siti

Quindi, Rudy, iniziando da zero sarebbe preferibile (in termini di costi) prendere un RCX, giusto?

 

Secondo me è preferibile usare gli RCX, per una questione di costo, visto che si trovano a poco.

La programmazione mi sembra più semplice, probabilmente realizzabile anche con il software originale Mindstorm.

I sensori sono meno ingombranti, e se non si trovano gli RCX con alimentazione esterna, è possibile modificarli abbastanza semplicemente, senza troppi scrupoli 8)

 

Aggiungo che un RCX usato per automatizzare gli scambi 9V, e ne può gestire tre, può anche essere lasciato alimentato a pile. Lo scambio assorbe energia solo all'atto del movimento, le pile durano ore e ore!!

Link to comment
Condividi su altri siti

 

Forse non l'hai notato, ma questo è il gruppo di lavoro... ;D e tu ormai ci sei dentro 8)

 

Argh...

 

 

Per favore parlaci di come funziona la tua automazione e cerchiamo di capire come mai non si è potuta integrare nel diorama.

 

In sostanza non è molto diverso da quello che voleva fare Pix, ma la mia versione include l'uso degli scambi.

 

In sostanza, si tratta di far fermare il treno in una stazione, alla pressione di un pulsante (simulato da un touch sensor). Circuito di base 9V ed RCX per la parte di automazione.

 

Il treno gira per i fatti suoi su un ovale. La stazione si trova su un secondo binario, con scambi in entrata/uscita. Quando si preme il pulsante, un light sensor controlla la posizione del treno in prossimità dello scambio di entrata. L'RCX aziona lo scambio, rallenta il treno e lo ferma sul binario della stazione non appena raggiunge un secondo light sensor. Per far ripartire il treno si ripreme il pulsante. L'RCX aziona lo scambio in uscita, fa ripartire il treno gradualmente e lo riporta sul binario principale.

 

L'uso dello scambio anche in uscita serve a diminuire la resistenza in corrente quando il treno si trova sul binario della stazione. L'RCX non è molto potente in uscita, per cui con circuiti lunghi e/o treni pesanti le cose si fanno difficili.

 

Uno dei motivi per cui l'integrazione non ha funzionato è proprio quello della lunghezza del circuito e della corrente coinvolta. Ciascun tratto "automatizzato" probabilmente dovrebbe essere autonomo in corrente nel tratto di binario di propria competenza, che non può essere molto lungo.

 

Un altro problema è banalmente il fatto che l'automazione di base non era prevista inizialmente nel diorama City, che è pensato più per un display statico che per il lato ferroviario. I treni sono un compendio per far vedere qualcosa in movimento, ma non sono mai stati la vera attrazione principale del circuito.

 

Propongo la prima specifica: il percorso nel diorama deve essere ad ovali concentrici, ciascuno con un treno (oppure più treni nel caso di moduli con doppio binario)

 

Io invece nell'ottica precedente, se vogliamo adottare 9v, proporrei una cosa leggermente diversa.

 

  • Decidere quanti treni si vogliono far girare sul circuito contemporaneamente.
  • In base al numero di treni contemporanei, prevedere un numero di ovali concentrici pari al numero di treni contemporanei.
  • Per ciascun ovale, ciascuna automazione viene prevista come "alterazione" rispetto al circuito iniziale (anche perché si suppone che il treno faccia qualcosa di diverso rispetto al girare in tondo)
  • Se l'automazione contiene una deviazione rispetto al circuito, debba prevedere SEMPRE un punto di ingresso ed uno di uscita verso il circuito principale.
    NOTA BENE: Il punto di ingresso e di uscita dell'automazione può essere lo stesso, attraverso il cambio di senso di marcia del treno. Es: una turntable che sostituisca il treno che sta girando sul circuito.
     
  • Ciascuna automazione deve essere indipendente in alimentazione della propria parte di circuito coinvolta

 

Questo è più o meno ciò che comincia a frullarmi per la testa. Sarebbe poi il caso che il "gruppo di lavoro" si riunisse una volta, davanti ad un po' di cibo e di alcool, che le idee fluiscono meglio ;D

Link to comment
Condividi su altri siti

  • Quanta carne al fuoco... :P Andiamo con ordine:
     

In sostanza, si tratta di far fermare il treno in una stazione, alla pressione di un pulsante
 
Bravo, il tuo modulo concettualmente funziona: un ingresso, un uscita ed il treno che fa qualcosa.
 
Per prima cosa penso che vada evitato l'intervento del "macchinista", quindi abbiamo due alternative:
- sostituiamo il pulsante con un sensore luce in modo da farlo attivare dal treno che passa
- mettiamo il pulsante a disposizione del pubblico ???
 
 
 
 

L'RCX non è molto potente in uscita, per cui con circuiti lunghi e/o treni pesanti le cose si fanno difficili.
 
Infatti: le specifiche tecniche dell'RCX parlano chiaro: la corrente massima assorbita dal motore del treno corrisponde alla corrente massima erogata da due porte dell'RCX, se ci aggiungiamo anche tutti i binari del diorama il treno si ferma di sicuro.
 

Ciascun tratto "automatizzato" probabilmente dovrebbe essere autonomo in corrente nel tratto di binario di propria competenza, che non può essere molto lungo.
 
Su questo siamo pienamente d'accordo: ogni partecipante crea ed alimenta solo il suo modulo, che va regolato in potenza per non far deragliare i treni che passano
 
 

  • Decidere quanti treni si vogliono far girare sul circuito contemporaneamente.
  • In base al numero di treni contemporanei, prevedere un numero di ovali concentrici pari al numero di treni contemporanei.

 

Qui non sono d'accordo: ho visto agli eventi decine di treni e pochi binari su cui farli correre. Inoltre la gestione del diorama è già di suo impegnativa. Secondo me prima vanno posati gli ovali in base allo spazio ed agli edifici e poi ci si mettono i treni a rotazione.

 

 

 

  • Per ciascun ovale, ciascuna automazione viene prevista come "alterazione" rispetto al circuito iniziale (anche perché si suppone che il treno faccia qualcosa di diverso rispetto al girare in tondo)
  • Se l'automazione contiene una deviazione rispetto al circuito, debba prevedere SEMPRE un punto di ingresso ed uno di uscita verso il circuito principale.

 

Qui siamo come nel GBC: ogni modulo ha un ingresso ed un uscita, poi su quello che fa c'è la massima libertà di espressione ;D

 

 

 

NOTA BENE: Il punto di ingresso e di uscita dell'automazione può essere lo stesso, attraverso il cambio di senso di marcia del treno. Es: una turntable che sostituisca il treno che sta girando sul circuito.

 

Eliminerei questo strappo alla regola: sai meglio di me che con i 9V non puoi fare il circuito "a racchetta", quindi niente inversioni di marcia. Se poi riesci a farle prendendo atto che il resto del circuito non inverte il senso di marcia solo per te mi va anche bene

 

 

  • Ciascuna automazione deve essere indipendente in alimentazione della propria parte di circuito coinvolta

 

Anche su questo sono d'accordo, anche per i motivi di alimentazione da parte dell'RCX visti sopra.

 

Questo è più o meno ciò che comincia a frullarmi per la testa. Sarebbe poi il caso che il "gruppo di lavoro" si riunisse una volta, davanti ad un po' di cibo e di alcool, che le idee fluiscono meglio ;D

 

Sul cibo ed alcool sono pienamente d'accordo :D ma per quest'anno sarà già tanto riuscire a far funzionare il modulo di Pix per Ballabio ;D

 

Riassiumiamo quindi i punti fondamentali del [glow=red,2,300]regolamento per automazione ferroviaria agli eventi[/glow]:

 

Il modulo partecipante al diorama ferroviario dovrà tassativamente avere le seguenti caratteristiche:

[*]Essere costruito con binari 9V, che possono essere isolati dal resto del diorama con un binario corto dritto PF

[*]Avere un punto di ingresso ed un punto di uscita in modo da poter essere inserito in un ovale

[*]Essere alimentato in maniera autonoma ed indipendente

[*]Essere autonomo (non deve aver bisogno dell'intervento del capostazione)

[*]Avere la possibilità di regolare la velocità del treno

[*]NON sono consentite inversioni di marcia (il resto dell'ovale non cambia il senso di marcia)

[*]Essere bello e divertente :D

[*]...

 

 

Link to comment
Condividi su altri siti

 

 

Bravo, il tuo modulo concettualmente funziona: un ingresso, un uscita ed il treno che fa qualcosa.

 

Per prima cosa penso che vada evitato l'intervento del "macchinista", quindi abbiamo due alternative:

- sostituiamo il pulsante con un sensore luce in modo da farlo attivare dal treno che passa

- mettiamo il pulsante a disposizione del pubblico ???

 

La seconda tutta la vita :D. La MOC di Kim a Cavallino ha molto da insegnare in questo senso...

 

 

 

Qui non sono d'accordo: ho visto agli eventi decine di treni e pochi binari su cui farli correre. Inoltre la gestione del diorama è già di suo impegnativa. Secondo me prima vanno posati gli ovali in base allo spazio ed agli edifici e poi ci si mettono i treni a rotazione.

 

Forse non sono stato chiaro: il mio "quanti treni girano" va inteso in parallelo, nel senso che se vogliamo vedere tre treni girare, bisogna prevedere tre circuiti. Non che se abbiamo dieci treni da far girare dobbiamo prevedere dieci ovali :) Quanti treni ha la gente è indifferente, possiamo portarne anche 100 e alternarli a girare sui tre circuiti :)

 

L'idea era di fare in modo di avere un certo numero di circuiti indipendenti, in modo da creare meno deragliamenti, casini, mancanze di corrente ecc. Allo stesso tempo più circuiti = più movimento = più divertimento per il pubblico!

 

Eliminerei questo strappo alla regola: sai meglio di me che con i 9V non puoi fare il circuito "a racchetta", quindi niente inversioni di marcia. Se poi riesci a farle prendendo atto che il resto del circuito non inverte il senso di marcia solo per te mi va anche bene

 

Anche qui mi son spiegato male. Mettiamola in questi termini: prevediamo di avere automazioni "a binario morto", ossia che possano essere eseguite indipendentemente dal circuito principale, vedi l'esempio della piattaforma girevole: voglio poter parcheggiare in deposito un locomotore e farne uscire un altro. È chiaro che il deposito può essere considerato un "binario morto", oppure un punto di ingresso/uscita.

In questo caso, chiaramente l'ovale deve continuare a funzionare, indipendentemente dallo stato della piattaforma girevole. Non pensavo certo a circuiti a cappio, che come dici tu sono cortocircuitati per natura.

 

Poi, se vogliamo mantenere ferma la specifica del diorama, basta prevedere che il treno in parcheggio entri sempre dallo stesso binario ed il treno di uscita esca da un altro binario, ciascuno col suo scambio di ingresso/uscita verso l'ovale di competenza.

 

Link to comment
Condividi su altri siti

I sensori sono meno ingombranti, e se non si trovano gli RCX con alimentazione esterna, è possibile modificarli abbastanza semplicemente, senza troppi scrupoli 8)

Non è necessario, basta avere un alimentatore capace di erogare 2A (giusto per stare larghi) a 9V e lo attacchi con dei morsetti ai contatti delle pile :)

Stando attenti alla polarità, ovvio.

Link to comment
Condividi su altri siti

Ragazzi!

Ho finito adesso di leggere tutto, purtroppo in queste discussioni è facile perdere il filo....... ::)

 

Butto giù qualche idea, legata a caso ai post precedenti:

- cercherei di non voler fare cose troppo complesse, meglio poche ma sicuramente funzionanti, vedere persone che per tutto l'evento programmano, spostano sensori, e raccolgono treni deragliati non è bello. :D

 

- Modularità: ogni pezzo di circuito dovrebbe avere un funzionamento indipendente e completo. Che ci siano o non ci siano altre automazioni. Ovviamente alimentato a se stante..... Sarà forse necessario fare dei binari "sezionati" per il passaggio tra tratti di linea appartenenti a due alimentatori diversi!

 

Corrente di alimentazione: l'RCX ha poca potenza, come potremmo migliorare? Per gli scambi non è un problema, assorbono poco e per poco tempo. Io avevo provato a motorizzare la manopola di un alimentatore 9 V, un disastro! :'(

 

Pensiamo non solo agli scambi, ma anche agli incroci, è bello vedere un treno che si ferma, per dare la precedenza ad un secondo treno che transita e lo incrocia, uno dei treni potrebbe essere un tram cittadino!

 

Le varie idee di circuito le potremmo disegnare con quel software ferroviario, non mi ricordo più come si chiama e da dove scaricarlo :'(

Link to comment
Condividi su altri siti

Butto giù qualche idea, legata a caso ai post precedenti:

- cercherei di non voler fare cose troppo complesse, meglio poche ma sicuramente funzionanti, vedere persone che per tutto l'evento programmano, spostano sensori, e raccolgono treni deragliati non è bello. :D

 

Credo che in questo aspetto vada presa a nostro uso e consumo l'esperienza del GBC: ciascuna automazione va provata e resa funzionante per proprio conto, collegandola possibilmente ad un circuito di base e vedendo come si comporta. Se resta nelle specifiche che saranno definite, va bene, qualunque sia la sua complessità.

Esattamente come nel GBC, se un modulo non funziona, si scarta e si rimanda a settembre :)

 

Sarà forse necessario fare dei binari "sezionati" per il passaggio tra tratti di linea appartenenti a due alimentatori diversi!

Secondo me, no, anzi...

 

Se ciascuno alimenta la sua sezione il numero di tratti alimentati aumenta ed il circuito ha più probabilità di essere alimentato in tutti i suoi tratti senza problemi. Si deve prevedere isolamento per le sezioni solo se pensiamo di aggiungere un'alimentazione continua "esterna" alle automazioni (un trasformatore), per garantire eventualmente la corrente in tratti dove il circuito non dovesse essere raggiunto dalla corrente degli RCX.

 

Corrente di alimentazione: l'RCX ha poca potenza, come potremmo migliorare? Per gli scambi non è un problema, assorbono poco e per poco tempo. Io avevo provato a motorizzare la manopola di un alimentatore 9 V, un disastro! :'(

 

Vedi sopra...

 

Le varie idee di circuito le potremmo disegnare con quel software ferroviario, non mi ricordo più come si chiama e da dove scaricarlo :'(

 

Credo tu stia parlando di BlueBrick, che si scarica qui:

 

http://bluebrick.lswproject.com/

Link to comment
Condividi su altri siti

Le varie idee di circuito le potremmo disegnare con quel software ferroviario, non mi ricordo più come si chiama e da dove scaricarlo :'(

 

E qua torna il ferroviere.... ::)

 

Scusate ma mi spiego meglio: non stiamo lavorando all'automazione del diorama personale, dove ci possiamo sbizzarrire con soluzioni di tutti i tipi per automatizzare gli scambi, farsi una plancia di comando degna della stazione di Milano (magari..... ;D ) e per cui serve una progettazione a monte di tutto l'impianto.

 

In questo caso stiamo lavorando ad un progetto comune che somiglia molto al GBC: ogni modulo accoglie un treno in ingresso e lo consegna al prossimo modulo in uscita. :P

 

Questo approccio elimina la necessità di coordinamento: come è stato giustamente detto se il modulo funziona rimane in linea, altrimenti viene sostituito da un binario dritto. I moduli si montano seguendo il tracciato del diorama che viene deciso dal coordinatore a seconda dei moduli a disposizione (portandosi comunque una scorta di binari dritti....)

 

Anche per questo aggiungo una regola:

 

  • il modulo va isolato in ingresso ma deve alimentare il binario d'uscita

 

Così il modulo non riceve interferenze di corrente dal modulo precedente ma alimenta la rotaia fino al modulo successivo.

 

Esempio: il mio modulo toglie la corrente per fermare il treno: se arriva la corrente del modulo precedente il mio treno non si ferma... ::)

 

Il modulo più semplice è un binario dritto attaccato al trasformatore.

 

Come per il GBC, le prove a casa si fanno collegando un ovale tra ingresso ed uscita e facendo correre due treni per simulare il caso peggiore... ;D

 

 

Scusate la verbosità ma capisco che stiamo mettendo insieme due mondi totalmente diversi, ed è meglio continuare a spiegare finché tutti hanno capito. ;)

 

 

Link to comment
Condividi su altri siti

 

O con l'RCX piloti un motore che aziona uno switch :)

Certo, perdi il controllo della velocità... comunque il treno del GBC funziona da anni con una sola uscita.

... E se invece di uno switch ne piloti due, su due trasformatori, settati uno a media velocità ed il secondo a velocità completa, nella stessa direzione?

 

In questa maniera non si può ottenere una specie di "cambio di velocità", combinando le direzioni degli switch?

 

 

Link to comment
Condividi su altri siti

... E se invece di uno switch ne piloti due, su due trasformatori, settati uno a media velocità ed il secondo a velocità completa, nella stessa direzione?

In questa maniera non si può ottenere una specie di "cambio di velocità", combinando le direzioni degli switch?

 

Secondo me aggiungiamo complicazione. ;)

 

Dobbiamo fare in modo che anche i meno esperti, siano in grado di costruire un "modulo" anche se semplice.

 

 

Link to comment
Condividi su altri siti

O con l'RCX piloti un motore che aziona uno switch :)

Certo, perdi il controllo della velocità... comunque il treno del GBC funziona da anni con una sola uscita.

 

e questa è la soluzione più semplice, e anche alla portata di tutti.

Se poi abbiamo un "alimentatore centrale" di potenza adeguata al quale allacciare TUTTI i cavetti di alimentazione, siamo a posto.

 

A questo punto gli RCX piuttosto che fornire energia al tratto di circuito, piloteranno un sistema on-off motorizzato, standard uguale per tutti.

 

E piuttosto che due switch che agiscono su due regolatori diversi, vorrei provare il sistema on-off che agisce in più tempi, esempio:

 

- treno in movimento

- off per 0,5 secondi

- on per 0,5 secondi

- off per 0,5 secondi

- on per 0,5 secondi

- off

 

per inerzia il treno dovrebbe "rallentare" anche se a scatti......

Link to comment
Condividi su altri siti

 

 

 

E piuttosto che due switch che agiscono su due regolatori diversi, vorrei provare il sistema on-off che agisce in più tempi, esempio:

 

 

- treno in movimento

- off per 0,5 secondi

- on per 0,5 secondi

- off per 0,5 secondi

- on per 0,5 secondi

- off

 

per inerzia il treno dovrebbe "rallentare" anche se a scatti......

 

Preferirei evitare di buttare motori, switch e motori di treni ad ogni esposizione :)

 

Link to comment
Condividi su altri siti

E piuttosto che due switch che agiscono su due regolatori diversi,

 

Raga... stiamo andando fuori dal seminato ;D

 

Confermo che il treno del GBC sta andando avanti e indietro da anni pilotato da un'unica uscita dell'RCX.

Anche il trenino di Cavallino era pilotato da un'unica uscita.

Come avevamo avuto già occasione di notare, il motore assorbe tutta quella potenza solo se in stallo, condizione che per fortuna è raro si verifichi in condizioni normali. ???

 

Riportiamoci sul giusto binario, confermo che un treno si può pilotare tranquillamente con un'uscita dell'RCX ;)

 

Link to comment
Condividi su altri siti

Riportiamoci sul giusto binario, confermo che un treno si può pilotare tranquillamente con un'uscita dell'RCX ;)

 

Hai ragione :D

 

Però il problema dell'alimentazione non va sottovalutato, per esempio io ho modificato un Emerald train e rifacendo i vagoni più lunghi e ce ne sono tre.

Ho dovuto modificare anche il tender e per muoverlo ho inserito DUE motori 9V.....

Ma ovviamente è un caso particolare

Link to comment
Condividi su altri siti

Tralasciando i casi particolari :D , riassiumo i punti fondamentali del [glow=red,2,300]regolamento per automazione ferroviaria agli eventi[/glow]:

 

Il modulo partecipante al diorama ferroviario ha le seguenti caratteristiche:

[*]Costruito con binari 9V

[*]Un binario singolo di ingresso ed un binario singolo di uscita in modo da poter essere inserito in un ovale

[*]Binario d'ingresso isolato con un segmento di binario PF, binario d'uscita alimentato

[*]Alimentazione autonoma ed indipendente

[*]Automatico (non deve aver bisogno dell'intervento del capostazione MA è consentito l'uso di un pulsante per il pubblico)

[*]Nel software ha la possibilità di regolare la velocità massima del treno

[*]NON contiene inversioni di marcia (il resto dell'ovale non cambia il senso di marcia)

[*]Bello e divertente :D

[*]...

 

 

Mi sembra che stia prendendo forma, mi piace ;D

 

Consigli per il materiale di base da usare:

- binari 9V :D

- trasformatore del treno

- RCX 1 con jack

- sensore luce RCX

- lampadina da mettere davanti al sensore luce (alimentata dalle rotaie con un attacco rotaia supplementare)

- motori PF con cavo adattatore

 

 

Link to comment
Condividi su altri siti

 

 

Su questo punto bisognerebbe solo verificare una cosa: che alla fine si riesca a chiudere il circuito fisicamente, soprattutto se ci sono degli scambi in giro. Assicuro che la cosa non è da prendere sottogamba e di rileggervi l'articolo di Bill Ward riguardo la geometria dei binari...

 

http://www.brickpile.com/track-layout-geometry/

 

  • Automatico (non deve aver bisogno dell'intervento del capostazione MA è consentito l'uso di un pulsante per il pubblico)

Aggiungerei una clausa sull'"automatico". Il modulo deve essere "non bloccante", ossia non posso fare un modulo che ferma il treno e per qualche motivo non lo fa mai più ripartire. Perlomeno, se quel treno non riparte, che venga sostituito con un altro sullo stesso ovale. Es. un disaccoppiatore di vagoni

 

So che sto facendo esempi complessi, ma se no finisce che ci ritroviamo con un ovale e venti stazioni che fanno fermare il treno per dieci secondi e lo fanno ripartire... Non mi pare molto divertente :)

 

Consigli per il materiale di base da usare:

 

...

- lampadina da mettere davanti al sensore luce (alimentata dalle rotaie con un attacco rotaia supplementare)

 

Io sto sperimentando l'uso delle luci led PF come alternativa, perché sono direzionali e in casi di illuminazione problematica "dovrebbero" essere più efficaci della lampadina.

Link to comment
Condividi su altri siti

Chiedo a Rudy che dopo Cavallino mi ha illuminato...

 

Il brick giusto è il Mindstorms RCX 1.0 with Power Jack - Complete Brick

 

Ho anche pensato a una cosa: se lo usi con delle batterie ricaricabili eviti di cancellare firmware e programma quando lo stacchi dalla corrente. 8)

 

Quando lo usi attaccato alla corrente, meglio togliere il coperchio del vano batterie e permettere una ventilazione per non surriscaldarlo. Ho visto la tua torretta, splendida con i rampicanti :o ma mi sa che con un uso intenso in ambiente estivo rischi di fondere tutto ??? Si potrebbe magari modificare sollevata da terra, senza pavimento e con delle feritoie sul tetto ad esempio.

 

PS: Per quanto riguarda l'illuminazione "problematica" vi assicuro che ne abbiamo avuta anche a Cavallino, ed è stata elegantemente aggirata tramite la calibrazione automatica del software 8) (non c'era alcuna schermatura)

Non discuto sulle luci da usare: quelle che ho consigliato sono più pratiche perché si attaccano direttamente alla rotaia, le altre hanno bisogno dell'adattatore ma consumano di meno. In pieno spirito AFOL create in libertà con quello che avete a disposizione ;D

 

 

Link to comment
Condividi su altri siti

Scusami, ma se alimento la lampadina dalle rotaie e fermo il treno, la lampadina non ha più tensione!!! ???

 

Si, ma la lampadina ti serve per segnalare l'arrivo del treno (= treno in corsa), quando fermi il treno e spegni la lampadina ormai il sensore ha già fatto il suo dovere.

 

Anche questo testato a Cavallino.... 8)

 

Link to comment
Condividi su altri siti

Crea un account o accedi per commentare

Devi essere un utente registrato per postare un commento

Crea un account

Iscriviti per un nuovo account nella nostra community. È facile!

Registra un nuovo account

Accedi

Hai un account? Accedi .

Accedi ora
  • Visualizzato ora da   0 utenti

    • Nessun utente registrato su questa pagina.

×
×
  • Crea nuovo...