LabVIEW Graphical Programming Cookbook-1-50

Machine Translated by Google
Gráfico LabVIEW
Programação
Livro de receitas
69 receitas para ajudá-lo a construir, depurar e

implantar aplicações modulares usando LabVIEW
Yik Yang
BIRMINGHAM - MUMBAI
Livro de receitas de programação gráfica do LabVIEW
Direitos autorais © 2014 Packt Publishing
Todos os direitos reservados. Nenhuma parte deste livro pode ser reproduzida, armazenada em um sistema de
recuperação ou transmitida de qualquer forma ou por qualquer meio, sem a permissão prévia por escrito do editor,
exceto no caso de breves citações incorporadas em artigos críticos ou resenhas.
Todos os esforços foram feitos na preparação deste livro para garantir a precisão das informações apresentadas. Contudo,
as informações contidas neste livro são vendidas sem garantia, expressa ou implícita. Nem o autor, nem a Packt
Publishing e seus revendedores e distribuidores serão responsabilizados por quaisquer danos causados ou supostamente
causados direta ou indiretamente por este livro.
A Packt Publishing tem se esforçado para fornecer informações de marcas registradas sobre todas as empresas e produtos
mencionados neste livro através do uso apropriado de letras maiúsculas. No entanto, a Packt Publishing não pode
garantir a exatidão desta informação.
Publicado pela primeira vez: janeiro de 2014
Referência de produção: 1160114
Publicado por Packt Publishing Ltd.

Lugar de libré
Rua Livery, 35
Birmingham B3 2PB, Reino Unido.
ISBN 978-1-78217-140-9
www.packtpub.com
Imagem da capa de Zarko Piljak (zpiljak@gmail.com)

Créditos
Autor Editores de cópia
Yik Yang Sayanee Mukherjee
Lavina Pereira
Revisores
Amit Dongol Coordenador de projeto

Chris Larson Venitha Cutinho
Qizhen Ruan
Justin Smith Revisor
Amy Johnson
Editor de Aquisição
Rubal Kaur Indexador
Mehreen Deshmukh
Editores técnicos líderes

Coordenador de produção
Madhuja Chaudhari
Conidon Miranda
Mandar Gate
Trabalho de capa
Editores Técnicos
Conidon Miranda
Tanvi Bhatt
Dipika Gaonkar
Mônica João
Neha Mankare
Sobre o autor
Yik Yang é um engenheiro de testes que mora em Chicago e se especializou em automação e

análise de dados. Tendo atuado em diversas áreas como semicondutores, automotiva e
energia, ele tem experiência com diversos tipos de automação e entende quais são as
necessidades das indústrias.
Ele iniciou sua carreira após receber seu bacharelado e mestrado em Engenharia Elétrica
pela Virginia Tech. Em sua carreira, trabalhou em projetos de automação que utilizaram
CompactDAQ, PXI, FPGA e assim por diante em LabVIEW. Ele também passou muito tempo
com Lean Six Sigma e análise estatística com JMP. Ele é engenheiro profissional certificado
(PE) na Carolina do Norte e desenvolvedor certificado do LabVIEW (CLD).
Gostaria de agradecer à minha esposa Qian e ao meu filho Elijah. Eles me

deram muito amor e apoio no processo de finalização deste livro. Mais
importante ainda, gostaria de agradecer a Deus, pois sem ele eu não estaria vivo
e seria capaz de escrever este livro depois do terrível acidente de bicicleta,
quando fui diretamente atropelado por um caminhão.
Sobre os revisores
Amit Dongol é candidato a doutorado (Física). Ele está trabalhando na montagem de um laboratório de
pesquisa com interface LabVIEW para aquisição de dados.
Chris Larson usa o LabVIEW há nove anos. Atualmente ele trabalha como pesquisador e desenvolvedor
de funcionalidades baseadas em nuvem para LabVIEW. Ele é especialista no desenvolvimento de
sistemas que aproveitam o mundo conectado e a Internet.
Chris aprendeu LabVIEW enquanto trabalhava no laboratório de Pesquisa e Desenvolvimento SEMS da

3M. Enquanto estava na 3M, ele criou vários sistemas baseados em LabVIEW para desenvolver e fabricar
produtos para as divisões da 3M, incluindo segurança e proteção, exibição e gráficos e cuidados de saúde.
Suas contribuições incluem projetos de antenas para rastreamento de arquivos RFID, fabricação
aprimorada de materiais retrorrefletivos, controle de qualidade aprimorado para filmes de brilho de
exibição e fabricação aprimorada em alta velocidade de fitas médicas especiais.
Qizhen Ruan é engenheiro de software. Ele tem mais de 13 anos de experiência em

desenvolvimento em LabVIEW. Ele projetou e desenvolveu muitos recursos do LabVIEW.
Justin Smith é formado em Ciência da Computação pela Tennessee Technological University e

atualmente é integrador de sistemas e soluções em uma empresa de TI industrial em Nashville,
Tennessee. Ele desenvolve software básico para interface com hardware e software de terceiros e
recentemente introduziu esse software como módulos no LabVIEW. Principalmente um desenvolvedor
Java, Justin tem usado ferramentas de código aberto para permitir que o código seja executado no LabVIEW.
Tendo crescido rodeado de computadores nos anos 80, Justin sempre soube que queria seguir uma
carreira na área da computação. Depois de estagiar na faculdade e passar mais de um ano no México
Central para sua empresa, ele percebeu todo o bem que pode ser feito ajudando a melhorar os
processos industriais (segurança, qualidade, eficiência). Isso o fez decidir que queria continuar
trabalhando em TI industrial e automação. Ele também sentiu que a indústria transformadora ainda
não viu as mesmas revoluções tecnológicas que outros sectores empresariais através dos avanços de
empresas como o Facebook e o Google.
Justin trabalha para a Summit Management Systems, Inc de Nashville, Tennessee há quase 10
anos. Comemorando seu 20º aniversário de negócios, a Summit Management Systems oferece
integração personalizada e soluções de processo em todo o mundo para o setor industrial e de
manufatura, bem como vários pacotes de software independentes que auxiliam na aquisição de
dados de dispositivos industriais e software para sistemas de gerenciamento de fluxo de trabalho de fabricação.
Gostaria de agradecer ao meu pai por todas as oportunidades que ele me deu
para me tornar quem eu sou. Desde me permitir crescer em torno de computadores
até me incentivar a entrar no campo de desenvolvimento de software, ele é a razão
pela qual pude trabalhar neste livro e revisá-lo. Obrigado pai.
www.PacktPub.com
Arquivos de suporte, e-books, ofertas de descontos e muito mais

Você pode querer visitar www.PacktPub.com para arquivos de suporte e downloads relacionados ao
seu livro.
Você sabia que a Packt oferece versões em e-book de todos os livros publicados, com arquivos PDF e ePub
disponíveis? Você pode atualizar para a versão do e-book em www.PacktPub.com e como cliente do livro impresso, você
tem direito a um desconto na cópia do e-book. Entre em contato conosco em service@packtpub.com para mais
detalhes.
Em www.PacktPub.com, você também pode ler uma coleção de artigos técnicos gratuitos, inscrever-se em uma
variedade de boletins informativos gratuitos e receber descontos e ofertas exclusivas em livros e e-books Packt.
MT
http://PacktLib.PacktPub.com
Você precisa de soluções instantâneas para suas questões de TI? PacktLib é a biblioteca de livros digitais online da
Packt. Aqui você pode acessar, ler e pesquisar toda a biblioteca de livros da Packt.
Por que assinar?

f Totalmente pesquisável em todos os livros publicados pela Packt
f Copie e cole, imprima e marque conteúdo
f Sob demanda e acessível via navegador da web
Acesso gratuito para correntistas Packt

