Mini Curso de LabVIEW

Prof. Eduardo G. Bertogna

DAELN/UTFPR
 O que é LabVIEW
• LabVIEW significa: Laboratory Virtual Instrument
Engineering Workbench.
• O termo Instrumento Virtual se deve ao fato dos
programas em LabVIEW imitarem a aparência de
instrumentos e dispositivos físicos, tais como:
Multímetros, Osciloscópios, Geradores de
Funções, etc.
• LabVIEW é um ambiente de programação gráfica
desenvolvido pela empresa norte-americana
National Instruments (NI) em 1986, sendo usado
por empresas e centros de pesquisas no mundo
todo, inclusive pela NASA e pelo CERN;
 O que é LabVIEW
• A linguagem de programação foi denominada pela NI
como linguagem G;
• Sendo orientada a fluxo de dados usando objetos
gráficos na forma de blocos funcionais representados
por ícones que interconectados constroem a lógica do
programa;
• Os programas criados no LabVIEW são chamados
Instrumentos Virtuais (Virtual Instruments – VIs);
– Os arquivos dos VIs terão extensão: *.vi
• Contém também ferramentas para a depuração do
código.
 O que é LabVIEW
• Aplicações sofisticadas podem ser criadas com a
integração de dispositivos de HW e SW de forma
fácil e natural especialmente nas áreas de:
– Testes; Medições; Controle automático.
• Com LabVIEW é fácil e rápido o interfaceamento
com uma ampla gama de dispositivos de HW como:
– Porta Serial, USB, GPIB, Placas de Aquisição e
Câmeras de Vídeo.
• Contém vasto conjunto de VIs e funções para:
– Aquisição, análise, visualização, armazenamento de
dados, etc.
 O que é LabVIEW
• O LabVIEW contém uma biblioteca extensa de
componentes para realizar análises para:
– Extração de informações;
– Processamento de sinais e imagem;
– Projeto e simulação de sistemas de controle
– Matemática estatística;
– Comunicação de dados e conectividade, etc.
• Com o LabVIEW pode-se desenvolver aplicações
para Sistemas Embarcados e Lógica Reconfigurável
usando dispositivos da NI CompactRIO, myRIO, etc;
• Suportado pelo Windows, Linux e Mac OS X.
Alguns HWs da National Instruments

myDAQ myRIO
Dispositivos para propósitos acadêmicos
 Instrumento Virtual (VI)
• Os VIs podem ser bastante poderosos e sofisticados
com interfaces gráficas elegantes e com inúmeras
funcionalidades.
Tela Inicial do LabVIEW
Criando um VI no LabVIEW
 Criando um novo VI
Painel Frontal

Controls Palete
Diagrama em
Blocos
 Componentes de um VI
• Os VIs contém 2 componentes principais:

– O Painel Frontal (Front Panel) - nesta janela a

interface com o usuário é criada e conterá
Controles e Indicadores.

– O Diagrama em Blocos (Block Diagram) – nesta

janela é onde se adicionam os blocos de funções,
tal que estes implementem o controle dos objetos
do painel frontal e a lógica do VI.
 Controles, Indicadores e Constantes
• Controles, indicadores e constantes se comportam
como entradas e saídas do algorítmo criado.

Indicator
Controles Numérico
Numéricos

Constante
Numerica
 Diagrama em Blocos
Function Nodes e Wires
• Function Nodes são objetos do diagrama em blocos
contendo entradas e/ou saídas e executam operações
na execução do VI, identificados pela cor amarelo claro;
• Nodes usuais são:
– Functions
– SubVIs Numeric Function
Numeric
Control Node
• Wires permitem Indicator

a interconexão dos
Function Nodes.
Wire
 Entendendo o Fluxo de Dados
• O fluxo de dados entre os blocos de funções, SubVIs
e estruturas presentes num diagrama em blocos
atendem as seguintes regras:
– Um node somente é executado quando todos os dados
por este requeridos estiverem disponíveis em seus
terminais de entrada;
– Um node somente fornece dados ao seu terminal de
saída quando sua execução termina;
– O fluxo de dados determina a ordem de execução dos
nodes em um diagrama em blocos;
– Uma vez que podem haver múltiplas entradas e saídas
nos nodes há a possibilidade de execução em paralelo.
 Visão compacta dos Ícones

• Pode-se escolher o
modo de visualização
dos Ícones no modo
compacto.
Functions Palete
Barra de Ferramentas de Execução do VI
Ferramentas Adicionais de Execução do VI
 SubVIs
