LABVIEW EM I/O RECONFIGURÁVEL

Sergio Luiz Schubert Severo.

Pelotas, Janeiro 2019

 INSTRUMENTAÇÃO VIRTUAL – INDICADOR DIGITAL
LED
A primeira tarefa consiste em inserir um LED (Light Emitting Diode) virtual e fazê-lo piscar. Para isso você deverá abrir o LabView
e criar uma “Blank VI”. Ao fazer isso duas janelas serão abertas. Uma é denominada “Front Panel” e outra “Block Diagram”. Após
as janelas serem abertas, clique em “File” salve sua “VI” (Virtual Instrument) com o nome que preferir.

INSERINDO O LED
Para inserir o LED clique com o botão direito dentro da janela do “Front Panel”, escolha o ícone “Boolean” e, no menu seguinte,
escolha “Round LED”, como se pode ver na figura:

Sua VI deve ficar com a seguinte aparência se você aumentar o tamanho do LED e nomeá-lo “LED”:

2
 LED PISCANTE
LOOP WHILE.
Para que o LED inserido possa piscar é preciso que o mesmo seja ligado e desligado repetidas vezes. Também essa repetição
deve-se dar em intervalos de tempo regulares. Uma das maneiras de fazer com que um mesmo comando (ligar ou desligar) seja
repetido várias vezes é o uso de um LOOP. O Loop que utilizaremos é conhecido como Loop While pois ele fica repetindo
ENQUANTO (While) uma determinada condição não acontece. A condição de parada do loop pode ser vista no canto inferior
direito do mesmo. Para inserir o loop While clique como o botão direito no “Block Diagram”, escolha o ícone “Structures” e,
nele, o “While Loop”:

Uma vez inserido devemos criar um “controle” para parar o loop. A maneira mais fácil de fazer isso é clicar com o botão direito
exatamente sobre a entrada da condição de parada do loop e escolher “Create Control”.

3
 LED PISCANTE
SHIFT-REGISTER E NOT
O LED é um indicador que “acende” se, na sua entrada, for conectado um valor booleano “verdadeiro”. Os valores booleanos
só podem assumir duas condições: “verdadeiro” ou “falso”. Iremos fazer o LED mudar sua condição a cada repetição do loop.
Para trocar de verdadeiro para falso e vice-versa, utilizaremos o operador booleano NOT sobre o valor aplicado ao LED no loop
anterior. Para inserir um operador NOT, clique com o botão direito no “Block Diagram”, escolha “Boolean” e então “Not”, como
mostra a figura:

Conecte a saída do NOT na entrada do LED. Conecte então a borda do loop na entrada do NOT. Clique com o botão direito sobre
o desenho que apareceu na borda e escolha “Replace with Shift Register”:

4
Note que surgiram duas setas na borda do loop, na esquerda ela aponta para baixo e na direita ela aponta para cima. Isso é para
indicar que o valor que for conectado na entrada da seta da direita será transferido para a seta da esquerda, ficando disponível
na próxima iteração do loop. Conecte agora a seta da direita na linha que conecta o NOT ao LED. Seu diagrama deve ficar como
na figura:

Agora seu programa já pode ser EXECUTADO. Para tanto, na barra de ferramentas superior, clique no botão RUN e seu programa
será executado. Para fazer com que ele pare é só pressionar o botão STOP que faz parte do seu programa no “Front Panel”.

5
 TEMPORIZAÇÃO
WAIT (MS)
Você deve ter percebido que seu LED pisca de forma errática. Isso se dá porque o loop executa cada ciclo em um tempo muito
curto. Para aumentarmos o intervalo entre as piscadas devemos inserir, dentro do loop, uma espera com tempo bem
determinado. Os blocos “Timing” podem ser utilizados para isso. Clique e acrescente ao seu diagrama de blocos o “Wait (ms)”.

Você precisa então criar uma constante para determinar o intervalo de tempo de espera em cada loop. Esse intervalo é dado
em milissegundos. Assim, uma constante com valor de 500 ira criar uma espera de meio segundo.

6
Seu diagrama de blocos agora deve estar parecido com o diagrama da figura a seguir. Modifique o valor da constante, execute
o programa e observe a frequência das piscadas de acordo com o intervalo de tempo utilizado.