Se você possui uma conta na Packt em www.PacktPub.com, você pode usar isso para acessar o PacktLib hoje
e visualizar nove livros totalmente gratuitos. Basta usar suas credenciais de login para acesso imediato.
Índice
Prefácio 1
Capítulo 1: Compreendendo o ambiente LabVIEW 5
Introdução 5
Configurando itens essenciais 6
Configurando o drop rápido 9
Usando ferramentas de depuração 10
Criando sonda personalizada 12
Compilando EXE 14
Depurando EXE 16
Compilando um aplicativo independente 19
Capítulo 2: Personalizando a interface do usuário 21

Introdução 21
Personalizando controles 22
Adicionando um menu para tempo de execução 27
Criando um diálogo 30
Dimensionando a caixa de diálogo automaticamente 33
Usando controle de imagem 2D 38
Atualizando controles com um mecanismo de ação 40
Criando uma animação simples 44
Criando subpainéis 45
Capítulo 3: Trabalhando com Arquiteturas Comuns 49

Introdução 49
Trabalhando com uma estrutura de caso 50
Trabalhando com uma estrutura de eventos 52
Trabalhando com loops 57
Usando a arquitetura da máquina de estado 59
Usando a arquitetura mestre-escravo 64
Índice
Usando a arquitetura produtor-consumidor 66

Criando um SubVI 69
Criando um mecanismo de ação 71
Chamando um VI por referência 74
Chamando um VI dinamicamente 75
Criando um VI reentrante 77
Capítulo 4: Gerenciando Dados 79

Introdução 79
Usando terminais de erro 79
Usando a estrutura de sequência plana 81
Usando o nó de feedback 82
Reutilizando memória 84
Manipulando uma matriz 88
Usando encontro 89
Usando semáforo 90
Capítulo 5: Passando Dados 95

Introdução 95
Usando um cluster type-def 95
Usando uma estrutura de eventos para passar dados 99
Usando uma fila para passar dados 104
Usando um notificador para passar dados 106
Usando uma variável compartilhada para passar dados 109
Usando mensagens TCP/IP simples para transmitir dados 111
Capítulo 6: Tratamento de Erros 115

Introdução 115
Passando um erro 115
Lidando com um erro com um arquivo de erro 118
Lidando com um erro com um VI centralizado 120
Criando uma fila de erros 123
Capítulo 7: Trabalhando com Arquivos 127

Introdução 127
Trabalhando com arquivos INI 127
Trabalhando com arquivos XML 132
Trabalhando com arquivos ASCII 139
Trabalhando com arquivos binários 141
Trabalhando com arquivos TDMS 143
Usando Telnet e FTP com arquivos 146
Trabalhando com um banco de dados 152
eu
Índice
Capítulo 8: Compreendendo a aquisição de dados 155

Introdução 155
Usando MAX 155
Trabalhando com VISA 161
Usando os servidores VISA 163
Controlando um osciloscópio 165
Usando um dispositivo DAQ simples 172
Usando um CompactDAQ 178
Capítulo 9: Simplificando o Código 183
Introdução 183
Usando VI polimórfico 183
Simplificando a seleção lógica 187
Usando uma matriz para computação 190
Formatando em string 192
Pesquisa rápida de array 194
Usando caminhos relativos em EXE 196
Capítulo 10: Trabalhando com Código Externo e Aplicativos 199
Introdução 199
Compilando uma 199
DLL usando uma 204
DLL .NET Depurando uma 208
DLL .NET usando uma 213
DLL baseada em 217
C Usando ActiveX 221
Construindo um serviço web 223
Usando SMTP para enviar e-mail Índice 231
iii
Prefácio
LabVIEW é uma linguagem de programação gráfica da National Instrument. Principalmente, é usado em campos de
teste e automação para controle de instrumentos, aquisição de dados e assim por diante. Neste livro, cobriremos
diferentes áreas da programação em LabVIEW com exemplos práticos que seguem padrões de codificação e regras
de design sólidos.
O que este livro cobre

O Capítulo 1, Entendendo o ambiente LabVIEW, aborda configurações e funções comuns no ambiente LabVIEW.
O Capítulo 2, Personalizando a interface do usuário, aborda diferentes funções usadas na criação de uma UI.
O Capítulo 3, Trabalhando com Arquiteturas Comuns, aborda arquiteturas comuns no LabVIEW.
O Capítulo 4, Gerenciando dados, aborda como usar a memória com eficiência e controlar o fluxo de dados.
O Capítulo 5, Passagem de dados, aborda diferentes métodos de transmissão de dados.
O Capítulo 6, Tratamento de Erros, aborda diferentes métodos de tratamento de erros.
O Capítulo 7, Trabalhando com Arquivos, aborda como trabalhar com diferentes tipos de arquivos.
O Capítulo 8, Compreendendo a aquisição de dados, aborda a aquisição de dados com diferentes tipos de
instrumentos.
O Capítulo 9, Simplificando Código, aborda maneiras de simplificar código.
O Capítulo 10, Trabalhando com código e aplicações externas, aborda como usar código e aplicações externas
no LabVIEW.
Prefácio
O que você precisa para este livro

Os exemplos neste capítulo foram escritos no ambiente de desenvolvimento LabVIEW 2012, mas também funcionam no
LabVIEW 2013. O ambiente de desenvolvimento vem em pacotes diferentes.
O pacote mais alto é o pacote de desenvolvedores. Alguns exemplos neste livro requerem kits de ferramentas
incluídos no pacote de desenvolvedores. É mais econômico comprar o pacote de desenvolvedores do que comprar os kits
de ferramentas individualmente. Para adquirir o pacote de desenvolvedores, visite www.ni.com.
Para quem é este livro

O livro é destinado a leitores que conhecem os recursos básicos do LabVIEW até os avançados.
Programadores LabVIEW.
Convenções
Neste livro, você encontrará vários estilos de texto que distinguem diferentes tipos de informação. Aqui estão alguns
exemplos desses estilos e uma explicação de seu significado.
Palavras de código em texto, nomes de tabelas de banco de dados, nomes de pastas, nomes de arquivos,
extensões de arquivos, nomes de caminhos, URLs fictícios, entrada do usuário e identificadores do Twitter são mostrados
a seguir: "Crie o VI principal que chama Coordinates.vi. "
Novos termos e palavras importantes são mostrados em negrito. As palavras que você vê na tela, em menus ou
caixas de diálogo, por exemplo, aparecem no texto assim: "Clique com o botão direito no anel da imagem e selecione
Adicionar item."
Avisos ou notas importantes aparecem em uma caixa como esta.
Dicas e truques aparecem assim.
Feedback do leitor
O feedback dos nossos leitores é sempre bem-vindo. Deixe-nos saber o que você pensa sobre este livro—
o que você gostou ou pode ter não gostado. O feedback do leitor é importante para desenvolvermos títulos que você realmente
aproveite ao máximo.
Para nos enviar um feedback geral, basta enviar um e-mail para feedback@packtpub.com e mencionar o título do livro
no assunto da sua mensagem.
Se houver um tópico no qual você tem experiência e estiver interessado em escrever ou contribuir para um livro,
consulte nosso guia do autor em www.packtpub.com/authors.
2
Prefácio
Suporte ao cliente
Agora que você é o orgulhoso proprietário de um livro Packt, temos uma série de coisas para ajudá-lo a aproveitar
ao máximo sua compra.
Errata
Embora tenhamos tomado todos os cuidados para garantir a precisão do nosso conteúdo, erros acontecem.
Se você encontrar um erro em um de nossos livros – talvez um erro no texto ou no código – ficaríamos gratos se
você nos relatasse isso. Ao fazer isso, você pode evitar a frustração de outros leitores e nos ajudar a melhorar
as versões subsequentes deste livro. Se você encontrar alguma errata, informe-a visitando http://
www.packtpub.com/submit-errata, selecionando seu livro, clicando no link do formulário de envio de
errata e inserindo os detalhes de sua errata. Assim que sua errata for verificada, seu envio será aceito e a errata
será carregada em nosso site, ou adicionada a qualquer lista de errata existente, na seção Errata desse título.
Qualquer errata existente pode ser visualizada selecionando seu título em http://www.packtpub.com/support.
Pirataria
A pirataria de material protegido por direitos autorais na Internet é um problema constante em todos os meios
de comunicação. Na Packt, levamos muito a sério a proteção de nossos direitos autorais e licenças. Se você
encontrar cópias ilegais de nossos trabalhos, de qualquer forma, na Internet, forneça-nos imediatamente o
endereço do local ou o nome do site para que possamos buscar uma solução.
Por favor, entre em contato conosco em copyright@packtpub.com com um link para o material suspeito
de pirataria.
Agradecemos sua ajuda na proteção de nossos autores e nossa capacidade de oferecer conteúdo valioso.
Questões
Você pode entrar em contato conosco pelo e-mail questions@packtpub.com se tiver algum problema com
algum aspecto do livro e faremos o possível para resolver o problema.
3
Compreendendo o
1
Ambiente LabVIEW
Neste capítulo, abordaremos:
f Configuração do essencial
f Configurando o quick drop f
Usando ferramentas de depuração
f Criando sonda personalizada
f Compilando EXE f
Depurando EXE
f Compilando um aplicativo independente
Introdução
Este capítulo explica como configurar o LabVIEW e como usar suas funções. As duas primeiras receitas explicam como
definir configurações comumente encontradas, e as receitas restantes explicam como usar funções comuns no LabVIEW.
Compreendendo o ambiente LabVIEW
Configurando itens essenciais

