sabato 6 dicembre 2008

creare icone nuove per nxt-g

Tratto da qui.

Usando la funzione dei MyBlock in NXT-G, si possono costruire propri blocchi. Un passo del processo di costruzione (vediqui) consiste nello scegliere l'icona da associare al MyBlock appena costruito.
per farlo, si puo' scegliere fra un insieme di icone predefinite (che si possono anche combinare). Ad un certo punto pero' finiscono le possibilita' di combinazione oppure l'icona non rende l'idea, per cui conviene crearsene da soli.

Supponiamo di voler creare questa:



La prima cosa da fare e' creare la figura che deve essere in formato PNG 32x32 con sfondo trasparente (in modo da renderla combinabile con altre). Usare Paint.NET per crearla.

La figura va messa nella cartella
C:\Program Files\LEGO Software\LEGO MINDSTORMS NXT\engine\Icons\MyBlock



Poi si procede come da procedura standard: una volta creato il MyBlock, al momento di associare le icone, si vedra' anche la nuova figura.



Attenzione che LEGO visualizza le prime 72 icone in ordine alfabetico!!!!!!!!
Per cui occorre fare i furbi nel dare il nome alla figura PNG se la si vuole vedere nella lista.

Comunque per fortuna LEGO memorizza l'icona dentro il programma .rbt che contiene il MyBlock creato. Per cui se la porta dietro ed e' possibile editarla se il programma rbt rimane nel computer.
Se si copia il MyBlock su un altro computer, il PNG originale non e' piu' disponibile sulla nuova macchina e la figura non puo' essere modificata.

domenica 23 novembre 2008

XXX ItLUG LEGOfest a Crema









programma usato (tratto da NXTLOG 2.0)




martedì 28 ottobre 2008

XXX ItLUG LEGOfest a Crema, 22 e 23 novembre 2008

XXX ItLUG LEGOfest a Crema, 22 e 23 novembre 2008

anche quest'anno all'interno di Dadi.com, che si terra' (al solito) presso la sede universitaria, in via Bramante 65, Crema

link

venerdì 24 ottobre 2008

labview per NXT

Qui si trovano vis di Gasperi di esempio per spiegare come controllare nxt con labview.
In attesa dell'uscita del libro.

PS: il libro e' uscito ma non si riesce ad ordinare dall'Italia

recensione

capitolo di esempio

venerdì 14 marzo 2008

programmare giochi sullo schermo del NXT

tutorial preparato da Guy su nxtlog che spiega come programmare piccoli videogames in NXT-G

domenica 2 marzo 2008

TDA8444 i2c multiple dacs

interfaccia di Gasperi per avere 8 uscite analogiche a 6bit di cui una pilota un VCO.

schema elettrico












il blocco NXT-G che lo pilota e' scaricabile dal sito di Gasperi
qui c''e il suo approccio labview

blocco principale:



































(unica) subVi:
all'InvokeNode va passato (oltre alla porta) un array costituito da :
indirizzo
canale e
"potenza"
















espansione delle subvi implicite:

getstatus




















e settypeand mode:

sabato 1 marzo 2008

links a siti che spiegano scilab

creo un altro blocco-note dedicato a scilab

per i fortunati possessori di Labview >8.0 e' disponibile il gateway Scilab-Labview

domenica 24 febbraio 2008

regolatore lqr per nxtway

tentativo di trovare il regolatore lqr (wiki) per il nxt di sybille mayer con scilab
attingendo a piene mani (copia-incolla) dal mitico R. Bucher


function [num,den]=tfdata(G)
num=G('num');
den=G('den');
endfunction

A=[0,1,0,0; 94.05,0,0,1.3;0,0,0,1; -544.05,0,0,-14.3]
B=[0;-0.21;0;2.32]
C=[1,0,0,0;0,0,1,0]
D=[0;0]
nxtway_SYB=syslin('c',A,B,C,D)
s=%s;
Ts=0.03
spec(A)
autovalori_di_A=spec(A)
sys=syslin('c',A,B,C,D);
sysd=dscr(sys,Ts);
[ad,bd,cd,dd]=abcd(sysd);

