25.01.2014 Views

LabVIEW 6 OK bis_7:LabVIEW_05

LabVIEW 6 OK bis_7:LabVIEW_05

LabVIEW 6 OK bis_7:LabVIEW_05

SHOW MORE
SHOW LESS

Create successful ePaper yourself

Turn your PDF publications into a flip-book with our unique Google optimized e-Paper software.

06<br />

SCUOLA DI LABVIEW<br />

Training per esperti<br />

RICHIAMARE OGGETTI<br />

IN LABVIEW<br />

a cura di Matteo Foini<br />

<strong>LabVIEW</strong> permette di accedere ad altre applicazioni Windows utilizzando le tecnologie .NET o ActiveX<br />

Il termine .NET fa riferimento alla tecnologia .NET di<br />

Microsoft. Il framework .NET è la base di programmazione<br />

dell’ambiente .NET per costruire, rilasciare ed eseguire<br />

applicazioni basate su Web, applicazioni smart client e Web<br />

service XML. È quindi necessario installare il framework .NET.<br />

Per maggiori informazioni si può consultare il sito Web MSDN.<br />

Nota Creare e comunicare con oggetti .NET richiede<br />

il .NET Framework 1.1 Service Pack 1 o successivo.<br />

Inoltre, National Instruments raccomanda vivamente di utilizzare<br />

solo oggetti .NET nei progetti <strong>LabVIEW</strong>.<br />

Il termine ActiveX si riferisce invece alla tecnologia ActiveX<br />

e alla tecnologia OLE di Microsoft. Con ActiveX<br />

Automation, un’applicazione Windows, come <strong>LabVIEW</strong>,<br />

fornisce un set pubblico di oggetti, comandi e funzioni a cui<br />

altre applicazioni Windows possono accedere.<br />

In questa prima parte verranno discussi i seguenti argomenti:<br />

A. Richiamo di oggetti in <strong>LabVIEW</strong> utilizzando ActiveX<br />

B. Uso di <strong>LabVIEW</strong> come Client ActiveX<br />

C. Uso di <strong>LabVIEW</strong> come Server ActiveX<br />

D. Eventi ActiveX<br />

Nella seconda parte, che verrà pubblicata sul numero di<br />

Settembre, verranno invece trattati i temi seguenti:<br />

E. Richiamo di oggetti in <strong>LabVIEW</strong> utilizzando .NET<br />

F. Implementazione di .NET<br />

G. Registriazione di Eventi .NET<br />

A. Richiamo di oggetti in <strong>LabVIEW</strong> utilizzando ActiveX<br />

Potete utilizzare <strong>LabVIEW</strong> come client ActiveX per accedere<br />

ad oggetti, proprietà, metodi ed eventi associati ad altre<br />

applicazioni abilitate ActiveX.<br />

<strong>LabVIEW</strong> può operare anche come server ActiveX, permettendo<br />

ad altre applicazioni di accedere ad oggetti, proprietà<br />

e metodi di <strong>LabVIEW</strong>.<br />

Oggetti, proprietà, metodi ed eventi ActiveX<br />

Le applicazioni abilitate ActiveX includono oggetti aventi<br />

proprietà e metodi accessibili ad altre applicazioni. Gli<br />

oggetti possono essere visibili agli utenti, come nel caso di<br />

pulsanti, finestre, immagini, documenti ed aree di dialogo, o<br />

invisibili agli utenti, come oggetti di applicazioni. Potete<br />

accedere a un’applicazione accedendo a un oggetto associato<br />

a quell’applicazione e settando una proprietà o invocando<br />

un metodo di quell’oggetto.<br />

Gli eventi sono le azioni eseguite su un oggetto, come cliccare<br />

un mouse, premere un tasto o ricevere notifiche circa<br />

fatti come l’esaurimento della memoria o il completamento<br />

di task. Ogni volta che queste azioni si verificano sull’oggetto,<br />

l’oggetto invia un evento per avvertire il contenitore<br />

ActiveX, insieme ai dati specifici all’evento. L’oggetto<br />

ActiveX definisce gli eventi disponibili per un oggetto.<br />

VI ActiveX, funzioni, controlli e indicatori<br />

Utilizzate i VI, le funzioni, i controlli e gli indicatori seguenti<br />

per accedere ad oggetti, proprietà, metodi ed eventi associati<br />

ad altre applicazioni abilitate ActiveX:<br />

• Usate il controllo automation refnum per creare un riferimento<br />

ad un oggetto ActiveX. Cliccate con il tasto destro su<br />

questo controllo sul pannello frontale per selezionare un<br />

