Nuovo aggiornamento in arrivo.
Abbiamo ascoltato i vostri suggerimenti!
Stiamo terminando la versione 22 che avrà lo stesso database quindi potrete continuamente continuare ad utilizzarlo senza perdere i vs dati, ma un interfaccia completamente rinnovata.
Sono state migliorate ulteriormente le maschere di inserimento al fine di ridurre i tempi di inserimento dati e migliore esperienza d’uso.
Ecco alcuni screenshot, ci piacerebbe ricevere commenti.
Nell’ambito del progetto alternanza Scuola-Lavoro, abbiamo organizzato un corso LabVIEW e Arduino.
I ragazzi di 4^ hanno realizzato delle acquisizioni da diversi sensori con ARDUINO e hanno poi realizzato delle interfacce di datalogging in LabVIEW.
I ragazzi si sono ambientati rapidamente alla programmazione grafica, intuitiva per gli Elettronici.
Vogliamo realizzare un test sequencer semplice per testare la versatilità dei Variant Set/Get Attribute, utilizzati come lookup table e l’utilizzo delle classi come valori.
Iniziamo con creare le classi per i Test:
Classe Test : Rappresenta la classe astratta con un metodo Test.VI che verrà riscritto(Override) nelle classi che ereditano da Test.
Procedimento: Andare su my computer e NEW/Class quindi spostarsi sulla classe Test appena creata e NEW/Vi from Dynamic Dispatch Template
Classe Test01: Eredita dalla classe Test e ne riscrive il metodo Test.vi
Procedura : Creare una nuova classe, quindi andare nelle property della classe appena creata, quindi in Inheritance , premere change inheritance e selezionare la classe test.
Ora eseguiamo l’override del metodo test selezionando la casse Test01 e New/vi from override, selezioniamo Test.vi
Classe Test 2 : identica procedura della classe Test01
Al termine della procedura avremo cliccando show hierarchy sulla classe Test, la seguente gerarchia che mostra la relazione Padre/Figli tra la classe astratta Test e le classi figlio Test01 e Test02.
Il progetto mostrerà come da figura le classi con i relativi metodi Test.vi.
Ora creiamo un vi (da myComputer, New VI) e trasciniamo le classi Test01 e Test02, quindi andiamo nella palette Variant e trasciniamo il Variant Set attribute(ne serviranno 2).
Colleghiamo la classe Test come ingresso del variant(non è obbligatorio, si può mettere anche un variant o altro).
Completare inserendo un For Loop (per farlo eseguire in modo continuo ho messo un while) in cui eseguire i test come nell’immagine successiva.
Quindi eseguendo il vi, il Get Variant Attribute seleziona la classe associata alla chiave di testo che ho associato nel Set Attribute.
Utilizzare questo modello per creare delle lookup table ha il vantaggio di inserire direttamente diversi tipi di dato, diversamente dei modelli basati sugli array è dinamico diversamente dall’utilizzo dei cluster e soprattutto come potrete trovare googlando sul tema, ha un algoritmo di ricerca non lineare che lo rende estremamente piu veloce.
Scarica il progetto e i vi già pronti:
Approfondimenti e ispirazioni:
ftp://ftp.ni.com/pub/events/webcasts/variant_attribute_lookup_table.pdf
https://forums.ni.com/t5/LabVIEW-Development-Best/Using-Variant-Attributes-for-High-Performance-Lookup-Tables-in/ba-p/3478922
What is the right design to create continuous polling process?
What is the typical behavior of polling process?
One of the most question, in development of our software, is how we create polling process, for example an acquisition process.
But the first question is what is a polling process? What’s the properties and add features?
Polling is process where someone asks, waits and receives something from someone else.
Is something like this.
Properties and fundamental question is Wait Time, Msg Sent, Msg Received, how it start?, how it stop.
In QMH, or other message based framework, this process need communicate from and to other processes.
Two kind of implement is Resending Msg and Timeout.
Issue : Other messages may not be executed, especially if sent by other slower processes.
Benefit : Not require timeout or contiuous poll
Solution: Enqueue on the opposite side for priority messages, and before turning on again, look for other messages in the queue and if they are different from the polling message.
As a sample GetStatus retrieve msg’s from queue and check if Acquire msg are present, if not enque.
Benefit: Timeout solves the problem, the code is then executed only if no messages have been sent.
Issue: Need some code to prevent the code from running in an uncontrolled manner, for example without first being initialised.
Il QMH si basa su un architettura producer consumer utilizzando la coda per eseguire azioni e passare i dati.
Il modello del messaggio nel QMH è basato su un cluster Stringa(comando da eseguire) e Variant (dato da passare).
Proviamo a sfruttare le caratteristiche OOP come astrazione ed ereditarietà per modificare il modello QMH.
Creiamo una classe Message con i seguenti metodi DinamicDispatch : Send, Do, Stop
Procedura : Andiamo su MyComputer e clicchiamo NewClass, quindi New Vi from Dinamic Dispatch e salviamo come Do.vi, quindi ancora per send.vi e stop.vi.
Modifichiamo Send.vi inserendo una reference alla coda (Enqueuer) come input (questa coda deve essere creata con il tipo di dato Classe Message).
Modifichiamo Stop.vi inserendo un led come output e lo settiamo con una costante a False
Ora abbiamo creato una classe Message che viene ereditata per i comandi dei vari processi.
Creiamo quindi il processo Process1.
Prima creiamo una libreria (non è obbligatorio, ma è un buon metodo per tenere in ordine le cose).
Quindi Creiamo il Process1.vi e lo inseriamo nella library Process1.lvlib
Ora il nostro progetto dovrebbe apparire come nell’immagine:
Selezioniamo Process1.lvlib e facciamo NEW CLASS, e la nominiamo Init (un caso sempre esistente).
Facciamo tasto destro sulla classe Init, quindi properties e Inheritance, cliccare “Change Inheritance” e selezionare la classe Message creata in precedenza.
Ora possiamo riscrivere i metodi necessari per questa classe, facendo tasto destro e NEW/VI for Override e selezioniamo Send e Do.
Creiamo un vi per eseguire il metodo Send.vi in modo che possiamo incapsulare la costante della classe Init. Per farlo andiamo sulla classe Init e NEW/Vi from Static dispatch Template, modifichiamo il vi trascinando il metodo send come mostrato in figura.
Ora abbiamo il Send del messaggio da posizionare nel vi per generare l’azione Do per la classe Init.
Creiamo la classe Stop e dopo aver modificato l’inheritance dalla classe message, creiamo gli override per Stop e Send.
Stessa cosa per la error class che eredita solo error e send.
Per tutti gli altri messaggi saranno eseguiti dal Do e quindi ereditiamo sempre Send e Do per ogni altra classe creata.
Allo stesso modo creeremo i comandi che ci servono, ora però creiamo il main.vi come da immagine.
Ora il codice del process non necessita piu di modifiche, lavoriamo direttamente sul progetto creando le classi per gli altri messaggi.
Ecco l’interfaccia main terminata :
E il Diagramma del Main.VI
Se vuoi scaricare il progetto di esempio puoi farlo da qui:
Lunedi 27 Marzo inizia il nostro corso agli studenti dell IIS Ferrara.
LabVIEW è uno strumento trasversale e utile, indipendentemente dalle conoscenze informatiche.
Nell’occasione saranno studiati, e risolti, alcuni casi reali, come ad esempio:
IMEM-CNR di Parma Corso LabVIEW
Corso finalizzato alla creazione di applicazioni di interfacciamento con strumentazione GPIB/Seriale.
Durante il corso sono state approfondite tematiche sulla creazione di librerie di interfacciamento riutilizzabili e importazione dei driver.
Creazione di un applicazione di esempio basata su macchina a stati con gestione delle eccezioni.
Presentazione dei dati e registrazione su file.
