Jump to content

Idea! NXT Automazione Treni


Post raccomandati

Per chi avesse preso per la prima volta in mano un RCX, ripeto una piccola [glow=red,2,300]guida per l'uso[/glow]:

 

Per la torretta USB va scaricato il driver presente nel file tower164.zip

Si apre lo zip

Si esegue il file "LEGO MindStorms SDK.exe"

Si collega la torretta USB

 

Se invece siete fortunati ed avete un PC con porta seriale e torretta seriale, non serve installare nessun driver.

 

Come software mi piace usare BricxCC.

 

Vantaggi:

- funziona sia su RCX che su NXT

- usa il firmware standard LEGO, (si possono caricare contemporaneamente anche programmi fatti tramite l'interfaccia LEGO)

- usa tutti i comandi disponibili, anzichè il set limitato dell'interfaccia grafica

 

Svantaggi:

- non possiede funzioni avanzate (tipo calcoli in virgola mobile, shift, od array multidimensionali, ma nelle normali applicazioni non se ne sente la mancanza)

- va scritto come un testo (ma esiste sempre il copia-incolla...)

 

Per utilizzarlo:

 

Scaricate ed installate BricxCC dalla pagina ufficiale

 

Per chi conosce l'inglese qui c'è il tutorial e qui ci sono le FAQ

 

Scaricate il firmware LEGO per l'RCX (firm0328.lgo) che si trova nel MINDSTORMS® SDK2.5 che va scaricato ed installato. Il file firm0328.lgo va preferibilmente copiato a mano nella cartella del BricxCC, visto che va reinstallato ogni volta che l'RCX rimane senza alimentazione.

 

Se usate Vista o superiori, scaricate ed installate anche il Microsoft WinHelp viewer per far funzionare l'aiuto sulle funzioni

 

Finalmente siete pronti per iniziare:

- Collegate la torretta

- Accendete l'RCX e posizionatelo di fronte alla torretta, ad una ventina di centimetri di distanza

- Fate partire BricxCC

- Dal menù che appare selezionate nel primo menù USB (per la torretta USB) o COMx (per la torretta seriale, dove X è il numero della porta, solitamente 1: es: COM1)

- Selezionate dal menù a destra RCX

- Lasciate il firmware su "standard" e cliccate su OK

 

Per gli esperti: nel menù "Edit" - "Preferences" nel tab "General" possiamo selezionare "Use fast mode" e "2X" per dimezzare il tempo di caricamento del firmware.

Nella stessa finestra, nel tab StartUp possiamo anche selezionare tipo di connessione e di brick per il prossimo avvio e poi cliccare su OK

 

Se sull'RCX appare solo l'icona dell'omino senza i quattro zeri, va caricato il firmware (la stessa cosa che mettere Win su un computer):

 

- Aprire il menù "Tools"

- Cliccare su "Download firmware"

Si apre una finestra dove cercare il file firm0328.lgo che si trova nella cartella dove avete installato il MINDSTORMS® SDK2.5, oppure dove l'avete copiato in precedenza.

Il firmware viene caricato sull'RCX, ci vogliono circa quattro minuti durante i quali sul display dell'RCX c'è un numero che avanza.

Alla fine l'RCX emette il suono di OK e sul display appaiono quattro zeri a sinistra dell'omino.

Se ci sono errori, la torretta è troppo lontana o troppo vicina all'RCX oppure ci sono interferenze (troppa luce o telecomandi ad infrarossi nei dintorni)

 

A questo punto per usare uno dei programmi che ho postato basta cliccare nel messaggio del forum sulla scritta "Seleziona" all'inizio del codice, usare la funzione "copia" (CTRL-C), passare a BricxCC, cliccare sulla prima icona in alto a sinistra (New file), usare "incolla" (CTRL.V) e salvare il file con l'estensione .nqc (ad esempio treno.nqc).

 

PS: Dopo salvato, portando il cursore su un'istruzione in blu, cliccando di nuovo con il tasto destro e selezionando "Topic Search" appare l'aiuto in inglese che spiega a cosa serve quell'istruzione.

 

Per caricare il programma sull'RCX,:

- Salvo il programma con l'icona blu del disco in alto a sinistra

- Seleziono il numero del programma (di solito Program 1) dal menù in alto

- Clicco sull'icona blu a onde a sinistra del menù di selezione dei programmi

Dopo un pò di tempo l'RCX dà il suono di OK ed il programma è pronto per essere eseguito

 

Per oggi basta, se servono delucidazioni chiedete pure...

 

PS: Visto che di questi tempi non si sa mai, aggiungo che questi software e driver sono forniti così come stanno, senza nessuna autorizzazione della LEGO.

Su questi non vi è alcun supporto ufficilale nè mio nè della LEGO.

Vengono inoltre forniti a titolo gratuito senza alcuna garanzia, utilizzateli a vostro rischio.

Nè la LEGO nè io siamo responsabili di eventuali danni che possono essere provocati dall'utlilzzo degli stessi

 

Link to comment
Condividi su altri siti

Scaricate il firmware LEGO per l'RCX (firm0328.lgo) che si trova nel MINDSTORMS® SDK2.5 che va scaricato ed installato. Il file firm0328.lgo va preferibilmente copiato a mano nella cartella del BricxCC, visto che va reinstallato ogni volta che l'RCX rimane senza alimentazione.

 

Solo una precisazione: il software SDK2.5 va installato solo per avere il file firm0328.lgo?

Questo software può essere rimosso oppure ha qualche altra utilità!

 

grazie

Link to comment
Condividi su altri siti

Solo una precisazione: il software SDK2.5 va installato solo per avere il file firm0328.lgo?

 

Il SDK (che risale al 2008) è roba da nerd: contiene vari firmware e documentazione tecnica per RCX 1 e 2, Scout e Spybotics. Contiene anche librerie ed headers in C per sviluppare software su PC.

 

Nel 99,9% dei casi installi, recuperi il firmware e poi cancelli il resto.

 

Un altro modo per recuperarlo è dal CD del RIS 2.0 8)

 

