Futebol de Robos F180 » Inteligência

# Utilizando passagem de parâmetros por referência em classes

Todos os arquivos do projeto que será utilizado de exemplo neste tutorial de passagem de parâmetros por referência estão disponíveis para serem baixados em ReferenceWiki.rar, adicionado à wiki ao final desta página.

Primeiramente, vamos mostrar como utilizar as ferramentas necessárias à passagem de parâmetros por referência em LabVIEW de forma mais geral, com um Numeric. E depois partiremos para a utilização em classes e com o objetivo de compartilhar informação entre whiles independentes, o qual é o objetivo de usarmos essa ferramenta na reformulação da arquitetura de software pela qual estamos passando.

Criamos uma VI chamada DataReferenceWithNumeric e fizemos duas situações parecidas, porém uma utilizando referência e a outra não:

![](ExRef.png)

O que está acontecendo é:

No for loop de baixo, a cada iteração um valor entra e ele é incrementado de 1. Isso é feito 100 vezes. Porém, nada está alterando o valor de entrada, já que é uma constante. Então, em todas 100 iterações, entra o valor 0.

O for loop de cima faz a mesma coisa. A diferença é que ao entrar um valor e ser incrementado de 1, isso é escrito na referência criada para o nuemric double constant 0. Na iteração seguinte, como estamos lendo o valor a partir da referência na memória, recebemos o valor que foi incrementado e escrito na iteração anterior. Ou seja, a entrada do for muda a cada iteração.

Temos então o seguinte resultado:

![](ResExRef.png)

Agora partiremos para a utilização em classes.

Criamos o seguinte projeto:

![](projeto.png)

Criamos a classe Class 1 que tem apenas os atributos x e y. A ideia é criarmos uma referência para a classe, escrever na referência num while e conseguir ler esse valor alterado em outro while, sem ter fios interligando-os.

Por algum motivo que ainda desconheço, não foi permitido criar a referência para a classe na função main (a qual não é um método). Então, por isso, criamos o método MakeRef que o faz:

OBS: Curiosamente, no nosso projeto Phoenix, foi permitido criar a referência para as classes na VI principal Phoenix.vi sem utilização de métodos. 

![](MakeRef.png)

Criamos depois o método SetByRef que recebe e lê a referencia, recebe também dois numeric double como entradas, seta nos atributos da classe e escreve isso na referência:

![](SetByRef.png)

Perceba que o objeto de entrada do método não foi alteado. Foi alterado o objeto que está na referência recebida como entrada desse método. O fato de levar o objeto ao bloco de escrita Data Value Reference Read/Write Element é o que altera a referência em memória.

Criamos depois o método GetByRef que recebe a referência, a lê, pega os atributos do objeto e os retorna em Indicators:

![](GetByRef.png)

Perceba que o Data Value Reference Read/Write Element da direita não é o de escrita. Quando é o de escrita, o programador é obrigado a informar um valor. Mas como queremos apenas ler nesse caso, podemos trocar para permitir apenas leitura. Para isso, basta clicar com o botão direito do mouse no elemento de escrita e:

![](OnlyRead.png)

Criamos o último método GetByRefWithFeedback, o qual é semelhante ao GetByRef, porém retorna o valor da última iteração:

![](GetByRefWIthFeedback.png)

Por fim, juntamos tudo isso na VI main (essa VI não é um método da classe) da seguinte forma:

![](main.png)

Apenas por uma escolha de melhor visualização, colocamos um wait de 1000ms no while de leitura para que demore 1 segundo para o valor de leitura ser alterado e, consequentemente 2 segundos para o valor de leitura com feeback node ser alterado.

Ao rodar o código, temos:

![](main0.png)

Alteramos para 1 o valor de x in e temos:

![](main100.png)

Passado 1 segundo, temos:

![](main110.png)

Passado mais 1 segundo (2 segundos ao total), temos:

![](main111.png)