• SubVI é um VI chamado a partir de outro VI;
• Qualquer VI tem o potencial de ser um SubVI;
• Criar SubVIs confere moduladade ao programa;
• O uso de SubVIs possibilita implementar módulos
separadamente que após testados podem ser
integrados ao VI principal;
• Criação de um SubVI:
– Seleciona-se blocos no diagrama em blocos;
– Evoca-se na barra de ferramentas em Edit, a opção:
Create SubVI, e então, salva este com extensão: .vi
 Express VIs
• Um Express VI é um tipo especial de SubVI que no
diagrama em blocos aparece em azul;
• Esses blocos podem ser expandidos por um duplo
click, que apresentará um Dialog Box oferecendo
opções de configurações diversas.
 Tipos de Dados no LabVIEW
• Através do fluxo de dados de um diagrama em blocos
diversos tipos de dados podem estar fluindo.
• Os tipos básicos de dados são:
– Booleano : admite apenas 2 valores (True e False) e se
apresentam com a cor verde;
– Numérico: representam valores numéricos cujo
formatos admitidos são: Inteiro Sinalizado e Não-
Sinalizado, Ponto Flutuante, Ponto Fixo e Complexo;
– String: representam um vetor de caracteres codificados
em ASCII;
– Enumerado: usado para criar lista de itens, é
constituído de um par de valores, sendo inteiro de 16-
bits e uma string.
 Tipo de Dado Booleano
• Controles e
Indicadores do tipo
Booleano estão na
Sub-Palete Boolean
do Controls Palete
em Modern, Silver
e Classic
 Controles e Indicadores Booleanos
• Painel frontal:

• No diagrama em blocos:
Visão em Ícones Visão Compacta
Ação Mecânica de Controles Booleanos

Switch When Pressed

Switch When Released

Switch Until Released

Latch When Pressed

Latch When Released

Latch Until Released

Ação Mecânica de Controles Booleanos
Switch When Pressed: muda imediatamente o
valor e o mantém até ser acionado novamente ;
Switch When Released: semelhante ao anterior
exceto que muda o valor na liberação do botão;
Switch Until Released: muda imediatamente o
valor e o mantém até que o botão ser liberado
quando o controle retorna ao valor inicial como
numa campainha ;
Latch Until Released: muda imediatamente o
valor até se liberar o botão, ou que o LabVIEW
leia o botão, o que ocorrer primeiro;
Latch When Released: valor muda na liberação
do botão e valor é mantido até o LV ler o botão
quando o controle retorna ao valor inicial;
Latch When Pressed: muda imediatamente o
valor e este é mantido até o LV ler o controle
quando então este retorna ao valor inicial.
 Operações com Dados Booleanos
• Operadores para Booleanos estão na Sub-Palete
Boolean do Functions Palete no Programming Palete
 Tipo de Dado Numérico
•Controles e
Indicadores do
tipo Numérico
estão na Sub-
Palete Numeric
do Controls
Palete em
Modern, Silver e
Classic.
 Dados Numéricos Inteiros
Numeric Unsigned Integer
Terminal Ícone Bits Faixa de Valores

8 0 a 255

16 0 a 65.535

32 0 a 4.294.967.295

64 0 a 2E19

Numeric Signed Integer

Terminal Ícone Bits Faixa de Valores

8 -128 a 127

16 -32.768 a 32.767

32 -2.147.483.646 a 2.147.483.64

64 -1E19 a 1E19
Dados Numéricos Pto Flutuante e Pto Fixo
Numeric Floating Point: Single, Double e Extended Precision
Terminal Ícone Bits Faixa de Valores

32 ±1,40E-45 a ±3,40E38

64 ±4,94E-324 a ±1,79E308

128 ±6,48E-4966 a ±1,19E4932

Fixed-Point e Complex Single, Double e Extended Precision

Terminal Ícone Bits Faixa de Valores

64 Configurável

64 ±1,40E-45 a ±3,40E38

128 ±4,94E-324 a ±1,79E308

128 ±6,48E-4966 a ±1,19E4932

 Conversão Numérica e Coerção
• Pode se fazer Conversão
Numérica usando os blocos
de funções em:
– Functions Palete=>Sub-Palete
Numeric => Conversion
• A coerção numérica ocorre
quando se conecta tipos
diferentes em um bloco de
função, como na situação :

Pto Verm.
coerção
 Operações com Dados Numéricos
• Operadores para Numeric estão na Sub-Palete
Numeric do Functions Palete no Programming Palete
 Operações com Dados Numéricos
• Consta ainda desta Sub-Palete funções para números
complexos e constantes matemáticas:
 Tipo de Dado String