PS: Grazie in anticipo per la prossima pubblicazione, please citare l'autore grazie ;)

 

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,

 

Quattro segmenti fanno un binario dritto, quindi i conti per compensare il circuito sono facili da fare ;)

 

Anche sul modulo "non bloccante" sono d'accordo, a Cavallino abbiamo testato che un tempo di "fermo macchina" di tre secondi è più che sufficiente per un modulo semaforo. 8)

 

 

Link to comment
Condividi su altri siti

Alura,

 

Ho appena messo in rete un [EDIT]

di un primo studio per l'Automazione Treni Modulare ItLUG (che roba altisonante!)

 

Il "modulo" dovrebbe essere una stazione: c'è un ovale principale ed uno scambio interno, che rappresenta la stazione.

 

Il treno fa X giri dell'ovale, dopodiché al quarto scambia verso la stazione, rallenta e si ferma. Resta in stazione Y secondi, dopodiché riparte, riaccelera e torna a fare X giri dell'ovale.

 

Prime riflessioni sulla realizzazione del modulo:

 

  • Ho usato un ovale molto piccolo, per cercare di capire come si comportava il treno in condizioni "minime" di funzionamento, per rispettare i vincoli richiesti dal modulo (vedi post precedenti, non sto a ripetermi)
  • Come fatto già notare, per poter chiudere l'ovale ho dovuto usare due pezzi di flexible track, uno per isolare il modulo in ingresso ed un altro per "chiudere il circuito". Risultato: il modulo è isolato completamente dal resto del circuito, ma questo non crea grossi problemi se il modulo è uno solo. Bisogna però prevedere il problema nel circuito finale, se i moduli presenti non sono multipli di 4. Una soluzione ce l'ho, ma ve la illustro in un altro post.
  • La parte di circuito che non fa parte del modulo, per il motivo di sopra, è alimentata autonomamente da un trasformatore.
  • All'inizio del codice dell'algoritmo di controllo ho inserito una routine di "taratura" dei sensori di luce e di "reset" degli scambi. La prima permette di configurare una soglia per i due sensori, semplicemente coprendo ciascun sensore, premendo un "tasto"(touch sensor), togliendo la copertura e ri-premendo il tasto. La seconda fa girare in entrambi i sensi i motori degli scambi una volta, in modo da avere la posizione di partenza sempre predefinita. Non sono stato a testare il senso di marcia dei motori, controllo banalmente la prima volta che faccio partire la routine se li ho collegati giusti, se no giro di 90 gradi il cavetto di connessione e via andare :)
  • I sensori di luce sono collegati ad una sola porta di input dell'RCX. Con un treno corto, i sensori vengono sollecitati uno alla volta (quello di prossimità alla stazione e quello di arrivo in stazione), per cui si possono controllare uno per volta e non ci sono problemi. Non ho fatto test con un treno che coprisse entrambi i sensori, ma credo che l'RCX misuri il valore del light sensor in termini di "resistenza alla luce", quindi se entrambi i sensori sono coperti, il valore dovrebbe essere più alto che se ne si copre solo uno. A questo punto, basta fare la taratura dei sensori correttamente all'inizio e i due sensori vengono rilevati nell'ordine giusto.

 

Perché le cose siano più chiare, vi allego il codice in NQC:

 

/* CONNESSIONI RCX :
// OUT_A = circuito treno
// SENSOR_1 = Stack Sensori luce
// SENSOR_3 = Touch sensor (taratura)
*/


/* Imposta la soglia per il sensore di luce */
void set_threshold  (int sensor_number, int &light_up, int &light_down) {

 int touch = 0;
 /* Soglia superiore - Meno luce*/
 while (touch  == false) { touch = SENSOR_3; }
 light_up = SENSOR_1;
 PlaySound(SOUND_DOUBLE_BEEP);

 /* Soglia Inferiore - Più luce */
 touch = 0;
 Wait(200);
 while (touch  == false) { touch = SENSOR_3; }
 light_down = SENSOR_1;
 PlaySound(SOUND_DOUBLE_BEEP);
 Wait(200);
}

void train_start (int speed) {

SetPower(OUT_A, speed);
OnFwd(OUT_A);

}

void train_accelerate (int &speed, int delta) {
   speed = speed + delta;
   SetPower(OUT_A,speed);
}