QUESTÕES
Antes de continuar o seu trabalho responda as seguintes questões:

1. Quais os valores que podem aparecer na saída do “Shift Register”?

2. Além do botão de STOP do seu programa existe outra forma de parar a execução dele sem sair do LabView?
3. Os menus que aparecem no “Front Panel” e no “Block Diagram”, ao se pressionar o botão direito, são iguais? Se são
diferentes qual o motivo?
4. O que faz o operador NOT?
5. Explique o funcionamento do temporizador.

Não escreva nada na apostila!

7
 PARADA SELETIVA
SELECT E VERTICAL TOGGLE SWITCH
Vamos agora fazer com que o LED pare de piscar e o programa continue em funcionamento! Para tal utilizaremos dois recursos:
uma chave para acionar a parada (o Vertical Toggle Switch) e o bloco Select que seleciona um ou outro caminho. Um dos
caminhos é originado na saída do NOT e o outro é simplesmente uma constante FALSE (falso), que irá desligar o LED. A figura
mostra o acesso ao bloco “Select”:

Na figura seguinte, acrescenta-se, no “Front Panel” a chave vertical:

8
Estabeleça as conexões para que a chave controle o caminho. Assim, quando a saída da chave determinar FALSE para o bloco
Select o caminho inferior do bloco será selecionado. Se a chave determinar TRUE (verdadeiro), o caminho superior será
selecionado.

Para que o LED desligue quando a chave estiver desligada (sua saída será FALSE) acrescentamos uma constante FALSE na entrada
inferior do bloco Select. Clique então na conexão logo após o NOT, delete ela e estabeleça a conexão entre a saída do NOT e a
entrada superior do Select. Conecte também a saída do Select com o LED. Se tudo estiver correto seu programa deverá se
parecer com o da figura a seguir após ser executado.

9
 ACIONAMENTO DE LED COM DAQMX
NI-DAQMX – CRIANDO UMA INTERFACE COM O MUNDO REAL.

A plataforma de programação DAQ-mx, da National Instruments, é utilizada para o acesso ao mundo real. Ela estabelece a
interface entre o software e o hardware conectado ao equipamento de aquisição de dados. Assim, chaves, acionadores,
contatoras, conversores A/D e D/A e outros dispositivos são lidos e acionados (escritos) com o auxílio dela. Embora possa ser
implementada com o uso de “wizards” iremos fazê-lo passo à passo para melhor entendimento do processo de aquisição.

ACIONANDO UM LED
O processo a seguir irá apresentar os passos necessários para o acionamento de um LED físico conectado na porta digital de
número 6 (pode ser utilizada qualquer outra disponível). De forma resumida os passos são:

1. Criar um canal virtual de acesso ao hardware (Create Virtual Channel).

2. Definir o tipo de aquisição (no caso Saída Digital – Digital Output).
3. Criar uma constante com o caminho de acesso ao canal escolhido.
4. Iniciar o processo de aquisição (Start).
5. Inserir o bloco de escrita (Write).
6. Definir a forma da escrita, no caso escreveremos:
o Formato digital (Digital).
o Um só canal (Single Channel ).
o Uma amostragem por vez (Single Sample).
o Booleano em uma linha (Boolean (1 line)).
7. Conectar o dado a ser escrito (o valor do LED virtual) na entrada data do bloco de escrita (Write).
8. Definir a constante de espera do bloco de escrita (timeout) em <-1> para espera infinita.
9. Inserir o bloco de limpeza da aquisição (Clear).
10. Conectar as linhas de fluxo de dados da tarefa (Task) e de erro (Error) entre os blocos de aquisição.
11. Inserir o indicador de erro na saída de erro do bloco de limpeza (Clear).

Ao final das etapas descritas o diagrama de blocos deverá ser similar ao apresentado abaixo:

10
 1. Criar um canal virtual de acesso ao
hardware (Create Virtual Channel).

2. Definir o tipo de aquisição como

(Saída Digital – Digital Output).

3. Criar uma constante com o

caminho de acesso ao canal
escolhido.

11
 3. Criar uma
constante com o
caminho de acesso
ao canal.
4. Iniciar o processo de
aquisição (Start).

5. Inserir o bloco
de escrita (Write).

12
 6. Definir a forma da escrita:
o Formato digital (Digital).
o Um só canal (Single Channel ).
o Uma amostragem por vez (Single Sample).
o Booleano em uma linha (Boolean (1 line)).

7. Conectar o dado a ser escrito (o valor do LED virtual) na entrada data do bloco
de escrita (Write).
8. Definir a constante de espera do bloco de escrita (timeout) em <-1> para espera
infinita.
9. Inserir o bloco de limpeza da aquisição (Clear).
10. Conectar as linhas de fluxo de dados da tarefa (Task) e de erro (Error) entre os
blocos de aquisição.
11. Inserir o indicador de erro na saída de erro do bloco de limpeza (Clear).

13
 SISTEMA HÍBRIDO RTSYSTEM – FPGA

AQUISIÇÃO E APRESENTAÇÃO DE ALTO DESEMPENHO.

Iremos criar do “zero” um sistema capaz de adquirir dados em altas taxas e transferir os mesmos para uma interface
de visualização (ou armazenamento) sem que nenhum dado seja desconsiderado no processo. Para tal iremos utilizar uma
arquitetura híbrida onde um dispositivo lógico programável realiza a aquisição em taxa precisamente determinada e um sistema
operacional em tempo real obtém esses dados adquiridos através de uma fila do tipo FIFO, armazenada em memória
compartilhada.

O desenvolvimento do sistema se dará nas seguintes etapas:

1. Criação de um projeto em branco.

2. Detecção do dispositivo lógico programável (FPGA) e inserção do mesmo na árvore do projeto.
3. Criação de uma VI no sistema operacional em tempo real.
4. Criação de uma VI no FPGA.
5. Criação de uma fila do tipo FIFO para a transferência dos dados.
6. Adição dos nodos de I/O no dispositivo alvo, o FPGA.
7. Criação de um “loop while” para aquisição contínua.
8. Inserção dos dados na FIFO.
9. Monitoramento do “timeout” e parada de execução no FPGA.
10. Geração paralela de dados para aquisição com “loop” temporizado de precisão.
11. Leitura da FIFO no sistema operacional em tempo real.
a. Abertura a referência para o FPGA.
b. Determinação do uso de interface customizada pelo myRIO.
c. Configuração da FIFO.
d. Inicialização da FIFO.
e. Monitoramento do crescimento da FIFO.
f. Esvaziamento dos elementos da FIFO.
g. Apresentação dos dados lidos.
h. Fechamento da FIFO.

14
 1. CRIAÇÃO DE PROJETO EM BRANCO
O template para o myRIO normalmente irá criar uma “personalidade”, ou seja, um programa básico que acessa todas as
interfaces de I/O e que consome, desnecessariamente, recursos do FPGA. Iremos criar, ao invés disso, um projeto em branco
( Blank Project ).

2.DETECTAR O DISPOSITIVO.
O sistema de desenvolvimento precisa, primeiramente,
acrescentar o dispositivo no projeto. Para fazer isso, acionando
o botão direito do mouse sobre a raiz do projeto criado,
escolha:

New → Target and Devices.

Marque as opções como mostrado e escolha o seu

dispositivo. Aqui é escolhido o myRIO.

Após o dispositivo ser detectado a árvore com o “Chassis”, os recursos do sistema

operacional em tempo real e o “FPGA Target” será apresentada nos itens do projeto.
Note que os elementos de I/O, como, por exemplo, LED0, LED1, ConnectorC/AO1 etc...
podem ser simplesmente arrastados para o diagrama de blocos adequado e utilizados.

15
 3.CRIAÇÃO DE UMA VI NO SISTEMA
OPERACIONAL EM TEMPO REAL DO
MYRIO.
As Vis que serão embarcadas no sistema
operacional em tempo real do myRIO devem ser
acrescentadas ao projeto clicando com o botão
direito do mouse no <nome do myRIO> e
escolhendo nos menus:

New → VI.

Salve a VI com o nome de sua preferência. Aqui

iremos chamá-la de “Host”.

4. CRIAR UMA VI NO FPGA.

Já as Vis embarcadas no dispositivo lógico programável,
o FPGA do myRIO, devem ser criadas sob o “FPGA
Target”. Para isso clique com o botão direito no <FPGA
Target> e escolha:

New → VI.

