Apostila LABVIEW- Final[1]

82
UNIVERSIDADE FEDERAL DE SANTA M ARIA UFSM CENTRO DE TECNO LOGIA CT CURSO DE ENG EN H A R IA ELÉTR IC A NÚCLEO DE PESQ UISA E DESENVO LVIM EN TO EM ENG EN H A R IA ELÉTR IC A NUPEDEE PRO G RAM A DE EDUCAÇÃO TUTO RIA L PET-EE Introdução ao 7.0 S anta M aria, Julho de 2 007

Transcript of Apostila LABVIEW- Final[1]

Page 1: Apostila LABVIEW- Final[1]

UNIVERSIDADE FEDERAL DE SANTA MARIA UFSMCENTRO DE TECNOLOGIA CT

CURSO DE ENGENHARIA ELÉTRICANÚCLEO DE PESQUISA E DESENVOLVIMENTO

EM ENGENHARIA ELÉTRICA NUPEDEEPROGRAMA DE EDUCAÇÃO TUTORIAL PET-EE

Int r odução ao

7.0

S anta Mar ia, J ul ho de 2007

Page 2: Apostila LABVIEW- Final[1]

Sumário

Capítulo 1 – Introdução.................................................................................4

Capítulo 2 – Construindo um VI (Instrumento Virtual)................................5

2.1 – Abrindo um novo VI pelo template......................................................................5

2.2 – Adicionando um controle para o painel frontal....................................................6

2.3 – Alterando o tipo de Sinal......................................................................................7

2.4 – Conectando objetos no diagrama de blocos.........................................................9

2.5 – Executando o VI...................................................................................................9

2.6 – Modificando o sinal............................................................................................10

2.7 - Mostrando dois sinais no gráfico........................................................................11

2.8 – Alterando as propriedades do potenciômetro (knob).........................................11

2.9 – Alterando as propriedades do gráfico.................................................................13

Capítulo 3 – Analisando e salvando dados..................................................15

3.1 – Abrindo um novo VI através de uma template:..................................................15

3.2 – Modificando o diagrama de blocos:...................................................................16

3.3 – Alterando o painel frontal...................................................................................17

3.4 – Analisando a amplitude do sinal.........................................................................17

3.5 – LED de aviso......................................................................................................18

3.6 – Configurando o limite para acionar o alerta.......................................................19

3.7 – Configurando o VI para salvar dados.................................................................21

3.8 – Salvando os dados em um determinado período................................................23

Capítulo 4 – Personalizando um VI............................................................25

4.1 – Abrindo um novo VI..........................................................................................25

4.2 – Adicionando um VI que simulará um sinal........................................................26

4.3 – Modificando o sinal............................................................................................26

4.4 – Personalizando interface do usuário pelo diagrama de blocos...........................27

4.5 – Configurando o VI para executar continuamente...............................................28

4.6 – Exemplos de VI..................................................................................................29

4.7 – Controlando a velocidade de execução..............................................................30

4.8 – Usando uma tabela de dados e mostrando no painel frontal..............................30

Capítulo 5 – Exemplo de projeto utilizando LabVIEW..............................32

5.1 – Tarefa 1: Criando um programa para o controle de temperatura.......................34

5.2 – Tarefa 2: Utilizando estruturas de realimentação de dados................................37

2

Page 3: Apostila LABVIEW- Final[1]

5.3 – Tarefa 3: Lendo arquivos de texto e criando um subVI.....................................39

5.4 – Tarefa 4: Utilizando um subVI...........................................................................42

5.5 – Tarefa 5: Trabalhando com datas e plotando dados em um gráfico...................43

5.6 – Tarefa 6: Comunicando-se com o mundo externo através da serial...................45

5.7 – Tarefa 7: Implementando uma aplicação completa de medição e automação. . .48

5.7.1 – Parte A: Módulo Escravo.......................................................................................................485.7.2 – Parte B: Módulo mestre.........................................................................................................50

Capítulo 6 – Tecnologias para aquisição de dados.....................................52

6.1 – Principais interfaces disponíveis no mercado.....................................................53

6.2 – Como escolher uma interface I/O específica?....................................................55

6.3 – Como configurar e utilizar os dados adquiridos no LabVIEW? ......................55

Apêndice A..................................................................................................57

1. Ligação da porta serial em curto-circuito ou loop-back..........................................57

2. Conexão de dois computadores através da porta serial...........................................57

Apêndice B – Atalhos do LabVIEW 7........................................................59

Referências..................................................................................................63

3

Page 4: Apostila LABVIEW- Final[1]

Capítulo 1 – Introdução

LabVIEW é uma linguagem de programação gráfica que usa ícones no lugar de

linhas de texto para criar aplicações. Em contraste com as linguagens baseadas em

texto, onde as instruções determinam a execução do programa, o LabVIEW usa uma

programação tipo fluxo de dados, onde este fluxo determina a execução. Esta linguagem

(acrônimo para Laboratory Virtual Instruments Engineering Workbench) foi

desenvolvida no final da década de 80 pela National Instruments, Inc para ambientes de

janelas (tipo Windows). Tornou-se popular e largamente aceito no meio científico,

sendo similar a outras linguagens gráficas oferecidas por outras empresas, como o

pacote HP-VEE da Hewlett-Packard. No LabVIEW, pode-se construir uma interface

usufruindo de um conjunto de ferramentas e objetos. A interface do usuário é conhecida

como painel frontal. Então, os códigos são adicionados usando representações gráficas

das funções, para controlar os objetos do painel frontal. O diagrama de blocos contém

este código. De muitas formas, o diagrama de blocos imita um fluxograma. Utiliza-se

uma linguagem de programação gráfica chamada G, mas não é necessário conhecê-la

para usufruir das possibilidades do LabVIEW. Pode-se adquirir muitos conjuntos de

ferramentas para o desenvolvimento de aplicações específicas. Todos estes conjuntos de

ferramentas integram perfeitamente o LabVIEW. Também é compatível com

ferramentas de desenvolvimento similares e pode trabalhar com programas de outra área

de aplicação, como o Matlab.

Além desta facilidade no desenvolvimento de aplicações computacionais, é de simples

integração com os componentes físicos do sistema, especialmente com placas de

medição, aquisição e processamento de dados, incluindo aquisição de imagens.

Encontra aplicabilidade em sistemas de medição, como monitoramento de processos e

aplicações de controle. É muito utilizado no processamento digital de sinais (Wavelets,

FFT, análise de conteúdo harmônico etc.), em processamento em tempo real de

aplicações biomédicas, na manipulação de imagens e áudio, automação, no projeto de

filtros digitais, geração de sinais, e outras.

4

Page 5: Apostila LABVIEW- Final[1]

Capítulo 2 – Construindo um VI (Instrumento Virtual)

Neste exercício você construirá um VI que irá gerar um determinado sinal e este

sinal irá ser plotado num gráfico. Quando você completar este exercício, o painel frontal

do VI ficará semelhante ao da figura 2.1.

Figura 2.1 – Projeto final do exemplo construindo um VI

2.1 – Abrindo um novo VI pelo template

O LabVIEW possui uma série de templates que facilitam o usuário a construir

seus VIs. Complete os seguintes passos para criar um VI que gere um sinal e mostre no

painel frontal.

1. Abra o LabVIEW.

2. Vá na opção New.

3. Escolha a opção VI from Template>>Tutorial (Getting Started)>>Generate

and Display. Note que na parte central da tela existe uma visualização do

painel central e também do diagrama de bloco.

4. Observe no painel frontal do VI que este possui um fundo cinza e inclui

indicadores e controladores. A barra azul, no topo da página indica o arquivo

que está aberto e se este está ou no painel central ou no diagrama de blocos.

5. Ainda no painel frontal pressione as teclas <Ctrl+E> e perceba que você irá

automaticamente para a área do diagrama de blocos, ou se preferir vá no

menu window>>show block diagram. O diagrama de blocos possui um

5

Page 6: Apostila LABVIEW- Final[1]

fundo branco e inclui VIs e estruturas que controlam os elementos do painel

frontal. Perceba que agora a barra azul, no topo da página indica o arquivo

aberto e se está no painel frontal ou no diagrama de blocos, neste caso

confirme que você está no diagrama de blocos.

6. Volte para a janela do painel frontal e faça que o programa rode. Você

poderá realizar este comando através de três maneiras, clicando no botão

, acessando o menu operate>>run ou simplesmente clicando <Ctrl+R>.

7. Pare o VI clicando no botão STOP , ou se preferir menu

operate>>stop ou ainda <Ctrl+.> (Control e ponto).

2.2 – Adicionando um controle para o painel frontal

Controles no painel frontal simulam a entrada de instrumentos físicos e

fornecem dados para o diagrama de blocos do VI (relembrando que VI significa Visual

Instrument, a partir de agora iremos apenas nos referir a esses instrumentos virtuais da

forma contraída). Muitos instrumentos físicos possuem potenciômetros que possibilitam

uma alteração em determinados sinais. Neste exemplo iremos adicionar um

potenciômetro, para isso, siga os passos.

1. Vá até a paleta de controles window>>Show Controls Pallete.