// pesi del controllore LQR

Q=diag([10000,1,10000,1]); // 4 per 4
R=[1]; // 1 per 1

//calcola i guadagni LQR per un sistema discreto
[n1,d1]=size(ad);
big=sysdiag(Q,R);
[w,wp]=fullrf(big ,1e-20);
C1=wp(:,1:n1);
D12=wp(:,n1+1:$);
P=syslin('d',ad,bd,C1,D12);
[k,X]=lqr(P)
k_lqr= -k;

E=spec(ad);
plqr=abs(real(log(E)/Ts))';
pmax=max(plqr);
k_lqr=-k_lqr;
preg=spec(A);
// osservatore di ordine ridotto
poli_oss=exp([real(preg(3)),real(preg(4))]*10*Ts);
T=[0,0,0,1;0,1,0,0];

// trova l'ossrvatore di ordine ridotto per A,B,C,D, con polo di osservatore
// T e' la matrice necessaria per rendere [C;T] invertibile
P=[cd;T]
invP=inv([cd;T])
AA=P * ad * invP
ny=size(cd,1)
nx=size(ad,1)
nu=size(bd,2)
A11=AA(1:ny,1:ny)
A12=AA(1:ny,ny+1:nx)
A21=AA(ny+1:nx,1:ny)
A22=AA(ny+1:nx,ny+1:nx)
L1=ppol (A22',A12',poli_oss)';
nn=nx - ny;
A_redobs=[-L1 eye(nn,nn)]*P*ad*invP*[zeros(ny,nn); eye(nn,nn)];
B_redobs=[-L1 eye(nn,nn)]*[P*bd P*ad*invP*[eye(ny,ny);L1]]*[eye(nu,nu) zeros(nu,ny);-dd, eye(ny,ny)];
C_redobs=invP*[zeros(ny,nx-ny);eye(nn,nn)];
D_redobs=invP*[zeros(ny,nu) eye(ny,ny);zeros(nx-ny,nu) L1]*[eye(nu,nu) zeros(nu,ny);-dd, eye(ny,ny)];
ao=A_redobs
bo=B_redobs
co=C_redobs
do=D_redobs

// Crea la forma compatta dell'osservatore ABCD e il guadagno K
//
//

Bu=bo(:,1);
By=bo(:,2:$);
Du=do(:,1);
Dy=do(:,2:$);
X=inv(1+k_lqr*Du);
Ac=ao - Bu*X*k_lqr*co;
Bc=[Bu*X,By-Bu*X*k_lqr*Dy]
Cc=-X*k_lqr*co;
Dc=[X,-X*k_lqr*Dy]
Greg=syslin('d',Ac,Bc,Cc,Dc)
///////////////////////////////////////////
Gregtf=ss2tf(Greg);
Gregtf( :,2)
Gregtf( :,3)
[g1n,g1d]=tfdata(Gregtf( :,2))
[g2n,g2d]=tfdata(Gregtf( :,3))


questo butta fuori come regolatore il seguente:

Greg =


Greg(1) (state-space system:)

!lss A B C D X0 dt !

Greg(2) = A matrix =

- 1.1704196 - 16.638285
0.1322204 2.048937

Greg(3) = B matrix =

0.0329866 - 559.33453 - 69.773154
- 0.0036029 41.850078 4.3785807

Greg(4) = C matrix =

- 35.525535 - 497.8127

Greg(5) = D matrix =

1. - 16487.356 - 1308.8181

Greg(6) = X0 (initial state) =

0.
0.

Greg(7) = Time domain =

d

sabato 23 febbraio 2008

regolatore con scilab

Riferimento al problema di regolare il sistema instabile del nxt-way di Sybille Mayer.

Con scilab:

A=[0,1,0,0; 94.05,0,0,1.3;0,0,0,1; -544.05,0,0,-14.3] // pag 24
B=[0;-0.21;0;2.32]
C=[1,0,0,0;0,0,1,0]
D=[0;0]
nxtway_SYB=syslin('c',A,B,C,D) // genera sistema lineare
s=%s; // variabile di laplace
spec(A) // calcola autovalori
autovalori_di_A=spec(A)
poli_desiderati=[-2.6 -3.9 -5.2 -6.5] // poli desiderati
K=ppol(A,B,poli_desiderati) // calcolo della matrice di feedback K

F=A-B*K // sistema in retroazione
g2=syslin('c',F,B,C,D) // genera nuovo sistema lineare
spec(F)
autovalori_di_F=spec(F) //calcola autovalori, per verificare il piazzamento poli

si ottengono i seguenti risultati:

--> A =

0. 1. 0. 0.
94.05 0. 0. 1.3
0. 0. 0. 1.
- 544.05 0. 0. - 14.3
B =

0.
- 0.21
0.
2.32
C =

1. 0. 0. 0.
0. 0. 1. 0.
D =

0.
0.
nxtway_SYB =


nxtway_SYB(1) (state-space system:)

!lss A B C D X0 dt !

nxtway_SYB(2) = A matrix =

0. 1. 0. 0.
94.05 0. 0. 1.3
0. 0. 0. 1.
- 544.05 0. 0. - 14.3

nxtway_SYB(3) = B matrix =

0.
- 0.21
0.
2.32

nxtway_SYB(4) = C matrix =

1. 0. 0. 0.
0. 0. 1. 0.

nxtway_SYB(5) = D matrix =

0.
0.

nxtway_SYB(6) = X0 (initial state) =

0.
0.
0.
0.

nxtway_SYB(7) = Time domain =

c
ans =

0
7.8847523
- 4.598569
- 17.586183
autovalori_di_A =

0
7.8847523
- 4.598569
- 17.586183
poli_desiderati =

- 2.6 - 3.9 - 5.2 - 6.5
K =

- 1063.3266 - 123.77134 - 3.2972279 - 9.5224059
F =

0. 1. 0. 0.
- 129.2486 - 25.991982 - 0.6924179 - 0.6997052
0. 0. 0. 1.
1922.8678 287.14951 7.6495687 7.7919818
g2 =


g2(1) (state-space system:)

!lss A B C D X0 dt !

g2(2) = A matrix =

0. 1. 0. 0.
- 129.2486 - 25.991982 - 0.6924179 - 0.6997052
0. 0. 0. 1.
1922.8678 287.14951 7.6495687 7.7919818

g2(3) = B matrix =

0.
- 0.21
0.
2.32

g2(4) = C matrix =

1. 0. 0. 0.
0. 0. 1. 0.

g2(5) = D matrix =

0.
0.

g2(6) = X0 (initial state) =

0.
0.
0.
0.

g2(7) = Time domain =

c
ans =

- 6.5
- 2.6
- 3.9
- 5.2
autovalori_di_F =

- 6.5
- 2.6
- 3.9
- 5.2



si vede che il sistema retroazionato ha i poli (negativi) del valore che si voleva.

I poli ottenuti da Sybille sono:
[-1051.93 -122.34 -3.32 -9.44]
mentre lo script scilab da'
K = - 1063.3266 - 123.77134 - 3.2972279 - 9.5224059

piu' o meno gli stessi.

risposta all'impulso instabile,
nxtway_SYB






















risposta all'impulso stabile, g2























risposta al gradino sistema instabile, nxtway_SYB:

























risposta al gradino sistema stabile, g2:

lunedì 18 febbraio 2008

matlab toolkit

questa e' la notizia del giorno: anche all'universita' di Aachen hanno sviluppato per NXT un toolkit per matlab (opensource GNU GPL scaricabile gratuitamente)

aachen

non mi sembra pero' niente paragonato al ECR-NXT


ps: se si ha matlab basta questo

sabato 16 febbraio 2008

localizzazione fine col sonar (US) /sliding scale sonar

L'idea e' quella del localizzatore normale che traccia la mappa del territorio circostante come in