Antes de usar o LabVIEW, é importante configurar o ambiente para produtividade máxima.
Existem muitas configurações no LabVIEW. Não precisamos configurar tudo; a configuração padrão
normalmente seria suficiente. Porém, devemos pelo menos configurar o layout dos Controles
paleta, o layout da paleta Functions e a opção LabVIEW, antes de começarmos a codificar.
Como fazer isso...

Começaremos configurando a paleta Functions . A configuração da paleta Controles não é mostrada,
mas é semelhante à configuração da paleta Funções . Aqui estão as etapas para configurar a paleta
Funções :
1. Para configurar a paleta Funções , clique com o botão direito no diagrama de blocos para obter a
paleta e clique com o botão esquerdo no pino do polegar para fixá-lo. Na paleta, navegue até Personalizar
| Visualize esta paleta como e selecione sua preferência sobre como a paleta deve ser
organizada. Para este exemplo, selecione Categoria (ícones e texto).
2. Em Personalizar, selecione Alterar paletas visíveis... e selecione quais categorias devem aparecer
na paleta. Somente as categorias usadas com frequência devem ser selecionadas. As categorias
não selecionadas ainda podem ser acessadas clicando na seta dupla (apontada para baixo) na
parte inferior da paleta. A captura de tela a seguir mostra a paleta Funções fixada, com o menu
Personalizar ativado:
6
Capítulo 1
3. Apenas a primeira categoria da paleta ficará aberta, portanto a categoria que for mais
utilizada (Programação) deverá ficar no topo. Quando a paleta é fixada, há um par de
linhas paralelas (||) à esquerda de cada categoria (seta para a esquerda ou para a
direita). As linhas paralelas são usadas para mover as categorias. A captura de tela a
seguir mostra como fica a paleta Functions após a configuração:
7
4. Na opção LabVIEW, podemos configurar detalhadamente o ambiente LabVIEW. A legibilidade e a

utilização do espaço podem ser melhoradas. No diagrama de blocos, clique em Ferramentas e
Opções. Na categoria Diagrama de blocos , desmarque Colocar terminais do painel frontal
como ícones para economizar espaço no diagrama de blocos e selecione Usar rótulos de nomes
transparentes para um diagrama de blocos mais limpo. O tamanho dos controles e indicadores
é reduzido no diagrama de blocos, e os rótulos de nomes parecem mais limpos no diagrama de
blocos em comparação com os rótulos de nomes que são opacos. A captura de tela a seguir
mostra a caixa de diálogo de opções do LabVIEW:
Como funciona...
As configurações da paleta e as opções do LabVIEW não são salvas localmente no arquivo VI (Virtual Instrument).
que contém o diagrama de blocos e o painel frontal. Eles são salvos globalmente, portanto, sempre que um
novo VI for criado, as configurações e opções salvas serão aplicadas. Dentro da pasta de instalação do
LabVIEW reside um arquivo chamado LabVIEW.ini . O arquivo contém todas as configurações e opções salvas
e é carregado quando o LabVIEW é iniciado. Se desejarmos transferir as configurações de um computador
para outro, podemos salvar este arquivo e transferi-lo para o mesmo local no outro computador.
Tanto para a paleta Controles quanto para Funções , apenas o que for necessário deve estar nelas e o
restante deve ficar oculto. A paleta Controls é para o painel frontal e a paleta Functions
paleta é para o diagrama de blocos. Demonstraremos apenas como configurar a paleta Functions , mas tenha em
mente que os mesmos procedimentos se aplicam à configuração da paleta Controls .
8
Capítulo 1
Configurando o drop rápido

O recurso quick drop foi introduzido no LabVIEW 8.6. Anteriormente, encontrar uma função exigiria navegar e pesquisar
na paleta. Com o quick drop, a localização de uma função pode ser feita por meio de uma pesquisa baseada em
texto, sem passar pela paleta. Para fazer uma pesquisa, é inserido o nome da função e, à medida que for inserido,
aparecerá uma lista de funções possíveis para o usuário escolher. Para facilitar a busca, uma função pode ser
associada a um atalho de teclado, e para tornar o quick drop ainda mais incrível, tarefas repetitivas podem ser
associadas a um atalho de teclado.
Como fazer isso...

Começaremos associando a função while loop a um atalho de teclado. Aqui estão as etapas para fazer isso:
1. Pressione Ctrl + barra de espaço para invocar o lançamento rápido e clique em Atalho. Como um exemplo,
associaremos o atalho W + L ao loop while. Em Atalho do Diagrama, insira wl.
Em Objeto de atalho de diagrama, insira While Loop. Se não tivermos certeza sobre o nome da função,
podemos sempre encontrar a função dentro da paleta e procurar seu nome.
Por fim, clicamos em Adicionar e depois em OK para adicionar o atalho personalizado à configuração de
drop rápido. A captura de tela a seguir mostra como o atalho é adicionado:
9
Além de encontrar funções rapidamente, podemos atribuir um atalho a um plugin que realiza
tarefas predefinidas.
2. Para executar um plugin via atalho, pressionamos Ctrl + Espaço e o atalho do plugin.
Atalhos integrados estão disponíveis para tarefas rotineiras. A seguir estão alguns exemplos de atalhos
integrados:
Ctrl + Espaço e depois Ctrl + D criam todos os controles e indicadores para um subVI
Ctrl + Espaço e depois Ctrl + R exclui um subVI, ao mesmo tempo que limpa todos os fios
desnecessários e reconecta os quebrados
Ctrl + Espaço e depois Ctrl + T move os rótulos de todos os controles e indicadores para a
esquerda e para a direita
Se os plug-ins integrados não forem adequados, podemos personalizar nosso próprio plug-in e atribuir
um atalho a ele.
3. Para fazer um plugin, use o template em LabVIEW\resource\dialog\