2. Mova o cursor até os ícones de controle numérico (Numeric Controls).

3. Clique no ícone de controles numéricos.

4. Selecione o potenciômetro (knob) e o coloque no painel frontal, ao lado

direito do gráfico de forma de onda.

5. Delete o gráfico de ondas.

6. Para desfazer alguma operação que você realizou basta digitar <Ctrl+Z>,

digite e faça com que o gráfico de ondas retorne a tela.

7. Após isso, salve o VI com o nome de “sinal de aquisição de dados.vi”.

6

Page 7: Apostila LABVIEW- Final[1]

Figura 2.2 – Paleta de Controle

2.3 – Alterando o tipo de Sinal

O diagrama de bloco possui um ícone azul, denominado Simulate Signal. Este

sinal tem como forma padrão a onda senoidal. Complete os seguintes passos para mudar

a forma de onda para dente de serra (sawtooth wave).

1. Vá até paleta de controles, window >>Show Controls Pallete.

2. Vá até a janela do diagrama de blocos <Ctrl+E>.

3. Com o botão direito do mouse clique sobre o simulador de sinal e selecione a

opção propriedades, após isso abrirá uma nova janela denominada Configure

Simulate Signal (barra azul).

4. Selecione a forma de onda dente de serra (sawtooth) no campo Signal type.

7

Page 8: Apostila LABVIEW- Final[1]

Figura 2.3 – Configuração do Sinal Simulado

5. Clique no botão OK e feche a janela de Configure Simulate Signal.

6. Aumente a caixa do simulador de sinal, puxando-a para baixo, até o item

Amplitude aparecer disponível. Com esta operação você poderá alterar a

amplitude através de um elemento auxiliar como um potenciômetro na

entrada.

Figura 2.4 – Aumentando a caixa da simulação de sinal.

8

Page 9: Apostila LABVIEW- Final[1]

2.4 – Conectando objetos no diagrama de blocos

Para alterar a amplitude do sinal simulado você irá precisar adicionar um

potenciômetro (knob) e realizar a conexão entre este e a entrada de Amplitude.

1. Certifique-se que o knob está dentro do laço (retângulo de bordas cinzas),

portanto todos os elementos que serão mencionados neste exemplo devem

estar dentro do laço para haver uma repetição no processamento.

2. Verifique onde se encontra o knob em relação ao Simulador de Sinal, faça

com que ele esteja posicionado à esquerda do simulador, para movimentar o

componente, você deve clicar com o mouse com o botão esquerdo e arrastar

de tal modo que faça uma área e dentro dessa área esteja o componente a ser

movimentado.

3. Após isso, mova o cursor do mouse até o canto direito do knob, onde há um

símbolo de uma flecha, observe o aparecimento de uma carretilha .

4. Quando a carretilha aparecer, pressione o botão esquerdo do mouse e arraste

até a entrada do Simulador de Sinal, denominada Amplitude.

Figura 2.5 – Potenciômetro

5. Clique em qualquer lugar em branco para desativar a ferramenta de criação

de fio ou pressione ESC.

6. Salve o VI.

2.5 – Executando o VI

1. Vá para a janela do painel frontal.

9

Page 10: Apostila LABVIEW- Final[1]

2. Execute o programa

3. Mude o valor da amplitude através do modo de controle knob.

4. Perceba a mudança no gráfico conforme a intervenção no knob, e observe

também que o eixo y possui o sistema de auto escala.

Observe também que enquanto o programa roda, o botão indicador modifica

seu estado, ficando .

5. Pare o programa no botão .

2.6 – Modificando o sinal

1. No diagrama de bloco, dê um duplo clique no fio que liga o simulador de

sinal até o gráfico de ondas.

2. Delete esse fio.

3. Abra a paleta de funções.

4. Selecione a função Scaling and Mapping, na aba Arithmetic &

Comparison, e a coloque dentro do laço, entre o simulador de sinal e o

gráfico de ondas. Caso não exista espaço suficiente para esta função ocupar

este lugar mova o gráfico de ondas para direita. Observe que uma caixa

Configure Scaling Mapping irá abrir automaticamente.

5. Defina o valor do fator de escala em

10 no campo slope(m). A caixa de

diálogo deverá ficar da seguinte

maneira.

6. Clique no botão OK para aplicar as

alterações e feche a janela de

configuração.

7. Mova o cursor até o sinal de saída do

simulador de sinal.

8. Quando a carretilha aparecer, ligue a

saída de sawtooth (simulador) até a

ntrada Signals (Scaling and

Mapping).

10

Figura 2.6 – Valor da escala

Page 11: Apostila LABVIEW- Final[1]

9. Usando os fios, ligue a saída scaled signals até a entrada do gráfico de

ondas.

Figura 2.7 – Disposição do diagrama de blocos

10. Salve o VI.

2.7 – Mostrando dois sinais no gráfico

Para comparar os sinais gerados pelo simulador com os sinais em que foram

aplicados um determinado fator de escala, iremos seguir os seguintes passos.

1. Mova o cursor até a saída Sawtooth do simulador de sinal.

2. Usando as conexões, ligue a saída Sawtooth no terminal do gráfico de ondas.

Perceba que automaticamente será criado um nó no ramo que vai até o

gráfico.

3. Salve o programa, você poderá salvar o programa apenas clicando

<Ctrl+S>.

4. Retorne ao painel frontal, rode o programa e altere a amplitude do sinal

simulado. Observe as escalas no eixo y de cada gráfico.

2.8 – Alterando as propriedades do potenciômetro (knob)

11

Page 12: Apostila LABVIEW- Final[1]

Nesta etapa do exemplo iremos alterar as características do comando de controle

knob.

1. Vá até o menu de propriedades do knob através de um clique com o botão

direito no elemento.

2. Na aba Appearance, na seção Label altere Knob por Amplitude.

Figura 2.8 – Propriedades do potenciômetro

3. Clique na aba de escala e selecione o estilo da escala, complete a caixa da

rampa visível (Ramp Visible).

4. Clique OK para efetivar as mudanças.

5. Salve o VI <Ctrl+S>.

6. Experimente modificar outras propriedades do knob, escolha algumas como,

por exemplo, mudar o máximo da escala ou ainda, no menu Text Labels,

dividir as escalas em quantas desejar e ainda colocar nomes nestas escalas,

como na Figura 2.9.

12

Page 13: Apostila LABVIEW- Final[1]

Figura 2.9 – Painel frontal

2.9 – Alterando as propriedades do gráfico

Perceba que neste gráfico temos dois sinais, mas apenas uma legenda, portanto

vamos resolver este pequeno problema.

1. Dê um simples clique no Sawtooth (Scaled) e arraste para cima, de modo

que apareçam as outras escalas do gráfico.

Figura 2.10 – Acrescentando legenda ao gráfico

2. Dê um clique com o botão direito no meio do gráfico e vá até o menu

propriedades.

13

Page 14: Apostila LABVIEW- Final[1]

3. Na aba Plots¸ selecione sawtooth. Mude a cor da linha do gráfico.

4. Desmarque a caixa Do not use waveform names for plot names. Dessa

maneira você poderá alterar o nome do gráfico.

5. Altere o label do gráfico para Scaled Sawtooth.

6. Clique OK para efetivar as mudanças e saia das propriedades, perceba as

alterações de cor nas linhas das formas de onda. Altere outras propriedades

do gráfico para praticar, por exemplo, tire a auto escala do eixo Y.

7. Salve o programa depois de praticar um pouco e feche esse VI.

14

Page 15: Apostila LABVIEW- Final[1]

Capítulo 3 – Analisando e salvando dados

O LabVIEW possui vários VIs para ajudar você a analisar sinais. Neste exemplo

você irá aprender como fazer uma análise básica de um sinal e como salvar os dados

deste sinal. Você irá construir um VI que irá gerar um sinal, extrair o valor DC, indicar

se o sinal excedeu um certo limite e armazenar os dados. Ao término deste exemplo o

seu painel frontal deverá ficar como na Figura 3.11.

Figura 3.11 – Painel frontal ao término do exemplo.

3.1 – Abrindo um novo VI através de uma template:

Para construir este VI, você pode começar abrindo uma nova caixa de diálogo.

Siga os próximos passos para selecionar uma nova template que gere, analise e mostre

um sinal.

1. Ao abrir o programa, clique no botão com a opção New.

15

Page 16: Apostila LABVIEW- Final[1]

2. Selecione o VI from Template >> (Getting Started) >> Generate, Analyze,

and Display template e clique no botão OK.

3. Vá ao diagrama de blocos, pressione <Ctrl+H> para ativar o bloco de ajuda

de cada elemento, basta deixar o cursor do mouse sobre um elemento que

automaticamente o bloco de ajuda irá informar as características do elemento

em questão.

3.2 – Modificando o diagrama de blocos:

O Simulador de sinal deste template tem como onda padrão a senoidal. Siga os

passos para alterar a forma de onda:

1. Vá até o simulador, ainda no diagrama de blocos, e clique com botão direito

sobre ele, selecione a última opção do menu que aparecer, no caso

propriedades.

Figura 3.12 – Diagrama de blocos

