Esercitazione A-2

Transcript

Esercitazione A-2

LabVIEW
Corso Base II
Corso sulla versione software 6.0
Edizione settembre 2000
Part Number 320629G-01
Traduzione Luglio 2001
A Survey of Modern Computer-Based Experiments
Copyright
© Copyright 2000 National Instruments Corporation. Tutti i diritti riservati. In base alle leggi sul copyright
questa pubblicazione non può essere riprodotta o trasmessa in alcuna forma elettronica o meccanica, inclusa
la fotocopia, la registrazione, la memorizzazione in banche dati, o tradotta, completamente o parzialmente,
senza il consenso preventivo della National Instruments Corporation. I prodotti e i nomi delle società elencati
sono marchi o nomi commerciali registrati delle rispettive società.
Marchi
LabVIEW™, National Instrument™ e ni.com™ sono marchi registrati di National Instruments Corporation.
I prodotti o le società citate sono marchi registrati o marchi delle rispettive società.
Indice
Worldwide Technical Support and Product Information
ni.com
National Instruments Corporate Headquarters
11500 North Mopac Expressway Austin, Texas 78759-3504 USA Tel: 512 794 0100
Worldwide Offices
Australia 03 9879 5166, Austria 0662 45 79 90 0, Belgium 02 757 00 20, Brazil 011 284 5011, Canada (Calgary) 403 274
9391,
Canada (Ontario) 905 785 0085, Canada (Québec) 514 694 8521, China 0755 3904939, Denmark 45 76 26 00,
Finland 09 725 725 11, France 01 48 14 24 24, Germany 089 741 31 30, Greece 30 1 42 96 427, Hong Kong 2645 3186,
India 91805275406, Israel 03 6120092, Italy 02 413091, Japan 03 5472 2970, Korea 02 596 7456, Mexico (D.F.) 5 280
7625,
Mexico (Monterrey) 8 357 7695, Netherlands 0348 433466, New Zealand 09 914 0488, Norway 32 27 73 00,
Poland 0 22 528 94 06, Portugal 351 1 726 9011, Singapore 2265886, Spain 91 640 0085, Sweden 08 587 895 00,
Switzerland 056 200 51 51, Taiwan 02 2528 7227, United Kingdom 01635 523545
LabVIEW Corso Base II
ii
 National Instruments Corporation
Indice
Indice
Guida per lo studente
A. Descrizione di questo manuale ...................................................................... GS-1
B. Prerequisiti ..................................................................................................... GS-3
C. Installazione del software per il corso ........................................................... GS-4
D. Obiettivi del corso.......................................................................................... GS-5
E. Tavola d’orientamento ................................................................................... GS-6
F. Convenzioni adottate nel corso ...................................................................... GS-7
Lezione 1
Pianificazione di applicazioni in LabVIEW
A. Il processo di pianificazione e di progetto..................................................... 1-2
B. Il processo di implementazione ..................................................................... 1-3
C. Tecniche di gestione degli errori.................................................................... 1-4
D. Architetture di programmazione in LabVIEW .............................................. 1-10
E. Modelli di VI.................................................................................................. 1-21
Sommario, trucchi e consigli .............................................................................. 1-24
Lezione 2
Progettazione di pannelli frontali
A. Nozioni fondamentali sull’interfaccia utente................................................. 2-2
B. Utilizzo di cluster booleani come menu......................................................... 2-14
C. Nodi proprietà ................................................................................................ 2-24
Proprietà comuni................................................................................................. 2-27
D. Proprietà dei grafici ....................................................................................... 2-37
E. Riferimenti al controllo .................................................................................. 2-46
F. Menu run-time di LabVIEW (opzionale)....................................................... 2-51
G. Diagrammi d’intensità ................................................................................... 2-60
Esercizi aggiuntivi .............................................................................................. 2-66
iii
LabVIEW Corso Base I
Indice
Lezione 3
Tecniche di gestione dei dati
A. Tecniche di gestione dei dati in LabVIEW.................................................... 3-2
B. Variabili locali ............................................................................................... 3-4
C. Variabili globali ............................................................................................. 3-14
D. Avvertenze importanti su variabili locali e globali........................................ 3-23
E. DataSocket ..................................................................................................... 3-26
Lezione 4
Tecniche avanzate di I/O su file
A. Lavorare con file a flusso di byte .................................................................. 4-2
B. File datalog di LabVIEW............................................................................... 4-12
C. Salvataggio di dati su disco............................................................................ 4-19
Lezione 5
Sviluppo di grandi applicazioni in LabVIEW
A. Assemblaggio di un’applicazione in LabVIEW ............................................ 5-2
B. Caratteristiche di LabVIEW per lo sviluppo di progetti................................ 5-14
C. Strumenti di LabVIEW per la gestione di progetti ........................................ 5-22
Lezione 6
Controllo delle prestazioni
A. Panoramica sul multithreading e il multitasking in LabVIEW ..................... 6-2
B. La finestra Profile .......................................................................................... 6-6
C. Velocizzare i VI ............................................................................................. 6-13
D. Memoria di sistema........................................................................................ 6-26
E. Ottimizzazione dell’uso della memoria da parte dei VI................................. 6-29
Appendice
A. SubVI polimorfici.......................................................................................... A-2
B. Grafica personalizzata in LabVIEW .............................................................. A-7
C. Il Web Server in LabVIEW ........................................................................... A-14
D. Informazioni aggiuntive................................................................................. A-19
E. Tabella delle corrispondenze dei caratteri ASCII .......................................... A-21
iv
Grazie per aver acquistato il kit del Corso Base II di LabVIEW. Voi
potrete iniziare a sviluppare un’applicazione subito dopo aver completato
gli esercizi di questo manuale. Questo manuale e il software di
accompagnamento vengono utilizzati nel Corso Base II di LabVIEW a
carattere pratico della durata di due giorni. Voi potete utilizzare l’acquisto
di questo kit per iscrivervi al corso senza versare la corrispondente quota
di registrazione se vi registrate entro 90 giorni dall’acquisto del kit.
Visitate la sezione Customer Education del sito ni.com per i programmi
dei corsi online, i prospetti, i centri di formazione, e la registrazione di
classi.
A. Descrizione di questo manuale
Questo manuale vi insegna ad utilizzare LabVIEW per sviluppare
applicazioni di test e misure, di acquisizione dati, di controllo degli
strumenti, di memorizzazione dati, di analisi delle misure e di
generazione di rapporti. Questo manuale presuppone che abbiate
familiarità con Windows, Macintosh o Unix e che abbiate esperienza
nella scrittura di algoritmi sotto forma di diagrammi di flusso o di schemi
a blocchi e che inoltre abbiate svolto il Corso Base I o abbiate
un’esperienza equivalente.
Il manuale è suddiviso in lezioni, ognuna delle quali copre un argomento
o un insieme di argomenti. Ogni lezione consiste in:
y
Un’introduzione che descrive lo scopo della lezione e che cosa
imparerete
y
Una descrizione degli argomenti trattati nella lezione
y
Un insieme di esercizi per fissare gli argomenti
y
Un insieme di esercizi aggiuntivi per approfondimenti se il tempo lo
consente
y
Un sommario che sottolinea concetti importanti e le conoscenze
impartite nella lezione
GS-1
Diversi esercizi presenti in questo manuale utilizzano un dispositivo plugin multifunzione per l’acquisizione dati (DAQ) collegato ad un DAQ
Signal Accessory contenente un sensore di temperatura, un generatore di
funzioni e dei LED.
Se non possedete questo hardware, potete completare comunque la
maggior parte degli esercizi. Assicuratevi di utilizzare le versioni demo
dei VI quando lavorate con gli esercizi. Gli esercizi che richiedono
esplicitamente dell’hardware sono contrassegnati con l’icona mostrata a
lato. Potete anche utilizzare altro hardware rispetto a quello indicato
precedentemente. Per esempio potete utilizzare un altro dispositivo DAQ
della National Instruments collegato ad una sorgente di segnale, come ad
esempio un generatore di funzioni.
Ogni esercizio mostra una figura con un pannello frontale finito e lo
schema a blocchi dopo che avete mandato in esecuzione il VI, come
mostrato nell’illustrazione seguente. Dopo ogni schema a blocchi segue
una descrizione di ogni oggetto presente nello schema a blocchi.
1 Pannello frontale
2 Schema a blocchi
GS-2
3
Commenti (questi non li
inserite)
B. Prerequisiti
Prima di utilizzare questo manuale, assicuratevi di avere i seguenti:

(Windows) Windows 95 o successivi installato sul vostro computer;
(Macintosh) Power Macintosh con sistema operativo MacOS 7.6.1 o
successivi; (UNIX) workstation Sun con Solaris 2.5 o successivi e
software di sistema XWindows, una workstation modello HP 9000
serie 700 con HP-UX 10.20 o successivi o un PC con Linux kernel
2.0.x o successivi per architetture Intel x86.

(Windows) Dispositivo DAQ multifunzione configurato come device 1
utilizzando Measurement & Automation Explorer; (Macintosh)
Dispositivo DAQ multifunzione nello Slot 1

DAQ Signal Accessory, conduttori e cavi

LabView Professional Development System 6.0 o successivi

(Opzionale) Un’applicazione per word processing come (Windows)
Notepad, WordPad, (Macintosh) TeachText, (UNIX) Text Editor, vi o
vuepad

I dischetti del Corso Base II di LabVIEW, contenenti i seguenti file:
Nome file
LVB2SW.exe
LVB2Sol.exe
LVB2Read.txt
Descrizione
Archivio contenente i VI utilizzati nel corso
Archivio contenente gli esercizi completi del
corso
File di testo che descrive la procedura di
installazione del software del corso
GS-3
C. Installazione del software per il corso
Seguite i passi seguenti per installare il software di LabVIEW Corso
Base.
Windows
1. Avviate il programma denominato LVB2SW.exe. I file del corso
verranno estratti nella directory c:\exercises\LV Basics 2.
Basics2.llb verrà installata nella directory LabVIEW\user.lib.
Quando avviate LabVIEW, comparirà una palette denominata Basics
2 Course nella palette User Libraries della palette Functions.
2. (Opzionale) Cliccate due volte su LVB2Sol.exe per installare le
soluzioni di tutti gli esercizi nella directory c:\solutions\LV
Basics 2.
Macintosh
1. Come mostrato nei punti 1 e 2 dell’installazione sotto Windows,
utilizzate un PC con Windows per estrarre i file e trasferirli nel vostro
Macintosh. Se non avete accesso ad un PC, contattate National
Instruments per i file decompressi.
2. Copiate i file sul vostro hard disk utilizzando la struttura a directory
descritta nella sezione Windows.
UNIX
1. Come mostrato nei punti 1 e 2 dell’installazione sotto Windows,
utilizzate un PC con Windows per estrarre i file e trasferirli nella
vostra workstation. Se non avete accesso ad un PC, contattate
National Instruments per i file decompressi.
2. Caricate il disco PC che state utilizzando per trasferire i file. Il corso
presuppone la struttura a directory descritta nella sezione Windows.
Copiate tutti i file nelle opportune locazioni.
GS-4
D. Obiettivi del corso
Il corso vi fornisce una preparazione che vi consente di:
y
Comprendere il processo di sviluppo dei VI.
y
Comprendere alcune architetture comuni di programmazione di VI.
y
Progettare interfacce utente (pannelli frontali) efficaci.
y
Utilizzare le tecniche di gestione dei dati nei VI.
y
Utilizzare le tecniche avanzate di I/O su file.
y
Utilizzare LabVIEW per creare le vostre applicazioni.
y
Migliorare l’utilizzo della memoria e le prestazioni dei vostri VI.
Applicherete questi concetti nella Lezione 5, Sviluppo di applicazioni più
grandi in LabVIEW. Nella Lezione 5, voi realizzerete un progetto che
utilizza i VI che avete creato nelle Lezioni 1, 2, 3 e 4. Mentre questi VI
singolarmente illustrano concetti e caratteristiche specifici di LabVIEW,
essi fanno parte di un progetto più grande che completerete nella Lezione
5.
Il progetto che realizzerete dovrà soddisfare i punti seguenti:
y
Fornire un’interfaccia utente a menu.
y
Richiedere all’utente di entrare nel programma con un nome e una
password corretti.
y
Se l’immissione dei dati da parte dell’utente non è corretta,
disabilitare le altre caratteristiche.
y
Acquisire dati con la specifica configurazione dell’utente.
y
L’utente può analizzare un sottoinsieme di dati e salvare i risultati su
file.
y
L’utente può caricare e visualizzare
precedentemente salvati su disco.
i
risultati
dell’analisi
Questo corso non vi fornisce le descrizioni seguenti:
y
Metodi di programmazione in LabVIEW coperti dal LabVIEW Corso
Base I.
y
Teoria della programmazione
y
Ogni VI interno, funzione o oggetto
y
Lo sviluppo di un’applicazione completa per ogni studente della
classe.
GS-5
E. Tavola d’orientamento
Pianificazione di
applicazioni in
LabVIEW
Sviluppo di diagrammi di flusso
per il VI Application Exercise
Progettazione
di pannelli frontali
Realizzazione di:
Menu di interfaccia utente,
VI Acquire Data,
VI Analyze & Present Data,
VI Disable Controls
Tecniche di
gestione dei dati
Realizzazione del VI Login
Tecniche avanzate
di I/O su file
Creazione di progetti
più grandi
Realizzazione del VI Save Data
to File (completa il VI Analysis &
Present Data)
Studio del VI View Analysis File
Assemblaggio di parti per
realizzare il VI Application
Exercise e terminare il progetto
Considerazioni
sulle prestazioni
GS-6
F. Convenzioni adottate nel corso
Nel manuale del corso vengono adottate le convenzioni seguenti:
»
Il simbolo » vi guida attraverso i menu nidificati e le opzioni delle
finestre di dialogo fino all’azione finale. La sequenza File»Page
Setup»Options vi indica che dovete partire dal menu File, scegliere la
voce Page Setup e quindi scegliere Options dall’ultima finestra di
dialogo.
Questa icona indica una nota, e vi avverte di leggere una informazione
importante.
Questa icona vi indica che l’esercitazione richiede un’interfaccia GPIB
plug-in o un dispositivo DAQ.
bold
Il testo in grassetto vi indica le voci che voi dovete selezionare o su cui
cliccare del software, come le voci di menu e le opzioni della finestra di
dialogo. Il testo in grassetto indica anche nomi di parametro, controlli e
pulsanti del pannello frontale, finestre di dialogo, sezioni di finestre di
dialogo, nomi di menu e nomi di palette.
italic
Il testo in corsivo indica variabili, enfasi, un riferimento incrociato o
un’introduzione ad un concetto chiave. Questo font indica anche del testo
che dovete introdurre o un valore che dovete applicare.
courier
Il testo in questo font indica testo o caratteri che dovete inserire da
tastiera, sezioni di codice, esempi di programmazione, ed esempi di
sintassi. Questo font viene usato anche per nomi propri di drive di dischi,
percorsi, directory, sottoprogrammi, nomi di dispositivi, funzioni,
operazioni, variabili, nomi file ed estensioni, parti di codice.
courier
bold
Arial
narrow
Il testo in questo font indica una piattaforma specifica e indica che il testo
seguente si applica solo a quella piattaforma.
Click tasto destro
(Macintosh) Premere <Command> e cliccare per ottenere la stessa azione
di un click col tasto destro del mouse.
GS-7
GS-8
Lezione 1
Pianificazione di
applicazioni in LabVIEW
Questa lezione descrive alcuni argomenti riguardanti lo sviluppo di
applicazioni in LabVIEW, incluso il processo di progettazione,
l’organizzazione di subVI componenti e il processo di combinazione di
questi componenti per creare un’applicazione completa. Questa lezione
descrive anche le comuni architetture di programmazione in LabVIEW
tramite alcuni strumenti che vi aiutano nella realizzazione di VI.
Imparerete:
A. A pianificare e progettare nel modo migliore lo sviluppo di
B. A convertire le vostre linee guida in subVI di LabVIEW
C. A conoscere le tecniche di gestione degli errori
D. A conoscere le architetture di programmazione in LabVIEW più
comuni
E. A conoscere i modelli dei VI
1-1
Lezione 1
A. Il processo di pianificazione e di progetto
Per impostare grandi progetti in LabVIEW, vedrete che di solito inizierete
con un approccio di tipo top-down. Questo vuol dire che inizialmente
definite le caratteristiche e le specifiche generali. Dopo aver definito i
requisiti dell’applicazione in base alle esigenze del vostro cliente, iniziate
a sviluppare i subVI che volete eventualmente assemblare per creare il
progetto completo. Questo stadio rappresenta il periodo di sviluppo
bottom-up. Il riscontro con il cliente vi aiuta a determinare nuove
caratteristiche e miglioramenti per la successiva versione del prodotto,
riportandovi alla fase progettuale. Lo schema seguente illustra questo
processo di sviluppo del progetto.
Processo di
confronto con il
cliente
Definizione del
progetto
Prove e rilascio
del prodotto finale
Progetto del
diagramma di
flusso
Integrazione di
subVI nel progetto
Implementazione
dei nodi come VI
Prove sui subVI
Top-Down
Bottom-up
Processo di sviluppo dei progetti in LabVIEW
Progettare un diagramma di flusso vi aiuta a visualizzare il
funzionamento della vostra applicazione e ad impostare la gerarchia
complessiva del vostro progetto. Siccome LabVIEW è un linguaggio di
programmazione a flusso di dati e i suoi schemi a blocchi sono simili a
diagrammi di flusso tipici, è importante pianificare con cura questo
diagramma. Potete implementare direttamente molti nodi del diagramma
di flusso come subVI di LabVIEW. Pianificando con cura il diagramma
di flusso prima dell’implementazione della vostra applicazione in
LabVIEW, potrete risparmiare del tempo successivamente.
1-2
Lezione 1
Tenete comunque presente le seguenti linee guida per lo sviluppo del
progetto:
•
Definite accuratamente le specifiche del sistema.
•
Determinate in maniera chiara le aspettative dell’utente finale.
•
Documentate che cosa deve effettuare l’applicazione.
•
Pianificate per il futuro modifiche ed aggiunte.
B. Il processo di implementazione
Dopo aver completato il processo di pianificazione, implementate la
vostra applicazione sviluppando i subVI che corrispondono ai nodi del
diagramma di flusso. Sebbene non possiate sempre adottare questo
approccio, esso vi aiuta a rendere la vostra applicazione modulare.
Definendo in maniera chiara una gerarchia delle specifiche della vostra
applicazione, create uno schema per l’organizzazione dei VI che
sviluppate.
Inoltre, la struttura a moduli rende più facile il test di piccole parti di
un’applicazione prima di passare ad una loro combinazione. Se realizzate
un’intera applicazione su un unico schema a blocchi senza subVI, potreste
non essere in grado di iniziare un test senza prima aver realizzato la
maggior parte dell’applicazione. A quel punto, risulta molto difficile
risolvere problemi che si dovessero presentare. Inoltre, effettuando test su
parti più piccole di VI, più specifiche, potete determinare difetti di
programmazione iniziali e correggerli prima di investire ore in
implementazione.
Prevedendo uno sviluppo modulare e gerarchico, è più facile mantenere il
controllo del codice sorgente del vostro progetto e dello stato del
progetto. Un altro vantaggio che deriva dall’utilizzo di subVI è che sarà
più facile in futuro apportare modifiche e miglioramenti all’applicazione.
Dopo aver realizzato e testato i subVI necessari, potrete completare
l’applicazione in LabVIEW. Questa è la parte di sviluppo bottom-up.
1-3
Lezione 1
C. Tecniche di gestione degli errori
Nel LabVIEW Corso Base I, avete utilizzato i cluster di error in e di
error out per trasferire le informazioni sugli errori tra funzioni e subVI.
Questi cluster di errore contengono tre parti di informazioneun
booleano di stato che indica un valore true per un errore, un numero che
indica il codice di errore e la stringa sorgente che visualizza quale
funzione o subVI ha generato l’errore. Potete utilizzare la funzione
Unbundle o Unbundle By Name che si trova nella palette
Functions»Cluster per estrarre questa informazione come indicato nello
schema a blocchi seguente.
Cluster di errore
L’esempio precedente illustra un tipico uso dell’approccio error in/error
out. I VI di I/O su File e le funzioni utilizzano i cluster di errore per
passare le informazioni da un’operazione alla successiva. Potete quindi
utilizzare i VI di gestione degli errori dalla riga in basso della palette
Time&Dialog per avvisare l’utente di ogni condizione di errore
verificatasi.
I VI di gestione degli errori
Il VI Simple Error Handler prende il cluster error in o il valore del codice
di errore e in caso di errore apre una finestra di dialogo che descrive
l’errore e le possibili ragioni di esso. Potete anche modificare il tipo di
finestra di dialogo che si apre visualizzando un pulsante OK, non
visualizzare per niente una finestra di dialogo o visualizzare una finestra
di dialogo e fornire all’utente la possibilità di continuare o di arrestare il
VI.
Il VI General Error Handler accetta il cluster error in o il valore del
codice di errore e in caso di errore appare una finestra di dialogo del tipo
specificato. Comunque potete anche impostare una lista di gestione degli
errori per fare in modo che gli errori specificati siano cancellati o
impostati quando occorre.
1-4
Lezione 1
Potete inoltre utilizzare il VI General Error Handler per aggiungere errori
alla tabella interna di descrizione degli errori. La tabella di descrizione
degli errori descrive tutti gli errori di LabVIEW e le operazioni relative.
Perciò potete aggiungere i vostri codici di errore e le descrizioni ai VI di
gestione degli errori. Fate riferimento a LabVIEW Help per informazioni
su come modificare i vostri VI di gestione degli errori.
In caso di errore, i VI Simple Error Handler e General Error Handler
aprono una finestra di dialogo che visualizza le informazioni contenute
nel cluster di errore e i possibili motivi di quell’errore come descritto
nella tabella interna di descrizione degli errori.
Talvolta avete linee separate di operazioni che vengono eseguite in
parallelo da LabVIEW e ogni operazione mantiene i propri cluster di
errore. Potete utilizzare il VI Merge Errors per combinare diversi cluster
di errore in uno.
Il VI Merge Errors controlla i cluster di errore in arrivo o la matrice dei
cluster di errore e pone in uscita il primo errore trovato. Se non ci sono
errori, LabVIEW restituisce il primo messaggio di avviso e il codice di
errore è un valore positivo. Altrimenti LabVIEW fornisce una condizione
di assenza di errore.
1-5
Lezione 1
Inserimento della gestione degli errori nei vostri VI
Dovreste inserire la gestione degli errori nei vostri VI in aggiunta
all’utilizzo dei cluster di errore per VI e funzioni interne. Per esempio,
quando state costruendo un subVI da utilizzare in un progetto più grande,
potreste non volere l’esecuzione di subVI in caso di errore occorso
precedentemente. Potete collegare i cluster di errore ad una struttura Case
per considerare le condizioni di Error o No Error come mostrato
nell’esempio seguente.
Inserite qui il codice da
eseguire quando non ci
sono stati errori
Come mostrato nell’esempio precedente, inserite il codice che volete
eseguire nella condizione No Error e quindi definite il valore di errore in
uscita corrispondente alla condizione in funzione di quello che avviene in
quella condizione.
Nell’esercizio successivo realizzerete un VI che genera dati, li analizza e
li presenta sul pannello frontale utilizzando i cluster di errore in modo
appropriato.
1-6
Lezione 1
Esercitazione 1-1
Obiettivo:
VI Generate & Analyze Data
Realizzare un VI che generi, analizzi e visualizzi i dati utilizzando tecniche di
gestione degli errori
Realizzerete un VI che genera una sinusoide con rumore, calcola la
risposta in frequenza di questi dati e rappresenta gli andamenti temporali
e in frequenza su due grafici. Utilizzerete i cluster di errore e i VI di
gestione degli errori per monitorare correttamente le condizioni di errore
Nota Utilizzerete questo VI nell’appendice.
Pannello frontale
1. Aprite un nuovo VI.
2. Aggiungete tre cursori verticali che si trovano nella palette
Controls»Numeric, il pulsante Stop che si trova nella palette
Controls»Boolean, e due grafici di forme d’onda che si trovano nella
palette Controls»Graph, come indicato nel pannello frontale
precedente.
Etichettateli
opportunamente.
Creerete
due
clusterSampling Info e averaging parametersdallo schema a
blocchi.
1-7
Lezione 1
Schema a blocchi
3. Aprite e realizzate lo schema a blocchi utilizzando i componenti
seguenti.
a. Inserite un ciclo While che si trova nella palette
Functions»Structures. Questo impone al VI di continuare a
generare e ad analizzare i dati finché l’utente clicca sul pulsante di
Stop. Cliccate con il tasto destro del mouse sul terminale
condizionale e selezionate Stop If True.
b. Inserite il VI Sine Waveform che si trova nella palette
Functions»Analyze»Waveform Generation. Questo VI genera
una forma d’onda sinusoidale con una data frequenza, ampiezza e
impostazioni sul campionamento. Per creare il controllo del
cluster con le impostazioni sul campionamento, cliccate con il
tasto destro del mouse sul terminale d’ingresso e selezionate
Create»Control dal menu rapido.
c. Inserite il VI Uniform White Noise Waveform che si trova nella
palette Functions»Analyze»Waveform Generation. Questo VI
genera un rumore bianco uniforme definito da ampiezza e
informazioni sul campionamento.
d. Inserite il VI Merge Errors che si trova nella palette
Functions»Time & Dialog. Questo VI combina i cluster di errore
che provengono dai VI Sine e Noise in un unico cluster di errore.
e. Inserite il VI Add Waveforms che si trova nella palette
Functions»Waveform»Waveform Operations. Questa funzione
somma le due forme d’onda per ottenere una sinusoide con
rumore.
f. Inserite il VI FFT Power Spectrum che si trova nella palette
Functions»Analyze»Waveform Measurements. Questo VI
calcola la risposta in frequenza dell’ingresso della forma d’onda
tempo-variante e media i dati secondo i parametri specificati.
1-8
Lezione 1
Per creare il controllo del cluster dei parametri della media,
cliccate con il tasto destro del mouse sul terminale d’ingresso e
selezionate Create»Control dal menu rapido.
g. Inserite la funzione Wait Until Next ms Multiple che si trova nella
palette Functions»Time & Dialog. Questa funzione determina
l’esecuzione del ciclo While ogni mezzo secondo. Per creare una
costante, cliccate con il tasto destro del mouse sul terminale
d’ingresso e selezionate Create»Constant dal menu rapido.
h. Inserite la funzione Unbundle By Name che si trova nella palette
Functions»Cluster. Questa funzione estrae il booleano di stato
dal cluster di errore in modo da arrestare il ciclo in caso di errore.
i. Inserite la funzione Or che si trova nella palette
Functions»Boolean. Questa funzione combina il Boolean dello
stato di errore e il pulsante Stop del pannello frontale affinché il
ciclo si fermi se uno di questi valori diventa True.
j. Inserite il VI Simple Error Handler che si trova nella palette
Functions»Time & Dialog. Una finestra di dialogo appare in
questo VI in caso di errore e visualizza informazioni sull’errore.
4. Salvate questo VI come Generate & Analyze Data.vi nella
directory c:\exercises\LV Basics 2.
5. Osservate come i VI che avete utilizzato nello schema a blocchi
gestiscono gli errori. Cliccate due volte sul VI Sine Waveform e aprite
il suo schema a blocchi. Notate che la prima cosa che fa è di osservare
l’errore nel cluster per verificare l’esistenza di errori precedenti. Se
c’è stato un errore, LabVIEW fornisce una forma d’onda vuota e
passa all’esterno le informazioni sull’errore. Se non ci sono stati
errori, LabVIEW genera una forma d’onda sinusoidale con i parametri
d’ingresso specificati.
6. Avviate il VI. Potete regolare i controlli del pannello frontale per
vedere i cambiamenti temporali e in frequenza delle forme d’onda.
Potete forzare un errore inserendo valori sbagliati in questi controlli.
Per esempio, una frequenza di campionamento Fs troppo bassa o
troppo alta fornisce un errore.
Attivando l’averaging mode, potete estrarre il picco della sinusoide
dal rumore indipendentemente dalle ampiezze. Notate come agiscono
le diverse tecniche di media sul segnale.
7. Fermate il VI e chiudetelo quando avete finito.
Fine dell’esercitazione 1-1
1-9
Lezione 1
D. Architetture di programmazione in LabVIEW
Potete sviluppare meglio programmi in LabVIEW e in altri linguaggi di
programmazione se seguite tecniche e architetture di programmazione
coerenti. I programmi strutturati sono più facili da mantenere e da capire.
Ora che avete creato diversi VI in LabVIEW sia nel LabVIEW Corso
Base I che in esperienze di programmazione simili, questo concetto di
programmazione strutturata viene descritto più in dettaglio.
Uno dei modi migliori per creare un’architettura di programmazione che
sia facile da comprendere è di seguire tecniche di programmazione
modulare e realizzare subVI per operazioni ripetute o raggruppabili per
analogia. Per esempio, fate riferimento al VI che avete realizzato
nell’esercitazione 1-1. I subVI che avete utilizzato rendono il VI molto
facile da seguire e da capire ed ogni parte può essere riutilizzata in altri
VI. Con la documentazione dello schema a blocchi e quella presente
nell’opzione File»VI Properties»Documentation, un VI modulare è
facile da capire e da modificare nel futuro.
Potete strutturare i VI in maniera diversa a seconda della funzionalità che
volete assegnarli. Questa sezione descrive alcuni tipi comuni di
architetture per VI, con i loro vantaggi/svantaggisemplice, generale, a
cicli paralleli, a condizioni multiple e a macchine di stato.
Architettura di VI semplice
Quando fate dei calcoli o effettuate delle misure veloci di laboratorio, non
avete bisogno di un’architettura complessa. Il vostro programma potrebbe
essere un singolo VI che esegue una misura, o un calcolo e visualizza o
registra i dati su disco. L’architettura di VI semplice di solito non richiede
un’azione specifica di avvio o di stop da parte dell’utente e il VI può
essere attivato quando l’utente clicca sul pulsante di run. Oltre ad essere
utilizzata per semplici applicazioni, questa architettura viene usata per
componenti funzionali all’interno di applicazioni più grandi. Potete
convertire questi semplici VI in subVI che vengono usati come blocchi
costituenti di applicazioni più grandi.
1-10
Lezione 1
Il pannello frontale e lo schema a blocchi precedente sono del VI Convert
C to F che avete realizzato nel LabVIEW Corso Base I. Questo VI esegue
l’unico compito di convertire un valore da gradi Celsius in gradi
Fahrenheit. Potete utilizzare questo semplice VI in altre applicazioni che
necessitano di questa conversione senza aver bisogno di ricordare
l’equazione.
Architettura generale di un VI
Nel progettare un’applicazione, generalmente dovete passare attraverso
tre fasi:
Inizializzazione
Questa sezione viene utilizzata per
inizializzare l’hardware, leggere le
informazioni di configurazione dai
file o per richiedere all’utente la
posizione dei file.
Applicazione principale
Questa sezione in generale consiste
in almeno un ciclo che viene
ripetuto fino a quando l’utente
decide di uscire dal programma o il
programma si arresta per altri
motivi come il completamento di
un I/O.
Chiusura
Questa sezione di solito si occupa di
chiudere i file, di scrivere le
informazioni di configurazione su
disco o di ripristinare l’I/O sullo
stato di default.
Lo schema a blocchi seguente mostra questa architettura generale. Per
applicazioni semplici, il ciclo dell’applicazione principale può essere
abbastanza semplice. Quando avete interfacce utente complicate o eventi
multipli, come ad esempio azioni dell’utente, trigger sull’I/O e così via,
questa sezione può diventare più complicata. Le illustrazioni successive
mostrano le strategie di progetto che potete adottare per progettare grandi
applicazioni.
Inserite qui il vostro codice
1-11
Lezione 1
Notate nello schema a blocchi precedente che i collegamenti del cluster di
errore controllano l’ordine di esecuzione delle tre sezioni. Il ciclo While
non può iniziare l’esecuzione se il VI Startup non ha finito l’esecuzione e
ha fornito il cluster di errore. Di conseguenza, il VI Shutdown non può
essere eseguito finché il programma principale all’interno del ciclo While
non ha terminato l’esecuzione e il cluster di errore è passato all’esterno
del ciclo. Un’altra cosa da notare nello schema a blocchi precedente è la
funzione di attesa. Una funzione di attesa è necessaria in molti cicli
soprattutto se quel ciclo sta monitorando un ingresso da parte dell’utente
sul pannello frontale. Senza la funzione di attesa, il ciclo potrebbe
rimanere in esecuzione continuativamente, utilizzando tutte le risorse del
sistema. La funzione di attesa forza l’esecuzione asincrona del ciclo anche
se l’intervallo di attesa viene impostato su zero millisecondi. Se le
operazioni all’interno del ciclo principale dipendono da azioni dell’utente,
allora il periodo di attesa può essere aumentato ad un livello accettabile
per i tempi di reazione. Un’attesa di 100-200 ms è di solito buona per la
maggior parte degli utenti che non si accorgono del ritardo tra la
pressione di un pulsante e la successiva esecuzione di un’azione.
Architettura di VI a cicli paralleli
Alcune applicazioni richiedono che il programma risponda a diversi
eventi concorrenti e li esegua. Un modo di progettare la sezione
principale di questa applicazione è di assegnare un ciclo differente ad
ogni evento. Per esempio, potreste avere un ciclo differente per ogni
pulsante del pannello frontale associato ad un’azione e per ogni altro
genere di eventi, come una selezione di menu, trigger su I/O e così via. Lo
schema a blocchi seguente mostra l’architettura di VI a cicli paralleli.
Inserite qui il codice per
il primo processo
Inserite qui il codice per
il secondo processo
Questa struttura è lineare e va bene per alcuni VI semplici del tipo a menu
in cui si aspetta che l’utente selezioni un pulsante tra tanti che portano ad
azioni differenti. Questa architettura di VI è vantaggiosa rispetto ad altre
tecniche anche nel consentire che un evento non vi impedisca di
1-12
Lezione 1
rispondere ad altri eventi aggiuntivi. Per esempio, se un utente seleziona
un pulsante che determina la comparsa di una finestra di dialogo, i cicli
paralleli possono continuare a rispondere ad eventi di I/O. Quindi, il
vantaggio principale dell’architettura di VI a cicli paralleli è la sua abilità
nel gestire processi multipli indipendenti e contemporanei.
Gli svantaggi principali dell’architettura a cicli paralleli riguardano il
coordinamento e la comunicazione tra cicli differenti. Il pulsante Stop per
il secondo ciclo nello schema a blocchi precedente è una variabile locale.
Non potete utilizzare delle linee per passare i dati tra i cicli, perché ciò
impedirebbe l’esecuzione in parallelo dei cicli. Invece dovete usare delle
tecniche globali per passare le informazioni tra i processi. Ciò può portare
a condizioni di conflitto in cui compiti differenti tentano di leggere e di
modificare gli stessi dati contemporaneamente determinando risultati
inconsistenti e rendendo difficile la ricerca degli errori.
Fate riferimento alla Lezione 3, Tecniche di gestione dei dati, di questo
corso, per ulteriori informazioni sulle variabili globali, sulle variabili locali e le
condizioni di conflitto.
Nota
Architettura di VI con strutture Case multiple
Lo schema a blocchi seguente mostra come progettare un VI che possa
gestire eventi multipli che possono passare dati in avanti e all’indietro.
Invece di usare cicli multipli, potete utilizzare un singolo ciclo che
contenga strutture Case separate per ogni evento. Questa architettura di
VI dovrebbe essere usata anche nella situazione in cui avete diversi
pulsanti sul pannello frontale e ognuno attiva eventi diversi. Le condizioni
FALSE seguenti sono vuote.
Codice della
Azione 1
Codice della
Azione 2
Un vantaggio di questa architettura è che potete utilizzare delle linee per
passare i dati. Ciò aumenta la leggibilità. Inoltre riduce il bisogno di
utilizzare dati globali e di conseguenza rende meno probabile che
incontriate situazioni di conflitto. Potete utilizzare i registri a scorrimento
sulla cornice del ciclo per riportare i valori da un’iterazione alla
successiva, passando anche i dati.
1-13
Lezione 1
Esistono diversi svantaggi nell’architettura di VI con strutture Case
multiple. Innanzitutto potete finire con l’avere schemi a blocchi che sono
molto grandi e difficili da leggere, modificare e correggere. Inoltre,
siccome tutti i gestori degli eventi sono nello stesso ciclo, ognuno viene
gestito in modo seriale. Di conseguenza, se un evento prende molto
tempo, il vostro ciclo non riesce a gestire altri eventi. Un problema
collegato è che gli eventi sono gestiti alla stessa velocità siccome nessun
evento può essere ripetuto finché tutti gli oggetti nel ciclo While hanno
terminato. In alcune applicazioni, potreste aver bisogno di impostare la
priorità degli eventi sull’interfaccia utente per renderli sufficientemente
confrontabili con gli eventi di I/O.
Architettura di VI con macchine a stati
Potete realizzare schemi a blocchi più compatti utilizzando una singola
struttura Case per gestire tutti i vostri eventi. L’architettura di VI con
macchine a stati è un metodo per il controllo dell’esecuzione di VI in
modo non lineare. Questa tecnica di programmazione è molto utile in VI
che sono frazionabili in diversi compiti semplici, come nei VI che
agiscono come interfaccia utente.
Create una macchina a stati in LabVIEW con un ciclo While, una
struttura Case e un registro a scorrimento. Ogni stato della macchina a
stati è una condizione nella struttura Case. Inserite i VI e altro codice che
volete eseguire nella condizione corretta. Un registro a scorrimento
memorizza lo stato da eseguire fino all’iterazione successiva del ciclo. Lo
schema a blocchi della macchina a stati è mostrato nelle figure seguenti.
1-14
Lezione 1
Codice della
Azione 1
Codice della
Azione 2
In questa architettura, progettate l’elenco dei possibili eventi, o stati, e
quindi mappateli ognuno su una condizione. Per il VI dello schema a
blocchi precedente, gli stati possibili sono startup, idle, event 1, event 2 e
shutdown. Questi stati sono memorizzati in una costante. Ogni stato ha la
sua condizione in cui potete inserire i nodi opportuni. Mentre una
condizione è in esecuzione, lo stato successivo viene determinato sulla
base del risultato corrente. Lo stato successivo viene memorizzato nel
registro a scorrimento. In caso di errore in uno degli stati, viene
richiamata la condizione shutdown.
Il vantaggio dell’architettura con macchine a stati è che lo schema a
blocchi può diventare molto più piccolo, rendendone più facile la lettura e
la correzione. Un inconveniente della struttura Sequence è che non si può
saltare o interrompere un frame. L’architettura con macchine a stati
risolve questo problema perché ogni condizione determina quale stato
dev’essere eseguito successivamente.
Uno svantaggio dell’architettura con macchine a stati è che con questo
approccio potete perdere degli eventi. Se due eventi si presentano nello
stesso istante, questo modello gestisce il primo e perde il secondo. Ciò
può condurre ad errori che sono difficili da correggere perché possono
presentarsi solo occasionalmente. Versioni più complesse dei VI con
architettura con macchine a stati contengono codice aggiuntivo che
realizza una coda di eventi e stati e così non li perdete.
1-15
Lezione 1
Note aggiuntive sulle architetture di programmazione
Come con altri linguaggi di programmazione, vengono usati diversi
metodi e tecniche di programmazione quando si progetta un VI in
LabVIEW. Le architetture mostrate in questa sezione costituiscono dei
metodi comuni per fornirvi un’idea di come si deve affrontare la scrittura
di un VI.
Le strutture dei VI diventano molto più complicate al crescere delle
dimensioni delle applicazioni e quando vengono combinati diversi tipi di
hardware, di interfacce utente e metodi di verifica degli errori. Tuttavia,
vedrete utilizzare queste stesse architetture di programmazione di base.
Esaminate gli esempi più grandi e le demo che vengono fornite con
LabVIEW e descrivete quale architettura di VI viene usata e perché.
Risorse aggiuntive per la realizzazione di applicazioni in LabVIEW sono
descritte nel manuale LabVIEW Development Guidelines.
Nel paragrafo successivo realizzerete un VI che utilizza una semplice
architettura di VI per verificare il nome e la password di un utente.
1-16
Lezione 1
Esercitazione 1-2
Obiettivo:
VI Verify Information
Realizzare un VI che mostri una semplice architettura.
Realizzerete un VI che accetta un nome e una password e verifica la
corrispondenza in una tabella contenente le informazioni degli impiegati.
Se il nome e la password coincidono, vengono forniti, come verifica, il
nome e un oggetto booleano.
Nota Utilizzerete questo VI nella Lezione 3.
Pannello frontale
1. Aprite un VI e realizzate il pannello frontale precedente. Modificate i
controlli a stringa come descritto nelle etichette cliccando con il tasto
destro del mouse sul controllo. Il controllo Table che si trova nella
palette Controls»List & Table è una matrice bidimensionale di
stringhe in cui la prima cella è l’elemento 0,0.
2. Inserite le informazioni mostrate nel pannello frontale precedente in
Table e salvate questi valori come default cliccando con il tasto destro
del mouse su Table e selezionando Data Operations»Make Current
Value Default dal menu rapido.
1-17
Lezione 1
Schema a blocchi
Il nome
corrisponde
Il nome non
corrisponde
3. Aprite e realizzate lo schema a blocchi precedente utilizzando i
componenti seguenti.
a. Inserite un ciclo While che si trova nella palette
Functions»Structures. Questo consente al VI di effettuare
continuamente verifiche finché c’è una corrispondenza di nome o
non ci sono più righe nella tabella. Notate che è abilitata
l’indicizzazione sulla matrice dei nomi ma non sulle altre due voci
inserite all’interno del ciclo While. Abilitate l’indicizzazione
cliccando con il tasto destro del mouse sul tunnel e selezionando
Enable Indexing dal menu rapido.
b. Inserite una struttura Case che si trova nella palette
Functions»Structures. Se l’ingresso Nome coincide con una
voce presente nell’elenco della prima colonna della tabella, allora
vengono verificate anche le password. Se Nome non corrisponde
all’inserimento corrente, il ciclo passa all’iterazione successiva.
Prima di creare una costante booleana nella condizione False,
completate i collegamenti della condizione True. Quindi
selezionate la condizione False e cliccate con il tasto destro del
mouse il tunnel bordato di verde e selezionate Create»Constant
dal menu rapido.
c. Inserite la funzione Index Array che si trova nella palette
Functions»Array. Questa funzione viene utilizzata per tirare
fuori la matrice dei nomi dalla tabella. Quando collegate la tabella
all’ingresso della matrice di questa funzione, appaiono due indici,
di riga e di colonna.
1-18
Lezione 1
Cliccate con il tasto destro del mouse sull’indice inferiore, di
colonna, e selezionate Create»Constant dal menu rapido.
Utilizzerete due di queste funzioni, quindi fatene una copia e
inseritela nella struttura Case alla condizione True.
d. Inserite la funzione Array Size che si trova nella palette
Functions»Array. Questa funzione fornisce le dimensioni della
matrice dei nomi.
e. Inserite la funzione Decrement che si trova nella palette
Functions»Numeric. Questa funzione decrementa di uno il
numero dei nomi della matrice così si può controllare il ciclo
While che parte da 0.
f. Inserite la funzione Equal? che si trova nella palette
Functions»Comparison. Utilizzerete due di queste funzioni per
verificare se l’ingresso Nome coincide con una voce della tabella
e analogamente per Password.
g. Inserite la funzione Less Than? che si trova nella palette
Functions»Comparison. Questa funzione controlla il terminale
condizionale del ciclo While. Il ciclo continua ad essere eseguito
finché il numero di iterazione corrente è inferiore al numero di
righe nella tabella.
h. Inserite la funzione Not Or che si trova nella palette
Functions»Boolean. Questa funzione controlla anch’essa il
terminale condizionale del ciclo While affinché il ciclo continui
fino a quando viene trovata una coincidenza o non ci sono più
righe nella tabella.
i. Inserite la costante Empty String che si trova nella palette
Functions»String. Utilizzerete due di queste costanti, una per la
condizione True e l’altra per la False. Se i nomi corrispondono ma
non le password o se nessuno dei due corrisponde, allora viene
fornita una stringa vuota nell’indicatore Nome Confermato.
j. Inserite la funzione Select che si trova nella palette
Functions»Comparison. Questa funzione viene usata con la
verifica della password. Se la password corrisponde, il nome
corrente viene inviato all’indicatore Nome Confermato;
altrimenti viene inviata la stringa vuota.
4. Salvate il VI come Verify Information.vi.
5. Andate sul pannello frontale ed assicuratevi di avere alcuni nomi, i
nomi non devono essere gli stessi usati nel manuale del corso, e
password nel controllo della tabella. Se non lo avete già fatto, cliccate
con il pulsante destro del mouse sulla tabella e selezionate Data
Operations»Make Current Values Default così nomi e password
vengono memorizzati permanentemente nella tabella.
1-19
Lezione 1
6. Inserite i valori nei controlli Nome e Password ed avviate il VI.
Se Nome e Password coincidono con una delle righe presenti in
tabella, viene fornito il nome nell’indicatore Nome Confermato e si
accende il LED Verificato. Altrimenti viene fornita una stringa vuota
e il LED è spento. Assicuratevi di provare diverse combinazioni di
nomi e password per verificare il comportamento corretto del VI.
7. Create un’icona per questo VI perché lo utilizzerete come subVI in un
esercizio più avanti. Per creare l’icona, cliccate con il tasto destro del
mouse sull’icona nell’angolo superiore destro del pannello frontale o
dello schema a blocchi e selezionate Edit Icon dal menu. Disegnate
un’icona simile a quella mostrata qui.
8. Create il riquadro dei connettori per questo VI cliccando con il tasto
destro del mouse sull’icona del pannello frontale e selezionando Show
Connector dal menu rapido. Selezionate uno schema e collegate gli
oggetti del pannello frontale ai terminali come mostrato nel riquadro
dei connettori seguente.
9. Salvate il VI con lo stesso nome.
10. Arrestate e chiudete il VI quando avete finito.
1-20
Lezione 1
E. Modelli di VI
Nell’ultima sezione, avete imparato qualcosa sulle architetture di
programmazione dei VI. Affinché non dobbiate partire da zero nella
realizzazione di un nuovo VI con un pannello frontale e uno schema a
blocchi vuoto, vengono inclusi nel pacchetto di LabVIEW alcuni modelli.
Questi modelli si trovano nella directory LabVIEW 6\Templates e
contengono file con l’estensione .vit. LabVIEW fornisce alcuni modelli
di base e comunque non tutte le architetture di VI descritte sono
disponibili come modelli.
Potete salvare un VI che avete creato come modelli utilizzando l’opzione
File»Save with Options come mostrato nella seguente finestra di
dialogo.
Questa opzione vi consente di salvare architetture di VI e altre strutture di
programmazione che utilizzate spesso per i vostri modelli. Ora
esaminerete un paio di modelli.
1-21
Lezione 1
Esercitazione 1-3
Obiettivo:
VIT Timed While Loop with Stop e
State Machine
Esaminare due modelli di VI forniti con LabVIEW.
Esaminerete i modelli di VI che mostrano sia l’architettura con la
macchina a stati sia quella generale.
Pannello frontale
1. Aprite il Timed While Loop with Stop.vit dalla directory
LabVIEW 6\Templates. Il pannello frontale contiene solo il
pulsante di Stop.
Schema a blocchi
2. Aprite ed esaminate lo schema a blocchi.
3. Noterete come questo VI possieda l’architettura generale di un VI.
Esso contiene un ciclo While che si arresta quando cliccate sul
pulsante del pannello frontale e una funzione di attesa nel ciclo
assicura che questo ciclo non utilizzi tutte le risorse del sistema.
4. Tornate al pannello frontale ed avviate il VI. Esso non fa niente ma
continua l’esecuzione fino a quando premete il pulsante di Stop.
6. Aprite
State
Machine.vit dalla
6\Templates. Il pannello frontale è vuoto.
il
1-22
directory
LabVIEW
Lezione 1
Schema a blocchi
8. Questa architettura con macchine a stati è implementata in un modo
leggermente diverso da quello descritto precedentemente. Questo VI
utilizza una costante di stringa per contenere gli stati della struttura
Case mentre il VI mostrato precedentemente usava una del tipo
enumerated, simile al controllo di tipo ring, per controllare gli stati.
Siccome la struttura Case accetta sia numeri che stringhe, non importa
come avete specificato i differenti stati. La chiave nell’architettura con
macchine a stati è che avete un ciclo While con una struttura Case
all’interno in cui ogni condizione è uno stato differente
dell’applicazione complessiva. Lo stato successivo viene determinato
mentre il VI è in esecuzione sulla base di quello che accade nello stato
corrente.
9. Chiudete il VI quando avete finito.
1-23
Lezione 1
Sommario, trucchi e consigli
y
In molti casi viene usato un approccio del tipo top-down per
pianificare la strategia complessiva di un progetto. Lo sviluppo e
l’implementazione di un’applicazione di solito è del tipo bottom-up.
y
Nella progettazione di un’applicazione in LabVIEW, è importante
determinare l’aspettativa finale dell’utente, cosa deve realizzare
esattamente l’applicazione e quali modifiche future potrebbero essere
necessarie prima di investire una gran quantità di tempo nello
sviluppo di subVI. Dovreste realizzare un diagramma di flusso che vi
aiuti a capire come dovrebbe operare l’applicazione e discuterne in
dettaglio con il vostro cliente.
y
Dopo aver realizzato il diagramma di flusso, potete sviluppare VI per
implementarne i vari passi. È una buona idea di rendere modulare la
vostra applicazione in compiti logici elementari, quando possibile.
Lavorando con piccoli moduli, potete correggere un’applicazione
testando ogni modulo singolarmente. Questo approccio rende molto
più facile dell’applicazione in futuro.
y
I cluster di errore sono un metodo potente di gestione degli errori
usato in quasi tutti i VI di I/O e le funzioni di LabVIEW. Questi
cluster passano le informazioni sugli errori da un VI al successivo.
y
Un gestore degli errori alla fine del flusso dei dati può ricevere il
cluster di errore e visualizzare le informazioni sugli errori in una
finestra di dialogo.
y
Le architetture di VI più comuni sono quella semplice, quella
generale, quella a cicli paralleli, quella a strutture Case multiple e
quella a macchine a stati. Ciascuna di queste architetture ha i suoi
vantaggi e svantaggi in funzione di quello che deve fare
l’applicazione.
y
L’architettura di VI con macchine a stati è molto utile per VI
d’interfaccia utente e genera un codice semplice e chiaro.
y
Molti modelli di VI vengono forniti con LabVIEW così non avete
bisogno ogni volta di iniziare lo sviluppo di un VI da pannelli frontali
e schemi a blocchi vuoti.
y
Fate riferimento al manuale LabVIEW Development Guidelines per
ulteriori informazioni sulla progettazione e realizzazione di VI.
1-24
Lezione 1
Note
1-25
Lezione 1
Note
1-26
Lezione 2
Questa lezione vi introduce alla progettazione e realizzazione di
interfacce utente per i vostri VI. Dapprima una panoramica ed un elenco
di cose da considerare durante la realizzazione del pannello frontale.
Quindi in alcune sezioni successive vengono descritti alcuni metodi e
strumenti comuni per la personalizzazione dei pannelli. Le sezioni
conclusive descrivono parti aggiuntive e oggetti dei pannelli utilizzati per
lo sviluppo di interfacce utente.
Imparerete:
A. A conoscere gli elementi fondamentali dell’interfaccia utente.
B. Ad utilizzare cluster booleani come menu.
C. A conoscere i Property Nodes.
D. A conoscere le proprietà dei grafici.
E. Ad utilizzare i Control References.
F. A conoscere i menu run-time di LabVIEW.
G. A conoscere gli Intensity Plots.
2-1
Lezione 2
A. Nozioni fondamentali sull’interfaccia utente
Quando sviluppate applicazioni che vengono utilizzate da altre persone,
dovete seguire alcune regole fondamentali riguardanti l’interfaccia utente.
Se il pannello frontale contiene troppi oggetti o presenta un miscuglio di
colori e di testo, gli utenti potrebbero non utilizzare correttamente il VI o
non ottenere le informazioni importanti dai dati. Questa sezione descrive
alcuni elementi da considerare nella realizzazione di pannelli frontali.
Una regola da seguire durante la realizzazione di un’interfaccia utente di
un VI è di mostrare solamente le parti nel pannello frontale che l’utente
ha bisogno di vedere in quel momento. L’esempio seguente mostra un
subVI che richiede all’utente un nome come login. Ci sono dei cluster di
errore perché è un subVI ma l’utente non ha bisogno di vedere quelle
parti o il nome del percorso del file.
L’esempio successivo mostra lo stesso subVI dopo che il pannello
frontale è stato ridimensionato e la barra dei menu, le barre di scorrimento
e la barra degli strumenti sono stati rimossi con l’opzione VI
Properties»Window Appearance»Dialog.
2-2
Lezione 2
Utilizzo dei colori
Un uso corretto dei colori può migliorare l’aspetto e la funzionalità del
vostro pannello frontale. L’utilizzo di troppi colori, tuttavia, può causare
contrasti che fanno apparire i pannelli frontali troppo pieni e dispersivi.
Ecco alcuni suggerimenti sugli abbinamenti dei colori:
y
Iniziate con il grigioselezionate uno o due toni di grigio ed
evidenziate i colori che hanno un buon contrasto con lo sfondo.
y
Aggiungete i colori con parsimoniasui grafici, sui pulsanti
d’interruzione ed eventualmente sui cursori per le impostazioni
importanti. Gli oggetti piccoli hanno bisogno di colori più brillanti e
di più contrasto rispetto a quelli più grandi.
y
Utilizzate spaziature ed allineamenti per raggruppare gli oggetti
invece di adottare i colori.
y
Dei luoghi buoni per imparare ad utilizzare i colori sono i pannelli
degli strumenti stand-alone, le cartine, i giornali e la natura.
Inoltre ricordate che circa il venti per cento degli ingegneri non
riconoscono tutti i colori. Essi si basano sui contrasti piuttosto che sui
colori quando devono distinguere gli oggetti.
Spaziatura ed allineamento
Gli spazi vuoti e l’allineamento sono probabilmente le tecniche più
importanti per raggruppare e separare. Più sono gli oggetti che i vostri
occhi possono trovare su una linea, più chiara è l’organizzazione. Quando
gli oggetti sono disposti su una linea l’occhio segue la linea da sinistra a
destra o dall’alto verso il basso. Questo è collegato alla direzione della
scrittura. Sebbene alcune culture procedano da destra a sinistra, quasi tutti
seguono dall’alto verso il basso.
Oggetti centrati sono meglio di quelli disposti casualmente, ma meno
ordinati rispetto a quelli allineati a sinistra o a destra. Una fascia di spazio
vuoto agisce come un vero strumento di allineamento. Gli oggetti centrati
hanno i bordi non allineati e l’ordine non è chiaro.
2-3
Lezione 2
I menu sono allineati a sinistra e i collegamenti relativi a destra come
mostrato nell’esempio in basso a sinistra del menu File di LabVIEW. E’
più difficile individuare voci nel menu con allineamento al centro come
mostrato nell’esempio in basso a destra. Notate come delle semplici linee
che dividono sezioni del menu vi aiutino a trovare le voci più
rapidamente, rafforzando le relazioni tra le voci della sezione.
Testo e font
Il testo è più facile da leggere e l’informazione ha più senso quando la
visualizzazione è ordinata. Per tenerne conto durante la realizzazione di
pannelli frontali, provate a raggruppare controlli correlati, utilizzando
spazi vuoti o linee. Questi metodi funzionano meglio quando non
distraggono dal contenuto informativo.
Usare troppi font rende il vostro pannello frontale troppo pieno e
disorganizzato. E’ meglio utilizzare due o tre dimensioni diverse dello
stesso tipo di font. Il Serif aiuta le persone a riconoscere intere parole a
distanza. Se state utilizzando più di una dimensione di un font,
assicuratevi che le dimensioni siano abbastanza diverse. Altrimenti
apparirà come un errore. Analogamente, se utilizzate due diversi tipi di
font, assicuratevi che siano distinguibili.
Alcune stazioni di operatori possono essere abbagliate o gli utenti
potrebbero aver bisogno di leggerle a grande distanza rispetto ai normali
computer o con un touch screen. Perciò dovreste utilizzare font più grandi
e maggior contrasto.
Consigli e strumenti per l’interfaccia utente
Non è necessario o non è intelligente perdere tempo a rendere ogni
pannello frontale chiaroconcentratevi su quelli che gli utenti vedono di
più.
2-4
Lezione 2
Alcuni degli strumenti interni di LabVIEW per rendere i pannelli frontali
user-friendly, comprendono controlli di dialogo, controlli tab,
decorazioni, menu e ridimensionamento automatico degli oggetti del
pannello frontale.
Controlli di dialogo
Una tecnica comune che si usa per l’interfaccia utente è di avere finestre
di dialogo che compaiono al momento opportuno per interagire con
l’utente. Potete fare in modo che un VI appaia come una finestra di
dialogo selezionando quell’opzione nella finestra di dialogo File»VI
Properties»Window Appearance. La palette Controls»Dialog
Controls contiene alcuni tipi di oggetti disponibili nelle finestre di
dialogo di sistema.
Dovreste utilizzare questi controlli di dialogo per realizzare finestre di
dialogo tipo quelle di sistema. I controlli di dialogo cambiano aspetto
secondo il sistema operativo e le impostazioni di Window Appearance e
di solito ignorano i click a colori eccetto quello trasparente. Se state
integrando un grafico o controlli non di dialogo nel pannello frontale,
provate a modificarli nascondendo alcune cornici o selezionando colori
simili a quelli di sistema.
Controlli Tab
Gli strumenti fisici di solito hanno delle buone interfacce utente. Prendete
spunto da questi ma considerate controlli più piccoli o più efficienti, come
quelli tipo ring o controlli tab laddove ha senso. I controlli tab si trovano
nella palette Controls»Dialog Controls o nella palette Controls»Array
& Cluster e offrono un modo conveniente per raggruppare insieme
oggetti del pannello frontale.
Il modo di utilizzare il controllo tab è di disporlo sul pannello frontale
come mostrato precedentemente. Aggiungete tab cliccando con il tasto
destro del mouse su un tab esistente e selezionando Add Page After, Add
Page Before o Duplicate Page dal menu. Rietichettate i tab con lo
strumento Testo ed inserite altri oggetti sul pannello frontale nelle pagine
appropriate. I terminali di questi oggetti sono presenti nello schema a
blocchi così come lo sono terminali di ogni altro oggetto del pannello
frontale.
2-5
Lezione 2
Il controllo tab si collega direttamente ad una struttura Case come
mostrato precedentemente e il nome della pagina compare in alto come
nome della condizione. Potete quindi collegare i dati agli altri terminali a
seconda delle necessità.
Decorazioni
Uno dei metodi più semplici e spesso trascurato per raggruppare o
separare oggetti è di utilizzare una delle possibilità offerte dalla palette
Controls»Decorations. Potete scegliere di utilizzare vari tipi di riquadri,
frecce e linee dalla palette nel modo seguente:
Potete trovare ulteriori decorazioni nella palette Controls»Classic
Controls. La palette seguente mostra i diversi riquadri, cornici, linee,
frecce, cerchi e triangoli.
2-6
Lezione 2
Menu
I menu costituiscono un buon modo di presentare la maggior parte delle
funzionalità del pannello frontale in modo ordinato e in uno spazio
relativamente piccolo. In tal modo si lascia spazio sul pannello frontale
per azioni necessarie in caso di emergenza, voci per principianti, voci
necessarie per la produttività e voci che non rientrano nei menu.
Assicuratevi anche di aggiungere pulsanti rapidi per i menu per le voci
richieste più frequentemente. Più avanti nella lezione imparerete a creare i
vostri menu in un VI.
Ridimensionamento automatico di oggetti del pannello frontale
Come già detto precedentemente, potete utilizzare le opzioni in VI
Properties»Window Appearance per modificare l’aspetto del pannello
frontale quando un VI è in esecuzione. Con le opzioni in VI
Properties»Window Size potete impostare le dimensioni minime di una
finestra, mantenere le proporzioni della finestra al variare dello schermo e
impostare il ridimensionamento degli oggetti del pannello frontale in due
modi diversi. La maggior parte delle applicazioni professionali non
ridimensiona ogni controllo quando le dimensioni della finestra variano,
ma prendono una tabella, un grafico o un elenco per adattarlo alla
finestra, lasciando gli altri oggetti vicino al bordo della finestra. Per
ridimensionare un oggetto del pannello frontale al variare del pannello
frontale, selezionate quell’oggetto e quindi Edit»Scale Object With
Panel.
L’esercizio seguente utilizza alcune delle tecniche descritte per creare un
VI con un’interfaccia utente facile da usare.
2-7
Lezione 2
Esercitazione 2-1
Obiettivo:
VI Scope Panel
Disporre e separare in modo logico gli oggetti del pannello frontale per rendere
l’interfaccia utente di un VI più semplice da leggere e da utilizzare.
Ridimensionerete, riorganizzerete e disporrete in modo diverso gli oggetti
del pannello frontale per rendere l’interfaccia utente più semplice da
utilizzare.
Pannello frontale
1. Aprite il VI Scope Panel dalla directory c:\exercises\LV basics
2. Il pannello frontale è quello mostrato sopra.
2. Spostate i controlli per raggruppare in maniera logica quelli che
presentano delle affinità (non tutti possono essere collegati ad un
gruppo). Per esempio il pulsante ON/OFF, il potenziometro di
posizionamento e il potenziometro Volts/Div etichettati con Channel
A operano tutti sul canale A e quindi ha senso disporli vicini l’uno
all’altro. Altri due esempi di gruppi potrebbero essere i controlli del
Channel B e i tre controlli di trigger.
Ricordatevi di utilizzare le possibilità offerte nella barra degli
strumenti da Align Objects e Distribute Objects.
Consiglio
3. Dopo aver raggruppato i controlli, utilizzate la decorazione Raised
Box sulla palette Controls»Decorations per rendere più visibili le
separazioni tra i gruppi.
2-8
Lezione 2
Ridimensionate la finestra affinché il pannello frontale si adatti alla
finestra, come mostrato nell’esempio seguente.
Dovete utilizzare il pulsante Reorder sulla barra degli strumenti
delle decorazioni per scegliere Move to Back, affinché i controlli siano visibili
al di sopra dei riquadri evidenziati inseriti.
Consiglio
4. Selezionate File»VI Properties per visualizzare la finestra di dialogo
VI Properties. Selezionate Window Size dal menu a tendina
superiore della finestra di dialogo VI Properties. Nella sezione
Minimum Panel Size, cliccate sul pulsante <<Set to Current
Window Size per impostare le dimensioni minime dello schermo
sulle dimensioni correnti della finestra. Cliccate su OK per tornare al
pannello frontale.
5. Selezionate il grafico del pannello frontale e selezionate Edit»Scale
Object With Panel. LabVIEW ridimensiona il grafico quando viene
ridimensionata l’intera finestra e sposta gli altri oggetti.
7. Ridimensionate la finestra. Notate che il grafico si ridimensiona con la
finestra e i controlli mantengono una distanza proporzionale con il
grafico e tra di loro, ma non si allargano o si restringono. Tuttavia
notate che le decorazioni non si ridimensionano. Per ottenere ciò,
dovete utilizzare pulsanti booleani che sembrano gli stessi in ogni
condizione e li ridimensionate da programma. Ciò richiede l’uso di
Property Nodes e l’argomento verrà trattato più avanti in questa
lezione.
2-9
Lezione 2
Esercitazione 2-2
Obiettivo:
VI Acquire Data
Modificare un VI per utilizzare il controllo tab con tecniche appropriate di
progettazione dell’interfaccia utente
Modificherete il VI Generate & Analyze affinché utilizzi il controlo tab.
Una pagina del tab servirà per la generazione dei dati come prima e la
seconda pagina servirà per l’acquisizione dati da un dispositivo DAQ.
Nota Utilizzerete questo VI nel progetto della Lezione 5.
Pannello frontale
1. Aprite il VI Generate & Analyze che avete realizzato
nell’esercitazione 1-1. Ridimensionate il pannello frontale per fare
spazio alla sinistra degli altri oggetti del pannello frontale visto che
aggiungerete il controllo tab.
2. Inserite nel pannello frontale un controllo tab che si trova nella palette
Controls»Array & Cluster come mostrato precedentemente.
Selezionate i controlli Sine Frequency, Sine Amplitude, Sampling
Info e Noise Amplitude e inseriteli nella prima pagina del controllo
tab.
2-10
Lezione 2
3. Nominate le due pagine del controllo tab Simulate e DAQ
rispettivamente. Cliccate sulla pagina DAQ e aggiungete oggetti nel
modo seguente:
4. Salvate il VI come Acquire Data.vi.
5. Cliccate con il tasto destro del mouse sul controllo DAQ Channel
Name e assicuratevi che sia selezionata l’opzione Allow Undefined
Names.
6. Per cambiare la scala sul potenziometro per leggere 20.0k invece di
20,000, cliccate con il tasto destro del mouse sul potenziometro e
selezionate Format & Precision. Selezionate Engineering Notation
e il k viene aggiunto per rappresentare le migliaia.
2-11
Lezione 2
Schema a blocchi
7. Aprite e modificate lo schema a blocchi come
precedentemente utilizzando i seguenti componenti:
mostrato
a. Inserite una struttura Case che si trova nella palette
Functions»Structures dello schema a blocchi. Quando è
utilizzata con un controllo tab, una condizione corrisponde alla
pagina Simulate e l’altra alla pagina DAQ.
b. Inserite il VI AI Acquire Waveform che si trova nella palette
Functions»Data Acquisition»Analog Input dello schema a
blocchi. Questo VI acquisisce dati da un canale d’ingresso
analogico sul dispositivo DAQ.
Nota Se non avete un dispositivo DAQ o una DAQ Signal Accessory, utilizzate
il VI Demo Acquire Waveform che si trova nella palette Functions»User
Libraries»Basic 2 Course dello schema a blocchi al posto del VI Acquire
Waveform. Il VI Demo Acquire Waveform simula l’acquisizione dati da un
canale d’ingresso analogico ad una frequenza di campionamento specificata e
fornisce in uscita il numero di campioni specificato.
2-12
Lezione 2
c. Create una costante di cluster cliccando con il tasto destro del
mouse sul tunnel della struttura Case e selezionando
Create»Constant dal menu rapido. Questa costante passa in
uscita i valori di default per il cluster di errore corrispondenti alla
condizione DAQ.
8. Salvate il VI.
9. Osservate come avete aggiunto nuove funzionalità a questo VI senza
complicare troppo il codice. L’utilizzo dei controlli tab è un modo
molto efficiente per aggiungere nuovi oggetti sul pannello frontale per
l’interfaccia utente e anche per aggiungere funzionalità allo schema a
blocchi senza ingrandire troppo le finestre del pannello frontale e
dello schema a blocchi.
10. Avviate il VI. Potete anche regolare i controlli del pannello frontale
per vedere cambiare gli andamenti temporali e in frequenza. Passate
dalla pagina Simulate a quella DAQ del controllo tab.
2-13
Lezione 2
B. Utilizzo di cluster booleani come menu
Potete utilizzare pulsanti booleani in un cluster per realizzare un menu per
un’applicazione. Considerate per esempio un’applicazione in cui un
operatore configura un sistema e può eseguire due test. Un possibile VI a
menu per questa applicazione è il seguente.
Cluster di pulsanti etichettati (azione meccanica → latch when released)
Ordine del cluster:
(0) Pulsante Configure
(1) Pulsante Test 1
(2) Pulsante Test 2
La funzione Cluster to Array converte il cluster booleano in una matrice
booleana a tre elementi. Quindi ogni elemento del cluster rappresenta un
elemento della matrice. La funzione Search 1D Array della palette
Functions»Array ricerca nella matrice monodimensionale di valori
booleani creata dalla funzione Cluster to Array il valore TRUE. Un valore
TRUE per un qualsiasi elemento della matrice indica che avete cliccato su
un pulsante del cluster. La funzione Search 1D Array restituisce l’indice
del primo valore TRUE che trova nella matrice. Se non cliccate su un
pulsante, Search 1D Array fornisce un valore dell’indice di –1. Se nessun
pulsante viene premuto, viene eseguita la condizione –1, cioè nulla viene
eseguito. Cliccando sul pulsante Configure si esegue la condizione 0, che
potrebbe, per esempio, chiamare il subVI Configure. Cliccando sul
pulsante Test 1 si esegue la condizione 1, che potrebbe chiamare il subVI
Test 1 e cliccando sul pulsante Test 2 si esegue la condizione 2. Il ciclo
While testa ripetutamente lo stato dei controlli booleani fino a quando
cliccate sul pulsante Stop. Lo schema a blocchi del VI è il seguente.
2-14
Lezione 2
Vuoto.
Search 1D Array
fornisce –1 se non
ci sono bottoni
premuti
Richiama il subVI
Configure
Richiama il subVI Test 1
Search 1D Array
fornisce 1 se viene
premuto il pulsante
Test 1
Search 1D Array
fornisce 0 se viene
premuto il pulsante
Configure
Richiama il subVI
Test 2
Search 1D Array
fornisce 2 se viene
premuto il pulsante
Test 2
Conversione di cluster
Potete convertire un cluster in una matrice se tutti i componenti del
cluster hanno lo stesso tipo di dati (per esempio, tutti booleani o tutti
numerici). Con tale conversione, potete utilizzare le funzioni delle matrici
per processare i componenti all’interno del cluster.
La funzione Cluster to Array presente nelle palette Functions»Cluster e
in Functions»Array converte un cluster di componenti dello stesso tipo
in una matrice monodimensionale di dati dello stesso tipo.
L’esempio seguente mostra un cluster booleano a quattro componenti
convertito in una matrice booleana a quattro elementi. L’indice di ogni
elemento della matrice corrisponde all’ordine logico del componente nel
cluster. Per esempio, Button 1 (componente 0) corrisponde al primo
elemento (indice 0) della matrice, Button 2 (componente 1) al secondo
elemento (indice 1), e così via.
2-15
Lezione 2
2
1
3
1 Pannello frontale
2 Pannello del cluster
3 Schema a blocchi
La funzione Array to Cluster (nelle palette Functions»Cluster e in
Functions»Array) converte una matrice monodimensionale in un cluster
in cui ogni componente del cluster è dello stesso tipo dell’elemento della
matrice.
Nota Dovete cliccare con il tasto destro del mouse sull’icona della funzione per
impostare il numero di componenti nel cluster. Il numero di default dei
componenti nel cluster di uscita è nove.
Potete combinare il concetto di una macchina a stati con un cluster di
menu booleano per fornire un potente sistema di menu. Per esempio, può
darsi che dobbiate realizzare l’applicazione seguente, che può essere
suddivisa in una serie di stati.
Valore di stato Nome di stato
Descrizione
-1, Deafult
No Event
Menu booleano
di controllo per
determinare
lo
stato successivo
0
Login
1
Configure
2
Acquire
2-16
Accesso
dell’utente
Configura
l’acquisizione
Acquisisce dati
Stato successivo
Dipende
dal
pulsante premuto.
Se non viene
premuto
alcun
pulsante, lo stato
successivo è No
Event.
No Event (0)
Acquire (2)
No Event (0)
Lezione 2
L’esempio seguente rappresenta una macchina a stati per questa
applicazione.
Il pannello frontale consiste in un cluster di pulsanti booleani, in cui ogni
pulsante corrisponde ad uno stato nella macchina a stati. Nello stato –1
(stato No Event), il cluster di pulsanti booleani viene controllato per
vedere se un pulsante è stato premuto. La funzione Search 1D Array
fornisce l’indice del pulsante premuto (o –1 se non vengono premuti
pulsanti) per determinare lo stato successivo da eseguire. Il valore di stato
corrispondente viene caricato nel registro a scorrimento, e così
all’iterazione successiva del ciclo While viene eseguito lo stato
selezionato.
In ognuno degli altri stati, il registro a scorrimento viene caricato con lo
stato successivo da eseguire utilizzando una costante numerica.
Normalmente questo è lo stato –1, e quindi il menu booleano verrà
verificato di nuovo ma nello stato 1 (Configure) lo stato successivo è lo
stato 2 (Acquire).
2-17
Lezione 2
Esercitazione 2-3
VI Menu
Obiettivo: Realizzare un sistema di menu per un’applicazione
Esiste un insieme di dipendenze tra le diverse operazioni
dell’applicazione da realizzare in questo corso. In molte circostanze, dopo
aver eseguito una certa operazione, l’applicazione dovrebbe tornare nello
stato “No Event”, in cui l’applicazione controlla un menu per vedere
quale pulsante è stato premuto.
Le dipendenze dell’applicazione possono essere descritte come una
semplice macchina a stati, in cui ogni stato numerico porta ad uno stato
successivo. La tabella seguente riassume questa serie di dipendenze.
Valore di stato Nome di stato
Descrizione
-1, Default
No Event
Menu booleano
di controllo per
determinare
lo
stato successivo
0
Login
1
2
Acquire
Analyze
3
View
4
Stop
Accesso
dell’utente
Acquisisce dati
Analizza dati e
possibilmente li
salva su file
Visualizza i file
dati salvati
Arresta il VI
Stato successivo
Dipende
dal
pulsante premuto.
Se non viene
premuto
alcun
pulsante, lo stato
successivo è No
Event.
No Event
No Event
No Event
No Event
No Event
In questa esercitazione realizzerete la macchina a stati da utilizzare in
questa applicazione osservando il suo funzionamento.
2-18
Lezione 2
Pannello frontale
2. Realizzate il pannello frontale seguendo l’esempio precedente. Ogni
pulsante nel cluster, quando viene premuto, attiva uno stato
opportuno. Quando realizzate il pannello frontale, assicuratevi che il
pulsante Login sia il cluster di ordine 0. Acquire Data è il cluster di
ordine 1, Analyze & Present Data è il cluster di ordine 2, View
Analysis File è il cluster di ordine 3 e Stop è il cluster di ordine 4.
L’ordine del cluster del cluster dei menu determina il numero dello
stato che verrà eseguito.
Suggerimenti:
y
Create per primo il pulsante con l’etichetta più grande.
y
Impostate l’azione meccanica su Latch When Released.
y
Utilizzate Copy e Paste per creare altri pulsanti.
y
Utilizzate Align e Distribute nella disposizione dei pulsanti.
2-19
Lezione 2
Schema a blocchi
1. Costruite lo schema a blocchi come mostrato in precedenza.
a. Inserite nello schema a blocchi un ciclo While che si trova
nella palette Functions»Structures. In tal modo il VI
continua a generare ed analizzare i dati fino a quando l’utente
preme il pulsante Stop. Create il registro a scorrimento
cliccando con il tasto destro del mouse sul bordo sinistro o
destro del ciclo e selezionando Add Shift Register dal menu
rapido.
2-20
Lezione 2
b. Inserite nello schema a blocchi una struttura Case che si trova
nella palette Functions»Structures. Questa struttura genera
gli stati per la macchina a stati. Aggiungete condizioni
cliccando con il tasto destro del mouse sulla cornice della
struttura Case. Assicuratevi di definire la condizione –1 come
default.
c. Inserite la funzione Wait Until Next ms Multiple che si trova
nella palette Functions»Time & Dialog. Questa funzione
determina l’esecuzione del ciclo While dieci volte al secondo.
Create una costante cliccando con il tasto destro del mouse sul
terminale d’ingresso e selezionando Create»Constant.
d. Inserite la funzione Cluster to Array che si trova nella palette
Functions»Cluster o Functions»Array. In questa
esercitazione questa funzione converte il cluster di pulsanti
booleani in una matrice di dati booleani. L’oggetto booleano
del cluster di ordine 0 diventa l’elemento booleano di indice 0
della matrice, quello di ordine 1 del cluster diventa l’elemento
di indice 1 della matrice e così via.
e. Inserite la funzione Search 1D Array che si trova nella palette
Functions»Array. In questa esercitazione, questa funzione
ricerca nella matrice booleana fornita da Cluster to Array un
valore TRUE. Un valore TRUE di un qualsiasi elemento
indica che avete cliccato sul pulsante corrispondente. La
funzione fornisce un valore –1 se non avete cliccato su un
pulsante.
f. Inserite la funzione One Button Dialog che si trova nella
palette Functions»Time & Dialog. Utilizzerete quattro di
queste funzioni per indicare quale stato è stato selezionato e
caricato nel registro a scorrimento.
2. Salvate il VI come Menu.vi.
3. Avviate il VI, Quando cliccate sui pulsanti Login, Acquire Data,
Analyze & Present Data o Data File View, compare una finestra
di dialogo per indicare lo stato corrispondente in cui vi trovate.
4. Utilizzando l’esecuzione passo-passo e evidenziata, osservate
come viene eseguito il VI. Notate che finché non premete un
pulsante, la funzione Search 1D Array fornisce un valore –1, che
determina l’esecuzione continua da parte del ciclo While dello
stato -1. Una volta che viene premuto un pulsante, comunque,
l’indice dei dati booleani viene usato per determinare lo stato
successivo da eseguire. Notate come gli stati del VI corrispondano
agli stati nella tabella precedente l’esercitazione.
Nelle ultime esercitazioni sostituirete i VI che avete creato per le
funzioni One Button Dialog per realizzare l’applicazione.
2-21
Lezione 2
5. Cliccate sul pulsante Stop per arrestare l’esecuzione.
2-22
Lezione 2
Esercitazione 2-4 VI Cluster Conversion Example (Opzionale)
Obiettivo: Esaminare un VI che utilizza cluster per processare dati.
Esaminerete un VI che utilizza cluster per processare dati. Il VI
rappresenta un cluster contenente quattro pulsanti etichettati. Il VI tiene
traccia del numero di volte che avete cliccato su ogni pulsante.
Pannello frontale
1. Aprite il VI Cluster Conversion Example che si trova in
c:\exercises\LV Basics 2.
Schema a blocchi
La condizione False è vuota e serve solo per passare il cluster dal registro
a scorrimento di sinistra a quello di destra.
3. Avviate il VI. Cliccate su un pulsante. L’indicatore digitale
corrispondente dovrebbe incrementarsi ogni volta che cliccate su un
pulsante.
4. Chiudete il VI. Non salvate le modifiche.
2-23
Lezione 2
C. Nodi Proprietà
In alcune applicazioni, potreste aver bisogno di modificare da programma
l’aspetto degli oggetti del pannello frontale in risposta a certi ingressi. Per
esempio, se un utente inserisce una password non valida, potreste causare
l’accensione di un LED rosso. Un altro esempio potrebbe essere di
cambiare il colore della traccia su un grafico. Quando i punti si trovano al
di sopra di una certa soglia, potreste attivare una traccia rossa invece che
verde. Anche ridimensionare gli oggetti del pannello frontale, nascondere
parti del pannello frontale e aggiungere cursori al grafico può essere fatto
da programma utilizzando i Nodi Proprietà.
I Nodi Proprietà in LabVIEW sono molto potenti e consentono molti
utilizzi. Questo corso copre solo un utilizzo dei Nodi Proprietà per
modificare da programma l’aspetto e le caratteristiche funzionali degli
oggetti del pannello frontale. Potete impostare proprietà come i colori del
display, la visibilità, la posizione, le dimensioni, il lampeggiamento, le
stringhe di menu, le scale dei grafici, i cursori dei grafici e molto altro.
Fate riferimento a Help»Contents and Index in LabVIEW per ulteriori
informazioni sui Nodi Proprietà.
Creazione di Nodi Proprietà
Create Nodi Proprietà selezionando l’opzione Create»Property Node dal
menu rapido di un oggetto del pannello frontale o dal suo terminale sullo
schema a blocchi. Selezionando Create»Property Node si crea un nuovo
nodo sullo schema a blocchi vicino al terminale dell’oggetto. Se l’oggetto
ha una propria etichetta, il Nodo Proprietà ha la stessa etichetta. Potete
modificare l’etichetta dopo aver creato il nodo. Potete creare un qualsiasi
numero di Nodi Proprietà per un oggetto del pannello frontale.
Siccome ci sono molte proprietà differenti per gli oggetti del pannello
frontale, copriremo soltanto le proprietà comuni. Selezionate
Help»Contents and Index per trovare informazioni su una proprietà
particolare.
Utilizzo dei Nodi Proprietà
Quando create un Nodo Proprietà, esso inizialmente possiede un
terminale che rappresenta una proprietà che potete modificare per
l’oggetto corrispondente del pannello frontale. Utilizzando questo
terminale sul Nodo Proprietà, potete sia impostare (scrivere) la proprietà
che leggere lo stato corrente di quella proprietà.
Per esempio, se create un Nodo Proprietà per un controllo digitale, esso
appare sullo schema a blocchi con la proprietà Visible mostrata nel suo
terminale. Una piccola freccia appare sul lato destro di quel terminale, ad
indicare che potete leggere un valore dalla proprietà Visible del controllo
digitale.
2-24
Lezione 2
Potete modificarla in una proprietà di scrittura cliccando con il tasto
destro del mouse sul nodo e selezionando Change To Write dal menu
rapido. Collegando un FALSE booleano a quel terminale si provocherà la
sparizione del controllo digitale dal pannello frontale quando il Nodo
Proprietà riceve i dati. Collegando un TRUE si determina la ricomparsa
del controllo.
Potete leggere lo stato corrente di una proprietà cliccando con il tasto
destro del mouse sul terminale Nodo Proprietà e selezionando Change To
Read. Quando viene chiamato il Nodo Proprietà, porrà in uscita un
booleano TRUE se il controllo è visibile o un booleano FALSE se è
invisibile.
Dal terminale sul Nodo Proprietà, potete selezionare le proprietà
cliccando sul nodo con lo strumento Modifica, mostrato a sinistra, e
selezionando la proprietà desiderata dal menu rapido.
Potete leggere o impostare più di una proprietà sullo stesso nodo
allargando il Nodo Proprietà. Utilizzando lo strumento Posiziona,
mostrato a sinistra, cliccate sull’angolo inferiore del Nodo Proprietà e
trascinate l’angolo verso il basso per allargare il nodo. Quando allargate il
nodo, aggiungete terminali. Potete quindi associare ogni terminale del
Nodo Proprietà con una proprietà dal suo menu rapido.
Alcune proprietà sono cluster. Questi cluster contengono diverse proprietà
che voi potete separare utilizzando la funzione Unbundle che si trova
nella palette Functions»Cluster. Per scrivere su queste proprietà è
necessaria la funzione Bundle:
Lettura di proprietà raggruppate
Scrittura di proprietà raggruppate
2-25
Lezione 2
Per accedere alle proprietà raggruppate, selezionate l’opzione All
Elements dal menu rapido della proprietà. Per esempio, potete accedere a
tutti gli elementi nella proprietà Position selezionando Position»All
Elements o potete accedere ad un singolo elemento da quel gruppo.
Ordine di esecuzione di Nodi Proprietà
I terminali del Nodo Proprietà vengono eseguiti dall’alto verso il basso.
Nell’esempio seguente, nel Nodo Proprietà di un grafico di forme d’onda,
il grafico viene dapprima reso visibile. Quindi Plot 0 viene impostato
come traccia attiva, il suo colore è rosso e il nome della traccia nella
legenda viene aggiornato. Infine, Plot 1 viene impostato come traccia
attiva, il suo colore è il verde e il nome della traccia nella legenda viene
cambiato.
Ordine di
esecuzione
Utilizzo della finestra Context Help
Utilizzate la finestra di LabVIEW Context Help e Help»Contents and
Index per trovare descrizioni, tipi di dati e valori accettabili per i Nodi
Proprietà. Con la finestra di Context Help attiva, passate il cursore sopra i
terminali del Nodo Proprietà per visualizzare informazioni. L’esempio
seguente mostra l’help per una singola proprietà ed un cluster con diverse
proprietà.
2-26
Lezione 2
Proprietà comuni
Ci sono molte proprietà disponibili in LabVIEW per i vari oggetti del
pannello frontale. Questa sezione descrive le proprietà Visible, Disable,
Key Focus, Blink, Position, Bounds e Value, che sono comuni a tutti gli
oggetti del pannello frontale. Vengono inoltre introdotti alcuni Nodi
Proprietà per alcuni tipi particolari di controlli e indicatori.
Proprietà Visible
La proprietà Visible, mostrata a sinistra, imposta o legge la visibilità di un
oggetto del pannello frontale. L’oggetto associato è visibile quando è
TRUE, nascosto quando è FALSE.
Esempio di collegamentoImpostate un controllo digitale su uno stato
invisibile. Un booleano TRUE rende visibile il controllo, come mostrato.
Schema a blocchi
Pannello frontale
Visible = TRUE
Visible = FALSE
Proprietà Disabled
La proprietà Disabled, mostrata a sinistra, imposta o legge lo stato di
accesso dell’utente ad un oggetto. Un valore di 0 abilita un oggetto
affinché l’utente possa lavorarci. Un valore di 1 disabilita l’oggetto,
impedendone il funzionamento. Un valore di 2 disabilita e fa diventare
grigio l’oggetto.
Esempio di collegamentoDisabilitate l’accesso dell’utente al controllo
digitale. Il controllo non cambia aspetto quando viene disabilitato.
2-27
Lezione 2
Esempio di collegamentoDisabilitate l’accesso dell’utente al controllo e
fatelo diventare grigio
Proprietà Key Focus
La proprietà Key Focus, mostrata a sinistra, imposta o legge il key focus
di un oggetto del pannello frontale. Quando è TRUE, il cursore è attivo
nell’oggetto associato. Nella maggior parte dei controlli, potete inserire
valori nel controllo digitandoli con la tastiera. Potete anche impostare il
key focus sul pannello frontale premendo il tasto <Tab> mentre si è in
esecuzione o premendo il tasto associato al controllo (assegnato
utilizzando l’opzione Key Navigation).
Esempio di collegamentoAttivate sul controllo digitale il key focus.
Potete allora inserire un nuovo valore nel controllo senza selezionarlo con
il cursore.
Proprietà Blinking
La proprietà Blinking, mostrata a sinistra, legge o imposta lo stato di
lampeggiamento di un oggetto. Impostando questa proprietà su TRUE, un
oggetto inizierà a lampeggiare. Potete impostare la frequenza di
lampeggiamento e i colori selezionando Tools»Options e quindi Front
Panel e Colors dal menu a tendina. Quando questa proprietà è impostata
su FALSE, l’oggetto smette di lampeggiare.
Esempio di collegamentoAbilitate il lampeggiamento di un controllo
digitale.
1
1 Schema a blocchi
2
2 Pannello frontale:
Normale
3
3 Pannello frontale:
lampeggiante
Proprietà Value
La proprietà Value, mostrata a sinistra, legge o imposta il valore corrente
di un oggetto. Quando impostate la proprietà Value in scrittura, essa
scrive il valore collegato all’oggetto sia nel caso di un controllo che di un
indicatore.
2-28
Lezione 2
Quando impostate la proprietà Value in lettura, essa legge il valore
collegato all’oggetto sia nel caso di un controllo che di un indicatore.
L’esempio seguente mostra un valore di pi greco scritto su un controllo
numerico e il valore all’interno di una stringa scritto su un’altra stringa.
Proprietà Position
La proprietà Position, mostrata a sinistra, imposta o legge la posizione
dell’angolo superiore sinistro di un oggetto sul pannello frontale. La
posizione è determinata in unità di pixel relative all’angolo superiore
sinistro del panello frontale. Questa proprietà consiste in un cluster di due
interi di tipo long senza segno. Il primo elemento nel cluster (Left) è la
posizione del bordo sinistro del controllo relativamente al bordo sinistro
del pannello frontale, e il secondo elemento nel cluster (Top) è la
posizione del bordo superiore del controllo relativamente al bordo
superiore del pannello frontale.
Esempio di collegamentoFate cambiare posizione al controllo digitale
sul pannello frontale.
2-29
Lezione 2
Proprietà Bounds
La proprietà Bounds, mostrata a sinistra, legge i limiti di un oggetto sul
pannello frontale in unità di pixel. Il valore include il controllo e tutte le
sue parti, inclusa l’etichetta, la legenda, la scala e così via. Questa
proprietà consiste in un cluster di due interi di tipo long senza segno. Il
primo elemento nel cluster (Width) è la larghezza dell’oggetto in pixel, e
il secondo (Height) l’altezza dell’oggetto in pixel. Questa è una proprietà
di sola lettura. Essa non ridimensiona un controllo o un indicatore del
pannello frontale. Alcuni oggetti hanno altre proprietà per il
ridimensionamento, come la proprietà Plot Area Size per i grafici.
Esempio di collegamentoDeterminate i limiti di un controllo digitale.
Proprietà Numeric: Format and Precision
La proprietà Format and Precision, mostrata a sinistra, imposta o legge il
formato (tipo di notazione) e precisione (numero di cifre visualizzate
dopo il punto decimale) degli oggetti numerici del pannello frontale.
L’ingresso è un cluster di due interi di tipo long senza segno. Il primo
elemento imposta il formato e il secondo imposta la precisione. La
proprietà Format può assumere uno dei seguenti valori interi:
0 - Notazione decimale
1 - Notazione scientifica
2 - Notazione ingegneristica
3 - Notazione binaria
4 - Notazione ottale
5 - Notazione esadecimale
6 - Notazione tempo relativo
Esempio di collegamentoImpostate il formato del controllo digitale
sulla notazione scientifica e 4 cifre di precisione.
2-30
Lezione 2
Proprietà booleana: Strings [4]
La proprietà Strings [4], mostrata a sinistra, imposta o legge le etichette
su un controllo booleano. L’ingresso è una matrice di quattro stringhe che
corrispondono agli stati False, True, True Tracking e False Tracking.
True and False: gli stati On e Off dell’oggetto booleano.
True e False Tracking: livelli di transizione temporanea tra stati
booleani. True Tracking è lo stato di transizione quando l’oggetto
booleano passa da True a False. Il tracking si applica solo ad oggetti
booleani aventi le azioni meccaniche Switch When Released e Latch
When Released. Queste azioni meccaniche sono in uno stato
transizionale fino a quando rilasciate il mouse. Le stringhe di testo True
Tracking e False Tracking vengono visualizzate durante la
transizione.
Esempio di collegamentoImpostate le stringhe del display per il
controllo Switch sulle scelte Stop, Run, Stop? E Run?.
Proprietà String: Display Style
La proprietà Display Style, mostrata a sinistra, imposta o legge il display
di un controllo o indicatore di stringa. Un intero di tipo long senza segno
determina il modo del display.
0 - Normal Display
1 - ‘\’ Codes Display
2 - Password Display
3 - Hex Display
2-31
Lezione 2
Esempio di collegamentoMostrate il testo nel controllo di stringa negli
altri modi.
2-32
Lezione 2
Esercitazione 2-5 VI Property Node Exercise
Obiettivo:
Realizzare un VI che utilizzi i Nodi Proprietà per modificare le caratteristiche
comuni degli oggetti del pannello frontale.
Realizzerete un VI che da programma modifica le proprietà position,
disabled e color degli oggetti del pannello frontale.
Pannello Frontale
1. Aprite un nuovo VI e realizzate il pannello frontale mostrato sopra.
Schema a blocchi
2-33
Lezione 2
2. Aprite e realizzate lo schema a blocchi mostrato precedentemente
utilizzando i componenti seguenti.
a. Inserite il ciclo While che si trova nella palette
Functions»Structures. Questo determina l’esecuzione del VI fino
a quando l’utente preme il pulsante Stop. Cliccate con il tasto
destro del mouse sul terminale condizionale e selezionate Stop If
True.
b. Inserite la funzione Wait Until Next ms Multiple che si trova nella
palette Functions»Time & Dialog. Questa funzione determina
l’esecuzione del ciclo While una volta al secondo. Create la
costante cliccando con il tasto destro del mouse sul terminale
d’ingresso e selezionando Create»Constant.
c. Inserite la funzione Random Number (0-1) che si trova nella
palette Functions»Numeric. Essa crea un numero casuale tra zero
e uno.
d. Inserite la funzione Multiply che si trova nella palette
Functions»Numeric. Essa moltiplica due numeri e viene usata
qui per riportare il numero casuale tra 0 e 10.
e. Inserite la funzione Greater? che si trova nella palette
Functions»Comparison. Essa confronta due valori, in questo
caso il valore casuale e quello limite e fornisce True se il valore
casuale è più grande di quello limite. Altrimenti fornisce False.
f. Inserite la funzione Select che si trova nella palette
Functions»Comparison. Utilizzerete due di queste funzioni.
Questa funzione prende un ingresso booleano ed emette il valore
superiore se il booleano è True e il valore inferiore se il booleano
è False.
g. Inserite la costante Color Box che si trova nella palette
Functions»Numeric»Additional Numeric Constants. Questa
costante viene utilizzata per colorare gli oggetti del pannello
attraverso il Nodo Proprietà. Avete bisogno di due di queste
costanti. Utilizzate lo strumento modifica per selezionare il colore
e rendere una rossa e l’altra blu.
h. Create il Nodo Proprietà per il Tank. Per creare questo nodo,
cliccate con il tasto destro del mouse sul terminale Tank e
dal menu rapido.
selezionate Create»Property Node
Ridimensionate questo nodo trascinando l’angolo con lo
strumento Posiziona per mostrare tre terminali. Selezionate le
proprietà indicate cliccando con il tasto destro del mouse su ogni
terminale e selezionando la voce dal menu Properties. Cliccate
con il tasto destro su quel nodo e selezionate Change All To
Write dal menu.
i. Inserite la funzione Bundle che si trova nella palette
Functions»Cluster. Questa funzione unisce le posizioni left e top
nella proprietà Position del serbatoio.
2-34
Lezione 2
j. Create il Nodo Proprietà per il booleano. Per creare questo nodo,
cliccate con il tasto destro del mouse sul terminale Boolean e
selezionate Create»Property Node dal menu rapido. Selezionate
la proprietà Disabled cliccando con il tasto destro del mouse sul
terminale e selezionandola dal menu Properties. Cliccate con il
tasto destro su quel nodo e selezionate Change To Write dal
menu rapido.
k. Create il Nodo Proprietà per la stringa. Per creare questo nodo,
cliccate con il tasto destro del mouse sul terminale String e
menu rapido.
l. Create il Nodo Proprietà per il limite. Per creare questo nodo,
cliccate con il tasto destro del mouse sul terminale Limit e
menu rapido.
m. Create il Nodo Proprietà per la posizione verticale del serbatoio.
Per creare questo nodo, cliccate con il tasto destro del mouse sul
terminale Tank Vertical Position e selezionate Create»Property
Node dal menu rapido. Selezionate la proprietà Disabled
cliccando con il tasto destro del mouse sul terminale e
selezionandola dal menu Properties. Cliccate con il tasto destro
su quel nodo e selezionate Change To Write dal menu rapido.
n. Create il Nodo Proprietà per la posizione orizzontale del serbatoio.
Per creare questo nodo, cliccate con il tasto destro del mouse sul
terminale
Tank
Horizontal
Position
e
selezionate
Create»Property Node dal menu rapido. Selezionate la proprietà
Disabled cliccando con il tasto destro del mouse sul terminale e
selezionandola dal menu Properties. Cliccate con il tasto destro
su quel nodo e selezionate Change To Write dal menu rapido
3. Salvate questo VI come Property Node Exercise.vi.
4. Tornate al pannello frontale ed avviate il VI. Dovrebbero succedere
molte cose.
5. Innanzitutto quando nuovi numeri casuali vengono generati e scritti
sul serbatoio, il colore di riempimento è rosso se il numero casuale è
più grande del valore limite e diventa blu se è inferiore.
6. I due cursori cambiano la posizione del serbatoio sul pannello.
Spostateli e vedete come si sposta il serbatoio.
2-35
Lezione 2
7. L’interruttore Disable controlla se potete modificare i valori. Portate
l’interruttore Disable su True e tutti gli oggetti del pannello eccetto
Disable e il pulsante Stop diventano grigi e non potete modificarne i
valori.
2-36
Lezione 2
D. Proprietà dei grafici
I Nodi Proprietà aumentano notevolmente la flessibilità da programma dei
grafici. Potete controllare la maggior parte delle caratteristiche dei grafici
con i Nodi Proprietà. Alcune di queste proprietà sono il colore della
traccia, informazioni sulle scale X e Y, la visibilità delle legende e della
palette, le dimensioni dell’area di rappresentazione e i cursori.
Legenda della
rappresentazione
Palette del grafico
Legenda delle scale
Legende dei cursori
Potete avere molte opzioni di scala per i grafici. Con i Nodi Proprietà,
potete impostare o leggere le informazioni di scala per le X e le Y. Per
ogni asse il VI può leggere o impostare i valori minimo, massimo e di
incremento.
Potete anche utilizzare i Nodi Proprietà per impostare o leggere da
programma i colori della traccia e dello sfondo e i colori della griglia X e
Y. Potete utilizzare questa possibilità per impostare i colori della traccia e
dello sfondo in funzione delle condizioni del programma come ad
esempio valori out of range o di errore.
Per cambiare le dimensioni di un grafico, utilizzate la proprietà Plot
Area»Size. Se volete che una traccia particolare appaia in una piccola
finestra durante un’applicazione ma appaia più grande più avanti, potete
utilizzare questa proprietà insieme con altre proprietà che modificano le
dimensioni di un pannello di VI.
Utilizzando i Nodi Proprietà, avete accesso alle informazioni che i cursori
forniscono sui grafici. Utilizzate i cursori per spostare un selettore di
grafico sulla traccia. Un cursore può essere bloccato sulla traccia o può
muoversi sulla superficie di rappresentazione. I valori provenienti da
ciascun cursore vengono forniti su un display opzionale del pannello
frontale.
2-37
Lezione 2
I Nodi Proprietà offrono un modo per impostare o leggere da programma
la posizione del cursore sul grafico, consentendo all’utente un accesso dai
cursori del VI.
Proprietà X (o Y) Range
La proprietà X (o Y) Range, mostrata a sinistra, imposta o legge
l’intervallo e l’incremento degli assi del grafico. La proprietà accetta un
cluster di cinque valori numerici, in funzione del tipo di grafico: valore
minimo dell’asse X, valore massimo dell’asse X, incrementi maggiori e
minori tra i marcatori dell’asse X e il valore di inizio della scala. Per
creare questa proprietà, selezionate X Scale»Range»All Elements
dall’elenco delle proprietà. Se non c’è abbastanza spazio per visualizzare
tutti i valori incrementali che avete specificato, LabVIEW selezionerà un
valore incrementale alternativo.
Esempio di collegamentoImpostate l’intervallo dell’asse X tra 0 e 50
con l’incremento maggiore dell’asse di 10, quello minimo di 1 e un valore
iniziale di zero.
Proprietà Active Plot e Plot Color
Le proprietà mostrate a sinistra impostano o leggono la traccia attiva (la
traccia per cui le proprietà relative vengono impostate o lette) e il colore
della traccia attiva. Active Plot è un intero corrispondente alla traccia
desiderata e Plot Color è un intero che rappresenta un colore. La proprietà
Plot Color si trova in Plot»Plot Color dall’elenco delle proprietà.
Esempio di collegamentoImpostate il colore della traccia attiva
utilizzando una costante Color Box (impostata sul rosso in questo
esempio). Quando selezionate la traccia attiva, il terminale Active Plot
deve precedere (appare prima) il terminale Plot Color.
2-38
Lezione 2
Proprietà Active Cursor, Cursor Position e Cursor Index
Le proprietà mostrate a sinistra impostano o leggono il cursore attivo, la
sua posizione nel grafico e l’indice (posizione dell’asse X) nella traccia in
cui risiede il cursore. La proprietà Active Cursor accetta un intero
corrispondente al cursore desiderato quando c’è più di un cursore sul
grafico.
Cursor Position consiste in un cluster di due numeri a virgola mobile che
rappresentano le posizioni X e Y sulla traccia. Per creare la proprietà
Cursor Position, selezionate Cursor»Cursor Position»All Elements.
Cursor Index accetta un intero corrispondente ad un elemento nella
matrice (traccia). Per accedere alla proprietà Cursor Index, selezionate
Cursor»Cursor Index.
Esempio di collegamentoInserite un cursore nella posizione (55.5,
34.8). Quando selezionate il cursore, il terminale Active Cursor deve
precedere il terminale Cursor Position. Siccome il nodo viene eseguito
dall’alto verso il basso, potete impostare un’altra posizione di cursore
aggiungendo un altro insieme di proprietà Active Cursor e Cursor
Position a questo nodo.
Plot Area»Size Property
Per leggere o modificare le dimensioni di un grafico, inviate nuovi valori
di Width e Height alla proprietà Plot Area Size. Width e Height sono
espressi in pixel.
Esempio di collegamentoRidimensionate un grafico per aumentare del
25% l’altezza e la larghezza.
Dopo l’esecuzione
Prima dell’esecuzione
2-39
Lezione 2
Esercitazione 2-6 VI Temperature Limit
Obiettivo:
Creare un VI che utilizzi i Nodi Proprietà per cancellare un grafico e avvisare
l’utente se i dati superano un limite.
Completerete la realizzazione di un VI che utilizza i Nodi Proprietà per
eseguire le azioni seguenti:
y
Impostare il valore delta X del grafico sulla frequenza di
campionamento in secondi.
y
Cancellare il grafico affinché inizialmente non contenga dati.
y
Modificare il colore di una traccia se i dati superano un certo valore.
y
Far lampeggiare un indicatore di allarme se i dati superano un certo
valore.
Pannello frontale
1. Aprite il VI Temperature Limit che si trova nella directory
c:\exercises\LV Basics 2. Il pannello frontale e parte dello
schema a blocchi sono già stati realizzati.
2-40
Lezione 2
Schema a blocchi
2. Modificate il VI in maniera tale che imposti il valore delta X sulla
frequenza di campionamento e cancelli il grafico della temperatura
prima dell’avvio. Mentre il VI acquisisce i dati, la linea “High Limit”
dovrebbe diventare rossa quando la temperatura supera il valore limite
e il LED Out of Range dovrebbe lampeggiare.
a. Nella struttura Sequence, create un Nodo Proprietà per il grafico
Temperature che ha due terminali. Un terminale dovrebbe essere
la
proprietà
multiplier,
X
Scale»Offset
and
Multiplier»Multiplier e l’altro terminale dovrebbe essere la
proprietà History Data. Per cancellare un grafico dallo schema a
blocchi, inviate una matrice di dati vuota alla proprietà History
Data. Per fare questo, cliccate con il tasto destro del mouse sulla
proprietà e selezionate Create»Constant. Assicuratevi che la
costante della matrice sia vuota.
b. Nella struttura Case all’interno del ciclo While, create un Nodo
Proprietà per il grafico di temperatura che abbia due terminali. Il
terminale superiore dovrebbe essere la proprietà Active Plot e
quello inferiore la proprietà Plot Color, Plot»Plot Color. Avete
bisogno di queste proprietà in entrambe le condizioni della
struttura Case. La traccia High Limit è plot 1, quindi impostate la
proprietà Active Plot su uno prima di impostare la proprietà Plot
Color. Se i dati superano High Limit, impostate il colore su rosso.
Altrimenti su giallo. Utilizzate una costante Color Box per inviare
il valore del colore su questa proprietà.
c. Cliccate con il tasto destro sull’indicatore Out of Range per creare
un Nodo Proprietà Blink. L’indicatore dovrebbe lampeggiare
quando la temperatura supera High Limit.
2-41
Lezione 2
4. Avviate il VI per avere conferma che funziona correttamente.
2-42
Lezione 2
Esercitazione 2-7 VI Analyze & Present Data
Obiettivo: Utilizzare i Nodi Proprietà con i cursori dei grafici.
Creerete un VI che utilizza i cursori del grafico per selezionare un
sottoinsieme di dati per l’analisi. In un esercizio successivo realizzerete
un subVI che salva i risultati su disco. Utilizzerete anche la proprietà
Value per inizializzare un indicatore.
Pannello frontale
1. Aprite il VI Analyze & Present Data che si trova nella directory
c:\exercises\LV Basics 2. Il pannello frontale di questo VI è
già realizzato. Voi completerete lo schema a blocchi.
Utilizzerete i due cursori indicati per selezionare un sottoinsieme di
dati da analizzare. Un cursore può muoversi liberamente o può essere
bloccato sulla traccia. Potete controllare questa azione utilizzando il
pulsante Lock Control che si trova sul lato destro del display del
cursore.
Movimento vincolato sui punti della traccia.
Movimento libero nell’area di rappresentazione.
In questa esercitazione, utilizzate i cursori vincolati sulla traccia.
Utilizzate i Nodi Proprietà per impostare inizialmente gli indici del
cursore all’inizio e alla fine della matrice di dati quando si avvia il VI.
Quando un utente clicca sul pulsante Analyze Selected Subset,
leggete la posizione di ogni cursore e utilizzate questa informazione
per trovare i valori DC, RMS, di frequenza, di ampiezza e di fase del
sottoinsieme di dati.
2-43
Lezione 2
Schema a blocchi
2. Completate lo schema a blocchi precedente.
Per creare i Nodi Proprietà, cliccate con il tasto destro del mouse sui
terminali Data e Analysis Result e selezionate Create»Property
Node dal menu rapido. Utilizzate lo strumento Posiziona per
ridimensionare il Nodo Proprietà affinché abbia un numero sufficiente
di terminali. Potete scegliere la proprietà cliccando con il tasto destro
del mouse sul nodo creato per ultimo e selezionando la proprietà dal
menu Proprietà. La proprietà Cursor Index si trova in
Cursor»Cursor Index.
Inserite la funzione Array Subset che si trova nella palette
Functions»Array. In questa esercitazione, questa funzione estrae
l’insieme di dati da analizzare.
Inserite la funzione Max & Min che si trova nella palette
Functions»Comparison. In questa esercitazione, questa funzione
determina il primo e l’ultimo indice per trovare il sottoinsieme di dati
da analizzare.
2-44
Lezione 2
Inserite il VI Basic Averaged DC-RMS che si trova nella palette
Functions»Analyze»Waveforms Measurements. Il VI prende la
forma d’onda d’ingresso e calcola i valori DC e RMS.
Inserite il VI Extract Single Tone Information che si trova nella
palette Functions»Analyze»Waveforms Measurements. Il VI
prende la forma d’onda d’ingresso, calcola la risposta in frequenza e
fornisce un singolo tono relativo all’ampiezza superiore. LabVIEW
fornisce l’ampiezza, la frequenza e i valori di fase di quel singolo
tono.
4. Avviate il VI. Spostate i cursori lungo il grafico per selezionare un
sottoinsieme di dati da analizzare e quindi cliccate sul pulsante
Analyze Selected Subset. Il risultato appare nel cluster Analysis
Results. Quando avete finito, cliccate sul pulsante Return.
2-45
Lezione 2
E. Riferimenti al controllo
Nelle due sezioni precedenti avete utilizzato i Nodi Proprietà per
modificare da programma le caratteristiche degli oggetti del pannello
frontale. Se state realizzando un grande VI che contiene molti Nodi
Proprietà o state utilizzando la stessa proprietà per diversi controlli e
indicatori, potreste anche pensare di inserire il Nodo Proprietà in un
subVI ed utilizzare i riferimenti al controllo per accedere a quel nodo. Un
Control Reference è un numero riferito ad un controllo specifico. Questa
sezione mostra solo un modo di utilizzo di questi oggetti versatili. Fate
riferimento ai manuali in LabVIEW per ulteriori informazioni sui
riferimenti al controllo.
Creazione di riferimenti al controllo
Create un riferimento al controllo per un oggetto del pannello frontale sia
cliccando con il tasto destro del mouse sull’oggetto sia sul terminale di
quell’oggetto e selezionando Create»Reference dal menu rapido.
Quindi collegate questo Control Reference ad un subVI che contiene i
Nodi Proprietà. Comunque, il subVI deve contenere un terminale che sia
Control Refnum. Create il Control Refnum selezionando
Controls»Refnum come segue.
Utilizzo dei riferimenti al controllo
Lo schema a blocchi seguente del subVI mostra come potete utilizzare un
riferimento al controllo per impostare molte delle proprietà di un oggetto
del pannello frontale.
I Nodi Proprietà utilizzano cluster di errore come molte delle funzioni di
I/O in LabVIEW e quindi potete utilizzare i sistemi di gestione dell’errore
per tenere traccia delle condizioni di errore. Il VI che chiama questo
subVI può utilizzarlo per modificare le proprietà di ogni tipo di controllo.
L’esempio seguente mostra il subVI che disabilita un numerico e imposta
un oggetto booleano come key focus.
2-46
Lezione 2
Più avanti realizzerete un subVI che modifica la proprietà disabled per
una matrice di controlli utilizzando i riferimenti al controllo.
2-47
Lezione 2
Esercitazione 2-8 VI Disable Controls e Control Refs Example
Obiettivo:
Realizzare un VI che utilizzi i riferimenti al controllo per accedere ai Nodi
Proprietà da un sub VI.
Inizierete con il VI Property Node Exercise che avete realizzato
nell’esercitazione 2-5. Costruirete un subVI che accede ad una matrice di
riferimenti di controllo ed assegna la proprietà Disabled. Quindi
modificherete il VI Property Node Exercise per utilizzare il subVI
piuttosto che i Nodi Proprietà originali.
Pannello frontale
1. Aprite un nuovo VI e realizzate il pannello frontale precedente.
Schema a blocchi
2. Aprite e costruite lo schema a blocchi precedente utilizzando i
componenti seguenti:
a. Inserite un ciclo For che si trova nella palette
Functions»Structures. Il ciclo For viene utilizzato per
l’autoindicizzazione attraverso la matrice di refnum di controllo in
maniera tale che ogni refnum e proprietà sia gestito separatamente.
b. Inserite un Nodo Proprietà che si trova nella palette
Functions»Application Control. Utilizzerete questo Nodo
Proprietà come controllo generico. Quando collegate il Refnum
Array al terminale di ingresso di refnum, la funzione cambia
leggermente come si vede dall’esempio seguente:
2-48
Lezione 2
c. Cliccate con il tasto destro del mouse sul terminale Property e
selezionate Properties»Disabled. Cliccate nuovamente con il
tasto destro sul terminale e selezionate Change To Write.
d. Inserite la funzione Select che si trova nella palette
Functions»Comparison. Questa funzione accetta un ingresso
booleano ed emette un valore superiore di 0 (enabled) se il
booleano è True e un valore inferiore di 2 (disabled) se il booleano
è False.
e. Inserite una costante numerica che si trova nella palette
Functions»Numeric. Avete bisogno di due di queste costanti una
con il valore di 0 e l’altra di 2 per la funzione Select.
3. Salvate il VI come Disabled Controls.vi.
4. Tornate al pannello frontale. Ora realizzerete per il VI un’icona e il
riquadro connettori come mostrato di seguito.
5. Salvate e chiudete questo VI. Ora realizzerete un VI chiamante per
questo subVI.
6. Aprite il VI Property Node Exercise che avete realizzato
nell’esercitazione 2-5. Non modificate il pannello frontale.
7. Selezionate File»Save As e rinominate questo VI Control Refs
Exercise.vi.
2-49
Lezione 2
8. Aprite lo schema a blocchi e modificatelo come indicato.
a. Create i riferimenti di controllo per i sei controlli cliccando con il
tasto destro del mouse sui loro terminali e selezionando
Create»Reference dal menu rapido.
b. Utilizzate la funzione Build Array che si trova nella palette
Functions»Array per combinare tutti i riferimenti di controllo in
una matrice per passarla al subVI Disable Controls che si trova
nella palette Functions»Select A VI.
c. Avete bisogno anche della funzione Not che si trova nella palette
Functions»Boolean per invertire il valore all’ingresso del subVI.
9. Salvate il VI.
10. Tornate al pannello frontale ed avviate il VI. Notate che quando
impostate il selettore su True, tutti i controlli diventano grigi come
prima.
2-50
Lezione 2
F. Menu run-time di LabVIEW (opzionale)
Potete personalizzare la barra dei menu per ogni VI che realizzate in
modo tale da avere un menu a tendina personalizzato mentre un VI è in
esecuzione. Ci sono due parti che consentono la personalizzazione di
menula creazione di menu e la gestione di menu.
Potete realizzare menu personalizzati in due modistaticamente durante
la fase di creazione o dinamicamente durante l’esecuzione. Potete
memorizzare staticamente un modello di menu in un file chiamato runtime menu (RTM). Potete associare un file RTM ad un VI durante la fase
di creazione. Quando un VI è in esecuzione, esso carica il menu dal file
RTM associato. Potete anche inserire, cancellare e modificare da
programma le voci di menu in fase di esecuzione dallo schema a blocchi
utilizzando diverse funzioni di LabVIEW. Inoltre potete determinare da
programma se un’opzione della barra dei menu è selezionata e da
programma gestire la selezione. Con queste caratteristiche, potete
personalizzare un menu a tendina per la vostra applicazione.
Menu statici
I menu statici sono memorizzati in file RTM. Potete abilitare, creare o
modificare un file RTM per un VI selezionando Edit»Run-Time Menu.
Compare la finestra di dialogo Menu Editor.
Sul lato sinistro di questa finestra di dialogo compare l’organizzazione
generale delle voci di menu. Le voci di menu sono classificate in tre tipi:
User Item, Application Item o Separator.
Un User Item può essere gestito da programma nello schema a blocchi.
Essa possiede un name, che è la stringa che compare nel menu attuale, e
un tag, che è un identificatore di stringa (non tiene conto di maiuscole o
minuscole). Un tag identifica uno User Item nello schema a blocchi.
2-51
Lezione 2
Per semplicità, in fase di creazione, quando inserite il nome, viene copiato
nel tag. Comunque, potete sempre modificare il tag per renderlo
differente dal nome. Perché una voce di menu sia valida, il suo tag non
dovrebbe essere vuoto. Le voci di menu non valide appaiono come ???.
Un Application Item viene fornito da LabVIEW. Queste voci fanno parte
del menu di default di LabVIEW. Per selezionare una voce particolare di
LabVIEW, cliccate sul pulsante a freccia vicino a Item Name. Potete
aggiungere voci singole o interi sottomenu utilizzando questo processo.
Gli Application Items vengono gestiti in modo implicito da LabVIEW.
Questi tag di voci non compaiono nello schema a blocchi. Non potete
alterare il nome, il tag o altre proprietà di un Application Item. LabVIEW
riserva dei tag che iniziano con APP_ per gli Application Item.
Un Separator inserisce una linea di separazione nel menu. Non potete
impostare tutte le proprietà per una voce Separator.
Il Menu Editor garantisce che un tag sia unico per una data gerarchia di
menu aggiungendo dei numeri, se necessario. Uno User Item può essere
abilitato/disabilitato o verificato/non verificato impostando le proprietà
relative. Potete impostare una combinazione rapida di tasti (acceleratore)
per uno User Item, selezionando un’opportuna combinazione di tasti.
Il Menu Editor vi consente di inserire, cancellare o riordinare delle voci
di menu nella gerarchia dei menu. Cliccando sul pulsante + si aggiunge
una nuova voce di menu. Potete anche modificare il tipo di voce di menu
selezionandola da Item Type. Inoltre potete riordinare le voci di menu e
creare sottomenu utilizzando i pulsanti a freccia. Infine, cliccando sul
pulsante Delete Item si cancellano le voci di menu selezionate.
La parte di anteprima del Menu Editor fornisce una vista aggiornata del
menu run-time. Sul menu a tendina Menu Editor, i pulsanti Open, New,
Save e Save As vi consentono di caricare e salvare file RTM. Una volta
che avete chiuso il Menu Editor, avete la possibilità di aggiornare i menu
run-time dei VI con il menu che avete creato.
Menu dinamici
Mentre un VI è in esecuzione, potete modificare le voci della barra dei
menu del VI utilizzando le funzioni di gestione dei menu descritte nella
sezione seguente. Tutte queste
funzioni si trovano
in
Functions»Application Control»Menu. Queste funzioni operano su un
refnum del menu ricavato utilizzando la funzione Current VI’s Menu.
2-52
Lezione 2
Insert Menu Items
Inserisce una voce di menu (o una matrice di voci di menu) individuata da
item names o item tags in un menu (barra dei menu o sottomenu). La
posizione della voce viene specificata sia attraverso il parametro after
item che attraverso una combinazione della coppia menu tag e after
item.
Delete Menu Items
Cancella una voce di menu (o una matrice di voci di menu) individuata da
items in un menu individuato da menu tag (dalla barra dei menu, se non
viene specificato menu tag). Items può essere un tag, una matrice di tag,
un numero di posizione o una matrice di numeri di posizione.
Get Menu Item Info
Fornisce le proprietà della voce di menu definita attraverso item tag (o
menubar se item tag non è specificato). Le proprietà comprendono item
name, enabled, checked e shortcut. Se la voce ha un sottomenu
collegato, i suoi tag vengono forniti in submenu tags.
2-53
Lezione 2
Set Menu Item Info
Imposta le proprietà della voce di menu individuata da item tag. Le
proprietà della voce comprendono item name, enabled, checked e
shortcut. Le proprietà non collegate rimangono invariate.
Get Menu Shortcut Info
Fornisce la voce di menu che è accessibile tramite una certa
combinazione rapida.
Gestione di Menu Selection
Le funzioni Menu Selection gestiscono le vostre selezioni di menu. I
menu potrebbero essere stati costruiti staticamente in VI Properties o
dinamicamente durante l’esecuzione. Per impostare lo schema a blocchi
affinché gestisca le selezioni di menu, prendete il controllo sul processo
di selezione dei menu con la funzione Get Menu Selection. Mentre il VI
controlla la selezione dei menu, aspetta una voce di menu selezionata
utilizzando la stessa funzione, Get Menu Selection. Tutte le voci di menu
in LabVIEW sono gestite in maniera implicita da LabVIEWsolo le
selezioni del menu utente vengono ottenute attraverso Get Menu
Selection.
Una volta che avete selezionato una voce, non potete selezionarne
un’altra finché la funzione Get Menu Selection non ha letto la prima voce.
In tali condizioni, Get Menu Selection viene chiamata in modalità blocco
menu, in cui il tracciamento del menu viene bloccato dopo che è stata
letta una selezione. Il menu viene abilitato dopo che avete processato la
selezione utilizzando la funzione Enable Menu Tracking.
Current VI’s Menubar
Fornisce il refnum menubar del VI corrente. Questa funzione dev’essere
eseguita prima che siano richiamate altre funzioni di gestione dei menu.
2-54
Lezione 2
Get Menu Selection
Fornisce item tag dell’ultima voce di menu selezionata, opzionalmente
aspettando un periodo di tempo specificato da timeout. Item path è una
stringa che descrive la posizione della voce nella gerarchia dei menu. La
selezione dei menu viene bloccata dopo che una voce è stata letta se
block menu viene impostato su TRUE.
Enable Menu Tracking
Questa funzione abilita o disabilita il tracciamento dei menu. Una volta
che un menu è stato bloccato utilizzando la funzione Get Menu Selection,
dev’essere eseguito Enable Menu Tracking per riabilitare il menu a
tendina.
2-55
Lezione 2
Esercitazione 2-9 VI Pull-down Menu (Opzionale)
Obiettivo: Realizzare un VI utilizzando un menu run-time personalizzato.
Questo VI illustra come modificare e controllare da programma un menu
personalizzato in un’applicazione in LabVIEW.
1. Aprite il VI Pull-down Menu che si trova in c:\exercises\LV
Basics 2. Il pannello frontale e lo schema a blocchi sono
parzialmente completi. Realizzerete un menu run-time personalizzato
per questo VI utilizzando il Menu Editor e completerete lo schema a
blocchi in maniera tale da poter accedere a questo menu.
2. Selezionate Edit»Run-Time Menu per visualizzare la finestra di
dialogo Menu Editor.
Il menu run-time corrente per l’applicazione è il menu di default di
LabVIEW. Nei prossimi passi sostituirete questo menu con un elenco
personalizzato di selezioni.
3. Modificate il controllo superiore di tipo ring in Menu Editor da
Default a Custom. Il menu elencato nella parte sinistra della finestra
di dialogo dovrebbe essere sostituito da ??? che rappresenta una
singola voce senza nome.
4. Nel controllo di tipo ring Item Type, selezionate Application
Item»Operate»Entire Menu. Il menu di LabVIEW Operate
dovrebbe essere aggiunto al menu personalizzato. Le opzioni di
default in LabVIEW, così come le selezioni che avete creato, possono
essere aggiunte ad un menu personalizzato.
Provate un momento a navigare nel menu Operate dell’editor. Notate
che potete scegliere varie voci e aprire sottomenu utilizzando le icone
a triangolo. Quando selezionate singole voci del menu, il loro Item
Name e Item Tag appaiono nella finestra Item Properties dell’editor.
Quando avete finito, chiudete il menu Operate cliccando sul triangolo
accanto all’opzione Operate.
2-56
Lezione 2
Ora dovreste vedere solo la voce Operate nell’elenco dei menu.
5. Cliccate sul pulsante + nella barra degli strumenti di Menu Editor.
Nell’elenco compare una nuova voce senza nome, ???. Quando questa
voce è evidenziata, inserite Test nella proprietà Item Name. Questa
voce di menu ora ha un nome e un tag Test.
6. Cliccate nuovamente sul pulsante + per aggiungere un’altra voce sotto
quella di Test. Cliccate sul pulsante con la freccia a destra e questa
opzione senza nome diventa una sotto-voce del menu Test. Digitate
Test 1 per questa nuova voce.
7. Aggiungete due nuove sotto-voci a Test chiamandole Test 2 e Test
3. La finestra di dialogo Menu Editor dovrebbe avere ora l’aspetto
seguente:
Nell’area Preview del Menu Editor, potete vedere come sarà il menu
personalizzato durante l’esecuzione.
8. Selezionate File»Save dalla finestra di dialogo Menu Editor. Salvate
il menu run-time come Menu Exercise.rtm nella directory
c:\exercises\LV Basics 2. Chiudete la finestra di dialogo
Menu Editor. Quando LabVIEW vi chiede se volete adottare come
menu run-time Menu Exercise.rtm selezionate Yes. Avete così
configurato un menu a tendina personalizzato che sarà richiamato
mentre il VI è in esecuzione.
2-57
Lezione 2
Schema a blocchi
9. Modificate lo schema a blocchi del VI e completatelo come mostrato
precedentemente.
a. Inserite la funzione Current VI’s Menubar che si trova nella
palette Functions»Application Control»Menu. Questa funzione
fornisce un refnum per il menu a tendina del VI selezionato,
affinché possa essere utilizzato.
b. Inserite la funzione Get Menu Selection che si trova nella palette
Functions»Application Control»Menu. Ogni volta che viene
eseguito il ciclo While, la funzione Get Menu Selection fornisce
un Item Tag per ogni voce selezionata dall’utente nel menu runtime. Se nessuna voce è stata selezionata, Item Tag fornisce una
stringa vuota. Questa funzione è configurata in maniera tale che
ogni volta che legge la barra dei menu, impedisce all’utente di
effettuare un’altra scelta nel menu finché non viene eseguita
Enable Menu Tracking.
c. Inserite la funzione Enable Menu Tracking che si trova nella
palette Functions»Application Control»Menu. Questa funzione
abilita il menu a tendina, dopo che è stato disabilitato dalla
funzione Get Menu Selection.
10. Salvate il VI ed avviatelo. Quando il VI è in esecuzione, compare sul
pannello frontale il menu run-time personalizzato. Se selezionate una
delle voci presenti nel menu a tendina Test, il nome relativo compare
nell’indicatore Item Tag e compare una finestra di dialogo con il
nome del test all’interno. A questo punto, se provate a selezionare
un’altra voce dal menu a tendina, noterete che il menu è disabilitato
(ciò è causato dal parametro di blocco menu della funzione Get Menu
Selection). Se cliccate su OK nella finestra di dialogo, l’indicatore
Item Tag viene cancellato e il menu abilitato nuovamente dalla
funzione Enable Menu Tracking.
2-58
Lezione 2
Inoltre, notate che le voci del menu a tendina Operate non vengono
mostrate nella stringa Item Tagsolo le voci dell’utente vengono
fornite dall’opzione Get Menu Selection.
Per osservare il flusso del VI, potreste utilizzare l’esecuzione
evidenziata e passo-passo ed esaminare lo schema a blocchi. Cliccate
su Stop del pannello frontale del VI per arrestare l’esecuzione del
programma.
11. Utilizzando il Menu Editor, potete assegnare combinazioni rapide di
tasti alle voci che avete creato. Assegnate combinazioni rapide di tasti
alle opzioni di test secondo la tabella seguente:
Voce del Menu
Combinazione di
tasti per Windows
Combinazione di
tasti per
Macintosh
Test 1
<Ctrl-1>
<option-1>
Test 2
<Ctrl-2>
<option-2>
Test 3
<Ctrl-3>
<option-3>
Oltre alle impostazioni precedenti, su piattaforme Windows potete
assegnare alle voci di menu delle combinazioni con ALT. Ciò si
realizza facendo precedere da un underscore la lettera del nome di
menu scelta per la combinazione. Per esempio, per assegnare ALT-X
ad una voce di menu chiamata Execute, date all’opzione Execute un
Item Name di E_xecute. In questa esercitazione, assegnate ALT-T
all’opzione Test del menu.
12. Salvate il menu con le assegnazioni rapide di tasti ed avviate il VI.
Ora dovreste essere in grado di utilizzare tali combinazioni di tasti al
posto del cursore, per selezionare le diverse opzioni di test.
13. Chiudete il VI.
2-59
Lezione 2
G. Diagrammi d’intensità
I diagrammi d’intensità sono estremamente utili per la visualizzazione di
dati campionati. Per esempio, i diagrammi funzionano meglio per la
visualizzazione del terreno, in cui l’ampiezza rappresenta l’altitudine.
Inoltre, potete rappresentare dati di temperatura con i diagrammi
d’intensità. Come per i grafici tipo chart e tipo graph, il diagramma
d’intensità tipo chart rappresenta un display con scorrimento, mentre
quello tipo graph mostra un display fisso. Questi display accettano un
blocco dati e mappano ogni valore con un colore associato, con un
massimo di 256 colori disponibili.
Opzioni dei diagrammi d’intensità
I display dei diagrammi d’intensità tipo chart e tipo graph utilizzano
molte delle stesse opzioni delle loro controparti (grafici). Il pannello
frontale seguente mostra molte delle opzioni disponibili. I diagrammi
d’intensità forniscono anche delle opzioni non disponibili negli altri tipi
di grafici. Siccome visualizzano un terzo valore (colore), è disponibile
una scala dei colori. Potete utilizzare queste opzioni per impostare e
visualizzare lo schema di mappatura dei colori. Il grafico d’intensità
aggiunge anche un terzo valore, il valore z, al display del cursore.
Scala dei colori
Asse Z
Asse Y
Palette del grafico
Asse X
Legenda della scala
Legenda del cursore
Per modificare il colore associato ad uno specifico valore d’intensità,
cliccate con il tasto destro del mouse sul marcatore che compare accanto
alla scala dei colori e selezionate Marker Color dal menu. Compare la
palette dei colori, da cui potete selezionare un colore per associarlo con
un particolare valore numerico. Per aggiungere più valori alla scala dei
colori, cliccate con il tasto destro del mouse su di essa e selezionate Add
Marker. Potete trascinare nell’opportuna posizione della scala dei colori
il marcatore a bordo spesso che appare, o selezionare il marcatore con lo
strumento Testo e digitare la posizione del marcatore. Dopo che avete
inserito il marcatore in un’opportuna posizione nella scala, cliccate con il
tasto destro del mouse su di esso e selezionate Marker Color.
2-60
Lezione 2
Tipi di dati per i diagrammi di intensità
I diagrammi di intensità di tipo chart e di tipo graph accettano una matrice
bidimensionale di numeri. La posizione di ogni elemento nella matrice (i
suoi indici di riga e di colonna) corrisponde ai valori di X e di Y.
L’ampiezza di ogni elemento della matrice corrisponde ad un colore.
L’esempio seguente mostra una matrice 4 x 3 rappresentata su un
diagramma di intensità. Notate come Intensity Graph trasponga gli
elementi della matrice.
2-61
Lezione 2
Esercitazione 2-10 VI Intensity Graph Example
Obiettivo: Utilizzare un diagramma di intensità.
Utilizzerete un VI che visualizza dei dati di un’onda d’interferenza su un
diagramma di intensità. Utilizzerete il VI anche per rappresentare una
matrice bidimensionale di dati sul grafico.
1. Aprite ed avviate il VI Intensity Graph Example che si trova nella
directory c:\exercises\LV Basics 2. Di default il VI
rappresenta una forma d’onda d’interferenza. Un Nodo Proprietà sullo
schema a blocchi definisce l’intervallo dei colori utilizzati nel
diagramma d’intensità. Potete modificare l’intervallo dei colori
aprendo lo schema a blocchi e modificando la costante Color Array.
2. Cambiate la posizione del selettore Plot sul pannello frontale,
portandola su User Data ed inserite i valori tra 0.0 e 10.0 nei controlli
della matrice User Data. Avviate il VI. Notate come l’ampiezza di
ogni elemento sia riportata sul grafico d’intensità.
2-62
Lezione 2
3. Chiudete il VI. Non salvate i cambiamenti.
2-63
Lezione 2
y
Quando progettate interfacce utente, tenete presente: il numero di
oggetti nel pannello frontale, il colore, la spaziatura e l’allineamento
degli oggetti, il testo e i font utilizzati.
y
LabVIEW possiede gli strumenti seguenti per aiutarvi a creare
interfacce utente: finestre di controllo, controlli tab, decorazioni,
menu e ridimensionamento automatico degli oggetti del pannello
frontale.
y
I pulsanti Latched Boolean in un cluster possono essere utilizzati per
realizzare menu per le applicazioni.
y
Potete convertire un cluster che contiene componenti con lo stesso
tipo di dato in una matrice e quindi utilizzare le funzioni delle matrici
per processare i componenti del cluster. La funzione Cluster To Array
(palette Functions»Cluster o Functions»Array) converte un cluster
in una matrice monodimensionale.
y
I Nodi Proprietà sono strumenti potenti per l’ampliamento delle
potenzialità dell’interfaccia utente. Utilizzate i Nodi Proprietà per
modificare da programma l’aspetto e le caratteristiche funzionali dei
controlli e degli indicatori del pannello frontale.
y
Create Nodi Proprietà dal menu rapido Create di un controllo o di un
indicatore (o di un terminale di un controllo o di un indicatore sullo
schema a blocchi).
y
Potete creare diversi terminali Nodi Proprietà per un singolo oggetto
del pannello frontale, e così potete configurare le proprietà da diverse
posizioni nello schema a blocchi.
y
Potete impostare o leggere le proprietà come l’accesso dell’utente
(enable, disable, gray out), i colori, la visibilità, la posizione e il
lampeggiamento.
y
I Nodi Proprietà aumentano notevolmente la funzionalità dei grafici
cambiando le dimensioni delle rappresentazioni, regolando i valori
delle scale e azionando i cursori o leggendo da essi.
y
Utilizzate la finestra Context Help per saperne di più sulle singole
proprietà.
y
Potete utilizzare i riferimenti al controllo e i refnum per accedere ai
Nodi Proprietà all’interno dei subVI.
y
Per creare i vostri menu run-time, selezionate Edit»Run-Time Menu
per visualizzare la finestra di dialogo Menu Editor.
y
Potete creare e leggere da programma menu run-time con le funzioni
presenti nella palette Functions»Application Control»Menu.
y
Potete utilizzare diagrammi di intensità per rappresentare dati
tridimensionali. La terza dimensione è rappresentata da colori
differenti corrispondenti alla mappatura dei colori da voi definita.
2-64
Lezione 2
I diagrammi di intensità sono usati comunemente con l’analisi
spettrale, la visualizzazione di temperatura e l’elaborazione delle
immagini.
2-65
Lezione 2
Esercizi aggiuntivi
2-11
Modificate l’esercitazione 2-4 aggiungendo un cluster con quattro
pulsanti etichettati. Ogni volta che cliccate su un pulsante nel
nuovo cluster, decrementate il display di uno. Utilizzate il
pannello frontale come segue per iniziare. Salvate il VI come
Cluster Example 2.vi.
2-12
Realizzate un VI che modifichi un controllo di un pulsante sul
pannello frontale. Il pulsante dovrebbe controllare l’esecuzione del
VI (cioè terminare il ciclo While). Utilizzate un Dialog Ring per
selezionare le opzioni seguenti: pulsanti Enable e Show, pulsante
Disable, pulsante Grey out e pulsante Hide. Utilizzate i Nodi
Proprietà per implementare le azioni che il Dialog Ring definisce.
Provate i diversi modi di funzionamento del pulsante mentre
provate ad arrestare il VI. Salvate il VI come Button Input.vi
quando avete finito.
2-13
Aprite il VI Analyze & Present Data che avete sviluppato
nell’esercitazione 2-7 e modificate il VI in maniera tale che se il
numero di punti nel sottoinsieme sia un punto o meno, il pulsante
Log Results to File viene reso opaco.
2-66
Lezione 2
Note
2-67
Lezione 2
Note
2-68
Lezione 3
Questa lezione descrive come potete organizzare gli schemi a blocchi dei
vostri VI basandosi sul modo di trasferite i dati da un posto all’altro.
Innanzitutto vi verrà ricordato come LabVIEW avvia un VI. Quindi
imparerete ad utilizzare i dati locali e globali per passare i dati fra i VI e
al loro interno e vi saranno forniti consigli per utilizzare questi dati in
maniera efficiente. Da ultimo imparerete ad utilizzare DataSocket per
passare i dati tra VI e computer.
Imparerete:
A. A conoscere le tecniche di gestione dei dati in LabVIEW
B. Ad utilizzare le variabili locali
C. Ad utilizzare le variabili globali
D. A conoscere qualche sistema di utilizzazione di variabili locali e
globali
E. Ad utilizzare DataSocket.
3-1
Lezione 3
A. Tecniche di gestione dei dati in LabVIEW
La lezione precedente descriveva come realizzare l’interfaccia utente o
pannello frontale di un VI. Questa lezione si concentra su alcune funzioni
dello schema a blocchi, come passare i dati tra i nodi e controllare
l’ordine di esecuzione.
Come già sapete, il principio che governa l’esecuzione di un programma
in LabVIEW viene chiamato a flusso di dati. Le regole del flusso di dati
sono:
y
Un nodo viene eseguito solo quando i dati sono disponibili a tutti i
suoi terminali d’ingresso.
y
Un nodo fornisce i dati a tutti i suoi terminali di uscita quando ha
completato l’esecuzione.
y
I dati fluiscono attraverso i collegamenti istantaneamente.
Quindi uno schema a blocchi non viene eseguito dall’alto verso il basso o
da sinistra a destra, ma secondo le regole del flusso di dati. Ciò contrasta
con il metodo del controllo del flusso di esecuzione di un programma
convenzionale in cui le istruzioni vengono eseguite nella sequenza in cui
sono scritte.
I collegamenti sono la chiave per comprendere come il flusso di dati
opera in LabVIEW. Quando i fili sono direttamente collegati da un nodo
al successivo, l’ordine di esecuzione è definito. Se non ci sono
collegamenti tra due nodi, allora quei nodi possono essere eseguiti
contemporaneamente. Se dovete eseguire quei due nodi in ordine, dovete
utilizzare una struttura Sequence o, se i nodi sono subVI, creare delle
dipendenze dei dati da programma come i cluster di errore per controllare
l’esecuzione del programma.
Quando non potete usare collegamenti
I fili sono il metodo più efficace per passare i dati da un nodo al
successivo quando utilizzate la programmazione a flusso di dati. Sullo
schema a blocchi i dati vengono trasferiti da una funzione o da un VI ad
un altro collegandoli con un filo. I dati allora fluiscono dal produttore al
consumatore.
Nodo
1
3-2
Nodo
2
Lezione 3
Questo approccio non funziona se avete bisogno di scambiare dati tra
schemi a blocchi che operano in parallelo. Schemi a blocchi in parallelo
possono trovarsi in due cicli paralleli dello stesso schema a blocchi o in
due VI che sono richiamati senza che ci sia dipendenza nel flusso dei dati.
Considerate lo schema a blocchi seguente.
Nodo
1
Nodo
2
Questo schema a blocchi non esegue i due cicli in parallelo perché c’è un
collegamento tra i due subVI. Il collegamento crea una dipendenza dei
dati in cui il secondo ciclo non si avvia finché il primo non ha finito e
passa i dati attraverso il suo tunnel. Il solo modo di eseguire i due cicli
contemporaneamente è di rimuovere il collegamento. Tuttavia i subVI
non possono scambiarsi dati a meno che non utilizziate un’altra tecnica di
gestione dei dati. Questa lezione descrive le variabili locali, le variabili
globali e DataSocket come metodi per passare i dati attraverso parti dello
stesso schema a blocchi e tra schemi a blocchi differenti.
3-3
Lezione 3
B. Variabili locali
Fino ad ora, avete letto o aggiornato i dati da un oggetto del pannello
frontale utilizzando il suo terminale sullo schema a blocchi. Tuttavia un
oggetto del pannello frontale ha solo un terminale sullo schema a blocchi
e potreste aver bisogno di aggiornare o leggere un oggetto del pannello
frontale da diversi posti dello schema a blocchi. Utilizzando le variabili
locali, potete accedere ad oggetti del pannello frontale in diversi posti e
passare i dati attraverso strutture che non possono essere collegate da un
filo.
Creazione di variabili locali
Ci sono due modi per creare variabili locali sullo schema a blocchi. Se
avete già creato un oggetto del pannello frontale, potete creare una
variabile locale cliccando con il tasto destro del mouse sull’oggetto e
selezionando Create»Local Variable dal menu rapido. Potete utilizzare
questo metodo sul pannello frontale o sullo schema a blocchi. Appare
un’icona della variabile locale per l’oggetto del pannello frontale accanto
al terminale dello schema a blocchi. Quando cliccate con il tasto destro
del mouse sul terminale per creare una variabile locale, la variabile locale
si riferisce all’oggetto su cui avete cliccato per creare l’icona.
Potete anche selezionare Local Variable dalla palette Structures. Sullo
schema a blocchi appare un nodo di variabile locale, mostrato a sinistra.
Potete selezionare l’oggetto del pannello frontale al quale volete accedere
cliccando con il tasto destro del mouse sul nodo della variabile e
selezionando un oggetto dal menu Select Item. Questo menu elenca le
etichette dei controlli e degli indicatori del pannello frontale. Per questo
motivo etichettate sempre i vostri controlli e indicatori del pannello
frontale con nomi descrittivi utilizzando le etichette.
Per esempio, se il primo oggetto che avete creato sul pannello frontale è
etichettato come number in, appare l’icona di variabile locale mostrata a
sinistra. Dopo che avete inserito la variabile locale nello schema a
blocchi, potete selezionare l’oggetto del pannello frontale opportuno
cliccando sulla variabile con lo strumento Modifica o cliccando con il
tasto destro del mouse su di esso e selezionando l’oggetto del pannello
frontale dal menu Select Item.
3-4
Lezione 3
Pannello frontale
Schema a blocchi
Read Local e Write Local
Potete leggere dati da una variabile locale oppure scriverci sopra. Dopo
che avete inserito la variabile locale nello schema a blocchi, dovete
decidere come utilizzarla.
Di default, una variabile locale assume di ricevere dati. Quindi, questo
tipo di variabile locale agisce come un indicatore ed è una write local.
Quando scrivete nuovi dati nella variabile locale, il controllo o
l’indicatore relativo del pannello frontale si aggiornano per prendere il
nuovo dato.
Potete modificare la configurazione di una variabile locale affinché agisca
come sorgente di dati o read local. Per fare questo, cliccate con il tasto
destro del mouse sulla variabile e selezionate Change To Read. Sullo
schema a blocchi, un’icona read local si comporta proprio come un
controllo. Quando questo nodo viene eseguito sullo schema a blocchi, il
vostro programma legge i dati nel relativo controllo o indicatore del
pannello frontale.
Per trasformare una read local in write local, cliccate con il tasto destro
del mouse sulla variabile e selezionate Change To Write. La variabile
locale modificherà la direzione dei dati per riceverli invece di fornirli.
Sullo schema a blocchi, potete distinguere visivamente i due tipi di
variabili locali proprio come distinguete i controlli dagli indicatori. Una
read local ha un bordo spesso, mettendo in evidenza che è una sorgente di
dati, analogamente ad un controllo. Una write local ha un bordo sottile,
perché agisce come un ricevitore di dati, analogamente ad un indicatore.
Nella figura seguente, entrambe le variabili locali si riferiscono allo stesso
oggetto del pannello frontale.
Read Local
3-5
Write Local
Lezione 3
Esempio di variabile locale
Come esempio che mostri quando potete aver bisogno di una variabile
locale, considerate come dovreste usare un singolo interruttore sul
pannello frontale per controllare due cicli While in parallelo. I due cicli
non sono collegati e vengono eseguiti contemporaneamente. Dapprima
studieremo due metodi errati che utilizzano un terminale per l’interruttore
sullo schema a blocchi (Metodo 1 e Metodo 2). Quindi mostreremo come
una variabile locale risolva il problema (Metodo 3). Il pannello frontale di
questo VI di esempio appare di seguito.
Metodo 1 (errato)
Come primo tentativo, inseriamo il terminale di controllo dei cicli
all’esterno di entrambi e colleghiamolo ad ogni terminale condizionale. In
questo caso, il terminale di controllo dei cicli viene letto una volta, prima
che ogni ciclo While inizi l’esecuzione. Ricordiamo che questo accade
perché LabVIEW è un linguaggio di programmazione a flusso di dati e lo
stato del controllo booleano costituisce un ingresso per entrambi i cicli.
Se viene passato un TRUE all’interno dei cicli, i cicli saranno
permanentemente in esecuzione. Spegnere l’interruttore non arresta il VI
perché l’interruttore non viene letto durante le iterazioni dei due cicli.
Questa soluzione non funziona.
Metodo 2 (errato)
Ora spostate il terminale di controllo dei cicli all’interno del ciclo 1
affinché venga letto ad ogni iterazione del ciclo 1. Sebbene il ciclo 1 si
arresti correttamente, c’è un problema in questo approccio. Il ciclo 2 non
va in esecuzione se non riceve i suoi dati d’ingresso.
3-6
Lezione 3
Ricordate che il ciclo 1 non passa i dati all’esterno se non viene arrestata
l’esecuzione del ciclo. Quindi il ciclo 2 deve aspettare il valore finale del
controllo del ciclo, disponibile solo dopo che il ciclo 1 ha terminato.
Quindi i cicli non vengono eseguiti in parallelo. Inoltre il ciclo 2 viene
eseguito per una sola iterazione perché il suo terminale condizionale
riceve un valore di FALSE dall’interruttore di controllo nel ciclo 1.
Metodo 3 (corretto)
In questo esempio, il ciclo 1 è nuovamente controllato dall’interruttore,
ma questa volta, il ciclo 2 legge una variabile locale associata
all’interruttore. Quando impostate l’interruttore su FALSE sul pannello
frontale, il terminale dell’interruttore nel ciclo 1 scrive FALSE sul
terminale condizionale del ciclo 1. Il ciclo 2 legge la variabile locale
dell’interruttore e scrive FALSE sul terminale condizionale del ciclo 2.
Quindi i cicli While operano in parallelo e terminano
contemporaneamente quando l’unico interruttore sul pannello frontale
viene spento.
Questo semplice esempio dimostra l’utilità delle variabili locali. Come
mostrato precedentemente, l’utilizzo di variabili locali fornisce l’accesso
ad un unico oggetto del pannello frontale da posti diversi dello schema a
blocchi. Le variabili locali sono anche necessarie quando non potete
raggiungere i vostri obbiettivi utilizzando dei fili per trasportare i dati.
Fin qui avete imparato che potete leggere dati di ingresso da controlli e
inviare i risultati su un indicatore. Ma, per esempio, cosa fate se volete
determinare quali parametri erano stati usati per avviare un VI
precedentemente e volete inserire quei valori nei controlli per consentirne
la modifica all’utente? Come potete scrivere quei valori in un controllo?
3-7
Lezione 3
Non potete farlo con controlli e indicatori standard. Utilizzando le
variabili locali potete superare questa limitazione. Potete aggiornare un
controllo dallo schema a blocchi. Inoltre, potete avere un qualsiasi
numero di riferimenti di variabili locali per un dato controllo del pannello
frontale, alcuni in modalità di scrittura e altri in modalità di lettura. Con
un riferimento di variabile locale, potete accedere ad un oggetto del
pannello frontale come ingresso e come uscita.
Per comprendere questo concetto, esamineremo un esempio che mostra
un altro uso delle variabili locali. Qui sotto c’è un unico indicatore di
stringa. Supponete di volerlo aggiornare per visualizzare il ciclo in
esecuzione. Senza una variabile locale, non c’è modo di risolvere il
problema. Potete inserire il terminale indicatore in un solo ciclo.
Tuttavia, utilizzando una variabile locale, potete accedere allo stesso
indicatore del pannello frontale da più di un posto dello schema a blocchi,
consentendo ad un unico indicatore di visualizzare il ciclo che è in
esecuzione. L’indicatore Quale ciclo? viene inserito nel ciclo 1 e una
variabile locale di quell’indicatore viene inserita nel ciclo 2. Sebbene
questo esempio sia semplice, esso mostra come un indicatore possa essere
aggiornato da due posti separati dello schema a blocchi.
3-8
Lezione 3
Esercitazione 3-1
VI Login
Obiettivo: Utilizzare variabili locali per inizializzare controlli del pannello frontale
Nota Utilizzate questo VI nel progetto della Lezione 5.
Pannello frontale
1. Aprite il VI Login che si trova nella directory c:\exercises\LV
Basics 2. Il pannello frontale è già stato creato. Completate lo
schema a blocchi.
Schema a blocchi
2. Notate che le variabili locali sono incluse in una struttura Sequence a
singolo frame e che la costante stringa vuota è collegata alla cornice
del ciclo While. Questa impostazione assicura che entrambe le
variabili locali siano aggiornate prima che parta il ciclo While.
a. La variabile locale Login Name è impostata su write
localRipristina il login del nome su una stringa vuota. Per creare
questa variabile locale, cliccate con il tasto destro del mouse sul
terminale Login Name e selezionate Create»Local Variable dal
menu rapido.
b. La variabile locale Password è impostata su write
localRipristina la stringa della password su una stringa vuota.
Per creare questa variabile locale, cliccate con il tasto destro del
mouse sul terminale Password e selezionate Create»Local
Variable dal menu rapido.
3-9
Lezione 3
c. Costante
Empty
String,
disponibile
nella
palette
Functions»StringPassa i valori della stringa alle variabili locali
Login Name e Password.
d. Nodo Proprietà Login NamePer creare questo nodo, cliccate
con il tasto destro del mouse sul terminale Login Name e
selezionate Create»Property Node. Scegliete la proprietà key
focus e collegate una costante booleana TRUE ad esso.
e. Inserite il VI Verify Information. Per selezionare questo VI,
selezionate
Functions»Select
a
VI,
andate
su
c:\exercises\LV Basics 2, cliccate due volte sul VI Verify
Information che avete realizzato nell’esercitazione 1-2 e inseritelo
nello schema a blocchi. Questo VI utilizza il nome e la password e
verifica se c’è corrispondenza in una tabella con le informazioni
sugli impiegati.
Se avete problemi nel collegare la costante di stringa ad una variabile
locale, cliccate con il tasto destro sulla variabile locale e selezionate Change to
Write Local.
Nota
4. Ritornate al pannello frontale ed avviate il VI. Notate che i controlli
Login Name e Password si reimpostano su stringhe vuote quando
avviate il VI.
5. Ora ridimensionate il pannello frontale per mostrare solo gli oggetti
necessari nel modo seguente:
6. Salvate e chiudete il VI.
3-10
Lezione 3
Esercitazione 3-2
Obiettivo:
VI Select and Plot Waveform (Opzionale)
Utilizzare le variabili locali per modificare sia gli indicatori che i controlli del
pannello frontale
Pannello frontale
1. Aprite il VI Select and Plot Waveform che si trova nella directory
c:\exercises\LV Basics 2. Il pannello frontale è già stato
creato. Completate lo schema a blocchi.
3-11
Lezione 3
Schema a blocchi
3. Completate lo schema a blocchi con le seguenti:
a. String
Constant,
che
si
trova
nella
palette
Functions»StringInvia i valori di testo all’indicatore del
pannello frontale Current Activity.
b. Numeric
Constant,
che
si
trova
nella
palette
Functions»NumericReimposta la finestra di dialogo di tipo
ring Select Waveform su zero (Stand By) dopo che la forma
d’onda è stata acquisita.
c. Variabile locale New Waveform impostata su read localLegge i
dati nel grafico New Waveform e li passa al grafico Previous
Waveform. Per creare questa variabile locale, cliccate con il tasto
destro del mouse sul terminale New Waveform e selezionate
Create»Local Variable dal menu rapido. Quindi cliccate con il
tasto destro del mouse sulla variabile locale e selezionate Change
To Read.
d. Variabile locale Current Activity impostata su write
localInserisce nuovo testo nell’indicatore Current Activity. Ci
sono diverse copie di questa variabile locale nello schema a
blocchi, mostrandovi come potete accedere ad un oggetto del
pannello frontale da diversi posti dello schema a blocchi. Per
creare una variabile locale, cliccate con il tasto destro del mouse
sul terminale Current Activity e selezionate Create»Local
Variable dal menu rapido. Quindi fate due copie in più di questa
variabile locale.
3-12
Lezione 3
e. Variabile locale Select Waveform impostata su write
localReimposta il controllo Select Waveform sulla modalità
Stand By. Per creare questa variabile locale, cliccate con il tasto
destro del mouse sul terminale Select Waveform e selezionate
Create»Local Variable dal menu rapido.
Assicuratevi di aver impostato correttamente ciascuna variabile locale
come read local o write local. Per passare da write local a read local, cliccate
con il tasto destro del mouse sull’icona e selezionate Change to read Local dal
menu rapido. Per passare da read local a write local, cliccate con il tasto destro
del mouse sull’icona e selezionate Change to Write.
Nota
f. Funzione Wait (ms), che si trova nella palette Functions»Time
& DialogGenera un ritardo che vi consente di osservare le
attività del pannello frontale.
g. VI Acquire Signal, che si trova nella palette User
Libraries»Basics 2 CourseGenera i dati per la forma d’onda
specificata dal controllo Select Waveform.
5. Tornate al pannello frontale ed avviate il VI. Notate che il VI aggiorna
l’indicatore di stringa e immagazzina la vecchia forma d’onda nel
grafico Previous Waveform. Inoltre osservate che dopo che la nuova
forma d’onda è stata acquisita e inviata sullo schermo, il controllo
Select Waveform viene reimpostato su Stand By (zero).
3-13
Lezione 3
C. Variabili globali
Ricordate che potete utilizzare le variabili locali per accedere ad oggetti
del pannello frontale da varie posizioni dello schema a blocchi. Queste
variabili locali sono accessibili solo in quel singolo VI. Supponete di aver
bisogno di passare i dati tra diversi VI che operano contemporaneamente,
o i cui subVI hanno delle icone che non possono essere collegate tramite
fili nello schema a blocchi. Potete utilizzare una variabile globale per
ottenere questo. Le variabili globali sono simili a quelle locali, ma invece
di essere limitate all’uso in un singolo VI, le variabili globali possono
passare valori tra diversi VI.
Considerate l’esempio seguente. Supponete di avere due VI che
funzionano contemporaneamente. Ogni VI scrive un dato su un grafico
tipo chart. Il primo VI contiene anche un booleano per arrestare entrambi
i VI. Ricordate che qualora entrambi i cicli fossero sullo stesso schema a
blocchi, avreste bisogno di utilizzare una variabile locale per arrestare i
cicli. Adesso che ogni ciclo si trova in un VI distinto, dovete utilizzare
una variabile globale per arrestare i cicli.
Creazione di variabili globali
Le variabili globali sono oggetti interni di LabVIEW. Essi appaiono come
VI speciali nella memoria del computer. Una variabile globale ha un
pannello frontale in cui potete inserire controlli e indicatori di ogni tipo.
Tuttavia, una variabile globale non ha schema a blocchi. Il pannello
frontale è semplicemente un contenitore da cui potete prelevare dati da
altri VI.
3-14
Lezione 3
Per creare una variabile globale, selezionate Global Variable dalla
palette Structures. Un nodo di variabile globale appare sullo schema a
blocchi. L’icona di una variabile globale sullo schema a blocchi è simile a
quella di una variabile locale, a parte una piccola figura di un mondo che
appare sulla sinistra del nome della variabile globale.
Aprite il pannello di una variabile globale cliccando due volte sul nodo
relativo. Inserite controlli e indicatori sul pannello frontale allo stesso
modo con cui lo fate in un pannello frontale di un VI standard.
Dovete etichettare ogni controllo o indicatore (con un’etichetta propria)
perché una variabile globale si riferisce ad un oggetto tramite il suo nome.
Nota
L’esempio seguente mostra il pannello frontale di una variabile globale
con tre oggettiun numero, una stringa e un cluster contenente un
controllo digitale e uno booleano. Notate che la barra degli strumenti
della finestra non mostra le stesse voci di un normale pannello frontale.
Dopo che avete finito di inserire gli oggetti sul pannello frontale della
variabile globale, salvate la variabile globale e tornate allo schema a
blocchi del VI originario. Selezionate l’oggetto specifico nel VI della
variabile globale al quale volete accedere. Per selezionare un dato
oggetto, cliccate con il tasto destro del mouse sul nodo della variabile
globale e selezionate l’oggetto dal menu Select Item. Questo menu elenca
le etichette proprie di tutti gli oggetti del pannello frontale. Notate che
potete anche aprire il pannello frontale contenente gli oggetti nella
variabile globale da questo menu rapido.
3-15
Lezione 3
Potete anche cliccare sul nodo con lo strumento Modifica e selezionare la
variabile globale cui volete accedere.
Dopo aver selezionato l’oggetto specifico della variabile globale al quale
volete accedere, il nodo cambia aspetto, dalla figura mostrata a sinistra
passa a visualizzare l’oggetto che avete scelto, ad esempio un numero.
Potete utilizzare questa variabile globale in altri VI. Siccome una
variabile globale è un tipo speciale di VI, potete inserirla in altri VI
utilizzando l’opzione Select a VI nella palette Function. Quindi cliccate
con il tasto destro del mouse sul nodo per selezionare un oggetto specifico
della variabile globale al quale volete accedere, come descritto sopra.
Un pannello frontale di variabile globale può contenere riferimenti a
molti oggetti singoli che sono accessibili globalmente. Non avete bisogno di
creare un VI di variabile globale separato per ogni oggetto su cui avete bisogno
di accedere in modo globale.
Nota
Lettura e scrittura delle variabili globali
Come per le variabili locali, potete sia leggere che scrivere dati su una
variabile globale. Di default una variabile globale è write global quando
la create. Potete scrivere un nuovo valore in una variabile globale e allora
la variabile globale si comporta da indicatore.
Potete modificare la configurazione di una variabile globale affinché
agisca come sorgente di dati, o read global. Per far questo, cliccate con il
tasto destro del mouse sulla variabile e selezionate Change To Read.
Sullo schema a blocchi, un’icona read global si comporta come un
controllo. Quando questo nodo è in esecuzione sullo schema a blocchi, il
programma legge dati nell’oggetto associato del pannello frontale.
Per modificare una read global in una write global, cliccate con il tasto
destro del mouse sulla variabile e selezionate Change To Write. La
variabile globale modificherà la direzione dei dati per ricevere dati invece
di fornirli. Quando questo nodo è in esecuzione sullo schema a blocchi, il
programma invia un nuovo dato nella variabile globale.
Nello schema a blocchi potete distinguere visivamente le variabili globali
in lettura rispetto a quelle in scrittura proprio come fate con i controlli e
gli indicatori. Una variabile globale in lettura ha un bordo spesso,
mettendo in evidenza che è una sorgente di dati. Una variabile globale in
scrittura ha un bordo sottile, perché agisce come serbatoio di dati. Nella
figura sotto, entrambe le variabili locali si riferiscono allo stesso oggetto
del pannello frontale della variabile globale.
Write Global
Read Global
3-16
Lezione 3
Esercitazione 3-3
VI Data to Global
Obiettivo: Realizzare un VI che scriva dati in una variabile globale
Create una variabile globale e utilizzatela per inviare dati al VI
dell’esercizio successivo.
Schema a blocchi
2. Realizzate lo schema a blocchi precedente.
a. Struttura
Sequence,
che
si
trova
nella
palette
Functions»StructuresInizializza una variabile globale
utilizzando una dipendenza dei dati artificiale con la costante
booleana, che si trova nella palette Functions»Boolean, e il ciclo
While.
b. Ciclo
While,
che
si
trova
nella
palette
Functions»StructuresDetermina l’esecuzione continua del VI
finché una variabile globale booleana invia un valore TRUE.
Cliccate con il tasto destro del mouse sul terminale Conditional e
selezionate Stop If True.
c. Funzione Wait Until Next ms Multiple, che si trova nella palette
Functions»Time & DialogGarantisce che i dati siano scritti
sulla variabile globale ogni 50 ms. Create la costante cliccando
con il tasto destro del mouse sul terminale input e selezionando
Create»Constant.
d. Funzione
Divide,
che
si
trova
nella
palette
Functions»NumericDivide il contatore di iterazione del ciclo
While per 20. Create la costante cliccando con il tasto destro del
mouse sul terminale inferiore input e selezionando
Create»Constant.
3-17
Lezione 3
e. Funzione
Sine,
che
si
trova
nella
palette
Functions»Numeric»TrigonometricAccetta
un
valore
d’ingresso in radianti e produce in uscita il seno di quel valore.
3. VI My Globals per le variabili globali—Passa i valori tra due VI che
operano contemporaneamente. Completate i passi seguenti per creare
e configurare le variabili globali.
a. Nello schema a blocchi selezionate Global Variable dalla palette
Structures.
b. Cliccate due volte sul nodo per attivare il pannello frontale della
variabile globale. Create il pannello frontale della variabile
globale come indicato nella figura seguente. Etichettate i controlli
con etichette proprie. Notate che non c’è schema a blocchi
associato al pannello frontale della variabile globale.
Pannello della variabile globale
c. Salvate e chiudete la variabile globale.
Globals.vi.
Chiamatela My
d. Ritornate allo schema a blocchi di Data to Global.
e. Cliccate con il tasto destro del mouse sul nodo della variabile
globale e selezionate Visible Items»Label.
f. Usando lo strumento Modifica, cliccate sul nodo della variabile
globale e selezionate Stop. Potete modificare la variabile per
renderla di lettura o di scrittura, cliccandoci sopra con il tasto
destro del mouse.
g. Fate un numero sufficiente di copie della variabile My
Global.vi. Utilizzate lo strumento Modifica per selezionare la
voce corretta di cui avete bisogno dalla variabile globale.
Inizializzate la variabile globale Stop all’interno della struttura
Sequence scrivendoci un FALSE. La costante è collegata al bordo del
ciclo per forzare la variabile globale all’inizializzazione prima che il
ciclo inizi l’esecuzione. Questo evita la lettura del ciclo While da
parte di una variabile non inizializzata o da una che ha un valore
sconosciuto.
4. Salvate il VI come Data to Global.vi. Tenetelo aperto perché
dovete eseguirlo nell’esercizio successivo.
3-18
Lezione 3
Esercitazione 3-4
VI Display Global Data
Obiettivo: Realizzare un VI che legga dati da una variabile globale
Realizzate un VI che legga i dati da una variabile globale che avete creato
nell’esercizio precedente e visualizzi i dati su un grafico tipo chart.
Pannello frontale
Schema a blocchi
2. Realizzate lo schema a blocchi come indicato precedentemente.
a. Ciclo
While,
che
si
trova
nella
palette
finché non viene premuto il pulsante di Stop. Cliccate con il tasto
destro del mouse sul terminale Conditional e selezionate Stop If
True.
b. Funzione Wait Until Next ms Multiple, che si trova nella palette
Functions»Time & DialogImposta la frequenza di esecuzione
del ciclo. Assicuratevi che di default sia di 20 iterazioni al secondo
o 50 ms.
3-19
Lezione 3
3. VI My Globals per le variabili globali—Passa i valori tra due VI che
operano contemporaneamente. Queste variabili globali non sono state
create da un nodo di variabile globale su questo schema a blocchi, per
cui i passi per creare e configurare le variabili globali sono i seguenti.
a. Selezionate
Functions»Select a VI e selezionate My
Globals.vi dalla directory c:\exercises\Basics 2, in cui
avete salvato la variabile globale che avete creato
nell’esercitazione 3-3. L’oggetto della variabile globale
visualizzato nel nodo è Stop o Data Value, a seconda dell’ordine
in cui sono stati disposti sul pannello frontale della variabile
globale.
b. Copiate la variabile globale in maniera tale da averne due, una di
Stop e l’altra Data Value. Per accedere ad un oggetto differente
della variabile globale, cliccate sul nodo con lo strumento
Modifica e selezionate l’oggetto desiderato.
c. Rendete la variabile Data Value di tipo read cliccando con il tasto
destro del mouse sul modo e selezionando Change To Read dal
menu rapido.
Il VI legge un valore da Data Value e lo passa al grafico. Esso scrive
anche il valore corrente del pulsante di Stop sulla relativa variabile
globale ad ogni ciclo. Utilizzando una variabile globale, il valore
booleano viene letto nel VI Data to Global per controllarne il ciclo
While.
4. Salvate il VI come Display Global Data.vi.
5. Passate al pannello frontale del VI Data to Global e posizionate i due
pannelli frontali affinché siano visibili entrambi.
6. Avviate Data to Global. Tornate al VI Display Global Data ed
avviatelo. Il grafico sul pannello frontale del VI Display Global Data
visualizza i dati. Data to Global scrive continuamente il valore che
calcola sull’oggetto della variabile globale Data Value. L’esempio
seguente mostra Display Global Data che legge l’oggetto della
variabile globale e aggiorna il grafico.
3-20
Lezione 3
Il controllo Time Delay stabilisce ogni quanto tempo viene letta la
variabile globale. Notate come Time Delay influenza i valori
rappresentati sul grafico. Se impostate Time Delay su 0, lo stesso
valore Data Value viene letto dalla variabile globale diverse volte,
facendo apparire una diminuzione della frequenza della sinusoide
generata in Data to Global. Se impostate Time Delay ad un valore più
grande di 50 ms, può darsi che Display Global Data non riesca a
leggere alcuni valori generati in Data to Global e la frequenza della
sinusoide sembra diminuire. Se impostate Time Delay su 50 ms, cioè
sulla stessa frequenza utilizzata nel ciclo While di Data to Global,
Display Global Data legge e visualizza ogni punto della variabile
globale Data Value una sola volta.
Quando utilizzate le variabili globali, se non fate attenzione, potete
leggere dei valori più di una volta, o potete non leggerli tutti. Se dovete
processare ogni singolo aggiornamento, fate particolare attenzione ad assicurare
che un nuovo valore non sia scritto nella variabile globale fino a quando il
precedente non è stato letto, e che dopo che una variabile globale è stata letta,
non venga letta di nuovo finché un altro valore non è stato scritto sulla variabile
globale.
Nota
7. Premete il pulsante STOP sul pannello frontale di Display Global
Data per arrestare il VI. Notate che sia Display Global Data che Data
to Global si arrestano. Il VI scrive continuamente il valore del
pulsante STOP sull’oggetto Stop della variabile globale. Quel valore
3-21
Lezione 3
viene quindi letto in Data to Global e passato al terminale
condizionale per controllarne il ciclo. Quando premete il pulsante
STOP, un valore TRUE passa attraverso la variabile globale a Data to
Global, in cui viene letto per arrestare anche quel VI.
8. Chiudete entrambi i VI.
3-22
Lezione 3
D. Avvertenze importanti su variabili locali e globali
Inizializzazione di variabili locali e globali
Verificate che le vostre variabili locali e globali contengano dei valori
noti prima che il programma inizi. Altrimenti, le variabili potrebbero
contenere dati in grado di causare dei malfunzionamenti del programma.
Se non inizializzate una variabile locale prima di leggere i dati da essa,
essa conterrà il valore corrente del controllo. La prima volta che il vostro
programma legge una variabile globale, essa contiene il valore di default
dell’oggetto che legge, a meno che non abbiate inizializzato
precedentemente la variabile globale.
Condizioni di conflitto
Le variabili locali e globali di LabVIEW non si comportano come le
variabili locali e globali nei linguaggi di programmazione testuali.
Ricordate che LabVIEW è un linguaggio a flusso di dati, non un
linguaggio di programmazione sequenziale. L’abuso di variabili locali e
globali può portare a comportamenti inattesi del vostro programma,
perché le funzioni potrebbero non essere eseguite nell’ordine corretto.
Considerate il semplice esempio di variabile locale qui sotto. Il codice in
LabVIEW appare accanto al codice equivalente di un linguaggio di
programmazione sequenziale.
Codice in LabVIEW
Codice sequenziale
x=x+5
x=x+2
o
x=x+2
x=x+5
Quando eseguite il codice sequenziale, la soluzione per un dato valore di
x è chiaro perché le istruzioni vengono eseguite dall’alto verso il basso.
Tuttavia, il codice in LabVIEW non segue tale convenzione perché è un
linguaggio a flusso di dati. Ogni nodo viene eseguito quando tutti i suoi
dati sono disponibili. Non ci sono dipendenze di dati per garantire
l’ordine desiderato di esecuzione nello schema a blocchi sopra. Infatti, ci
sono diverse soluzioni possibili, in funzione di come il VI viene
compilato. Non potete assumere che il codice che si trova nello schema a
blocchi in basso sia eseguito dopo il codice al di sopra di esso.
L’esempio mostrato sopra illustra quello che è noto come condizione di
conflitto. Il risultato del vostro programma dipende dall’ordine in cui
vengono eseguite le istruzioni e il codice potrebbe non seguire l’ordine
che presupponete. Se utilizzate variabili locali e globali, potreste avere
3-23
Lezione 3
condizioni di conflitto se notate che il vostro codice viene eseguito
correttamente solo alcune volte, o che viene eseguito correttamente
durante l’esecuzione evidenziata ma non durante la normale esecuzione.
Per evitare situazioni di conflitto, scrivete su una variabile locale o
globale in una locazione separata rispetto a quella da cui l’avete letta—in
posizioni diverse dello schema a blocchi o della struttura, o in diverse
strutture o VI. Quando si utilizzano variabili globali in VI che vengono
eseguiti in parallelo, potreste aver bisogno di utilizzare una variabile
globale booleana aggiuntiva che indica quando un dato di variabile
globale è stato modificato. Altri VI possono monitorare questo booleano
per vedere se il dato è stato modificato e leggere il nuovo valore.
Utilizzare variabili locali e globali solo quando necessario
Le variabili locali e globali sono uno strumento potente che potete
utilizzare per raggiungere determinati obiettivi. Per esempio, potete creare
su un singolo schema a blocchi cicli paralleli che vengono controllati con
un oggetto da pannello frontale, oppure potete scambiare dati tra VI in
esecuzione separata. Comunque, le variabili locali e globali non fanno
parte intrinsecamente del concetto di programmazione a flusso di dati di
LabVIEW. Gli schemi a blocchi possono diventare più difficili da leggere
quando si utilizzano variabili locali o globali. Le condizioni di conflitto
possono causare comportamenti inattesi. L’accesso ai dati immagazzinati
ad una variabile locale o globale è più lento rispetto al flusso di dati e
meno efficiente dal punto di vista di utilizzo della memoria. Quindi,
utilizzate con parsimonia le variabili locali e globali e solo quando
necessario. Per esempio, non utilizzate variabili locali e globali per
evitare lunghi collegamenti nello schema a blocchi o per accedere in ogni
frame di una struttura Sequence.
3-24
Lezione 3
Considerate lo schema a blocchi precedente.
La struttura Sequence a tre frame esegue i soliti compiti di tutti i VI. Il
Frame 0 legge i controlli sul pannello per la configurazione del sistema di
test, il Frame 1 utilizza le variabili locali per i controlli per acquisire i dati
e il Frame 2 utilizza le variabili locali per scrivere dati su file. Sebbene
non ci sia fondamentalmente nulla di sbagliato nell’utilizzo della struttura
sequence e delle variabili locali in questo modo, esso non costituisce il
metodo più efficiente di utilizzo della programmazione a flusso di dati.
Quando osservate uno dei frame, non è semplice capire da dove
provengono i valori delle variabili locali e dove sono stati aggiornati
l’ultima volta.
Lo schema a blocchi mostrato sopra elimina l’uso delle variabili locali
disponendo i terminali di controllo originali al di fuori della struttura
sequence cosicché ogni frame della sequenza ora ha accesso ai valori. I
dati vengono passati tra i frame della sequenza attraverso una variabile
locale della sequenza.
Lo schema a blocchi mostrato sopra rimuove la struttura sequence ed
utilizza il flusso dei dati per definire le modalità operative del
programma. I cluster di errore definiscono l’ordine di esecuzione dei
subVI e mantengono anche le condizioni di errore che vengono verificate
alla fine con il VI di gestione degli errori. Questo è un modo più efficiente
di realizzare un programma e di gestire i dati in LabVIEW. Non solo lo
schema a blocchi è più piccolo e più facile da leggere, ma trasferire i dati
attraverso i fili di collegamento è il metodo di gestione migliore della
memoria.
3-25
Lezione 3
E. DataSocket
Finora in questa lezione avete imparato tre cose principali:
y
Il modo più efficiente per gestire i dati nello schema a blocchi è
tramite un collegamento diretto.
y
Le variabili locali possono essere usate per accedere ad oggetti del
pannello frontale da posti diversi dello schema a blocchi.
y
Le variabili globali possono essere usate per passare i dati tra VI
distinti senza utilizzare un collegamento.
Ci sono molti altri modi di gestire dati in LabVIEW. Questa lezione copre
un altro metodo, DataSocket. DataSocket è una tecnologia di
programmazione di Internet basata su protocollo TCP/IP che semplifica lo
scambio di dati tra computer ed applicazioni. Con DataSocket potete
trasferire dati su Internet in modo efficiente e rispondere a più utenti
senza la complessità della programmazione TCP a basso livello.
Quindi potete usare DataSocket per passare dati non solo tra VI in
esecuzione sulla stessa macchina ma anche tra computer distinti che sono
collegati tramite la rete. Potete anche utilizzare DataSocket per
comunicare tra LabVIEW ed un qualsiasi altro linguaggio di
programmazione che supporta il protocollo TCP/IP, come Excel, Visual
Basic, C e così via.
Come opera DataSocket?
DataSocket consiste in due componenti, DataSocket API e DataSocket
Server. DataSocket API presenta una singola interfaccia utente per la
comunicazione con diversi tipi di dati provenienti da altri linguaggi di
programmazione. DataSocket Server semplifica la comunicazione in
Internet tramite la gestione della programmazione del protocollo TCP/IP.
DataSocket API
DataSocket è un singolo API, unificato per l’utente finale, basato su URL
per il collegamento a misure e a dati di automazione che si possono
trovare dovunque, su un computer locale o su Internet. E’ un API
indipendente dal protocollo, dal linguaggio e dal sistema operativo,
progettato per semplificare la gestione di dati binari. Il DataSocket API
viene implementato affinché possiate utilizzarlo in ogni ambiente di
programmazione e con un qualsiasi sistema operativo.
Il DataSocket API converte automaticamente le vostre misure in una
sequenza di byte che viene inviata in rete. L’applicazione DataSocket
converte la sequenza di byte nella sua forma originaria. Questa
conversione automatica elimina la complessità della rete, che comporta la
scrittura di una gran quantità di codice quando utilizzate librerie TCP/IP.
3-26
Lezione 3
DataSocket Server
Il DataSocket Server è un componente leggero, stand-alone con cui i
programmi utilizzanti DataSocket API possono trasmettere misure in
corso a velocità elevate, usando Internet, a diversi client remoti
contemporaneamente.
Il DataSocket Server semplifica la programmazione TCP gestendo in
maniera automatica connessioni su client. Potete accedere a DataSocket
Server
selezionando
Start»Programs»National
Instruments»
DataSocket»DataSocket Server. Quando selezionate il DataSocket
Server, si apre la finestra seguente e il server va in esecuzione.
Come mostrato sopra, il DataSocket Server tiene traccia del numero di
client connessi e del numero di pacchetti di dati che sono stati scambiati.
Potete scegliere di avere DataSocket Server operante in maniera non
visibile selezionando Hide DataSocket Server dal menu Server.
La trasmissione dati con DataSocket Server richiede tre attori—chi
pubblica, il DataSocket Server e chi sottoscrive. Un’applicazione di
pubblicazione utilizza DataSocket API per scrivere dati sul server.
Un’applicazione di sottoscrizione utilizza DataSocket API per leggere
dati dal server. Entrambe le applicazioni sono client nei confronti di
DataSocket Server. I tre attori possono risiedere sulla stessa macchina ma
è più frequente il caso che si trovino su macchine diverse. La possibilità
di eseguire il DataSocket Server su un’altra macchina aumenta le
prestazioni e fornisce la sicurezza isolando collegamenti di rete dalla
vostra applicazione di misura. Il DataSocket Server limita l’accesso ai
dati amministrando la sicurezza e i permessi. Con DataSocket potete
condividere misure riservate su Internet impedendo l’accesso a persone
non autorizzate.
Una URL per ogni sorgente di dati
Prima che possiate iniziare ad utilizzare le funzioni DataSocket in
LabVIEW, dovete capire come DataSocket si collega a differenti
tecnologie di I/O e come nominare il dispositivo o la risorsa con la quale
state scambiando dati. Per esempio nell’I/O di file il nome della risorsa è
un percorso ad un file. Per il TCP/IP ci sono due parti del nome, un nome
di macchina e un numero di porta. Con DataSocket, il nome della risorsa
è sotto forma di URL, o uniform resource locator, simile all’indirizzo web
utilizzato da un browser. Considerate come potrebbe interpretare un
3-27
Lezione 3
browser la URL ni.com/datasocket. Essa dice al browser di usare un
protocollo basato TCP/IP chiamato HTTP, o hyper text transfer protocol,
per collegarsi alla macchina denominata ni.com e prendere la pagina
web chiamata datasocket.
La URL è differente dai nomi utilizzati dalla maggior parte delle
tecnologie di I/O perché non solo definisce a che cosa siete interessati ma
indica anche come prenderlo. Il come, codificato nella prima parte della
URL, viene chiamato metodo di accesso del protocollo. I web browser
utilizzano tipicamente molti metodi di accesso, come HTTP, HTTPS
(encrypted HTTP), FTP (file transfer protocol) e FILE (per leggere file
sulla vostra macchina locale). DataSocket presenta lo stesso approccio per
le misure. Per esempio, DataSocket può utilizzare la URL seguente per
collegarsi ad un insieme di dati: dstp://mytestmachine/wave1. Il
dstp all’inizio dice a DataSocket di aprire un collegamento con il
protocollo di trasferimento data socket e di prendere un segnale
denominato wave1. Se la URL fosse iniziata con file, i dati sarebbero stati
presi da un file invece che dal DataSocket server.
Le funzioni DataSocket
DataSocket API in LabVIEW è un insieme di funzioni e di VI che si trova
nella palette Functions»Communication»DataSocket.
La comunicazione in DataSocket è semplice. Potete eseguire tutte le
operazioni di base con le funzioni e i VI seguenti.
La funzione DataSocket Write scrive l’ingresso dei dati sulla URL
specificata. I dati possono essere in un qualsiasi formato del tipo dato di
LabVIEW. I cluster error in e error out mantengono le condizioni di
errore.
La funzione DataSocket Read legge i dati di tipo specificato dalla URL
specificata. Il valore ms timeout di default è di 10 s e potete specificare
un diverso valore di timeout. Il booleano timed out indica TRUE se
questa funzione è scaduta. I cluster error in e error out mantengono le
condizioni di errore.
3-28
Lezione 3
Il VI DataSocket Select URL viene usato solo quando non sapete la URL
di un oggetto e volete cercare una sorgente di dati o una destinazione da
finestra di dialogo.
Collegamento DataSocket diretto ad un qualsiasi oggetto del pannello
Non avete bisogno di utilizzare le funzioni DataSocket Write e
DataSocket Read per pubblicare e sottoscrivere dati utilizzando
DataSocket Server. Potete stabilire un collegamento DataSocket diretto da
un oggetto del pannello frontale. Cliccate con il tasto destro del mouse su
un
oggetto
del
pannello
frontale
e
selezionate
Data
Operations»DataSocket Connection per Visualizzare la finestra di
dialogo DataSocket Connection.
Nel campo Connect To, inserite una URL e scegliete se volete
pubblicare, sottoscrivere o entrambe le cose. Quindi contrassegnate il
riquadro Enabled.
Quando cliccate sul pulsante Attach, l’oggetto del pannello frontale
diventa disponibile alla URL specificata nel DataSocket Server. Compare
un piccolo rettangolo nella parte superiore destra del controllo o
dell’indicatore, ad indicare lo stato del collegamento DataSocket. Se il
rettangolo è verde, il collegamento è buono.
Se il rettangolo è grigio, non c’è collegamento al server. Se il rettangolo è
rosso, c’è un errore nel collegamento.
Ora realizzate due VI che trasferiscono dati utilizzando DataSocket.
3-29
Lezione 3
Esercitazione 3-5
VI DS Generate Data e VI DS Read Data
Obiettivo: Realizzare due VI che utilizzino DataSocket per trasferire i dati
Realizzate un VI che generi un numero casuale e visualizzi questo valore
su uno strumento misuratore e invii i dati ad una URL DataSocket. Quindi
realizzate un secondo VI che legga la URL DataSocket e visualizzi il
valore in un indicatore tipo slide. Infine, utilizzate le caratteristiche di
pubblicazione e di sottoscrizione automatica per inviare dati su un
collegamento DataSocket.
Pannello frontale
L’oggetto URL è un controllo di stringa.
Schema a blocchi
2. Aprite e realizzate lo schema a blocchi mostrato sopra utilizzando i
componenti seguenti.
a. Ciclo
While,
che
si
trova
nella
palette
True.
Functions»Time & DialogDetermina l’esecuzione del ciclo
While una volta al secondo. Create la costante cliccando con il
tasto destro del mouse sul terminale input e selezionando
Create»Constant.
3-30
Lezione 3
c. Funzione Random Number (0-1), che si trova nella palette
Functions»NumericCrea un numero casuale tra zero e uno.
d. Funzione
Multiply,
che
si
trova
nella
palette
Functions»NumericMoltiplica due numeri e viene usato qui
per riportare il numero casuale nella scala tra 0 e 10.
e. Funzione DataSocket Write, che si trova nella palette
Functions»Communication»DataSocketScrive il numero
casuale sulla URL specificata.
f. VI Simple Error Handler, che si trova nella palette
Functions»Time & DialogApre una finestra di dialogo in caso
di errore e visualizza le informazioni di errore.
3. Salvate questo VI come DS Generate Data.vi.
4. Ora realizzate il secondo VI per leggere il valore casuale.
Pannello frontale
L’oggetto URL è un controllo di stringa. Per mostrare la scala
sull’indicatore a scorrimento, cliccateci sopra con il tasto destro del
mouse e selezionate Scale»Style.
Schema a blocchi
2. Aprite e realizzate lo schema a blocchi mostrato sopra utilizzando i
componenti seguenti:
a. Ciclo
While,
che
si
trova
nella
palette
True.
3-31
Lezione 3
Functions»Time & DialogImpone l’esecuzione del ciclo ogni
secondo. Create la costante cliccando con il tasto destro del mouse
sul terminale input e selezionando Create»Constant.
c. Costante
Numeric,
che
si
trova
nella
palette
Functions»NumericCrea il tipo di dato corretto per leggere il
valore attraverso DataSocket. Assicuratevi che questa costante sia
una DBL cliccandoci sopra con il tasto destro del mouse e
selezionando Representation»Double Precision dal menu
rapido.
d. Funzione DataSocket Read, che si trova nella palette
Functions»Communication»DataSocketLegge il numero
casuale dalla URL specificata.
e. VI Simple Error Handler, che si trova nella palette
Functions»Time & DialogApre una finestra di dialogo in caso
di errore e visualizza le informazioni di errore.
3. Salvate il VI come DS Read Data.vi.
4. Posizionate i pannelli frontali dei VI DS Generate Data e DS Read
Data in maniera tale che li possiate vedere entrambi.
5. Avviate DataSocket Server dal menu Start e selezionate
Start»Programs»National Instruments»DataSocket»DataSocket
Server. Compare la finestra DataSocket Server, simile a quella
mostrata sotto.
6. Tornate ai due pannelli frontali dei VI ed assicuratevi che siano state
inserite le stesse URL in entrambi i VI.
y
dstp—Il protocollo di trasferimento DataSocket.
y
localhost—Il computer che state utilizzando.
y
data1—il nome dato al numero casuale che invierete.
7. Avviate i VI DS Generate Data e DS Read Data.
La finestra DataSocket Server mostra un processo connesso e il
valore Number of packets si incrementa ogni secondo quando il
misuratore e il cursore mostrano gli stessi numeri casuali.
8. Arrestate entrambi i VI quando avete finito. Ora modificate i VI per
utilizzare la pubblicazione e sottoscrizione automatiche degli oggetti
del pannello frontale.
3-32
Lezione 3
Pannello frontale
9. Inserite un indicatore digitale sul pannello forntale del VI DS Read
Data come mostrato sopra.
10. Cliccate con il tasto destro del mouse sul nuovo indicatore digitale e
selezionate Data Operations»DataSocket Connection dal menu
rapido. Inserite i valori seguenti.
11. Cliccate sul pulsante Attach e un piccolo rettangolo grigio appare in
alto sul lato destro dell’indicatore digitale. Ciò indica che la
connessione DataSocket non è attiva.
12. Avviate nuovamente i VI DS Generate Data e DS Read Data.
Il rettangolo vicino all’indicatore Random Number diventa verde e il
valore corrisponde ai valori mostrati nel misuratore e nell’indicatore a
scorrimento.
Nota Se il vostro computer è in rete con altri computer utilizzati in aula, potete
digitare nelle URL gli indirizzi di altre macchine in rete e trasferire i valori tra
computer della classe. Ricordate che potete utilizzare un qualsiasi linguaggio di
programmazione o sistema operativo con le connessioni DataSocket. Andate
alla pagina web su DataSocket della National Instruments all’indirizzo
ni.com/datasocket, per ulteriori informazioni.
13. Arrestate e chiudete entrambi i VI e il DataSocket Server quando
avete finito.
3-33
Lezione 3
y
DataSocket è un metodo di trasferimento dati basato su Internet che è
indipendente dalla piattaforma, dal linguaggio di programmazione e
dal protocollo. DataSocket utilizza URL per definire una connessione
dati specifica.
y
DataSocket consiste in due parti, DataSocket API e DataSocket
Server.
y
DataSocket
API
di
LabVIEW
consiste
nella
palette
Functions»Communication»DataSocket. Le due funzioni principali
sono DataSocket Write e DataSocket Read.
y
Potete consentire ad ogni controllo o indicatore di pubblicare e/o
sottoscrivere dati attraverso DataSocket Server cliccando sopra
quell’oggetto del pannello frontale con il tasto destro del mouse e
utilizzando la finestra Data Operations»DataSocket Connection.
y
Potete utilizzare variabili globali e locali per accedere ad un
determinato insieme di valori nell’ambito della vostra applicazione in
LabVIEW. Queste variabili scambiano informazioni tra diversi posti
della vostra applicazione quando non potete utilizzare collegamenti
diretti.
y
Le variabili locali accedono agli oggetti del pannello frontale del VI in
cui avete inserito la variabile locale.
y
Quando scrivete su una variabile locale, aggiornate il corrispondente
controllo o indicatore del pannello frontale.
y
Quando leggete da una variabile locale, leggete il valore corrente del
corrispondente controllo o indicatore del pannello frontale.
y
Le variabili globali sono oggetti interni a LabVIEW che passano i dati
tra VI. Essi possiedono dei pannelli frontali in cui immagazzinano i
loro dati.
y
Scrivete sempre un valore sulla variabile globale prima di leggere da
essa, per fare in modo che abbia un valore iniziale noto quando
accedete ad essa.
y
Scrivete su variabili locali e globali da posizioni diverse rispetto a
quelle da cui le leggete, per evitare situazioni di conflitto.
y
Utilizzate variabili locali e globali solo quando necessario. Un abuso
può causare un’esecuzione più lenta ed un utilizzazione inefficiente
della memoria nell’ambito della vostra applicazione.
y
Le variabili locali e globali non usano il flusso di dati, e quindi se le
usate troppo di frequente, potete rendere i vostri schemi a blocchi di
difficile comprensione per altre persone. Utilizzate variabili locali e
globali in maniera sapiente.
3-34
Lezione 3
Esercizi aggiuntivi
3-6 Aprite il VI In Range. Esaminate lo schema a blocchi. Questo
semplice VI genera cinque numeri casuali e accende un LED se
l’ultimo numero generato si trova tra 0.1 e 0.9. Avviate il VI diverse
volte fino a quando si accende il LED. Notate che se il LED si
accende durante un’esecuzione del VI, rimane acceso durante la
seconda esecuzione finché il ciclo For è terminato e l’ultimo numero
viene passato alla funzione In Range?, che si trova nella palette
Functions»Comparison. Modificate il VI utilizzando una variabile
locale affinché il LED si spenga quando il VI viene avviato. Salvate il
vostro VI dopo che avete finito.
3-7 Come già detto prima, il trasferimento dati tramite una variabile
globale non è un processo sincronizzato. Se provate a leggere dati da
una variabile globale troppo rapidamente o troppo lentamente,
potreste leggere copie dello stesso valore o perdere completamente dei
dati. Questo è stato visto nell’esercitazione 3-4, in cui potevate
regolare il ritardo tra le letture della variabile globale Data Value per
ottenere dati più velocemente o più lentamente.
Modificate Data to Global e Display Global Data, nell’esercitazione
3-3 e 3-4, affinché utilizzino un protocollo di handshake per garantire
che i dati non vengano saltati o letti più volte. Impostate un ulteriore
booleano in My Global.vi denominato Handshake, che verrà usato
per indicare quando i VI sono pronti per inviare o ricevere dati. Nel
VI Data to Global, assicuratevi di impostare la variabile globale
booleana Handshake su FALSE prima che passi un nuovo dato al
numerico Data Value. In Display Global Data impostate il booleano
Handshake su TRUE prima che tenti di leggere il dato numerico. In
entrambi i VI, assicuratevi di impostare il booleano Handshake in
modo tale che altri VI sappiano quando accedere alla variabile.
Chiamate
la nuova variabile globale booleana Handshake
Global.vi e gli altri due VI Data to Handshake Global.vi e
Display Handshake Global.vi.
Sfida
3-8 Aprite il VI Select and Plot Waveform dall’esercitazione 3-2.
Utilizzate le informazioni alla fine della Sezione D per riscrivere
questo VI per non utilizzare più la struttura Sequence e le variabili
locali.
Suggerimento Utilizzate un’architettura con macchine a stati e trasferite i dati
utilizzando i registri a scorrimento o collegamenti diretti.
Salvate il VI come Select and Plot Waveform2.vi.
3-35
Lezione 3
Note
3-36
Lezione 4
Quando si implementano subVI per l’I/O su file, potreste aver bisogno di
considerare diversi formati di file. Per esempio, se un’applicazione fatta
da altre persone dovesse leggere dati acquisiti da LabVIEW, dovreste
salvare i dati in formato testo perché molte applicazioni supportano i file
di testo. D’altro canto, se solo LabVIEW dovrà accedere ai dati e le
dimensioni dei file sono critiche, i file binari risultano essere una scelta
migliore. Tecniche avanzate di I/O su file e le funzioni interne per l’I/O di
file consentono questa flessibilità.
Imparerete:
A. A lavorare con file a flusso di byte
B. A creare e a lavorare con file datalog
C. A trasferire i dati su disco
D. A conoscere vantaggi e svantaggi di file testo, binari e datalog.
I subVI che realizzerete consentono di:
A. Salvare dati su file
B. Visualizzare file di analisi
4-1
Lezione 4
A. Lavorare con file a flusso di byte
Le funzioni per l’I/O su file di LabVIEW rendono estremamente semplice
lavorare con file a flusso di dati o con file di testo e binari. Utilizzate le
stesse funzioni per manipolare questi file. Tuttavia, quando si lavora con
file binari, i dati generalmente non sono in un formato leggibile. Inoltre,
siccome non potete contare su caratteri speciali come i tasti <Tab> e
<Return>, dovete conoscere la struttura dei dati immagazzinati nel file
prima di leggerlo. Senza questa conoscenza, non potete interpretare con
successo i dati memorizzati nel file binario.
Funzioni per l’I/O di file più frequenti
Prima di descrivere i file a flusso di dati in dettaglio, rivedremo
rapidamente le funzioni per l’I/O su file di LabVIEW. Queste funzioni si
trovano nelle palette Functions»File I/O e Functions»File
I/O»Advanced File Functions.
Fate riferimento a Help»Contents and Index per ulteriori informazioni
su queste funzioni.
Nota
La funzione File Dialog nella palette File I/O»Advanced File Functions
visualizza una finestra di dialogo per la selezione di file. Potete scegliere
da questa finestra file nuovi o esistenti oppure directory. Descriveremo
più avanti nella lezione l’uso dell’ingresso datalog type.
La funzione Open File nella palette File I/O»Advanced File Functions
apre un file esistente. Dovete collegare un percorso valido all’ingresso file
path. Questa funzione non è in grado di creare o sostituire file. Essa apre
solo file esistenti. L’ingresso datalog type viene usato solo quando si
aprono file datalog di LabVIEW.
La funzione New File nella palette File I/O»Advanced File Functions
crea un nuovo un nuovo file per la lettura o la scrittura. Dovete collegare
un percorso all’ingresso file path. Utilizzate l’ingresso datalog type solo
quando si creano nuovi file datalog di LabVIEW.
4-2
Lezione 4
La funzione Write File nella palette Functions»File I/O scrive dati su un
file aperto. Il comportamento di questa funzione varia leggermente a
seconda che stiate scrivendo dati su un file a flusso di dati o su un file
datalog di LabVIEW.
La funzione Read File nella palette Functions»File I/O legge dati da un
file aperto. Quando si leggono file a flusso di dati, potete utilizzare
l’ingresso byte stream type per indicare come LabVIEW dovrebbe
interpretare i dati nel file. Descriveremo questo concetti più avanti in
questa lezione.
La funzione Close File nella palette Functions»File I/O chiude il file
associato a refnum.
File a flusso di dati
Potete utilizzare la funzione Write File per creare entrambi i tipi di file a
flusso di dati—testo e binario. La creazione di un file testo è semplice
come mandare una stringa contenente caratteri alla funzione Write
Function.
Quando utilizzare file testo
I file testo sono utili e diffusi per molte ragioni. Quasi ogni sistema
operativo e la maggior parte delle applicazioni software possono leggere e
scrivere file in formato testo. Storicamente la maggior parte delle
applicazioni di controllo degli strumenti, come la GPIB e la seriale,
utilizzano stringhe di testo per inviare istruzioni di controllo.
4-3
Lezione 4
A causa dell’universalità del formato testo, ci sono diverse situazioni in
cui i file testo sono preferibili per la memorizzazione dei dati. Per
esempio, i file testo sono preferibili quando progettate di leggere o
manipolare dati con altre applicazioni software, come fogli elettronici o
word processor.
I file testo presentano anche degli svantaggi significativi. E’ difficile
accedere in maniera casuale a dati numerici presenti in file testo. Sebbene
ogni carattere in una stringa occupi esattamente un byte di spazio, lo
spazio necessario per esprimere un numero come testo tipicamente non
viene fissato. Per trovare il nono numero in un file testo, LabVIEW deve
dapprima leggere e convertire i precedenti otto numeri.
Potreste perdere in precisione memorizzando i dati numerici in file di
testo. I computer memorizzano i dati in formato binario, e tipicamente
scrivete dati numerici su un file testo con notazione decimale. Potrebbe
esserci una perdita di precisione quando leggete dati da un file testo. La
perdita di precisione non avviene con i file binari.
Come mostrato nello schema a blocchi precedente, la funzione Write File
scavalca ogni informazione di intestazione che LabVIEW utilizza per
immagazzinare la stringa in memoria e scrive il contenuto del controllo
dati della stringa su file. Infatti la funzione Write File non distingue una
stringa di testo da una binaria quando si scrivono dati su file—essa scrive
i dati su file. Il terminale dati della funzione Write File è polimorfico, il
che significa che si adatta ad ogni genere di dato che collegate ad esso.
Perciò potete creare un file binario collegando dati binari alla funzione
Write File nell’esempio precedente. Tuttavia noterete che le informazioni
di intestazione sono vitali per l’interpretazione del file binario.
Per esempio, se collegate una matrice bidimensionale di numeri nel
terminale data, la funzione Write File inserisce una copia byte per byte
dei dati di ingresso nel file. Essa non converte il numero in testo né
inserisce informazioni sul numero di righe o di colonne della matrice nel
file. Anche se sapete che i dati erano originariamente numeri in virgola
mobile e singola precisione, non potete ricostruire con successo la matrice
bidimensionale. Se il file contiene 24 byte di dati e sapendo che i numeri
in virgola mobile e singola precisione utilizzano quattro byte di memoria
ciascuno, potete calcolare che la matrice conteneva sei valori (24/4 = 6).
Tuttavia, i dati originari potrebbero essere stati memorizzati in una
matrice monodimensionale di sei elementi, una matrice bidimensionale
con una riga e sei colonne o una tabella con tre colonne e due righe.
Quando utilizzare file binari
Rispetto ai file di testo, quelli binari richiedono meno spazio sul disco per
memorizzare la stessa mole di informazioni. I file binari vi consentono di
accedere in maniera casuale ai dati memorizzati nel file.
4-4
Lezione 4
Tuttavia i file binari generalmente non sono trasportabili su altre
applicazioni. Inoltre dovete documentare con cura i dettagli necessari ad
estrarre l’informazione memorizzata in un file binario.
Creazione di informazioni di intestazione per un file binario
Quando create file binari, ideare un’opportuna intestazione del file è
spesso l’unico compito importante. Potete creare informazioni di
intestazione generando in modo esplicito un’intestazione o utilizzando
l’ingresso header della funzione Write File. L’esempio seguente mostra
come generare esplicitamente un’intestazione che contenga il numero di
righe e colonne dei dati.
Potete anche generare lo stesso file utilizzando l’ingresso header della
funzione Write File. Se collegate un valore booleano TRUE all’ingresso
header della funzione Write File, essa scrive gli stessi dati sul file come
se aveste scritto manualmente un’intestazione. L’esempio seguente
mostra come utilizzare la funzione Write File per creare un file binario
con intestazione.
Utilizzando l’esempio dello schema a blocchi precedente, se collegate
nuovamente una matrice bidimensionale di numeri a singola precisione
con tre righe e due colonne, il file dovrebbe contenere 24 byte di dati e
due interi di tipo long aggiuntivi, di quattro byte ciascuno, come
informazioni di intestazione. I primi quattro byte contengono il numero di
righe della matrice; i secondi quattro byte contengono il numero di
colonne.
Come mostrato nell’esempio seguente, potete leggere il file binario dagli
esempi precedenti utilizzando la funzione Read File.
4-5
Lezione 4
Notate che l’ingresso byte stream type della funzione Read File possiede
una matrice bidimensionale di numeri in singola precisione collegata ad
essa. La funzione Read File utilizza solo il tipo di dato di questo ingresso
per leggere i dati nel file, assumendo che abbia le informazioni di
intestazione corrette per quel tipo di dato.
Accesso casuale nei file a flusso di byte
Se memorizzate matrici di dati numerici su un file, potreste avere la
necessità di accedere ai dati in posizioni casuali del file. Non potete
accedere in maniera casuale ai dati memorizzati in file di testo quando i
dati hanno il segno negativo, hanno un numero variabile di cifre su singoli
punti di dati e altri fattori. Per esempio, se avete una matrice di 100
numeri compresi tra 0 e 1000, non potete prevedere dove si trovi un dato
elemento nella matrice all’interno del file di testo. Il problema è che nel
testo, il numero 345 richiede tre byte per essere memorizzato mentre il
numero 2 ne richiede solo uno. Quindi non potete prevedere la posizione
di un elemento arbitrario nel file.
Tali ostacoli non si presentano nei file binari. In un file binario, il formato
compatto di un numero in LabVIEW è un’immagine binaria del numero
stesso. Quindi ogni numero nella matrice utilizza un numero fissato di
byte di memorizzazione su disco. Se sapete che un file memorizza numeri
in singola precisione, che utilizzano quattro byte per numero, potete
leggere un gruppo arbitrario di elementi dalla matrice, come mostrato
nell’esempio seguente.
Calcolate il numero di byte dall’inizio
del file per iniziare a leggere i dati
4-6
Lezione 4
Nell’esempio dello schema a blocchi precedente, l’ingresso pos mode
della funzione Read File è impostato su start, il che significa che la
funzione inizia a leggere i dati al numero di byte pos offset dall’inizio del
file. Il primo byte nel file ha un offset di zero. Quindi la posizione
dell’elemento di ordine n in una matrice di numeri in virgola mobile e
singola precisione memorizzati in questo file è di 4xn byte dall’inizio del
file. Una costante in virgola mobile e singola precisione collegata
all’ingresso byte stream type, dice alla funzione Read File di leggere i
valori in virgola mobile e singola precisione dal file. Il controllo # values
to read, collegato all’ingresso count della funzione Read File, dice alla
funzione quanti sono gli elementi in singola precisione da leggere dal file.
Notate che quando l’ingresso count è collegato, LabVIEW inserisce i dati
di uscita in una matrice, perché LabVIEW legge più di un valore dal file.
Sono importanti da ricordare i seguenti punti relativamente alle
operazioni ad accesso casuale:
y
Quando si eseguono I/O su file di testo e binari, ricordate che i valori
per il terminale pos offset sono misurati in bytes.
y
L’ingresso count nella funzione Read File controlla quanti byte di
informazione sono letti dal file quando l’ingresso byte stream type
non è collegato. I dati letti dal file vengono restituiti in una stringa.
y
Se l’ingresso byte stream type è collegato, l’uscita data della
funzione Read File è dello stesso tipo dell’ingresso byte stream type
quando l’ingresso count non è collegato.
y
Se l’ingresso byte stream type è collegato e l’ingresso count ha dei
dati collegati ad esso, allora la funzione Read File restituisce una
matrice contenente count elementi dello stesso tipo di dati
dell’ingresso byte stream type.
y
Fate riferimento al LabVIEW Help e al LabVIEW User Manual per
ulteriori informazioni sulle operazioni di accesso casuale e sui file a
flusso di dati.
4-7
Lezione 4
Esercitazione 4-1
Obiettivo:
VI Binary File Writer
Realizzare un VI che scriva dati su un file binario con uno schema semplice di
formattazione dei dati
Questo VI salva i dati su un file binario utilizzando uno schema semplice
di formattazione in cui l’intestazione del file è un intero di tipo long word
(I32) contenente il numero di dati presenti nel file. Nell’esercizio
successivo, costruite un VI che legga il file binario.
Pannello frontale
2. Costruite il seguente pannello frontale. Quando create il menu tipo
ring, ricordate che una combinazione rapida di tasti per aggiungere
una nuova voce all’elenco di opzioni si ottiene premendo <ShiftEnter> dopo aver immesso il testo per una voce dell’elenco. Inserite
Zero for nella voce 0 dell’elenco, Sine nella voce uno e così via.
Per visualizzare il valore numerico del menu tipo ring, cliccate con il
tasto destro del mouse sul controllo e selezionate Visible
Items»Digital Display.
Macintosh, <Shift-Return>; Sun, <Shift-Return>; HP-UX, <Shift-Enter>; and
Linux, <Shift-Return>.
L’aspetto del controllo del menu tipo ring varia da una piattaforma
all’altra.
Nota
3. Aprite lo schema a blocchi.
4-8
Lezione 4
Schema a blocchi
4. Realizzate lo schema a blocchi seguente.
a. Inserite il VI Open/Create/Replace File VI che si trova nella
palette Functions»File I/O. Questo VI crea o sostituisce un file.
b. Inserite la funzione Write File che si trova nella palette
Functions»File I/O. Questa funzione appare due volte in questa
esercitazione. La prima funzione scrive l’intestazione del file
binario, che è un intero a quattro byte contenente il numero di
valori scritti sul file. La seconda scrive la matrice di dati su file.
c. Inserite la funzione Close File che si trova nella palette
Functions»File I/O. In questa esercitazione questa funzione
chiude il file binario dopo che i dati sono stati scritti in esso.
d. Inserite il VI Simple Error Handler che si trova nella palette
Functions»Time & Dialog. In caso di errore, questo VI
visualizza una finestra di dialogo con le informazioni sul tipo di
errore e dove è avvenuto.
e. Per creare questa costante, cliccate con il tasto destro del mouse
sull’ingresso pos mode della funzione Write File e selezionate
Create»Constant. Impostate position mode su start per garantire
che i nuovi dati siano scritti relativamente all’inizio del file.
f. Per creare questa costante, cliccate con il tasto destro del mouse
sull’ingresso function del VI Open/Create/Replace File e
selezionate Create»Constant. Selezionando create or replace,
consentite all’utente di creare un nuovo file o di sovrascriverne
uno esistente.
g. Inserite il VI Acquire Signal che si trova nella palette
Functions»User Libraries»Basics-II Course. In questa
esercitazione, questo VI genera la forma d’onda selezionata
tramite il controllo Select Waveform.
h. Inserite la funzione Array Size che si trova nella palette
Functions»Array. In questa esercitazione, questa funzione
restituisce il numero di elementi nella matrice monodimensionale
di dati da scrivere su file.
5. Salvate il VI come Binary File Writer.vi. Avviatelo, salvando
i dati sul file del disco denominato data.bin.
4-9
Lezione 4
Esercitazione 4-2
VI Binary File Reader
Obiettivo: Realizzare un VI che legga il file binario creato nell’ultima esercitazione.
Pannello frontale
1. Aprite un nuovo VI e realizzate il pannello frontale seguente.
Schema a blocchi
3. Realizzate lo schema a blocchi seguente.
a. Inserite il VI Open/Create/Replace File VI che si trova nella
palette Functions»File I/O. Questo VI apre un file.
b. Inserite la funzione Read File che si trova nella palette
Functions»File I/O. Questa funzione appare due volte in questa
esercitazione. La prima funzione legge l’intestazione del file
binario, che è un intero a quattro byte contenente il numero di
elementi nella matrice memorizzata sul file. La seconda legge la
matrice di dati dal file.
c. Inserite la funzione Close File che si trova nella palette
chiude il file binario dopo che i dati sono stati letti da esso.
d. Inserite il VI Simple Error Handler che si trova nella palette
4-10
Lezione 4
e. Inserite la costante Numeric che si trova nella palette
Functions»Numeric. Dovete creare una costante I32 affinché la
funzione Read File sappia quale tipo di dato aspettarsi. I32 è il
tipo di dato di default per le costanti numeriche.
f. Inserite la costante Numeric che si trova nella palette
Functions»Numeric. Dovete creare una costante in doppia
precisione affinché la funzione Read File sappia quale tipo di dato
aspettarsi. Siccome I32 è il tipo di dato di default per le costanti
numeriche, cliccate con il tasto destro del mouse e selezionate
Representation»Double Precision.
4. Tornate al pannello frontale. Salvate il VI come Binary File
Reader.vi.
5. Avviate il VI. Aprite il file data.bin creato nell’esercitazione 4-1.
Dopo aver aperto il file, la funzione Read File utilizza l’ingresso byte
stream type, che presenta un intero di tipo long, quattro byte, collegato
ad esso, per leggere i primi quattro byte dal file. La funzione
visualizza il numero nell’indicatore Number of Data Points, che
mostra quanti numeri erano memorizzati nel file. Ricordate che questa
intestazione è stata creata dalla funzione Write File nel VI Binary File
Writer nell’esercitazione 4-1.
La seconda funzione Read File legge la matrice di dati dal file
utilizzando l’ingresso byte stream, che presenta un valore a virgola
mobile in doppia precisione collegato ad esso. L’ingresso count
definisce quanti valori dovrebbero essere letti dal file.
6. Chiudete il VI.
4-11
Lezione 4
B. File datalog di LabVIEW
Se i vostri dati sono di tipo diverso, la formattazione in stringhe di testo o
binario per la memorizzazione può essere noioso e poco efficiente. I file
datalog di LabVIEW utilizzano un formato di memorizzazione dei dati
per il salvataggio di dati di un qualsiasi tipo. Per esempio potreste voler
salvare dei record di dati che contengono diverse centinaia di punti,
compresa la data e l’ora per ogni insieme.
Un file datalog memorizza le informazioni come una serie di record di un
qualsiasi tipo di dato. Sebbene tutti i record in un file devono essere dello
stesso tipo, tali record possono essere arbitrariamente complessi. Ogni
record è scritto su file come un cluster contenente il nome dell’operatore
del test, informazioni sul test, data e ora, e una matrice di valori numerici
per i dati attuali del test.
Utilizzate le stesse funzioni di I/O che avete usato per i file a flusso di
byte per lavorare con i file datalog. Tuttavia, utilizzate l’ingresso del tipo
di dato in maniera diversa per i file datalog. Per creare un nuovo file
datalog, collegate un cluster che si adatti con il cluster del record di dati al
terminale datalog type della funzione New File. Questo cluster definisce
come i dati vengono scritti sul file. Quindi collegate il record dei dati
attuali al terminale data della funzione Write File. Il cluster datalog type
collegato a New File non deve essere un record di dati attuali—ne avete
bisogno solo per definire il tipo di dato che potete memorizzare nel file.
L’esempio seguente mostra come creare un nuovo file datalog.
4-12
Lezione 4
Per leggere il record delle informazioni dal file datalog, dovete collegare
un ingresso a datalog type della funzione Open File che coincida
esattamente con il tipo di dato dei record memorizzati nel file. L’esempio
seguente mostra come aprire e leggere un file datalog esistente.
Il cluster collegato all’ingresso datalog type della funzione Open File
dev’essere identico al cluster utilizzato per creare il file e scriverci i dati,
compresi il tipo di dato numerico e l’ordine del cluster.
Nota
Quando l’ingresso count della funzione Read File rimane scollegato, la
funzione legge un singolo record dal file datalog. Se collegate un ingresso
al terminale count, Read File restituisce una matrice di record.
Quando utilizzare i file datalog
Potete utilizzare file datalog per memorizzare e recuperare formati
complessi di dati in LabVIEW. Tuttavi, i file datalog, come quelli binari,
non hanno un formato standard per la memorizzazione. Quindi essi sono
virtualmente impossibile da leggere con applicazioni software diverse da
LabVIEW. I file datalog sono più utili se intendete accedere ai dati solo
da LabVIEW e avete bisogno di memorizzare strutture complesse di dati.
4-13
Lezione 4
Esercitazione 4-3
VI Save Data to File
Obiettivo: Completare un VI che salvi i dati in un file testo, binario o datalog.
Completando questo VI si abilita l’opzione Log Results to File del VI
Analyze and Present Data dell’esercitazione 2-7. Ricordatevi che utilizzerete
l’esercitazione 4-3 nel progetto della Lezione 5.
Nota
Nell’applicazione che state per sviluppare, avete bisogno di salvare un
insieme di dati diversi su disco. Questo insieme di dati contiene semplici
numeri, matrici di numeri e dati di tipo stringa. Inoltre questi dati
vengono utilizzati solo in LabVIEW. A causa di questi vincoli,
utilizzerete i file datalog per salvare su disco dei sottoinsiemi di dati
dell’applicazione.
Pannello frontale
1. Aprite il VI Save Data to File che si trova nella directory
exercises\Basics2. Il pannello frontale è già realizzato
I due controlli sul pannello frontale sono utilizzati per passare i dati
dell’applicazione a questo VI, che opera come subVI nel progetto
completo. Il Data Cluster conterrà il sottoinsieme di dati analizzati da
salvare su disco e la stringa Employee name conterrà il nome
dell’operatore da salvare su file.
4-14
Lezione 4
Schema a blocchi
3. Completate la struttura Case dello schema a blocchi seguente. Le
condizioni che non sono mostrate sono già realizzate.
a. Cancellate la costante booleana etichettata con Delete Me.
b. Inserite la funzione File Dialog che si trova nella palette
Functions»File I/O»Advanced File Functions. Questa funzione
richiede il nome per il nuovo file. Collegate l’uscita dei terminali
exists e cancelled agli ingressi della funzione OR. Collegate il
valore exists alla struttura Case come mostrato nel precedente
schema a blocchi.
c. Per creare questa costante, cliccate con il tasto destro del mouse
sull’ingresso select mode della funzione File Dialog e selezionate
Create»Constant. Con lo strumento modifica, impostate questa
costante sul valore new file.
d. Per creare questa costante, cliccate con il tasto destro del mouse
sull’ingresso prompt della funzione File Dialog e selezionate
Create»Constant. Questa stringa visualizza un messaggio di
richiesta nella finestra di dialogo.
La struttura Case esterna scrive i dati su un file datalog di
LabVIEW. Notate che collegando Employee Name con Data
Cluster si fornisce il tipo di dato per il file datalog.
e. Inserite la funzione New File che si trova nella palette
Functions»File I/O»Advanced File Functions. Questa funzione
crea un nuovo file. Notate che l’ingresso datalog type di questa
funzione deve ricevere un ingresso.
f. Inserite la funzione Write File che si trova nella palette
Functions»File I/O. Questa funzione scrive un record su un file
datalog.
g. Inserite la funzione Close File che si trova nella palette
chiude il file dopo che ci sono stati scritti i dati.
4-15
Lezione 4
h. Inserite il VI Simple Error Handler che si trova nella palette
4. Dopo aver completato il VI, salvatelo e chiudetelo.
5. Aprite Analyze and Present Data.vi, che avete completato
nell’esercitazione 3-3. Questo VI richiama il VI Save Data to File.
Quando avviate questo VI e cliccate sul pulsante Log Results to File,
compare una finestra di dialogo nel VI Save Data to File così potete
dare un nome al file dati da salvare. Una volta che avete scelto il
nome del file, LabVIEW salva l’insieme dei dati come file datalog.
4-16
Lezione 4
Esercitazione 4-4
Obiettivo:
VI View Analysis File
Studiare un VI che legga i file dati creati dal VI Save Data to File dall’esercitazione
4-3.
Questo VI legge e visualizza i dati memorizzati dal VI Save Data to File.
Pannello frontale
1. Aprite il VI View Analysis File che si trova nella directory
exercises\Basics2. Questo VI è già stato realizzato.
4-17
Lezione 4
Schema a blocchi
La condizione True è vuota
3. Esaminate il comportamento del VI. Se l’utente cancella la finestra di
dialogo, non accade niente.
Notate che l’ingresso datalog type della funzione File Dialog è
collegato ad un cluster dummy dello stesso tipo di quelli da leggere.
Questo collegamento fa sì che la finestra di dialogo di LabVIEW
visualizzi solo le directory e i file con un opportuno tipo di dato. Una
volta che il file è stato selezionato, viene aperto come file datalog e
viene letto un unico record di dati. Infine, notate l’uso della verifica
degli errori in questa applicazione.
4. Dopo che avete avviato e testato il VI, chiudetelo. Non salvate i
cambiamenti.
4-18
Lezione 4
C. Salvataggio di dati su disco
Quando la vostra applicazione acquisisce dati e li scrive su disco
ripetutamente, potete migliorare l’efficienza delle operazioni di I/O su file
se non aprite e chiudete il file ogni volta che vi accedete. La tecnica per
lasciare aperti i file tra le operazioni di scrittura viene chiamata disk
streaming. Disk streaming è una tecnica che abbiamo usato in questo
corso senza descriverne le sue caratteristiche vantaggiose. Fate
riferimento all’esercitazione 4-3 per un esempio.
Gli esempi seguenti mostrano i vantaggi che derivano dall’utilizzo di
questa tecnica. Nel primo esempio il VI deve aprire e chiudere il file
durante ogni iterazione del ciclo. Il secondo esempio utilizza il disk
streaming per ridurre il numero di volte che il VI interagisce col sistema
operativo per aprire e chiudere il file. Aprendo il file una volta prima che
il ciclo inizi e chiudendolo dopo che il ciclo ha terminato, risparmiate due
operazioni su file ad ogni iterazione del ciclo.
La tecnica di Disk streaming è particolarmente importante quando
utilizzate VI ad alto livello, come Write To Spreadsheet File e Write
Characters To File. Questi VI aprono, scrivono e chiudono il file ogni
volta che vengono eseguiti. Perciò se richiamate uno di questi VI in un
ciclo, eseguite operazioni di Open File e Close File inutili ad ogni
iterazione del ciclo.
4-19
Lezione 4
Potete utilizzare le funzioni di I/O su file di LabVIEW per lavorare con
file di testo, binari o datalog. Le stesse operazioni di base di Open File,
Read File, Write File e Close File operano con tutti i tipi di file.
File di testo
I file di testo sono file in cui tutti i dati sono memorizzati come caratteri
di testo leggibili. I file di testo sono utili perché quasi tutte le applicazioni
software e i sistemi operativi possono leggerli. Tuttavia i file di testo
possono essere più grandi del necessario e quindi ne vengono rallentati gli
accessi. E’ anche molto difficile eseguire I/O su file ad accesso casuale
con file di testo. Di solito utilizzate file di testo quando:
y
Altri utenti o applicazioni hanno bisogno di accedere al file dati.
y
Non avete bisogno di accedere casualmente in lettura o in scrittura al
file dati.
y
Lo spazio su disco e la velocità di I/O su file non sono cruciali.
File binari
I file di dati binari sono file in cui i dati vengono memorizzati in formato
binario senza conversioni per rappresentarli come testo. I file di dati
binari sono generalmente più piccoli e vi si accede più rapidamente. L’I/O
su file ad accesso casuale non presenta grandi difficoltà. Tuttavia non
esiste un formato standard per i file binari. Quindi dovete mantenere le
informazioni sui tipi di dati e sulle intestazioni utilizzate nei file binari. Vi
consigliamo di utilizzare file di dati binari quando:
y
E’ improbabile che altri utenti o applicazioni abbiano bisogno di
accedere ai vostri dati.
y
Avete bisogno di effettuare I/O su file ad accesso casuale.
y
Lo spazio su disco e la velocità di I/O su file sono importanti.
File datalog
I file datalog sono un tipo particolare di file binario usati per il
salvataggio e il recupero di strutture di dati complesse in LabVIEW.
Come nel caso di file binari, essi non hanno un formato standard.
Consigliamo l’uso di file datalog quando:
y
I vostri dati sono composti da tipi di dati misti o complessi.
y
E’ improbabile che altri utenti o applicazioni abbiano bisogno di
accedere ai vostri dati.
y
La tecnica di Disk streaming viene utilizzata per scrivere dati su un
file più volte senza chiudere il file dopo ogni operazione di scrittura.
Ricordate che i VI ad alto livello aprono e chiudono i file ogni volta
che vengono eseguiti, determinando l’esecuzione di operazioni inutili
ad ogni ciclo.
4-20
Lezione 4
Esercizi aggiuntivi
4-5
Scrivete un VI che utilizzi funzioni di I/O su file avanzate per creare
un nuovo file. Quindi scrivete su quel file una stringa singola
composta da una stringa di ingresso da parte dell’utente concatenata
con un numero convertito in una stringa di testo utilizzando la
funzione Format Into String. Chiamate il VI File Writer.vi.
4-6
Scrivete un VI che utilizzi funzioni di I/O su file avanzate per
leggere il file creato nell’esercitazione 4-5. Chiamate il VI File
Reader.vi.
Consiglio Utilizzate la funzione EOF che si trova nella palette File
I/O»Advanced File Functions per ottenere la lunghezza del file scritto.
4-21
Lezione 4
Note
4-22
Lezione 5
Sviluppo di grandi
Questa lezione descrive alcuni aspetti che si devono considerare quando
si realizzano grandi applicazioni in LabVIEW, incluso il processo di
progettazione, l’organizzazione di subVI componenti e il processo di
combinazione di questi componenti per creare un’applicazione completa.
Imparerete:
A. Ad assemblare la vostra applicazione in LabVIEW a partire da subVI
già sviluppati.
B. A conoscere le caratteristiche di LabVIEW per la gestione dello
sviluppo del progetto.
C. A conoscere gli strumenti di LabVIEW per la gestione del progetto.
5-1
Lezione 5
A. Assemblaggio di un’applicazione in LabVIEW
La Lezione 1 di questo corso ha descritto un approccio di tipo generale
allo sviluppo di applicazioni in LabVIEW. Questo approccio includeva
una progettazione di tipo top-down dell’applicazione, seguito da
un’implementazione bottom-up del progetto come serie di subVI. Di
seguito si riporta uno schema di questo ciclo di sviluppo.
Processo di
confronto con il
cliente
Definizione del
progetto
Prove e rilascio
del prodotto finale
Progetto del
diagramma di
flusso
Integrazione di
subVI nel progetto
Implementazione
dei nodi come VI
Prove sui subVI
Top-Down
Bottom-up
Processo di sviluppo dei progetti in LabVIEW
In questa lezione, inserirete i VI costruiti nelle lezioni precedenti in
un’applicazione più grande. Svilupperete un VI per una generica
acquisizione di dati che soddisfi i seguenti criteri:
y
Fornisca un’interfaccia utente a menu.
y
Richieda all’utente di accedere con un nome e una password corretti.
y
Se l’utente non ha inserito i dati corretti, le altre caratteristiche
vengono disabilitate.
y
Consenta all’utente di configurare le impostazioni di acquisizione,
compresa la frequenza di campionamento, il numero di campioni o di
simulare i dati.
y
Acquisisca dati da forme d’onda con la configurazione definita
dall’utente.
5-2
Lezione 5
y
Non appena i dati sono stati acquisiti ed ogni volta che lo desidera,
l’utente possa selezionare un sottoinsieme di dati acquisiti, li possa
analizzare, salvando i risultati dell’analisi su un file.
y
Consenta all’utente di caricare e visualizzare i risultati dell’analisi
precedentemente salvati su disco.
y
Arresti l’applicazione con un click del pulsante Stop.
Nelle lezioni dalla 1 alla 4, vi siete concentrati sugli elementi inferiori del
processo di sviluppo, implementando e provando subVI che
corrispondono ai nodi del seguente diagramma di flusso del progetto.
START
No
Monitor
Menu Interfaccia
utente
Selezione
effettuata?
Sì
Pulsante di login
selezionato?
No
No
Entrato?
Sì
Sì
Log in
No
Premuto il
pulsante di
uscita?
Configura
impostazioni di
acquisizione
Sì
Raccoglie
dati del
processo
Stop
Selezione
del processo
Analizza dati
correnti e
salva su file
Carica e
visualizza
file di analisi
Lo sviluppo di grandi applicazioni in LabVIEW è un processo diverso
rispetto alla realizzazione di VI relativamente lineari, essenzialmente
adibiti ad un unico compito, con i quali abbiamo lavorato finora. Quando
sviluppate grandi applicazioni, troverete che lavorare in gruppo,
controllare il codice sorgente e creare uno schema gerarchico intuitivo per
i subVI della vostra applicazione aumenta la produttività e migliora la
documentazione e le prestazioni dell’applicazione.
5-3
Lezione 5
Lavoro di gruppo
Gli esperti di business management mettono in rilievo l’importanza del
lavoro di gruppo durante la progettazione di compiti grandi e complessi.
Quando si utilizza LabVIEW, il lavoro di gruppo è uno strumento potente
per aumentare la produttività della programmazione grafica. Quando
molte persone lavorano insieme per sviluppare un progetto in LabVIEW,
è essenziale che tutti i membri della squadra concordino su un metodo di
controllo del codice e di organizzazione.
Controllo del codice sorgente
Quando il numero di VI utilizzati nel vostro progetto cresce, il vostro
gruppo di sviluppatori dovrebbe adottare misure per controllare il codice
sorgente del progetto. Potete utilizzare la finestra interna VI Revision
History, che si trova in Tools»VI Revision History, per registrare i
cambiamenti che avete fatto ai VI. Quindi potete allestire un sistema di
verifica per i VI.
Strumenti di sviluppo realizzati da altri, che offrono un sistema di verifica
per proteggere i file di progetto, di solito possono lavorare con LabVIEW,
se sono in grado di operare con file binari. Se utilizzate uno di questi
strumenti per gestire i vostri file di progetto, ricordatevi che i VI e LLB,
le librerie di VI, sono file binari. Quindi gli strumenti che uniscono file
sorgente non operano correttamente con i file di LabVIEW.
Se utilizzate un sistema di verifica e i VI sono memorizzati in una LLB,
dovete verificare l’intera libreria di VI. Tenete presente questo quando
lavorate su un progetto. Una tecnica di gestione di VI è di lavorare su una
copia del VI che volete modificare e di bloccare il VI originale per
indicare agli altri che il VI non dev’essere modificato. Per bloccare un VI,
abilitate l’impostazione Locking selezionando Security dal menu a
tendina della finestra di dialogo File»VI Properties. Dovreste anche
indicare che avete verificato il VI aggiungendo un commento nella
finestra VI Revision History. Quando bloccate un VI, il suo schema a
blocchi non può essere modificato. Dopo che avete finito di modificare il
VI, sostituite il VI memorizzato nella LLB con la nuova versione e
sbloccatela così altri sanno che è sicura la verifica del VI.
Per documentare i vostri VI, selezionate Description and Tip dal menu a
tendina nella finestra di dialogo File»VI Properties. Le descrizioni di
controllo forniscono anch’esse un aiuto online che potete utilizzare nel
prodotto finale.
Utilizzo di librerie di LabVIEW (LLB)
Potete caricare e salvare VI utilizzando un file speciale denominato
libreria di VI (.llb). I file librerie di VI sono utili per l’organizzazione di
VI. Alcuni dei vantaggi che derivano dall’uso di LLB sono:
5-4
Lezione 5
y
Potete utilizzare nomi lunghi fino a 255 caratteri per i vostri VI.
y
LLB memorizzano diversi VI in un formato compresso, che fa
risparmiare spazio su disco.
y
Potete classificare dei VI per metterli in testa alla classifica.
y
Il trasporto di VI su un’altra piattaforma è semplificato perché non
avete bisogno di trasferire molti file.
Ci sono anche alcuni svantaggi quando utilizzate LLB:
y
Il caricamento e il salvataggio per applicazioni che usano un gran
numero di subVI memorizzati in LLB sono generalmente più lenti
rispetto a subVI che sono memorizzati direttamente su disco
utilizzando directory.
y
Le librerie di VI non sono gerarchiche. Non potete creare una libreria
di VI in un’altra libreria di VI, e quindi tutti i VI e subVI sono allo
stesso livello.
y
Quando i file LLB diventano grandi, cioè fino a diversi megabyte, il
salvataggio su un VI memorizzato in una LLB prende più tempo.
y
Ricordate che il sistema operativo visualizza una LLB come un
singolo file, così quando salvate un VI in una LLB, LabVIEW e il
sistema operativo devono operare su un file molto grande. Lavorando
con file di tali dimensioni, correte rischi maggiori di superare i limiti
di memoria o di spazio su disco, aumentando la probabilità di rovinare
la libreria e di perdere il lavoro.
y
Non potete utilizzare gli strumenti di ricerca dei file del vostro sistema
operativo per trovare VI memorizzati in una LLB.
y
Il controllo del codice sorgente di VI memorizzati in LLB è più
difficile.
Come regola, provate a limitare le dimensioni della vostra LLB a circa 1
MB. Memorizzare i vostri VI in una LLB o direttamente su disco può
dipendere dalle limitazioni sul nome del file del vostro sistema operativo
o da come scegliete di organizzare i vostri file.
Fate riferimento al manuale LabVIEW Development Guidelines,
disponibile all’indirizzo ni.com, per ulteriori informazioni sulla
progettazione, la realizzazione e il test di applicazioni in LabVIEW, con
una guida sugli stili, elenchi di controllo e riferimenti.
Creazione di applicazioni in LabVIEW
Ora state per creare l’applicazione descritta nelle pagine precedenti. Il
primo passo per creare un’applicazione professionale e indipendente
tramite VI è di capire l’architettura della vostra applicazione. Voi state
per utilizzare l’architettura a macchine a stati descritta nella Lezione 1.
Questa applicazione contiene un unico VI a livello superiore che richiama
altri VI come subVI.
5-5
Lezione 5
Nelle quattro esercitazioni successive realizzerete il VI Application
Exercise. Ogni esercitazione aggiunge uno stato o due all’applicazione.
Questo metodo viene utilizzato per consentirvi di testare l’applicazione
man mano che viene costruita.
5-6
Lezione 5
Esercitazione 5-1
Obiettivo:
VI Application Exercise (5-1)
Utilizzare il VI Login creato nell’esercitazione 3-1 per proteggere con password
un’applicazione.
Inizierete a creare un’applicazione che utilizza diversi VI che avete scritto
precedentemente nel corso. Il primo passo di questo processo di sviluppo
è di aggiungere una procedura di login al VI Menu creato
nell’esercitazione 2-3.
Pannello frontale
1. Aprite il VI Menu che si trova nella directory exercises\Basics2.
Avete creato questo VI nell’esercitazione 2-3.
Nota Se non avete completato l’esercitazione 2-3, individuate il VI Menu nelle
soluzioni del corso memorizzate sul vostro computer.
2. Aggiungete un indicatore di stringa che si trova nella palette
Controls»String & Path. Etichettatela con Operatore.
3. Aggiungete un Led rettangolare che si trova nella palette
Controls»Boolean ed etichettatela con Accesso consentito.
Scriverete questo VI in maniera tale che, finché non viene
riconosciuto un utente con login corretto, l’utente possa utilizzare solo
i pulsanti Login e Stop.
5-7
Lezione 5
Schema a blocchi
5. Modificate il VI seguente. Modificate solo il ciclo While e le
condizioni –1 e 0. Il VI Login viene richiamato quando l’utente preme
il pulsante Login sul pannello frontale (condizione 0 della struttura
Case). Ricordatevi di cancellare la funzione One Button Dialog che
avete inserito nella condizione 0 nell’esercitazione 2-3.
Nota Se non avete completato l’esercitazione 3-1, individuate il VI Login nelle
soluzioni del corso memorizzate sul vostro computer.
5-8
Lezione 5
6. Inoltre modificate il VI in maniera tale che:
a. L’indicatore Operatore sia inizializzato con una stringa vuota
quando il VI si avvia.
b. Se l’utente non ha effettuato il login correttamente, solo i pulsanti
Login e Stop siano in esecuzione.
c. Se il VI Login fornisce un valore FALSE per l’uscita Accesso
consentito, l’indicatore Operatore deve risultare vuoto.
Nota Il VI ha bisogno delle informazioni Operatore e Accesso consentito nelle
successive iterazioni del ciclo. Quindi questo VI utilizza due registri a
scorrimento aggiuntivi per memorizzare i dati. Dovete assicurarvi che le altre
condizioni della struttura Case passino i dati correttamente, in maniera diretta
fra le condizioni.
Utilizzando i registri a scorrimento, notate che solo la condizione 0, in cui
viene eseguito il VI Login, può modificare i valori Operatore e Accesso
consentito.
Il ciclo verifica che il valore memorizzato nel registro a scorrimento
booleano, che rappresenta lo stato di Accesso consentito, sia TRUE, se
l’utente ha premuto il pulsante Login (componente 0 nel cluster di menu)
o quello Stop (componente 4) per determinare quale condizione eseguire.
Se tutte queste condizioni sono FALSE, allora viene eseguita la
condizione –1.
7. Avviate il VI e testatelo per assicurarvi che si comporti correttamente.
Utilizzate gli strumenti di verifica di LabVIEW—esecuzione
evidenziata, passo-passo, sonde e punti d’interruzione—per
determinare il flusso di dati del VI.
8. Salvate il VI come Application Exercise (5-1).vi. Non
chiudete il VI.
5-9
Lezione 5
Esercitazione 5-2
Obiettivo: Aggiungere il VI Acquire Data all’applicazione iniziata nell’esercitazione 5-1.
Nell’esercitazione precedente, avete iniziato a realizzare il VI Application
Exercise. Ora dovete aggiungere il VI Acquire Data, che avete realizzato
nell’esercitazione 2-2.
Schema a blocchi
1. Assicuratevi che il VI Application Exercise (5-1) sia aperto. Non
modificherete il pannello frontale in questa esercitazione. Aprite lo
schema a blocchi.
2. Mostrate la condizione 1 della struttura Case e cancellate la funzione
One Button Dialog. Aggiungete il VI Acquire Data, che avete
realizzato nell’esercitazione 2-2. Se non avete finito
quell’esercitazione, utilizzate il VI delle soluzioni che si trova sul
vostro computer.
3. Aggiungete un registro a scorrimento sulla cornice del ciclo While.
Collegate l’uscita Time Waveform del VI Acquire Data sul lato
destro del registro a scorrimento.
4. Dovete inizializzare il nuovo registro a scorrimento che avete creato.
a. Cliccate con il tasto destro del mouse sul lato sinistro del registro a
scorrimento che contiene il cluster di configurazione e selezionate
Create»Control dal menu rapido. Questo crea un controllo di
forma d’onda vuoto sul pannello frontale.
b. Nascondete questo controllo di Time Waveform cliccando con il
tasto destro del mouse sul terminale e selezionando Hide Control
dal menu rapido. Ciò rende il controllo invisibile in maniera da
non confondere gli utenti.
5-10
Lezione 5
5. Modificate le proprietà del subVI Acquire Data in maniera tale che
appaia come una finestra di dialogo quando viene richiamato. Cliccate
due volte sul subVI Acquire Data per aprirne il pannello frontale.
Selezionate File»VI Properties e quindi Window Appearance dal
menu a tendina superiore e cliccate sul pulsante Dialog. Cliccate su
OK quindi salvate e chiudete il VI Acquire Data.
6. Ricordate che se una condizione della struttura Case passa i dati
all’esterno, anche tutte le altre condizioni della struttura devono farlo.
Completate il VI affinché scambi i dati fra le altre condizioni non
modificate, ricordando il metodo adottato nell’esercitazione 5-1.
7. Salvate il VI come Application Exercise (5-2).vi. Avviatelo
e testatelo.
5-11
Lezione 5
Esercitazione 5-3
Obiettivo:
Completare il VI Application Exercise aggiungendo i subVI per i pulsanti Analyze
& Present Data e View Analysis File.
Aggiungerete il VI Analyze & Present Data dell’esercitazione 2-7 e il VI
View Analysis File, che avete studiato nell’esercitazione 4-4.
Schema a blocchi
1. Assicuratevi che il VI Application Exercise (5-2) sia aperto. Non
modificherete il pannello frontale in questa esercitazione. Aprite lo
schema a blocchi.
5-12
Lezione 5
2. Cancellate la funzione One Button Dialog nella condizione 2 della
struttura Case. Aggiungete il VI Analyze & Present Data VI a questa
condizione. Avete completato questo VI nell’esercitazione 2-7.
a. Collegate la stringa contenente il nome dell’operatore all’ingresso
Operator.
b. Collegate la forma d’onda contenente i dati raccolti sull’ingresso
Data.
3. Mostrate la condizione 3 della struttura Case e cancellate la funzione
One Button Dialog. Aggiungete il VI View Analysis File. Non avete
bisogno di fare collegamenti ad esso.
4. Salvate il VI come Application Exercise (5-3).vi ed
avviatelo. Dovreste essere in grado ora di eseguire tutte le opzioni
disponibili nel menu dopo aver effettuato il login con un nome e una
password validi.
Dovete selezionare un sottoinsieme di dati acquisiti quando scegliete
Analyze & Present Data. Dopo aver scelto il sottoinsieme, cliccate sul
pulsante Analyze e quindi selezionate il pulsante per salvare i dati su file.
Altrimenti il file non contiene dati di forma d’onda.
Nota
5-13
Lezione 5
B. Caratteristiche di LabVIEW per lo sviluppo di progetti
Storia dei VI
Uno degli strumenti di LabVIEW più utili per lo sviluppo da parte di
gruppi è la finestra VI Revision History. Ogni VI ha una finestra History
che visualizza i commenti registrati da coloro che hanno lavorato sul VI.
Potete utilizzare la finestra VI Revision History per mantenere traccia
delle modifiche e delle revisioni dei VI e delle applicazioni. Potete
configurare LabVIEW con diverse opzioni di VI Revision History, che
possono essere globali o per ogni VI, utilizzando le preferenze di
LabVIEW presenti in Tools»Options e in File»VI Properties.
Per aprire la finestra Revision History di un VI, selezionate Tools»VI
Revision History.
Dopo aver digitato i vostri commenti nell’area Comment della finestra
Revision History, cliccate su Add per aggiungerli alla storia del VI. La
finestra Revision History memorizza anche del numero di revisioni. Ogni
volta che salvate il VI, il numero di revisioni del VI si incrementa di uno.
Oltre al numero di revisioni e alla data e ora in cui è stato aggiunto il
commento alla storia del VI, compare il nome dell’utente corrente nel
campo User. Potete configurare le preferenze di LabVIEW per richiedere
un nome utente all’avvio, selezionando Revision History dal menu a
tendina superiore nella finestra di dialogo Tools»Options, oppure potete
modificare il nome dell’utente selezionando Tools»User Name.
5-14
Lezione 5
Gerarchia dei VI
Uno dei principali vantaggi derivanti dalla scomposizione della vostra
applicazione in subVI è il risparmio di memoria. Inoltre, la risposta
dell’editor di LabVIEW migliora perché VI più piccoli sono più facili da
gestire. Applicazioni gerarchiche sono più facili da sviluppare, da leggere,
da documentare e da modificare.
Quindi, come regola generale, si consiglia di mantenere lo schema a
blocchi del VI a livello superiore al disotto dei 500 KB. In generale, i
vostri subVI dovrebbero essere significativamente più piccoli. Per
verificare le dimensioni di uno schema a blocchi, selezionate Memory
Usage dal menu a tendina superiore nella finestra di dialogo File»VI
Properties. Solitamente dovete prendere in considerazione il suddividere
un VI in diversi subVI se il vostro schema a blocchi è troppo grande per
entrare completamente nello schermo.
Se trovate che lo schema a blocchi di un VI sta diventando troppo grande.
Potete convertirne una parte in un subVI utilizzando Edit»Create SubVI.
Questa possibilità vi fornisce un metodo rapido e facile per creare la
gerarchia della vostra applicazione.
La finestra VI Hierarchy è anche un valido strumento per posizionare
subVI e visualizzare il layout complessivo del progetto quando la vostra
applicazione cresce. Per visualizzare la finestra VI Hierarchy, selezionate
Browse»Show VI Hierarchy. Compare una nuova finestra che mostra le
gerarchie di tutti i VI di livello superiore in memoria.
Potete utilizzare le opzioni disponibili nella barra degli strumenti
superiore della finestra VI Hierarchy per mostrare o nascondere varie
categorie di oggetti utilizzati nella gerarchia, come variabili globali o VI
forniti con LabVIEW, così come la gerarchia che si espande in
orizzontale o in verticale.
5-15
Lezione 5
Cliccando sulla piccola freccia che compare accanto ad un VI, si espande
o si comprime la vista di quella gerarchia. Potete espandere diversi rami
della gerarchia complessiva.
La finestra Hierarchy seguente contiene la gerarchia dell’applicazione che
avete completato nell’esercitazione precedente. I VI della directory di
LabVIEW vi.lib non vengono mostrati. L’intera gerarchia viene
mostrata cliccando con il tasto destro del mouse su un’area libera della
finestra e scegliendo Show All VIs.
Redo Layout
Layout orizzontale
Comprende globali
Comprende
Layout verticale
VI Library
Comprende Type Def
Quando spostate il cursore sulle icone mostrate nella finestra Hierarchy,
compare il nome del VI. Potete cliccare due volte su un’icona per aprire il
VI. Potete anche individuare un VI nella gerarchia digitando il nome di un
VI mentre siete nella finestra Hierarchy. Mentre digitate il nome, la
finestra Hierarchy scorre sul relativo VI. Potete anche utilizzare la
caratteristica Find per cercare un VI nella finestra Hierarchy.
La finestra Hierarchy può anche essere usata come strumento di sviluppo
quando pianificate o implementate il vostro progetto. Per esempio, dopo
aver sviluppato un diagramma di flusso dei VI necessari per
un’applicazione, potete creare, dal basso della gerarchia verso l’alto,
ciascuno di questi VI in maniera tale che essi abbiano tutti gli ingressi e le
uscite necessari sul loro pannello frontale, e i subVI che richiamano sul
loro schema a blocchi. Ciò realizzerà la gerarchia di base
dell’applicazione, che appare nella finestra Hierarchy. Potete quindi
iniziare a sviluppare ciascun subVI, codificando con i colori le icone, che
saranno colorate anche nella finestra Hierarchy, indicando il proprio stato.
5-16
Lezione 5
Per esempio, icone bianche potrebbero rappresentare VI non toccati,
icone rosse potrebbero rappresentare subVI in corso di sviluppo e icone
blu potrebbero rappresentare VI completati. Mentre questo è solo un
esempio di utilizzo della finestra Hierarchy come strumento di sviluppo,
esso dimostra l’utilità di questa finestra nell’organizzazione di un
progetto.
Utilizzo dell’Help online nelle vostre applicazioni in LabVIEW
Quando eseguite gli ultimi ritocchi alla vostra applicazione, potreste
decidere di fornire un help online all’utente. LabVIEW offre diversi
meccanismi per farlo. Utilizzando l’opzione Description and Tip
disponibile su ogni controllo e indicatore del pannello frontale, create non
solo VI ben documentati, ma anche VI che possiedono help online estesi
per l’utente.
Se selezionate Help»Show Context Help, compare la finestra Context
Help. Quando muovete il cursore su un oggetto, la finestra Context Help
si modifica per mostrarne la descrizione. Potete da programma mostrare o
nascondere la finestra Context Help con le funzioni Get Help Window
Status e Control Help Window, che trovate nella palette
Functions»Application Control»Help.
Utilizzate questa funzione per determinare se la finestra Context Help è
visibile e la posizione dell’angolo superiore sinistro della finestra.
Con questa funzione potete controllare la visibilità della finestra Context
Help e dove deve apparire nel caso venga mostrata.
Potete anche utilizzare la funzione Control Online Help per accedere a
LabVIEW Help o a file personalizzati di help che compilate utilizzando
strumenti di altri. Il tipo di strumenti di sviluppo per riferimenti online
che potete utilizzare per creare tale tipo di file dipende dalla piattaforma
su cui gira la vostra applicazione.
y
Windows - Microsoft Help (.hlp files)
y
Macintosh – QuickView
y
Sun/HP-UX – Hyper Help
5-17
Lezione 5
Con questa funzione potete gestire un file di help online. Potete elencare
il contenuto del file di help, passare alle parole chiave nel file, o chiudere
il file di help online.
Fornire help online e materiale di riferimento per la vostra applicazione
rende più facile utilizzarla e le conferisce un aspetto più pulito e
professionale.
Confronto di VI
Il LabVIEW Professional Development System comprende uno strumento
per determinare le differenze tra due VI caricati in memoria. Dal menu a
tendina di LabVIEW selezionate Tools»Compare»Compare VIs per
visualizzare la finestra di dialogo Compare VI.
Da questa finestra di dialogo potete selezionare i VI che volete
confrontare, così come le caratteristiche da verificare nei VI. Quando
confrontate i VI, entrambi saranno visualizzati, con una finestra
Differences che elenca tutte le differenze tra i due VI. In questa finestra
potete scegliere le differenze e i dettagli da visualizzare, che possono
essere cerchiati per chiarezza.
5-18
Lezione 5
Esercitazione 5-4
Obiettivo:
Esaminare alcune delle caratteristiche interne di LabVIEW per la gestione delle
applicazioni.
In questa esercitazione esplorerete alcune delle caratteristiche interne a
LabVIEW per la gestione delle applicazioni.
1. Aprite il VI Application Exercise(5-3) che avete creato
nell’esercitazione precedente. Chiudete ogni altro VI caricato in
memoria.
2. Selezionate Tools»VI Revision History. Appare la finestra della
storia del VI.
3. Cliccate su Reset nella finestra Revision History per cancellare la
storia presente. Cliccate su Yes per confermare la cancellazione e il
ripristino del numero di revisione.
4. Nel riquadro Comment della finestra History digitate Creata
l’applicazione iniziale e quindi cliccate sul pulsante Add. Il
vostro commento dovrebbe apparire nell’elenco Revision History,
insieme alla data e all’ora. Chiudete la finestra Revision History.
5. Selezionate Browse»Show VI Hierarchy. Compare la gerarchia
5-19
Lezione 5
6. Provate ad espandere e a comprimere la gerarchia. Notate che quando
cliccate sulle piccole frecce nere e rosse della gerarchia, si espandono
o si comprimono rami della gerarchia. Potreste vedere alcune icone
con una freccia rossa accanto, ad indicare che richiamano uno o più
subVI. Inoltre, potreste vedere anche delle icone con una freccia blu
accanto, che si presenta quando un subVI è chiamato da diversi posti
nell’ambito dell’applicazione, ma non tutte le chiamate sono
correntemente indicate nella gerarchia.
7. Esaminate il funzionamento dei pulsanti nella barra degli strumenti
della gerarchia. Notate come potete disporre la gerarchia utilizzando i
pulsanti Layout o trascinando le icone, oppure come potete includere
vari componenti dell’applicazione utilizzando i pulsanti Include.
Utilizzate Redo Layout per ridisegnare il layout della finestra per
minimizzare gli incroci tra linee e massimizzare la simmetria.
8. Cliccate due volte su ogni icona di subVI della gerarchia per
visualizzare il subVI appropriato. Chiudete il subVI che avete scelto e
chiudete la finestra della gerarchia.
nell’esercitazione 5-2, passate al pannello frontale del VI Application
Exercise(5-3) e quindi selezionate Tools»Compare»Compare VIs
per visualizzare la finestra di dialogo Compare VIs.
10. Utilizzando l’opzione Select, assicuratevi che i due Application
Exercise siano elencati nel riquadro VIs to Compare e che le opzioni
di Compare siano impostate come nell’esempio precedente.
11. Cliccate su Compare per visualizzare la finestra Differences e
affiancate i due VI. Contrassegnate il riquadro Circle Differences
nella finestra Differences. Quindi selezionate una differenza
dall’elenco, selezionate un dettaglio dall’elenco Details e quindi
cliccate su Show Detail. Viene evidenziata la differenza tra i due VI.
Esaminate le varie differenze tra i due VI e quindi chiudete la finestra
Differences.
5-20
Lezione 5
12. Chiudete Application Exercise(5-2).vi.
5-21
Lezione 5
C. Strumenti di LabVIEW per la gestione di progetti
Ci sono diversi strumenti che potete aggiungere nell’ambiente di
LabVIEW per avere assistenza nello sviluppo del progetto. La sezione
seguente descrive due di questi strumenti che sono inclusi nel LabVIEW
Professional Development System.
Strumenti di controllo del codice sorgente
Questi strumenti semplificano la gestione di applicazioni più grandi. La
prima caratteristica aggiunta con questi strumenti è un sistema per il
controllo del codice sorgente (SCC) che è fortemente integrato
nell’ambiente di LabVIEW. Questo sistema contiene molte caratteristiche
che si possono trovare in altri sistemi per il controllo del codice sorgente,
come la verifica dei file in ingresso e uscita, il tracciamento delle
revisioni e il supporto per utenti multipli. Inoltre gli strumenti SCC
possono supportare altri sistemi per il controllo del codice sorgente come
il Microsoft Visual SourceSafe. Tuttavia, come già detto precedentemente
in questa lezione, i VI di un progetto devono essere salvati come singoli
file (invece che all’interno di LLB) perché le caratteristiche di gestione
dei file dei vari sistemi operativi non supportano le librerie di LabVIEW.
Gli strumenti SCC contengono anche uno strumento VI Metrics per
misurare la complessità di un’applicazione analogo al diffuso Source
Lines of Code (SLOCs) per linguaggi testuali. Con lo strumento VI
Metrics potete visualizzare statistiche sui VI, come il numero di nodi
(funzioni, chiamate a subVI, strutture, terminali e così via) di un VI e dei
suoi subVI. Altre statistiche comprendono il numero e le dimensioni degli
schemi a blocchi, il numero e il tipo di interfacce utente, il numero di
accessi a variabili globali e locali e il numero di chiamate a Code
Interface Node o a librerie condivise. Avete accesso alla seguente finestra
VI Metric dal menu Tools»Advanced.
5-22
Lezione 5
E’ incluso in questo pacchetto anche uno strumento VI Library
Manager. Questa funzione vi consente di copiare, rinominare e
cancellare VI, sia che si trovino o meno in LLB. Il VI Library Manager
può anche convertire LLB esistenti in file in una subdirectory, per rendere
l’implementazione di strumenti SCC più semplice.
Sono incluse anche le funzioni Compare VIs e Compare VI
Hierarchies. Come descritto precedentemente, esse vengono usate per
determinare le differenze tra due VI o gerarchie.
Il LabVIEW Help e i manuali di questo pacchetto non solo forniscono
materiale di riferimento per le utility precedenti ma anche discussioni
estese sulla gestione di progetti software. Sono descritti in dettaglio vari
modelli di sviluppo, tecniche di sviluppo di prototipi e di progetto, e
metodi di tracciamento del progetto. Anche la documentazione dei VI e i
consigli per lo sviluppo di un codice chiaro sono descritti in dettaglio.
Application Builder di LabVIEW
Potete utilizzare l’Application Builder di LabVIEW per creare programmi
eseguibili indipendenti per utenti che non possiedono il software di
sviluppo di LabVIEW. I VI eseguibili o le librerie condivise possono
includere una gerarchia di VI che avete creato o il VI può essere
configurato per aprire ed avviare un VI qualsiasi per l’utente.
Configurazione di sistema necessaria
Le applicazioni o le librerie condivise che avete creato con l’Application
Builder generalmente avranno gli stessi requisiti del sistema di sviluppo
di LabVIEW. I requisiti di memoria varieranno in funzione delle
dimensioni dell’applicazione creata.
5-23
Lezione 5
Trasformazione della vostra applicazione in un eseguibile
indipendente
Prima di LabVIEW 5.1, il processo di creazione di un’applicazione
consisteva nel salvare i VI in una libreria, nel creare un’applicazione
utilizzando la finestra di dialogo Build Application e quindi di creare
l’installatore utilizzando la finestra di dialogo Create Distribution Kit.
In LabVIEW 5.1 potete utilizzare la finestra di dialogo Build Application
per svolgere tutte queste operazioni.
Quando selezionate Tools»Build Application or Shared Library (DLL)
compare una finestra di dialogo con dei tab. Effettuando le impostazioni
nelle varie pagine dei tab della finestra di dialogo, potete definire
l’applicazione che volete realizzare. Potete salvare uno script ed
utilizzarlo successivamente per ricostruire l’applicazione. La finestra di
dialogo Build Application or Shared Library contiene le seguenti
pagine sotto tab—Target, Source Files, VI Settings, Application
Settings e Installer Settings, come mostrato nell’esempio seguente.
y
Dal tab Target, potete definire se volete creare un eseguibile
indipendente o una libreria condivisa, il nome della vostra
applicazione e la directory in cui crearla. Opzionalmente, potete
scegliere di scrivere i subVI in un file esterno se volete mantenere
piccola l’applicazione principale.
y
Dal tab Source Files, potete definire i VI che fanno parte della vostra
applicazione. Quando cliccate su Add Top Level VI, aggiungete i VI
principali della vostra applicazione. Dovete selezionare solo i VI ad
alto livello e LabVIEW include automaticamente tutti i subVI e i file
collegati (come i file di menu o DLL). Se il vostro VI chiama
dinamicamente un qualsiasi subVI utilizzando il VI Server, LabVIEW
5-24
Lezione 5
non può rilevarlo automaticamente, quindi dovete aggiungerli
cliccando sul pulsante Add Dynamic VI. Se volete includere un
qualsiasi file dati nella vostra applicazione, cliccate sul pulsante Add
Support File, e i file dati verranno automaticamente copiati nella
directory della vostra applicazione.
y
Dal tab VI Settings definite le modifiche da effettuare ai vostri VI
come parte della realizzazione. Potete scegliere di disabilitare certe VI
Properties. Queste impostazioni si applicano solo al processo in corso
e non influenzano i vostri VI sorgente originali. LabVIEW crea
automaticamente la vostra applicazione la più piccola possibile
rimuovendo codice per le correzioni, schemi a blocchi e pannelli
frontali inutili. Se aprite un pannello frontale dinamicamente
utilizzando il VI Server, dovete specificare che il pannello frontale è
necessario utilizzando il tab VI Settings.
y
Dal tab Application Settings potete personalizzare le caratteristiche
della vostra applicazione. Potete scegliere di definire le dimensioni
della memoria per il Macintosh, o personalizzare icone e
caratteristiche di server ActiveX sotto Windows.
y
Dal tab Installer Settings (solo Windows) create un installatore.
L’installatore viene scritto sulla directory che contiene la vostra
applicazione.
Quando sviluppate un VI eseguibile con LabVIEW sotto Windows e lo
trasferite su un altro computer, dovete includere anche la DLL Run-Time
di LabVIEW. Il computer su cui viene eseguito il VI deve installare
questa DLL utilizzando Run-Time DLL Installer di LabVIEW prima
dell’esecuzione del VI. Se distribuite un VI utilizzando Build
Application, la DLL Run-Time viene eseguita automaticamente.
Dopo aver installato correttamente su una macchina la DLL Run-Time,
essa può eseguire un qualsiasi VI eseguibile sviluppato in LabVIEW. Dovete
includere solo la DLL Run-Time con il primo VI inviato su ciascun computer.
Nota
Creazione di applicazioni in LabVIEW
Per creare un’applicazione professionale indipendente con dei VI, dovete
aver chiari quattro aspetti:
y
L’architettura della vostra applicazione
y
Problemi di programmazione particolari dell’applicazione
y
Come realizzare la vostra applicazione
y
Come realizzare un installatore per la vostra applicazione
La prima sezione di questa lezione descrive l’architettura della vostra
applicazione ed ha realizzato l’applicazione nell’esercitazione. La vostra
applicazione è un unico VI a livello superiore che si avvia quando
lanciate l’applicazione e richiama pannelli frontali da diversi subVI,
5-25
Lezione 5
quando vengono chiamati. Questa è l’architettura più comune e più
semplice per la realizzazione di applicazioni indipendenti.
Aspetti della programmazione
Dovreste considerare diversi aspetti della programmazione quando state
realizzando VI che confluiranno in un’applicazione. Il primo aspetto da
conoscere è quale codice di uscita viene usato per l’applicazione. Per
esempio, state richiamando una qualche DLL di sistema o personalizzata
o delle librerie condivise? State per processare argomenti sulla linea di
comando? Questi sono esempi avanzati che vanno oltre lo scopo di questo
corso, ma li dovete considerare per l’applicazione.
Un secondo aspetto riguarda i nomi dei percorsi utilizzati nel VI. Un
esempio è quando utilizzate la capacità del VI Server di caricare
dinamicamente e di avviare i VI (questo viene descritto nel corso
LabVIEW Advanced I). Una volta che l’applicazione è stata costruita, i
VI vengono inclusi in un eseguibile. Supponete di avere un VI
denominato test.vi all’interno dell’applicazione test.exe. Una
richiesta di percorso in test.vi restituisce test.exe\test.vi con
tutto il percorso precedente di test.exe. Facendo attenzione a questi
aspetti imparerete a realizzare applicazioni più robuste in futuro.
Un ultimo aspetto da considerare che condizionerà l’applicazione che
avete realizzato è che il VI a livello superiore non esce da LabVIEW né
chiude i pannelli frontali dei VI quando ha completato l’esecuzione. Per
uscire completamente e chiudere il VI a livello superiore, dovete
utilizzare la funzione Quit LabVIEW che si trova nella palette
Functions»Application Control dello schema a blocchi del VI a livello
superiore.
Realizzazione dell’applicazione
Come già descritto in questa sezione, utilizzate l’Application Builder di
LabVIEW per creare un eseguibile o una libreria condivisa (DLL) per la
vostra applicazione. Questo corso descrive come realizzare un eseguibile
e il corso LabVIEW Advanced I descrive come realizzare ed utilizzare
una libreria condivisa (DLL).
L’Application Builder di LabVIEW può compattare la vostra
applicazione in una delle due forme—come un singolo eseguibile o come
singolo eseguibile con una libreria di VI. In funzione di come volete che
appaia la vostra applicazione all’utente finale, e di quanto complesso
possa essere il processo di installazione, potreste preferire un formato o
l’altro.
5-26
Lezione 5
Di default è prevista la compressione dell’applicazione in un singolo file
eseguibile. Tutti i VI che fanno parte dell’applicazione sono inclusi nel
file eseguibile. Questi comprendono i VI a livello superiore, i VI dinamici
e tutti i subVI relativi. Mentre questa compattazione è semplice perché
fornisce un singolo file, questi file possono diventare abbastanza grandi in
funzione del numero di VI facenti parte della vostra applicazione.
La seconda opzione di compressione consiste nello spezzare
l’applicazione in un file eseguibile e in una libreria di VI. In questo caso,
l’Application Builder include tutti i VI ad alto livello e i VI dinamici nel
file eseguibile risultante e tutti i subVI relativi vengono inseriti in
un’unica libreria di VI. Mentre questa compressione comprende due file,
il file che l’utente finale lancia può essere abbastanza piccolo.
A seconda della natura della vostra applicazione, può essere necessaria la
presenza di file che non sono VI per funzionare correttamente. I file
comunemente necessari comprendono un file di preferenze (.ini) per
l’applicazione, il file serpdrv di LabVIEW e altri file di help che i vostri
VI richiamano. Il file serpdrv di LabVIEW (Windows e Unix) è necessario
per ogni applicazione che utilizza la porta di I/O seriale. Notate che i file
di menu run-time e i file delle librerie condivise richiamate utilizzando il
Call Library Node non sono file di supporto. L’Application Builder
comprende file di menu run-time nei file principali dell’applicazione.
Esso memorizza automaticamente ogni libreria condivisa necessaria nella
directory dei file di supporto dell’applicazione. Anche le subroutine
esterne per CIN vengono memorizzate nei file principali
Nota Fate riferimento al LabVIEW Help in Help»Contents and Index per
ulteriori descrizioni su come utilizzare l’Application Builder e costruire un file
con le preferenze per la vostra applicazione.
Realizzazione dell’installatore
L’ultima fase della creazione di un’applicazione professionale
indipendente a partire dai vostri VI è quella di creare un installatore.
L’Application Builder di LabVIEW comprende le funzionalità per creare
installatori per Windows. Gli strumenti comuni per creare installatori su
Macintosh sono DragInstall e Vise. Sui sistemi Unix potete creare uno
script shell per installare la vostra applicazione. Gli installatori che create
con l’Application Builder di LabVIEW installano tutti i file che fanno
parte dell’elenco dei file sorgente. Dovete aggiungere a questo elenco tutti
i file che volete installare. Definendo destinazioni particolari ai file
sorgente, potete creare strutture a directory arbitrariamente complesse
all’interno della directory di installazione.
5-27
Lezione 5
Imparerete a conoscere le procedure e le opzioni dell’Application Builder
quando realizzerete un’applicazione nell’esercizio successivo. Dopo aver
definito le vostre specifiche utilizzando l’Application Builder, salverete
queste impostazioni su disco sotto forma di file di script (.bld).
5-28
Lezione 5
Esercitazione 5-5
Obiettivo:
La mia applicazione eseguibile
Creare un’applicazione indipendente con l’Application Builder.
Dovete avere l’Application Builder correttamente installato per avviare
questo esempio. Per stabilire se è installato, selezionate il menu Tools. Se
compare l’opzione Build Application or Shared Library (DLL) nel menu Tools,
allora l’Application Builder è correttamente installato.
Nota
Pannello frontale
nell’esercitazione 5-3. Modificate il pannello frontale per rimuovere i
commenti.
2. Selezionate File»VI Properties per visualizzare la finestra di dialogo
VI Properties. Selezionate Window Appearance dal menu a tendina
superiore, quindi selezionate Top-level Application Window. Questo
fornisce al pannello frontale un aspetto professionale quando viene
aperto come eseguibile.
3. Salvate il VI come Application Exercise.vi.
Schema a blocchi
4. Aprite lo schema a blocchi ed utilizzate i componenti seguenti.
a. Inserite la funzione not che si trova nella palette
Functions»Boolean. Questa funzione inverte il valore da inviare
al terminale condizionale del ciclo While. Quando il ciclo ha
terminato l’esecuzione, questo valore è False, quindi viene inviato
un True sul bordo del ciclo per la funzione Quit LabVIEW.
5-29
Lezione 5
b. Inserite la funzione Quit LabVIEW che si trova nella palette
Functions»Application Control. Questa funzione fa uscire da
LabVIEW e dall’applicazione dopo che è stata realizzata.
5. Salvate il VI come Application Exercise.vi.
6. Aprite il pannello frontale ed avviate il VI. Quando selezionate il
pulsante Stop, il VI si arresta ed uscite da LabVIEW.
7. Riavviate LabVIEW e aprite un nuovo VI. Non aprirete il VI
Application Exercise perché l’Application Builder non può creare un
eseguibile se dei VI sono caricati in memoria.
8. Selezionate Tools»Build Application or Shared Library (DLL).
Realizzate un eseguibile a partire da Application Exercise.vi
denominato myApplication.exe ed inseritelo nella directory
c:\myapp. Modificate il tab Target come segue.
5-30
Lezione 5
9. Cliccate sul tab Source Files e selezionate il pulsante Add Top-Level
VI. Aggiungete Application Exercise.vi come mostrato.
10. Cliccate sul tab VI Settings. Lasciate queste impostazioni sui valori di
default—il VI a livello superiore si avvia quando viene aperto e gli
schemi a blocchi e i pannelli frontali vengono salvati solo se
necessario. Esaminate queste impostazioni; dovrebbero essere simili
agli esempi seguenti.
11. Cliccate sul tab Application Settings. Qui è dove dovreste abilitare le
impostazioni di ActiveX o fornire un’icona personalizzata alla vostra
applicazione. Lasciate l’icona di default di LabVIEW. Non cambiate
queste impostazioni.
5-31
Lezione 5
12. Cliccate sul tab Installer Settings. Realizzate un kit per la
distribuzione della vostra applicazione che si installa nella directory
c:\Program Files\Myapplication. Configurate il tab Installer
come indicato.
13. Cliccate sul pulsante Build. I file associati all’installatore vengono
quindi compressi in dischetti di setup, che sono memorizzati nella
directory c:\myapp\installer\disks. Viene anche creato un file
Setup.exe, che può essere utilizzato per installare le immagini del
dischetto. Tutti questi file possono essere copiati su dischetti per
trasferire l’applicazione su un altro sistema. L’installatore LabVIEW
Run-Time DLL è incluso di default. Viene anche creato l’eseguibile
della vostra applicazione e chiamato myApplication.exe, come
specificato nel tab Target.
14. Selezionate Done dalla finestra Build Application per chiudere questa
funzione. Vi viene chiesto di salvare uno script affinché possiate
realizzare nuovamente l’applicazione. Selezionate Yes e chiamate lo
script myapp.bld. Ora se effettuate dei cambiamenti all’applicazione
originale e volete ricostruire un eseguibile e un installatore con le
stesse impostazioni, potete aprire questo script utilizzando il pulsante
Load.
15. Avviate myApplication.exe dalla directory c:\myapp.
Application Exercise dovrebbe aprire il proprio pannello frontale ed
avviarsi automaticamente. Fate lavorare il VI per essere sicuri che
tutte le impostazioni che avete scelto siano operative. Chiudete
l’applicazione quando avete finito.
5-32
Lezione 5
16. Avviate
il
file
Setup.exe
nella
directory
c:\myapp\disks\Myapplication. Dovreste essere guidati
attraverso il processo di setup, l’eseguibile è creato all’interno della
directory c:\Program Files\Myapplication, e dovreste essere
in grado di avviare l’applicazione da Programs».
5-33
Lezione 5
y
LabVIEW possiede diverse caratteristiche per assistere voi e i vostri
collaboratori nello sviluppo di progetti, come la finestra VI Revision
History per registrare commenti e modifiche ad un VI, e un login
utente che, quando è usato con VI Revision History, registra chi ha
fatto i cambiamenti sul VI. Potete accedere alla finestra VI Revision
History in un qualsiasi momento selezionando VI Revision History
dal menu Tools.
y
La finestra VI Hierarchy vi fornisce una panoramica rapida e sintetica
dei VI utilizzati nel vostro progetto. C’è anche la possibilità di
confrontare due VI per verificarne le differenze.
y
LabVIEW fornisce diversi strumenti per facilitare lo sviluppo di
grandi progetti. Gli strumenti Source Code Control contengono
diverse funzioni per la gestione del codice di LabVIEW, e
l’Application Builder vi consente di creare eseguibili indipendenti o
librerie condivise (DLL). Entrambi questi pacchetti sono inclusi nel
LabVIEW Professional Development System.
y
La creazione di un’applicazione professionale indipendente con i
vostri VI avviene attraverso la comprensione dei seguenti aspetti:
− L’architettura della vostra applicazione.
− Gli aspetti di programmazione particolari dell’applicazione.
− Il processo di costruzione dell’applicazione.
− Il processo di realizzazione dell’installatore.
5-34
Lezione 5
Esercizi aggiuntivi
5-6
Modificate il VI Application Exercise affinché i pulsanti Acquire
Data, Analyze & Present Data e View Analysis File siano
disabilitati e resi opachi se l’utente non ha inserito nome e password
corretti.
Consiglio: Utilizzate i riferimenti di controllo e il VI Disable
Controls che avete realizzato nell’esercitazione 2-8 per modificare i
pulsanti.
Salvate l’applicazione come Application Exercise(5-6).vi.
5-7
Aggiungete un pulsante al controllo del cluster dei menu nel VI
Application Exercise affinché l’utente possa mostrare o nascondere
la finestra di Help di LabVIEW. Il testo del pulsante dovrebbe
indicare cosa succede quando l’utente clicca sul pulsante, per
esempio, Mostra Help e Nascondi Help. Se vi accorgete che i
pulsanti e gli indicatori del pannello frontale non hanno descrizioni
nella finestra Context Help, dovete aggiungerli nella finestra di
dialogo rapida Description and Tip per ogni controllo e indicatore.
Assicuratevi che il VI tracci correttamente lo stato della finestra
Context Help. Per esempio, se l’utente clicca sul pulsante Show
Help per mostrare la finestra Context Help, ma chiude la finestra
Context Help dal menu Help»Show Context Help, il vostro VI
assume erroneamente che la finestra Context Help è in
visualizzazione. Salvate questo VI come Application
Exercise(5-7).vi.
Nota Utilizzate un Property Node per impostare il testo del pulsante. L’azione
meccanica del pulsante dovrebbe essere Latch When Released. Utilizzate un
registro a scorrimento per ricordare lo stato della visibilità della finestra
Context Help e utilizzate la funzione Control Help Window per mostrare e
nascondere la finestra Context Help.
5-35
Lezione 5
Note
5-36
Lezione 6
Questa lezione descrive come ottimizzare le prestazioni dei vostri VI e
anche come aumentare la velocità di esecuzione e migliorare l’utilizzo
della memoria.
Imparerete:
A. A conoscere il multithreading e il multitasking di LabVIEW.
B. Ad utilizzare la finestra Profile.
C. A velocizzare i vostri VI.
D. A conoscere quali aspetti della memoria di sistema influenzano le
prestazioni di LabVIEW.
E. Ad ottimizzare l’utilizzo della memoria e le prestazioni relative dei
singoli VI.
6-1
Lezione 6
A. Panoramica sul multithreading e il multitasking in LabVIEW
In LabVIEW 4 e versioni precedenti, potevate avviare diversi VI
contemporaneamente e i VI rispondevano ancora agli ingressi utente da
cursore o da tastiera. Per ottenere questo, il sistema di esecuzione
utilizzava il multitatsking cooperativo—ogni attività differente processata
una alla volta e a rotazione. Il multitatsking cooperativo funziona bene,
ma il tempo del processore non è equamente distribuito su ogni attività.
Eseguire una routine computazionale lunga o visualizzare una grande
quantità di dati su un grafico può utilizzare una quantità spropositata di
tempo del processore. Le attività vengono eseguite a turno dal processore,
e una lunga attività non viene frazionata in parti più piccole, più brevi.
Con questa architettura, compiti multipli venivano eseguiti nel sistema
sotto un singolo thread, o processo.
Le versioni di LabVIEW dalla 5.0 in poi, supportano il multithreading.
Con il multithreading parti diverse di un’applicazione possono essere
eseguite sotto diversi thread, o processi, in un computer. Questa
architettura consente al sistema operativo di appropriarsi di un thread di
esecuzione per fornire tempo di processore ad un altro thread. In tal modo
il tempo della CPU viene più equamente condiviso tra i thread.
Per sfruttare il multithreading, utilizzate LabVIEW 5.0 o successivi su un
sistema operativo che supporta il multithreading come Windows, Solaris 2 o
Concurrent PowerMax. Su sistemi operativi che non supportano il
multithreading, LabVIEW continua a funzionare con il multitasking
cooperativo.
Di default LabVIEW sfrutta il multithreading se il sistema operativo lo
supporta. Se volete verificare se il multithreading è abilitato, selezionate
Performance and Disk dal menu a tendina superiore nella finestra di
dialogo Tools»Options. Potete contrassegnare o meno il riquadro
etichettato con Run with multiple threads.
6-2
Lezione 6 Controllo delle prestazioni
Questa opzione è disponibile solo su sistemi operativi che supportano il
multithreading. Se rimuovete il contrassegno dal riquadro, il sistema di
esecuzione si comporta come se voi aveste un unico thread. L’esecuzione
di un singolo thread rimuove alcune sovrapposizioni dal sistema di
esecuzione. Tuttavia non beneficiate dei vantaggi del multithreading,
come il supporto multiplo del processore e la possibilità, per
un’operazione di priorità più alta, di interrompere un’operazione lunga,
come una schermata da rinfrescare per ottenere una risposta migliore
dall’applicazione. Rimuovete il contrassegno per VI che non sono
compatibili con un sistema di esecuzione multithreading.
Vantaggi
Un vantaggio importante del multithreading in LabVIEW è la separazione
dell’interfaccia utente dall’esecuzione dello schema a blocchi. Ogni
attività condotta nell’interfaccia utente, come il disegno del pannello
frontale, la risposta ai click del mouse e così via, opera nel proprio thread.
Ciò impedisce all’interfaccia utente di sottrarre tempo di esecuzione al
codice dello schema a blocchi. In tal modo la visualizzazione di una
grande quantità di in formazioni su un grafico non impedisce l’esecuzione
del codice dello schema a blocchi. Inoltre, l’esecuzione di una lunga
routine computazionale non impedisce all’interfaccia utente di rispondere
ai click del mouse o a digitazioni su tastiera.
I computer con processori multipli beneficiano ancora di più del
multithreading. Su un sistema a singolo processore, il sistema operativo si
impadronisce dei thread e distribuisce sul processore il tempo di ogni
thread. Su un computer a processori multipli, i thread possono essere
eseguiti su più processori contemporaneamente, e quindi più di un’attività
può essere svolta nello stesso istante.
6-3
Lezione 6
Utilizzo del multithreading
Quando un’applicazione esistente di LabVIEW è in esecuzione, sfrutta
automaticamente il sistema del multithreading senza dover effettuare
modifiche all’applicazione. Tuttavia, lavorando con più VI, ci sono
diverse classificazioni di thread, chiamate sistemi di esecuzione,
disponibili per organizzare la vostra applicazione. Ci sono sei sistemi di
esecuzione disponibili per avviare VI:
y
User Interface
y
Standard
y
Instrument I/O
y
Data Acquisition
y
Other 1
y
Other 2
Lo scopo di avere alcuni sistemi di esecuzione differenti è di fornire
partizioni diverse per VI che devono essere eseguiti indipendentemente da
altri VI. Di default, i VI vengono eseguiti con il sistema di esecuzione
Standard, che consente l’esecuzione in thread separati dall’interfaccia
utente. Il sistema di esecuzione Instrument I/O è incluso per evitare che
VISA, GPIB e I/O seriale interferiscano con altri VI. Analogamente, il
sistema di esecuzione Data Acquisition viene impostato per i VI DAQ.
Anche se i VI che voi scrivete saranno eseguiti correttamente se lasciate
impostata la modalità di esecuzione Standard, potreste aver bisogno di
spostare determinati VI su sistemi di esecuzione diversi. Per esempio, se
state sviluppando driver per gli strumenti, potreste impostare la modalità
di esecuzione dei vostri VI su Instrument I/O.
Per cambiare la categoria del thread in cui un VI viene eseguito,
selezionate Execution dal menu a tendina superiore della finestra di
dialogo VI Properties.
6-4
Il riquadro Preferred Execution System elenca le categorie disponibili di
sistemi di esecuzione. Potete anche creare delle priorità su compiti
paralleli in un ambiente che opera in multithread impostando la Priority
del VI. All’interno di ogni categoria di thread, potete definire la priorità di
esecuzione—normal, above normal, high, time critical, subroutine e
background. La priorità normal coincide con la priorità a livello 1 e così
via. Se ci sono più VI, i VI vengono disposti in coda di esecuzione. I VI
con priorità più alta, eccetto la priorità subroutine, verranno eseguiti
prima di quelli aventi priorità più bassa. Tuttavia, i VI con un livello di
priorità subroutine si comportano in maniera diversa rispetto ai VI con
altri livelli di priorità. Quando un VI è in esecuzione con una priorità
subroutine, viene eseguito nella categoria di thread del suo chiamante e
nessun altro VI può trovarsi in esecuzione fino a quando quel VI o i suoi
subVI hanno terminato. I VI con una priorità subroutine possono
chiamare solamente altri VI con priorità subroutine. Utilizzate VI con una
priorità subroutine solo quando volete mandare in esecuzione un semplice
calcolo senza elementi interattivi. Potete saltare l’esecuzione di un subVI
con priorità subroutine quando esso è occupato, cliccando con il tasto
destro del mouse sul subVI e selezionando Skip Subroutine Call if
Busy. Utilizzate questa opzione quando state chiamando una subroutine
condivisa da un VI con priorità high ma non volete aspettare che un VI
subroutine diventi disponibile.
Fate attenzione quando impostate i livelli di priorità per i VI. Utilizzare
delle priorità per controllare l’ordine di esecuzione potrebbe non produrre
i risultati sperati. Per esempio, se utilizzate l’impostazione delle priorità
in maniera non corretta, i compiti con priorità più bassa potrebbero non
essere mai eseguiti. Come vedrete più avanti in questa lezione, l’uso
strategico delle funzioni Wait all’interno dei VI può anche essere un
modo molto efficace di ottimizzazione del codice in LabVIEW. Fate
riferimento a LabVIEW Help per ulteriori informazioni su come utilizzare
le funzioni Wait.
6-5
Lezione 6
B. La finestra Profile
La finestra Profile è uno strumento potente per analizzare come la vostra
applicazione utilizza il tempo di esecuzione e la memoria. Con queste
informazioni potete individuare VI specifici o parti di VI che hanno
bisogno di essere ottimizzati. Per esempio, se notate che un particolare
subVI impiega una grande quantità di tempo ad aggiornare il display,
potete focalizzare la vostra attenzione sul miglioramento delle prestazioni
del display di quel VI.
La finestra Profile visualizza le informazioni sulle prestazioni di tutti i VI
in memoria sotto forma di tabella interattiva. Dalla finestra potete
scegliere il tipo di informazione da prendere e ordinare le informazioni
per categoria. Potete anche monitorare le prestazioni dei subVI all’interno
di differenti VI. Per mostrare la finestra Profile, selezionate
Tools»Advanced»Profile VIs. Compare la finestra seguente.
Notate che dovete selezionare l’opzione Profile Memory Usage prima di
avviare una sessione per il profilo. Raccogliere informazioni sull’utilizzo
della memoria da parte dei VI aggiunge una quantità di calcolo
significativa all’esecuzione del VI, che influenza l’accuratezza di ogni
statistica temporale che raccogliete durante la sessione per il profilo. Per
questo dovreste eseguire profili per la memoria separati da quelli sul
tempo.
Molte delle opzioni nella finestra Profile sono disponibili solo dopo che
avete iniziato una sessione. Durante una sessione, potete catturare
un’istantanea dei dati disponibili e salvare i dati in ASCII su un foglio
elettronico. Le misure di tempo si accumulano ogni volta che eseguite un
VI.
Tutte le statistiche misurate in una sessione di profilo sono raccolte per
un’esecuzione completa di un VI, non per un’esecuzione parziale.
Nota
6-6
Statistiche sul tempo di esecuzione
Per avere statistiche sul tempo di esecuzione con la finestra Profile,
cliccate sul pulsante Start. L’esempio precedente mostra la finestra
Profile dopo una sessione di profilo.
La colonna di statistiche su VI Time mostra il tempo speso
nell’esecuzione del VI e nella visualizzazione dei suoi dati, come anche il
tempo speso dall’utente ad interagire con il pannello frontale. Questo
tempo consiste in cinque sottocategorie, che potete mostrare selezionando
l’opzione Timing Details. Le sottocategorie sono Diagram, Display,
Draw, Tracking e Locals. Fate riferimento a LabVIEW Help o a LabVIEW
User Manual per ulteriori informazioni su queste statistiche.
La colonna di statistiche SubVI mostra il tempo di esecuzione totale per
tutti i subVI richiamati dal VI principale. Inoltre le informazioni sui tempi
possono essere visualizzate in secondi, millisecondi o microsecondi.
La colonna di statistiche Total Time rappresenta il tempo di esecuzione
totale per il VI principale come somma dei valori dei VI e dei subVI.
Se selezionate l’opzione Timing Statistics, compaiono quattro nuove
categorie di informazioni. # Runs visualizza quante volte ogni VI è stato
eseguito. Il valore Average rappresenta il valore del tempo del VI diviso
per # Runs, o la media del tempo impiegato da un VI in esecuzione.
Shortest e Longest mostrano la più piccola e la più grande quantità di
tempo necessaria per l’esecuzione del VI.
Statistiche sulla memoria
Per avere statistiche sulla memoria con la finestra Profile, selezionate
l’opzione Profile Memory Usage prima di avviare la sessione dei profili.
Potete anche selezionare l’opzione Profile Memory Usage dopo aver
avviato il Profiler per avere informazioni aggiuntive sulla memoria.
La finestra Profile visualizza due insiemi di dati sull’uso della memoria.
Un insieme di dati mostra il numero di byte di memoria utilizzati, e l’altro
mostra i blocchi della memoria. LabVIEW memorizza i dati come
matrici, stringhe e percorsi in blocchi contigui di memoria. Se un VI
utilizza un gran numero di blocchi di memoria, la memoria può
frazionarsi, il che degrada le prestazioni di LabVIEW in generale, non
l’esecuzione del VI.
La colonna di statistiche Average Bytes mostra il numero medio di byte
di memoria utilizzati da uno spazio dati di un VI durante la sua
esecuzione. Min Bytes e Max Bytes rappresentano la più piccola e la più
grande quantità di memoria utilizzata da un VI durante una singola
esecuzione. Average Blocks indica quanti blocchi di memoria servono ad
un VI in media, mentre Min Blocks e Max Blocks mostrano il più
6-7
Lezione 6
piccolo e il più grande numero di blocchi di memoria utilizzati da un VI
durante una singola esecuzione.
6-8
Esercitazione 6-1
Obiettivo:
La finestra Profile
Utilizzare la finestra Profile per avere informazioni su come la vostra applicazione
viene eseguita.
La finestra Profile è uno strumento potente per analizzare come la vostra
applicazione utilizza il tempo di esecuzione e la memoria. Con queste
informazioni, potete individuare le aree del vostro VI che necessitano di
ottimizzazione. In questa esercitazione esaminate il progetto appena
completato utilizzando la finestra Profile.
1. Aprite il vostro progetto definitivo, denominato CD Application
Exercise VI. Se non avete completato il progetto potete aprire la
soluzione.
2. Prima di eseguire il vostro progetto definitivo, selezionate
Tools»Advanced»Profile VIs per visualizzare la finestra Profile. La
finestra Profile non sta ancora acquisendo dati.
6-9
Lezione 6
3. Per raccogliere informazioni sui tempi del vostro progetto definitivo,
contrassegnate il riquadro Timing Statistics e cliccate sul pulsante
Start.
Ora state raccogliendo informazioni sui tempi dei VI in memoria.
6-10
4. Avviate il VI CD Application Exercise e lavorate come se foste un
utente tipico. In un qualsiasi momento potete tornare alla finestra
Profile per fotografare i tempi. Effettuare uno Snapshot non influenza
le statistiche temporali finali.
5. Quando avete finito di lavorare con il vostro progetto, tornate alla
finestra Profile e cliccate nuovamente sul pulsante Snapshot. Potete
ordinare ogni colonna di dati cliccando sull’intestazione di colonna.
Potete anche scegliere di visualizzare le statistiche temporali in
secondi, millisecondi o microsecondi. Cliccando due volte sui VI
elencati nella finestra Profile, potete visualizzare le statistiche dei VI
che lo compongono. Ciò vi consente di esaminare i subVI per vedere
il tempo impiegato. Potete visualizzare il pannello frontale dei singoli
VI cliccando con il tasto destro del mouse sui VI elencati nella
finestra Profile.
Ordinate la colonna Total Time e osservate dove il VI CD Application
Exercise impiega la maggior parte del suo tempo. Notate come quei
VI corrispondono ai VI che richiedono interazione con l’utente.
L’attesa di un ingresso dell’utente è spesso la parte dell’esecuzione
che richiede più tempo.
Nella finestra Profile potete catturare statistiche temporali e
informazioni sull’uso della memoria da parte dei VI. Per avere
informazioni sull’uso della memoria, contrassegnate il riquadro
Profile Memory Usage.
La raccolta di informazioni sull’uso della memoria da parte dei VI
richiede sovrapposizioni che possono alterare le statistiche temporali.
Nota
6-11
Lezione 6
6. Raccogliete statistiche sull’uso della memoria da parte del VI CD
Application Exercise.
Dove viene utilizzata la memoria e perché?
Osservate quali VI frazionano la memoria, e quali VI utilizzano molti
blocchi. Perché questi VI utilizzano i blocchi? L’aver frazionato la
memoria provoca l’esecuzione più lenta dei VI perché spostare i dati nella
memoria è dispendioso.
6-12
C. Velocizzare i VI
LabVIEW compila i vostri VI e genera un codice che generalmente viene
eseguito molto rapidamente. Tuttavia, quando si lavora su applicazioni
critiche dal punto di vista temporale, dovete utilizzare particolari tecniche
di programmazione per ottenere la migliore velocità di esecuzione
possibile. Considerate le seguenti tre problematiche quando volete
velocizzare i vostri VI:
y
Input/Output—file, controllo di strumenti, acquisizione dati e
collegamento in rete
y
Visualizzazione di schermate—controlli e schermate efficienti
y
Gestione della memoria—uso efficiente di matrici, stringhe e strutture
di dati
Altri fattori, come il tempo di esecuzione e quello di chiamata di subVI,
di solito hanno effetti minimi sulla velocità di esecuzione.
Input/Output
Chiamate di Input/Output (I/O) generalmente richiedono più tempo di
un’operazione computazionale. Per esempio, una semplice operazione di
lettura su una porta seriale può richiedere diversi millisecondi. Questo
dispendio è presente non solo in LabVIEW, ma anche in altre
applicazioni. Il motivo di ciò è che una chiamata di I/O comprende il
trasferimento di informazioni attraverso diversi livelli di un sistema
operativo.
Il metodo migliore per ridurre questo dispendio di risorse in I/O è di
minimizzare il numero di chiamate di I/O nella vostra applicazione.
Strutturate la vostra applicazione in maniera tale da trasferire grandi
quantità di dati ad ogni chiamata, invece di effettuare parecchie chiamate
che trasferiscono piccole quantità di dati.
Per esempio, considerate la creazione di un’applicazione di acquisizione
dati (DAQ) che acquisisca 100 punti di dati. Per un’esecuzione più rapida,
utilizzate una funzione di trasferimento dati di più punti come il VI AI
Acquire Waveform, invece di utilizzare una funzione di trasferimento di
un punto singolo come il VI AI Sample Channel. Per acquisire 100 punti,
utilizzate VI AI Acquire Waveform con un ingresso che specifica che
volete 100 punti. Ciò è più veloce che utilizzare il VI AI Sample Channel
in un ciclo con una funzione di attesa per stabilire la temporizzazione.
6-13
Lezione 6
Trasferimento dati di singoli punti
(Metodo più lento)
Trasferimento dati di più punti
(Metodo più veloce)
Nell’esempio precedente, il dispendio di risorse del VI Acquire
Waveform è grosso modo lo stesso di una singola chiamata al VI AI
Sample Channel, anche se sta trasferendo molti più dati. Inoltre, i dati
vengono raccolti dal VI Acquire Waveform utilizzando temporizzatori
hardware per controllare il campionamento. Chiamando il VI AI Sample
Channel in un ciclo non consente una raccolta di dati ad una velocità di
campionamento costante.
Schermate
L’aggiornamento dei controlli su un pannello frontale è un altro compito
dispendioso dal punto di vista temporale in un’applicazione. Mentre il
multithread aiuta a ridurre l’effetto che gli aggiornamenti del display
hanno sul tempo di esecuzione complessivo, display complicati, come i
grafici possono influenzare negativamente il tempo di esecuzione. Questo
effetto può diventare significativo su piattaforme di LabVIEW che non
supportano il mutlithreading. Sebbene molti indicatori non vengano
ridisegnati quando ricevono dati che coincidono con i dati precedenti, i
grafici vengono sempre ridisegnati. Per minimizzare questo spreco di
risorse, mantenete semplici i display del pannello frontale e provate a
ridurre il numero di oggetti del pannello frontale. Si aumenta l’efficienza
dei grafici disabilitando l’autoscaling, i marcatori di scala e le griglie.
Anche il progetto dei subVI può ridurre sprechi di visualizzazione. Se i
subVI hanno pannelli frontali che rimangono chiusi durante l’esecuzione,
nessuno dei controlli del pannello frontale può influenzare la velocità di
esecuzione complessiva del VI.
Come mostrato nello schema a blocchi seguente, potete ridurre gli sprechi
di visualizzazione minimizzando il numero di volte che il vostro VI
aggiorna il display. Disegnare i dati sullo schermo è un’operazione di I/O,
simile all’acceso ad un file o ad uno strumento GPIB. Per esempio, potete
aggiornare un grafico tipo waveform un punto alla volta, o diversi punti
alla volta. Ottenete velocità di visualizzazione dei dati molto più alte se
raccogliete i vostri dati su matrici, potendo così visualizzare diversi punti
alla volta. In tal modo riducete la quantità di tempo richiesta dall’I/O per
aggiornare l’indicatore.
6-14
Aggiornamento singolo del
grafico (Metodo più lento)
Aggiornamento multiplo del
grafico (Metodo più veloce)
Altre problematiche
Impegno risorse dei subVI
Ogni chiamata ad un subVI richiede un certo dispendio di risorse. Questo
dispendio è relativamente piccolo, dell’ordine delle decine di
microsecondi, specialmente in confronto al tempo necessario per l’I/O e il
display, che possono richiedere dai millisecondi alle decine di
millisecondi. Tuttavia, se voi fate 10000 chiamate ad un subVI in un
ciclo, l’impegno potrebbe influenzare in maniera significativa la vostra
velocità di esecuzione. In questo caso, potreste considerare di includere il
ciclo nel subVI.
Un altro modo di minimizzare l’impegno di risorse dei subVI è di
trasformare i vostri subVI in subroutine selezionando Execution dal
menu a tendina superiore nella finestra di dialogo File»VI Properties.
Tuttavia ci sono degli inconvenienti. Le subroutine non possono
visualizzare i dati del pannello frontale, chiamare funzioni di
temporizzazione o di finestre di dialogo o andare in multitask con altri VI.
Le subroutine sono generalmente più adatte per VI che non richiedono
interazione con l’utente e costituiscono piccoli compiti eseguiti
frequentemente.
Calcoli superflui nei cicli
Evitate l’inserimento di calcoli nei cicli se il calcolo produce lo stesso
valore per ogni iterazione. Spostate il calcolo all’esterno del ciclo e
passate il risultato all’interno del ciclo. Per esempio considerate i due
schemi a blocchi seguenti. Il risultato della divisione è lo stesso in ogni
iterazione del ciclo, quindi potete migliorare le prestazioni spostando la
divisione all’esterno del ciclo.
Calcolo superfluo nel ciclo
(Metodo più lento)
6-15
Solo calcoli necessari nel ciclo
(Metodo più veloce)
Lezione 6
Inoltre evitate di accedere a variabili locali e globali nei cicli quando non
è necessario. Per esempio, lo schema a blocchi seguente spreca tempo
leggendo dalla variabile globale e scrivendoci sopra durante ogni
iterazione del ciclo. Se sapete che la variabile globale non viene letta o
scritta da un altro schema a blocchi durante il ciclo, considerate l’utilizzo
di registri di scorrimento per memorizzare dati, come mostrato nel
secondo schema a blocchi.
Accessi frequenti alla variabile
globale (Metodo più lento)
Accessi minimizzati alla variabile
globale (Metodo più veloce)
Notate che avete bisogno dei registri a scorrimento per passare un nuovo
valore dal subVI all’iterazione successiva del ciclo. Gli utenti principianti
di LabVIEW spesso omettono questi registri a scorrimento. Senza un
registro a scorrimento, i risultati del subVI non vengono passati indietro
al subVI come nuovo valore di ingresso, come mostrato nello schema a
blocchi seguente.
Nello schema a blocchi precedente, la variabile globale viene letta una
volta prima dell’inizio del ciclo e lo stesso valore viene passato alla
funzione 10000 volte. Il risultato del ciclo è lo stesso di quello che avreste
ottenuto scrivendo il codice come nello schema a blocchi seguente.
6-16
Schemi in parallelo
Quando diversi cicli vengono eseguiti in parallelo sullo schema a blocchi,
LabVIEW elabora i cicli alternativamente. Se alcuni di questi cicli sono
meno importanti di altri, dovreste utilizzare la funzione Wait (ms) per
garantire che i cicli meno importanti utilizzino meno tempo. Considerate
per esempio lo schema a blocchi seguente.
I due cicli vengono eseguiti in parallelo. Uno dei cicli acquisisce i dati e
deve essere eseguito il più frequentemente possibile. L’altro ciclo
monitora l’ingresso dell’utente. In tal modo entrambi i cicli prendono lo
stesso tempo. Il ciclo che monitora l’utente può essere eseguito diverse
centinaia di volte al secondo. In realtà questo ciclo avrebbe bisogno di
essere eseguito solo alcune volte al secondo, perché l’utente non può
effettuare cambiamenti sull’interfaccia molto rapidamente. Come
mostrato nello schema a blocchi seguente, potete richiamare la funzione
Wait (ms) nel ciclo dell’interfaccia utente per lasciare molto più tempo di
esecuzione all’altro.
6-17
Lezione 6
Esercitazione 6-2
VI Charting Benchmark Example
Obiettivo: Osservare le velocità relative di un grafico a punti singoli e a punti multipli
utilizzando la finestra Profile e gli effetti del multithreading su sistemi che
supportano questa caratteristica.
Quando aprite il VI Charting Benchmark Example, due altri pannelli
frontali di subVI vengono aperti. Questi due subVI rappresentano gli
stessi dati in condizioni differenti.
Pannelli frontali
1. Se state eseguendo LabVIEW su un sistema operativo che supporta il
multithreading (Windows, Solaris2, o Concurrent PowerMAX), completate
i passi da a a c. Se siete su un sistema che non supporta il multithread,
andate al passo 2.
a. Configurate LabVIEW in maniera tale che non utilizzi il
multithreading quando esegue i VI. Selezionate Tools»Options
per visualizzare la finestra di dialogo Options.
b. Dal menu a tendina superiore della finestra di dialogo Options
selezionate Performance and Disk. Nella sezione Performance
and Disk, rimuovete il contrassegno dal riquadro Run with
multiple threads. Cliccate su OK.
c. Uscite e riavviate LabVIEW affinché siano attivi gli
aggiornamenti nelle preferenze. LabVIEW ora è configurato per
eseguire VI in un singolo thread, utilizzando il multitasking
cooperativo.
6-18
2. Chiudete tutti gli altri VI che potrebbero essere aperti.
3. Aprite il VI Charting Benchmark Example. Il VI è già realizzato.
Quando lo aprite, si aprono anche altri due VI.
Il VI Charting Benchmark Example genera una matrice di 1000
numeri casuali. Quando cliccate sul pulsante Run SubVIs, i due
subVI vanno in esecuzione. Il subVI Update Chart 1 Point at a Time
aggiorna il grafico 1000 volte. Il secondo subVI Update Chart 50
Points at a Time aggiorna il grafico 20 volte, visualizzando 50 punti
alla volta. Selezionate Tools»Advanced»Profile VIs.
4. Spostate la finestra affinché non si sovrapponga agli altri pannelli
frontali.
5. Cliccate sul pulsante Start nella finestra Profile. Vedete nella tabella
le statistiche VI Time, SubVIs Time e Total Time.
6. Avviate il VI Charting Benchmark Example. Il VI non fa niente
finché non cliccate sul pulsante Run SubVIs. Avviate i subVI almeno
tre o quattro volte. Quindi cliccate sul pulsante Quit per arrestare il VI
Charting Benchmark Example.
7. Dopo aver avviato i subVI diverse volte, cliccate sul pulsante
Snapshot nella finestra Profile. Individuate il VI Charting
Benchmark Example nella finestra Profile e cliccate due volte su di
esso per visualizzare i due subVI. Ricordate che sono tempi cumulati,
non le quantità di tempo necessarie per eseguire i sub VI una volta.
Notate che l’aggiornamento del grafico un punto alla volta è il metodo
più lento e che l’aggiornamento del grafico con diversi punti alla volta
è il metodo più rapido.
6-19
Lezione 6
8. Selezionate l’opzione Timing Statistics per visualizzare il tempo di
esecuzione medio per i subVI. Quindi selezionate l’opzione Timing
Details ed esaminate le statistiche Display e Draw. Notate che il
tempo di Display è superiore per il subVI Update Chart 1 Point at a
Time ed è molto basso per il subVI Update Chart 50 Points at a Time.
Registrate il tempo di esecuzione medio nella tabella seguente.
Fate riferimento a LabVIEW Help o a LabVIEW User Manual per
ulteriori informazioni sulle statistiche.
9. Cliccate sul pulsante Stop nella finestra Profile per arrestare la
sessioni sui profili. Quindi chiudete la finestra Profile.
10. Chiudete tutti i VI aperti e non salvate i cambiamenti.
11. Se state eseguendo LabVIEW su un sistema operativo con
multithreading, contrassegnate il riquadro Run with multiple threads
nella pagina Performance and Disk di Tools»Options e riavviate
LabVIEW. Ripetete i passi da 3 a 10, notando nella tabella quanto più
veloce vengano eseguiti i VI quando il display è in esecuzione nel suo
sottosistema di esecuzione.
Tabella 6-1. Tempi di esecuzione
Tempo di esecuzione medio
Multithreading off Multithreading on
Più veloce in %
VI
Charting
%
Benchmark Example
VI Update Chart 1
%
Point at a Time
VI Update Chart 50
%
Points at a Time
6-20
Esercitazione 6-3
Obiettivo:
VI Dialog & SubVI Demo
Osservare come una struttura a flusso di dati possa influenzare la velocità di
esecuzione.
Caricate ed avviate un VI che rappresenti un pattern di forme d’onda.
Notate come il flusso di dati influenza l’esecuzione del VI.
Pannello frontale
1. Se state eseguendo LabVIEW su un sistema operativo che supporta il
multithread (Windows, Solaris2, o Concurrent PowerMAX), completate i
passi da a a c. Se siete su un sistema che non supporta il
multithreading, andate al passo 2.
a. Configurate LabVIEW in maniera tale che non utilizzi il
multithreading quando esegue i VI. Selezionate Tools»Options
per visualizzare la finestra di dialogo Options.
b. Dal menu a tendina superiore della finestra di dialogo Options
selezionate Performance and Disk. Nella sezione Performance
and Disk, rimuovete il contrassegno dal riquadro Run with
multiple threads. Cliccate su OK.
c. Uscite e riavviate LabVIEW affinché siano attivi gli
aggiornamenti nelle preferenze. LabVIEW ora è configurato per
eseguire VI in un singolo thread, utilizzando il multitasking
cooperativo.
2. Aprite il VI Dialog & SubVI Demo. Il VI è già realizzato. Il pannello
frontale contiene un grafico tipo strip e diversi pulsanti opzione.
Questo grafico mostra due tipi di dati, la media continua di una
temperatura simulata e una traccia rossa che mostra quanto
rapidamente queste medie vengono calcolate.
6-21
Lezione 6
3. Aprite lo schema a blocchi ed esaminatelo. Due cicli While vengono
eseguiti in parallelo. Un ciclo gestisce la raccolta dei dati e l’analisi
mentre l’altro gestisce l’interfaccia utente.
4. Avviate il VI. Osservate la velocità di rappresentazione e le medie al
secondo da calcolare.
Notate che il valore Average/Sec è periodico e si abbassa molto. Lo
schema a blocchi contiene due cicli While eseguiti in parallelo. Il Plot
Loop (superiore) è quello che genera la media della temperatura e il
numero di medie al secondo. Il degrado delle prestazioni avviene
quando il Menu Loop viene eseguito e verifica i valori dei pulsanti sul
pannello frontale. Le prestazioni migliorano quando viene eseguito il
Plot Loop.
5. Cliccate sul pulsante Show Dialog. Notate l’effetto sulla velocità di
rappresentazione e sul valore Averages/Sec. Ricordate che un ciclo
non può iniziare l’iterazione successiva finché l’intero schema a
blocchi all’interno non ha completato l’esecuzione. Nel Menu Loop,
vengono letti i valori dai pulsanti per determinare quale condizione
dev’essere eseguita. Se cliccate sul pulsante Show Dialog, viene
eseguita la condizione 0. La condizione non ha completato
l’esecuzione se non cliccate sul pulsante OK nella finestra di dialogo.
Perciò, mentre la finestra di dialogo viene visualizzata, il Plot Loop
non deve condividere il processore con il Menu Loop.
6-22
6. Cliccate sul pulsante Pop-Up VI. Il VI Pop-up 2nd Process apre il
proprio pannello frontale e va in esecuzione. Notate l’effetto sul primo
valore Average/Sec del VI. Come nella situazione in cui avete cliccate
sul pulsante Show Dialog, il Menu Loop non viene più eseguito
finché non ha completato il VI Pop-up 2nd Process. Tuttavia
LabVIEW avvia il secondo VI nello stesso istante del VI originario. Il
degrado nelle prestazioni avviene quando viene avviato il secondo VI.
Perciò LabVIEW esegue più VI nello stesso modo in cui esegue cicli
in parallelo—ogni processo occupa lo stesso tempo.
7. Cliccate sul pulsante Stop.
8. Modificate il Menu Loop affinché includa una funzione Wait (ms).
Collegate un valore costante di 300 all’ingresso della funzione.
Notate come cambia la velocità del Plot Loop.
9. Chiudete il VI e non salvate le modifiche.
10. Se state eseguendo LabVIEW su un sistema operativo con
multithreading, contrassegnate il riquadro Run with multiple threads
nella pagina Performance and Disk di Tools»Options e riavviate
LabVIEW. Ripetete i passi da 2 a 9, notando come il multithreading
influenza la velocità di esecuzione del VI Dialog & SubVI Demo.
Se volete ottenere ulteriori risultati, spostate la finestra con il cursore
mentre il VI Dialog & SubVI Demo è in esecuzione. Questo aumenta il
carico di lavoro del processore creando risultati evidenti.
6-23
Lezione 6
Esercitazione 6-4
Obiettivo:
VI Computation & Global Benchmark
Osservare gli effetti di calcoli superflui e di attività con variabili globali sulla
velocità di esecuzione dei VI.
Usate la finestra Profile per confrontare le prestazioni di VI che eseguono
gli stessi compiti utilizzando differenti tecniche di programmazione.
Pannello frontale
1. Chiudete tutti i VI eventualmente aperti.
2. Aprite il VI Computation & Global Benchmark. Il VI è già realizzato.
3. Selezionate Tools»Advanced»Profile VIs. Cliccate sul pulsante Start
nella finestra Profile. Non raccogliete statistiche.
4. Avviate il VI Computation & Global Benchmark. Cliccate sul
pulsante Run SubVIs per avviare i seguenti quattro subVI. Avviate i
subVI almeno tre o quattro volte.
6-24
5. Dopo aver avviato i subVI diverse volte, arrestate il VI e cliccate sul
pulsante Snapshot nella finestra Profile. Individuate il VI
Computation & Global Benchmark nella finestra Profile e cliccateci
sopra due volte per visualizzare i suoi subVI se non sono già
visualizzati.
Osservate il tempo impiegato da ogni subVI. In particolare,
confrontate il tempo impiegato eseguendo il VI Update Globals Inside
Loop rispetto al VI Globals Outside of Loop e il tempo impiegato
eseguendo il VI Unnecessary Loop Computations rispetto al VI
Unnecessary Computations Removed. Vi aspettavate questo
comportamento? Come potreste applicare quello che avete imparato in
questa esercitazione al vostro modo di programmare?
6. Cliccate sul pulsante Stop nella finestra Profile per arrestare la
sessione profili. Quindi chiudete la finestra Profile.
7. Chiudete il VI. Non salvate i cambiamenti.
6-25
Lezione 6
D. Memoria di sistema
LabVIEW gestisce in maniera trasparente molti dettagli con cui
normalmente avete a che fare nei linguaggi di programmazione testuali.
Una delle principali sfide della programmazione con un linguaggio
testuale è l’uso di memoria. In un linguaggio di programmazione testuale,
dovete allocare memoria prima di usarla e disallocarla quando avete
finito. Dovete anche prestare particolare attenzione a non scrivere
accidentalmente oltre la memoria che avete allocato. Gli errori principali
che si commettono nei linguaggi di programmazione testuali riguardano
l’allocazione della memoria.
La programmazione a flusso di dati di LabVIEW rimuove molte delle
difficoltà riguardanti la gestione della memoria. In LabVIEW non allocate
variabili, assegnandole dei valori o leggendo dei valori da esse. Invece
create uno schema a blocchi con collegamenti grafici che rappresentano il
percorso dei dati.
Le funzioni che generano dati allocano l’immagazzinamento di quei dati.
Quando i dati non sono più necessari, LabVIEW disalloca la memoria
relativa. Quando dovete aggiungere una nuova informazione ad una
matrice o ad una stringa, LabVIEW alloca la memoria necessaria.
Questa gestione automatica della memoria è uno dei principali vantaggi di
LabVIEW. Tuttavia, siccome è automatica, ne avete un controllo
inferiore. Dovete capire come LabVIEW alloca e disalloca la memoria
affinché possiate progettare applicazioni con esigenze di memoria
inferiori. Inoltre, una comprensione su come minimizzare l’uso della
memoria può aiutarvi ad aumentare la velocità di esecuzione, siccome
l’allocazione di memoria e la copia di dati può prendere una
considerevole quantità di tempo.
La memoria in LabVIEW
Windows, Sun e HP-UX—LabVIEW alloca la memoria in maniera dinamica,
prendendo quanto necessario. Questo processo è trasparente per l’utente.
Macintosh— LabVIEW alloca un singolo blocco di memoria all’avvio, al
di fuori del quale vengono eseguite tutte le allocazioni successive.
Quando caricate un VI, i suoi componenti vengono caricati in questo
blocco di memoria. Inoltre, quando avviate un VI, tutta la memoria che
utilizza viene allocata da questo blocco.
Su Macintosh configurate la quantità di memoria che LabVIEW alloca
all’avvio selezionando l’opzione Get Info dal menu File nel Finder.
Notate che se LabVIEW va oltre questa memoria, non può incrementare
queste dimensioni. Perciò dovete impostare questo parametro il più
grande possibile. Assicuratevi di lasciare abbastanza memoria per
qualsiasi altra applicazione vogliate eseguire contemporaneamente con
LabVIEW.
6-26
Memoria virtuale
Quando utilizzate Windows o Macintosh, potete utilizzare la memoria
virtuale per aumentare la memoria disponibile per le vostre applicazioni.
La memoria virtuale utilizza lo spazio disponibile su disco per
accumulare RAM. Se allocate molta memoria virtuale, le applicazioni
considerano questa memoria disponibile per l’immagazzinamento dati.
Su Macintosh allocate memoria virtuale utilizzando il dispositivo
Memory nella cartella Control Panel. Windows, Sun e HP-UX gestiscono
automaticamente l’allocazione di memoria virtuale.
LabVIEW non distingue tra RAM e memoria virtuale. Il sistema
operativo nasconde il fatto che la memoria sia virtuale. Tuttavia, l’accesso
ai dati memorizzati nella memoria virtuale è più lento di quello alla RAM
fisica. Con la memoria virtuale, potete osservare occasionalmente
prestazioni più lente perché i dati vengono scambiati con l’hard disk dal
sistema operativo. La memoria virtuale può aiutare le applicazioni più
grandi, ma probabilmente non è adatta ad applicazioni che hanno vincoli
di tempo stringenti.
Componenti dei Vi
I VI hanno i seguenti componenti principali:
y
Pannello frontale
y
Schema a blocchi
y
Codice—schema a blocchi compilato in codice macchina
y
Dati—valori di controlli e indicatori, dati di default, costanti dello
schema a bocchi e così via.
Quando caricate un VI, LabVIEW carica in memoria il pannello frontale,
il codice, se coincide con la piattaforma, e i dati del VI. Se il VI deve
essere ricompilato a causa di un cambiamento di piattaforma o di
un’interfaccia di un subVI, LabVIEW carica in memoria anche lo schema
a blocchi.
LabVIEW carica in memoria anche il codice e lo spazio dati dei subVI. In
alcuni casi, LabVIEW carica in memoria anche il pannello frontale di
alcuni subVI. Per esempio, se il subVI utilizza i Property Nodes,
LabVIEW deve caricare il pannello frontale perché i Property Nodes
operano sulle caratteristiche dei controlli del pannello frontale.
Come mostrato nell’esempio seguente, potete risparmiare memoria
convertendo in subVI alcuni dei componenti dei VI. Se create un unico,
grande VI senza subVI, il pannello frontale, il codice e i dati di quel VI ad
alto livello finiscono in memoria. In taluni casi potreste realmente vedere
abbassarsi l’uso della memoria run-time.
6-27
Lezione 6
Pannello Schema a
frontale blocchi
Codice
Spazio
dati
VI a livello superiore
Pannello Schema a
frontale blocchi
Codice
Spazio
dati
subVI
Pannello Schema a
frontale blocchi
Codice
Spazio
dati
subVI
Sempre residente
Residente quando necessario
6-28
E. Ottimizzazione dell’uso della memoria da parte dei VI
Questa sezione descrive alcuni aspetti specifici riguardanti l’utilizzo più
efficiente della memoria da parte dei VI. Discuteremo come monitorare e
migliorare l’utilizzo della memoria e suggeriremo dei modi per
assemblare e processare in modo efficiente matrici e strutture di dati.
Come monitorare l’uso della memoria
Come mostrato nell’esempio seguente, selezionate Memory Usage dal
menu a tendina superiore nella finestra di dialogo File»VI Properties per
avere un’analisi dell’utilizzo della memoria per un particolare VI. La
colonna di sinistra sintetizza l’uso del disco e quella di destra indica
quanta RAM viene usata per i vari componenti del VI. Osservate che le
informazioni non comprendono l’utilizzo di memoria dei subVI.
Potete anche utilizzare la finestra Profile per monitorare la memoria
utilizzata da tutti i VI in memoria.
Nota Quando monitorate l’utilizzo di memoria di un VI, assicuratevi di salvare
il VI prima di esaminare i suoi requisiti relativi alla memoria. La caratteristica
Undo di LabVIEW esegue delle copie temporanee degli oggetti e dei dati, che
possono aumentare la memoria necessaria indicata per un VI. Salvando il VI si
liberano le copie generate da Undo, generando dei rapporti accurati sulla
memoria.
6-29
Lezione 6
Regole generali per un uso migliore della memoria
Adottate le regole seguenti per creare VI che utilizzino la memoria in
maniera efficiente.
y
Spezzare un VI in subVI solitamente migliora l’utilizzo della memoria
perché LabVIEW può recuperare la memoria dati dei subVI quando i
subVI non sono in esecuzione.
y
Non eccedete nell’uso di variabili globali e locali per memorizzare
matrici o stringhe; la lettura di una variabile globale o locale genera
una copia dei dati memorizzati nella variabile.
y
All’apertura dei pannelli frontali, visualizzate grandi matrici e
stringhe solo se necessario. Gli indicatori sui pannelli frontali
mantengono una copia dei dati che visualizzano.
y
Se il pannello frontale di un subVI non sarà visualizzato, non lasciate
inutilizzati i Property Nodes sul subVI. I Property Nodes
provocheranno la giacenza in memoria del pannello frontale del
subVI, incrementando l’utilizzo di memoria.
y
Non utilizzate l’opzione Suspend Data Range con VI critici dal punto
di vista tempi e memoria. Il pannello frontale dei subVI dev’essere
caricato per verifiche sull’intervallo e vengono eseguite copie extra
dei dati per i controlli e gli indicatori dei subVI.
y
Quando progettate schemi a blocchi, osservate i luoghi in cui le
dimensioni di un ingresso sono differenti da quelle di un’uscita. Per
esempio, se aumentate frequentemente le dimensioni di una matrice o
di una stringa utilizzando la funzione Build Array o Concatenate
Strings, generate copie dei dati, aumentando il numero di allocazioni
di memoria che LabVIEW deve effettuare. Queste operazioni possono
frazionare la memoria.
y
Utilizzate tipi di dati consistenti per le matrici ed osservate i punti di
forzatura quando vengono passati i dati a subVI e a funzioni. Quando
LabVIEW cambia il tipo di dati, l’uscita è un nuovo buffer.
y
Non utilizzate tipi di dati complicati, di tipo gerarchico, per esempio
matrici di cluster contenenti grandi matrici o stringhe, o cluster
contenenti grandi matrici o stringhe. La sezione Strutture di dati
semplici rispetto a quelle complesse in questa lezione contiene
ulteriori informazioni sulla progettazione di tipi di dati efficienti.
Assemblaggio ed elaborazione di matrici
Quando progettate lo schema a blocchi, ci sono diversi passi da seguire
per rendere più efficiente l’utilizzo della memoria da parte dei vostri VI.
Per esempio, potete assemblare ed elaborare matrici in modi che
minimizzano la quantità di accesso in memoria necessaria.
6-30
LabVIEW memorizza matrici di numeri in blocchi contigui di memoria.
Se utilizzate cicli For per assemblare queste matrici, LabVIEW può
determinare la quantità di memoria necessaria ed allocare lo spazio
necessario a monte della prima iterazione. Tuttavia, se utilizzate cicli
While, LabVIEW non può predeterminare i requisiti di spazio di cui avete
bisogno. LabVIEW potrebbe aver bisogno di riallocare l’intero buffer,
forse parecchie volte, quando la matrice cresce. Il tempo necessario a
questa operazione aumenta con le dimensioni della matrice. Perciò,
quando possibile, dovreste utilizzare cicli For per assemblare matrici
piuttosto che cicli While o concatenare matrici con la funzione Build
Array.
Inplaceness
Quando possibile, il compilatore di LabVIEW riutilizza i buffer
d’ingresso di una funzione per memorizzare la sua uscita. Questa
condivisione di buffer viene chiamata inplaceness. Nell’esempio
seguente, la funzione Multiply utilizza lo stesso buffer come ingresso
superiore. La matrice sulla destra si dice che è stata inserita nella matrice
A.
6-31
Lezione 6
Un’uscita di una funzione riutilizza un buffer d’ingresso se l’uscita e
l’ingresso hanno lo stesso tipo di dati, di rappresentazione e, nelle matrici,
nelle stringhe e nei cluster, la stessa struttura e numero di elementi.
Funzioni in grado di implementare l’inplaceness sono le funzioni
trigonometriche e logaritmiche, la maggior parte delle funzioni numeriche
e alcune funzioni su stringhe e matrici come To Upper Case e Replace
Array Element. Una funzione che fa scorrere o sposta elementi di una
matrice, come la Replace Array Element, può riutilizzare i buffer. Alcune
funzioni come Array Subset e String Subset potrebbero non copiare dati
ma potrebbero passare puntatori a sottomatrici o sottostringhe.
Nell’illustrazione seguente A, B, C e D identificano buffer singoli. Build
Array e Concatenate Strings sono funzioni speciali. Esse operano con
l’inplaceness quando possono ma talvolta devono allocare nuovi buffer.
6-32
Funzioni che riutilizzano i buffer
Funzioni che possono allocare
nuovi buffer
Funzioni che allocano nuovi buffer
Forzatura e tipi di dati consistenti
Considerate la funzione Random Number (0-1), utilizzata spesso negli
esempi mostrati nel corso. Questa funzione produce dati in doppia
precisione e a virgola mobile (DBL). Quindi vengono create sulla cornice
dei cicli For matrici DBL. Per risparmiare memoria potreste considerare
l’utilizzo di matrici in singola precisione a virgola mobile (SGL) al posto
delle matrici DBL. Dei tre metodi seguenti per creare matrici SGL, uno è
corretto e gli altri due sbagliati. Ricordate che ogni valore DBL richiede 8
byte di memoria, mentre ogni valore SGL richiede 4 byte di memoria.
6-33
Lezione 6
Metodo 1 (sbagliato)
Il metodo 1 potrebbe essere il vostro primo tentativo di risparmiare spazio
dati in memoria. Potreste pensare che portare su SGL la rappresentazione
della matrice sul pannello frontale (FP) possa far risparmiare spazio in
memoria. Tuttavia questo metodo non influisce sulla quantità di memoria
necessaria al VI, perché la funzione crea un buffer separato per mantenere
i dati convertiti. Il punto di forzatura sul terminale della matrice SGL
indica che la funzione ha creato un buffer separato per mantenere i dati
convertiti.
6-34
Metodo 2 (sbagliato)
Il metodo 2 è un tentativo di rimuovere il punto di forzatura convertendo
ogni matrice in SGL utilizzando la funzione To Single Precision Float che
si trova nella palette Functions»Numeric»Conversion. Tuttavia anche
questo metodo incrementa le dimensioni dello spazio dati, perché la
funzione crea due nuovi buffer, Ce D, per mantenere le nuove matrici
SGL.
6-35
Lezione 6
Metodo 3 (corretto)
Il metodo 3 riduce considerevolmente le dimensioni dello spazio dati, da
24.3 kB a 12.6 kB. Questo metodo converte in SGL l’uscita della
funzione Random Number (0-1) prima che venga creata la matrice;
quindi questo metodo crea due matrici SGL sulla cornice del ciclo For
piuttosto che due matrici DBL.
6-36
Strutture di dati semplici rispetto a quelle complesse
I tipi di dati semplici, che comprendono stringhe, numeri, booleani,
cluster di numeri o di booleani e le matrici di numeri o di booleani, hanno
dei riferimenti in memoria. Per altri dati, noti come nidificati, o dati
complessi, è più difficile creare riferimenti. Esempi di dati nidificati
comprendono matrici di stringhe, cluster contenenti matrici di cluster e
matrici di cluster contenenti matrici.
Matrice di cluster
contenente matrici
Cluster di matrici
contenenti un cluster
Dati semplici
Dati complessi
Per prestazioni migliori, evitate di creare strutture di dati complicate. Le
prestazioni possono risentirne perché è difficile accedere e manipolare
elementi interni senza generare copie di dati. Quindi, mantenete le vostre
strutture di dati le più semplici possibile. Strutture di dati semplici
possono generalmente essere manipolate con facilità ed in maniera
efficiente.
Considerate un’applicazione in cui volete registrare i risultati di diverse
prove. Nei risultati volete una stringa che descriva la prova e una matrice
con i risultati della prova. Un tipo di dati che potreste utilizzare per
memorizzare queste informazioni è una matrice di cluster contenenti una
stringa descrittiva e una matrice con i dati della prova, come mostrato nel
pannello frontale seguente.
6-37
Lezione 6
Ora pensate a che cosa vi serve per effettuare cambiamenti ad un
elemento nella matrice Test Data. Innanzitutto dovete indicizzare un
elemento della matrice complessiva Tests. Per quell’elemento, che è un
cluster, dovete separare gli elementi per accedere alla matrice. Quindi
sostituite un elemento della matrice e memorizzate la matrice risultante
nel cluster. Infine memorizzate il cluster risultante nella matrice
originaria. Un esempio di questo è mostrato nell’illustrazione seguente.
Copiare dati è dispendioso in termini di memoria e di prestazioni. La
soluzione è di realizzare strutture di dati più semplici possibile. In questo
caso potreste memorizzare i dati in due matrici, come mostrato nello
schema a blocchi seguente. La prima matrice è una matrice di stringhe. La
seconda matrice è bidimensionale, ed ogni riga è formata dai risultati di
una prova. Nell’esempio seguente, il pannello frontale contiene nuovi
controlli per memorizzare i dati e lo schema a blocchi effettua gli stessi
cambiamenti ai dati della prova, come mostrato nello schema a blocchi
precedente.
6-38
6-39
Lezione 6
Esercitazione 6-5
VI Assembling Arrays
Obiettivo: Osservare la velocità di costruzione di matrici utilizzando metodi diversi.
Caricate ed avviate un VI che crei una matrice di numeri utilizzando
diversi metodi. Utilizzando la finestra Profile, confrontate le prestazioni
dei VI utilizzando cicli For, cicli While, l’autoindicizzazione e la
funzione Build Array per creare matrici. Inoltre confrontate questi metodi
con una tecnica che utilizza la funzione Replace Array Element su una
matrice esistente.
Pannello frontale
2. Aprite il VI Assembling Arrays.
3. Per visualizzare la finestra Profile selezionate Tools»Advanced»
Profile VIs. Selezionate l’opzione che visualizza le statistiche
temporali. Cliccate sul pulsante Start nella finestra Profile per
iniziare una sessione di profili. Non raccogliete statistiche sulla
memoria.
4. Avviate il VI Assembling Arrays. Per verificare differenti metodi di
costruzione di matrici, cliccate sul pulsante Test. L’indicatore Method
mostra quale metodo è sotto osservazione. Il VI prova sei metodi
diversi.
5. Dopo aver eseguito il test diverse volte, cliccate sul pulsante
Snapshot nella finestra Profile.
Ora descriveremo le sei diverse tecniche di costruzione di matrici e
perché le prestazioni di questi VI differiscono.
Utilizzando la finestra Profile, contrassegnate il riquadro Timing
Statistics ed osservate i tempi di esecuzione medi mostrati.
6-40
La funzione Initialize Array è leggermente più veloce di un ciclo For con
autoindicizzazione. In entrambi i casi la dimensione della matrice è nota e
LabVIEW può allocare la quantità corretta di memoria una sola volta.
Ricordate che il ridimensionamento richiede più tempo di esecuzione.
Perciò la funzione Initialize Array o il ciclo For con autoindicizzazione
sono il metodo migliore per creare matrici.
Un ciclo For viene eseguito un numero predeterminato di volte. Un ciclo
While no, quindi LabVIEW non può predeterminare quanta memoria
deve allocare se una matrice viene costruita all’interno di un ciclo While.
Quando la matrice viene costruita in un ciclo While, esso si ridimensiona
secondo le necessità. Ogni ridimensionamento richiede al sistema
operativo l’allocazione di un nuovo buffer e quindi la copia del vecchio
buffer nel nuovo buffer più grande. Più c’è bisogno di ridimensionamenti,
maggiore è il tempo di esecuzione. Un ciclo For richiede meno
ridimensionamenti, e quindi viene eseguito più rapidamente rispetto al
ciclo While. Osservate questa differenza quando confrontate il tempo di
esecuzione medio per il ciclo For utilizzando il VI Auto Indexing e il
ciclo While utilizzando il VI Auto Indexing.
Se potete predeterminare le dimensioni massime di una matrice da
costruire, allora potete inizializzare questa matrice e passarla all’interno
del ciclo While. Una volta all’interno del ciclo While, ogni elemento può
essere aggiornato o sostituito se necessario. Questo è un metodo efficiente
perché la matrice non ha bisogno di essere riallocata una volta che è stata
passata all’interno del ciclo While. Questo non è ancora così efficiente
come il ciclo For o la funzione Initialize Array.
6-41
Lezione 6
Evitate di utilizzare la funzione Build Array all’interno di un ciclo. Ogni
volta che un nuovo valore viene aggiunto alla matrice, LabVIEW deve
riallocare il buffer e copiare l’intera matrice nella nuova locazione. Perciò
i tempi di esecuzione della funzione Build Array sono più lenti.
6. Chiudete la finestra Profile. Chiudete il VI
modifiche.
e non salvate le
6-42
Esercitazione 6-6
VI Performance Enhancements
Obiettivo: Incrementare le prestazioni di un VI.
Il VI Performance Enhancements è stato creato per svolgere i seguenti
compiti.
y
Acquisire 1000 punti di un forma d’onda da un canale.
y
Salvare questi dati su disco.
y
Visualizzare lo spettro di potenza della forma d’onda acquisita.
Il VI è scritto in modo scarno. Il VI consuma molta memoria, viene
eseguito lentamente ed è poco documentato. Inoltre, il VI non fornisce i
risultati desiderati per forme d’onde sopra i 60 Hz.
In questo progetto dovete utilizzare le informazioni del capitolo
precedente ed altre che avete appreso nel corso.
2. Aprite
il
VI
Performance Enhancements nella directory
Exercises\LV
Basics2. Visualizzate la finestra Profile
selezionando Tools»Advanced»Profile VIs. Selezionate Timing
Statistics nella finestra Profile.
3. Avviate il VI. Dopo che ha terminato, cliccate sul pulsante Snapshot
nella finestra Profile per visualizzare le informazioni sull’esecuzione
del VI. Osservate quante volte vengono richiamati i VI e tra quei VI
che vengono chiamati più volte quelli più lenti. Osservate quali VI
sono stati eseguiti molte volte e osservate quali VI richiedono
probabilmente tempi di esecuzione più lunghi.
4. Selezionate File»VI Properties e quindi Memory Usage dal menu a
tendina superiore. Un VI ben scritto per questa applicazione dovrebbe
consumare un totale di circa 25 k di memoria. Osservate quanto
consuma questo VI scritto in modo scarno.
5. Modificate il VI affinché questa applicazione:
− Funzioni correttamente per forme d’onda a frequenza superiore.
− Sia più veloce.
− Utilizzi meglio le strutture di dati e sia più facile da comprendere.
− Sia meglio documentata.
Utilizzate i consigli dati in questa lezione, le informazioni di altri
capitoli di questo corso e i seguenti consigli per partire:
− Mettere i VI ad alto livello all’interno di cicli crea chiamate
ridondanti a funzioni.
− Raccogliere o visualizzare dati un punto alla volta è meno
efficiente che acquisire più punti.
6-43
Lezione 6
− Tipi di dati lineari sono più efficienti in termini di uso della
memoria rispetto a strutture complesse di dati.
− Ci sono molti modi per documentare un VI.
6. Salvate il VI modificato.
7. Avviate il VI. Notate i miglioramenti nell’esecuzione e nell’utilizzo
della memoria. Notate anche la maggiore leggibilità e semplicità del
codice.
Assicuratevi di salvare il VI prima di esaminare il suo utilizzo di
memoria. Questo evita che la caratteristica Undo di LabVIEW allochi
inutilmente memoria.
Nota
8. Quando siete soddisfatti del vostro VI, salvatelo come Performance
Improvements.vi.
6-44
Esercitazione 6-7
VI Performance Challenge/
VI Maximized Performance
Obiettivo: Incrementare le prestazioni di un VI.
Il VI Performance Challenge svolge i seguenti compiti.
1. Genera quattro insiemi di dati. Ogni insieme è costituito da una
matrice di 5000 punti e da una stringa contenente data e ora relativa a
quando sono stati presi i dati. Ogni elemento ha bisogno di 2 sole cifre
di precisione.
2. Salva tutti i dati acquisiti e i relativi riferimenti temporali su disco. Il
file sarà usato solo nelle applicazioni in LabVIEW e quindi non
necessita di alcun formato specifico.
3. Trova il valore massimo per ogni insieme di dati e visualizza 100
punti intorno al valore massimo del grafico. Il grafico finale dovrebbe
contenere quattro tracce, una per ogni insieme di dati.
Questo VI è scritto in maniera scarna. Viene eseguito lentamente e
impegna più memoria del necessario. In questa esercitazione ottimizzate
il VI per incrementare la velocità di esecuzione e diminuire l’impegno di
memoria.
1.
Chiudete tutti i VI eventualmente aperti.
2. Aprite il VI Performance Challenge. Visualizzate la finestra Profile
selezionando Tools»Advanced»Profile VIs. Selezionate Timing
Statistics e Timing Details nella finestra Profile, affinché posiate
avere una migliore comprensione su quello che avviene mentre il VI è
in esecuzione.
3. Avviate il VI. Dopo che ha terminato, cliccate sul pulsante Snapshot
nella finestra Profile per visualizzare le informazioni sull’esecuzione
del VI. Osservando queste informazioni, notate quanto tempo viene
richiesto per l’aggiornamento delle variabili locali e anche quante
volte questa applicazione richiama subVI di I/O su file.
4. Selezionate File»VI Properties e quindi Memory Usage dal menu a
tendina superiore. Notate la considerevole quantità di memoria
richiesta dai dati di questo VI.
5. Modificate il VI per incrementare la velocità di esecuzione e per
ridurre la quantità di memoria richiesta. Utilizzate i consigli di questa
lezione e le seguenti indicazioni per cominciare:
y
Le variabili locali aumentano l’impegno di memoria e rallentano
la velocità di esecuzione, specialmente quando vi si accede
all’interno di cicli.
y
Create le matrici in modo efficiente.
y
Minimizzate il numero di operazioni di I/O eseguite nell’ambito
dell’applicazione. Aprite e chiudete un file solo se necessario.
6-45
Lezione 6
y
Evitate calcoli inutili e conversioni di dati, specialmente
all’interno di cicli.
y
Minimizzate e semplificate i display dei pannelli frontali.
y
Utilizzate strutture di dati semplici.
Suggerimento Dovete solamente rispettare i requisiti dell’applicazione descritti
precedentemente. Come implementare questa applicazione dipende da voi.
6. Salvate il VI modificato.
7. Avviate il VI, notando i miglioramenti sulla velocità nella finestra
Profile e sull’impegno di memoria in VI Properties. Potreste anche
ripetere i passi da 5 a 7 diverse volte, ottimizzando ulteriormente
l’applicazione.
Assicuratevi di salvare il VI prima di esaminare il suo utilizzo di
memoria. Questo evita che la caratteristica Undo di LabVIEW allochi
inutilmente memoria.
Nota
8. Quando siete soddisfatti del vostro VI, salvatelo come Maximized
Performance.vi.
6-46
In funzione del sistema operativo. LabVIEW utilizza il multithreading o il
multitasking cooperativo per svolgere più compiti contemporaneamente.
Con il multithreading, compiti differenti possono utilizzare differenti
thread di esecuzione, mentre in un sistema con multitasking cooperativo,
compiti diversi utilizzano lo stesso thread di esecuzione.
Utilizzate la finestra Profile per valutare le prestazioni di un VI e per
aiutarvi ad individuare i compiti che richiedono la maggior parte del
tempo di esecuzione e di impegno di memoria. Potete quindi concentrarvi
sul miglioramento di queste aree critiche per aumentare le prestazioni
complessive del vostro VI.
Utilizzate i seguenti consigli per velocizzare i vostri VI:
y
Riducete il numero di chiamate di I/O diminuendo il numero di dati
da acquisire, o acquisendo più dati in poche chiamate.
y
Riducete il numero di controlli e indicatori che avete sul pannello
frontale.
y
Evitate l’uso di autoscaling sui grafici.
y
Aggiornate i grafici con diversi punti alla volta, non un punto alla
volta.
y
Forzate l’attesa di compiti meno importanti, utilizzando la funzione
Wait (ms). In tal modo i compiti più importanti hanno più tempo
macchina a disposizione.
y
Evitate calcoli inutili in strutture a cicli.
Sebbene LabVIEW rimuova molte delle difficoltà relative alla gestione
della memoria, potete avere meno controllo su altri processi. Ricordate
che potete monitorare la memoria del vostro computer andando sulla
pagina Memory Usage nella finestra di dialogo File»VI Properties e in
Tools»Advanced»Profile VIs.
L’uso della memoria virtuale possiede vantaggi e svantaggi. Essa può
significativamente aumentare la RAM disponibile per LabVIEW e i vostri
VI. Tuttavia, siccome la RAM si trova sull’hard disk, le prestazioni
possono risentirne quando vi si accede.
Spezzare grandi VI ad alto livello in diversi subVI più piccoli riduce la
quantità di memoria consumata dalla vostra applicazione e può migliorare
le prestazioni.
Utilizzate i seguenti consigli per velocizzare i vostri VI:
y
Evitate di eccedere nell’uso di variabili locali e globali.
y
Evitate di visualizzare e di operare con grandi matrici e stringhe.
6-47
Lezione 6
y
Utilizzate funzioni che riutilizzano i buffer dati.
y
Utilizzate tipi di dati consistenti. In altre parole, evitate i punti di
forzatura.
y
Utilizzate strutture di dati le più semplici possibile.
y
Quando all’interno di cicli generate matrici la cui rappresentazione
dev’essere cambiata, cambiate la rappresentazione all’interno del
ciclo, non dopo.
6-48
Note
6-49
Lezione 6
Note
6-50
Appendice
Questa appendice, contenente informazioni utili per gli utenti di
LabVIEW, è composta dalle seguenti sezioni:
A. SubVI polimorfici
B. Grafica personalizzata in LabVIEW
C. Il Web Server in LabVIEW
D. Informazioni aggiuntive
E. Tabella delle corrispondenze dei caratteri ASCII
A-1
Appendice
A. SubVI polimorfici
Le funzioni interne di LabVIEW possono gestire differenti tipi di dati per
lo stesso terminale, una potenzialità chiamata polimorfismo. Un esempio
di polimorfismo è la funzione ADD.
E’ anche possibile creare i vostri VI polimorfici, che possono gestire più
di un tipo di dato per lo stesso terminale. Questi VI polimorfici possono
essere utilizzati come subVI polimorfici.
L’uso di VI polimorfici vi consente di presentare all’utente un’interfaccia
più semplice per i vostri VI. Considerate il caso di un VI polimorfico che
possa ordinare sia matrici mono che bidimensionali. Invece di avere un
VI per l’ordinamento di matrici monodimensionali e un altro subVI per
l’ordinamento di matrici bidimensionali, un unico VI chiamato Sort Array
gestisce entrambi i tipi di ingressi.
Completate i passi seguenti per creare il vostro VI polimorfico.
1. Create un insieme di VI aventi lo stesso schema per il riquadro dei
connettori, uno per differenti insiemi di tipi di dati.
2. Create un VI polimorfico selezionando File»New e quindi
Polymorphic VI nella finestra di dialogo New. Compare la finestra di
dialogo Polymorphic VI.
A-2
Appendice
3. Aggiungete ciascuno degli insiemi dei VI al VI polimorfico
utilizzando il pulsante Add VI.
4. Potete creare un’icona per il VI polimorfico utilizzando il pulsante
Edit Icon. Potete creare anche il context help per il VI polimorfico
selezionando Documentation dal menu a tendina superiore nella
finestra di dialogo File»VI Properties.
Nota Context help per il VI polimorfico non è associato al context help dei VI
che compongono il VI polimorfico. Perciò dovete creare un nuovo context help
utilizzando la pagina Documentation nella finestra di dialogo File»VI
Properties.
Un VI polimorfico è una raccolta di subVI con lo stesso schema per il
riquadro connettori. Ogni subVI costituisce un’istanza del VI polimorfico.
Quando i dati sono collegati ad un subVI polimorfico, LabVIEW sceglie
automaticamente quale istanza utilizzare in funzione dei tipi di dati
collegati agli ingressi del subVI polimorfico. Se l’istanza non è
disponibile, compare un file spezzato. Potete scavalcare la selezione
automatica di LabVIEW cliccando con il tasto destro del mouse sul subVI
polimorfico e selezionando un’istanza specifica dal menu a tendina di
destra Select Type.
A-3
Appendice
Esercitazione A-1
Ordinare matrici polimorfiche
Obiettivo: Creare un VI polimorfico e utilizzarlo come subVI.
Utilizzare VI polimorfici vi consente di presentare un’interfaccia molto
più semplice agli utenti dei vostri VI. Considerate il caso di un VI
polimorfico che possa ordinare sia matrici mono che bidimensionali. Due
VI singoli possono svolgere questa funzione.
Invece di avere un VI per l’ordinamento di matrici monodimensionali e
un altro subVI per l’ordinamento di matrici bidimensionali, un VI
chiamato Sort Array gestisce entrambi i tipi di ingressi. In questa
esercitazione create questo VI.
1. Create un VI che ordini una matrice monodimensionale. Questo VI
dovrebbe includere anche un’opzione per ordinare gli elementi in
maniera ascendente o discendente e produrre un oggetto booleano di
errore. L’esempio seguente è un possibile pannello frontale. Avete
bisogno di creare il pannello frontale e lo schema a blocchi e di
provare il codice che avete scritto.
2. Create un riquadro connettori utilizzando la configurazione seguente.
Utilizzate lo stesso riquadro connettori per l’istanza Sort 2D Array.
Altrimenti il VI polimorfico produce fili spezzati.
Nota
A-4
Appendice
3. Salvate il vostro lavoro come Sort 1D Array+.vi.
4. La funzione Sort 2D Array è già realizzata. Tuttavia dovete
completare il riquadro dei connettori. Questo esempio è stato scaricato
da ni.com\support nel Example Programs Database. Aprite questo
file da exercises\LV Basics2\Sort 2D Array.vi.
5. Create e collegate il riquadro dei connettori per il VI Sort 2D Array.
Anche se il riquadro dei connettori è già costruito potreste aver
bisogno di modificarlo per agevolare la differenziazione rispetto al
programma Example. Non avete bisogno di collegare tutti i controlli e
indicatori su questo pannello frontale. Ricordate la configurazione
utilizzata per il VI Sort 1D Array.
6. Salvate questo nuovo VI come Sort 2D Array+.vi.
Ora create il VI polimorfico, che è composto dall’istanza Sort 1D Array+
e dall’istanza Sort 2D Array+.
7. Per combinare le due istanze in un unico VI polimorfico, selezionate
File»New e quindi Polymorphic VI. Se vi trovate nella finestra di
benvenuto, selezionate Polymorphic VI dal menu a tendina New VI.
A-5
Appendice
8. Aggiungete i VI Sort 1D Array+ e Sort 2D Array+ utilizzando il
pulsante Add VI. Potreste aver bisogno di andare nelle directory in
cui avete salvato questi VI.
9. Create un’icona per questo nuovo VI polimorfico selezionando il
pulsante Edit Icon.
10. Create il context help per questo VI selezionando Documentation dal
menu a tendina superiore nella finestra di dialogo File»VI
Properties.
11. Salvate il vostro VI come Sort Poly Array.vi.
12. Utilizzate questo VI come subVI in un altro VI per testare la
funzionalità. Osservate la schermata dell’help. Notate anche cosa
succede quando cliccate due volte sul VI polimorfico. Cosa succede
se selezionate un particolare contesto cliccando con il tasto destro del
mouse e selezionando Select Type?
Fine dell’esercitazione A-1
A-6
Appendice
B. Grafica personalizzata in LabVIEW
Ci sono diverse caratteristiche di LabVIEW disponibili per fornire ai
pannelli frontali un aspetto personalizzato più professionale. Queste
caratteristiche, fornite con LabVIEW full and professional development
system, forniscono all’interfaccia utente una grafica personalizzata e
possibilità di animazione.
Decorazioni
Uno dei metodi più semplici per migliorare l’interfaccia utente è di
applicare le decorazioni di LabVIEW ad un pannello frontale così come
avete fatto nella Lezione 2, Progettazione di pannelli frontali. Attraverso
un uso attento delle decorazioni, potete aumentare la leggibilità dei
pannelli frontali.
Importazione di grafica
Potete importare grafica da altri VI per utilizzarla come immagini di
sfondo, come elementi nei controlli di tipo ring o parti di altri controlli.
Tuttavia, prima che possiate utilizzare un’immagine in LabVIEW, dovete
caricarla nella clipboard di LabVIEW. Ci sono uno o due modi per fare
ciò, in funzione della vostra piattaforma.
y
Windows—Se copiate un’immagine direttamente da un programma di
disegno nella Clipboard di Windows e quindi passate a LabVIEW,
LabVIEW importa automaticamente l’immagine nella Clipboard di
LabVIEW. Potete anche utilizzare l’opzione Import Picture from
File del menu Edit di LabVIEW per importare un file grafico nella
clipboard di LabVIEW. LabVIEW riconosce i file grafici nei seguenti
formati: CLP, EMF, GIF, PCX, BMP, TARGA, TIFF, LZW,WFM e
WPG.
y
Macintosh—Se copiate da un programma di disegno nella Clipboard e
quindi passate a LabVIEW, LabVIEW importa automaticamente
l’immagine nella Clipboard di LabVIEW.
y
UNIX—Potete utilizzare l’opzione Import Picture from File del menu
Edit di UNIX per importare un’immagine di tipo X Window Dump
(XWD), che potete creare utilizzando il comando xwd.
Dopo che un’immagine è stata copiata nella Clipboard di LabVIEW,
potete riportarla sul pannello frontale come immagine statica, oppure
potete utilizzare l’opzione Import Picture di un menu rapido o le opzioni
Import Picture nel Control Editor.
Controlli personalizzati
Potete personalizzare i controlli e gli indicatori in LabVIEW per
modificare il loro aspetto sul pannello frontale. Potete anche salvare
questi controlli per utilizzarli in altri VI. Da un punto di vista del
programma, funzionano come i controlli standard di LabVIEW.
A-7
Appendice
Control Editor
Avviate il Control Editor selezionando un controllo sul pannello frontale
e quindi Edit»Customize Control. Il Control Editor appare con l’oggetto
selezionato del pannello frontale nella sua finestra. Il Control Editor
presenta due modalità di funzionamento, edit mode e customize mode.
Edit Mode
In edit mode, potete cliccare con il tasto destro del mouse sul controllo e
modificare le sue impostazioni come volete che appaiano nell’ambiente di
programmazione di LabVIEW.
Edit Mode
Type Def.
Status
Testo
Align Distribute Reorder
Objects Objects Objects
Customize Mode
In customize mode, potete spostare singoli componenti del controllo l’uno
rispetto all’altro. Per un elenco di ciò che potete modificare in customize
mode, selezionate Window»Show Parts Window.
Customize Type Def.
Mode
Status
Testo
Align Distribute Reorder
Objects Objects Objects
Un modo di personalizzare un controllo è di modificare type definition
status. Potete salvare un controllo come controllo, come definizione di
tipo, o come definizione di tipo stringente, in funzione della selezione
mostrata nel ring Type Def. Status. L’opzione del controllo è la stessa
che voi avreste selezionando un controllo dalla palette Controls. Potete
modificarla in un qualsiasi modo ed ogni copia che realizzate e modificate
mantiene le sue proprietà specifiche.
Un controllo Type Definition è una copia principale di un controllo
personalizzato. Tutte le copie di questo genere di controllo devono essere
dello stesso tipo. Per esempio, se create un controllo personalizzato Type
Definition con una rappresentazione numerica di tipo Long, non potete
farne una copia e portare la sua rappresentazione su Unsigned Long.
Utilizzate una Type Definition quando volete inserire un controllo con lo
stesso tipo di dato in più posti. Se cambiate il tipo di dato di Type
Definition nel Control Editor, il tipo di dato si aggiorna automaticamente
in tutti i VI che utilizzano il controllo personalizzato.
A-8
Appendice
Tuttavia, potete ancora personalizzare individualmente l’aspetto di ogni
copia di controllo Type Definition.
Un controllo Strict Type Definition dev’essere identico sotto tutti i punti
di vista dovunque lo utilizziate. Oltre al tipo di dato, le sue dimensioni, i
suoi colori e il suo aspetto devono essere gli stessi. Utilizzate un controllo
Strict Type Definition quando volete avere oggetti completamente
identici in più posti e volete modificarli tutti automaticamente. Potete
ancora avere etichette singole per ogni istanza di un Strict Type
Definition.
Salvataggio dei controlli
Dopo aver creato un controllo personalizzato, potete salvarlo per un
utilizzo successivo. Di default i controlli salvati sul disco hanno
un’estensione .ctl. Potete anche inserire controlli nella palette Controls
utilizzando lo stesso metodo che avete usato per aggiungere subVI alla
palette Functions.
Potete anche utilizzare il Control Editor per salvare controlli con le
proprie impostazioni di default. Per esempio, potete utilizzare il Control
Editor per modificare le impostazioni di default di un grafico tipo
waveform, salvarle e richiamarle successivamente in altri VI.
A-9
Appendice
Esercitazione A-2
Obiettivo: Utilizzare il Control Editor per modificare un controllo.
1. Aprite un nuovo pannello frontale.
2. Inserite un Horizontal Pointer Slide che si trova nella palette
Controls»Numeric del pannello frontale. Cliccate con il tasto destro
del mouse sul controllo e selezionate Visible Items»Digital Display.
Modifica del controllo
3. Avviate il Control Editor selezionando il controllo con lo strumento
Posiziona e selezionando Edit»Customize Control. Utilizzando lo
strumento Modifica spostate il controllo nel mezzo del pannello
frontale per avere più spazio lavorativo a disposizione.
4. Cliccate con il tasto destro del mouse sul display digitale e selezionate
Replace»Numeric»Meter. Posizionate il misuratore sopra il
controllo slide, come mostrato nell’esempio seguente.
5. Nascondete la scala dello slide cliccandoci sopra con il tasto destro
del mouse e selezionando Scale»Style»None.
A-10
Appendice
6. Chiudete il Control Editor selezionando Close dal menu File. Salvate
il controllo come Custom Slider.ctl, quindi cliccate su Yes per
sostituire quello esistente. Il controllo modificato viene mostrato sul
pannello frontale.
Potete salvare controlli che avete creato quando salvate VI. Potete
caricare controlli salvati utilizzando Select a Control dalla palette Controls. I
controlli hanno un’estensione .ctl.
Nota
7. Lavorate con il controllo ed osservate come il misuratore segue i
valori.
8. Chiudete il VI. Non salvate le modifiche.
A-11
Appendice
Esercitazione A-3
Obiettivo: Creare un indicatore booleano personalizzato.
Realizzate un VI che utilizzi indicatori booleani personalizzati per
mostrare lo stato di un becco di Bunsen e di un’ampolla riscaldata. Le
figure che rappresentano gli stati on e off del becco di Bunsen e l’ampolla
sono già stati disegnati.
Pannello frontale
1. Aprite il VI Custom Picture Exercise che si trova nella directory
exercises\Basics2.
Il VI contiene un selettore verticale per attivare o disattivare il becco
di Bunsen ed un pulsante per uscire dall’applicazione. Esso contiene
anche due immagini per rappresentare gli stati on e off del becco di
Bunsen e due immagini che rappresentano gli stati di ebollizione e
non ebollizione dell’ampolla.
2. Per creare l’oggetto booleano personalizzato dell’ampolla, completate
i passi seguenti.
a. Cliccate con il tasto destro del mouse su un’area libera del
pannello frontale e selezionate Square LED dalla palette
Controls»Classic Controls»Boolean. Etichettate il LED con
Ampolla.
b. Utilizzando lo strumento Posiziona, selezionate l’immagine che
mostra l’ampolla in ebollizione e selezionate Edit»Cut. Cliccate
sull’indicatore a LED dell’ampolla e selezionate Edit»Customize
Control. Ora appare il Control Editor con il LED dell’ampolla
visualizzato. Cliccate con il tasto destro del mouse sul LED e
selezionate Import Picture»True. Questa immagine rappresenta
ora lo stato TRUE.
Nota Lo stato di default del LED è FALSE. Se non vedete l’immagine, il LED
si trova probabilmente nello stato FALSE.
A-12
Appendice
c. Passate al pannello frontale cliccandoci sopra. Utilizzando lo
strumento Posiziona, selezionate l’immagine dell’ampolla con il
contenuto non in ebollizione e selezionate Edit»Cut. Passate alla
finestra Control Editor cliccandoci sopra.
d. Cliccate con il tasto destro del mouse sull’ampolla e selezionate
Import Picture»False. Questa immagine rappresenta ora lo stato
FALSE.
e. Selezionate Apply Changes dal menu File e chiudete il Control
Editor. Non salvate il controllo personalizzato.
3. Cliccate con il tasto destro del mouse su un’area libera e selezionate
Square LED dal menu rapido Controls»Classic Controls»Boolean.
Etichettate il LED con Fiamma.
4. Seguendo i passi precedenti, rendete il LED uguale al becco di
Bunsen. Lo stato TRUE dovrebbe mostrare il bruciatore on; lo stato
FALSE dovrebbe mostrare il bruciatore off.
5. Nascondete le etichette degli indicatori booleani cliccandoci sopra con
il tasto destro del mouse e selezionando Visible Items»Label.
Selezionate gli indicatori booleani e allineateli orizzontalmente
usando lo strumento Align Objects.
Schema a blocchi
6. Completate lo schema a blocchi seguente.
8. Tornate al pannello frontale ed avviate il VI. Portate sulla posizione
on ed off il selettore Burner e notate i cambiamenti del booleano
personalizzato.
9. Arrestate il VI cliccando sul pulsante Quit. Se cliccate sul pulsante
Quit mentre il bruciatore è acceso, una fienstra di dialogo avvisa che
dovete spegnere il bruciatore prima di arrestare il sistema.
A-13
Appendice
Il Web Server in LabVIEW
Il Web è uno dei modi più popolari per condividere informazioni ed è un
buon modo per condividere le vostre misure e dati. LabVIEW offre
diversi modi per aiutarvi nella pubblicazione dei vostri dati sul web e per
creare documenti HTML. La Lezione 3 descrive DataSocket e come esso
utilizzi il metodo ad URL per descrivere ed accedere a dati di LabVIEW.
Un altro metodo è di utilizzare il Web Server in LabVIEW per pubblicare
immagini dei vostri pannelli frontali sul web. Di default, dopo che avete
abilitato il Web Server, tutti i VI sono visibili a tutti i browser Web.
Tuttavia, potete controllare l’accesso da browser ai pannelli frontali
pubblicati e configurare quali VI siano visibili sul Web. Per visualizzare
pannelli frontali di VI sul Web, i VI devono trovarsi nella memoria del
computer.
Per configurare il Web Server, selezionate Tools»Options e quindi Web
Server: Configuration dal menu a tendina superiore.
La finestra Web Server: Configuration è quella in cui dovete abilitare il
Web Server. La configurazione di default del Web Server è adatta alla
maggior parte della applicazioni. Se dovete modificare la configurazione
di default, fate riferimento all’help di LabVIEW.
La finestra Web Server: Browser Access vi consente di configurare
quali indirizzi browser possono visualizzare i pannelli frontali dei vostri
VI. Quando un Web browser tenta di ottenere un’immagine di un
pannello frontale di un VI, il Web Server confronta l’indirizzo del
browser con quelli presenti nella Browser Access List per determinare se
è consentito l’accesso. Se un indirizzo della Browser Access List coincide
con l’indirizzo del browser, Web Server consente o nega l’accesso a
seconda di come è stata effettuata l’impostazione. Di default tutti i
browser hanno accesso al Web Server di LabVIEW. Fate riferimento alla
finestra Context Help per ulteriori informazioni sulla sintassi utilizzata
per definire l’accesso dei browser.
La finestra Web Server: Visible VIs vi consente di definire quali VI
siano accessibili ad un Web browser. Quando un Web browser cerca di
ottenere un’immagine di un pannello frontale, il Web server confronta il
nome del VI con quelli presenti nell’elenco Visible VIs per stabilire se è
consentito l’accesso. Se un nome nell’elenco Visible VIs coincide con il
nome del VI, il Web Server consente o nega l’accesso a quell’immagine
di VI basandosi sulle impostazioni effettuate da voi. Di default le
immagini dei pannelli frontali di tutti i VI sono visibili. Fate riferimento
alla finestra Context Help per ulteriori informazioni sulla sintassi
utilizzata per stabilire la visibilità dei VI.
A-14
Appendice
Nota Utilizzate l’Enterprise Connectivity Toolset di LabVIEW per controllare i
VI sul Web e per aggiungere maggiore sicurezza ai VI da pubblicare sul Web.
Fate riferimento al sito Web della National Instruments per ulteriori
informazioni.
Il Web Publishing Tool di LabVIEW
Potete anche utilizzare Tools»Web Publishing Tool per creare un
documento HTML e includere immagini statiche o animate del pannello
frontale. Potete anche includere immagini del pannello frontale in un
documento HTML esistente.
Cliccate sul pulsante Instructions per visualizzare informazioni su come
aggiungere un titolo al vostro file HTML e su come aggiungere testo
prima e dopo il pannello frontale del vostro VI. Inserite un nome di VI nel
campo VI Name o selezionate Browse dal menu a tendina VI Name e
andate su un VI.
Per visualizzare pannelli frontali di VI sul Web, i VI devono risiedere
nella memoria del vostro computer.
Nota
Potete avere un’anteprima del documento nel vostro browser di default
cliccando sul pulsante Start Web Server e quindi sul pulsante Preview
in Browser. Se il pulsante Start Web Server non è evidenziato, il Web
Server è già in esecuzione. Quando cliccate sul pulsante Save to Disk, il
titolo, il testo e l’immagine del pannello frontale del VI vengono salvati in
un documento HTML. Se volete visualizzare il documento da un
computer remoto, salvate il documento HTML nella directory root del
Web Server, solitamente labview\www. Compare la finestra di dialogo
Document URL con la URL del vostro documento HTML.
A-15
Appendice
Esercitazione A-4 Generate & Analyze Data
Obiettivo:
Utilizzare gli strumenti del Web Server di LabVIEW per visualizzare un pannello
frontale in un web browser.
Aprite il VI che avete realizzato nell’esercitazione 1-1, il VI Generate &
Analyze Data e salvate il suo pannello frontale in un documento HTML.
Pannello frontale
1. Aprite il VI Generate & Analyze Data dalla directory exercises\LV
Basics2.
2. Abilitate e configurate il Web Server selezionando Tools»Options.
3. Selezionate Web Server: Configuration dal menu a tendina
superiore della finestra di dialogo Options e contrassegnate il
riquadro Enable Web Server.
4. Cliccate sul pulsante OK per chiudere la finestra di dialogo Options.
Ora il Web Server di LabVIEW è in esecuzione.
5. Avviate il VI per alcuni secondi e fermatelo.
6. Selezionate Tools»Web Publishing Tool. Cliccate sul pulsante
Instructions e leggete come utilizzare questo strumento.
A-16
Appendice
7. Cliccate sul collegamento continue e configurate la finestra seguente.
8. Cliccate sul pulsante Preview in Browser per aprire e visualizzare il
pannello frontale in un browser. Compare una finestra simile a quella
mostrata nella figura successiva.
A-17
Appendice
L’opzione Animated funziona solo con Netscape Navigator. In Internet
Explorer potete solamente visualizzare immagini statiche.
Nota
9. Tornate alla finestra Web Publishing Tool e cliccate sul pulsante
Save to Disk per salvare il titolo, il testo e l’immagine del pannello
frontale del VI in un documento HTML. Salvate il documento come
Generate & Analyze Data.htm nella directory LV Basics2.
Compare un messaggio di avviso che vi dice dove installare il file se
volete che altre macchine lo vedano.
10. Cliccate sul pulsante Done per uscire dal Web Publishing Tool.
11. Tornate al browser e digitate la seguente URL nella barra degli
indirizzi: http://127.0.0.1. Questa definisce la macchina locale.
Compare la finestra seguente.
12. Leggete le informazioni e chiudete il browser quando avete finito.
13. Disattivate il Web Server selezionando
visualizzare la finestra di dialogo Options.
Tools»Options
per
14. Selezionate Web Server: Configuration dal menu a tendina
superiore della finestra di dialogo Options e rimuovete la selezione
dal riquadro Enable Web Server.
15. Cliccate sul pulsante OK per chiudere la finestra di dialogo Options.
16. Chiudete il VI Generate & Analyze Data.
A-18
Appendice
D. Informazioni aggiuntive
Questa sezione descrive come potete avere ulteriori informazioni
relativamente a LabVIEW, ai driver degli strumenti e ad altri argomenti
relativi a questo corso.
Opzioni del supporto tecnico della National Instruments
Il modo migliore per ottenere un supporto tecnico e altre informazioni su
LabVIEW, prove e misure, strumentazione e altri prodotti e servizi della
National Instruments è di collegarsi al sito web della NI che si trova
all’indirizzo ni.com.
La pagina di supporto del sito web della National Instruments contiene
collegamenti a note applicative, la conoscenza di base del supporto,
centinaia di esempi e vari tipi di aiuto per la risoluzione di problemi
relativi ad argomenti discussi in questo corso ed altro ancora.
Un altro eccellente posto per ottenere supporto quando sviluppate varie
applicazioni con i prodotti della National Instruments è la NI Developer
Zone sempre all’indirizzo ni.com.
La NI Developer Zone comprende anche collegamenti diretti alla rete di
driver per gli strumenti e alle pagine web dei membri dell’Alliance
Program.
L’Alliance Program
L’Alliance Program della National Instruments riunisce integratori di
sistemi, consulenti e venditori hardware per fornire servizi completi e
esperienza ai clienti. Il programma assicura assistenza qualificata e
specializzata per lo sviluppo di applicazioni e di sistemi. Le informazioni
relative e i collegamenti a molti dei membri dell’Alliance Program sono
disponibili presso il sito della National Instruments.
Newsgroup di supporto all’utente
I newsgroup di supporto all’utente della National Instruments sono una
raccolta di newsgroup Usenet che copre i prodotti della National
Instruments e i campi generali della scienza e dell’ingegneria. Potete
leggere, cercare e scrivere sui newsgroup per condividere soluzioni e
trovare un supporto aggiuntivo da altri utenti. Potete accedere ai
newsgroup di supporto all’utente dalla pagina web di supporto della
National Instruments.
Altri corsi di formazione della National Instruments.
National Instruments offre diversi corsi di formazione per gli utenti di
LabVIEW. I corsi sono elencati nel catalogo della National Instruments e
online all’indirizzo ni.com/custed. Questi corsi continuano la
formazione che avete ricevuto qui e la espandono in altre aree. Potete
acquistare il materiale dei corsi o iscrivervi ad un corso con istruttore
contattando la National Instruments.
A-19
Appendice
Pubblicazioni di LabVIEW
Newsletter LabVIEW Technical Resource (LTR)
Iscrivetevi al LabVIEW Technical Resource per scoprire consigli e
tecniche potenti per lo sviluppo di applicazioni in LabVIEW. Questa
pubblicazione trimestrale offre informazioni tecniche dettagliate per
nuovi utenti e per utenti avanzati. Inoltre, ogni numero contiene un
dischetto di VI e utility di LabVIEW che implementano metodi trattati nel
numero. Per ordinare LabVIEW Technical Resource, chiamate la
redazione di LTR al numero (214) 706-0587 o visitate il sito
www.ltrpub.com.
Libri di LabVIEW
Sono stati scritti molti libri sulla programmazione e sulle applicazioni in
LabVIEW. Il sito web della National Instruments contiene un elenco di
tutti i libri su LabVIEW e i collegamenti a siti per l’acquisto di questi
libri. Sono anche comprese informazioni sull’editore così potete
contattare direttamente l’editore per ulteriori informazioni sul contenuto e
sull’ordinazione di libri su LabVIEW, di automazione e su misure basate
su PC.
Listserve info-labview
Info-labview è un e-mail group di utenti di tutto il mondo che
discutono su LabVIEW. Gli appartenenti a questa lista possono
rispondere a domande sulla realizzazione di sistemi in LabVIEW per
applicazioni particolari, su dove trovare i driver degli strumenti o fornire
aiuto per un dispositivo e su problemi che si presentano.
Inviate un messaggio di sottoscrizione a info-labview all’indirizzo
[email protected].
Inviate altri messaggi amministrativi al responsabile dell’elenco infolabview a:
[email protected]
Inviate un messaggio agli iscritti a:
[email protected]
Potete anche ricercare tra archivi ftp all’indirizzo:
ftp://ftp.pica.army.mil/pub/labview/
Gli archivi contengono diversi VI, messi a disposizione per l’esecuzione
di una grande varietà di compiti.
A-20
Appendice
E. Tabella delle corrispondenze dei caratteri ASCII
La tabella seguente contiene i codici dei caratteri ASCII e quelli
equivalenti nel sistema esadecimale, ottale e decimale.
Hex
Ottale
Decimale
ASCII
Hex
Ottale
Decimale
ASCII
00
01
02
03
04
05
06
07
08
09
0A
0B
0C
0D
0E
0F
10
11
12
13
14
15
16
17
18
19
000
001
002
003
004
005
006
007
010
011
012
013
014
015
016
017
020
021
022
023
024
025
026
027
030
031
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
NUL
SOH
STX
ETX
EOT
ENQ
ACK
BEL
BS
HT
LF
VT
FF
CR
SO
SI
DLE
DC1
DC2
DC3
DC4
NAK
SYN
ETB
CAN
EM
20
21
22
23
24
25
26
27
28
29
2A
2B
2C
2D
2E
2F
30
31
32
33
34
35
36
37
38
39
040
041
042
043
044
045
046
047
050
051
052
053
054
055
056
057
060
061
062
063
064
065
066
067
070
071
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
SP
!
“
#
$
%
&
‘
(
)
*
+
,
.
/
0
1
2
3
4
5
6
7
8
9
A-21
Appendice
Hex
Ottale
Decimale
ASCII
Hex
Ottale
Decimale
ASCII
1A
1B
1C
1D
1E
1F
40
41
42
43
44
45
46
47
48
49
4A
4B
4C
4D
4E
4F
50
51
52
53
54
55
56
57
58
59
5A
5B
5C
5D
5E
5F
032
033
034
035
036
037
100
101
102
103
104
105
106
107
110
111
112
113
114
115
116
117
120
121
122
123
124
125
126
127
130
131
132
133
134
135
136
137
26
27
28
29
30
31
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
SUB
ESC
FS
GS
RS
US
@
A
B
C
D
E
F
G
H
I
J
K
L
M
N
O
P
Q
R
S
T
U
V
W
X
Y
Z
[
\
]
^
_
3A
3B
3C
3D
3E
3F
60
61
62
63
64
65
66
67
68
69
6A
6B
6C
6D
6E
6F
70
71
72
73
74
75
76
77
78
79
7A
7B
7C
7D
7E
7F
072
073
074
075
076
077
140
141
142
143
144
145
146
147
150
151
152
153
154
155
156
157
160
161
162
163
164
165
166
167
170
171
172
173
174
175
176
177
58
59
60
61
62
63
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
:
;
<
=
>
?
`
a
b
c
d
e
f
g
h
i
j
k
l
m
n
o
p
q
r
s
t
u
v
w
x
y
z
{
|
}
~
DEL
A-22