QuickDrop\QuickDrop Plugin Template.vi como ponto de partida. Após a conclusão
do plugin, ele precisa ser colocado em LabVIEW\resource\dialog\
QuickDrop\plugins ou LabVIEW Data\Quick Drop Plugins. Se o plugin for colocado na pasta LabVIEW ,
ele estará disponível apenas para aquela versão do LabVIEW.
Se o plugin for colocado em outro caminho, versões do LabVIEW a partir de 2010 poderão usar o plugin.
Siga a etapa anterior para atribuir um atalho a um plugin.
Como funciona...
Quando um atalho é associado a uma função ou tarefa, o atalho é salvo na configuração do LabVIEW para que
possa ser usado novamente.
Veja também
f Para plug-ins úteis feitos por outros usuários do LabVIEW, visite o link https://decibel.ni.com/
content/groups/quick-drop-enthusiasts?view=documents.
Usando ferramentas de depuração
Existem muitos recursos no LabVIEW para depurar um programa. Os programadores baseados em texto já
devem estar familiarizados com alguns dos recursos, como entrar, sair e assim por diante, mas existem alguns
recursos que podem parecer desconhecidos.
10
Capítulo 1
Como fazer isso...

Antes de entrar no código, vamos verificar o óbvio:
1. Examine o botão de execução (uma seta para a direita) no diagrama de blocos para ver se ele está quebrado ou não.
Se estiver quebrado, clique nele para ver uma lista de problemas que devemos corrigir. Se clicarmos duas vezes
em um item da lista, o LabVIEW nos levará ao local do problema. Precisamos resolver todos os problemas
primeiro, antes de prosseguirmos. Para ver a aparência de uma seta quebrada, abra um novo VI e coloque um
nó add sob a paleta Numeric . Clique na seta quebrada para ver qual é a causa da seta quebrada.
2. Depois que a seta de execução ficar sólida, podemos começar a depurar o programa. Primeiro, ativamos Retain
Wire Values clicando em seu botão na barra de ferramentas do diagrama de blocos. Isso nos permitirá
examinar os valores em todos os fios. Em seguida, navegamos até o local de interesse e definimos um ponto de
interrupção clicando com o botão direito no local, selecionando Breakpoint e Set Breakpoint.
3. Depois de configurar o programa para depuração, clique na seta de execução para executar o programa.
O programa fará uma pausa no ponto de interrupção. Se colocarmos nosso ponto de interrupção em um SubVI,
podemos optar por ultrapassá-lo, para permanecermos em nosso VI atual sem nos aprofundarmos; ou podemos
intervir, para irmos ao subVI para uma investigação mais aprofundada. Se já estamos num subVI e queremos sair,
podemos sair dele. Para entrar, passar por cima ou sair, podemos clicar no botão correspondente na barra de
ferramentas do diagrama de blocos. A captura de tela a seguir mostra a parte da barra de ferramentas do
diagrama de blocos discutida:
4. Para examinar o valor de um fio, clique com o botão direito no fio e selecione Sonda. Uma caixa de diálogo
aparecerá e mostrará o valor do fio. Quando o programa não envia dados por essa conexão, o valor não é
preenchido. Depois que o valor for preenchido, ele aparecerá na caixa de diálogo. Com a sonda, podemos
visualizar os dados dentro do fio, mas não podemos modificá-los.
5. Para ativar o Highlight Execution, clicamos em seu botão na barra de ferramentas do diagrama de blocos.
Esse recurso nos permite visualizar como os dados estão realmente fluindo no programa, mas nosso programa
ficará lento. Muitos programadores do LabVIEW consideram isso útil porque lhes permite compreender
como os dados fluem em um VI.
Tenha cuidado ao usar esse recurso. Como isso torna o programa mais
lento, pode criar bugs relacionados ao tempo.
11
Como funciona...
As ferramentas de depuração permitem que os programadores analisem um programa em profundidade, oferecendo
recursos para controlar o fluxo do programa.
Criando sonda personalizada

A sonda personalizada é um aprimoramento da sonda genérica que só permite aos usuários examinar o valor de um fio.
Uma investigação personalizada é capaz de pausar o programa usando instruções condicionais dentro da investigação. Ao
fazer isso, a investigação personalizada atua como um ponto de interrupção condicional. Além disso, pode processar e
extrair informações dos dados brutos para facilitar o processo de depuração.
Como fazer isso...

Criaremos um probe personalizado com um VI integrado à instalação do LabVIEW. A seguir estão as etapas para fazer isso:
1. Usaremos o código mostrado na captura de tela a seguir para configurar a sonda personalizada.
O código contém um loop while externo que executa o loop for interno continuamente.
O loop for interno geraria um array de 0 a 10 elementos aleatoriamente, e cada elemento conteria um número
aleatório entre 0 a 30. Neste exemplo, queremos que a execução seja pausada quando a geração do array contiver
mais de 9 elementos.
12
Capítulo 1
2. Para criar uma sonda personalizada, clique com o botão direito no fio que alimenta o indicador da matriz U32 e
navegue até Sonda Personalizada | Novo. Quando uma caixa de diálogo aparecer, selecione Criar uma
sonda a partir de uma sonda existente e clique em Avançar. Uma caixa de diálogo com uma lista de testes seria exibida.
Na lista, em nosso exemplo, selecionamos o Conditional Unsigned32 Array Probe.
Quando uma sonda é selecionada, uma descrição detalhada sobre a sonda é mostrada abaixo da lista. É assim
que determinamos se uma sonda existente é adequada ou não para nossa aplicação. Quando clicamos em
Avançar, a próxima página aparece, e inserimos u32array como Nome do arquivo e deixamos todas as
outras opções na configuração padrão. Clicamos em Salvar. Veja a captura de tela a seguir para iniciar a
configuração:
3. Criamos um probe personalizado para nossa aplicação baseado em um existente na instalação do LabVIEW.
Para experimentar a sonda personalizada, clicamos com o botão direito no fio que alimenta o indicador
do array U32 e selecionamos Sonda Personalizada | u32array.vi. A janela de observação da sonda é
exibida; no lado direito, contém um controle de guias com duas guias. A primeira aba mostra os dados e o
tamanho do array. O tamanho da matriz é uma função para esta investigação personalizada. Não está presente
em uma sonda genérica. A segunda aba contém todas as condições que podemos definir para interromper a
execução do programa. Para nosso exemplo, definiremos a caixa de seleção para definir o Número do
elemento como critério e definiremos os critérios como maiores que nove. Depois de terminarmos a
configuração da sonda personalizada, clicamos no botão executar para iniciar o programa. Como colocamos
um nó Wait Until Next ms Multiple e o definimos como igual a 1000ms, o loop while externo irá iterar uma vez a
cada segundo. Enquanto o programa está em execução, podemos ir para a janela Probe Watch e observar os
dados. Assim que o critério for atendido, o programa será pausado e poderemos testar outros fios no diagrama
de blocos, se quisermos.
13
Como funciona...
Quando criamos um probe personalizado baseado em um probe existente, podemos usar os probes localizados
na pasta vi.lib da pasta de instalação do LabVIEW. Para usar uma sonda personalizada, devemos salvá-la
na pasta \default localizada em <LabVIEW>\user.lib\_probes ou na pasta Probes localizada em
<Documents>\LabVIEW Data\. Se o probe for salvo no primeiro caminho (a pasta padrão ), o LabVIEW usará
esse probe personalizado como o probe padrão para aquele tipo de dados específico.
Compilando EXE
A máquina onde iremos implantar nosso código geralmente não possui software de desenvolvimento
LabVIEW. Para implantar nosso código, precisamos instalar o mecanismo de tempo de execução LabVIEW
com a versão correta (gratuitamente) e implantar um executável em vez de implantar um conjunto de VI.
Como fazer isso...