void train_decelerate (int &speed, int delta) {
   speed = speed - delta;
   SetPower(OUT_A,speed);
}

void train_stop () {
    Rev(OUT_A);
    Off(OUT_A);

}

void switch_reset() {
    SetPower (OUT_C,3);
    OnFwd (OUT_C);
    Wait(50);
    Off(OUT_C);
    OnRev (OUT_C);
    Wait (50);
    Off(OUT_C);
}

void switch_station() {
    SetPower (OUT_C,3);
    OnFwd (OUT_C);
    Wait(50);
    Off(OUT_C);
}

void switch_main () {
    SetPower (OUT_C,3);
    OnRev (OUT_C);
    Wait (50);
    Off(OUT_C);
}


int current_speed;
/* Programma principale */
task main (){

    /* Numero giri prima del fermo in stazione */
    int round_numbers = 3;
    int round_counter = 0;


    /* Sensore 3 - tocco */
    SetSensor (SENSOR_3, SENSOR_TOUCH);
    SetSensorMode (SENSOR_3, SENSOR_MODE_BOOL);

    /* Sensore 1 - Luce */
    SetSensor(SENSOR_1,SENSOR_LIGHT);
    SetSensorMode(SENSOR_1,SENSOR_MODE_RAW);

    //Soglie ingresso
    int up_th_in;
    int down_th_in;

    //Soglie Uscita
    int up_th_out;
    int down_th_out;

    //Taratura soglie ingresso
    PlaySound (SOUND_UP);

    /* Controllo Soglia sensore ingresso */
    set_threshold(SENSOR_1,up_th_in,down_th_in);

    Wait (100);
    PlaySound (SOUND_UP);

    /* Controllo soglia sensore uscita */
    set_threshold(SENSOR_1,up_th_out,down_th_out);

    /* Reset Scambi */
    switch_reset();

    // Valori correnti dei sensori di luce
    int pre_station;
    int in_station;
    int delta_light = 5;

    // Modificatori velocità del treno
    int base_speed = 2;
    int current_speed = base_speed;
    int delta_speed = 1;

    Wait (100);
    train_start(base_speed);
    Wait(100);
    train_accelerate(base_speed,delta_speed);
    current_speed = base_speed;

    //Inizio ciclo controllo treno
    while (true){

          //Lettura sensore ingresso
          pre_station = SENSOR_1;
          while (pre_station  < (up_th_in - delta_light))
                { pre_station = SENSOR_1; }
          // Non ho raggiunto il numero massimo di giri per entrare in stazione
          if (round_counter < round_numbers) {
             round_counter ++ ;
             Wait(100);
          } else { // Ho raggiunto il numero di giri per entrare in stazione
             round_counter = 0;

             //scambio
             train_decelerate(current_speed, delta_speed);
             switch_station();
             in_station = SENSOR_1;
             while (in_station  < (up_th_in - delta_light))
                   { in_station = SENSOR_1; }
             //Sensore_stazione - STOP treno
             train_stop();
             Wait (500);
             train_start(current_speed);
             Wait (50);
             train_accelerate (current_speed, delta_speed);
             Wait (300);
             switch_main();
          }

     }



}

Link to comment
Condividi su altri siti

Ho appena messo in rete un video

 

link non funzionante... consiglio di correggerlo ;)

 

Il treno fa X giri dell'ovale, dopodiché al quarto scambia verso la stazione, rallenta e si ferma. Resta in stazione Y secondi, dopodiché riparte, riaccelera e torna a fare X giri dell'ovale.

 

quindi la logica è

- inizializzo lo scambio e sensori

- conto i passaggi al sensore

-- al terzo attivo lo scambio

-- al quarto:

--- tolgo corrente al binario stazione

--- rimetto lo scambio a posto

--- attesa 3 secondi

--- faccio ripartire il treno

 

Per semplificarti la vita, basta motorizzare uno scambio solo (visto che sono tallonabili ed il treno va sempre nello stesso senso)

 

Per la taratura dei sensori, consiglio di usare la mia taratura automatica: fai a meno del touch e ti semplifichi ulteriormente la vita...

 

Quindi hai collegato i sensori luce alla stessa porta e funziona? Le specifiche dicono che non si può, mi sa che mi tocca fare delle prove perché ci serve anche per il tram

 

 

 

Perché le cose siano più chiare, vi allego il codice in NQC:

 

Bravo, sei promosso ;)

 

 

 

Link to comment
Condividi su altri siti

 

Quindi hai collegato i sensori luce alla stessa porta e funziona? Le specifiche dicono che non si può, mi sa che mi tocca fare delle prove perché ci serve anche per il tram

 

 

Io le specifiche non le sapevo, ho settato la misurazione dei sensori come SENSOR_RAW, per avere una precisione maggiore nella misura ed ha funzionato tutto...

Link to comment
Condividi su altri siti

 

Per semplificarti la vita, basta motorizzare uno scambio solo (visto che sono tallonabili ed il treno va sempre nello stesso senso)

 

 

È vero, ma così perdo meno corrente. Ho notato che se gli scambi sono entrambi "girati" ho meno resistenza sul circuito elettrico e la velocità del treno è più controllabile. Non so se è solo un problema dei miei scambi (li ho comprati tutti usati) o se la cosa sia vera in generale...

 

 