16
 Salve a VI com o nome de sua preferência. Iremos chamá-la
de “FPGAaquisita”. Observe que a VI está em um nível
diferente da Host.vi.

5. CRIAÇÃO DE UMA FILA DO TIPO

FIFO PARA A TRANSFERÊNCIA
DOS DADOS.
Não só VIs podem ser criadas na árvore do projeto.
Outros componentes, como variáveis ou filas de
memória compartilhada, são especificados ali. Para
que possamos transferir rapidamente dados entre,
por exemplo, o sistema operacional em tempo real
e o FPGA, é adequado o uso de um “buffer”
organizado como uma fila do tipo FIFO (First In –
First Out).

Clique com o botão direito sobre o FPGA Target e

escolha:

New→ FIFO.

CONFIGURAÇÃO DA FIFO
Devemos determinar o nome da FIFO, nós a chamaremos
de <FIFOvet>. Também, na sua tela “General”,
estabelecemos o “Type” da FIFO. Como vamos transferir
os dados coletados do FPGA para o “Host”, escolhemos
“Target to Host – DMA”.

O número inicial de elementos também deve ser

escolhido . Definimos 4095. Se houverem “Timeouts”
durante as transferências via DMA(Direct Memory Acess)
entre o FPGA e o host, podemos invocar (Invoke) o
método “FIFO.Configure” e incrementar o parâmetro
chamado “Depth Parameter” no lugar de aumentar o
“Request Number of Elements”.Ao incrementar o “Depth Parameter” estaremos ampliando o tamanho do buffer “no lado do
host”, o que resolve o timeout sem aumentar a utilização do FPGA!

17
 Defina ainda o tipo do “dado” a ser transferido no FIFO e na opção “Interface” escolha “Arbitrate if multiple requests”.

Tecle OK e verifique se a FIFO foi criada. Dentro da arquitetura proposta a VI “FPGA aquisita” irá escrever um FIFO e
ela será lida, e esvaziada, na VI “Host”.

6. ADICIONANDO I/O(S) AO FPGA TARGET.

No sistema que estamos construindo
utilizamos o FPGA para acessar
diretamente o mundo externo. Com
software implementado em hardware
é possível determinismo, paralelismo
e altíssimo desempenho. Uma vez
garantida a aquisição no FPGA os
dados serão transferidos para o “Host”
via FIFO para posterior
armazenamento e visualização.

No diagrama de blocos da VI
FPGAaquisita, clique com o botão
direito para abrir a janela Functions e
escolha:

Program → FPGA I/O → I/O Node

No controle FPGA I/O node adicionado

clique com o botão esquerdo e escolha no
menu pop-up:

add New FPGA I/O

o item

ConectorC> → Analog → Conector C/AIO

(para escolher a entrada analógica do
conector C)

Amplie o bloco para baixo e

surgirá o conector C/AI1, para
os dados do segundo canal.

Uma maneira muito mais simples é arrastar dos itens do projeto o ConnectorC/AI0 e AI1 para
dentro do diagrama de blocos da VI FPGAaquisita!

18
7. EXECUTANDO A AQUISIÇÃO REPETIDAS VEZES
Em um sistema supervisório,
normalmente, a aquisição de dados deve
ser realizada de forma contínua. Para
tanto é necessário algum tipo de “laço de
repetição”. Utilizaremos nesse exemplo o
“loop” While. Com o botão direito no
diagrama de blocos da VI “FPGA aquisita”
abra a tela:

Functions → Structures →While Loop

Faça com que o loop enlace os controles responsáveis pela

aquisição.

Com o mouse sobre a entrada do controle de parada do loop

(loop condition) crie um controle booleano para parar o loop
(create control).

Esse controle “stop” deverá ser acessado do Host para

que o FPGA não continue em execução estando o Host
parado!

19
8. CONECTANDO À FIFO AOS DADOS ADQUIRIDOS.
Vamos agora escrever os dados na FIFO. Para tanto os enviamos em um array. No caso do exemplo temos apenas dois elementos
mas pode-se ter quantos forem necessários.

Com o botão direito do mouse abra:

Functions →Array → Build Array

Junte os dados dos canais em um Array

conectando as saídas nas entradas do
Build Array.

No menu Functions clique em:

Structures→ For loop.

