LabVIEW Graphical Programming Cookbook-101-150

Machine Translated by Google
Gerenciando Dados
Manipulando uma matriz

Manipular o array incorretamente pode custar caro à memória. Esta receita demonstra como manipular o array
corretamente.
Como fazer isso…

Começaremos demonstrando como adicionar um elemento na frente de um array de forma eficiente.
1. Crie o seguinte diagrama de blocos para inserir um elemento na frente de um array. No

parte superior do diagrama de blocos, use o nó build array diretamente para adicionar um elemento no início
de um array. Na parte inferior do diagrama de blocos, vemos a reversão da matriz, a adição do elemento
e a reversão da matriz novamente. A abordagem posterior é mais eficiente em termos de memória, uma vez
que não é necessária nenhuma alocação de memória adicional. A reversão da matriz requer apenas a
alteração dos ponteiros. Quando a memória é alocada para um array, memória extra fica disponível no final da
memória alocada, portanto, adicionar um elemento ao final de um array não requer alocação de memória
adicional.
2. Construa o diagrama de blocos conforme mostrado na imagem a seguir. No topo do diagrama, o segundo
elemento de uma matriz é multiplicado por dois. Na parte inferior do diagrama de blocos, uma matriz
é dividida em duas matrizes de comprimento 1. Ambas as matrizes são multiplicadas por 2 e 3,
respectivamente, e combinadas novamente em uma matriz.
88
Capítulo 4
Como funciona…
Ao inserir um elemento na frente de um array, se for feito diretamente, a memória é realocada.
Em vez disso, se o elemento for inserido na frente da matriz invertendo a matriz, anexando o
elemento ao final da matriz e invertendo a matriz mais uma vez, a memória não será
realocada, portanto, será mais eficiente. A reversão de uma matriz não requer realocação de
memória, pois apenas os ponteiros estão mudando.
Usando encontro
O encontro garante que uma seção de código seja executada somente se vários threads de código
forem concluídos. Na receita a seguir mostraremos um exemplo de uso do rendezvous.
Como fazer isso…

Criaremos um programa que usa rendezvous para sincronizar três loops:
1. Crie o seguinte diagrama de blocos. Ele cria um encontro e alimenta a referência em três
loops while em threads paralelos. As estruturas case nos loops while executarão
primeiro seu caso falso, com base nos valores inicializados dos registradores de deslocamento.
Os loops aguardarão 1, 2 e 3 segundos em paralelo. Quando o tempo de espera
terminar, os loops exibirão uma string para indicar o status.
89
Gerenciando Dados
2. O caso verdadeiro é executado após a execução do caso falso, conforme mostrado na imagem a seguir. O caso
falso aguardará todos os loops usando o rendezvous. Quando todos os loops chegam, uma string é emitida
para indicar o status.
Como funciona…
O exemplo cria um encontro para três loops while. Cada loop espera por um período de tempo diferente e eles
esperarão um pelo outro antes de gerar uma string que indica que tudo chegou. O encontro é usado para sincronizar
vários threads de um programa, forçando diferentes threads a esperar um pelo outro antes de prosseguir.
Usando semáforo
O semáforo é usado para limitar o número de tarefas que podem operar em um recurso compartilhado ou protegido.
Nesta receita demonstramos como o semáforo é utilizado em uma versão modificada do problema do fumante, descrito
por SS Patil.
90
Capítulo 4
Como fazer isso…

O programa irá simular três fumantes fabricando e fumando cigarros juntos.
Quando um fumante está fumando, ele estará ocupado demais para ajudar na pausa para fumar.
1. Crie o seguinte diagrama de blocos. Primeiro, é criado um array de três semáforos.

Um semáforo é selecionado aleatoriamente e a string da tabela é atualizada de acordo. O semáforo
de liberação de verificação SubVI verificará o status de cada semáforo e atualizará a string do fumante
de acordo.
91
Gerenciando Dados
2. Se o semáforo pelo qual um SubVI é responsável não estiver disponível, o SubVI atualizará a string do fumante
para indicar seu status e manterá o status por 3 segundos antes de liberar o semáforo, conforme
mostrado na imagem a seguir:
3. O painel frontal na captura de tela a seguir mostra como o programa atualizará o

situação dos fumantes e da mesa:
92
Capítulo 4
Como funciona…
No programa, três fumantes estão sentados em uma mesa redonda. Uma pessoa tem
tabaco, outra tem papel fumegante e outra tem fósforos em quantidade ilimitada. Um
manipulador de materiais irá aleatoriamente até dois fumantes e colocará seu suprimento na
mesa. O terceiro fumante pegará o suprimento da mesa e junto com o suprimento fará um cigarro
e fumará. Enquanto fuma o cigarro, o manipulador do material pode pegar o suprimento do
fumante. Porém, se houver suprimentos na mesa para ele fazer outro cigarro, mas ele estiver
fumando, ele esperará até terminar o cigarro.
O exemplo cria três semáforos, um para cada fumante, e seleciona aleatoriamente um para
fazer o cigarro pegando o semáforo. O SubVI verificará o status de cada semáforo em paralelo.
Se não houver semáforo disponível, o fumante começará a fumar por 3 segundos e liberará
o semáforo.
Veja também
f Para mais detalhes sobre os problemas dos fumantes, consulte

http://en.wikipedia.org/wiki/Cigarette_smokers_problem
93
5
Passando dados
Neste capítulo, abordaremos:
f Usando um cluster type-def
f Usando uma estrutura de eventos para passar dados
f Usando uma fila para passar dados
f Usando um notificador para passar dados
f Usando uma variável compartilhada para passar dados
f Usando mensagens TCP/IP simples para transmitir dados
Introdução
Este capítulo apresenta dicas sobre como passar dados no LabVIEW. Cluster, estrutura de eventos, fila, notificador,
variável compartilhada e Mensagens TCP/IP Simples (STM) são as formas de passar dados que discutiremos neste capítulo.
Usando um cluster type-def