2. Ao abrir as propriedades do simulador de sinal, mude o tipo de onda para

DC.

3. Adicione ruído à forma de onda (marque a caixa add noise).

4. Especifique 5.1 na amplitude do ruído (Noise Amplitude).

16

Page 17: Apostila LABVIEW- Final[1]

5. Vá até o painel frontal e faça rodar o VI. Perceba que o sinal aparece no

gráfico e o valor RMS aparece no indicador digital.

6. Pare o programa, salve o VI como Analise.vi utilizando a função save as.

3.3 – Alterando o painel frontal

Se você usar um template e não quiser utilizar determinado indicador, basta

deletá-lo, entretanto você deve tomar algumas precauções para evitar problemas. Siga

os passos para aprender o modo correto de remover indicadores.

1. Selecione o indicador RMS e delete-o.

2. Vá para o diagrama de blocos, perceba que o fio que conectava o indicador

RMS está quebrado e, além disso, que o botão utilizado para executar o

programa foi alterado, agora ele indica uma lista de erros que impossibilitam

a simulação.

3. Clique no botão para rodar o programa.

4. Observe o erro indicado, dê um duplo clique no erro “wire: has loose ends”,

perceba que irá mostrar na tela justamente o erro já mencionado

anteriormente.

5. Você tem duas formas de deletar os fios que estão sem conexão, uma delas é

selecionando um a um e deletando, outra é pressionado as teclas <Ctrl+B>

que irá deletar todos os fios sem conexão. Escolha uma das opções e delete o

fio.

6. Perceba que o botão para rodar o programa está novamente como padrão,

indicando que agora não há erros e é possível rodar o programa.

3.4 – Analisando a amplitude do sinal

O VI The Amplitude and Level Measurements Express possui opções que faz

com que você possa analisar níveis de tensão de um sinal. Complete os passos para

medir valores pico a pico deste sinal.

17

Page 18: Apostila LABVIEW- Final[1]

1. Vá até o diagrama de blocos e clique com o botão direito sobre o VI citado

anteriormente, e vá até as propriedades.

2. Desmarque a caixa de RMS.

3. Pressione o botão Help para descobrir qual caixa você deverá marcar para

obter uma medida do pico máximo ao mínimo.

Figura 3.13 – Usando o menu Help

4. Minimize a janela de ajuda e selecione a medida conforme a pesquisa

realizada no Help.

3.5 – LED de aviso

Se você quiser um indicador visual para valores que excedam um determinado

limite pré-estabelecido, siga os próximos passos.

1. Na paleta de controle, selecione a paleta de LEDs, e na paleta de LEDs,

selecione o LED redondo, conforme Figura 3.14.

18

Page 19: Apostila LABVIEW- Final[1]

Figura 3.14 – Adicionando LEDs

2. Coloque o LED na esquerda do gráfico.

3. Abra o menu das propriedades do LED e altere o label para LED de Aviso,

clique OK para confirmar a alteração.

4. Salve o projeto como LED de aviso.vi

3.6 – Configurando o limite para acionar o alerta

Para especificar o valor aceitável do sistema, use o Comparison Express VI e

desse modo para valores acima do especificado o LED irá ligar alertando o usuário.

Para realizar tal tarefa, siga os passos:

1. No diagrama de blocos, selecione o VI Comparison Express na paleta

Arithmetic & Comparison>>Express Comparison (para a paleta de funções

aparecer, basta clicar com o botão direito em algum lugar em branco na tela).

19

Page 20: Apostila LABVIEW- Final[1]

Figura 3.15 – Adicionando um comparador ao diagrama de blocos

2. Vá até o menu propriedades do VI Comparison e selecione a opção >

greater, que irá fazer com que um sinal seja emitido toda vez q o sinal

recebido passar de um determinado nível estipulado por você.

3. Observe a caixa Comparison Inputs, marque a caixa “use um valor

constante” e a seguir defina esse valor como 0,195, após isso clique OK para

efetuar as mudanças.

4. Ligue a saída peak to peak, do VI Amplitude and Levels Measurements, à

entrada Operand I do comparador, e em seguida ligue a saída Result na

entrada do LED.

5. Clique com o botão direito no fio, que liga a saída peak to peak à entrada

Operand I, e crie um indicador numérico. Arrume o layout do diagrama de

blocos para ficar de uma maneira compacta, conforme Figura 3.16.

20

Page 21: Apostila LABVIEW- Final[1]

Figura 3.16 – Layout geral do diagrama de blocos

6. Vá até o painel frontal e rode o programa, observe se o LED está

acendendo. Se estiver funcionando, pare o programa e salve, caso contrário

analise novamente seu diagrama de bloco e tente achar o erro.

3.7 – Configurando o VI para salvar dados

Para armazenar informações que seu VI gera, use o VI chamado Write

LabVIEW Measurement File Express. Complete os próximos passos para construir um

VI que irá salvar os valores pico a pico de sua simulação.

1. Abra a paleta de funções no diagrama de blocos, selecione a opção de

outputs e a seguir escolha o VI Write LVM.

2. Quando você adicionar o novo VI, irá surgir uma janela de configuração. No

campo que diz se um arquivo já exista (If a file already exists), selecione a

opção Append to file, ou seja, todos os dados serão gravados sem a hipótese

de perder dados em função de gravar um arquivo novo sobre um arquivo

antigo de mesmo nome.

21

Page 22: Apostila LABVIEW- Final[1]

3. Selecione a opção One header only na opção Segment Headers, desse modo

o cabeçalho do programa aparecerá uma vez a cada gravação, pelo método

one header per segment, ele iria apresentar estes dados a cada iteração, fato

que iria poluir o documento visualmente.

4. Coloque como descrição do arquivo “Amostras de valores de pico a pico”.

5. Descubra onde é a entrada de sinal do novo VI e ligue ela até o fio que

possui os valores de pico a pico. Utilize o atalho <Ctrl+H> para obter

informações sobre o VI e saber o que cada entrada representa, basta abrir a

janela de ajuda e deixar o cursor sobre o componente que deseja

informações.

6. Salve o VI como salvar dados.vi .

7. Vá até o painel de controle e rode o programa para os dados serem salvos.

8. Pare o programa.

9. Para ver os dados que você salvou, volte ao diagrama de blocos, vá até as

propriedades do VI Write LVM, copie o endereço onde salvou as

informações, abra o bloco de notas e procure pelo arquivo test.lvm, você

deverá colocar a opção de abrir todos os arquivos, pois a princípio o bloco de

notas não reconhece esse tipo de arquivo lmv.

22

Page 23: Apostila LABVIEW- Final[1]

Figura 3.17 – Abrindo arquivos lmv pelo bloco de notas

10. Observe os dados que foram salvos e depois volte ao diagrama de blocos

3.8 – Salvando os dados em um determinado período

Se você quiser salvar os dados apenas em determinado período da simulação,

uma solução é usar um botão que, quando pressionado, habilita a armazenagem dos

dados. Complete os seguintes passos para adicioná-lo ao seu projeto.

1. No painel frontal escolha o rocker button no menu Buttons & Switches.

2. Vá até as propriedades deste botão, mude o nome (label) para salvar dados.

Na aba de operação, selecione a opção Latched when pressed. Observe o

funcionamento do botão no menu Preview. Após observar o funcionamento,

clique no botão OK e salve o VI.

3. Vá até o diagrama de blocos nas configurações do VI Write LVM e altere o

nome do arquivo a ser salvo, mudando de test.lvm para amostras.lvm.

23

Page 24: Apostila LABVIEW- Final[1]

Figura 3.18 – Configurando o VI que salva os dados no formato lmv

4. Após alterar as configurações do item 3, certifique-se que a entrada Signals

está ligada ao terminal de pico a pico e ligue a saída do botão salvar dados

com a entrada enable do VI Write LVM, se necessário, utilize o menu de

ajuda <Ctrl+H>.

5. Vá para o painel frontal e rode o programa, aperte várias vezes no botão

salvar os dados. Pare o programa e vá observar os dados salvos.

24

Page 25: Apostila LABVIEW- Final[1]

Capítulo 4 – Personalizando um VI

Neste exemplo, você irá montar um VI mais complexo, para isso irá utilizar VIs

já existentes e acrescentará indicadores e controles. Você construirá um VI que gera um

sinal, reduz o número de amostras no sinal e mostra o resultado em uma tabela no painel

frontal. Quando você completar o exercício, o painel frontal do VI será similar com o da

Figura 4.19.

Figura 4.19 – Painel frontal ao término do exemplo 3

4.1 – Abrindo um novo VI

Para um VI em branco, siga os seguintes passos.

1. Ao abrir o programa, clique no botão com a opção New.

2. Selecione o Blank VI ou pressione <Ctrl+N> para abrir um novo VI.

3. Se a paleta de funções não estiver visível, clique com o botão direito que ela

aparecerá temporariamente.

25

Page 26: Apostila LABVIEW- Final[1]

4.2 – Adicionando um VI que simulará um sinal

Complete os seguintes passos para achar o VI que você quer usar e adicioná-lo

no diagrama de blocos.

1. Se o Help do programa não estiver visível pressione <Ctrl+H>.

