09 - programando lego mindstorms

SISTEMAS OPERACIONAIS

PROGRAMANDO LEGO MINDSTORMS

UTILIZANDO LABVIEW

- ROTEIRO - Introdução→Como programar Lego Mindstorms no LabView?

Estruturas e loops→Estruturas de controle→Estruturas de repetição

Operações e funções→Operações lógicas e aritméticas→ Funções especiais

Tela e movimento→Display→Motores

Sensores e variáveis→Controlando os sensores→Criando e trabalhando com variáveis

PROGRAMANDO NO LABVIEW

- PROGRAMANDO LEGO MINDSTORMS -


- INTRODUÇÃO -

- PROGRAMANDO LEGO MINDSTORMS - Introdução→Como programar Lego Mindstorms no LabView?• Para criarmos qualquer programa no para o Lego Mindstorms

no LabView precisamos primeiro instalar a biblioteca NXT ROBOTICS.

• Ela nos permite criar VIs especialmente para o Lego.• Apresenta uma biblioteca com vários objetos de manipulação

para o robô.• Quando o Lego está conectado ao computador, ela nos

possibilita atualizar o firmware dele.• Com ela podemos compilar, enviar e executar nossos VIs no

robô.• Além de fornecer os drivers corretos para a conexão com o

Lego, que sem eles não conseguiríamos nem enviar os VIs.

- PROGRAMANDO LEGO MINDSTORMS - Introdução→Como programar Lego Mindstorms no LabView?• Com a biblioteca instalada um categoria chamada NXT

ROBOTICS é adicionada nas palhetas de controles e de funções.

• Para criarmos uma VI em branco para o Lego basta clicar em BLANK VI TARGETED TO NXT na janela de boas vindas do LabView.

• Um painel frontal e um diagrama de blocos em branco é criado, lembre-se de salvar antes de salvar para não perder suas modificações.

• Repare que no canto inferior esquerdo aparece um texto escrito NXT TARGET que significa que você está no modo de programação do Lego.

- PROGRAMANDO LEGO MINDSTORMS - Introdução→Como programar Lego Mindstorms no LabView?• Caso o texto que esteja aparecendo seja MAIN

APPLICATION INSTANCE significa que está no modo padrão de programação.

• Para mudar de um modo para outro basta clicar com o botão direito do mouse sobre o texto e selecionar o modo desejado.

• Quando está no modo de programação do Lego o fundo do texto fica verde caso o robô esteja conectado ao computador contrário ficará laranja.

• No modo de programação do robô as palhetas de controle e de funções se modificam e apresentam apenas os controle e funções que podem ser utilizadas no Lego.

- PROGRAMANDO LEGO MINDSTORMS - Introdução→Como programar Lego Mindstorms no LabView?• Com isso não precisamos nos preocupar em inserir os

controles e funções certos para que não dê erro na hora de enviarmos para o robô.

• No modo MAIN APPLICATION INSTANCE temos todos os recursos do LabView, caso desejemos utilizar algum recurso especifico do Lego podemos encontrar na categoria NXT ROBOTCIS.

• Para conectarmos um robô ai LabView basta clicar com o direito do mouse sobre o texto no canto inferior esquerdo e selecionar a opção FIND NXT.

• Com ela podemos obter algumas informações sobre o Lego.

- PROGRAMANDO LEGO MINDSTORMS - Introdução→Como programar Lego Mindstorms no LabView?• Para que nossos objetos do Lego sejam executados

precisamos interligá-los através da conexão NXT.• Cada objeto que comanda as funções do Lego apresentam

uma entrada e uma saída NXT, na qual utilizamos para darmos o sinal de que iremos utilizar aquele recurso.

• Esses objetos que apresentam essa conexão são na verdade outros VIs que inserimos em nossos VI como subVI, para visualizarmos o funcionamento interno dele basta dar dois cliques sobre o VI. Não o modifique pois afetará todos os VI.

- PROGRAMANDO LEGO MINDSTORMS - Introdução→Como programar Lego Mindstorms no LabView?• Na palheta de funções do diagrama de blocos temos a

categoria NXT PROGRMMING que já vimos suas funções anteriormente.

• Na categoria NXT I/O temos algumas outras divisões além das funções MOTOR, SENSOR, WAIT, DISPLAY que veremos mais adiante nesse módulo.

• Temos uma função para manipulação de mensagens MAIL, uma para o controle de sons emitidos pelo Lego SOUND e uma para controle de logs das portas do robô LOG DATA.

• Ainda temos outras subcategorias dentro de NXT I/O.

- PROGRAMANDO LEGO MINDSTORMS - Introdução→Como programar Lego Mindstorms no LabView?• Na subcategoria COMPLETE encontramos vários VIs para

controle dos motores em MOTOR, para controle dos sensores em SENSOR, para definições de espera em WAITS,para manipulação do visor em DISPLAY, para controle da emissão de sons em SOUND, para manipulações de logs em LOGGING e para manipulações nas caixas de mensagens em MAIL.

• Na subcategoria ADVANCED encontramos diversos VIs avançados para utilizarmos, exemplo: CALCULATOR para calcularmos uma determinada fórmula que definimos pela entrada FORMULA.

- PROGRAMANDO LEGO MINDSTORMS - Introdução→Como programar Lego Mindstorms no LabView?• Na subcategoria NXT NATIVE I/O encontramos vários VIs

nativos do Lego.• Na subcategoria ADDITIONAL SENSORS AND MOTORS

encontramos diversos VIs especiais para utilização dos sensores e motores.

• Para aprender mais sobre cada VI basta selecioná-lo e verificar sua descrição na janela CONTEXT HELP ou ativar a ajuda do LabView para o VI desejado.

• Veremos a seguir algumas funções básicas e mais utilizadas.


