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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
criar uma estrutura para alterar a temperatura conforme a influência dos atuadores e o
número de iterações do programa.
36
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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.
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
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.
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,
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.
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
Figura A.3 – Esquema de ligação sem suporte a controle de fluxo via hardware
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.
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.
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.
Ctrl-3 Displays Dialog font in Font dialog box.Ctrl-4 Displays current font in Font dialog box.
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)
Top Related