oggetto dalla type library a cui volete accedere.<br />

• Usate la funzione Automation Open per aprire un oggetto<br />

ActiveX.<br />

• Usate il contenitore ActiveX per accedere ad un oggetto<br />

ActiveX sul pannello frontale e visualizzarlo. Cliccate con il<br />

tasto destro sul contenitore, selezionate Insert ActiveX<br />

Object nel menu abbreviato e selezionate l’oggetto a cui<br />

volete accedere.<br />

• Usate il Property Node per leggere (get) o scrivere (set) le<br />

proprietà associate ad un oggetto ActiveX.<br />

• Usate l’Invoke Node per invocare i metodi associati a un<br />

oggetto ActiveX.<br />

• Usate la funzione Register Event Callback per gestire gli<br />

eventi che si verificano su un oggetto ActiveX.<br />

• Usate il controllo e l’indicatore variant per trasferire dati<br />

verso o da controlli ActiveX.<br />

Suggerimento Selezionate Tools».NET & ActiveX»Add<br />

ActiveX Controls to Palette per aggiungere file di controllo<br />

custom alla palette dei controlli ActiveX.<br />

B. Uso di <strong>LabVIEW</strong> come Client ActiveX<br />

Quando <strong>LabVIEW</strong> accede agli oggetti associati a un’altra<br />

applicazione abilitata ActiveX, agisce come client ActiveX.<br />

Potete usare <strong>LabVIEW</strong> come client ActiveX nei modi seguenti:<br />

30


SCUOLA DI LABVIEW<br />

• Aprite un’applicazione, come Microsoft Excel, create un<br />

documento ed aggiungete dati al documento.<br />

• Incorporate un documento, come un documento<br />

Microsoft Word o uno spreadsheet Excel, sul pannello frontale<br />

in un contenitore.<br />

• Piazzate sul pannello frontale un pulsante o un altro<br />

oggetto di un’altra applicazione, come un pulsante Help<br />

che richiama il file help dell’altra applicazione.<br />

• Linkate da un’altra applicazione un controllo ActiveX che<br />

avete costruito.<br />

<strong>LabVIEW</strong> accede a un oggetto ActiveX con il controllo automation<br />

refnum o il contenitore ActiveX, che sono entrambi<br />

oggetti del pannello frontale. Usate il controllo automation<br />

refnum per selezionare un oggetto ActiveX. Usate il contenitore<br />

ActiveX per selezionare un oggetto ActiveX visualizzabile,<br />

come un pulsante o un documento, e piazzatelo sul<br />

pannello frontale. Entrambi gli oggetti appaiono come controlli<br />

automation refnum sullo schema a blocchi.<br />

La fig. 1 illustra come <strong>LabVIEW</strong>, operando come client<br />

ActiveX, interagisce con le applicazioni server.<br />

Figura 1 - <strong>LabVIEW</strong> come ActiveX Automation Client<br />

<strong>LabVIEW</strong> accede alla type library del server per ottenere<br />

informazioni circa i suoi oggetti, metodi e proprietà.<br />

<strong>LabVIEW</strong> può eseguire azioni come invocare metodi, leggere<br />

o scrivere proprietà e così via.<br />

Accesso ad un’applicazione abilitata ActiveX<br />

Per accedere a un’applicazione abilitata ActiveX, usate il<br />

controllo automation refnum sullo schema a blocchi per<br />

creare un riferimento a un’applicazione. Collegate il controllo<br />

alla funzione Automation Open, che apre<br />

l’applicazione chiamante. Usate il Property Node per selezionare<br />

e accedere alle proprietà associate con l’oggetto.<br />

Usate l’Invoke Node per selezionare e accedere ai metodi<br />

associati con l’oggetto. Chiudete il riferimeno all’oggetto<br />

usando la funzione Close Reference.<br />

Chiudendo il riferimento si rimuove l’oggetto dalla memoria.<br />

Per esempio, potete costruire un VI che apre Microsoft Excel<br />

in modo che appaia sullo schermo dell’utente, crei un workbook,<br />

crei uno spreadsheet, crei una tabella in <strong>LabVIEW</strong> e<br />

scriva tale tabella nello spreadsheet Excel.<br />

Consultate il VI Write Table To XL in labview\examples\<br />

comm\ExcelExamples.llb per un esempio sull’uso di<br />

<strong>LabVIEW</strong> come client Excel.<br />

Inserimento di un oggetto ActiveX sul pannello<br />

frontale<br />

Per inserire un oggetto ActiveX sul pannello frontale, cliccate<br />