- ESTRUTURAS E LOOPS -

- PROGRAMANDO LEGO MINDSTORMS - Estruturas e loops→Estruturas de controle• No modo de programação do Lego na palheta de funções

encontramos uma categoria que nos possibilita trabalhar com estruturas de controle.

• Podemos facilmente controlar nossos VI com a estrutura CASE STRUCTURE.

• Podemos encontrar também nessa categoria a função LOCAL VARIABLE para trabalharmos com variáveis locais.

• Ainda na mesma categoria temos a estrutura FLAT SEQUENCE STRUCTURE para trabalharmos com execuções seqüenciais. Porém para utilizarmos essa estrutura no lego precisamos utilizá-las com seqüências separadas e ligadas com a conexão NXT dos blocos do Lego.

- PROGRAMANDO LEGO MINDSTORMS - Estruturas e loops→Estruturas de repetição• No modo de programação do Lego na palheta de funções

encontramos uma categoria que nos possibilita trabalhar com estruturas de repetição.

• Temos a estrutura WHILE LOOP para definir partes do código a serem repedidas.

• O FOR LOOP não compila no Lego, porém podemos criar uma estrutura FOR LOOP utilizando a estrutura WHILE LOOP.

• Já aprendemos como funciona essas duas estruturas de repetição nos módulos anteriores.


- OPERAÇÕES E FUNÇÕES -

- PROGRAMANDO LEGO MINDSTORMS - Operações e funções→Operações• Podemos inserirmos operações numéricas com a categoria

NUMERIC, lógicas com a categoria BOOLEAN, entre textos com a categoria STRING, entre arrays com a categoria ARRAY, entre clusters com a categoria CLUSTER.

• Temos ainda a categoria COMPARISON para comparações.• A maioria das funções dessas categorias são as mesmas que

já vimos anteriormente.• Algumas funções são específicas para a programação do

robô, as veremos posteriormente.• As funções específicas do Lego apresentam em seu nome o

prefixo NXT para indicar o grupo a qual ela pertence.

- PROGRAMANDO LEGO MINDSTORMS - Operações e funções→ Funções especiais• Algumas das funções que temos disponíveis no modo de

programação do robô são especificas para a programação do Lego por isso seus nomes começam com NXT.

• Para podermos visualizar essas funções precisamos mudar para o modo de programação do Lego ou selecionarmos a categoria NXT ROBOTICS da palheta de funções no modo de programação normal.

• Algumas dessas funções estão separadas em subcategorias, por exemplo a TRIGONOMETRY que é a categoria para funções trigonométricas.

• A maioria são VIs já criados para facilitar nossa programação.

- PROGRAMANDO LEGO MINDSTORMS - Operações e funções→ Funções especiais• Para utilizarmos uma função especial precisamos entender

para que serve, quais as conexões de entrada e saída que ela apresenta e como utilizá-la.

• Ativando a janela CONTEXT HELP podemos visualizar uma breve descrição de cada função apenas passando o mouse sobre ela.

• Essa janela além de nos fornecer uma descrição de como funciona o objeto selecionado, aparece também os tipos de dados recebidos e retornado (conexões de entrada e saída).

• São muitas funções para abordamos, ao longo d curso veremos as mais utilizadas.


- TELA E MOVIMENTO -

- PROGRAMANDO LEGO MINDSTORMS - Tela e movimento→Display• O Lego nos permite utilizar seu visor para mostrar textos ou

desenhos, nos permitindo interagir com o usuário.• Na palheta de funções do diagrama de blocos temos a

categoria NXT I/O onde encontramos diversos VIs para controle e recepção de dados com o robô.

• Além dos VIs já existentes temos também dentro da subcategoria NXT NATIVE I/O uma série de Vis para envio e recebimento de dados.

• O VI DISPLAY encontrado na categoria NXT I/O da palheta de funções é o que mais usaremos em nossos exercícios e o que utilizaremos para mostramos alguma informação no visor do robô.

- PROGRAMANDO LEGO MINDSTORMS - Tela e movimento→Display• A entrada NXT é o sinal que indica que utilizaremos esse VI

em nossa execução. O primeiro VI que inserirmos não utilizará essa entrada, pois será o VI inicial e o último não utilizará a saída NXT, pois será o VI de término.

• Caso o VI NXT DISPLAY não seja o primeiro devemos ligar essa entrada ao VI anterior.

• A entrada inferior esquerda mudará de acordo com o tipo de dado que escolhermos no menu abaixo do bloco.

• A entrada LINE só aparece para a ação WRITE do menu abaixo do VI DISPLAY.

• Se clicarmos na seta preta abaixo do bloco onde existe um texto escrito no taremos que um menu é exibido.

- PROGRAMANDO LEGO MINDSTORMS - Tela e movimento→ Display• Esse menu serve para selecionarmos o que desejamos mostrar

em seu visor.• Temos quatro opções de ação com o display do Lego: WRITE,

DRAW, ERASE e RESTORE DISPLAY.• A ação WRITE nos permite escrever no visor do Lego:

A opção TEXT nos permite escrever um texto, com isso a entrada inferior esquerda mudará para o tipo string.

A opção INTERGER nos permite escrever um número inteiro, com isso a entrada inferior esquerda mudará para tipo número com representação inteira.

A opção FLOAT nos permite escrever um número real, com isso a entrada inferior esquerda mudará para tipo número com representação float.

- PROGRAMANDO LEGO MINDSTORMS - Tela e movimento→Display• A ação DRAW nos permite desenhar no visor do Lego,

reparemos que a entrada inferior esquerda mudará para o tipo array: Com a opção POINT desenhamos pontos, informando as

coordenadas do ponto no array de entrada. Com a opção LINE desenhamos linhas, informando as