meow
oppure
davis
oppure
guy
oppure
xaos69

ma perfezionata da un motore che va avanti-indietro radialmente in modo da determinare la posizione in cui US cambia cifra.

Lasciamo perdere il fatto che quando US dice 27cm (a proposito occorre ricordare di mettere
DefaultUnits=Metric , per avere cm invece di pollici nel file
C:\Program Files\LEGO Software\LEGO MINDSTORMS NXT\MINDSTORMS Options.ini) in realta' possono essere 30cm oppure 24cm. Non e' accurato, si sa.

Parliamo invece di precisione.
Supponiamo che US dica 27cm di distanza. In realta' potrebbe essere 27.1cm oppure 27.9cm.
Montando US su un meccanismo a vite senza fine, si puo' stabilire quanti mm all'interno del cm.
Un motore sposta radialmente (ma si monitorano le rotazioni) US di poco verso l'oggetto finche' la cifra passa a 26cm.
Il motore potrebbe essere spingere un coso cosi':












Il blu viene fatto girare, la vite senza fine ruota il filetto nella scanalatura gialla, la quale spinge il pezzo a "L", dove e' montato il sensore US.
Un giro di motore corrisponde ad una distanza pari a quella del passo del filetto.
In questo modo sappremo quanti mm era oltre i 27cm.

en passant: link meccanica

distribuzione dei visitatori a questo blog



NXT nel mezzo dell'Amazzonia?!?

venerdì 15 febbraio 2008

allargatore di loop


Un problema tipico con NXT-G e' quello di far stare i blocchi nei loop che si stringono attorno al loro contenuto e diventano scomodissimi.
B. Davis ha escogitato il trucco di allargarli artificialmente inserendo di proposito dei blocchi con hub molto lunghi (per poi toglierli alla fine).

Ho preparato con Labview un bel block che non fa nulla, ma ha un hub bello lungo (piu' dell'altezza della pagina).

martedì 12 febbraio 2008

NXT che manda un e-mail

E' possibile (se NXT e' connesso ad un PC con Labview e NXTToolkit ovviamente) fare in modo che mandi una e-mail ad un destinatario.

Questo puo' essere utile ad esempio se uno vuole mettere un allarme provvisorio ad una porta.

Il .vi si trova nella directory degli esempi di Labview e va modificato per il NXT.
















"telechirurgia"


Come si puo' controllare un braccio robotico che esegue una operazione chirurgica a distanza?
Ecco dei rudimenti.













Ho messo il datasocket al .vi del post precedente.
Adesso ci sono 2 .vi, uno che sta su un PC e uno sull'altro.
Il .vi col Write data socket, prende i dati dal joystick e li manda sulla rete.
Il joystick e' connesso a questo PC (192.168.1.2).
























Il NXT e' connesso all'altro PC (192.168.1.3) che fa girare questo .vi con il datasocketRead.



































Prima accortezza: il router deve aprire la porta del datasocket (3015).
Seconda: i datasocket server devono essere lanciati su entrambi i PC
(C:\Program Files\National Instruments\DataSocket\cwdss.exe).
Terza: i dati devono fluire su uno stream chiamato "wave".


http://zone.ni.com/devzone/cda/pub/p/id/257?metc=mthg3n

lunedì 11 febbraio 2008

controllo NXT con joystick








































per controllare via joystick (attraverso il PC) un braccio robotico connesso allo stesso PC si puo' usare questo .vi


la divisione per 128 che si vede sui dati provenienti dal joystick e' richiesta dal fatto che il parametro "power" del NXT e' limitato, mentre dal joystick escono dati da -32768 a +32768.

il prossimo passo sara' telecomandare un NXT remoto su internet (occorrera' una webcam...): basta usare il datasocket sul cluster degli assi (il filo marrone uscente dal joystick come "axis info").

domenica 10 febbraio 2008

matrici 2D con NXT-G

Le matrici 2D sono semplicemente array 1D in cui le colonne ( o le righe) sono infilate una di seguito all'altra.