2. Na paleta de funções, observe os componentes da aba Input, movendo o

cursor sobre eles. Procure por um VI que possa gerar uma onda senoidal e

adicione este ao diagrama de blocos.

3. Ajuste o valor da freqüência para 10.7 Hz e a amplitude para 2 .

4. Clique em OK para salvar as modificações.

4.3 – Modificando o sinal

Complete os seguintes passos para obter uma amostra reduzida do sinal gerado.

1. Selecione o menu Help>>VI, Function, & How- To Help para abrir a ajuda

do LabView.

2. Ao abrir a janela de ajuda do LabView, vá na aba pesquisar, na qual você

pode digitar alguma dúvida específica, no caso deste exercício você deverá

procurar informações sobre sample compression, que consiste em reduzir as

amostras dos dados de um sinal.

3. Observe que há um VI já feito que possui esse bloco denominado sample

compression, observe o endereço que ele está e abra este VI.

4. Após abrir o VI denominado Data Reduction, copie o bloco denominado

sample compression e cole no seu projeto, ao lado direito do simulador de

sinal.

5. Vá nas propriedades do novo bloco e coloque 25 como fator de redução.

6. Conecte a o gerador de sinal com o sample compression.

7. Salve o VI como amostra reduzida.vi

26

Page 27: Apostila LABVIEW- Final[1]

4.4 – Personalizando interface do usuário pelo diagrama de

blocos

Nos exercícios anteriores, você adicionou controles e indicadores no painel

frontal usando a paleta de controle. Você também adicionar controles e indicadores no

diagrama de blocos. Complete os seguintes passos para adicionar controles e

indicadores no diagrama de blocos.

1. No diagrama de blocos, clique com o botão direito em mean que está no VI

sample compression e selecione Create>>Numeric indicator.

2. Novamente clique com o botão direito em Mean que está no VI sample

compression e selecione Select Input/Output e marque a opção enable.

3. Clique com o botão direito na opção enable do VI e selecione

Create>>Control. Se o terminal aparecer no lado esquerdo do bloco, isto

indica que é controle, ao contrário se o terminal aparecer no lado direito, isto

indica que é um terminal indicador.

4. Clique com o botão direito no fio que conecta a saída do gerador de sinal e

selecione Create>>Graph Indicator .

5. Clique com o botão direito em mean no VI sample compression e selecione

signal manipulation palette, por fim selecione o item merge signals.

6. Arranje os elementos conforme a Figura 4.20.

27

Page 28: Apostila LABVIEW- Final[1]

Figura 4.20 – Utilizando a ferramenta merge signals

7. Observe que os blocos que são adicionados possuem seu equivalente do

painel frontal. Salve o VI.

4.5 – Configurando o VI para executar continuamente

Neste estágio, o programa simula o VI uma vez, gera o sinal e para de executar.

Para simular o VI continuamente, você pode usar um laço while. Complete os seguintes

passos para adicionar um laço while no diagrama de blocos.

1. Abra o painel frontal e simule o VI. O programa simula o VI uma vez e

então pára. O painel frontal não tem um botão para interromper a simulação.

2. No diagrama de blocos, selecione o laço while na paleta Execution Control

e adicione-o ao VI de tal maneira que todo o VI já existente deverá ficar

dentro dele, conforme Figura 4.21.

28

Page 29: Apostila LABVIEW- Final[1]

Figura 4.21 – Adicionando um laço while

3. Este laço while é configurado para parar quando o usuário clicar no botão

STOP.

4. Abra o painel frontal e simule o VI. Perceba que agora o programa simulará

o VI até que o usuário clique no botão STOP.

4.6 – Exemplos de VI

Para saber mais como usar um especifico VI, você pode procurar por um ou

analisar um exemplo que usa um VI. Complete os seguintes passos para encontrar um

exemplo que usa o Delay Values VI.

1. Select Help>> Find Examples para mostrar o NI Example Finder.

2. Clique em Browse e procure pela pasta New Examples for LabVIEW 7.0 .

3. Na pasta Express VIs você encontrará o arquivo Delay Values.vi.

4. Clique uma vez no arquivo e na caixa ao lado, chamada descripition,

aparecerá a descrição do exemplo.

5. Para abri-lo clique no arquivo duas vezes, e ele aparecerá no painel frontal.

29

Page 30: Apostila LABVIEW- Final[1]

4.7 – Controlando a velocidade de execução

Para plotar os pontos, ou seja, realizar a simulação de uma forma mais lenta,

você pode adicionar um tempo de atraso no diagrama de blocos. Complete os seguintes

passos para controlar a velocidade na qual o VI é simulado.

1. No diagrama de blocos, procure por Time Delay Express VI na paleta de

funções e coloque-o dentro do laço while.

2. Coloque 0.250 no Time delay (segundos). O ajuste do Time delay especifica

quão rápido ocorrerá a iteração. A cada 0.250 segundos, ocorrerá uma.

3. Clique em OK para salvar as novas configurações e feche Configure Time

Delay.

4.8 – Usando uma tabela de dados e mostrando no painel

frontal

Complete os seguintes passos para mostrar os dados em uma tabela no painel

frontal.

1. No painel frontal, procure por Express Table

que se encontra na paleta de controle e

coloque-o no painel frontal no lado direito da

curva do painel.

2. Vá até o diagrama de blocos e verifique se o

terminal da tabela está conectado no menu

table do VI Express Table .

3. Conecte o menu Mean do VI Sample Compression no menu Signals.

30

Figura 4.22 – Construindo uma tabela

Page 31: Apostila LABVIEW- Final[1]

Figura 4.23 – Diagrama de blocos do VI amostragem reduzida

4. A tabela mostra os principais valores a cada 25 amostras do sinal. Se a chave

esta desligada a tabela não mostra os dados e se a chave esta ligada a tabela

irá mostrar os dados na tabela.

5. Vá até o painel frontal e simule o VI, perceba que a cada 25 amostras o

indicador Mean apresentará um valor apenas. Altere o estado do switch e

observe que quando desligado, nem o valor Mean do sinal aparece tão pouco

os valores na tabela.

6. Salve e feche o VI.

31

Page 32: Apostila LABVIEW- Final[1]

Capítulo 5 – Exemplo de projeto utilizando LabVIEW

O projeto de um Sistema de Controle e Monitoramento da Temperatura de uma

Casa de Vegetação será desenvolvido ao longo do curso com o intuito de fazer o

estudante aprender a utilizar o software LabVIEW de uma maneira mais prática e

intuitiva. Assim, o processo de aprendizado tende a tornar-se mais atraente e eficiente

em contrapartida com outros em que o conhecimento é dividido em módulos

aparentemente desconexos, dificultando muito ao estudante juntar tais módulos para

produzir uma aplicação real usando o software.

O sistema proposto pretende simular uma aplicação do LabVIEW através do

desenvolvimento de um programa que gerencie informações de temperatura de uma

casa de vegetação ou “estufa”, gerando relatórios dos dados coletados e enviando

mensagens para acionar os atuadores genéricos aquecedor e refrigerador na casa de

vegetação. Como não se tem à disposição todos os dispositivos necessários para a

implementação do projeto, grande parte deles será simulado no próprio software.

Abaixo, tem-se a lista de alguns itens que existiriam em um projeto real e quais seriam

os respectivos substitutos para uma simulação da operação.

Tabela 5.1 – Comparação entre itens de uma aplicação real e os simulados neste projeto

Aplicação Real SimulaçãoComputador gerente dos dados com software para o usuário que controlará o sistema

Software do nó mestre (mestre)

Placa de aquisição de dados e atuadores Software do nó escravo (escravo)

Variação real da temperatura ambiente de acordo com a hora do dia

Controlador numérico e, depois, leitura dos dados em arquivo texto (escravo)

Interferência de atuadores reais no ambiente

Variação de ±3ºC na temperatura interna da estufa a cada ciclo ou iteração se o aquecedor ou o refrigerador estiverem ligados (escravo)

Comunicação entre o computador gerente e a placa de aquisição de dados através de um meio qualquer

Comunicação entre o computador com o software do nó mestre e o computador do nó escravo através da porta serial utilizando cabo cross-over(mestre e escravo)

32

Page 33: Apostila LABVIEW- Final[1]

O presente projeto será desenvolvido a partir da execução de pequenas tarefas.

Em cada tarefa dada, propõem-se ações a serem feitas de modo a completá-la e evoluir

para a próxima. Assim, consegue-se partir de um programa básico e evoluir até a versão

final do projeto de modo que a complexidade de um programa para o outro cresça de

forma linear e natural.

Figura 5.24 – Diagrama de um exemplo de aplicação real

Nota-se que toda a parte de medição e condicionamento será feita neste projeto

por um outro programa no LabVIEW, que gerará os dados referentes à temperatura

interna de uma estufa com base na variação da temperatura ambiente e na influência dos

atuadores.

Figura 5.25 – A simulação de vários dispositivos será feita no LabVIEW

33

Page 34: Apostila LABVIEW- Final[1]

5.1 – Tarefa 1: Criando um programa para o controle de

temperatura

Um exemplo de como pode ficar o painel frontal após a realização desta tarefa