coordenadas iniciais e finais da linha no array de entrada. Com a opção RECTANGLE desenhamos retângulos,

informando as coordenadas iniciais e as medidas do retângulo.

Com a opção CIRCLE desenhamos círculos, informando as coordenada do centro do círculo e seu raio.

- PROGRAMANDO LEGO MINDSTORMS - Tela e movimento→Display• Na ação DRAW além dos desenhos básicos vistos no slide

anterior temos também a possibilidade de mostrarmos figuras no visor do Lego, para isso utilizamos a opção PICTURE: Nela encontramos quatro outros VIs. Os VIs BLUE PICTURE, RED PICTURE e GREEN

PICTURE nos possibilidade desenhar figuras pré-definidas.

O VI FILE nos permite informar um arquivo RIC para ser desenhado no visor do robô. Precisamos para isso informar o nome do arquivo do Lego que desejamos que ele mostre em seu visor.

- PROGRAMANDO LEGO MINDSTORMS - Tela e movimento→Display• Na ação ERASE podemos apagar o conteúdo do visor para

modificá-lo. Com a opção SCREEN podemos limpar totalmente o

visor. A opção RECTANGLE nos permite limpar uma área

retangular do visor, bastando passar as coordenadas do ponto inicial e os tamanhos dos lados.

• Com a ação RESTORE DISPLAY podemos restaurar o visor do robô para as configurações padrões do display.

• Lembre-se sempre de ligar a entrada NXT caso o subVI não seja o primeiro e a saída caso não seja o último a ser executado.

- PROGRAMANDO LEGO MINDSTORMS - Tela e movimento→Motores• Além de controlarmos o que é exibido no visor do Lego

temos a possibilidade de controlar os motores para controlar seu movimento.

• O Lego apresenta três saídas A, B e C que nos permite controlar os motores.

• Podemos controlar cada saída individualmente,ou juntas, temos a possibilidade de definir qual velocidade os motores movimentarão.

• Para trabalharmos com os motores do robô precisamos inserir o VI MOTOR da palheta de funções na categoria NXT I/O.

• Com eles podemos ligar ou desligar os motores.

- PROGRAMANDO LEGO MINDSTORMS - Tela e movimento→Motores• Esse VI também apresenta uma entrada e uma saída NXT

para informar que desejamos que ele seja executado pelo Lego.

• Com a entrada OUTPUT PORT que por padrão fica definida como ALL PORTS.

• Podemos mudar a porta que desejamos controlar informando o número correspondente da porta: 1 para PORT A, 2 para PORT B, 3 para PORT C e 4 para ALL PORT.

• Se desejar entender melhor o funcionamento desse VI basta dar dois cliques nele com o mouse que o VI será aberto em outra janela, mas lembre-se de não modificá-lo pois afetará todos os VIs que o utilizarem como subVI.

- PROGRAMANDO LEGO MINDSTORMS - Tela e movimento→Motores• No menu abaixo do bloco MOTOR podemos escolher a ação

MOTOR ON para ligarmos o motor escolhido.• Temos duas opções para esta ação:

A FORWARD que nos permite ligar o(s) motor(es) definidos a uma determinada potência.

Com a entrada POWER definimos a potência que os motores deverão ser ligados, o padrão é 75.

A opção REVERSE nos permite inverter o movimento dos motores. Ela apresenta as mesmas conexões da opção FORWARD.

Para valores negativos de potência (POWER) temos movimentos inversos.

- PROGRAMANDO LEGO MINDSTORMS - Tela e movimento→Motores• Na ação MOTOR OFF podemos desligar o(s) motor(es).• Temos duas opções para esta ação:

Com a opção COAST podemos fazer com que o motor seja encostado, levemente diminua a velocidade até parar.

A opção BRAKE faz o motor parar imediatamente.• Para pararmos um motor, basta informar a porta e ligar a

conexão NXT.• Na palheta de funções NXT I/O >> NXT NATIVE I/O >>

OUTPUT encontramos diversos VIs que podemos utilizar para controlar nossos motores.

• Basta selecionar e verificar quais dados de entrada são pedidos e quais dados de saída são retornados.


- SENSORES E VARIÁVEIS -

- PROGRAMANDO LEGO MINDSTORMS - Sensores e variáveis→Controlando sensores• O Lego apresenta quatro entradas nas quais são conectados

os sensores do robô.• Temos sensores de sonoro, luminoso, de distância e de toque.• Cada sensor é conectado em uma porta de entrada que são

definidas de 1 a 4.• Devemos sempre nos preocupar em verificar qual porta cada

sensor está conectado, para não ocorrer erro na execução.• Além das portas de conexão temos também os botões do

robô, que nos permitem um controle a mais.• Temos também como controlar a rotação, o nível da bateria,

o timer e até mesmo a temperatura caso um sensor de temperatura esteja conectado a alguma porta de entrada.

- PROGRAMANDO LEGO MINDSTORMS - Sensores e variáveis→Controlando sensores• Antes de começarmos a obter os dados de um sensor

específico, precisamos ter em mente que tipo de dados é retornado pelo sensor.

• Precisamos saber exatamente qual é a porta que ele está conectado.

• Para ai sim definir uma função para obter informações daquele sensor.

• A função SENSOR da palheta de funções na categoria NXT I/O nos permite configurar diversos tipos de sensores.

• Tais como os botões do Lego, sensores conectados as portas, sensor de rotação para o motor, sensor timer dentre outros.

- PROGRAMANDO LEGO MINDSTORMS - Sensores e variáveis→Controlando sensores• Ao inserirmos a função SENSOR verificamos que um menu

aparece logo abaixo da mesma.• Nesse menu temos as diversas formas de trabalharmos com a

aquisição de dados dos sensores e controles do nosso robô.• Para cada opção escolhida os tipos de dados da função