Per la taratura dei sensori, consiglio di usare la mia taratura automatica: fai a meno del touch e ti semplifichiulteriormente la vita...

 

La differenza principale sta nel fatto che io uso anche una soglia per la luce minima, che viene molto utile per usare i due sensori collegati sullo stesso ingresso.

 

La tua idea comunque idea è buona, però la taratura è sempre dipendente dal resto del codice, perché è nello stesso task.

 

Secondo me si può notevolmente migliorare, usando un task separato, che così gira in parallelo e mantiene sempre al meglio il valore di soglia per la luce.

 

Una roba del genere:

 

 

/* NOTA: La variabile di soglia deve diventare globale, perché possa essere aggiornata anche nel main task */

int light_th_upper;

task sensor_tuning() {

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

task main() {

/* SNIP - Inizializzazione variabili */

start sensor_tuning; 

/* SNIP - Codice principale stazione */

}

Link to comment
Condividi su altri siti

Ho pensato anche una cosa: le rotaie del modulo vanno messe così come stanno o su baseplates?

 

Rotaie semplici:

  • Semplici da unire
  • Spoglie
  • ...

 

Con baseplates:

  • Va stabilito il punto esatto di entrata per tutti (centrale? laterale? Quanti stud?)
  • Belle da vedere e sfiziose da decorare
  • Aggiungiamo anche un brick di altezza per far passare i cavi?
  • ...

 

 

Si accettano proposte e commenti.

 

Link to comment
Condividi su altri siti

Beh secondo me il "modulo" è bello se ha anche un po' di decorazioni attorno, per cui sono ben accetti baseplates, fondo dei binari, catenaria, eccetera, ma lascerei il tutto alla libertà dell'autore.

 

I vincoli da rispettare secondo me devono essere i minimi per cui il singolo ovale si "chiuda" (vedi numero di flexible track da inserire in base al numero di moduli) e perché il singolo modulo non interferisca con gli altri. A questo proposito si può inserire una lunghezza minima del raccordo tra modulo ed ovale, in termini di numero di binari dritti/curvi. Un po'come per le dimensioni del cestone del GBC.

Link to comment
Condividi su altri siti

Stanotte ho fatto le prime prove della mia vita in ambito ferroviario LEGO...

Come avevo immaginato il segmento di rotaia flessibile viene tranquillamente ignorato dal motore 9V, in quanto prende corrente sia dall'asse anteriore che da quello posteriore ed almeno un asse è sempre in contatto con le rotaie mentre lo supera. 8)

 

Offendo i puristi della geometria :D il mio ovale anche se piccolo "chiude" regolarmente anche con quel quarto di dritto in più, che presenta una leggera curvatura.

Ne deduco che su un tracciato tipo Ballabio se le stazioni sono uguali ai due lati ben venga, altrimenti la differenza di +1 / -1 sul circuito si può tranquillamente ignorare.

 

Ho notato che se gli scambi sono entrambi "girati" ho meno resistenza sul circuito elettrico

 

La resistenza del circuito varia perchè gli scambi fanno passare la corrente solo nel lato scambiato.

Un interessante effetto secondario è che posso usare lo scambio per accendere e spegnere il treno nella stazione mantenendo il binario principale alimentato:

- attivo lo scambio di ingresso

- appena il treno entra in stazione rimetto diritto lo scambio

- a fine sosta rimetto lo scambio deviato

(sensore luce in stazione, scambio di uscita diritto, motore su scambio di entrata)

 

Con due treni:

- quando arriva un treno attivo gli scambi

(sensore luce in stazione1, sensore luce in stazione2, motore su scambio di uscita, motore su scambio di entrata)

 

In questo modo arriva il treno sul binario 1, lo scambio lo spegne, arriva il treno sul binario 2, viene spento dallo scambio che accende il treno sull'1

 

In questo caso vanno azionati entrambi gli scambi, altrimenti entrambi i binari rimangono alimentati dalla corrente che arriva dal secondo scambio.

 

La differenza principale sta nel fatto che io uso anche una soglia per la luce minima

 

Che secondo me si può tranquillamente eliminare ;)

 

Secondo me si può notevolmente migliorare, usando un task separato

 

Alla faccia delle finezze ??? Geniale, ma tieni presente che con il task parallelo tari il sensore anche quando il treno è fermo proprio davanti e può portare ad un falso positivo 8)

 

 

Link to comment
Condividi su altri siti

 

Offendo i puristi della geometria :D il mio ovale anche se piccolo "chiude" regolarmente anche con quel quarto di dritto in più, che presenta una leggera curvatura.

Ne deduco che su un tracciato tipo Ballabio se le stazioni sono uguali ai due lati ben venga, altrimenti la differenza di +1 / -1 sul circuito si può tranquillamente ignorare.

 

 

 

a 3 euro a binario dritto, visto che a me se n'è già rotto uno solo tirandolo via dal brick 1x8 su cui era incastrato, direi che non si può ignorare nessuna curvatura "anomala"...

 

La resistenza del circuito varia perchè gli scambi fanno passare la corrente solo nel lato scambiato.

