Autor: Eduardo Caboz

Para mover a janela de um VI podemos usar o 'PanelBounds' através da propriedade do 'VI Front Panel Window'. A fim de conseguir o evento de carregar no botão do rato, altera-se o tamanho do botão, torna-se o botão transparente e para conseguir a sua posição pode ser usado o 'user32.dll'.

Podemos usar a User Interface para interagir com o utilizador de diferentes maneiras, tais como alterar cores, piscar, alterar imagens e mover o painel frontal como mostro no vídeo.

Nível - Fácil

Para simplificar o código podemos usar referencias de um controlo ou indicador para usar num subVI. Dentro do subVI podemos usar as propriedades ou metodos para ler ou alterar o objecto

Nível - Fácil

Às vezes, é necessário saber se o 'subvi' ou uma secção do código está a ser executada pela primeira vez. Nesse caso, uso para inicializar um valor apartir de um ficheiro ini numa 'function global'.

Nível: Intermédio

Para evitar fugas de memória do programa é necessário prestar atenção ás referencias criadas que não foram fechadas. Depois de criar o código é boa prática criar um teste de stress e verificar se não existem fugas de memória.

As fugas de memória fazem aumentar a memoria usada pelo nosso programa e algures no tempo o programa bloqueia. Como as condições criticas, as fugas de memória não são fáceis de detectar, é necessário testar, testar, testar.

Nível: Intermédio

No Labview, é possível usar o .NET para utilizar recursos como o 'Notification Icon'. Usando o ícone de notificação, é possível criar animações alterando o ícone e indicar assim indicar o status do programa. Também é possível criar um menu e obter retorno.

Nível - Fácil

Esta é uma dica muito pessoal, porque acho que todos precisam alterar as preferências do programa para criar uma programação mais fácil e intuitiva.

Desabilitar no Block Diagram, 'place front terminal as icons', para tornar o código mais compacto e fácil de ler.

Desabilitar no Block Diagram, 'enable automatic wire routing', para ter o poder de decisão por onde vão passar as ligações dos objectos.

Desabilitar no Front Panel, 'show front panel grid', para estar sempre a ver o resultado final do UI e poder alterar os objectos pixel a pixel.

Nível: Fácil

Com o LabVIEW podemos mover objectos durante a execução do programa utilizando um 'property node' com o argumento 'position'.

Nível: Intermédio

Pode se usar os 'Channel Wires' para passar informação entre ciclos paralelos de uma maneira simples, sem ter de recorrer a queues ou notifiers. Este tipo de comunicação funciona como a arquitectura produtor / consumidor, pois temos de ter alguns cuidados em escolher qual o tipo de ligação a fazer.
TAG - conseguimos garantir a velocidade de execução do ciclo de leitura e pode ter vários módulos de escrita e leitura na mesma ligação, mas a leitura pode perder dados.
STREAM - garante a sequência dos dados com um determinado tamanho de buffer, mas a leitura pode ficar com uma fila de dados, ficando em atraso em relação à escrita.
MESSENGER - garante a sequência dos dados com um determinado tamanho de buffer e pode ter vários módulos de escrita e leitura na mesma ligação, mas a leitura pode ficar com uma fila de dados, ficando em atraso em relação à escrita.

Nível: Fácil

Para que o utilizador saiba que o programa está a executar algo podemos usar as funções do cursor 'Set Busy' e 'Unset Busy', para bloquear as acções do rato e mostrar o cursor 'busy'.

Nível: Fácil

Para simplificar o 'User Interface' podemos usar um menu, que além de gerar acções pode conter estados e até mesmo criar listas programaticamente. O menu pode ser alterado durante a execução do programa.

Nível: Intermédio

Por vezes é necessário criar uma função de dialogo para se poder inserir dados ou mesmo configurar algo no programa. O nossa função de dialogo deverá ser simples para que o utilizador saber intuitivamente o que fazer e podemos adicionar verificações aos 'inputs' para que não haja erros no programa com valores mal inseridos.

Na figura seleccione a letra correspondente a:

SHIFT REGISTER
CONDITIONAL TERMINAL
CONCATENATING TUNNEL
CONDITIONAL TUNNEL
INTERATION TERMINAL
TUNNEL
INDEXING TUNNEL

B - SHIFT REGISTER
E - CONDITIONAL TERMINAL
F - CONCATENATING TUNNEL
G - CONDITIONAL TUNNEL
D - INTERATION TERMINAL
A - TUNNEL
C - INDEXING TUNNEL

Nível: Intermédio

A utilização de base de dados nos programas é cada vez mais comum devido a ser mais versátil e rápido a aceder a dados.
Uma das maneiras de conseguirmos usar uma base de dados mySQL é através do modulo 'Database', utilizando um conector ODBC e um ficheiro UDL.