mudam, exceto para a entrada e saída NXT, que serve para definir a execução do bloco inserido.

• As quatro primeiras opções correspondem ao sensores de toque, sonoro, luminoso e ultra-sônico respectivamente de cima para baixo.

• Como já falamos, cada um apresenta uma porta padrão.• Por padrão a função já vem com essas portas definidas.

- PROGRAMANDO LEGO MINDSTORMS - Sensores e variáveis→Controlando sensores• Com a opção READ TOUCH podemos escolher entre três

estados: PRESSED verifica se o sensor foi pressionado; RELEASED se o sensor foi liberado e BUMPED se o sensor foi clicado, um valor lógico é retornado.

• Com a opção READ SOUND podemos escolher receber dados da forma logarítmica ou da forma discreta.

• Para valores discretos utilizamos o VI dBA, para valores mais sensíveis utilizamos o VI dB.

• Com a opção READ LIGHT podemos obter intensidades luminosas com ou sem o LED ligado.

• Com LEDON utilizamos o sensor com o LED ligado e com LEDOFF utilizamos com o LED desligado.

- PROGRAMANDO LEGO MINDSTORMS - Sensores e variáveis→Controlando sensores• Com a opção READ ULTRASONIC podemos obter qual

distância objetos próximos estão do robô.• Os valores são obtidos em centímetros.• Com a opção READ ROTATION verificamos a rotação do

motor em graus.• Com a opção READ TIMER obtemos o tempo decorrido em

milissegundos.Podemos escolher entre os três contadores de tempo que o Lego nos fornece.

• Precisamos informar qual o timer que iremos utilizar em nossa leitura.

• Com a opção READ BATTERY LEVEL verificamos o nível de bateria do robô em milivolts.

- PROGRAMANDO LEGO MINDSTORMS - Sensores e variáveis→Controlando sensores• Com a opção READ NXT BUTTONS o estado dos botões do

lego. Se ele está pressionado, se foi liberado ou se foi clicado.• Podemos escolher entre os botões ENTER, LEFT ou RIGTH.• A opção RESET MOTOR é para limpar o contador de rotação

do motor especificado.• A opção RESET TIMER limpa o contador de tempo.• Ao iniciarmos um programa no Lego todos os contadores são

limpos e iniciados, ou seja, eles passam a ser contados a partir do início da execução do programa.

• Com a opção READ TEMPERATURE podemos obter valores de temperatura na escala de graus Celcius. Lembrando que devemos definir a porta que o sensor está.

- PROGRAMANDO LEGO MINDSTORMS - Sensores e variáveis→Controlando sensores• Na opção READ COLOR temos várias formas de obter os

dados do sensor luminoso: com BLUE LED verificamos a intensidade de luz azul do objeto, com GREEN LED verificamos a intensidade de luz verde do objeto, com RED LED verificamos a intensidade de luz vermelha do objeto, com DETECT COLOR obtemos o valor correspondente a cor do objeto e com NO LIGHT desativamos o LED para obtermos um modo básico de iluminação.

• Na categoria NXT NATIVE I/O >> INPUT encontramos diversos VIs para a obtenção de dados dos sensores dentre outros, basta selecionarmos o desejado e verificar como ele funciona na janela CONTEXT HELP.

- PROGRAMANDO LEGO MINDSTORMS - Sensores e variáveis→Controlando sensores• Na categoria NXT I/O da palheta de funções encontramos a

função WAIT.• Ela nos permite parar a execução da seqüência corrente até

que um evento determinado ocorra.• Esta função apresenta um menu abaixo para definirmos qual

evento que iremos aguardar.• Podemos aguar um determinado tempo com a opção WAIT

FOR TIME definindo se iremos aguardar em segundos ou milissegundos.

• Com essa opção a execução fica interrompida até que o tempo de espera seja alcançado.

- PROGRAMANDO LEGO MINDSTORMS - Sensores e variáveis→Controlando sensores• Com a opção WAIT FOR TOUCH podemos aguardar o

sensor de toque ser pressionado PRESSED ou ser liberado RELEASED.

• Com a opção WAIT FOR SOUND podemos aguardar o sensor sonoro captar valores acima LOUD ou menores SOFT do definido na entrada LOUDNESS.

• Com a opção WAIT FOR LIGHT podemos aguardar uma determinada claridade com BRIGHTER ou uma determinada escuridão com DARKER usando comparações relativas.

• Para comparações absolutas utilizamos BRIGHTNESS para claridade e DARKNESS para escuridão.

• Os valores esperados são definidos na entrada numérica.

- PROGRAMANDO LEGO MINDSTORMS - Sensores e variáveis→Controlando sensores• Com a opção WAIT FOR ULTRASOUND podemos aguardar

o sensor ultra-sônico detectar um objeto mais longe que a distância definida com FURTHER ou mais próximo que a definida com FURTHER.

• Podemos aguardar também uma mensagem bluetooth de uma das 10 caixas de mensagem com a opção WAIT FOR BLUETOOTH MESSAGE.

• Com a opção WAIT FOR NXT BUTTON aguardamos um dos botões do Lego ser acionado.

• Com a opção WAIT FOR TEMPERATURE podemos aguardar temperaturas maiores HEAT ou menos COLD que a definida.

- PROGRAMANDO LEGO MINDSTORMS - Sensores e variáveis→Controlando sensores• Com a opção WAIT FOR ROTATION aguardamos uma

determinada rotação de um dos motores.• E com a opção WAIT FOR NXT FLAG aguardamos que uma

um evento ocorra.• Definimos o número correspondente ao evento a esperado

com a entrada NXT FLAG NUMBER.• Quando a flag correspondente ao evento esperado for ativada