Isso cria um loop “For” que servirá para

adicionar elemento por elemento do
array com os dados adquiridos.

20
 Arraste a “FIFOvet” criada para dentro
do loop For. Verifique antes se ela está
enviando dados do FPGA (Target) para o
Sistema em tempo real (Host).

Conecte a saída do “Build Array” com a

entrada “Element” da FIFO. Para
corrigir o erro mostrado na figura mude
a entrada no loop for para indexada.

Com o botão direito na entrada

Timeout crie uma constante.
Determine o valor do Timeout em Ticks
(entre 0-10).

9. MONITORANDO O TIMEOUT E PARANDO A TRANSFERÊNCIA.

O Timeout da FIFO avisa que a mesma está cheia. Nessa situação não devemos mais colocar dados nela e disponibilizar esse
valor para o Host através de um indicador. Com essa informação será possível ajustar o buffer do Host ou a taxa de entrada de
dados na FIFO dentro dos limites do sistema.

Adicionar uma porta OR para comparar o valor

booleano de Timeout atingido com o
armazenamento em um registrador.

21
Criar uma estrutura condicional para só transferir
dados no caso do timeout não ser verdadeiro.

Com o botão direito do mouse no diagrama de

blocos e chamar:

Structure →Case Structure

Colocar a FIFO no Case FALSE e reconectá-la.

Dentro do Case FALSE acrescentar uma porta lógica OR.

22
Conectar as entradas da OR na saída do
Timeout e na saída do seletor do Case.

Conectar a saída da OR com a borda do While

e transforme o túnel em um registrador de
deslocamento (Shift Register).

Trocar o “Tunnel Mode” do Loop for para

“Last Value”.

Na opção TRUE do case conectar a saída

do seletor direto ao túnel à direita.

Conectar a saída do Shift Register à

esquerda com o selecionador da “Case
structure”.

Inicializar o Shift Register à esquerda do

Loop While com o valor FALSE!

Tal diagrama de blocos irá fazer que,

quando eventualmente ocorra um
Timeout, a transferência dos dados
adquiridos pare de acontecer.

23
10 – GERANDO DADOS PARA SEREM ADQUIRIDOS.
Se não estiver disponível um gerador de funções para ser conectado no I/O analógico pode-se gerar dados para aquisição
fazendo uso dos conversores digitais- analógicos ou das portas lógicas de saída. Para a última opção pode-se criar um laço
separado em paralelo com o de aquisição de dados e escrever em uma porta analógica ou digital, conforme for mais conveniente.
A sequência de comandos para isso segue:

10.1 – Crie uma Structure através do menu Structure → Timed Structures →Timed Loop, fora do Loop While.

10.2 – Clique com o botão direito sobre a palavra Default (abaixo de ticks) no canto superior esquerdo da Timed Loop criada e
escolha Configure Input Node.

10.3 – Escolha então o botão Select Timing Source e selecione 40Mhz onboard Clock, o texto Default deve trocar/mudar para
40Mhz.

10.4 – Crie o controle de parada do Loop.

10.5 – Arraste o Conector C/DIOØ para dentro do Loop.

10.6 – Com o Mouse sobre o Node da porta no controle, clique com o botão direito e escolha Change to Write.

10.7 – Acrescente um operador booleano NOT dentro do Loop.

10.8 – Conecte a saída do operador na borda direita do Timed Loop.

10.9 – Mude o Tunnel com Replace with Shift Register.

10.10 – Conecte o lado esquerdo do Shift Register com a entrada do NOT e depois com a entrada da porta de IO Conector
C/DIOØ.

Este relógio terá uma frequência de 20Mhz, o programa no módulo FPGA estará pronto após compilado.

24
LENDO E APRESENTANDO OS DADOS DA FIFO NO SISTEMA
OPERACIONAL EM TEMPO REAL.
1 – Gerando referência.

1.1 – No diagrama de blocos da VI Host.vi abra uma referência para o seu dispositivo FPGA formado, com o uso do botão direito:

FPGA Interface → Open FPGA VI Reference

1.2 – Clique d uas vezes no ícone para abrir a tela “Configure Open FPGA VI Reference”.

1.3 – Marque o botão (x)VI e escolha no menu Select VI o programa “FPGAaquisita”.