con il tasto destro sul contenitore ActiveX, selezionate Insert<br />

ActiveX Object dal menu abbreviato e selezionate il controllo<br />

o il documento ActiveX che volete inserire. Potete settare<br />

le proprietà di un oggetto ActiveX usando l’ActiveX Property<br />

Browser o le pagine delle proprietà, oppure potete settare le<br />

proprietà da programma usando il Property Node.<br />

Usate l’Invoke Node per invocare i metodi associati con<br />

l’oggetto.<br />

Per esempio, potete visualizzare una pagina Web sul<br />

pannello frontale usando un contenitore ActiveX per<br />

accedere al controllo Microsoft Web Browser, selezionando<br />

la classe di metodi Navigate, selezionando<br />

il metodo URL e specificando l’URL.<br />

Se usate il contenitore ActiveX, non dovete collegare<br />

il controllo automation refnum sullo schema a blocchi<br />

alla funzione Automation Open o chiudere il rifrimento<br />

all’oggetto usando la funzione Close<br />

Reference. Potete collegare direttamente l’Invoke<br />

Node o il Property Node perché il contenitore ActiveX<br />

incorpora l’applicazione chiamante in <strong>LabVIEW</strong>.<br />

Tuttavia, se il contenitore ActiveX include proprietà o<br />

metodi che restituiscono altri automation refnum,<br />

dovete chiudere tali riferimenti addizionali.<br />

Design Mode per oggetti ActiveX<br />

Cliccate con il tasto destro su un contenitore<br />

ActiveX e selezionate Advanced»Design Mode<br />

dal menu abbreviato per visualizzare il contenitore in design<br />

mode mentre editate il VI. In design mode non vengono<br />

generati eventi e non sono eseguite procedure di evento. La<br />

modalità di default è la run mode, nella quale potete interagire<br />

con l’oggetto come farebbe l’utente.<br />

Impostazione delle proprietà ActiveX<br />

Dopo avere aperto un server ActiveX o avere inserito un controllo<br />

o un documento ActiveX, potete settare le proprietà<br />

associate a quel controllo o documento usando l’ActiveX<br />

Property Browser, le pagine delle proprietà e il Property Node.<br />

ActiveX Property Browser<br />

Usate l’ActiveX Property Browser per visualizzare e impostare<br />

tutte le proprietà associate a un controllo o documento<br />

ActiveX in un contenitore ActiveX. Per accedere<br />

31


06<br />

SCUOLA DI LABVIEW<br />

all’ActiveX Property Browser, cliccate con il tasto destro sul<br />

controllo o documento nel contenitore sul pannello frontale<br />

e selezionate Property Browser nel menu abbreviato.<br />

Potete anche selezionare Tools».NET & ActiveX»Browse<br />

ActiveX Properties. L’ActiveX Property Browser è un<br />

modo semplice per impostare le proprietà di un oggetto<br />

ActiveX interattivamente, ma non potete usare il browser<br />

per impostare le proprietà da programma e potete usare<br />

l’ActiveX Property Browser solo con oggetti ActiveX in un<br />

contenitore. L’ActiveX Property Browser non è disponibile in<br />

run mode o mentre viene eseguito un VI.<br />

Pagine delle proprietà ActiveX<br />

Molti oggetti ActiveX includono pagine di proprietà, che organizzano<br />

le proprietà associate con l’oggetto su tab separati.<br />

Per accedere alle pagine delle proprietà ActiveX, cliccate con il<br />

tasto destro sull’oggetto nel contenitore sul pannello frontale<br />

e selezionate il nome dell’oggetto nel menu abbreviato.<br />

Analogamente all’ActiveX Property Browser, anche le pagine<br />

delle proprietà ActiveX sono un modo semplice per<br />

impostare le proprietà di un oggetto ActiveX interattivamente,<br />

ma non potete utilizzarle per impostare le proprietà<br />

da programma, e potete usare le pagine delle proprietà solo<br />

con gli oggetti ActiveX in un contenitore. Le pagine delle<br />

proprietà non sono disponibili per tutti gli oggetti ActiveX.<br />

Inoltre, le pagine delle proprietà non sono disponibili in run<br />

mode o mentre il VI è in esecuzione.<br />

Figura 2 - Cambiamento della proprietà Value per il controllo ActiveX CWButton<br />

Property Node<br />

Usate il Property Node per impostare le proprietà ActiveX da<br />

programma. Per esempio, se usate un oggetto ActiveX per<br />

avvertire un utente quando una temperatura supera un limite,<br />

usate il Property Node per impostare la proprietà Value<br />