a execução será reativada.• Na categoria NXT I/O >> COMPLETE >> WAITS temos

todas as funções vista separadas.• Devemos lembrar de definir as entrada PORT, MAILBOX,

BUTTON e OUTPUT PORT de cada função escolhida.

- PROGRAMANDO LEGO MINDSTORMS - Sensores e variáveis→Criando e trabalhando com variáveis• Todo programa necessita de variáveis para guardar seus

dados durante sua execução.• No Lego isso não é diferente, precisamos definir nossas

varáveis que irão guardar nossos dados durante sua execução.• Devemos definir varáveis sempre necessitarmos guardar

alguma informação para uma utilização futura.• Essas variáveis podem ser acessadas de duas formas: como

leitura para resgatar a informação guardada ou como escrita para definir a informação a ser guardada.

• Podemos definir um controle ou indicador como controlador de uma variável.

- PROGRAMANDO LEGO MINDSTORMS - Sensores e variáveis→Criando e trabalhando com variáveis• Sabemos como criar e utilizar variáveis no LabView, agora

iremos aprender a utilizar variáveis no Lego.• Para criarmos uma variável podemos clicar com o direito do

mouse sobre um controle ou indicador do painel frontal e na opção CREATE escolher LOCAL VARIABLE.

• Podemos também definir uma variável local através da categoria STRUCTURE, da palheta de funções do diagrama de blocos, a função LOCAL VARIABLE.

• Quando criamos a variável local direto pelo controle ou indicador do painel frontal automaticamente a variável é associada ao tipo do controle ou indicador que escolhemos.

- PROGRAMANDO LEGO MINDSTORMS - Sensores e variáveis→Criando e trabalhando com variáveis• Quando inserimos uma variável local, através da palheta de

funções, ela é inserida sem tipo por isso ainda precisamos definir qual tipo ela terá.

• Para isso escolhemos um dos controles e indicadores que temos em nosso VI.

• Clicamos com o botão direito do mouse sobre a variável inserida e selecionamos a opção SELECT ITEM, uma lista com nossos controles e indicadores será exibida.

• Desse modo temos um pouco de dificuldade em encontrar qual o controle ou indicador queremos se eles tiverem nomes iguais, por isso o primeiro modo é mais prático e evita definições erradas.

- PROGRAMANDO LEGO MINDSTORMS - Sensores e variáveis→Criando e trabalhando com variáveis• Uma variável local apresenta duas manipulações: de leitura

READ e de escrita WRITE.• Podemos mudar a interação a ser feita clicando com o direito

do mouse sobre a variável e escolhendo CHANGE TO WRITE ou CHANGE TO READ.

• Na opção de leitura temos uma saída para receber os dados e na opção de escrita temos uma entrada para enviar os dados.

• Mesmo depois de definido qual controle ou indicador corresponde a variável ainda podemos mudar selecionando um novo na opção SELECT ITEM como visto antes.

• O nome do controle ou indicador fica escrito dentro do bloco da variável correspondente.


- UTILIZANDO PROGRAMAÇÃO LEGO MINDSTORMS -


Exercício:→ Iremos criar um exemplo de programa para o Lego.→O programa irá obter os dados dos sensores: luminoso, sonoro,

ultra-sônico, de toque e de rotação dos motores.→Teremos indicadores para visualizarmos esses valores no

computador.→O sensor de toque controlará o fim da execução, caso ele seja

pressionado o programa terminará.→O sensor ultra-sônico controlará os movimentos do robô, caso ele

detecte um obstáculo a uma distância menor que 40cm ele virará.→Os outros sensores serão monitoras, porém não controlarão a

execução. Mas poderíamos criar algo para eles.→No visor mostraremos uma mensagem para o estado atual do

robô: iniciar, executando ou terminar.


Exercício:→ Se quiséssemos poderíamos mostrar os valores dos sensores no

visor do Lego, mas não iremos fazer nesse exercício.→Temos que ter que informar cada ação que o robô deverá efetuar.→Tanto para as leituras dos sensores, quanto para os movimentos

dos motores e as impressões no visor.→ Para termos uma execução mais rápida e treinarmos uma

programação em paralelo criaremos várias linhas de execução ao invés de uma só.

→O robô irá coletar os dados dos sensores constantemente e mostrá-los nos indicadores do PC, quando o mesmo estiver conectado ao robô.

→Concorrentemente ele irá andar para frente e caso detecte, com o sensor ultra-sônico, um obstáculo a menos de 40cm desviará.


Exercício:→Caso o sensor de toque detecte que foi pressionado o robô

abortará a execução.→Vamos primeiro entender o que o Lego realmente deverá fazer.→ Primeiro ele iniciará e mostrará uma mensagem na tela para

informar o início do programa.→Após isso ele ativará dois loops, em um ficará ativando a leitura

dos sensores e gravando em suas respectivas variáveis.→No outro loop ficará as ações de movimento que deverão ser

tomadas de acordo com os resultados dos sensores.→Analisando o primeiro loop percebemos que antes de ativarmos

os sensores de rotação precisamos zerar para que não haja erro na execução, apesar que cada programa quando iniciado no Lego todos os contadores (time, rotação) são zerados.


Exercício:→Dentro do loop de leitura dos sensores inserimos os VIs que

ativam as leituras de cada sensor e informamos qual a porta de cada leitura, de acordo com a configuração do robô.

→No nosso caso não utilizaremos o motor C, logo não iremos ler suas rotações por não ser necessário.

→No caso dos sensores sonoro e luminoso também não serão utilizados para controle, porém eles são independentes e por isso iremos utilizá-los apenas para a obtenção de dados, se preferir poderá retirá-los.

→Cada sensor ativado deverá guardar seus valores em uma variável para que possamos utilizar caso necessário.