• Controles e
Indicadores do
tipo String
estão na Sub-
Palete String
do Controls
Palete em
Modern, Silver
e Classic
 Operações com Strings
• Na Sub-Palete Strings em Programming do Functions
Palete há grande variedade de funções para strings:
 Modos de Visualização de Strings
• A seguir os possíveis modos de visualização de
uma string:
Representações de Strings
Modo Visualização Descrição

Normal Modo normal de visualização.

Códigos ‘\’ Apresenta os códigos de controle existentes.

Password Coloca asteríscos no lugar dos caracteres.

Hexa Coloca os valores hexadecimais dos caracteres.

 Tipo de Dado Enumerated
• São usados para criar listas de itens usados para
seleção de opções nelas contidas;

• Cada item da lista representa um par de valores, um

deles uma string e o outro um inteiro de 16 bits.
• A constante enumerada se encontra na Sub-Palete
Numeric do Functions Palete;
• O controle enumerado se encontra em Ring & Enum
do Controls Palete em Modern, Silver ou Classic.
 Estruturas de Repetição no LabVIEW
• Há 2 tipos de estruturas
de repetição no
LabVIEW:
– While Loop e For Loop
• Ambas encontra-se no
Functions Palete em
Structures.
 Estrutura While-Loop
• Essa estrutura tem a forma de um laço e repetirá a
execução do subdiagrama no seu interior enquanto a
condição no terminal booleano Loop Condition estiver
sendo atendida, sendo i o contador de iterações.

Stop if True Continue if True

– Na condição Stop if True um valor true entrando no loop
condition termina a execução do laço;
– Na condição Continue if True um valor false entrando no
loop condition termina a execução do laço.
 Exemplo de uso do While-Loop
• O controle booleano Raiz/Quadr seleciona a
operação matemática raiz quadrada ou potência
de 2 do número de entrada x, colocando em
Resultado.
 Estrutura For-Loop
• Essa estrutura tem a forma de um bloco de folhas e
repetirá a execução do subdiagrama no seu interior
até que N iterações sejam executadas, sendo que no
terminal N um valor numeric inteiro deve ser
conectado para definir o número de iterações;

• No For-Loop o contador de iterações inicia em zero e

vai até N-1.
 Exemplo de uso do For-Loop
• O fatorial de N é calculado, sendo N a entrada do valor
de repetição do For-Loop cujo contador de iterações
incrementado de 1 é multiplicado pelo valor da
iteração anterior, e então, por exemplo para N=3, após
3 iterações resulta:
– Iteração 1: 1x1=1
– Iteração 2: 1x2=2
– Iteração 3: 2x3=6
 While-Loop versus For-Loop
• O subdiagrama de um While-Loop executará ao menos
uma vez, o For-Loop poderá nunca executar caso N=0.
 Shift Registers
• No cálculo do Fatorial de N foi usado o contador de
iterações do For-Loop incrementado de 1 e então
multiplicado pelo valor da iteração anterior:
– O elemento da linguagem G que possibilita armazenar o
valor produzido em uma iteração é o Shift Register;
– Este elemento é representado pelas setas azuis em direções
opostas nas bordas laterais da estrutura de repetição
Valor inicial do Shift Register
Shift Register
 Stacked Shift Register
• Quando se deseja mais valores de múltiplas
iterações passadas pode-se usar um Stacked SR

• No exemplo os 3 últimos valores das 3 iterações

anteriores estão disponíveis para o cálculo da
multiplicação destes pelo valor de i, então, são
todos somados e colocados no indicador Res.
 Nó de Realimentação – Feedback Node
• Quando se tenta conectar uma saída de um bloco
de função à entrada do mesmo bloco um nó de
realimentação é criado.
• O nó de realimentação é na verdade uma memória
como no caso do SR, sendo uma alternativa à este.
Valor inicial do Feedback Node
Feedback Node
Comutando um Feedback Node para Shift
Register e Vice-Versa
 Túneis - Tunnels
• O Tunnel permite que dados sejam providos de uma
estrutura a outra, identificado como um bloco sólido
na borda da estrutura.
Tunnel

• O Tunnel admite 4 modos de operação:

 Tunnels - Modos de Operação
• Last Value: apresenta o último valor produzido;
• Auto-Indexing: apresenta os valores de todas iterações
anteriores na forma de um array de dimensão igual ao
número de iterações;

• Conditional: dado somente atravessa o Tunnel se a

condição é atendida.
 Temporização de um Loop
• Numa estrutura de repetição quando uma iteração
termina a próxima é executada imediatamente;
• Para se temporizar um loop pode-se usar as funções
Wait(ms), Wait Until Next ms Muliple, Time Elaspsed e
Time Delay Express VIs na Sub-Palete Timing:
 Diferençcas entre Wait(ms), Wait Until Next