dell’oggetto per specificare il limite.<br />

Lo schema a blocchi di fig. 2 illustra un esempio che cambia<br />

la proprietà Value per il controllo ActiveX CWButton, che<br />

fa parte della National Instruments Measurement Studio<br />

User Interface ActiveX Library, quando la temperatura raggiunge<br />

o supera 85 gradi Fahrenheit.<br />

In questo caso, il controllo CWButton opera come un LED,<br />

cambia colori e visualizza ‘Warning’ quando la temperatura<br />

raggiunge il limite, che è lo stato ‘on’ del controllo CWButton.<br />

Nota In questo esempio, potete utilizzare l’ActiveX<br />

Property Browser o le pagine delle proprietà per<br />

impostare le proprietà OffText, OffColor, OnText e OnColor<br />

per il controllo CWButton, perché non è necessario impostare<br />

queste proprietà da programma.<br />

C. Uso di <strong>LabVIEW</strong> come Server ActiveX<br />

L’applicazione <strong>LabVIEW</strong>, i VI e le proprietà e i metodi di controllo<br />

sono disponibili tramite chiamate ActiveX da altre<br />

applicazioni. Altre applicazioni abilitate ActiveX, come<br />

Microsoft Excel, possono richiedere proprietà, metodi e singoli<br />

VI da <strong>LabVIEW</strong>, e <strong>LabVIEW</strong> opera come server ActiveX.<br />

Per esempio, potete incorporare un VI graph in uno spreadsheet<br />

Excel e dallo spreadsheet inserire dati negli input del<br />

VI ed eseguire il VI. Quando eseguite il VI, i dati sono plottati<br />

nel grafico.<br />

Consultate labview\examples\comm\freqresp.xls per un<br />

esempio d’uso delle proprietà e dei metodi <strong>LabVIEW</strong> in uno<br />

spreadsheet Excel. <strong>LabVIEW</strong> supporta un’interfaccia ActiveX<br />

verso il VI Server. Tale interfaccia con il server permette alle<br />

applicazioni client di accedere da programma a <strong>LabVIEW</strong>.<br />

La fig. 3 illustra come <strong>LabVIEW</strong> opera come server ActiveX<br />

per interagire con le applicazioni client.<br />

La type library di <strong>LabVIEW</strong>, labview.tlb, fornisce informazioni<br />

circa oggetti, metodi e proprietà di <strong>LabVIEW</strong>. Le applicazioni<br />

client possono accedere ai metodi e scrivere o leggere<br />

proprietà del server ActiveX <strong>LabVIEW</strong>.<br />

Potete usare <strong>LabVIEW</strong> come server ActiveX, permettendo ad<br />

altri client abilitati ActiveX di richiedere proprietà e metodi<br />

da <strong>LabVIEW</strong> e singoli VI. Per configurare <strong>LabVIEW</strong> come server<br />

ActiveX, selezionate Tools»Options per visualizzare<br />

l’area di dialogo Options. Selezionate VI Server: Confi -<br />

guration nel menu a tendina superiore e mettete un segno<br />

di spunta su ActiveX.<br />

Supporto per interfacce ActiveX Automation personalizzate<br />

Se state scrivendo un client ActiveX che accede a proprietà<br />

e metodi di un server ActiveX usando <strong>LabVIEW</strong>, potete accedere<br />

alle interfacce custom esposte dal server. A tale scopo,<br />

non è necessario utilizzare IDispatch. Tuttavia, lo sviluppatore<br />

del server ActiveX deve fare in modo che i parametri<br />

delle proprietà e dei metodi in tali interfacce custom abbiano<br />

tipi di dati Automation (IDispatch). Lo sviluppatore del<br />

server deve fare in questo modo per esporre più interfacce<br />

da un oggetto, anziché da più oggetti.<br />

32


SCUOLA DI LABVIEW<br />

Gestione di Eventi ActiveX<br />

Dovete creare un VI di callback per gestire eventi dai controlli<br />

ActiveX quando i controlli stessi generano gli eventi<br />

registrati. Il VI di callback viene eseguito al verificarsi dell’evento.<br />

Per creare un VI di callback, cliccate<br />

con il tasto destro sull’input VI Ref della funzione<br />

Register Event Callback e selezionate<br />

Create Callback VI nel menu abbreviato.<br />

<strong>LabVIEW</strong> crea un VI rientrante. Aprite il VI ed<br />

editate lo schema a blocchi per gestire l’evento.<br />

Il VI di callback contiene i seguenti elementi:<br />

Figura 3 - <strong>LabVIEW</strong> ActiveX Automation Server<br />