→No caso do sensor de toque ele ainda controlará o loop, ou seja, será ligado na estrutura de loop.


Exercício:→Agora para o controle das ações ativamos os motores A e B (que

controlam as rodas).→No momento ele só andará para frente, precisamos definir um

loop que irá modificar a ação a ser tomada de acordo com o resultado obtido pelo sensor ultra-sônico.

→Não precisamos ativar o sensor ultra-sônico novamente para obter a informação que desejamos, basta utilizar a variável correspondente.

→Utilizamos a variável do sensor de toque para controlar o loop de ação também.

→ Inserimos a verificação que desejamos e ligamos na estrutura de controle que irá definir o que será executado em cada caso recebido.


Exercício:→Caso a resposta seja falsa ativamos os motores A e B para frente.→Caso seja verdadeira precisamos de uma execução mais

complexa.→ Primeiro precisamos parar os motores, depois ativamos os

motores A e B de forma que efetuem uma curva e paramos os motores novamente.

→ Podemos ativar dentro desse loop também o visor para que ele informe que o programa está em execução.

→ Por fim, caso o loop de ação seja terminado devemos parar todos os motores e finalmente ativar o visor para informar que o programa terminou.

→ Para que o texto do visor possa ser lido ao final do programa devemos adicionar um tempo de espera.


Exercício:→Vimos exatamente cada iteração que o Lego deverá executar,

agora vamos criar o VI para ser executado no Lego.→No painel frontal insira cinco indicadores numéricos, um de texto

e um lógico.→Eles servirão para nos mostrar os valores obtidos durante a

execução quando estivermos debugando o programa com o Lego conectado ao computador.

→Além disso precisaremos desses indicadores para definir nossas variáveis.

→Arrume o painel frontal separando e nomeando cada indicador.→ Indicador string será o texto que aparecerá no visor do robô.→ Indicador lógico será indicará se o sensor de toque foi

pressionado ou não.


Exercício:→Dois indicadores numéricos mostrarão as rotações dadas pelos

motores A e B, defina-os com representação de inteiro de 32bits. →Os outros três indicadores numéricos mostrarão os valores

recebidos dos sensores sonoro, luminoso e ultra-sônico, defina-os com representação de inteiro de 16bits.

→Essas representações são definidas pelo tipo de saída do sensor correspondente.

→Coloque textos e decorações para melhorar a visibilidade e facilitar o entendimento.

→Com nosso painel frontal pronto podemos efetuar as ligações para que nosso programa seja executado.

→No diagrama de blocos ative a palheta de funções e a janela CONTEXT HELP para ver as descrições das funções.


Arrume os indicadores, insira textos e decorações para melhor visualização

Sensores de rotação

Texto do visorSensores sonoro,

luminoso e ultra-sônico

Sensor de toque


Exercício:→ Primeiro iremos definir a inicialização dos indicadores para que

não tenhamos resultados errados ao executarmos.→ Para o indicador string insira uma constante string em branco e

ligue-a ao indicador string.→ Para o indicador lógico insira uma constante lógica FALSE e

ligue-a ao indicador lógico.→ Para os indicadores numéricos precisaremos entender um pouco

mais sobre os VI que fornecerão os dados para eles.→Os indicadores que recebem os valores de rotação dos motores

serão ligados a um VI que retorna um número inteiro de 32bits, logo precisaremos inserir constantes numéricas com representação de inteiro de 32bits I32.


Exercício:→Não precisamos inseris uma constante para cada indicador, pois

eles receberam o mesmo valor constante, basta inserir uma só e ligá-la aos dois indicadores.

→Quando iniciar o programa os valores de rotação deverão ser sempre zero, pois os motores ainda não foram ligados, logo defina a constante com o valor zero.

→ Para os indicadores dos sensores sonoro e luminoso poderíamos utilizar a mesma constante utilizada para os motores, porém os indicadores são no formato de inteiro de 16bits.

→ Se fizermos isso o número de 32bits automaticamente será convertido para 16bits, mas aqui iremos utilizar uma constante numérica já em 16bits apenas para treinar utilizar as representações corretas para cada tipo de indicador.


Exercício:→ Insira uma nova constante numérica e a defina como inteiro de

16bits I16 com o valor zero, ligue-o aos indicadores sonoro e luminoso.

→ Para o indicador ultra-sônico temos que ter outra constante pois a inicialização deverá ser com o valor 255.

→ Se colocarmos a inicialização com o valor de zero teremos um resultado diferente do esperado, ele irá virar assim que o programa iniciar, e queremos que ele vire apenas se encontrar um obstáculo muito próximo.

→Defina a representação da constante numérica como inteiro de 16bits I16 e com o valor 255, ligue-o ao indicador ultra-sônico.

→Agora arrume do lado direito da tela de forma a ficar mais legível e separados das funções.


Exercício:→Agora vamos efetuar a programação do nosso VI.→ Insira primeiro um VI DISPLAY da palheta de funções em NXT

I/O caso esteja no modo de programação do Lego ou em NXT ROBOTICS >> NXT I/O no modo de programação padrão.

→No menu abaixo do VI selecione TEXT, insira uma constante string e ligue na entrada TEXT do VI inserido.

→Dentro da constante string escreva “Iniciar” para definir o texto que irá aparecer no visor do robô.

→ Para que seja atualizado o indicador texto do painel frontal precisamos inserir uma variável para controlar o indicador.

→Clique com o botão direito do mouse sobre o indicador texto no diagrama de blocos e selecione CREATE >> LOCAL VARIABLE.


Exercício:→Coloque a variável próxima ao VI DISPLAY e ligue na constante

string.→Assim quando o visor for ativado nosso indicador também será.→ Insira uma constante numérica inteira de 16bits I16 e ligue na