Um cluster é como um array, mas pode conter elementos de diferentes tipos de dados. Um controle type-def é um controle
centralizado que propaga suas alterações para os controles associados no programa. Um cluster geralmente é criado como um
controle type-def para evitar retrabalho e é usado para passar dados em um programa. É uma ótima maneira de antecipar
mudanças na estrutura de dados no futuro.
Se a aparência do type-def precisar ser preservada, com relação ao posicionamento exato de cada elemento, um type-def deve
ser transformado em um type-def estrito. Nesta receita, criaremos um programa que transmite dados com um cluster type-def.
Passando dados
Como fazer isso…

Criaremos uma máquina de estado que usa um cluster para passar dados de um estado para o próximo.
1. Crie um cluster type-def que usaremos para passar dados de um estado para outro dentro da máquina de
estado. Em um diagrama de blocos, navegue até Arquivo | Novo… | Controle personalizado. Um
painel frontal aparecerá. Solte um cluster no painel frontal e preencha-o com elementos. Observe que o
rótulo de cada elemento será usado para agrupar e desagregar elementos do cluster. Veja a captura de
tela a seguir para o cluster. O cluster contém três valores de ponto flutuante e uma string.
2. Construa a seguinte máquina de estados. Fora do loop while, coloque um cluster type-def
com três números de ponto flutuante (Random Num, Constant e Result) e uma string (Result Str). Um
enum type-def alimentando o registrador de deslocamento de estado de fora do while
loop inicializará a máquina de estado para iniciar nesse estado. O enum contém todos os estados da
máquina. O estado Inicializar também é o estado padrão. Se uma entrada da estrutura de caso não
for contabilizada, este estado será executado. Este estado agrupa a entrada Constant no cluster, passa
o cluster para o próximo estado e vai para o estado Gerar Número .
96
capítulo 5
3. O próximo estado é “Gerar Número”. Ele gera um número aleatório de 0 a

1, agrupa o valor no cluster e vai para o próximo estado, conforme mostrado na
captura de tela a seguir:
4. O próximo estado é o estado "Multiply Num" . Ele desmembra os valores Random

Num e Constant do cluster, multiplica-os e agrupa o resultado no cluster em
Resultado, conforme mostrado na captura de tela a seguir:
97
Passando dados
5. O próximo estado é o estado "Comparar Número" . Ele desmembra o resultado do cluster e alimenta o
valor em uma estrutura de caso. O caso Default é executado quando o valor de entrada não
corresponde a nenhuma condição dos outros casos. Nesse caso, a string >50 é gerada e agrupada
no cluster em Result Str, conforme mostrado na captura de tela a seguir:
6. A captura de tela a seguir mostra o outro caso da estrutura de caso. Se a entrada

for menor ou igual a 50, a string <=50 será gerada.
7. O último estado é o estado "Saída" . Define a condição de parada da máquina de estado

para verdadeiro. A máquina de estado sairá neste estado.
98
capítulo 5
Como funciona…
Esta receita usa uma máquina de estados. Para utilizar a máquina de estados, são criados um cluster para passagem
de dados e um enum com todos os estados. A máquina inicia com o estado Inicializar , no qual a constante de
entrada do usuário é agrupada no cluster e passada para o próximo estado Gerar Número. No próximo estado, um
número aleatório é gerado e agrupado no cluster antes de ir para o estado Multiply Num . No estado Multiply Num ,
Random Num e Constant
são desagregados do cluster e multiplicados. O resultado é agrupado no cluster Resultado
e passado para o próximo estado Compare Number. No próximo estado, Result Str é criado e empacotado no cluster
com base no valor de Result. Ao final, a máquina transita para o último estado, Exit, onde a máquina de estado é
desligada. Em vez de usar variáveis locais e globais para passar dados, usar um cluster é a principal forma de passar
dados no LabVIEW. Como apenas uma estrutura de dados, o cluster, é usada para passar os dados, o código é muito
organizado e segue a estrutura de fluxo de dados do LabVIEW.
Usando uma estrutura de eventos para passar dados

Uma estrutura de evento é executada quando os eventos ocorrem. Quando não há nenhum evento, as estruturas de
eventos ficam ociosas, não consumindo nenhum recurso da CPU, ao contrário de um loop while, que será executado
constantemente para pesquisar eventos. Além de executar código com base em eventos reais, ele pode executar
código com base em um evento de software (evento de usuário) que é acionado dentro do software. Um evento de usuário
também pode ser usado para transmitir dados. Esta receita demonstra como passar dados para uma estrutura de eventos.
Como fazer isso…

Neste exemplo, criaremos um programa que passa dados entre loops com base em eventos do usuário.
1. Coloque as funções Create User Event e Register For Events no diagrama de blocos para criar e registrar
um evento de usuário. Veja a seguinte captura de tela:
99
Passando dados
2. O Refnum de Registro de Evento do nó Registrar para Evento é alimentado no Terminal de Evento