Un interessante effetto secondario è che posso usare lo scambio per accendere e spegnere il treno nella stazione mantenendo il binario principale alimentato:

 

Provato anche io, però preferisco rendere indipendente la direzione dello scambio dalla marcia del treno, perché diventa più facile fare modifiche dopo.

 

Poi, per il principio di indipendenza dei moduli, questi son gusti personali :)

 

Alla faccia delle finezze ??? Geniale, ma tieni presente che con il task parallelo tari il sensore anche quando il treno è fermo proprio davanti e può portare ad un falso positivo 8)

 

Considerato che il valore della soglia viene tarato solo quando si abbassa (più luce), non c'è pericolo che se ci passa il treno davanti venga tarato sbagliato, perché il valore del sensore è più alto (di parecchio), quindi la soglia non viene modificata. No falsi positivi :)

 

[EDIT]

Ti dirò di più, basta stoppare il task quando il treno è fermo...

[/EDIT]

 

Inoltre l'autotaratura non è in conflitto con la taratura manuale al primo colpo. Le due cose non si escludono, anzi consolidano il sistema 8)

 

P.S. Si vede che so informatico eh.... :P

 

Link to comment
Condividi su altri siti

Ho pensato anche una cosa: le rotaie del modulo vanno messe così come stanno o su baseplates?

 

Ok, tagliamo la testa al topo e via con l'ultima versione 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

[*]Costruito su baseplates 32x32

[*]Un binario singolo di ingresso a 4 stud dal bordo anteriore della baseplate

[*]Un binario singolo di uscita a 4 stud dal bordo anteriore della baseplate, in modo da poter essere inserito in un ovale

[*]Prima del binario d'ingresso va attaccato un segmento di binario PF per isolarlo dal precedente

[*]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 c'è 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

Il modulo partecipante al diorama ferroviario ha le seguenti caratteristiche:

[*]Costruito con binari 9V

[*]Costruito su baseplates 32x32

 

Non vorrei essere rompi...... ma:

se il modulo è costruito su basplates 32x32, diventa più difficile inserirlo in un diorama comunitario, dove altri hanno già pensato a basi, strade, ecc.

PEr esempio potrebbe esserci un ponte, come lo scorso anno, dove appoggiare i nostri binari, e saremmo obbligati a staccarli dalla base. Non che sia difficoltoso..... ;)

Link to comment
Condividi su altri siti

Per esempio potrebbe esserci un ponte, come lo scorso anno, dove appoggiare i nostri binari

 

Giusta obiezione, ma stiamo parlando di moduli indipendenti, a cui si possono anche attaccare binari supplementari.

 

Per il ponte invece si parla di binari "sciolti". Mi sa che un modulo stazione nel bel mezzo di un ponte non ci starebbe proprio bene... ;)

 

Link to comment
Condividi su altri siti

Ho un paio di brutte notizie per il nostro progettino di pilotare i PF con l'RCX.

 