entrada LINE do VI DISPLAY, depois defina a linha desejada.→ Insira um VI STEERING ON da palheta de funções em NXT I/O

>> COMPLETE >> MOTORS.→Utilizamos esse VI para ativar dois motores ao mesmo tempo.→Com ele podemos fazer com que dois motores sejam ligados ao

mesmo tempo.→ Insira uma constante numérica e ligue na entrada POWER do VI

STEERING ON para definir a potência que os motores deverão ser ligados.


Exercício:→ Insira um MOTOR PORTS da palheta de funções em NXTO I/O

>> COMPLETE >> MOTORS e escolha quais os motores deverão ser ativados e ligue na entrada OUTPUT PORTS.

→Com a entrada STEERING definimos como os motores serão ativados.

→ Para valores negativos ativamos o primeiro motor para traz e o segundo para frente, para valores positivos ativamos o primeiro para frente e o segundo para traz e com o valor zero os dois são ativados para frente.

→No nosso caso colocaremos zero, pois queremos que o robô ande para frente apenas.

→Conectamos sua entrada NXT à saída NXT do DISPLAY.


Exercício:→ Insira o VI RESET ROTATION da palheta de funções em NXT

I/O >> COMPLETE >> SENSORS.→Ligue sua entrada NXT à saída NXT do VI DISPLAY.→ Insira um MOTOR PORT da palheta de função em NXTO I/O

>> COMPLETE >> MOTORS, escolha a opção ALL PORTS para definir todas as portas e ligue na entrada OUTPUT PORT do VI RESET ROTATION.

→Agora insira duas estruturas WHILE LOOP uma para cada execução.

→Ligue a saída NXT do VI STEERING ON a uma estrutura e a saída NXT do VI RESET ROTATION a outra estrutura.


Estrutura para execução dos movimentos

Estrutura para

obtenção dos dados

dos sensores


Exercício:→ Iremos criar o loop que irá obter os dados dos sensores.→Todos os VIs serão conectados na conexão de entrada da

estrutura de repetição, para que as execução sejam feitas de forma paralela.

→ Sempre teremos uma obtenção de dados e uma gravação na variável correspondente.

→ Insira dois VIs READ ROTATION da palheta de funções NXT I/O >> COMPLETE >> SENSORS.

→ Insira dois MOTOR PORT da palheta de função em NXTO I/O >> COMPLETE >> MOTORS, escolha a porta correspondente para definir a porta e ligue na entrada OUTPUT PORT de cada VI READ ROTATION.

→ Para cada VI indique a porta correspondente.


Exercício:→ Insira uma variável local (escrita – WRITE) para o indicador

numérico de rotação do motor A e ligue na saída do VI correspondente ao motor A.

→ Insira uma variável local (escrita – WRITE) para o indicador numérico de rotação do motor B e ligue na saída do VI correspondente ao motor B.

→Na palheta de funções em NXT I/O >> COMPLETE >> SENSORS insira um VI READ SOND (DBA), um READ LIGTH (LED ON), um READ ULTRASOUND (CM) e um READ TOUTCH (PRESSED).

→ Insira um SENSOR PORT da palheta de funções NXTO I/O >> COMPLETE >> SENSORS para cada VI e defina a porta do sensor.


Exercício:→Coloque uma variável local (escrita – WRITE) para cada VI e as

definam para o indicador correspondente.→Cada indicador que colocamos no painel frontal irá controlar

uma variável dessa.→Ligue cada variável ao seu VI correspondente.→Conecte a conexão STOP da estrutura de repetição na saída do

VI READ TOUCH, para que o loop seja terminado quando o resultado for TRUE.

→Arrume bem os objetos dentro da estrutura de forma que fiquem alinhados pela vertical.

→Liguem a conexão NXT que colocamos na estrutura em cada VI que está dentro da mesma.

→Assim temos uma execução paralela dos VIs inseridos.


Porta utilizada

VI utilizado

Variável utilizada

Conexão para terminar repetição

Obtenção dos sensores


Exercício:→Agora iremos inserir os VIs dentro da estrutura de repetição

ligada a saída NXT do VI STEERING ON.→Esse loop irá controlar as ações de movimento do robô.→Dentro dele teremos duas linhas de execução, uma que irá

mostrar uma mensagem na tela informando que o programa está executando e outra para efetuar os movimentos.

→Vamos criar a que irá controlar o visor primeiro pois é mais simples.

→ Insira um constante string e uma constante numérica.→Na constante string escreva a mensagem desejada, não exagere

muito nos caracteres, pois a tela do robô é pequena.→Na constante numérica defina a linha que deverá aparecer o texto

e defina a representação como inteiro de 16bits I16.


Exercício:→ Insira uma variável local (escrita – WRITE) e a defina para o

indicador string do visor.→Vá na palheta de funções NXT I/O >> COMPLETE >>

DISPLAY e insira um VI TEXT ou insira um VI DISPLAY da categoria NXT I/O e defina como TEXT.

→Ligue a constante numérica na entrada LINE do VI DISPLAY.→Conecte a constante string na entrada TEXT do VI DISPLAY e

na entrada da variável local que corresponde ao display.→ Insira uma nova variável local (leitura – READ) e a defina para o

indicador do sensor de toque, depois conecte-a na entrada STOP da estrutura de repetição para que o loop seja terminado caso receba um valor TRUE.

→ Ligue a conexão NXT na entrada NXT do VI DISPLAY.


Exercício:→ Insira a estrutura de controle CASE STRUCTURE dentro do

WHILE LOOP que controlará as ações de movimento.→Ligue a conexão NXT na estrutura CASE STRUCTURE para

que possamos utilizá-la dentro da estrutura.→ Insira uma constante numérica e uma variável local (leitura –

READ) dentro do loop e fora da estrutura de controle.→ Insira a função lógica LESS? (menor que) e ligue uma entrada na