pode ser visto na Figura 5.26.

Figura 5.26 – Painel frontal resultante da tarefa 1

1. Ao entrar com uma determinada temperatura (ambiente) por meio de um

controlador numérico, é necessário fazer uma verificação desse valor na

faixa de 20ºC a 28ºC. O programa deve indicar se o valor estiver acima ou

abaixo dos limites estabelecidos.

2. A seguir, deve-se fazer uma simulação da influência de dois atuadores na

temperatura: um aquecedor e um refrigerador. A influência desses

atuadores resume-se a aumentar ou reduzir 3ºC da temperatura de entrada. O

usuário deverá receber uma notificação caso acione os dois atuadores

simultaneamente. A função temperatura a ser implementada será

(1)

onde

= temperatura final da estufa

= temperatura ambiente de entrada (manipulada pelo usuário)

= valor do aquecedor (ligado=1 e desligado=0)

= valor do resfriador (ligado=1 e desligado=0)

34

Page 35: Apostila LABVIEW- Final[1]

3. Depois de cumprir os itens 1 e 2, passa-se para a última etapa, que é fazer o

programa ser executado ciclicamente com um tempo de atualização definido

pelo usuário. Toda essa estrutura inicial será útil para o aprimoramento

constante do programa até o fim de todas as tarefas. Segue, na Figura 5.27,

duas classes de funções e os devidos elementos em destaque para serem

utilizados na elaboração desta tarefa.

(a)

(b)

Figura 5.27 – Funções utilizadas das classes (a) Lógica e (b) Comparação

A partir de então, você deverá se familiarizar com a janela de funções do

LabVIEW, explorando cada função e pesquisando por funções com o mecanismo

Search na paleta de funções. Portanto, você deverá procurar, por conta própria, as

funções específicas que atendam às necessidades de cada problema. A tabela a seguir

lista os elementos sugeridos para serem empregados na tarefa 1. Ressalta-se que não há

uma solução única para as tarefas propostas.

Tabela 5.2 – Elementos sugeridos para executar a tarefa 1

Tendo

verificado o funcionamento deste programa, passa-se para a tarefa 2, na qual você deve

Classe da função Função específica

Painel Frontal

controladores numérico e lógico

indicadores numérico e lógico

Diagrama de Blocos

comparação > e <

numérico soma e multiplicação

lógicoAND

conversão para numérico

temporização espera de tempo definido

estrutura seqüencial laço while

35

Page 36: Apostila LABVIEW- Final[1]

criar uma estrutura para alterar a temperatura conforme a influência dos atuadores e o

número de iterações do programa.

36

Page 37: Apostila LABVIEW- Final[1]

5.2 – Tarefa 2: Utilizando estruturas de realimentação de dados

Após a execução desta tarefa, espera-se que o seu painel frontal tenha a mesma

funcionalidade que o apresentado na Figura 5.28.

Figura 5.28 – Painel frontal resultante da tarefa 2

Usando uma cópia do arquivo da tarefa anterior, substitua a entrada que controla

a temperatura ambiente por um valor inicial da temperatura e uma estrutura seqüencial

que possa armazenar o valor da variável temperatura da última iteração. A função que

descreve o comportamento da temperatura é:

(2)

onde

= temperatura da estufa da iteração [i + 1]

= temperatura da estufa da iteração [i]

= valor do aquecedor (ligado=1 e desligado=0)

= valor do resfriador (ligado=1 e desligado=0)

Além dos elementos já utilizados, você pode também empregar os indicados na

tabela a seguir.

37

Page 38: Apostila LABVIEW- Final[1]

Tabela 5.3 – Elementos sugeridos para executar a tarefa 2

As duas estruturas seqüenciais mostradas na Figura 5.29 têm em comum o fato

de armazenar dados de uma variável de uma iteração para a outra, fato esse que as

limita a serem usadas somente em estruturas do tipo while ou for. A diferença entre elas

emerge da propriedade que o registrador de deslocamento possui de armazenar dados

de mais de uma iteração anterior e não somente o valor da última.

(a)

(b)

Figura 5.29 – (a) Registrador de deslocamento e o (b) nó de realimentação

Classe da função Função específica

Painel Frontal

decoração caixa em baixo relevo

Diagrama de Blocos

estruturas seqüenciaisnó de realimentação,

registrador de deslocamento

38

Page 39: Apostila LABVIEW- Final[1]

5.3 – Tarefa 3: Lendo arquivos de texto e criando um subVI

Em vez de trabalharmos com um valor atemporal de temperatura, podemos

utilizar dados da variação da temperatura ambiente em um determinado dia, lidos de um

arquivo texto. Então, nesta tarefa, o principal objetivo será ler um arquivo de texto

plano que contém uma matriz de dados e processar as informações nele contidas por

meio de um indexador, que retorna os valores contidos na matriz quando especificadas a

linha e coluna desejada. Na figura a seguir, você tem uma idéia de como pode ficar o

painel frontal ao fim desta tarefa.

Figura 5.30 – Exemplo de painel frontal ao fim da tarefa 3

1. Crie um arquivo texto e salve no computador.

2. Use a função Read from Spreadsheet da classe File I/O para ler o arquivo e

mostrar no painel frontal em formato de matriz.

3. Utilize uma função da classe Matrizes para ler um elemento específico.

4. Depois de realizada com sucesso a leitura do arquivo texto e o

processamento dos valores, você deve salvar esse VI e transformá-lo numa

função, ou seja, um subVI. Essa função personalizada terá o mesmo formato

que o das funções que você utilizou até agora: blocos que recebem os dados

39

Page 40: Apostila LABVIEW- Final[1]

Figura 5.31 – Criando um subVI

Figura 5.32 – Editando conexões

Figura 5.33 – Associação

por meio de suas entradas, executam funções internamente e disponibilizam

o resultado das operações nas suas saídas. Você verá como fazer um subVI

nas próximas etapas desta tarefa.

Como criar um subVI?

1. Vá ao painel frontal do seu programa e

clique com o botão direito no ícone do VI

posicionado no canto superior direito da

janela. Você deve, portanto selecionar o

item Show Connector. A Figura 5.31

ilustra o procedimento.

2. O ícone se transformará em um diagrama

de conexões que serão configuradas

para o subVI conforme a Figura 5.32.

3. Selecionando o item Patterns, você

tem a possibilidade de configurar o

esquema do diagrama de conexões.

Escolha o melhor esquema para o seu

subVI, sabendo que ele terá, a

princípio, três entradas (arquivo a ser

lido, linha e coluna da matriz) e uma

saída (elemento correspondente à

linha e à coluna especificadas).

4. Tendo escolhido um esquema, clique com o

botão esquerdo onde você deseja posicionar o

conector e, em seguida, clique na respectiva variável a ser associada no

painel frontal, conforme Figura 5.33.

Fazendo isso com todas as variáveis, você já pode salvá-lo normalmente e

utilizá-lo em qualquer outro programa que você fizer como um bloco com terminais,

assim como são as demais funções do LabVIEW.

Executando todas as etapas adequadamente, o programa deverá ler o arquivo

texto, coletar os dados de linha e coluna do arquivo (planilha) e informar o valor do

40

Page 41: Apostila LABVIEW- Final[1]

respectivo elemento da matriz. Somente a informação da variação da temperatura

ambiente contida no arquivo será pertinente ao cálculo da temperatura interna da estufa.

A Tabela 5.4 lista alguns elementos que ainda não foram vistos e que podem ser

úteis para executar esta tarefa.

Tabela 5.4 – Elementos sugeridos para executar a tarefa 3

Classe da função Função específica

Painel Frontal

indicador matricial

Diagrama de Blocos

file I/O ler arquivo de planilha

matrizes indexador de elemento

41

Page 42: Apostila LABVIEW- Final[1]

5.4 – Tarefa 4: Utilizando um subVI

Voltemos agora ao programa principal. Devemos utilizar nosso subVI para

fornecer a variação da temperatura ambiente e calcular sua influência na estufa segundo

a equação (2).

1. Insira o subVI no diagrama de blocos através da paleta de funções.

2. Conecte seus terminais de modo a implementar a função da equação (2).

3. Sugere-se que se faça a hora do dia ser determinada pela variável i de um

laço for e esse laço seja executado de modo a i variar de 0 a 23 iterações.

Para cada iteração, ou seja, para cada hora, deve ser lido o valor da variação

de temperatura correspondente.

4. Você deve continuar utilizando um valor inicial de temperatura. Ao fim

desta tarefa, o programa deverá calcular a temperatura interna da estufa

baseado na temperatura inicial, na informação dos atuadores e na variação da

temperatura ambiente lida do arquivo.

Tabela 5.5 – Elementos novos sugeridos para executar a tarefa 4

Você ainda verá que o programa possui um erro estrutural. Tente descobri-lo!

(solução na tarefa 5)

Classe da função Função específica

Painel Frontal

utilize os elementos já estudados e explore outros, tendo em mente que esta é a interface que o usuário interage

Diagrama de Blocos

subVI inserir subVI

estruturas seqüenciais laço for

42

Page 43: Apostila LABVIEW- Final[1]

