fbpx

Anteprima ByteGS_22

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.

bytegs

 

Corso LabVIEW e Arduino

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.

 

Costruisci il tuo test sequencer con OOP e Variant LookUpTable

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


 

 

Poll a Process what is the right?

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.

ReEnque Message after acquisition 

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.

 

Use Timeouts 

 

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.

 

 

Object Oriented Queue Message Handler

QMH dal cluster Stringa/Variant alle Classi

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:

Corso LabVIEW – IISFerrara

CORSO LabVIEW Laboratorio di Tecnologia e Progettazione di Sistemi Elettronici ed Elettrotecnici – IIS Ferrara

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:

  • Speed and position PID controller with analog and digital transducers of a DC motor;
  • PID pressure control with a proportional valve;
  • Realization of a Virtual Instrument (driver) for an HVAC motors.

 

IIS Ferrara corso LabVIEW

Corso LabVIEW- IMEM Parma

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.

 

 

 

Our Last Works

 

 

 

 

 

 

I nostri ultimi lavori

 

 

Meccanica
Ecco i progetti relativi alla meccanica

Read More

Our Team Members
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed nec enim euismod, elementum enim ac, posuere augue. Duis interdum metus non elementum gravida.

Read More

More Facts About Us
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed nec enim euismod, elementum enim ac, posuere augue. Duis interdum metus non elementum gravida.

Read More

Our Latest Projects
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed nec enim euismod, elementum enim ac, posuere augue. Duis interdum metus non elementum gravida.

Read More

Our Latest Photographic Projects

Find Out More About Us

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed nec enim euismod, elementum enim ac, posuere augue. Duis interdum metus non elementum gravida.

Read More

Share a Little Love

Come For a Visit

Broadway,
New York, NY
USA

Google Map