constante numérica e a outra na variável local.→Defina um valor para a constante, essa constante que definirá o

limite de aproximação dos obstáculos.→Defina a representação da constante como inteiro de 16bits I16.→Agora defina a variável local para o indicador do sensor ultra-

sônico.


Exercício:→A saída da função LESS? conecte na entrada CASE SELECTOR

da estrutura de controle.→ Isso fará com que o robô execute de acordo com o resultado da

comparação, se o resultado for falso ele apenas andará para frente e caso seja verdadeiro ele irá executar uma seres de ações para que possa desviar do obstáculo.

→Mude para a opção FALSE da estrutura de controle CASE STRUCTURE e insira um VI STEERING ON.

→ Insira uma constante numérica para definir a potência do motor e outra para informar qual direção deverá ser tomada.

→Ligue cada constante em sua respectiva entrada no VI STEERING ON, defina a constante STEERING como zero, para que o movimento seja para frente e informe uma potência.


Exercício:→ Insira um MOTOR PORTS, escolha as portas dos motores e

conecte na entrada PORTS do VI STEERING ON.→Conecte a conexão NXT, que vem da estrutura, na entrada NXT

do VI STEERING ON.→Mude a estrutura CASE STRUCTURE para a opção TRUE.→ Insira um VI MOTOR BREAK da palheta de funções NXT I/O

>> COMPLETE >> MOTORS.→ Insira um MOTOR PORT, escolha ALL PORTS e o conecte na

entra PORTS do VI MOTOR BREAK.→ Insira um VI STEERING ON porém a entrada STEERING não

receberá o valor zero. Para valores positivos o primeiro motor é ligado para frente e o outro para traz, para valores negativos o segundo motor é ligado para frente e o outro para traz.


Exercício:→ Insira duas constantes numéricas uma para definir a potência e

outra para definir a direção do movimento.→Ligue as constantes em suas devidas entradas do VI STEERING

ON, POWER e STEERING.→ Para a constante ligada na entrada STEERING você deverá

indicar um valor entre -100 e 100, e ele deverá ser diferente de zero.

→Vamos inserir um tempo de espera para desligarmos os motores.→ Insira um VI WAIT FOR TIME (MSEC) da palheta de funções

em NXT I/O >> COMPLETE >> WAITS.→ Insira uma constante numérica e defina o tempo de espera que

desejamos em milissegundos.→Ligue-a na entrada TIME do VI WAIT FOR TIME (MSEC).


Exercício:→Conecte a saída NXT do VI STEERING ON na entrada NXT do

VI WAIT FOR TIME (MSEC).→ Insira um VI MOTOR BREAK ou copie e cole o anterior,

marque ALL PORTS.→Conecte a saída NXT do VI anterior na entrada do VI MOTOR

BREAK.→Nosso programa está praticamente pronto, porém iremos emitir

uma mensagem informando que o programa terminou.→Mas antes precisamos levar o sinal NXT para fora das estruturas

CASE STRUCTURE e WHILE LOOP.→Ligue a saída dos VIs STEERING ON, da opção FALSE da

estrutura, e MOTOR BREAK, da opção TRUE, no lado direito da estrutura WHILE LOOP.


Conexão NXT para saída do loop

Utilização do visor

Estrutura de controle


Exercício:→ Insira um VI MOTOR BREAK e um MOTOR PORT definido

como ALL PORTS.→Ligue o MOTOR PORT na entrada OUTPUT PORT do VI

MOTOR BREAK.→ Insira um VI DISPLAY definido como TEXT, insira uma

constante numérica para definir a linha a ser usada, insira uma constante string para especificar o texto que deverá aparecer no visor.

→Ligue a constante numérica na entrada LINE do VI DISPLAY e a constante string na entrada TEXT.

→ Insira uma variável local (escrita – WRITE) para o indicador do visor e ligue na constante string.

→Configure os valores das constantes.


Exercício:→Nosso exemplo está quase pronto, precisamos apenas inserir um

VI de espera ao final para que possamos visualizar o que foi mostrado no visor.

→ Se não colocarmos um timer no final o texto do visor irá aparecer muito rápido que não dará tempo de visualizarmos, parecendo que ocorreu algum problema que não mostrou nada.

→ Insira um VI WAIT FOR TIME (SEC) para definirmos um valor em segundos de espera antes de continuar e terminar a execução.

→ Insira uma constante numérica para definir o tempo de espera.→Conecte a constante na entrada TIME do VI.→ Pronto agora temos nosso programa pronto para ser compilado,

enviado e executado pelo Lego.


Final da execução


Exercício:→Com tudo conectado e configurado execute o VI.→Ative o modo de debug no botão HIGHHIGHT EXECUTION do

diagrama de blocos, mas verifique se o robô está conectado ao computador.

→Mude a aquisição de dados dos sensores para o modo seqüencial e verifique o resultado.

→No modo de programação do Lego envie o VI para o robô e execute diretamente dele.

→Modifique os valores das constante numéricas para obter outros resultados.

→Crie outras execuções com outros VIs e execute várias vezes.→Estude como funcionam os VIs do pacote NXT para ter mais

informações.


Resumo→Aprendemos como programar o Lego Mindstorms utilizando o

LabView.→Vimos a utilização de estruturas de repetição e de controle em

nossos VIs.→Aprendemos a debugar nossos códigos diretamente com o robô

conectado ao computador.→Vimos a necessidade de efetuar cada comando para que

tenhamos o resultado desejado.→ Programando o robô temos que definir cada ação a ser executada,

pois ele não executa nada além do que feito para fazer.→Agora podemos exercitar de várias maneiras os conhecimentos

aprendidos.

09 - programando lego mindstorms

Documents