Antes de compilar um executável, criaremos um projeto que contenha tanto o VI quanto o executável
construído a partir do VI. Aqui estão as etapas para criar um projeto:
1. Para criar um projeto, a maneira mais fácil é selecionar Criar Projeto e depois Projeto em Branco
na tela inicial. Ou, se já tivermos um VI, podemos selecionar Projeto | Criar projeto | Projeto
em branco. Dentro do projeto, clique com o botão direito em Meu Computador e selecione Novo
| VI. Agora que o VI está dentro do projeto, criaremos um VI chamado EXEvi.vi para calcular uma
forma de onda senoidal de 1 ciclo com determinada amplitude, fase e frequência. Ele contém uma
estrutura de evento com um caso de evento que será executado quando o controle booleano Read File
for clicado. Veja a captura de tela a seguir para ver o exemplo:
14
Capítulo 1
2. O subVI, SinWave.vi, no exemplo anterior leva os parâmetros de entrada para

calcule a taxa de amostragem e o número de amostras para um ciclo de forma de onda antes de
usar o Sine Waveform.vi para gerar a forma de onda. Consulte o Capítulo 3, Trabalhando com
Arquiteturas Comuns para criar um subVI. Veja a seguinte captura de tela:
3. Para compilar o executável, clique com o botão direito em Build Specifications e selecione New |
Aplicativo (EXE) dentro do projeto. A caixa de diálogo Propriedades do meu aplicativo aparecerá
e configuraremos cada categoria da caixa de diálogo. Na categoria Informações, inserimos
ExeExampleBuild sob o nome Especificações de compilação . Esse nome apareceria em Build
Specification em nosso projeto. Entramos ExeExample.exe
sob o nome do arquivo de destino, e esse é o nome real do executável. Para o diretório de
destino, insira um local conveniente para desenvolvimento.
4. Na categoria Arquivos de origem, selecione EXEvi.vi e clique na seta para a direita ao lado de
VIs de inicialização para que o VI apareça quando o executável for invocado. Quanto ao Always
Included, se o programa chama o VI dinamicamente ou por referência, trabalha com arquivos,
e assim por diante, podemos incluir essas dependências que o programa utiliza. Como o subVI,
SinWave.vi, faz parte do programa, o compilador sabe que precisa incluir o subVI na compilação
sem especificação.
5. Em Destinos deixaremos tudo como padrão. Se tivermos dependências (subVIs, arquivos e assim
por diante), podemos escolher onde colocá-las em relação ao executável. As dependências
podem ir para o executável ou para um diretório de suporte. Podemos adicionar destinos
adicionais se assim o desejarmos. Nesta categoria estamos configurando todos os destinos
para onde os arquivos podem ir.
15
6. Em Configurações do arquivo de origem, podemos escolher como os arquivos serão incluídos no

executável. Se clicarmos em EXEvi.vi, vemos que o Tipo de Inclusão é Startup VI, pois já
especificamos o mesmo na categoria Arquivos de Origem . O destino do Startup VI é o próprio executável,
o que significa que o Startup VI não está localizado em ...\ExeExample.exe\EXEvi.vi. Para SinWave.vi,
usaremos a configuração padrão.
A configuração padrão também colocará o subVI dentro do executável. A captura de tela a seguir
mostra a aparência do projeto com o executável:
Como funciona...
Para que um executável possa ser executado em um computador, ele deve ter pelo menos o mecanismo de tempo
de execução LabVIEW com a versão correta. Alguns outros drivers de dispositivo também podem ser necessários.
Discutiremos esse tópico na receita Compilando uma aplicação autônoma neste capítulo.
Depurando EXE
Às vezes, nosso código funcionará perfeitamente no ambiente de desenvolvimento, mas falhará
miseravelmente quando implantarmos e executarmos seu executável em outro computador. Quando isso acontecer,
podemos colocar mais indicadores no VI para exibir dados em locais relevantes do programa.
Então, podemos recompilar o executável e usar os dados extras para encontrar o bug. Se isso ainda não
funcionar, podemos percorrer o executável de forma semelhante ao que fazemos no ambiente de
desenvolvimento.
16
Capítulo 1
Como fazer isso...

Se nosso código funciona perfeitamente no desenvolvimento, mas falha miseravelmente após a
implantação no modo executável, como depuramos o executável?
1. Não temos o software de desenvolvimento LabVIEW na máquina onde implantamos o executável,

então como percorremos o executável? Iremos nos conectar à máquina onde o EXE está
implantado (máquina EXE) de outro computador que possua o software de desenvolvimento
LabVIEW instalado (máquina DEV). Os dois computadores devem estar na mesma rede;
verificamos sua conexão emitindo o comando ping no prompt de comando com o endereço IP
da máquina EXE do computador DEV. Veja a captura de tela a seguir para ver um exemplo:
2. Depois de verificar se podemos executar ping na máquina EXE a partir da máquina DEV, precisamos
recompilar o executável com a opção Habilitar depuração selecionada, para que o diagrama de
blocos seja compilado no executável para fins de depuração. A opção está dentro das propriedades
do executável e na categoria Avançado. Dentro da opção Habilitar depuração, há outra opção
que podemos selecionar; é Aguarde o depurador na inicialização.
Se selecionarmos essa opção, ao clicar duas vezes no executável para executá-lo, ele não será
executado e aguardará a conexão do depurador. Para nosso exemplo, selecionaremos apenas
a opção Habilitar depuração.
17
3. Na máquina EXE, clique duas vezes no seu executável para executá-lo. Enquanto estiver em execução,
abra o sistema de desenvolvimento LabVIEW na máquina DEV. Na janela de inicialização, selecione
Operar | Depurar aplicativo ou biblioteca compartilhada. A caixa de diálogo Depurar aplicativo
ou biblioteca compartilhada aparece, inserimos o endereço IP da máquina EXE e clicamos em
Atualizar. Em Aplicativo ou biblioteca compartilhada, aparecerá o nome do executável que está
rodando na máquina EXE, clique em Conectar. Veja um exemplo na captura de tela a seguir:
4. Após a conexão ser estabelecida, o painel frontal do executável aparecerá na máquina DEV. No painel
frontal, clicamos com o botão direito e selecionamos Depuração Remota | Mostrar diagrama de
blocos. Veja um exemplo na captura de tela a seguir. Quando o diagrama de blocos é mostrado,
podemos usar todas as ferramentas de depuração do LabVIEW.
18
Capítulo 1
5. Se não conseguirmos fazer a conexão, a máquina EXE pode ter um firewall que está
impedindo a conexão da máquina DEV. Para resolver esse problema, podemos abrir a porta 3580 através
do Firewall do Windows para o NI Service Locator. Se esta abordagem falhar, podemos instalar o software
de desenvolvimento LabVIEW na máquina EXE e conectar-se ao host local (a ele mesmo) para depuração.
Como funciona...
Para depurar um executável em uma máquina que não possui o ambiente de desenvolvimento LabVIEW
instalado, um executável versão debug pode ser implantado e conectado a outro computador, que esteja
na mesma rede e com o ambiente de desenvolvimento LabVIEW instalado.
Compilando um aplicativo independente

Depois de compilarmos um executável e implantá-lo em uma máquina, não poderemos executá-lo imediatamente.
Devemos configurar a máquina com o software correto antes de podermos executar o executável. É problemático
ter que instalar vários softwares na máquina antes de podermos executar o executável. Nesta receita
aprenderemos como empacotar o executável com o software necessário em um instalador, de forma que basta
clicar duas vezes no instalador e tudo será instalado automaticamente.
Como fazer isso