ms Multiple e Elapsed Time Express VI
• Wait (ms): apenas gera um atraso de tempo, e caso o
subdiagrama leve mais tempo para excutar o tempo da
iteração será somado ao do tempo de atraso;
• Wait Until Next ms Multiple: termina a iteração após
um múltiplo em ms especificado na sua entrada, mesmo
que o subdiagrama não tenha terminado sua execução;
• Elapsed Time Express VI: usada para determinar quanto
tempo transcorre após um determinado ponto do VI.
Pode ser usado para terminar um loop após um tempo
determinado gerando um timeout.
 Exemplo de uso de Temporização
de um While-Loop
• Após 5 segundos o while-loop é terminado e o nr de
ocorrências de valores maiores que 0,99 gerados
pelo bloco de função random a cada 1 milisegundo
é apresentado.
 Estruturas de Decisão no LabVIEW
• Há essencialmente 2 estruturas de decisão no LV:
– Case Structure: usado quando declarações
condicionais são executadas, como no caso de if-
them-else ou switch nas linguagens textuais;
– Event Structure: semelhante ao Case Structure
exceto que as condições ficam associadas a
eventos que podem ser originados por 3 fontes
diferentes:
1. Ações nos controles do painel frontal;
2. Dispositivos de E/S;
3. Outras partes do programa.
 Case Structure
• Nesta estrutura há diversos quadros sobrepostos
que conterão subdiagramas que são selecionados
pelo case selector (?), como mostrado abaixo
num exemplo simples:
 Event Structure
• Um Event Structure normalmente estará dentro de
uma estrutura de repetição para repetidamente
atender aos eventos, tendo a seguinte aparência:
 Criando uma Event Structure
• Suponha que desejemos um VI que faça 2 tarefas:
– Converta uma temperatura em Celsius para Farenheit
sempre que se digitar um novo valor em Temp(°C);
– Apresentar a Data/Hora sempre que se atuar no botão
Data/Hora;
• Uma vez que se tenham controles no painel frontal,
pode-se criar uma estrutura de eventos para os 3
controles do Painel Frontal.
 Criando uma Event Structure
• Inicia-se colocando uma Event Structure dentro de um
While-Loop
– Obseve os ícones dos controles criados no painel frontal
 Criação dos Eventos
• Evoca-se o pop-up menu na barra da Event Structure
 Criação do Evento Date/Time
• Selecionar em Event Source: Date/Time
• Selecionar em Events: Value Change
 Criação do Evento Date/Time
• Criar o subdiagrama para esse evento:
– Saída da função Get Date/Time in Seconds conectado
ao indicador current time:
 Criação do Evento Celsius para Farenheit
• Evocando-se o pop-up menu na barra da Event
Structure escolher: Add Event Case...
 Criação do Evento Celsius para Farenheit
• Selecionar a fonte do evento o controle: Temp(°C),
e evento: Value Change.
 Criação do Evento Celsius para Farenheit
• Criar o subdiagrama para esse evento:
– Entrada Temp(°C) conectado ao diagrama em blocos que
implementa a conversão, e saída conectada ao indicador
Temp(°F):
 Criação do Evento Stop
• Criar um evento para o controle Stop como feito para
os demais eventos, conectando esse controle ao Loop
Condition via túnel.
 Estruturas Sequenciais no LabVIEW
• Usadas quando se deseja determinar a ordem de
execução do fluxo de dados;
• São de 2 tipos: Flat Sequence e Stacked Sequence

Flat Sequence Stacked Sequence

Observar a aparência semelhante a quadros de um
filme que implica em sequência temporal.
 Estruturas de Dados
• Arrays
– Usados quando se deseja agrupar dados do mesmo tipo;
– Esses dados podem ser oriundos, por exemplo, de
cálculos repetitivos, ou de uma sequência de medidas
efetuadas de alguma variável física adquirida através de
um sensor, por exemplo de temperaturas;
• Clusters
– Usados quando se deseja agrupar dados de diferentes
tipos, porém quem mantém alguma relação;
– Como exemplo as medidas de temperatura mencionada
podem ser associadas ao instantes de tempo em que
ocorrem.
 Arrays
• Os elementos de um array são ordenados por um
índice;
• O índice sempre inicia em zero, por exemplo, num
array de N elementos, o índice varia de 0 a N-1;
• Através do índice é possível acessar um elemento
específico do array;
• Os arrays podem ter uma ou mais dimensões;
• Um array de 2 dimensões conterá 2 linhas e N
colunas;
• Um array de 3 dimensões pode ser pensado
como uma pilha de tabelas de 2 dimensões.
 Criando um Array