Pertanto e' solo questione di manipolare l'indice in modo che da due numeri (l'indice di riga e l'indice di colonna) se ne ricava uno solo.

Se si crea un MyBlock che all'interno manipola l'indice, si rileva un baco pero': il filo che porta DENTRO l'array rimane "spezzato" (cio' non accade al filo d'uscita).

Percio' e' meglio partire da Labview e crearsi un Block apposito.

Supponiamo di voler creare un blocco che inserisca un elemento in una matrice alla posizione (riga, colonna).

In LV occorre creare una struttura di files i cui nomi devono essere specificati in modo fisso.

Il modo piu' veloce e' fare creare a LV la struttura dei files, chiamando il Wizard sotto Tools->NXTModule.

Il file piu' importante e'









dopo di questo il piu' complicato e' invece:







che viene costruito con la tavolozza NXTControls e
che nel block diagram e'













questi sono i blocchettini che non si vedono nella figura principale perche' dentro il "case" a destra.
in pratica servono a dire che il valore va cambiato quando l'utente lo cambia ...

per rendere automatico il tutto e' meglio partire con il collegare (crea variabile locale con tasto destro sul controllo nel front panel) i vari blocchetti alle variabili locali e solo in seguito definire le opzioni del case: infatti seguendo questo schema il case stesso (tasto destro sull'intestazione del case) proporra' le varie possibilita' di evento (per esempio: cambia il valore del numero di colonne)








































praticamente Config serve a "sentire" quale valore viene cambiato dal programmatore NXT-G nella consueta finestra in basso a sinistra (in NXT-G) e a passarlo di conseguenza al .vi principale.

infine occorre definire nella directory creata col Wizard quali immagine vedere nella tavolozza (palette) e quale vedere quando si trascinera' il blocco in posizione sul diagramma.

Per caricare queste immagini (.png) occorre poi un file .vi (quello che contiene la parola Draw) : va bene quello di default.

Per far comparire l'hub sotto il blocco (quella cosa che si espande e permette di collegare i fili per intenderci) occorre non dimenticarsi di collegare il "connettore".
Ecco come si fa.
Si va sul front panel del principale (2D_Array_Insert.vi nel nostro caso): in alto a destra c'e' una figurina da cliccare col destro -> Show Connector.
Sul front panel si clicca ora un elemento (per esempio number_of_columns) e subito dopo si clicca uno dei quadratini che rappresentano le "prese" per i fili. Il quadratino cambia colore se viene assegnato.
Si raccomanda di assegnare i due quadratini in alto a destra e a sinistra ai controlli di Sequence Flow.

Finito tutto questo si passa al NXT-G e si chiama il wizard di importazione, indicandogli la directory dove sta la serie di files e la tavolozza (per esempio : Advanced) dove mettere il blocco.

Se dira' "successful" significa che il blocco si potra' prelevare in tavolozza ed usarlo:

sabato 9 febbraio 2008

controllo remoto del NXT con Labview/NXTtoolkit

Ho chiesto a qualcuno su nxtasy.org se voleva provare a controllare il mio nxt (o viceversa) usando il datasocket (*) fornito da Labview ma nessuno mi ha mai contattato.