5.5 – Tarefa 5: Trabalhando com datas e plotando dados em um gráfico

Nesta tarefa nós corrigiremos o erro pendente da tarefa 4 e mostraremos os

dados de temperatura da estufa em um gráfico. Ao final, o painel frontal resultante da

execução com sucesso da tarefa 5 possuirá o seguinte aspecto:

Figura 5.34 – Exemplo de painel frontal ao fim da tarefa

1. Remova o laço for clicando com o botão direito no contorno do laço e

selecionando Remove For Loop.

2. Suponha que o contador de iterações do laço while externo informa o

número de horas transcorridas. Você deve usar uma função de divisão

inteira, que retorna o quociente (dias) e o resto (horas).

3. Após isso, informe as horas no painel frontal no formato [hh:mm]. Um modo

de fazer isso é concatenar a string “:00” com o número referente à hora atual.

Então, concatenando o número inteiro “11” e a string “:00”, o painel frontal

irá indicar a string “11:00”.

4. Exiba o valor da temperatura da estufa em um gráfico.

Na Tabela 5.6, são sugeridos alguns elementos que podem ser empregados nesta

tarefa.

43

Page 44: Apostila LABVIEW- Final[1]

Tabela 5.6 – Elementos sugeridos para executar a tarefa 5

Classe da função Função específica

Painel Frontal

gráfico forma de onda

Diagrama de Blocos

numérico quociente e resto

stringconversão numérico para string

concatenar

44

Page 45: Apostila LABVIEW- Final[1]

5.6 – Tarefa 6: Comunicando-se com o mundo externo através da serial

Nessa tarefa, antes de partirmos para utilizar a comunicação serial no nosso

projeto, vamos ver uma breve introdução sobre como utilizar a porta serial do

computador com o auxílio do LabVIEW.

A National Instruments, juntamente com outras empresas de medição e

automação, desenvolveu uma arquitetura chamada VISA (Virtual Instrument Software

Architecture), específica para o controle de recursos de entrada/saída de baixo nível de

dispositivos de hardware do tipo VXI, GPIB e, dentre outras, a comunicação serial.

No LabVIEW, VISA é uma simples biblioteca de funções que possui os drivers

necessários para a comunicação com grande parte dos recursos anteriormente

mencionados e outros. Ela pode ser acessada na paleta de funções por Instrument I/O

>> VISA (ver Figura 5.35). Para acessar as funções específicas para a comunicação

serial (ver Figura 5.36) utiliza-se o caminho Instrument I/O >> Serial.

Figura 5.35 – Biblioteca VISA Figura 5.36 – Funções para a comunicação serial

Na tabela a seguir, tem-se uma descrição de algumas funções que podem ser

usadas para a comunicação serial.

Tabela 5.7 – Funções relevantes no uso da comunicação serial

Função Descrição

VISA Configure Serial Port

Configura parâmetros da porta serial como taxa de bauds, paridade, controle de fluxo dos dados.

45

Page 46: Apostila LABVIEW- Final[1]

Tabela 5.8 - PortasRecurso Porta ASRL1 COM1ASRL2 COM2ASRL3 COM3ASRL10 LPT

VISA WriteEscreve os dados fornecidos pelo terminal write buffer no dispositivo especificado pelo VISA resource name.*

VISA ReadLê o respectivo no de bytes indicados em byte count no processo e os retorna em read buffer.

VISA CloseFinaliza uma sessão ou evento especificado pelo VISA resource name. Cada evento aberto deve ser fechado.

VISA Bytes at Serial Port

Retorna o número de bytes em espera na porta serial.

VISA Break Envia pedido de parada para a saída especificada.

*O terminal VISA resource name irá especificar a porta

utilizada durante a operação: COM1, COM2, LPT etc. No

entanto, o LabVIEW poderá representar tais portas com seu

nome “real”, ou seja, o nome do recurso, como ASRL1. A

Tabela 5.8 evidencia alguns dos recursos exibidos e sua respectiva relação com a porta

usada.

Uma vez entendidas as informações contidas nesta introdução:

1. Curto-circuite os pinos 2 e 3 (Receive Data e Transmit Data,

respectivamente) da porta serial por meio de um jumper (para verificar a

especificação dos pinos do conector DB-9, veja a figura A.1 do Apêndice A.

2. Faça um programa que escreva algo na porta serial e indique o resultado da

leitura no painel frontal. Se tiver dificuldade, oriente-se pelo diagrama de

blocos da Figura 5.37.

3. Agora, em vez de escrever e ler um texto, tente escrever um número e

mostrá-lo em um indicador gráfico. Lembre-se que a porta serial aceita

somente dados do tipo string.

4. Em seguida, modifique o programa de modo que ele escreva periodicamente

na porta e leia o valor escrito e conecte o cabo cross-over na porta serial RS-

232 do seu computador e em outra máquina e tente interagir com um colega,

pela porta serial, estabelecendo a comunicação entre os dois computadores.

46

Page 47: Apostila LABVIEW- Final[1]

As funções sugeridas para emprego nesta tarefa e nas demais estão na Tabela

5.9.

Tabela 5.9 – Elementos sugeridos para executar a tarefa 6

Figura 5.37 – Diagrama de blocos para uma operação simples de escrever e ler dados na porta serial.

Classe da função Função específica

Painel Frontal

indicador leitura de string

controlador escrita de string

Diagrama de Blocos

estruturas seqüenciais laço while ou stacked sequence

VISA Serial

configuração da porta

escrita de dados

leitura de dados

nº de bytes na porta

47

Page 48: Apostila LABVIEW- Final[1]

5.7 – Tarefa 7: Implementando uma aplicação completa de medição e automação

Após você ter se familiarizado com a comunicação serial do computador,

chegou o momento de aplicá-la no projeto para o controle e monitoramento da

temperatura de uma casa de vegetação. Como foi dito na descrição do projeto, vamos

implementar um programa que simulará a parte de aquisição e transmissão dos dados

(escravo) e outro programa que terá as funções de controlar os atuadores remotamente e

armazenar os dados coletados (mestre).

5.7.1 – Parte A: Módulo Escravo

1. Leitura da porta serial: Estruture o seu programa de forma que os atuadores

sejam acionados caso recebam do outro computador (mestre) uma

mensagem da porta serial do tipo “aquecer” ou “resfriar” para acionar o

aquecedor ou o refrigerador, respectivamente. Os atuadores devem

permanecer ligados enquanto forem recebidas mensagens de ordem do

mestre. Para isso, utilizam-se dois comparadores após a leitura da porta

serial e o seu sinal lógico (V ou F) irá para o conversor lógico-numérico, da

mesma maneira que acontecia com os botões nas tarefas anteriores.

2. Escrita na porta serial: O módulo escravo deve informar em sua saída os

dados referentes ao dia, hora e valor da medição de temperatura. Isso pode

ser feito concatenando uma string com todos esses dados (montando o

pacote) e desmembrando-a no módulo-mestre (desmontando o pacote). Você

pode escolher qualquer tipo de estrutura de dados para enviar o pacote com a

informação das três variáveis. Na Tabela 5.10, há um modelo de pacote de 7

bytes sugerido.

Tabela 5.10 – Estrutura do pacote de dados

Dia Hora TempPosição (Byte) 0 1 2 3 4 5 6

Conteúdo D D H H T T T

3. Utilize a função Build Array para montar um vetor linha com os dados do

dia, hora e temperatura. Armazene os vetores linha em um arquivo texto

48

Page 49: Apostila LABVIEW- Final[1]

usando a função Write To Spreadsheet File. Na Figura 5.38, é

apresentado um exemplo de como deve ficar o armazenamento dos dados

no arquivo texto, onde cada coluna indica, respectivamente, o dia, a hora

do dia e a temperatura.

Figura 5.38 – Formato do armazenamento dos dados.

Para deixar mais clara a idéia do pacote, vamos enviar, por exemplo, a

temperatura de 23º C correspondente à hora 18 do dia 3. O pacote enviado, segundo a

estrutura da Tabela 5.11, seria:

Tabela 5.11 – Exemplo

Dia Hora Temp0 1 2 3 4 5 6

3 1 8 2 3

Vale ressaltar que os espaços em branco também ocupam um byte na memória,

assim como qualquer caractere do código ASCII. Para chegar ao pacote final, será

necessária a experiência com conversão numérico-string e concatenação dessas strings

em uma só.

Em resumo, na parte A desta tarefa, temos que nos ater a acionar os atuadores

caso venha uma mensagem específica para tal ação e montar o pacote de dados

adequadamente para enviá-lo ao módulo mestre.

Função Search/Split String

Divide uma string em duas, sendo este ponto de divisão um ou mais

caracteres que serão rastreados na string (search string/char). A função, após achar

o ponto de divisão fornecido, fornece na saída a parte da string antes do ponto de

49

Page 50: Apostila LABVIEW- Final[1]

divisão (substring before match) e o resto da string original no outro terminal de

saída (match + rest of string).

Figura 5.39 – Terminais da função Search/Split String.

No nosso caso, podemos separar usando a posição do byte onde queremos

dividir a string entrando com um número no terminal offset. Ou seja, para o exemplo do

pacote citado anteriormente [_ 3 1 8 _ 2 3], um offset de valor 2 iria dividir a string em

uma antes do byte de posição 2 [_ 3] e outra com os bytes das posições 2 até 6 [1 8 _ 2

3] como é mostrado na figura a seguir.

Figura 5.40 – Exemplo de divisão da string original com offset 2.

5.7.2 – Parte B: Módulo mestre

1. Escrita na porta serial: Altere o programa feito na tarefa 5 de modo que

ele escreva na porta serial “aquecer” ou “resfriar” caso sejam

pressionados os botões que acionam os atuadores. Qualquer uma destas

mensagens deverá ser enviada ao módulo escravo uma vez por ciclo de

atualização do sistema se for desejado um funcionamento contínuo dos

atuadores. Caso contrário, se a mensagem for enviada somente uma vez,

o atuador em questão só ficará ligado por um ciclo.

2. Leitura da porta serial: O módulo escravo deverá transmitir uma

mensagem com estrutura semelhante à do pacote da Tabela 5.10. Cabe ao

mestre dividir essa mensagem em quantas partes for necessário de modo

a interpretar os dados enviados. Seguindo o exemplo dado na Tabela

50

Page 51: Apostila LABVIEW- Final[1]

5.11, a mensagem deveria ser partida em três pedaços. Mas como dividir

em três? Basta fazer uma divisão em cascata usando apenas dois blocos

da função Search/Split String. Deve-se tomar muita atenção para manter

a taxa de envio de dados do escravo e a taxa de atualização (leitura) do

mestre em concordância. Caso contrário, pode haver um acúmulo de

dados não-lidos na porta serial do mestre, podendo ocasionar erros na

desmontagem do pacote.

3. Após ter conseguido efetuar os passos 1 e 2 com sucesso, passa-se à

etapa de armazenamento desses dados vindos do escravo em um arquivo

no computador. Para efetuar tal operação, veja o 3º passo da parte A

desta tarefa.

Tabela 5.12 – Elementos novos para a tarefa 7

Classe da função Função específica

Diagrama de Blocos

String divisão

Matrizes montar vetor

File I/O montar arquivo texto

51

Page 52: Apostila LABVIEW- Final[1]

Capítulo 6 – Tecnologias para aquisição de dados

Até o momento, já vimos como processar um sinal gerado pelo LabVIEW ou um

conjunto de dados previamente salvo em um arquivo. Porém, ainda não discutimos um

tópico bastante importante que é a aquisição dos dados a serem trabalhados, através da

utilização de hardware específico para tal fim.

Você já experimentou um pouco como se dá esse processo através da utilização

da porta serial do seu computador. Basicamente, é dessa maneira que se dá a aquisição

de dados, porém geralmente ela é feita de maneira um pouco mais sofisticada, através

de hardware e protocolos de comunicação especialmente desenvolvidos para isso.

A figura a seguir ilustra algumas das tecnologias mais comuns utilizadas para

aquisição de dados. Dentre elas, está a nossa já conhecida serial.

Figura 6.41 – Tecnologias para aquisição de dados

Vamos ver aqui, de maneira geral, no que consiste cada uma dessas tecnologias.

Para maiores detalhes, você pode consultar alguma das bibliografias indicadas no final

da apostila ou então visitar o site da National Instruments. Nesse site você pode entrar

em contato com o que há de mais novo em termos de dispositivos para aquisição de

dados, além de poder ler e fazer o download de material técnico, application notes e

exemplos de programas.

Page 53: Apostila LABVIEW- Final[1]

Uma das interfaces mais antigas utilizadas para aquisição de dados é a GPIB

(General Purpose Interface Bus), que corresponde à especificação IEEE 488. Antes

mesmo da introdução dos computadores pessoais, na década de 80 do século passado,

este barramento já era utilizado por controladores dedicados para comunicar-se com

instrumentos de medição. Com o advento dos computadores pessoais, estes passaram a

ser cada vez mais utilizados para o controle de instrumentos e empresas como a

National Instruments cresceram bastante nessa época. A NI já era, em 1983, o principal

fornecedor de interfaces de hardware GPIB para a comunicação entre PCs e

instrumentos/placas de aquisição. Nessa época, praticamente todo software para

controle de instrumentos, ou driver, era escrito em linguagem BASIC, o que dificultava

o rápido desenvolvimento de aplicações. É nesse momento histórico, inclusive, que a NI

decide investir na criação de uma linguagem visual, intuitiva e de fácil aprendizado para

simplificar a utilização de instrumentos e a aquisição e processamento de dados. Essa

decisão daria origem ao LabVIEW e mudaria a história da empresa.

6.1 – Principais interfaces disponíveis no mercado

O LabVIEW tornou-se em pouco tempo o ambiente de desenvolvimento

preferencial para aquisição e processamento de dados e incorpora, além de todas as

ferramentas que já trabalhamos, uma vasta gama de bibliotecas contendo drivers para

praticamente qualquer dispositivo que utilize as principais interfaces disponíveis no

mercado. Analisemos rapidamente, então, algumas delas:

Placas de aquisição de dados (plug-in DAQ boards): a maioria das placas de

aquisição disponíveis possui um determinado número de entradas e saídas analógicas,

além de bits de entrada/saída. Geralmente, possuem multiplexadores, conversores

Analógico-Digital e Digital-Analógico e são conectadas a slots ISA, PCI e, mais

recentemente, PCI-Express existentes na placa mãe de um computador.

GPIB: acrônimo para General Purpose Interface Bus, a

interface GPIB corresponde ao padrão IEEE-488 e é uma das

arquiteturas mais utilizadas em placas de aquisição de dados. É uma

interface de comunicação de dados paralela que utiliza um conector

Page 54: Apostila LABVIEW- Final[1]

de 24 pinos e que permite que até 15 dispositivos dividam um barramento paralelo de 8

bits, conectados em topologia do tipo daisy-chain – os dispositivos são conectados em

série, um após o outro, e os sinais transmitidos vão primeiro para o primeiro dispositivo,

depois para o segundo e assim por diante. Utiliza 16 linhas de sinal (8 bits para

transferência bidirecional de dados, 3 para handshake e 5 para gerenciamento do

barramento) e as demais 8 são linhas de retorno de terra. A máxima taxa de

transferência é de 8MB/s

VXI: a arquitetura VXI é uma plataforma aberta, padrão, baseada numa

arquitetura mais antiga chamada VMEbus. VXI significa VME eXtensions for

Instrumentation e é mantida por um consórcio de empresas dentre as quais estão a

National Instruments e a Agilent Technologies. Sua principal utilização é em sistemas

de teste automático nas áreas de aviação e militar.

PXI: acrônimo para PCI eXtensions for Instrumentation, PXI é uma plataforma

para instrumentação modular introduzida em 1997 pela National Instruments e

promovida por um consórcio de 59 empresas chamado PXI Systems Alliance. Foi

desenvolvida para aplicações industriais de medição e automação onde uma alta

performance é exigida e oferece todos os benefícios de se utilizar a arquitetura PCI,

incluindo performance e robustez.

Serial: ainda que existam várias plataformas de

comunicação serial, incluindo a amplamente utilizada USB,

sempre que falamos em serial estivemos nos referindo à

especificação RS-232. A RS-232 foi durante anos a interface serial

padrão e é ainda hoje largamente utilizada, principalmente em aplicações em que um

dispositivo de hardware é conectado ao PC e não exige taxas de transmissão de dados

muito altas. Nesta altura deste curso, você já teve a oportunidade de entrar em contato

com a utilização da interface RS-232 e mais informações sobre ela podem ser

encontradas no Apêndice A. Em ambientes industriais, utiliza-se o protocolo serial RS-

485, que é mais robusto, apresentando taxas de transmissão maiores e sendo mais imune

a ruídos.

Page 55: Apostila LABVIEW- Final[1]

6.2 – Como escolher uma interface I/O específica?

De maneira geral, não existem regras que determinem qual interface é a mais

adequada para uma determinada aplicação. Do ponto de vista do LabVIEW,

praticamente qualquer interface I/O utilizada para instrumentação pode ser adotada e,

nesse aspecto, o usuário é livre para escolher. Porém, segundo a referência [Gary W.

Johnson], alguns fatores determinantes na escolha são:

Experiência prévia (e positiva) com o equipamento ou recomendações de

alguém confiável, que já o tenha utilizado;

Disponibilidade imediata de hardware: é melhor utilizar algo que já foi

utilizado em outro projeto e que possa ser comprado e entregue num período

curto de tempo;

Adequado ao propósito: não faz sentido possuir vários dispositivos de

hardware que não são adequados à aplicação, é melhor comparar especificações

e necessidades cuidadosamente antes de se comprometer com qualquer solução

de hardware;

Disponibilidade de drivers: se o LabVIEW dispuser do driver para um

determinado instrumento, você irá poupar tempo e esforço, pois escrever um

driver de dispositivo é muitas vezes mais complexo do que desenvolver uma

aplicação inteira;

Confiabilidade e segurança: quanto mais altas estas exigências, mais elas

devem influenciar na sua escolha de (e também de software);

Por fim, o custo por canal também deve ser considerado como parâmetro

de escolha.

6.3 – Como configurar e utilizar os dados adquiridos no LabVIEW?

A configuração do hardware de aquisição é bastante facilitada

no LabVIEW, uma vez que ele geralmente possui os drivers

necessários instalados. Além disso, ele possui uma classe de funções

chamada Express que automatiza toda a configuração e utilização da placa de aquisição,

Page 56: Apostila LABVIEW- Final[1]

inclusive detectando-a automaticamente. Utilizando o VI chamado DAQ Assistant, é

possível configurar a placa de aquisição, escolher os canais da placa a serem utilizados e

o tipo de dado que está sendo adquirido (analógico, digital, tensão, corrente, etc.). Cada

vez que ele é clicado, ele inicia um assistente que permite reconfigurar uma placa já

configurada ou configurar novas placas, de maneira interativa. Ao final da configuração,

é possível imprimir um diagrama esquemático das configurações da placa, contendo os

canais utilizados, o label que está associado a cada um deles e os tipos de sinais que eles

recebem.

A classe Express possui ainda VIs dedicados ao processamento e/ou análise dos

dados, como por exemplo análise espectral, análise estatística e filtragem. Também

possui estruturas de controle do fluxo de execução e VIs utilizados para saída de dados

através de arquivos do tipo .lvm (LabVIEW Measurements File) e dos próprios canais da

placa de aquisição. Obviamente, além da classe Express, todas as demais classes de

funções podem e devem ser utilizadas.

Como lembrete final, não esqueça que a discussão aqui apresentada considera

que os limites de tensão e corrente de entrada do dispositivo de aquisição utilizado

foram levados em conta e que o sinal, seja ele analógico ou digital, já encontra-se

condicionado de modo a atender esses limites.

Page 57: Apostila LABVIEW- Final[1]

Apêndice A

1. Ligação da porta serial em curto-circuito ou loop-back

Para executar o teste da tarefa 6, utilize jumper ou algo semelhante para curto-

circuitar os pinos 2 e 3 (ver Figura A.1) do conector DB-9 da porta serial do

computador que utiliza o protocolo RS-232.

Figura A.1 – Especificação dos pinos do DB-9

2. Conexão de dois computadores através da porta serial

Para estabelecer a comunicação entre dois computadores diretamente, usa-se um

cabo cross-over para conectá-los através da porta serial. Existem dois modos: com

suporte a controle de fluxo via hardware (Figura A.2) ou sem suporte (Figura A.3).

Figura A.2 – Esquema de ligação com suporte a controle de fluxo via hardware

Page 58: Apostila LABVIEW- Final[1]

Figura A.3 – Esquema de ligação sem suporte a controle de fluxo via hardware

Page 59: Apostila LABVIEW- Final[1]

Apêndice B – Atalhos do LabVIEW 7

Keyboard Shortcut DescriptionObject/Movement

Shift-click Selects multiple objects; adds object to current selection.Arrow keys Moves selected objects one pixel at a time.Shift-Arrow keys Moves selected objects several pixels at a time.Shift-click (drag) Moves selected objects in one axis.Ctrl-click (drag) Duplicates selected object.Ctrl-Shift-click (drag) Duplicates selected object and moves it in one axis.Shift-resize Resizes selected object while maintaining aspect ratio.Ctrl-resize Resizes selected object while maintaining center point.Ctrl-drag a rectangle Inserts more working space on the front panel or block diagram.Ctrl-A Performs last alignment operation on objects.Ctrl-D Performs last distribution operation on objects.Double-click open space

Places free label on the front panel or block diagram.

Ctrl-mouse wheelScrolls through subdiagrams of a Case, Event, or Stacked Sequence structure.Navigating the LabVIEW Environment

Ctrl-E Displays block diagram or front panel.

Ctrl-#Enables or disables alignment grid. On French keyboards, press the <Ctrl-"> keys.

Ctrl-/ Maximizes and restores window.Ctrl-T Tiles front panel and block diagram windows.Ctrl-F Finds objects or text.Ctrl-G Searches VIs for next instance of object or text.Ctrl-Shift-G Searches VIs for previous instance of object or text.Ctrl-Shift-F Displays Search Results window.Ctrl-Tab Cycles through LabVIEW windows.Ctrl-Tab Cycles backward through LabVIEW windows.Ctrl-I Displays VI Properties dialog box.Ctrl-L Displays Error List window.Ctrl-Y Displays History window.Ctrl-D Redraws Hierarchy window.Ctrl-A Shows all VIs in Hierarchy window.

EnterFinds next node that matches the search string after initiating a search by typing in Hierarchy window.

Shift-EnterFinds previous node that matches the search string after initiating a search by typing in Hierarchy window.

DebuggingCtrl-Down arrow Steps into node.Ctrl-Right arrow Steps over node.

Page 60: Apostila LABVIEW- Final[1]

Ctrl-Up arrow Steps out of node.File Operations

Ctrl-N Creates new VI.Ctrl-O Opens existing VI.Ctrl-W Closes VI.Ctrl-S Saves VI.Ctrl-P Prints the window.Ctrl-Q Quits LabVIEW.

Basic EditingCtrl-Z Undoes last action.Ctrl-Shift-Z Redoes last action.Ctrl-X Cuts an object.Ctrl-C Copies an object.Ctrl-V Pastes an object.

HelpCtrl-H Displays Context Help window.Ctrl-Shift-L Locks Context Help window.Ctrl-? or <F1> Displays LabVIEW Help.

Tools and PalettesCtrl Switches to next most useful tool.Shift Switches to Positioning tool.Ctrl-Shift over open space

Switches to Scrolling tool.

SpacebarToggles between two most common tools if automatic tool selection is disabled.

Shift-Tab Enables automatic tool selection.

TabCycles through four most common tools if you disabled automatic tool selection by clicking the Automatic Tool Selection button. Otherwise, enables automatic tool selection.

Arrow Keys Navigates temporary Controls and Functions palettes.Enter Navigates into temporary palette.Esc Navigates out of temporary palette.

SubVIsDouble-click subVI Displays subVI front panel.Ctrl-double-click subVI

Displays subVI block diagram.

Drag VI icon to block diagram

Places that VI as a subVI on the block diagram.

Shift-drag VI icon to block diagram

Places that VI as a subVI on the block diagram with constants wired for controls that have non-default values.

Ctrl-right-click block diagram and select VI

Opens front panel of that VI from the Functions palette.

ExecutionCtrl-R Runs VI.Ctrl-. Stops VI, when used while VI is running.

Page 61: Apostila LABVIEW- Final[1]

Ctrl-M Changes to run or edit mode.Ctrl-Run button Recompiles current VI.Ctrl-Shift-Run button Recompiles all VIs in memory.

Ctrl-Down arrowMoves key focus inside an array or cluster, when used while VI is running.

Ctrl-Up arrowMoves key focus outside an array or cluster, when used while VI is running.

TabNavigates the controls or indicators according to tabbing order, when used while VI is running.

Shift-TabNavigates backward through the controls or indicators, when used while VI is running.

WiringCtrl-B Removes all broken wires.Esc, right-click, or click terminal

Cancels a wire you started.

Single-click wire Selects one segment.Double-click wire Selects a branch.Triple-click wire Selects entire wire.A Disables automatic wire routing temporarily.Double-click (while wiring)

Tacks down wire without connecting it.

Spacebar Toggles automatic wiring while moving objects.Shift-click Undoes last point where you set a wire.Ctrl-click input on function with two inputs

Switches the two input wires.

Spacebar Switches the direction of a wire between horizontal and vertical.Text

Double-click Selects single word in string.Triple-click Selects entire string.Ctrl-Right arrow Moves forward in string by one word.Ctrl-Left arrow Moves backward in string by one word.Home Moves to beginning of current line in string.End Moves to end of current line in string.Ctrl-Home Moves to beginning of entire string.Ctrl-End Moves to end of entire string.

Shift-EnterAdds new items when entering items in enumerated type controls and constants, ring controls and constants, or Case structures.

Esc Cancels current edit in a string.Ctrl-Enter Ends text entry.Ctrl-= Increases current font size.Ctrl-- Decreases current font size.Ctrl-0 Displays Font dialog box.Ctrl-1 Displays Application font in Font dialog box.Ctrl-2 Displays System font in Font dialog box.

Page 62: Apostila LABVIEW- Final[1]

Ctrl-3 Displays Dialog font in Font dialog box.Ctrl-4 Displays current font in Font dialog box.

Page 63: Apostila LABVIEW- Final[1]

Referências

1. National Instruments. Getting Started With LabVIEW

2. National Instruments. LabVIEW User's Guide

3. National Instruments. LabVIEW Fundamentals

4. Ertugrul, Nesimi. LabVIEW for Electric Circuits, Machines, Drives and

Laboratories. Editora Prentice Hall

5. Johnson, Gary W. LabVIEW Graphical Programming: Practical

Applications in Instrumentation and Control . Editora McGraw-Hill

6. http://www.rogercom.com/PortaSerial/PortaSerial.htm (acessado em

20/07/2007)