Nível: Intermédio

A comunicação com um dispositivo exterior pode ser feito através de USB-Serial-VISA. Neste exemplo o arduino envia pela porta serie a letra 'A' quando o botão está premido e 'a' quando é libertado, enquanto isso o labVIEW está à espera da comunicação através de um ciclo produtor, que tem a capacidade de recuperar se a porta serie for desligada. O ciclo consumidor faz a alteração do valor num control.

Qual a 'function node' que é executada primeiro?

Multiply - Possivel
Divide - não
Subtract - não
Pi - Possivel
Add - Possivel
Exponential - não

Qualquer uma das funções multiply, pi e add pode ser a primeira a ser executada, pois estão todas com valores nas suas entradas quando o programa começa. Como não se sabe qual delas o compilador decide a sua ordem, temos de ter cuidado com o nosso código para não criar nenhuma corrida critica.

Nível: Intermédio

Podemos fazer um histograma com um gráfico XY em modo de barras, para ser mais fácil a criação das barras, existe na palete de probabilidade e estatística a função 'Histogram'. Usando os cursores podemos marcar alguns valores tais como a média e o desvio padrão.

Nível: Intermédio

Para melhorar o 'user interface' nada melhor que ter botões apelativos, para isso podemos usar os botões normais com imagens personalizadas.

Nível: Fácil

Os Indicadores ou controlos numéricos podem ser formatados como uma 'string', podendo ter texto e varias formatações para o mesmo valor. No caso de ser um 'control' o valor pode ser editado em qualquer um dos formatos.

Nível: Avançado