La prima brutta notizia è che, come si può evincere CHIARAMENTE dalle specifiche del protocollo IR dei PF (http://www.philohome.com/pf/LEGO_Power_Functions_RC_v110.pdf, pagina 13), i bit sono codificati da un impulso IR di durata 156μs (6 cicli di una portante a 38kHz) seguito da un silenzio di durata 260μs per lo 0, o di 546μs per l'1. Per non parlare del mark di inizio trasmissione e dei bit di start e stop.

 

Invece l'RCX, come ho FACILMENTE scoperto su questa pagina (http://www.crynwr.com/lego-robotics/) usa un normale protocollo seriale con gli 0 trasmessi come impulsi e gli 1 come silenzio; a 2400bps questi durano 417μs, 209μs a 4800bps o 104μs a 9600bps.

 

Come vedete, quindi, non c'azzeccano. L'unica soluzione è pilotare direttamente il trasmettitore IR, ma non si può fare con il firmware standard; per questo serve BrickOS.

 

La seconda brutta notizia è che funziona solo con l'RCX 1.0, in quanto l'RCX 2.0 usa invece una portante di 76 kHz. Pare si possa impostare anche a 38 kHz, ma ci devo ancora investigare.... temo non sarà facile.

Link to comment
Condividi su altri siti

Ho un paio di brutte notizie per il nostro progettino di pilotare i PF con l'RCX.

 

Complimenti Gabriele per lo sforzo, ottima ricerca! Sono rimasto davvero stupito ed entusiasmato da quello che hai trovato!

 

Traduco per gli informolesi: :D

 

il PF è sintonizzato sulla "stazione radio" 38

l'RCX 1 è sintonizzato sulla "stazione radio" 38

l'RCX 2 è sintonizzato sulla "stazione radio" 76

 

La cosa è positiva perché solo l'RCX 1 ha la presa per il trasformatore dei treni ;D

 

A questo punto il problema è la lingua che parlano:

il PF ha "lettere" larghe 6 seguite da uno "spazio" largo 7 o uno spazio largo 14

l'RCX 1 usa "lettere" o "spazi" larghi uguali da 10, da 5 o da 3

 

Gabriele, riusciresti a fare delle prove per vedere se il PF ha una tolleranza e risponde anche ad impulsi che hanno una durata simile ai suoi?

 

Grazie ed ancora tanto di cappello!!

 

Link to comment
Condividi su altri siti

Gabriele, riusciresti a fare delle prove per vedere se il PF ha una tolleranza e risponde anche ad impulsi che hanno una durata simile ai suoi?

Il ricevitore ha una tolleranza, ma non è comunque sufficiente per i nostri impulsi. Potrei fare delle prove... ma non credo ci siano molte speranze, e comunque non ci riuscirei prima di Ballabio :(

Link to comment
Condividi su altri siti

sto facendo qualche prova e avendo poco tempo, preferisco sfruttare l'esperienza di chi ha già fatto!!!

 

Dunque, la mia stazione del tram con sensore di luce sotto la pensilina, quale soluzione è meglio per rilevare il treno?

 

1- sensore di luce + elemento bianco dalla parte opposta

2- sensore di luce + elemento riflettente (specchio, carta alluminio) dalla parte opposta

3- sensore di luce + led o lampadina, entrambe sotto la pensilina e elemento riflettente dalla parte opposta.

4- sensore di luce + led o lampadina dalla parte opposta

 

Le versioni 1, 2 e 3 mi permettono di avere alimentazione solo da un lato

La versione 4 mi permette di avere più "variazione" rilevata dall'RCX

 

Il mio dubbio è che la variazione di luce rilevata al passaggio del treno, rispetto alla luce ambiente, sia troppo bassa e quindi causa di errori

Fatta qualche prova, leggendo il display dell'RCX, con le versioni 1 e 2 ottengo valori che passano da 750 a 820 (senza treno e con treno presente)

Con la versione 3 i valori passano da 700 a 800 circa

Con la versione 4 i valori passano da 650 a 800 circa.

 

Certamente il software farà una taratura preliminare della luce ambiente!

 

Grazie

 

Link to comment
Condividi su altri siti

Direi che ti sei risposto da solo con le rilevazioni che hai fatto...

 

Infatti......

ma io ho solo fatto delle prove "sul banco", la domanda è quindi:

quanto deve essere almeno la variazione di "luminosità rilevata" per essere tranquilli? Tenendo conto che il tram quando passa davanti al sensore, comunque riflette un pò di luce anche lui. ::)

 

 

Link to comment
Condividi su altri siti

Ragazzi datemi una mano! :'(

 

I listati che avete pubblicato nei poste precedenti, non riesco a caricarli!

Mi dà tutta una serie di errori durante la compilazione, in effetti molte istruzioni non le capisco. Sembrano più "evolute" di quelle che conosco io

 

per esempio mi da errore su questa istruzione: SetPower(OUT_C,maxspeed);

 

Ovviamente sto usando il listato per RCX e trasmetto ad un RCX, il software Bricxcc che uso è del marzo 2011

 

E' chiaro che sono arrugginito nella programmazione, ma non credo di farcela da solo a fare il programma!

:'(

Link to comment
Condividi su altri siti

quanto deve essere almeno la variazione di "luminosità rilevata" per essere tranquilli?

 

A Cavallino abbiamo fatto le stesse prove, e la lettura più affidabile è stata quella con la luce davanti, nonostante il treno riflettesse pure lui.

 

Questo per i visitatori che passano e fotografano, oltre alla luce ambiente che varia durante la giornata. 8)

 

I miei listati pubblicati fanno una taratura automatica, e si aspettano una variazione di 10, modificabile all'inizio del programma che trovi qui.

 

Allego il listato per il treno con più fermate intermedie:

 

/*------------------------------------------------------------------------------
; File          : tram.nqc (va salvato come NQC prima di compilare)
; Description   : tram che va avanti e indietro su rotaia dritta
; Programmed by : Rudy
; ports:
: A
; B
; C  treno
; 1  sensore luce di fine corsa (inizio e fine)
; 2  sensore luce della stazione/stazioni
; 3
; 4
; NOTA: si possono attaccare più sensori di luce sulla stessa porta
;-----------------------------------------------------------------------------*/

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 un sensore
   if (light1>(light1_max+soglia) || light2>(light2_max+soglia)) {
     // frena il treno
     Float(OUT_C);
     // aspetta x centesimi di secondo
     Wait(300);
     if (light1>(light1_max+soglia)) {
       // cambia verso se è il sensore di fine
       verso=1-verso;
     }
     // riparte
     if (verso) {
       // riparte avanti
       OnFwd(OUT_C);
     } else {
       // riparte indietro
       OnRev(OUT_C);
     }
     // aspetta x centesimi di secondo che il treno si levi dal sensore
     Wait(200);
   }
 }
}



 

 

Link to comment
Condividi su altri siti

Allego il listato per il treno con più fermate intermedie e tempo di fermata casuale come richiesto 8)

 

/*------------------------------------------------------------------------------
; File          : tram.nqc (va salvato come NQC prima di compilare)
; Description   : tram che va avanti e indietro su rotaia dritta
; Programmed by : Rudy
; ports:
: A
; B
; C  treno
; 1  sensore luce di fine corsa (inizio e fine)
; 2  sensore luce della stazione/stazioni
; 3
; 4
; NOTA: si possono attaccare più sensori di luce sulla stessa porta
;-----------------------------------------------------------------------------*/

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;
 // tempo di sosta minimo del treno in secondi (0=non si ferma)
 int sosta_min=1;
 // tempo di sosta massimo del treno (meglio non esagerare)
 int sosta_max=4;