Dinâmico da estrutura de evento no loop superior. O User Event Refnum do nó Create User Event é
alimentado no loop inferior para gerar um evento de usuário. O loop superior contém uma estrutura de
eventos para lidar com eventos, e o loop inferior é uma máquina de estados que implementa uma
tarefa. O “Queijo”: Mudança de Valor
O caso de evento é executado quando o controle booleano Cheese é clicado e geraria a string Cheese.
O caso Initialize no loop inferior inicializa os valores do programa. Veja a seguinte captura de tela:
3. No loop superior, o próximo caso de evento é "Hello": Value Change. Ele é executado quando o controle
booleano Hello é clicado e a string Hello é gerada, conforme mostrado no exemplo
seguinte captura de tela:
100
capítulo 5
4. No loop superior, o próximo caso de evento é "Exit": Alteração de valor. É executado quando o
Sair O controle booleano é clicado. Ele gera a saída sem sequência de dados e define a condição de parada
do loop superior como verdadeira.
5. No último caso de evento, é o caso <Dados de Saída>: Evento do Usuário . É executado quando um
evento de usuário baseado em software é gerado. Ele compara os dados de saída que são passados
do loop inferior, onde o evento do usuário é gerado com a verificação da string. Se a string passada não for
igual à verificação, a string dos Dados de Saída será gerada. Caso contrário, a string no registrador de
deslocamento do loop superior será passada.
101
Passando dados
6. No loop inferior, o próximo caso é "Add Random". Ele gera um número aleatório,
multiplica por 1,1 e adiciona ao valor no registrador de deslocamento.
7. Para o loop inferior, o próximo caso é "Subtract Random". Ele gera um número aleatório e o subtrai do
valor no registrador de deslocamento.
8. Para o loop inferior, o próximo caso é "Check Number". Ele compara o valor dentro do registrador de
deslocamento com o número de ponto flutuante Stop Limit especificado pelos usuários no painel frontal.
Se o valor do registrador de deslocamento for maior que Stop Limit, o próximo estado é Exit. Caso
contrário, o próximo estado é Adicionar Aleatório. Um evento de usuário também é gerado para passar
a verificação de string para o loop superior. Quando o loop superior obtiver a verificação da string, ele
saberá que não precisa sair.
102
capítulo 5
9. Para o loop inferior, o último caso é “Exit”. Ele cria a string Exit com Num %0.2f, sendo 0.2f o número
de ponto flutuante de entrada com duas casas decimais. A string é enviada ao loop superior por
meio de um evento do usuário. Quando o loop superior reconhecer que a string não foi verificada,
ele será encerrado. A condição de parada também é definida como verdadeira para interromper o loop.
10. Fora do loop superior, coloque Unregister for Events e Destroy User
Evento. São utilizados para liberar recursos ocupados por referências criadas que não são
mais necessárias.
Como funciona…
Esta receita contém dois loops. O loop superior trata eventos e exibe uma string de acordo.
O loop inferior, começando em zero, adiciona e subtrai um número aleatório até que o resultado atinja um
limite especificado pelo usuário. Quando o limite é atingido, ele usa eventos do usuário para enviar o resultado
ao loop superior em uma string.
Quando o evento do usuário é criado com o nó Criar Evento do Usuário , o nome da entrada do tipo de dados
do evento do usuário se torna o nome do evento do usuário. O caso de evento do usuário é ativado pelo loop
inferior sempre que o loop inferior entra no estado Check Number ou Exit .
Quando o loop inferior entra no estado Check Number , uma string de verificação é passada para o loop
superior e sinaliza ao loop superior para exibir os valores anteriores. Quando a string de verificação não é
enviada, o loop superior atualizará o indicador de string com uma nova string.
Neste exemplo, o evento do usuário é usado para sincronizar o comportamento de saída de ambos os
loops. Isto é muito importante, pois se um loop for finalizado e o outro não, o programa não será encerrado,
pois um loop ainda está em execução. Quando o loop superior é encerrado primeiro, o evento do usuário
é cancelado e destruído. Quando o loop inferior tentar gerar um evento de usuário, ocorrerá um erro, pois
o evento não está mais disponível. O loop inferior também irá parar. Quando o loop inferior é finalizado
primeiro, uma string que não é verificada é passada para o loop superior. Quando os loops superiores
reconhecerem que a string passada não foi verificada, ele será encerrado.
103
Passando dados
Usando uma fila para passar dados

Esta receita mostra como usar uma fila para passar dados entre loops. Em uma fila, os dados são preservados,
a menos que o elemento seja enfileirado quando o número máximo de elementos da fila for atingido e o tempo
alocado para esperar por um espaço disponível acabar. Nesse caso, os dados são perdidos.
Como fazer isso…

Criaremos um programa que gera dados de forma de onda em um loop e os passa para outro para exibir os dados.
1. Crie uma fila com nome Wave, 100 elementos e tipo de dados duplo. A fila
terá capacidade para armazenar 100 números de ponto flutuante.
2. Crie dois loops while. O loop superior contém uma estrutura de eventos. O caso do evento Timeout é
executado uma vez a cada 100 ms. Ele gera um ponto em uma onda senoidal e enfileira os dados.
Enfileirar dados significa colocar dados em uma fila. O loop inferior retira os dados da fila e os coloca
em um gráfico uma vez a cada 1000 ms. Desenfileirar dados significa retirar dados de uma fila. Veja
a captura de tela a seguir. Observe que os dados entram na fila mais rápido do que saem. Como o
terminal de tempo limite não está conectado, a operação de enfileiramento nunca atingirá o tempo limite
por padrão. Quando o nó de enfileiramento for executado e a fila estiver cheia, o programa fará uma
pausa no nó de enfileiramento até que um espaço esteja disponível por uma operação de
desenfileiramento.
104
capítulo 5
3. O próximo caso de evento no loop superior é Exit. É executado quando o controle Exit Boolean é clicado.
Ele define a condição de parada do loop while para o valor do controle booleano Exit , que será
verdadeiro e fará com que o loop seja encerrado.
105
Passando dados
4. Fora do loop, a referência da fila é destruída. Ele está localizado fora do loop superior. Quando a referência da fila
for destruída, o loop inferior também sairá, uma vez que a condição de parada do loop inferior está conectada
ao terminal de erro do desenfileiramento
nó. Quando a referência da fila for destruída, o nó de desenfileiramento gerará um erro, que fará com que o
loop inferior pare.
Como funciona…
Esta receita contém dois loops. O loop superior gera um ponto de dados de uma onda senoidal uma vez a cada 100 ms. Os
dados são passados para o loop inferior por meio de uma fila. O loop inferior retira os dados da fila e os exibe em um
gráfico uma vez a cada segundo. Assim que o usuário clica em sair, o loop superior é concluído e a função de destruição
da fila é executada. Nesse ponto, a referência da fila torna-se inválida. Quando o loop inferior tenta retirar da fila um
elemento com uma referência de fila inválida, ocorre um erro e interrompe o loop inferior. Quando o programa
enfileira um elemento na fila e a fila está cheia, o programa ficará preso no nó de enfileiramento até que um elemento seja
retirado da fila para liberar espaço, uma vez que nenhum tempo limite é especificado.
Usando um notificador para passar dados