Quando temos funções (Vi's) que ocupam memória e não estão a ser constantemente usados no programa, devem ser chamados dinamicamente. Para facilitar a chamada do VI pode-se usar o 'Call Setup'.

Nível - Fácil

Para melhorar o rendimento na criação do programa podemos utilizar atalhos.

Nível - Fácil

Para ser mais simples localizar código podemos usar 'bookmarks', para isso é necessário colocar um comentário com #('hashtag') seguindo do nome da marcação sem espaços e de seguida o texto que desejamos.

Nível : Intermédio

Para criar um texto com variáveis de diversos formatos, podemos usar varias maneiras de o fazer. Com o 'Format Into String' o codigo fica mais limpo, mas com 'Concatenate Strings' fica mais flexível.

Nível : Intermédio

Para um User Interface mais flexível, podemos usar 'Sub Panels' para colocar VIs. No decorrer do programa pode-se ir alterando de VI's nos 'Sub Panels' como se fossem programas distintos, podendo passar informação de uns para os outros ou mesmo parar a sua execução.

Level : Advanced

Quando temos mais do que um produtor e queremos que só seja executado um de cada vez, consoante a sua disponibilidade, podemos usar semáforos. Os semáforos ficam à espera, por ordem de chegada, da libertação do que estiver a ser executado, conseguindo assim que nunca trabalhem em simultâneo.

Nível : Intermédio

No Labview podemos usar funções de '.NET' como por exemplo: ir no 'Block Diagram', 'Functions', 'connectivity', '.NET' onde encontra-se o 'constructor node' e ai escolher 'speechSyntheizer' para colocamos o nosso programa a falar.

Nível :  Avançado

Gosto de comparar uma 'thread' a um balão com um fio ('handle') que o une ao programa que o gerou, para que se possa facilmente controla-lo. Criar programas com 'threads' dinâmicas dá uma grande flexibilidade, pois quando se adiciona mais uma ligação ao sistema não é necessário alterar código e torna-lo mais complexo.

Nível : Intermédio

Ao usar um serviço de webserver, pode-se colocar dados na nuvem para que fiquem disponíveis em diversos dispositivos com sistemas operativos diferentes. Este tipo de interconexão poderá fazer parte de um sistema baseado em IOT (internet of things), para se poder interagir com diversos equipamentos (Get/Insert Data, Input/Outputs).

O código em labview se estiver limpo e conciso, já por si pode ajudar à sua compreensão, podendo ser complementado por comentários, imagens e decorações. Quando queremos "comentar" um segmento do código para não ser executado pode-se usar o 'Disable Structure'.

Quando é necessário gerar um evento de alteração de um valor programaticamente num determinado objecto, pode-se usar o 'property node' - 'Value(Signaling)' e assim é como se fosse alterado pelo utilizador.

É importante podermos criar um ficheiro onde possa ser inserido texto por ordem cronológica para reportar eventos, essa função deverá poder ser usada em diferentes partes do programa.

Uma maneira de criar um painel de instrumentos personalizado é ao criar uma mascara com transparência e coloca-la por cima de indicadores.

Ao escolher o método 'clipboard.write' no 'invoke node' pode-se copiar para o clipboard uma string pré-formatada com 'array to spreadsheet string'. Para inserir os dados no Excel basta fazer colar ou usar o atalho 'ctrl+v'.

Pode-se aproveitar a leitura do ficheiro de configuração (.INI) para criar um valor por defeito no ficheiro - caso o mesmo não exista. Usando o 'stacked sequence structure' ocupa-se menos espaço e a leitura do ficheiro de configuração fica mais organizada.

A alteração dos elementos do User Interface faz com que o programa fique mais apelativo e prático de utilizar. Uma das formas mais simples é alterar as cores. Para remover a moldura dos controls pode-se utilizar o pincel da Tools Palette escolhendo a cor transparente como primaria e secundaria.

Ao alterar propriedades dos objectos que estão no Front Panel obriga a que os objectos sejam redesenhados, isso vai fazer com que o UI fique lento. Para tornar o UI fluido pode-se bloquear o update dos objectos enquanto são desenhados e só liberta-lo no fim.

Podemos desenhar um gráfico através de pontos (x,y) tendo como base um array de valores e assim criar uma nova forma de representar, bastando agrupar alguns pontos.

Ao juntar 'arrays' de dimensões diferentes através do 'build array' vai criar um 'array' com uma dimensão superior e vai colocando o valor 'default' nos menores até ficarem com dimensões iguais. Para manter as dimensões dos 'arrays' coloca-se individualmente cada um num 'cluster' e assim já podem ser colocados num 'build array' sem perderem sua dimensão.

Quando o VI tem muitas saídas/entradas pode ser complicado mapear os terminais, para simplificar pode-se usar clusters para agrupar (deveram ser typedef para facilitar no caso de alguma alteração).

No labview não basta colocar o código da esquerda para a direita, ou mesmo de cima para baixo para garantir a sequência do código. É necessário garantir o um fluxo de informação como desejamos que o programa se comporte, para isso podemos usar algumas ferramentas para garantir a sequência, tais como, usar a linha de Controlo de Erros, Flat Sequence, Stacked Sequence, ciclo FOR com Case Structure, Máquina de Estados ...

É importante ao criar um 'vi' / função alterar o seu ICON, para que seja mais fácil a sua implementação no código. Ao ver o ICON devemos conseguir perceber qual a sua função, para isso tem de ser perceptível o texto (letras grandes e se necessário abreviaturas) e para auxiliar pode-se desenhar algo simples que identifique a função.

Quando é necessário passar dados entre iterações de ciclos deve-se usar o Shift Register para evitar variáveis e garantir o sincronismo. Pode-se puxar o túnel de entrada do Shift Register para obter os valores das iterações anteriores, de cima para baixo (último [-1], penúltimo [-2], antepenúltimo [-3], ...).

O número de ciclos pode ser inicializado pelo"N" ou pela entrada de arrays no ciclo FOR. Quando se inicializa com "0" no "N" o código que está dentro do ciclo FOR não irá ser executado e os túneis de saída ficam com os valores default, no caso de ser um túnel simples o valor é default do tipo de variável, já se for um shift register o valor é o que estiver na entrada do mesmo. Ao inicializar com arrays a quantidade de ciclos será definida pelo array menor, todas as outros valores de entrada não alteram a quantidade de ciclos.

Por vezes o User Interface é mais importante do que o próprio código, sendo a "cara" do nosso programa, por isso devemos trata-lo como tal. Trato o UI como se fosse um quadro, primeiro começo a fazer um croqui onde coloco todos os elementos necessários para a iteração com o utilizador, de seguida continuo a fazer o código (dar vida ao quadro). Ao decorrer do programa cruza-se a informação dos objectos com o equilíbrio do UI, até ter o formato desejado.

Para sair do labview apenas se estiver em modo "Run Time" (ficheiro executável) coloca-se um "Property Node" -> "Application" -> "Kind" em sequência do programa, com um "case - Run Time System" com "Quit Labview"

Para se garantir o sincronismo na utilização de variáveis pode-se criar uma função altamente customizável e utiliza-la em qualquer parte do programa. Para criar usa-se um ciclo while de uma única interacção ("true" na condição de saída) alojando um ou mais shift register para guardar a informação. Para as condições de entrada do "case" pode-se utilizar "enum", "string", "numeric", "bollean"... dependendo do pretendido.

• 

Para usar esta arquitectura podemos utilizar queues (filas de dados) para inserir dados no Master (produtor) e retirar os dados num ou mais Slaves (consumidores). Para terminar a execução do Slave poderá ser ligada a linha de erros da Queue na condição termino do ciclo while. (no release queue é necessário colocar a entrada "force destroy" a "true")