Lo linko qui (dove pero' non posso caricare files, solo immagini); magari c'e' interesse.

L'idea e' di controllare NXT attaccato ad un PC (il mio bluetooth ha dei problemi, ma passare a BT e' facilissimo) da un altro PC via internet.

Il primo esperimento si concentra sul semplice problema di comunicare. Il sensore e' quello di luce; nessun attuatore.

Un .vi parla col NXT via USB e passa i dati al datasocket (internet); l'altro .vi parla col data socket e mostra i dati a schermo.

Il .vi che riceve i dati deve "sottoscrivere" la connessione indicando dspt://indirizzoIPdelPCchetrasmette/wave
dove wave e' il nome che ho scelto nel primo .vi per lo stream di dati nel PC che trasmette.

L'esperimento che ho proposto consiste nello scaricare i due .vi di Labview (o almeno quello che si vuole usare) e provare a vedere che succede.

E' importante la configurazione iniziale del data socket. Inoltre sul router va abilitata la porta 3015.


Se funziona si puo' passare ad altro (vedi esperimento successivo su nxtasy.org) .

(*) Copio-incollo dalla tesi di F. Altamura:
Le VI di LabVIEW possono comunicare o lavorare in rete (networking) con altri
processi, inclusi quelli che sono eseguiti da altre applicazioni o su computer remoti.
In particolare è possibile condividere dati in tempo reale con altre VI in rete
sfruttando la tecnologia DataSocket della National Instruments.
È necessario installare sulla macchina un Datasocket Server , cioè un applicazione
che fornisce il servizio Datasocket ad altri computer effettuando operazioni di
networking e di gestione di file.
Con questo tipo di tecnologia è possibile vedere e comandare ogni controllo e
indicatore del pannello di controllo della VI.
Attraverso questo tipo di connessione vengono scambiati dei dati, non dei grafici, e
in questo modo è possibile operare delle elaborazioni sui dati da remoto.
Vediamo, nella figura 7.3, due esempi di diagrammi a blocchi per leggere e scrivere
dei dati attraverso la connessione DataSocket.

La VI di sinistra genera una temperatura e invia il dato relativo ad essa al
DataSocket server con il nome di temp , mentre la VI di destra preleva il dato
relativo a temp dal server e lo visualizza su un grafico.

Il programma sviluppato per il controllo remoto dell apparecchio usa la tecnologia
Datasocket per lo scambio dei dati attraverso il web; è composto da due parti
distinte:
1. una parte installata sulla macchina a cui è collegato fisicamente
l' apparecchio e su cui è installato il Datasocket server ;
2. una parte (client) installata su una qualsiasi altra macchina remota che,
dialogando con il server, controlla l 'apparecchio.

come fare ottime fotografie ai robot NXT

Dave colpisce ancora!!
Ecco un fantastico tutorial su come fare le foto ai robot (ma vale anche per altre situazioni ovviamente).

Cerco di riassumere qui per i ragazzi italiani come mio figlio (macchina fotografica punta-e-scatta, cioe' non reflex) le cose fondamentali:

primo passo:

Step back about 3 feet and zoom in
Fai un passo indietro di 1 metro e zoomma.

Put the robot in a corner of a room and use white walls to reflect the flash
Metti il robot in un angolo della stanza e usa i muri bianchi per riflettere il flash a 45 gradi (cioe' in modo che il flash non rimbalzi indietro accecando)

Use Full Automatic mode (with flash)
Usa modo automatico con flash

Crop picture afterwards to get close-ups instead of getting closer or zooming in more
Non zoomare ulteriormente con la macchina, ma per selezionare i particolari una volta fatta la foto, usa un programma di fotoritocco che sappia ritagliare il particolare che interessa

Use digital photo editing software to adjust the lighting afterwards if necessary
Usa il programma di fotoritocco per sistemare l'illuminazione della foto.



Fill Light: da usare per schiarire la foto, che in casa viene sempre un po' scura
Neutral Color Picker: serve a dire al programma quale punto della foto e' bianco (ad esempio il corpo del NXT). Supponi che il NXT nella foto e' venuto giallastro: clicco questo Picker, poi con la pipetta vado sulla zona giallastra che voglio diventi bianca e clicco. A questo punto il programma sa che quello deve diventare bianco e trasforma tutto il resto della foto coerentemente.

venerdì 8 febbraio 2008

toledo

schema per iniziare a provare la port del NXT

data sheet espansione di memoria i2c

Obiettivo: creare un datalogger con grande profondita' di memoria.
caratteristiche eeprom 512kB:






































Ecco gli strumenti virtuali Labview che permettono a NXT di accedere ad un indirizzo i2c esterno.
Essi sono presi dal Block scaricabile dal sito Mindsensors e aperti con Labview Student Edition scaricabile da National Instrument.

altro sensore i2c : temperatura