D. Eventi ActiveX<br />

Per usare eventi ActiveX in un’applicazione, dovete registrare<br />

l’evento e gestirlo quando si verifica. La registrazione degli<br />

eventi ActiveX è simile alla registrazione degli eventi dinamici.<br />

Tuttavia, l’architettura del VI di un evento ActiveX è diversa<br />

dall’architettura di un VI di gestione eventi. Un tipico VI di<br />

evento ActiveX è formato dai seguenti componenti:<br />

• Oggetto ActiveX per il quale desiderate generare un evento.<br />

• Funzione Register Event Callback per specificare e registrare<br />

il tipo di evento che volete generare.<br />

• VI Callback contenente il codice che dovete scrivere per<br />

gestire l’evento che specificate.<br />

Potete generare e gestire eventi relativi a oggetti ActiveX in<br />

un contenitore o relativi a oggetti ActiveX che specificate<br />

usando un Automation Refnum. Per esempio, potete chiamare<br />

un controllo ad albero Windows da un contenitore<br />

ActiveX e specificare che volete generare un evento Double<br />

Click per gli elementi visualizzati nel controllo ad albero.<br />

La funzione Register Event Callback è un nodo ridimensionabile<br />

in grado di gestire più eventi, analogamente alla funzione<br />

Register For Events.<br />

Quando cablate la reference di un oggetto ActiveX alla funzione<br />

Register Event Callback e specificate l’evento che volete<br />

generare per quell’oggetto, state registrando l’oggetto ActiveX<br />

per quell’evento. Dopo la registrazione, create un VI di callback<br />

che contiene il codice scritto per gestire l’evento.<br />

Eventi diversi possono avere formati dati differenti, quindi<br />

cambiare l’evento dopo avere creato un VI di callback potrebbe<br />

rompere i fili di connessione sullo schema a blocchi.<br />

Selezionate quindi l’evento prima di creare il VI di callback.<br />

• Event common data contiene i seguenti<br />

elementi:<br />

• Source è un controllo numerico che specifica<br />

la sorgente dell’evento, come <strong>LabVIEW</strong> o<br />

ActiveX. Un valore 1 indica un evento<br />

ActiveX.<br />

• Type specifica quale evento si è verificato. Questo è un tipo<br />

enumerato per gli eventi dell’interfaccia utente e un tipo intero<br />

senza segno a 32 bit per le sorgenti ActiveX e altre sorgenti<br />

di eventi. Per gli eventi ActiveX, il tipo di evento rappresenta<br />

il codice del metodo, o ID, per l’evento registrato.<br />

• Time è il time stamp in millisecondi che specifica quando<br />

è stato generato l’evento.<br />

• Control Ref è un riferimento all’ActiveX o all’Auto -<br />

mation Refnum su cui si è verificato l’evento.<br />

• Event Data è un cluster dei parametri specifici all’evento<br />

gestito dal VI di callback. <strong>LabVIEW</strong> determina<br />

l’appropriato Event Data quando selezionate un evento<br />

dalla funzione Register Event Callback. Se un evento non ha<br />

alcun dato associato ad esso, <strong>LabVIEW</strong> non crea questo<br />

controllo nel VI di callback.<br />

• Event Data Out è un cluster dei parametri modificabili<br />

specifici all’evento gestito dal VI di callback. Tale elemento<br />

è disponibile solo se l’evento ActiveX ha parametri d’uscita.<br />

• (Opzionale) User Parameter è il dato che si desidera<br />

passare al VI di callback quando l’oggetto ActiveX genera<br />

l’evento.<br />

Nota Potete usare un VI esistente come VI di callback<br />

purché il pannello dei connettori del VI che intendete<br />

utilizzare corrisponda al pannello dei connettori dei dati di<br />

evento. Il VI di callback deve essere rientrante e la reference<br />

al VI di callback deve essere strettamente tipizzato.<br />

Non potete eseguire chiamate sincrone a finestre di dialogo<br />

non modali da un VI di callback. Dovete chiamarle in modo<br />

asincrono da un VI di callback invocando un metodo Run VI<br />

e scrivendo una costante booleana FALSE all’ingresso Wait<br />

Until Done del metodo.<br />

Note sull’autore<br />

Laureato in ingegneria nucleare al Politecnico di Milano, Matteo<br />

Foini lavora in qualità di Technical Marketing Engineer presso<br />

National Instruments Italy<br />

Readerservice.it n. 626<br />

33

Hooray! Your file is uploaded and ready to be published.

Saved successfully!

Ooh no, something went wrong!