//----------------------------------------------------------------------------



 // 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 un sensore
   if (light1>(light1_max+soglia) || light2>(light2_max+soglia)) {
     // frena il treno
     Float(OUT_C);
     // aspetta x centesimi di secondo
     x=(random(sosta_max-sosta_min)+sosta_min)*100;
     Wait(x);
     if (light1>(light1_max+soglia)) {
       // cambia verso se è il sensore di fine
       verso=1-verso;
     }
     // riparte
     if (verso) {
       // riparte avanti
       OnFwd(OUT_C);
     } else {
       // riparte indietro
       OnRev(OUT_C);
     }
     // aspetta x centesimi di secondo che il treno si levi dal sensore
     Wait(200);
   }
 }
}



 

 

Link to comment
Condividi su altri siti

una domanda:

l'RCX con alimentazione supplementare, con cosa lo alimento?

Direttamente dal trasformatore del regolatore di velocità per treni?

Sì.

Devo/posso usare un qualsiasi alimentatore esterno con uscita 10-11-12 V?

Forse è possibile, ma non ci scommetterei...

Link to comment
Condividi su altri siti

l'RCX con alimentazione esterna, può avere anche le pile inserite?

 

Si, anche se consiglio di usare le ricaricabili e di non "inscatolare" l'RCX in modo che non si surriscaldi...

 

PS: State facendo anche voi le notti insonni a finire le vostre MOC all'ultimo momento? Non vedo l'ora di finire la mia Trench Run e manca sempre qualcosina...

Link to comment
Condividi su altri siti

Si, anche se consiglio di usare le ricaricabili e di non "inscatolare" l'RCX in modo che non si surriscaldi...

 

Non è necessario usare le ricaricabili (anche se anch'io le consiglio), in quanto l'RCX passa automaticamente dall'alimentazione esterna alle pile e viceversa, e comunque non le ricarica.

 

Semmai usando le ricaricabili ci può essere la fregatura che erogano solo 7,2 volt, e se sta pilotando un motore questo andrà più lento.

 

PS: State facendo anche voi le notti insonni a finire le vostre MOC all'ultimo momento? Non vedo l'ora di finire la mia Trench Run e manca sempre qualcosina...

 

Non ci crederai ma ho violato una delle regole fondamentali del GBC: mai fare un modulo una settimana prima.

Link to comment
Condividi su altri siti

Approfitto delle ferie per riportare in auge questo thread.

 

Prima domanda: a Ballabio ho visto un modo molto simpatico per motorizzare gli scambi con delle bellissime casette bianche con il tetto rosso contenenti un motore medio PF. Qualcuno ha le istruzioni per caso?

 

Seconda domanda ad un certo Pix: sotto i fumi delle abbondanti libagioni di Ballabio :D abbiamo parlato di una serie di possibili utilizzi per la tua stazione. Hai deciso come utilizzarla che ti scrivo il software?

 

PS: Sono contento che il tram abbia funzionato molto bene a Ballabio, complimenti!! 8)

 

Link to comment
Condividi su altri siti

PS: Sono contento che il tram abbia funzionato molto bene a Ballabio, complimenti!! 8)

 

Si il tram con il tuo software ha funzionato bene, ho modificato la parte "random" delle fermate, allungando i tempi e rendendoli molto casuali. Questo comportava che il tram rimaneva fermo anche un minuto o più sotto alla pensilina.

 

Ma questo, secondo me, aumenta il realismo, perchè c'è meno "movimento automatico", spesso ho sentito qualche visitatore che diceva: " il tram non parte più!", e poco dopo questo ripartiva!! :P

Da capire bene le situazioni quando il tram si fermava improvvisamente in aperta campagna ??? Anche se poi ripartiva senza problemi.

 

Bè anche i nostri treni veri, spesso si fermano in aperta campagna senza motivo! :-[

Link to comment
Condividi su altri siti

Riporto in auge questo topic perché mi sono arrivate delle domande interessanti per tutti.

 

Non ci crederai...ho comprato 2 rcx 1.0 (with jack) per futura "automazione treni", i sensori (4 luce e 2 touch) e la tower ir (usb) per comunicare tra pc e rcx.

A questo punto ti DEVO chiedere, siccome sono ignorante in merito, mi indichi il software di programmazione che usi tu?

 

Bravissimo! ;D

La mia preferenza va al bricxcc che somiglia molto al C

Qui trovi il tutorial per l'installazione

 

Un tutorial sul linguaggio di programmazione esiste o devo chiedere tutto a te?? :D:D

 

 

Per i programmi, si inizia facendo copia-incolla (tanto sono una manciata di istruzioni) e modificando a seconda di quello che ti serve.

 

Per i treni il robot deve solo modificare la corrente del binario e leggere i sensori, quindi ti basta imparare pochi comandi. Per i motori:

OnFwd("ports", "pwr"); // accende il motore
Off("ports"); // spegne il motore

 

Per i sensori:

SetSensor(IN_1,"type") ;  //accende il sensore
SENSOR_1;  //legge il sensore

 

Per il flusso del programma:

Wait(millisecondi); // aspetta 
until ("condizione"); // aspetta che si verifichi una condizione
repeat ("numero");  // ripete tot volte

 

Forse un giorno scriverò un tutorial, nel frattempo questo è semplice ed in inglese

 

Poi, ho un eeepc dell'asus (netbook piccolino bianco) con su windows xp home, puo' essere una buona scelta come base per preparare i programmi da lanciare all' rcx?

 

L'eepc con bricxcc va benissimo (se vuoi usare quello LEGO / NXT l'eepc non basta, già provato)

 

 

