Jump to content
Pix

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

Condividi questo post


Link al post
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)

Condividi questo post


Link al post
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?

Condividi questo post


Link al post
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

Condividi questo post


Link al post
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...

Condividi questo post


Link al post
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

Condividi questo post


Link al post
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

Condividi questo post


Link al post
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.

Condividi questo post


Link al post
Condividi su altri siti

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

Al momento non possiedo ne il BI ne l

Condividi questo post


Link al post
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

Condividi questo post


Link al post
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

Condividi questo post


Link al post
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? ;)

 

 

Condividi questo post


Link al post
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).

Condividi questo post


Link al post
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.

Condividi questo post


Link al post
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).

 

 

Condividi questo post


Link al post
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

 

 

 

Condividi questo post


Link al post
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. 

Condividi questo post


Link al post
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

Condividi questo post


Link al post
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);
   }
 }
}


Condividi questo post


Link al post
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?

Condividi questo post


Link al post
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)

 

 

Condividi questo post


Link al post
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...