Um notificador permite passar o mesmo dado para vários locais, ao contrário de uma fila.
Esta receita demonstra como usar o notificador para transmitir dados.
Como fazer isso…

Criaremos um programa que passa uma amplitude especificada pelo usuário para dois loops diferentes que geram uma
onda senoidal e triangular.
1. Coloque o nó Obter Notificador com um número de precisão dupla como dados do elemento
digite entrada.
106
capítulo 5
2. Crie três loops while. O loop superior contém uma estrutura de evento que é executada após
o loop ser executado uma vez, que é quando a Primeira Chamada? a função gera falso.
Quando uma notificação é recebida nos loops inferiores, o botão Aguardar Notificação
O nó recebe a nova amplitude do loop superior e gera um ponto de dados nas ondas
senoidais e triangulares de acordo. A nova amplitude é salva no registrador de deslocamento.
Sem receber uma notificação do loop superior, o nó Wait on Notification nos loops inferiores
atingirá o tempo limite em 5 ms para gerar pontos de onda senoidal e triangular para exibi-
los com a amplitude anterior armazenada no registrador de deslocamento.
107
Passando dados
3. Para o loop superior, o caso verdadeiro notifica os loops inferiores da amplitude inicial quando o programa é
iniciado.
4. O próximo caso de evento do loop superior é manipulado quando o botão Sair é clicado, conforme mostrado
na captura de tela a seguir:
5. Quando o loop superior termina, ele prossegue para o nó Destroy Notifier . Após a destruição do
notificador, os loops inferiores, que aguardam o notificador, irão gerar um erro, pois o notificador não
está mais disponível. O erro fará com que os loops inferiores saiam.
108
capítulo 5
Como funciona…
A receita gera ondas sinusoidais e triangulares com base na amplitude especificada pelo usuário.
Quando um usuário clica em atualizar, a amplitude é enviada para os loops inferiores por meio de um notificador.
Os loops inferiores usarão a nova amplitude para gerar as ondas de acordo. Se os loops inferiores não obtiverem
uma nova amplitude em 5 ms, o nó Wait on Notification atingirá o tempo limite e os loops inferiores usarão a
amplitude anterior para gerar as ondas. Assim que o usuário clicar em sair, o loop superior será concluído e
executará a Notificação de Liberação, o que invalidará a referência do notificador. Quando os loops inferiores
aguardam uma notificação com uma referência inválida, ocorrem erros e os loops são interrompidos.
Usando uma variável compartilhada para passar dados

Uma variável compartilhada é usada para transmitir dados dentro de um programa, entre diferentes programas
no mesmo PC e entre programas implantados em diferentes PCs na mesma rede.
É muito semelhante a uma variável global, mas contém recursos que podem prevenir condições de corrida.
Esta receita demonstra como usar variáveis compartilhadas para passar dados.
Como fazer isso…

Criaremos dois VIs que rodam no mesmo PC e compartilham dados com uma variável compartilhada. Este tipo
de variável é denominado "processo único". Para uma variável acessível a todos os PCs na mesma rede, o tipo de
variável é denominado "publicação de rede".
1. Crie um projeto. Clique com o botão direito em Meu Computador e navegue até Novo | Variável. Quando
uma caixa de diálogo aparecer, configure a variável para processo único. Veja a captura de tela a
seguir para saber como ficará o projeto após a adição da variável.
109
Passando dados
2. Crie o seguinte diagrama de blocos. Isso funciona como um servidor. Ele gera um ponto em uma
onda senoidal com amplitude aleatória e o grava na variável compartilhada WaveformValue
uma vez a cada 500 ms. Um usuário pode interromper o loop clicando no controle booleano stop .
3. Crie o seguinte diagrama de blocos. Este é um VI separado e atua como um cliente.

Ele lê o nó WaveformValue e o carimbo de data/hora quando o valor foi gravado.
Isso é executado uma vez a cada 100 ms. Um usuário pode clicar no controle booleano stop para
interromper o loop.
Como funciona…
Nesta receita, criamos uma única variável compartilhada de processo. É usado como variável global nesta receita;
o VI servidor e cliente estão na mesma estação de trabalho. As variáveis compartilhadas também podem ser
configuradas de forma que possam ser acessadas por qualquer computador na mesma rede. Nesta receita, o
servidor gera um ponto de dados em uma onda senoidal e o cliente obtém os dados e os exibe em um gráfico. As
informações de carimbo de data/hora também são exibidas no cliente e refletem quando o novo valor é gravado
na variável.
110
capítulo 5
Usando mensagens TCP/IP simples para transmitir dados

Mensagens TCP/IP simples (STM) são outra maneira de transmitir dados entre programas dentro de um PC e
programas executados em PCs diferentes na mesma rede. É muito semelhante à variável compartilhada, mas
utiliza o protocolo TCP/IP para comunicação. Esta receita demonstra como usar STM para transmitir dados.
Como fazer isso…

Neste exemplo, criaremos dois programas que residem no mesmo PC e se comunicarão via STM.
1. Crie o VI do servidor. O primeiro estado é Inicializar. Ele aguarda uma conexão TCP na porta 55555 e
configura o nome da variável para a conexão. Ele configura os metadados para mensagens, que são
então enviados para o outro lado para fins de decodificação de mensagens. O nome da variável Number
é enviado como metadados. Como o STM está se comunicando via TCP/IP, o firewall pode representar
um problema para a comunicação. Se for esse o caso, abra exceção para a porta onde ocorre a
comunicação na configuração da rede do PC. Consulte um profissional de TI para a configuração. Veja a
seguinte captura de tela:
111
Passando dados
2. O próximo estado é “Enviar Dados”. Ele contém uma estrutura de evento. O caso do evento "Enviar":
Alteração de Valor é executado quando o usuário clica em Enviar. Ele enviará o número
especificado pelo usuário pela rede. O número enviado é especificado pelo usuário através do
controle no painel frontal. Veja a seguinte captura de tela:
3. O próximo caso de evento é stop. Isso fará a transição do programa para o estado de saída , conforme mostrado
na captura de tela a seguir:
4. O próximo estado é “Sair”. Ele obtém a referência TCP e a fecha.
112
capítulo 5
5. Crie o VI cliente. É uma máquina de estado. No primeiro estado Inicializar, faz