Link to comment
Condividi su altri siti

Grazie alla gentile collaborazione di Maurizio Di Palma abbiamo l'ultimo brick che ci mancava per l'automazione!!

 

Ora inizio mettendo sotto sforzo Paolo il ferroviere che ha appena acquistato l'RCX.

 

Automatizziamo il modulo stazione che hai portato a PSG

 

Ti servono due scambi, per costruirli usi questo progetto che funziona a meraviglia con l'RCX

 

Oltre ai vari brick normali, hai bisogno di due motori PF

 

8883-1.gif

 

Questi li colleghi ai cavi 9v e quindi all'RCX con i cavi adattatori

 

8886-1.gif

 

Hai bisogno anche di due sensori di luce

 

9758-1.gif

 

 

Il tracciato da costruire davanti alla stazione è questo:

 

---<====>---

binario singolo - primo scambio - binario doppio - secondo scambio

(La stazione si trova sul tratto di binario doppio)

Tutto con binari 9V, tranne un pezzo di flex all'inizio ed alla fine per isolare la stazione dal resto del tracciato che va alimentato normalmente con la rotella.

Il binario doppio è lungo a sufficienza per contenere un treno completo

 

 

Su ogni binario del tratto doppio va messo il sensore di luce da un lato ed una luce dall'altro, vanno fatte delle prove ma in genere è verso il bordo della stazione.

 

Collegamenti dell'RCX:

Output A - rotaia

Output B - scambi

Output C - semaforo (?)

Input 1 - sensore binario 1

Input 2 - sensore binario 2

 

Il software lo sto provando ma è semplicissimo:

 

- cambia i due scambi sul binario 1

- dai corrente al binario

- ripeti

-- aspetta un treno sul binario 1

-- togli corrente al binario

-- scambia sul 2

-- dai corrente al binario

-- aspetta un treno sul binario 2

-- togli corrente al binario

-- scambia sull'1

-- dai corrente al binario

 

lo posto quando funziona bene... alla prossima puntata se vi interessa!

 

Link to comment
Condividi su altri siti

Mi è balenata un'idea pazzerella...

 

Qualcuno ha questo brick?

 

Electric, Train 12V 2 x 3 Signal Light Brick with Red and Green Lights

 

70022.gif

 

Se qualcuno lo ha in casa, potrebbe per cortesia controllare cosa succede alimentandolo con il trasformatore/rotella del treno 9V?

 

Grazie

 

Link to comment
Condividi su altri siti

Senza ricorrere al forbidden building (e io l'ho fatto quando ero giovinetto 8)), come pensi di fare ad alimentare un mattoncino luminoso a 12V, che richiede un collegamento spina/presa, con un alimentatore 9V che ha il collegamento con il plate 2x2 elettrificato? :-[

 

Comunque l'esito te lo dico io.... si tratta di 2 LED montanti con orientamento inverso: se la corrente corre in un verso si accende il LED rosso, se inverti le polarità si accende il LED verde.

 

Link to comment
Condividi su altri siti

come pensi di fare ad alimentare un mattoncino luminoso a 12V, che richiede un collegamento spina/presa

 

Semplice (non inorridite!!!): si prende ad esempio questo:

 

Black Electric, Wire with Brick 2 x 2 x 2/3 Pair, 36 Studs Long

5311-1.gif

 

Si taglia a metà

Si attaccano due di queste:

 

Light Gray Electric, Connector, 2 Way male Squared Narrow Long - Complete Assembly

766c01.gif

 

Così usando solo LEGO otteniamo due cavi adattatori per i due semafori 8)

 

Ovviamente prima di attuare uno simile scempio :'( vorrei essere sicuro che il semaforo si accenda a 9V

 

 

se la corrente corre in un verso si accende il LED rosso, se inverti le polarità si accende il LED verde.

 

Questo lo sapevo grazie, l'unica incognita è se bastano i 9V della rotella per accenderli.

Puoi fare per cortesia una prova con dei fili volanti?

 

Link to comment
Condividi su altri siti

Per Piru, i led funzionano con 1volt circa, per cui una resistenza ci deve essere per forza da qualche parte.

Per Rudy, se non si accendono ci deve essere una resistenza di tal misura che non li fa accendere con meno di 12v, basta sostituirla e ricorda che la pratica delle volte ti fa saltare i componenti, bisogna partire dalla teoria, in rete ci sono tavole e specifiche per il dimensionamento delle resistenze e dei led.. :)

 

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...