25
1.3

1.4 – Na entrada do ícone (a esquerda na parte superior dele) clique com o botão direito e crie uma constante.

26
Se o seu myRIO estiver conectado via local você usará o endereço IP dele. Caso contrário (USB), aparecerá apenas o nome.
Quando colocar o myRIO na rede será necessário alterar essa variável.

Agora temos uma referência para o FPGA e é possível acessar o mesmo através de operações de leitura/escrita de controles
definidos na VI do FPGA. Invocar (Invoke) métodos e fechar a interface.

2 – Determine que o myRIO irá utilizar uma interface customizada (e não a sua “personalidade” padrão).

2.1 – Clique com o botão direito para abrir o menu Functions e clique em

myRIO → Utilities → Set custom bitfile

2.2 – Conecte a saída “FPGA VI Reference out” do bloco “Open FPGA VI Reference” na entrda do “Set custom bitfile”.

27
3 – Configure a FIFO.

3.1 – No diagrama escolha FPGA Interface → Invoke method.

3.2 – Conecte a saída do “Set custom bitfile” na entrada do “Invoke method”.

3.3 – Clique com o botão direito na palavra Method do bloco e escolha no menu pop-up.

FIFOvet → Configure.

28
3.4 – Crie uma constante para a entrada “Request Depth” com um valor que achamos adequado (de preferência maior/menor
que o tamanho do Buffer da FIFO no FPGA).

3.5 – Crie um indicador para apresentar o valor alocado. Nós o chamamos de DMA Buffer.

4 – Inicie a FIFO.

4.1 – No diagrama de blocos, botão direito, escolha:

FPGA Interface → Invoke Method.

4.2 – Conecte a saída do método anterior onde foi invocado o FIFOvet e configure na entrada da nova chamada.

4.3 – Clique na palavra Method dentro do bloco e escolha:

FIFOvet → Start.

29
5 – Monitorando o crescimento da FIFO até que o número de elementos esteja pronto para ser visualizado.

5.1 – Crie um Loop While, nós chamamos o nosso de Loop Principal (Dica: para nomear o Loop entre nas propriedades dele e
marque “subdiagram label visible”).

5.2 –Crie um controle de parada para o Loop

5.3 – Invoque o método FIFOvet.Read dentro do Loop.

30
5.4 – Defina o “número de elementos” e o timeout para zero. Isso fará com que a FIFO fique enchendo e irá dar os “Elements
remaining” com a quantidade adquirida.

6 – Envazie os elementos da FIFO.

6.1 – Invoque novamente o método FIFOvet.Read dentro do loop principal.

6.2 – Insira um comparador <maior que> e compare a saída do “Elements remaining” do método anterior com o número de
elementos que for necessário retirar da FIFO em cada ciclo de apresentação dos dados.

6.3 – Na saída desse comparador conecte um CASE que envolva o método para esvaziar os elementos da FIFO (coloque a FIFO
só no TRUE do case).

31
6.4 – Conecte o valor de “Elements remaining” na entrada “Number of elements” do FIFO.vet.Read novo.

6.5 – “Sete” o timeout para zero.

7 – Pare a execução do FPGA, pare a FIFO e feche a referência ao FPGA.

7.1 – Fora do Loop insira um Read/Write control para escrever na variável “stop” do FPGA.

32
Invoque um método para parar a FIFO

7.2 – Conecte a referência no stop e depois ao Close FPGA VI Reference, que pode ser obtido no menu:

FPGA Interface → Close FPGA VI Reference.

33
Insira um indicador de erro e conecte na saída de erro do “Close FPGA VI Reference”.

INTERFACE DE APRESENTAÇÃO DE DADOS.

34
Como os dados foram empilhados na forma de sucessivos arrays será necessário separá-los através do Decimate 1D Array:

A aquisição analógica do myRIO retorna um número inteiro que precisa ser transformado em um valor de tensão. Para tal é
preciso primeiro convertê-lo para “float”e depois usar uma expressão numérica para converter o valor.

Decimados e convertidos, os dados podem agora ser apresentados no painel de controle. Iremos apresentá-los em um
“Waveform Graph”:

35
Como são dois os canais lidos, apresentaremos dois “charts”. Assim o sistema completo no sistema operacional em tempo real
fica:

36