Um aplicativo independente é apenas um instalador que inclui um executável e os drivers exigidos pelo executável.
Usaremos um executável que criamos anteriormente.
1. Abriremos o projeto ExeExample.lvproj da receita onde aprendemos como compilar um executável.

Clicamos com o botão direito em Especificação de construção e selecionamos Novo | Instalador;
a caixa de diálogo Propriedades do meu instalador , onde podemos configurar as propriedades do
instalador, aparece.
2. Na categoria Informações do produto , especificamos o nome da especificação de construção

com ExeExampleInstaller, Nome do produto com ExeExample e Destino do instalador com um
local conveniente para o exemplo.
3. Na categoria Destino podemos configurar para onde irá o conteúdo do nosso programa.
Usaremos a configuração padrão, e isso criará uma pasta dentro dos Arquivos de Programas
pasta em sua unidade local.
4. Na categoria Arquivos de origem , selecionamos o executável e todos os arquivos relevantes à esquerda

e transferi-los para a direita.
19
Como funciona...
Em um aplicativo independente compilado, ele pode ser enviado como um instalador para implantação
em outra máquina. No instalador está incluído tudo o que é necessário para executar um programa. Basta
o usuário clicar duas vezes no instalador recebido e o programa com todas as suas dependências será
instalado automaticamente.
Na categoria Instaladores Adicionais , selecionamos todos os instaladores adicionais que nosso

programa necessita durante a execução. No mínimo, o NI LabVIEW Run-Time Engine é necessário. Se
você usou outros recursos como DAQmx, VISA, FPGA e assim por diante, serão necessários mais
instaladores. Se você não tiver certeza sobre o que é necessário, clique em cada instalador e leia sua
descrição para ver se o instalador descreve um recurso em nosso código ou não.
20
2
Personalizando o
Interface de usuário
Neste capítulo, abordaremos:
f Personalizando controles
f Adicionando um menu para tempo de execução
f Criando uma caixa de diálogo
f Dimensionando a caixa de diálogo automaticamente
f Usando o controle de imagem 2D
f Atualizando controles com um mecanismo de ação
f Criando uma animação simples
f Criando subpainéis
Introdução
Este capítulo apresenta dicas sobre como criar uma interface de usuário. Demonstraremos diferentes recursos de UI no design
de UI, como personalizar um controle, adicionar menu de tempo de execução, criar uma caixa de diálogo, usar controle de imagem 2D,
criar animação simples e criar subpainéis. Maneiras de gerenciar a UI, como dimensionar uma caixa de diálogo automaticamente e
atualizar controles com mecanismo de ação, também serão demonstradas.
Personalizando a interface do usuário
Personalizando controles
No LabVIEW, existem diferentes estilos de controles para você escolher. Estilos de controle como clássico, moderno e
assim por diante atenderiam à maioria das necessidades de design de UI. Além disso, existem outros estilos que podem ser
baixados do OpenG. No entanto, às vezes, precisamos de um controle para ter uma aparência específica e podemos
personalizar esses controles especiais no LabVIEW.
Preparando-se
Para completar esta receita, é necessário o ambiente de desenvolvimento LabVIEW. Neste exemplo, o LabVIEW 2012 é usado.
Para personalizar o controle numérico, são necessárias uma imagem de um carro azul e uma imagem de um carro amarelo.
Como fazer isso…

Siga as etapas fornecidas para implementar a receita:
1. Abra um novo projeto e VI.
2. Começaremos a construir o painel frontal. Para criar uma pista com um carro de corrida, clique com o botão direito
no painel frontal e vá em Clássico | Numérico | Deslizamento horizontal.
3. Clique com o botão direito no controle e selecione Make Type Def.
4. Clique com o botão direito no controle e selecione Open Type Def.
5. No tipo def, clique em Alterar para Modo Personalizar (ícone de chave inglesa).
6. Clique com o botão direito no botão e selecione Importar do arquivo no mesmo tamanho, conforme mostrado
na captura de tela a seguir:
22
Capítulo 2
7. Navegue até a imagem do carro azul e ajuste o tamanho do carro.
8. Clique com o botão direito no controle e selecione Alterar para indicador.
9. Salve o controle e vá em Arquivo | Aplicar mudanças.
10. Repita as etapas 2 a 8 para a imagem do carro amarelo.
11. Para criar um sinal que inicia/para a corrida, clique com o botão direito no painel frontal e
vá para Moderno | Booleano | LED redondo.
12. Clique com o botão direito em LED redondo e selecione propriedades.
13. Mantenha a cor Ligada como verde e mude a cor Desligada para vermelho.
14. Habilite Mostrar texto booleano e Múltiplas strings.
15. Para o texto On, digite GO, e para o Off Text, escreva STOP.
16. Clique com o botão esquerdo no LED e arraste seu canto para ampliá-lo.
17. Clique com o botão direito no controle e selecione Alterar para Indicador.
18. Para criar um indicador de status, clique com o botão direito no painel frontal e vá em Clássico | String e caminho |
Cadeia Simples.
19. Para tornar transparente o entorno da String Simples, pressione Ctrl + Shift + clique com o botão direito no painel
frontal e selecione a ferramenta de coloração.
20. Com a ferramenta de coloração, clique com o botão direito ao redor do indicador Simple String e selecione
transparência para a cor de fundo e de primeiro plano. Vemos a seguinte captura de tela do painel frontal após
executar as etapas 1 a 17:
21. O painel frontal está concluído e trabalharemos no diagrama de blocos. Usaremos o