• No painel frontal, através do
Controls Palete, na Sub-Palete
Array, Matrix & Cluster, inserir
um array vazio.

• Em seguida criar um controle ou

indicador no interior deste array:

Array de Controles Array de Indicadores

 Criando um Array
• Pode agora expandir a
visualização do array
arrastando a borda direita
do array com o mouse;
• Pode-se então, digitar os
valores iniciais do array
sejam eles numeric ou
string;
• Para adicionar dimensões ao array => menu pop-up => Add
Dimension:
Linha
Linha 0
Coluna Linha 1
Coluna 0 Coluna 1 Coluna 2
 Funções para Manipulação de Arrays
• As funções para
strings podem ser
encontradas no
Functions Palete
em Programming,
Sub-Palete Array.
Exemplo de Algumas Funções
para String
 Criação de Clusters
• No painel frontal, através do Controls
Palete, na Sub-Palete Array, Matrix &
Cluster, inserir um cluster vazio.

• Em seguida arrastar controle e/ou

indicadores para o interior do cluster:
 Criação de Clusters
• Arrastar controle e/ou indicadores para o interior do cluster:
 Extraindo Elementos de Clusters
• Esta tarefa é feita através da função Unbundle By
Name no Sub-Palete Cluster em Programming do
Functions Palete:

• Pode-se então operar sobre esses dados;

• Caso se deseje inserir dados em elementos de um
cluster usa-se a função Bundle By Name:
 Operando com Elementos de Clusters
• Exemplo:
 Plotando Dados
• Para a visualização de dados na forma gráfica
o LV fornece 2 estruturas: Charts e Graphs:
– Chart: plota dados de forma iterativa, ou seja,
assim que se tornam disponíveis são inseridos
no plot;
– Graphs: não permite a inserção de dados de
forma iterativa, sendo necessário que esses
dados estejam prontos na forma de um array
de valores para poder ser apresentado;
• Graphs podem ser do tipo Waveform Graph e
XY Graph.
 Waveform Chart
• Encontrado na Sub-palete Graph do Controls Palete.

• Multi-Plot Chart
 Waveform Graph
• Encontrado na Sub-palete
Graph do Controls Palete.
• Neste caso um array de
dados deve ser preparado
antes de ser conectado ao
Waveform Graph, como no
diagrama em blocos a
seguir:
Waveform Graph – Formas de Uso
Waveform Graph – Formas de Uso
 Aquisição de Som
• Aqui dados sonoros via
microfone da placa de som
são mostrados num
Waveform Chart
continuamente.
 Geração de Som
• Aqui dados sonoros são
garados via placa de
som e mostrados num
Waveform Chart
continuamente.
 Aquisição de Dados com Placas DAQ
• A forma mais efetiva de se implementar um
sistema de aquisição de dados com LabVIEW é
usando-se um dispositivo de hardware para
aquisição de dados (DAQ).

Sensor DAQ LabVIEW como

(Encoder) (USB6008) Instrumento Virtual
 Criando uma Aplicação com NI-DAQ
• Com o NI-DAQmx instalado, o controle de um dispositivo
NI-DAQ pode ser feito através dos SubVIs da Subpalete
NI-DAQmx do Functions Palete em Measurement I/O:
 Criando uma Aplicação com NI-DAQ
• Numa aplicação típica de aquisição de dados
usando o DAQmx, a seguinte sequência de SbVIs
devem estar presente:
– Create Vrtual Channel;
– Configure Task;
– Start Task;
– Acquire/Generate Data;
– Stop Task;
– Clear Task;
– Check for Errors.
 Aplicação com o NI-DAQ USB6008
• Diagrama em Blocos:

• Painel Frontal:
 Aplicação com o NI-DAQ USB6008
• Diagrama em Blocos com um SubVI adicional para a
configuração da amostragem do sinal de entrada:

• SubVI Timing: configurado a amostragem do sinal

de entrada de forma contínua e com uma taxa de
amostragem de 1000 Hz.
Pinagem do myDAQ e USB6008
 Máquina de Estados
• A forma mais
eficiente de se
constituir um VI
mais complexo é
através de uma
Máquina de
Estados;
• Pode-se fazer uso
de um template
ao se criar um
novo projeto em
Create Project.
Exemplo de Máquina de Estados
Máquina de Estados
Estado Inicial
Máquina de Estados
Evento Exit
Máquina de Estados
Evento: Tarefa 1
Máquina de Estados
Evento: Tarefa 2
Máquina de Estados
Estado Exit