uma conexão TCP/IP com o localhost (próprio) na porta 55555 e lê os metadados para fins de
decodificação de mensagens, conforme mostrado na captura de tela a seguir:
6. O próximo estado é “Obter Dados”. Ele lê os dados reais descritos pelo

metadados e os interpreta. Quando o nó STM Read Message não atinge o tempo limite, um valor é recebido.
Se o valor tiver o número de metadados, que é o esperado, a string recebida não será nivelada em um valor
de precisão dupla. Se a saída
O controle booleano é clicado e a máquina de estado passa para o estado Exit .
Caso contrário, a máquina de estado irá para o estado Obter Dados .
113
Passando dados
7. O próximo estado é “Sair”. Veja a captura de tela a seguir. Fecha todas as referências que foram criadas. Ele
define a condição de parada da máquina de estado como verdadeira para interromper o loop.
Como funciona…
Nesta receita, há um VI servidor e um VI cliente. O VI servidor espera que o VI cliente estabeleça uma
conexão e transmite os metadados ao cliente assim que a conexão for feita. O cliente receberá dados sempre
que o servidor clicar em enviar.
Veja também
f O LabVIEW não vem com a biblioteca Simple TCP/IP Message (STM). Baixe stm_202_installer.zip no
seguinte link para arquivos do instalador: http://zone.ni.com/devzone/cda/epd/p/id/2739. Após a
instalação, você pode acessar o STM através da paleta em Bibliotecas do Usuário.
114
Manipulação de erros
6
Neste capítulo, abordaremos:
f Passando um erro
f Tratamento de um erro com um arquivo de erro
f Lidando com um erro com um VI centralizado
f Criando uma fila de erros
Introdução
Este capítulo apresenta dicas sobre diferentes maneiras de lidar com erros de maneira adequada. Este tópico é
frequentemente ignorado, pois o LabVIEW pode tratar alguns erros automaticamente. No entanto, projetar nosso
próprio esquema de tratamento de erros tornará a depuração muito mais fácil, pois podemos adicionar informações
de erro personalizadas, registro e assim por diante para facilitar o processo de depuração.
Passando um erro
Esta receita demonstra como um erro é transmitido em uma máquina de estado. Quando ocorre um erro, ele
deve ignorar todo o código subsequente, para que as informações do erro não sejam corrompidas.
As informações do erro finalmente chegarão a um manipulador de erros que mostrará uma caixa de diálogo, registrará o erro em um
arquivo e assim por diante.
Como fazer isso...

Criaremos uma máquina de estados com estados que gerarão um erro aleatoriamente. Quando ocorrer um
erro, ele passará para o estado de tratamento de erros e o manipulador de erros fará com que uma caixa
de diálogo de erro apareça.
1. Crie a máquina de estados no diagrama de blocos a seguir. O enum é um type-def com valores Case 1,
Case 2, Case 3 e End. Todos os casos, exceto Caso 3 e Caso final , chamam GenerateError.vi e
transitam para o próximo estado. Examinaremos o SubVI em etapas posteriores.
2. O Caso 2 é quase idêntico ao Caso 1, portanto não é mostrado. A única diferença é que
O Caso 2 fará a transição para o Caso 3. Para o Caso 3, o mesmo SubVI é chamado, mas se ocorrer
um erro, o próximo estado é End; caso contrário, a máquina de estados volta ao Caso 1.
116
Capítulo 6
3. Para o caso "Fim" , veja a captura de tela a seguir. O erro é tratado pelo Simple Error Handler.
Se houver um erro, uma caixa de diálogo de erro aparecerá para indicar que ocorreu um
erro.
4. Os SubVIs usados nos Casos 1, 2 e 3 são mostrados na captura de tela a seguir. Se ocorrer
um erro no upstream, o caso Error (não mostrado) será executado. O case não faz muita
coisa, apenas passa o erro do upstream sem corrompê-lo.
Para o caso Sem Erro , as entradas Numérica e Estado são utilizadas para tornar a
mensagem de erro mais descritiva, para que possamos saber quando e onde ocorre um
erro. Ele gera um erro aleatoriamente ao comparar um número aleatório com o número 0,8.
Se o número aleatório for maior que 0,8, um erro será criado. Ele cria uma mensagem de
erro que indica em que estado e em qual iteração o erro ocorreu.
Todos os erros recebem o código de erro 5000. No LabVIEW, os intervalos de códigos de
erro personalizados são -8999 a -8000, 5000 a 9999 e 500.000 a 599.999. Escolhemos 5000
para simplificar, mas podemos fazer o código do erro como entrada e fazer com que o erro
gerado por cada estado tenha um código diferente. Os casos de erro e falso ficam em branco
durante a alimentação através dos terminais aplicáveis. Existem códigos de erro que são
usados pelo LabVIEW. Para encontrar mais informações sobre esses códigos, visite http://zone.ni.com/
referência/en-XX/help/371361J-01/lverror/misc_lv_error_codes/.
117
Como funciona...
Neste exemplo, um erro é gerado aleatoriamente se um número aleatório for maior que 0,8. No
SubVI, uma estrutura de caso de erro envolve todo o código para que o código seja ignorado se
houver um erro no upstream. Este é um aspecto importante na passagem/tratamento de erros. Se
ocorrer um erro, ele deverá pular todo o código subsequente para que as informações do erro não
sejam corrompidas e o erro seja tratado posteriormente em uma parte designada do código.
Os casos 1 a 3 geram um erro aleatoriamente. No Caso 3, se nenhum erro ocorrer, o programa