arquitetura de máquina de estado. Começaremos colocando um loop while no diagrama de blocos e colocaremos uma
estrutura case dentro do loop while.
22. Crie e salve um tipo de enum def. com estados: Inicializar, Inativo, Executar, Concluído e Sair.
23
23. Para o loop while, crie quatro registradores de deslocamento clicando com o botão direito e selecionando
Add Shift Register; um para BlueCar, um para YellowCar, um para Resultado e um para
Estado. Conecte esses quatro registradores e configure o registrador de deslocamento de estado
para Inicializar. Coloque um nó Wait Until Next ms Multiple dentro do loop while e conecte 500 ms
a ele. Crie uma variável local para o controle Trigger Boolean e defina-a como false para inicializá-
lo. A condição de parada é definida com o valor booleano padrão, que é falso.
A máquina de estado e seu estado Inicializar são mostrados na captura de tela a seguir:
24. Construa o estado "Idle" com uma estrutura de evento, conforme mostrado na imagem a seguir:
25. Construa o segundo caso de evento dentro do estado Idle , conforme mostrado a seguir
captura de tela:
24
Capítulo 2
26. Crie o estado "Executar" , conforme mostrado na captura de tela a seguir:
27. Crie o estado "Concluído" , conforme mostrado na captura de tela a seguir:
25
28. Crie o estado "Sair" , conforme mostrado na captura de tela a seguir:
Como funciona…
O programa mostrado na seção anterior é uma simulação de corrida. São criados dois controles personalizados
com carros de corrida amarelos e azuis, e eles são conduzidos por números aleatórios. Um grande LED é usado para
iniciar a corrida, e o status da corrida é mostrado com um simples indicador de string.
As imagens dos carros de corrida foram obtidas na internet e em um software gratuito chamado GIMP.
(http://www.gimp.org/) foi usado para tornar o fundo das imagens transparente.
Para o indicador de status, uma String Simples Clássica é usada para que o fundo possa ser colorido como
transparente; o fundo não aparecerá e cercará o carro. Para trabalhar com imagens no LabVIEW, o formato Portable
Network Graphics (png) é o preferido.
O programa começa com o estado Inicializar para inicializar todos os indicadores e registradores de deslocamento
e prossegue para o estado Idle . No estado Idle , possui uma estrutura de eventos. O programa não passará neste
estado a menos que o Trigger tenha um evento de alteração de valor. Depois que o valor Trigger é alterado, o
programa passa para o estado Run . Se o painel fechar? filtro ocorrer, o programa descartará o painel
Fechar? evento e parar o programa. Neste caso, o Painel Fechar? evento é filtrado, então o painel não será
fechado. No estado Run , dois geradores de números aleatórios separados são usados para acumular a distância
percorrida por cada carro. Se algum dos carros cruzar a linha de chegada (dentro de 50 ms), o programa
passa para o estado Concluído ; caso contrário, o programa volta ao estado Executar . Se o carro azul vencer,
um valor booleano verdadeiro será a saída. Se o carro amarelo vencer, um valor booleano falso será a saída.
O estado Concluído produzirá o resultado com base no valor booleano e transitará o programa para o estado Sair ,
onde o programa encerra tudo.
Veja também
f Para obter mais informações sobre a arquitetura da máquina de estado, consulte o Capítulo 3, Trabalhando
com arquiteturas comuns
26
Capítulo 2
Adicionando um menu para tempo de execução
Para tornar um programa mais profissional, o menu runtime é essencial. Nesta receita, criaremos um programa com menu de
atalho de tempo de execução que é invocado clicando com o botão direito em um indicador e um menu de tempo de execução
que reside na barra de menu superior do programa.
Como fazer isso…

Siga as etapas fornecidas para criar o exemplo desta receita:
1. Abra um novo projeto e VI.
2. Crie um indicador gráfico clicando com o botão direito no painel frontal e navegue até Modern |
Gráfico | Gráfico de forma de onda.
3. Crie uma parada booleana clicando com o botão direito no painel frontal e navegando até Modern | Booleano | Botão
de parada. Primeiro, começaremos criando um menu de atalho com o botão direito do mouse para o gráfico.
4. Clique com o botão direito no gráfico e vá para Avançado | Menu de atalho em tempo de execução | Editar....
5. No editor, selecione Personalizado na barra de menu superior.
6. Em Propriedades do Item, selecione Usuário em Tipo de Item e insira Incremento como o

Nome do item.
7. Clique no botão adicionar no canto superior esquerdo para adicionar outra entrada de menu.
8. Em Propriedades do item, selecione Usuário em Tipo de item e insira Decrement como o

Nome do item.
10. Em Propriedades do Item, selecione Separador em Tipo de Item.
12. Em Propriedades do item, vá para Item do aplicativo | Itens Visíveis | Menu inteiro.
27
13. Navegue até Arquivo | Salvar | Salve em arquivo e salve o menu como RunTimeShortcut. rtm na mesma pasta do VI.
A captura de tela a seguir é de um menu de atalho concluído:
14. Depois de terminarmos o menu de atalho do botão direito, prosseguiremos para adicionar um personalizado
barra de menu superior.
15. Para criar uma barra de menu superior personalizada para o painel frontal, vá em Editar | Menu de tempo de execução....
16. No editor, selecione Personalizado na barra de menu superior.
17. Em Propriedades do Item, selecione Usuário em Tipo de Item e insira Tarefas como o
Nome do item.
19. Em Propriedades do item, selecione Usuário em Tipo de item e insira Multiplicado

por 2 como o nome do item.
20. Clique na seta para a direita para tornar Multiplicado por 2 um subitem de Tarefas.
22. Em Propriedades do item, selecione Usuário em Tipo de item e insira Dividido por 2
como o nome do item.
23. Clique na seta para a direita para tornar Multiplicado por 2 um subitem de Tarefas.
24. Vá para Arquivo | Salve e salve o arquivo como RunTimeTop.rtm na mesma pasta do VI.
28
Capítulo 2
25. Crie o painel frontal conforme mostrado na imagem a seguir:
26. Crie o diagrama de blocos conforme mostrado na imagem a seguir:
27. Crie o segundo caso de evento, “Gráfico”: Seleção do Menu de Atalho (Usuário),
conforme mostrado na imagem a seguir. Para a estrutura interna do caso, o caso
"Decremento" é mostrado. A estrutura case possui mais dois casos que não são
mostrados: Increment e Default. Para o caso Incremento, use o nó incremento. Para o
caso padrão, basta conectar o fio de entrada.
29
28. Crie o último caso de evento conforme mostrado na captura de tela a seguir. Para a estrutura interna
do caso, é mostrado o caso "Dividido por 2" . A estrutura do caso possui mais dois casos que não
são mostrados. Eles são multiplicados por 2 e padrão. Para o caso Multiplicado por 2, use o nó de
multiplicação com 2 e o fio de entrada como entradas. Para o caso padrão, basta conectar o fio de
entrada.
Como funciona…
O programa gera números aleatórios e os exibe em um gráfico. O usuário pode optar por dimensionar ou deslocar
os números no gráfico.
A estrutura do evento possui três casos. O caso de tempo limite é acionado uma vez a cada segundo e irá gerar
uma matriz de 10 números aleatórios e exibi-los em um gráfico. Se o usuário clicar com o botão direito no gráfico
e selecionar Aumentar/Decrementar, o evento de seleção do menu de atalho será acionado e os valores do
gráfico serão alterados de acordo. Se o usuário selecionar o menu Tarefas na parte superior e selecionar
Multiplicado/Dividido por 2, o evento de seleção de menu será acionado e os valores do gráfico serão
dimensionados de acordo.
Criando um diálogo
A caixa de diálogo é um pop-up simples que coleta informações do usuário para o programa. Nesta receita,
criaremos um diálogo simples.
Como fazer isso…

Dialog é um SubVI que aparece para coletar informações. Para criar uma caixa de diálogo simples,
precisamos executar as seguintes etapas:
1. Crie um novo projeto e VI.
2. Crie o painel frontal conforme mostrado na próxima imagem. O conjunto de controles à direita está
dentro de uma definição de tipo. cluster e ele precisa ser criado e salvo.
3. Para definir os valores padrão para todos os controles, podemos escrever um valor para cada
controle usando uma variável local ou definir um valor padrão manualmente. Para definir um valor
padrão manualmente, insira o valor padrão no controle. Clique com o botão direito no controle.
Selecione Operações de Dados e Torne o Valor Atual como Padrão.
30
Capítulo 2
4. No painel frontal, clique no canto superior direito do painel de conectores 4 x 2 x 2 x 4 e, em

seguida, clique em Info Cluster para posicionar o Info Cluster no painel de conectores.
5. Crie o diagrama de blocos conforme mostrado na imagem a seguir:
31
6. Na barra de menu superior do painel frontal, vá para Arquivo | VI Propriedades. Na caixa de diálogo de edição,
selecione a opção Diálogo . Verifique a captura de tela a seguir. Em Posição do tempo de execução da janela,
podemos selecionar em qual local do monitor a caixa de diálogo aparece.
7. Redimensione o painel frontal para que o cluster fique fora de vista.
8. Para usar o VI dialog em outras aplicações, simplesmente colocamos o VI dialog no

aplicação e conecte todas as entradas e saídas. Quando o fluxo de execução da aplicação chegar ao VI de
diálogo, ele irá aparecer e coletar as informações pretendidas.
Como funciona…
Este VI é usado como SubVI dentro de um programa. Quando o programa chama esse VI de diálogo, o diálogo aparece e o
thread do programa que depende dos dados do diálogo é interrompido. O usuário inseriria todas as informações e clicaria
em OK. O programa preenche um cluster e passa os dados do SubVI para o programa que o chama.
Para que a caixa de diálogo apareça, sua aparência deve ser definida como caixa de diálogo dentro das propriedades do
VI. A opção faz com que o VI a mostre no painel frontal durante a execução. Criar controles para obter dados de usuários e
usar um cluster para transmitir esses dados parece redundante. É possível usar um cluster para obter e passar os dados do
usuário. Porém, quando os controles estão dentro do cluster, ele tem menos flexibilidade para decoração.
32
Capítulo 2
Veja também
f Se o diálogo for usado para exibir uma mensagem sem a necessidade de coletar informações dos usuários
enquanto permite que o programa continue, um diálogo chamado dinamicamente deverá ser usado. Para obter
mais referências sobre este tópico, consulte a receita Chamando um VI dinamicamente no Capítulo 3,
Trabalhando com Arquiteturas Comuns
Dimensionando a caixa de diálogo automaticamente
O tamanho da caixa de diálogo é ajustado e salvo manualmente, de modo que apenas o que se pretende ver seja mostrado
quando a caixa de diálogo aparecer. No entanto, sempre que uma caixa de diálogo for modificada, o tamanho poderá
precisar ser ajustado novamente. Para evitar o problema de ajustar o painel frontal sempre que uma alteração é feita,
esta receita fornece uma maneira de dimensionar uma caixa de diálogo automaticamente.
Como fazer isso…
Para começar a construir o VI para dimensionar um diálogo automaticamente, precisamos executar os seguintes passos:
1. Abrimos um novo projeto e VI.
2. Crie o diagrama de blocos conforme mostrado nas imagens a seguir. Os seis valores contidos em enum
são Inicializar, Encontrar Altura Máxima, Definir Origem, Definir Limites do Painel, Centralizar FP e
Desligar. O primeiro estado Initialize obtém a referência do VI para o painel frontal que gostaríamos
de dimensionar automaticamente. A referência do painel é obtida assumindo que existe apenas um
painel no painel frontal. São obtidas as referências de todas as decorações dos painéis frontais.
33
3. Crie o próximo caso, "Encontrar Altura Máxima". Examina a altura de toda a decoração do painel frontal
e extrai a referência da decoração com altura máxima. Consulte a seguinte captura de tela:
4. Crie o próximo caso "Set Origin", conforme mostrado na imagem a seguir. Ele define o
origem do painel frontal até o canto superior esquerdo da decoração maior:
34
Capítulo 2
5. Crie o próximo caso "Definir limites do painel", conforme mostrado na imagem a seguir.
Fixa o painel frontal vinculado à decoração maior.
6. Crie o próximo caso "Center FP", conforme mostrado na imagem a seguir. Ele centraliza
painel frontal quando mostrado no monitor.
35
7. Crie o estado final “Desligamento”, conforme mostrado na imagem a seguir. Fecha todas as
referências de nós de propriedade usados em estados anteriores. Ele interrompe a máquina de
estado definindo a condição de parada como verdadeira.
8. No painel frontal, conecte o controle de caminho usado no estado Inicializar ao canto superior
esquerdo do padrão de terminais. Veja a seguinte captura de tela:
9. Vamos construir um VI que use o SubVI que construímos nos passos 1 a 8. Construa o painel frontal
conforme mostrado na imagem a seguir:
36
Capítulo 2
10. Construa o diagrama de blocos conforme mostrado na imagem a seguir:
Como funciona…
Esta receita constrói um SubVI AutoResizeVI.vi que é chamado por outro VI para redimensionar seu painel frontal em
torno de uma moldura decorativa. Ele usa uma máquina de estado simples como arquitetura.
Primeiro, a máquina de estado entra no estado Inicializar para abrir as referências do VI chamador, do painel do
VI chamador, do Painel do VI chamador e das decorações do VI chamador em seu painel frontal. No próximo estado
Find Max Height , a referência para a decoração com a altura máxima é extraída da matriz de referências de
decoração. No próximo estado Definir Origem, as coordenadas do canto superior esquerdo da decoração são
definidas como a origem do Painel. No próximo estado Definir Limites do Painel, o limite da decoração é definido igual
ao limite do painel frontal. No estado Center FP , o painel frontal é movido para o centro do monitor. Finalmente, no
desligamento
estado, todas as referências são fechadas e a condição de parada para o loop while é definida como verdadeira
para sair do programa.
No VI chamador, ele chama AutoSize.vi para redimensionar seu painel frontal para o tamanho de sua decoração.
Em seguida, aguardará que o usuário clique em sair para sair do programa.
37

LabVIEW Graphical Programming Cookbook-1-50

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

LabVIEW Graphical Programming Cookbook-1-50

Uploaded by

Copyright:

Available Formats

Machine Translated by Google

Machine Translated by Google

69 receitas para ajudá-lo a construir, depurar e

Livro de receitas de programação gráfica do LabVIEW

Direitos autorais © 2014 Packt Publishing

Publicado pela primeira vez: janeiro de 2014

Referência de produção: 1160114

Publicado por Packt Publishing Ltd.

Imagem da capa de Zarko Piljak (zpiljak@gmail.com)

Autor Editores de cópia

Yik Yang Sayanee Mukherjee

Amit Dongol Coordenador de projeto

Justin Smith Revisor

Editores técnicos líderes

Yik Yang é um engenheiro de testes que mora em Chicago e se especializou em automação e

Gostaria de agradecer à minha esposa Qian e ao meu filho Elijah. Eles me

Chris aprendeu LabVIEW enquanto trabalhava no laboratório de Pesquisa e Desenvolvimento SEMS da

Qizhen Ruan é engenheiro de software. Ele tem mais de 13 anos de experiência em

Justin Smith é formado em Ciência da Computação pela Tennessee Technological University e

Arquivos de suporte, e-books, ofertas de descontos e muito mais

Por que assinar?

f Copie e cole, imprima e marque conteúdo

f Sob demanda e acessível via navegador da web

Acesso gratuito para correntistas Packt

Capítulo 2: Personalizando a interface do usuário 21

Capítulo 3: Trabalhando com Arquiteturas Comuns 49

Usando a arquitetura produtor-consumidor 66

Capítulo 4: Gerenciando Dados 79

Capítulo 5: Passando Dados 95

Capítulo 6: Tratamento de Erros 115

Capítulo 7: Trabalhando com Arquivos 127

Capítulo 8: Compreendendo a aquisição de dados 155

O que este livro cobre

O Capítulo 3, Trabalhando com Arquiteturas Comuns, aborda arquiteturas comuns no LabVIEW.

O Capítulo 5, Passagem de dados, aborda diferentes métodos de transmissão de dados.

O Capítulo 6, Tratamento de Erros, aborda diferentes métodos de tratamento de erros.

O Capítulo 9, Simplificando Código, aborda maneiras de simplificar código.

O que você precisa para este livro

Para quem é este livro

Avisos ou notas importantes aparecem em uma caixa como esta.

Dicas e truques aparecem assim.

Neste capítulo, abordaremos:

f Configurando o quick drop f

Usando ferramentas de depuração

f Criando sonda personalizada

f Compilando um aplicativo independente

Compreendendo o ambiente LabVIEW

Configurando itens essenciais

Como fazer isso...

Compreendendo o ambiente LabVIEW

4. Na opção LabVIEW, podemos configurar detalhadamente o ambiente LabVIEW. A legibilidade e a

Configurando o drop rápido

Como fazer isso...

Compreendendo o ambiente LabVIEW

3. Para fazer um plugin, use o template em LabVIEW\resource\dialog\

Usando ferramentas de depuração

Como fazer isso...

Compreendendo o ambiente LabVIEW

Criando sonda personalizada

Como fazer isso...

Compreendendo o ambiente LabVIEW

Como fazer isso...

2. O subVI, SinWave.vi, no exemplo anterior leva os parâmetros de entrada para