voltará ao Caso 1. Se ocorrer um erro, o programa irá para o estado Final . No estado Final , o
Simple Error Handler gerará uma caixa de diálogo que notificará o usuário sobre o erro.
Lidando com um erro com um arquivo de erro

Esta receita demonstra como lidar com erros por meio de um arquivo central. O arquivo é baseado
em texto e pode ser lido sem LabVIEW. O texto exato do erro pode ser atualizado facilmente e
cada erro tratado é visto claramente. Quando um aplicativo que usa um arquivo de erro é
implementado, o arquivo de erro também deve ser implementado com o aplicativo.
Como fazer isso...

O último exemplo criou a mensagem de erro e o código de erro dentro do programa. Neste exemplo,
o código de erro ainda é especificado no programa, mas a mensagem de erro é capturada em um
arquivo de texto.
1. Neste exemplo, usaremos a máquina de estados da receita anterior, Passando um erro.

Somente o SubVI será modificado. Faça um Save As na receita anterior e salve-a com
outro nome.
2. O SubVI irá gerar um erro aleatoriamente. O número aleatório é convertido em números

inteiros entre 5000-5009. O código de erro é convertido em um cluster de erro por
meio do VI Error Cluster From Error Code .
118
Capítulo 6
3. Crie um arquivo de erro que associe o código do erro à descrição do erro. No diagrama de blocos,
navegue até Ferramentas | Avançado | Edite códigos de erro. Crie um novo arquivo de
erro e salve-o na pasta <versão>\user.lib\errors . O formato do nome do arquivo de erro é xxx-
errors.txt, onde xxx é o nome do arquivo.
Como funciona...
Semelhante à receita anterior, Passando um erro, este exemplo gera um erro aleatoriamente.
A diferença é como as informações de erro são empacotadas. Na receita anterior, as informações do
erro são empacotadas dentro do código. Para esta receita, as informações do erro estão localizadas em
um arquivo de erro e o código pode extrair informações usando o código de erro correspondente. Este é
um bom método para centralizar informações de erro, mas cria um arquivo adicional que deve ser
implantado corretamente no momento da implantação.
Veja também
Ao implantar um executável, o local do arquivo de erro associado ao executável é diferente do local do

arquivo no modo de desenvolvimento. Para mais informações, consulte o seguinte link: http://
www.ni.com/white-paper/3209/en/.
119
Lidando com um erro com um VI centralizado

Esta receita demonstra como agrupar todas as informações de erro em um VI. Com esta abordagem, todas as
informações de erro estão dentro de um VI e não há necessidade de acompanhar um arquivo de erro.
Como fazer isso...

Criaremos uma máquina de estados que irá gerar um erro aleatoriamente. Quando o erro for gerado, ele
ignorará o código subsequente e irá para o manipulador de erros.
1. Construa a máquina de estado conforme mostrado na captura de tela a seguir. O enum é um type-def e possui
os valores Initialize, Case 1, Case 2, Case 3 e End . O caso Initialize envia todos os códigos de erro e
mensagens possíveis para o SubVI para tratamento.
2. O caso 1 utiliza um SubVI para gerar um erro aleatoriamente.
3. O Caso 2 é quase idêntico ao Caso 1, exceto que o Caso 2 transita para o Caso 3,
portanto, a captura de tela do Caso 2 não é mostrada. O Caso 3 transitaria de volta para o Caso 1
se não houver erro. Ele transitaria para o estado final se ocorresse um erro.
Veja a seguinte captura de tela:
120
Capítulo 6
4. O estado “End” chama um SubVI para tratar o erro.
5. O tratamento de erros do SubVI é mostrado na captura de tela a seguir. O estado inicializar

salva as informações de erro em registradores de deslocamento.
121
6. O segundo estado do tratamento de erros SubVI trata o erro.
7. O SubVI que gera erros aleatoriamente é mostrado na imagem a seguir. As entradas Numeric e
State são utilizadas para tornar a mensagem de erro mais descritiva, para que possamos
saber quando e onde ocorre um erro. Ele gera um erro aleatoriamente ao comparar um
número aleatório com o número 0,8. Se o número aleatório for maior que 0,8, um erro será
criado. Ele fornece ao erro uma mensagem que indica em que estado e em qual iteração
o erro ocorreu. O nó Format Into String é usado para criar uma mensagem de erro com as
entradas fornecidas. Um código de erro diferente é fornecido dependendo do estado em que
o erro ocorreu. Um código de erro é associado ao cluster de erro dependendo do caso em que
o erro ocorreu.
Como funciona...
Este exemplo mostra como consolidar informações de erro e colocá-las dentro do código. Ao fazer isso,
as informações de erro são centralizadas sem a necessidade de usar um arquivo de erro. No
exemplo, o primeiro caso salva todas as informações de erro no manipulador de erros SubVI. Para
tornar o programa mais elegante, podemos criar um VI wrapper em torno dele. Após o estado
Inicializar , o programa irá gerar um erro aleatoriamente. No Caso 3, o programa irá para o estado
Final , caso tenha ocorrido um erro. Caso contrário, o programa voltará ao Caso 1. Quando o programa chegar ao Fim
estado, significa que ocorreu um erro e será tratado pelo SubVI de tratamento de erros.
122
Capítulo 6
Criando uma fila de erros

Esta receita demonstra como usar uma fila de erros em um processo paralelo para tratamento de erros.
Isso permite lidar com erros em vários VIs.
Como fazer isso...

Para este método de tratamento de erros, o VI de tratamento de erros é executado em segundo plano no
programa principal para tratar erros.
1. Construa a máquina de estado conforme mostrado na captura de tela a seguir. A enumeração possui os
valores Inicializar, Caso 1, Caso 2, Caso 3 e Fim. O estado Initialize cria um caminho para
BackError.vi, assumindo que o VI está na mesma pasta que o VI principal e abre a referência do
VI com o nó Open VI Reference . A referência é conectada a um Invoke Node e o método Run VI é
selecionado, que chamará o VI dinamicamente em segundo plano. Fora da estrutura do caso, se houver
um erro, um SubVI enviará o cluster de erro para o VI de fundo e mudará o estado principal para o
estado End .
2. Os casos 1, 2 e 3 gerarão um erro aleatoriamente. Eles são idênticos. Veja a captura de tela a seguir
para o Caso 1:
123
3. O caso "End" encerra a fila usada para passar dados para o VI de segundo plano.
4. O erro de fila SubVI é mostrado na captura de tela a seguir. Quando um erro ocorre no upstream
e é passado para o SubVI, uma referência à fila de erros é obtida com o nó Obter Fila e o
cluster de erros é enfileirado com o nó Enqueue Element . Consulte o Capítulo 3, Trabalhando
com Arquiteturas Comuns, para ver outra aplicação sobre como uma fila é usada.
5. No erro ao enfileirar o SubVI, quando a mensagem Concluído? Boolean é definido como

True, a referência da fila de erros é obtida e liberada. Para a função de fila de liberação,
certifique-se de definir a destruição forçada como True, pois existem muitas referências da fila.
124
Capítulo 6
6. Os verdadeiros casos do VI de erro em segundo plano são mostrados na captura de tela a seguir.
Quando o VI é chamado pela primeira vez, os casos verdadeiros são executados. Ele cria um
arquivo Error.txt na mesma pasta do VI principal, configura informações de erro com o SubVI
de erro de tratamento e obtém uma referência para a fila de erros.
125
7. Os casos falsos do VI de erro em segundo plano são mostrados na captura de tela a seguir.
Eles são executados quando o VI não é executado pela primeira vez. Ele espera que um elemento seja retirado
da fila indefinidamente. Quando um elemento está disponível, ele é retirado da fila e gravado em um arquivo.
8. Se o código de erro for maior que 5001, uma caixa de diálogo de erro aparecerá para alertar o usuário
do erro. Veja a captura de tela a seguir para a caixa de diálogo:
Como funciona...
Este programa consiste em um VI principal e um VI de fundo. O VI principal inicia o VI de fundo e gera um erro aleatoriamente. Assim
que um erro é gerado, o VI principal passa o erro para o VI de segundo plano através de uma fila de erros. Depois que o VI de
segundo plano recebe as informações do erro, ele registra as informações em um arquivo. Se o código de erro for maior que 5001, uma
caixa de diálogo de erro aparecerá para indicar a gravidade do erro.
126
Trabalhando com arquivos

7
Neste capítulo, abordaremos as seguintes receitas:
f Trabalhando com arquivos INI
f Trabalhando com arquivos XML
f Trabalhando com arquivos ASCII
f Trabalhando com arquivos binários
f Trabalhando com arquivos TDMS
f Usando Telnet e FTP com arquivos
f Trabalhando com um banco de dados
Introdução
Este capítulo apresenta dicas sobre como trabalhar com diferentes tipos de arquivos, como INI, XML, ASCII, binário e
TDMS. Também exploraremos como usar Telnet, FTP e banco de dados neste capítulo.
Trabalhando com arquivos INI

Um arquivo INI é um arquivo de configuração que armazena constantes usadas em um programa. O arquivo consiste em
seções e chaves. As chaves são agrupadas em seções diferentes. Esta receita extrai os valores de todas as chaves em um
arquivo INI e os armazena em um cluster para que os valores possam ser recuperados em um programa.
Como fazer isso…

Para ler os valores de todas as chaves em um arquivo INI, criamos uma máquina de estado para iterar pelo arquivo, usando as
seguintes etapas:
1. Crie o arquivo INI para leitura. Veja a captura de tela a seguir para o conteúdo do
Arquivo INI.
2. Crie uma máquina de estado, conforme mostrado na captura de tela a seguir. Ele inicia no estado Open INI para abrir um
arquivo INI localizado na mesma pasta do VI. Depois que esse estado for concluído, ele transitará para o estado Extrair
Valores .
128
Capítulo 7
3. Crie o estado “Extrair Valores” , conforme mostrado na imagem a seguir. Ele percorre todas
as seções e chaves do arquivo INI. O valor de cada chave é agrupado em um cluster.
129
4. No estado Extrair Valores , ele agrupa os valores de todas as chaves listadas na imagem a seguir
em um cluster. A estrutura do caso recebe entrada de string, que é o nome das chaves no arquivo
INI.
5. Após todos os valores no arquivo INI serem agrupados em um cluster, a máquina de estado transita
para o estado "Exit" . Veja a captura de tela a seguir, onde a referência do arquivo INI é fechada
e o erro é tratado:
130
Capítulo 7
6. O cluster preenchido pela máquina de estado é mostrado na captura de tela a seguir:
Como funciona…
Esta máquina de estado lê um arquivo INI na mesma pasta. Ele lê cada seção e chave e armazena todos
os valores em um cluster para processamento posterior. Em vez de codificar as constantes usadas
diretamente em um programa, usar um arquivo INI é a forma preferida. Se um valor no INI precisar ser alterado,
o arquivo poderá ser aberto, compreendido e modificado facilmente por qualquer usuário. Por outro lado, se um
valor estiver codificado em um programa, será necessária uma alteração de código. Além disso, o LabVIEW
possui funções integradas que funcionam com um arquivo INI, tornando o uso de arquivos INI mais conveniente.
131
Trabalhando com arquivos XML

Os arquivos Extensible Markup Language (XML) armazenam informações de forma que sejam legíveis por
humanos e por máquinas. No LabVIEW, existem muitas maneiras de trabalhar com XML, e esta receita
apresenta uma maneira de modificar um valor em um arquivo XML.
Como fazer isso…

Neste exemplo, criaremos um arquivo XML baseado em dados de diferentes pessoas e escreveremos uma
aplicação LabVIEW para modificar um parâmetro selecionado pelo usuário no arquivo. Este aplicativo é útil
quando você precisa modificar o mesmo parâmetro em mil arquivos XML. Nesse caso, a aplicação pode ser
executada em loop para todos os arquivos.
1. Crie um arquivo XML manualmente. Os dados de cada pessoa estão na carteira de estudante.
O nome, sexo, idade e detalhes da empresa de cada pessoa são registrados no arquivo.
Dê uma olhada na seguinte captura de tela:
2. Crie a máquina de estado, conforme mostrado na imagem a seguir. O primeiro estado é

"Entrada do usuário", que espera que os usuários cliquem em Iniciar ou Sair. Se um usuário clicar
em Iniciar, a máquina preencherá um cluster com valores dos controles do painel frontal e entrará no
estado Inicializar . Se um usuário clicar em Sair, a máquina transita para Fechar Ref.
estado imediatamente.
132
Capítulo 7
3. O próximo estado é "Inicializar". Ele abre o arquivo XML com um caminho especificado pelo usuário e
agrupa a referência no cluster de entrada, conforme mostrado na captura de tela a seguir:
133
4. O próximo estado é "Elemento do Documento". Ele abre a referência do elemento que está um nível abaixo na estrutura XML
e transita para o próximo estado Match Node.
5. No estado "Match Node" , ele pega uma expressão XPath (um critério de pesquisa XML) e retorna um resultado de
pesquisa. Em seguida, ele transita para o estado do nó filho .
134
Capítulo 7
6. Depois que o nó desejado for encontrado, o estado "Nó Filho" desce um nível na estrutura XML e
transita para o estado Modificar Valor .
7. No estado "Modificar valor" , ele modifica um valor com base na entrada do usuário e nos trânsitos
para o estado Salvar XML , conforme mostrado na captura de tela a seguir:
135
8. Após as alterações serem feitas no arquivo XML, o arquivo XML é salvo e transita para o
Exibir estado XML.
9. No estado "Exibir XML" , ele lê o arquivo XML e gera o conteúdo em um indicador de string.
Feito isso, ele volta ao estado de entrada do usuário para aguardar a entrada do
usuário.
136
Capítulo 7
10. Se o botão Sair for clicado, o estado "Fechar Ref" é inserido. Este estado fecha todas as referências XML
abertas, conforme mostrado na captura de tela a seguir:
11. Após o fechamento das referências, o programa chega ao estado "End" onde o
o loop do programa é interrompido, conforme representado na captura de tela a seguir:
137

LabVIEW Graphical Programming Cookbook-101-150

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

LabVIEW Graphical Programming Cookbook-101-150

Enviado por

Direitos autorais:

Formatos disponíveis

Machine Translated by Google

Manipulando uma matriz

Como fazer isso…

1. Crie o seguinte diagrama de blocos para inserir um elemento na frente de um array. No

Como fazer isso…

Como fazer isso…

1. Crie o seguinte diagrama de blocos. Primeiro, é criado um array de três semáforos.

3. O painel frontal na captura de tela a seguir mostra como o programa atualizará o

f Para mais detalhes sobre os problemas dos fumantes, consulte

f Usando um cluster type-def

f Usando uma estrutura de eventos para passar dados

f Usando uma fila para passar dados

f Usando um notificador para passar dados

f Usando uma variável compartilhada para passar dados

f Usando mensagens TCP/IP simples para transmitir dados

Usando um cluster type-def

Como fazer isso…

3. O próximo estado é “Gerar Número”. Ele gera um número aleatório de 0 a

4. O próximo estado é o estado "Multiply Num" . Ele desmembra os valores Random

6. A captura de tela a seguir mostra o outro caso da estrutura de caso. Se a entrada

7. O último estado é o estado "Saída" . Define a condição de parada da máquina de estado

Usando uma estrutura de eventos para passar dados

Como fazer isso…

2. O Refnum de Registro de Evento do nó Registrar para Evento é alimentado no Terminal de Evento

Usando uma fila para passar dados

Como fazer isso…

Usando um notificador para passar dados

Como fazer isso…

Usando uma variável compartilhada para passar dados

Como fazer isso…

3. Crie o seguinte diagrama de blocos. Este é um VI separado e atua como um cliente.

Usando mensagens TCP/IP simples para transmitir dados

Como fazer isso…

4. O próximo estado é “Sair”. Ele obtém a referência TCP e a fecha.

5. Crie o VI cliente. É uma máquina de estado. No primeiro estado Inicializar, faz

6. O próximo estado é “Obter Dados”. Ele lê os dados reais descritos pelo

f Tratamento de um erro com um arquivo de erro

f Lidando com um erro com um VI centralizado

f Criando uma fila de erros

Como fazer isso...

Os casos 1 a 3 geram um erro aleatoriamente. No Caso 3, se nenhum erro ocorrer, o programa

Lidando com um erro com um arquivo de erro

Como fazer isso...

1. Neste exemplo, usaremos a máquina de estados da receita anterior, Passando um erro.

2. O SubVI irá gerar um erro aleatoriamente. O número aleatório é convertido em números

Ao implantar um executável, o local do arquivo de erro associado ao executável é diferente do local do

Lidando com um erro com um VI centralizado

Como fazer isso...

2. O caso 1 utiliza um SubVI para gerar um erro aleatoriamente.

4. O estado “End” chama um SubVI para tratar o erro.

5. O tratamento de erros do SubVI é mostrado na captura de tela a seguir. O estado inicializar

6. O segundo estado do tratamento de erros SubVI trata o erro.

Criando uma fila de erros

Como fazer isso...

5. No erro ao enfileirar o SubVI, quando a mensagem Concluído? Boolean é definido como

Trabalhando com arquivos

f Trabalhando com arquivos INI

f Trabalhando com arquivos XML

f Trabalhando com arquivos ASCII

f Trabalhando com arquivos binários

f Trabalhando com arquivos TDMS

f Usando Telnet e FTP com arquivos

f Trabalhando com um banco de dados