APOSTILA DE SOFTWARE V1 - XBot€¦ · de Ferramentas possui algumas das opções contidas no Menu...

1

APOSTILA DE SOFTWARE V1.1

MARÇO 2012

2

Sumário

Introdução ......................................................................................................................................................... 3

1. Kit Curumim .............................................................................................................................................. 4

2. Instalação do Software Curumim ............................................................................................................. 4

2.1 Instalação do Rádio Base ............................................................................................................... 7 2.2 Instalação do QRCode Enconde ..................................................................................................... 7

3. Software Curumim .................................................................................................................................. 12

3.1. Áreas do Software ....................................................................................................................... 12 3.1.1. Área de Menu e Barra de Ferramentas ....................................................................................... 13 3.1.2. Área de Programação em Blocos ................................................................................................. 14 3.1.3. Utilizando o Software .................................................................................................................. 20 3.1.4. Configurações .............................................................................................................................. 21 3.2. Iniciando a programação ............................................................................................................. 26 3.2.3. Novo Programa ............................................................................................................................ 26 3.2.4. Novo Programa em Blocos .......................................................................................................... 27 3.2.5. Salvar o Programa em Blocos ...................................................................................................... 27 3.2.6. Fechar o Programa em Blocos ..................................................................................................... 28 3.2.7. Abrir o Programa em Blocos ........................................................................................................ 28 3.2.8. Tradução do Programa em Blocos ............................................................................................... 28 3.2.9. Imagem Capturada pela Câmera do Robô................................................................................... 29 3.2.10. Execução de Programa em Blocos ............................................................................................... 30 3.2.11. Novo Programa em C/C++ ........................................................................................................... 30 3.2.12. Salvar o Programa em C/C++ ....................................................................................................... 30 3.2.13. Idioma .......................................................................................................................................... 31 3.2.14. Ajuda ............................................................................................................................................ 31 4. Programando em Visual C++ ....................................................................................................... 31 4.1. Criação de um novo Projeto ........................................................................................................ 31 4.1.1. Configuração do Projeto .............................................................................................................. 31 4.1.2. Programando ............................................................................................................................... 42

5. Integração com Microsoft Robotics Studio ............................................................................................ 54

5.1. Microsoft Robotics Studio ........................................................................................................... 54 5.2. Visual Programming Language(VPL) ............................................................................................ 54 5.2.1. Área Atividades Básicas ............................................................................................................... 56 5.2.2. Área Serviços ............................................................................................................................... 56 5.2.3. Exemplos de uso .......................................................................................................................... 57 5.3. Serviços para o robô Curumim .................................................................................................... 67 5.3.1. Diferencial Motor Curumim......................................................................................................... 67 5.3.2. Rear Motor Curumim................................................................................................................... 73 5.3.3. Sensors Curumim ......................................................................................................................... 77

Anexo A – Entendendo a fundo o QR Code ..................................................................................................... 83

3

Introdução

Com o intuito de promover o desenvolvimento educacional e o aprendizado de conceitos

básicos de lógica por intermédio de um robô, foi elaborado o kit Curumim. Esse kit é constituído

de uma plataforma robótica, o robô Curumim, e um ambiente para programação para esse robô, o

software Curumim.

O software Curumim é o intermediário entre o robô e o usuário. É por meio do software que o

usuário irá conseguir enviar os comandos desejados para a movimentação do robô. Isso é

possível por meio de uma programação em blocos ou linguagem C/C++.

A programação em blocos é formada por um conjunto de blocos que o usuário escolhe um a

um para montar seu programa, o qual envia comandos para o robô para que o mesmo realize as

ações planejadas.

Existem diversos tipos de blocos organizados em delimitadores, de movimentação e

condicionais. Os delimitadores são blocos exclusivamente usados para delimitar o início e o

término de um programa em blocos. Os de movimentação são os que possuem algum comando

de ação para o robô. E, os condicionais são os que fazem a verificação de certa condição para

determinar se outros blocos a eles submetidos serão avaliados e executados ou se serão

desconsiderados.

Dessa forma, ao montar um programa em blocos, o usuário terá que raciocinar quais tipos de

blocos utilizarem e em que ordem “encaixá-los”, além de usar de sua criatividade, para conseguir

alcançar o objetivo pretendido.

O software Curumim ainda possui um “tradutor”' de blocos para C/C++. A cada bloco incluído

em seu programa existe um trecho de código equivalente que vai construindo o programa em

C/C++ respectivo. Esse código disponibilizado ao usuário para que o mesmo possa acessá-lo e

até alterá-lo, trazendo mais um ponto positivo pelo uso do software, pois tal funcionalidade pode

propiciar a familiarização do usuário com a linguagem C/C++.

O usuário ainda tem a sua disposição a câmera do robô que serve para registrar as imagens

feitas durante o percurso executado, retirando fotos e fazendo filmes sempre que o usuário assim

o solicitar.

Para familiarizar o usuário com o software Curumim, este manual registra inicialmente como

deve ser elaborada a instalação do software e em seguida é descrito como o usuário pode

manipular o software, identificando suas funcionalidades disponíveis. É relatado desde a

identificação das telas até o gerenciamento do programa em blocos e em C/C++. Com isso,

espera-se sanar as dúvidas do usuário, de modo que o mesmo possa aproveitar satisfatoriamente

todos os recursos que o software Curumim oferece.

4

1. Kit Curumim

O kit do Curumim é um pacote que se encontra em www.xbot.com.br/externo e que contém os

seguintes arquivos:

1. Java JRE.

2. Codificador QRCode

3. Visual C++ 2005.

4. Driver do Rádio Base

5. Documentação e manual.

6. Setup Curumim.

7. Curumim extra.

OBS: Para acessar www.xbot.com.br/externo utilize:

Usuário: xbot

Senha: 1234xbot

2. Instalação do Software do Curumim

O processo de instalação do software Curumim consiste em seis passos. Tal processo é

orientado por um programa de instalação geralmente empregado em ambientes baseados no

sistema operacional Windows.

Passo 1 : No primeiro passo, execute o arquivo setupSwCurumim.exe . Ao executar tal

arquivo a tela inicial de instalação é apresentada conforme ilustra a Figura 1.

Figura 1 - Tela inicial do processo de instalação.

5

Para continuar a instalação clique no botão Avançar ou Cancelar para finalizar o processo.

Passo2 : É apresentado nesta etapa o Contrato de Licença de Uso, conforme ilustra a Figura

2. Para continuar com o processo de instalação leia atentamente este contrato e em seguida

selecione a opção para aceitar o contrato e clique em Avançar .

Figura 2 – Contrato de Licença de Uso.

Passo 3 : Neste momento é necessário selecionar se é desejado a criação de um ícone na

área de trabalho. A Figura 3 ilustra este passo. Após selecionar clique em Avançar .

Figura 3 – Definir a criação de um ícone na Área de Trabalho.

6

Passo 4 : É apresentado o botão Instalar que iniciará o processo de cópia e configuração

do software Curumim para o computador. A Figura 4 apresenta esta tela.

Figura 4 – Tela de Instalação.

Após o início da operação, uma tela informa o progresso da instalação conforme apresenta a

Figura 5.

Figura 5 - Progresso da instalação.

7

Passo 5 : A Figura 6 apresenta a tela de instalação do MS Visual C++ SP1 Redistributable.

Nesta tela existe a opção de instalar ou não instalar. É sugerido que seja feita a instalação, pois

caso o computador ainda não possua este pacote o software do Curumim não irá funcionar.

Figura 6 – Instalação do MS Visual C++ SP1 Redistributable.

Passo 6 : A Figura 7 apresenta a tela de encerramento do processo de instalação. Nesta tela é

possível iniciar a aplicação instalada recentemente.

Figura 7 - Tela de encerramento da instalação.

Finalizado o processo de instalação, o software Curumim pode ser encontrado no menu

Iniciar da barra de tarefas do sistema operacional Windows

8

2.1 Instalação do Driver do Rádio Base

O Driver do Rádio Base pode ser encontrado em c:/Swcurumim/drivers/Radio Base.rar. O

driver do rádio base nada mais é do que um driver USB – Serial, para instalar basta conectar o

rádio base no computador, irá aparecer uma tela solicitando o driver, selecione para localizar o

driver localmente e insira o caminho da pasta do driver devidamente descompactada.

2.2 Instalação do QrCode Encode

O QrCode Encode é um software que permite codificar um Qrcode. Para realizar a instalação desde software devem-se seguir os passos a seguir: Passo 1: Assim que clicar no ícone de instalação abrirá a primeira tela do instalador, que pode ser

vista na Figura 8 e para prosseguir com a instalação clique em Next .

Figura 8 - Tela inicial da instalação.

Passo 2: A próxima tela que irá aparecer é a tela de configuração do instalador, onde pode-se

selecionar o caminho da instalação assim como selecionar se será instalado para apenas o

9

usuário que está utilizando no momento ou para todos os usuários do computador. Esta tela pode

ser vista na Figura 9 e para dar sequência na instalação clique em Next .

Figura 9 - Tela de configuração da instalação.

Passo 3: Neste passo é apresentada uma tela de confirmação das configurações, como

apresentada na Figura 10. Para confirmar as configurações inseridas e dar continuidade na

instalação clique em Next .

10

Figura 10 - Tela de confirmação da instalação.

Passo 4: Na Figura 11 é apresentada a tela onde o programa esta sendo instalado e assim que é

finalizada é apresentado a tela de finalização na Figura 12, informando que o software foi

instalado e para finalizar clique em Close .

11

Figura 11 - Tela da instalação.

Figura 10 - Tela de encerramento da instalação.

12

3. Software Curumim

3.1 Áreas do Software

Com a finalidade de facilitar a compreensão do software Curumim, pode-se dividir a sua

interface em cinco áreas, de acordo com suas funcionalidades, como é exibido na Figura 8:

Figura 8 - Divisão da interface do software Curumim

A áreas 1 e 2 (Menu e Barra de Ferramentas e Programação em Blocos, respectivamente)

possuem mais detalhes, os quais serão descritos a seguir.

1. Área de Menu e Barra de Ferramentas : o Menu conta com todas as opções gerais

disponíveis do software, desde o gerenciamento dos programas gerados pelo usuários,

assim como configurações, visualizações e ajuda para melhor utilização software. A Barra

de Ferramentas possui algumas das opções contidas no Menu com a finalidade de

servirem de teclas de atalho rápido para as tais opções.

2. Área de Programação em Blocos : conta com duas janelas. A janela de Menu de Blocos

apresenta os blocos disponíveis para a construção do programa que irá controlar o robô.

Existem desde blocos delimitadores de início e término do programa, bem como blocos

com ações diretas para o robô e blocos condicionais (de repetição ou não) que

determinam a execução ou não dos blocos que estão condicionados ao mesmo. A Janela

de Programação em Blocos é o local destinado à construção do programa em blocos.

13

3. Área de Imagem : possui uma janela que exibe a imagem capturada pela câmera do robô.

O usuário pode solicitar sua exibição ou fechamento sempre que quiser, exceto durante a

execução do programa em blocos em que sua exibição é feita automaticamente pelo

software. Caso não exista um dispositivo de vídeo conectado a tela não irá abrir.

4. Área de Programação C/C++ : conta com uma janela que exibe o programa em C/C++,

seja ela a “tradução fiel” do programa em blocos ou a “tradução” acrescida de alterações

realizadas pelo usuário. Também é possível o usuário criar um programa em C/C++ limpo,

sem ter sido criado a partir de qualquer “tradução” de um programa em blocos, entretanto

isso não é recomendado, pois o editor não dispõe de qualquer ferramenta para facilitar a

construção do programa por parte do usuário.

5. Área de Mensagens : possui uma janela que exibe as informações referentes ao resultado

da compilação e linkagem do programa C/C++ ou a indicação de cada bloco executado

pelo robô durante a execução do programa em bloco. Essa janela não é solicitada pelo

usuário, sendo exibidas somente durante as duas situações citadas por ordem do próprio

software.

3.1.1 Área de Menu e Barra de Ferramentas

O Menu do software Curumim está sempre visível, podendo algumas de suas opções estarem

desabilitadas em certos momentos, de acordo com cada situação, durante a execução do

software.

Figura 9 - Opções do Menu do software Curumim

As opções do Menu são separadas em grupos, como ilustrado na Figura 9:

● Arquivo: possui as opções referentes ao gerenciamento dos programas do usuário, como

criar um Novo, Abrir , Salvar ou Fechar um programa, além da opção de Sair do

software Curumim;

● Visualizar: possui as opções de visualizar a imagem gerada pela câmera do robô e a

“tradução” do programa em blocos para C/C++ (programação C/C++ );

● Configurações: esse grupo é uma opção, pois selecionando esse grupo já aciona-se uma

janela com as opções de configuração da comunicação e dos produtos da câmera,

dispensando um sub-menu;

14

● Executar: possui as opções de Compilar um programa C/C++, desde que haja um aberto,

Executar um programa em blocos ou em C/C++ (no caso do programa em C/C++, é

necessário que o programa já esteja compilado para que o mesmo possa ser executado),

Pausar e Parar , desde que haja um programa em blocos em execução;

● Idioma: possui os seguintes idiomas disponíveis para o software Curumim: Espanhol,

Inglês ou Português;

● Ajuda: possui as opções de Ajuda que disponibiliza informações do modo de uso do

software com a finalidade de auxiliar o usuário com suas dúvidas a respeito do software

Curumim e Sobre que exibe informações a respeito do software.

Algumas dessas opções estão disponíveis para acesso rápido na Barra de Ferramentas, como

ilustrado na Figura 10.

Figura 10 - Barra de Ferramentas do software Curumim

3.1.2 Área de Programação em Blocos

A janela de Menu de Blocos e a janela de Programação em blocos trabalham em conjunto,

pois a primeira oferece as opções de blocos para a construção do programa em blocos e a

segunda é a região onde são construídos os programas em blocos.

O Menu de Blocos, Figura 11, possui 11 blocos que, organizados e repetidos, podem gerar os

mais diversos programas para o robô de acordo com a necessidade e criatividade do usuário.

15

Figura 11 - Menu de Blocos

Os blocos de Início e Término do Programa são delimitadores que servem para indicar o

começo e o fim do programa, sendo importantes quando solicitada a “tradução” do programa em

blocos para programa C/C++. São os únicos blocos que só podem ser utilizados uma única vez

em cada programa em blocos.

Os blocos Andar Reto , Rotacionar , Curva e Ativar Motor são blocos de movimento,

ou seja, que envolvem algum comando enviado ao robô para que o mesmo realize uma ação.

Esses blocos possibilitam:

• Andar Reto : ir para frente ou para trás;

• Rotacionar : rotacionar para a direita ou para a esquerda;

• Curva : fazer uma curva a direita para frente, a esquerda para frente, a direita para trás ou

a esquerda para trás;

• Ativar Motor : controlar os motores individualmente;

O bloco Tempo de Espera é um bloco que faz com que o robô permaneça parado, sem

executar qualquer ação, durante um período de tempo.

Os blocos Laço PARA , Laço ENQUANTO e Desvio SE são blocos condicionais que

englobam outros blocos, sendo que a avaliação e execução desses outros blocos dependem da

verificação da condição do bloco condicional em questão. A condição avaliada por cada bloco

condicional é:

• Laço PARA : enquanto o número de vezes determinado para sua repetição não for

ultrapassado, os blocos envolvidos pelo Laço PARA são avaliados e executados;

• Laço ENQUANTO : enquanto a combinação dos sensores escolhidos for verdadeira e o

número máximo de vezes determinado para sua repetição não for ultrapassado, os blocos

envolvidos pelo Laço ENQUANTO são avaliados e executados;

• Desvio SE : se a combinação dos sensores escolhidos for verdadeira, os blocos envolvidos

pelo Desvio SE são avaliados e executados.

Ao inserir qualquer um dos blocos, exceto delimitadores, uma janela com as informações

do bloco é aberta com valores padrões que podem ser alterados pelo usuário:

Andar Reto

16

Figura 12 – Configuração do Bloco Andar Reto

• Direção: indicador da direção a ser seguida pelo robô (frente ou trás);

• Velocidade: indicador da velocidade a ser adotada pelo robô (1 – baixa; 2 – média; 3 –

alta);

• Distância: indicador da distância a ser percorrida pelo robô (1 mm até 99.999 mm);

• Recurso de vídeo: indicador de uso de qual tipo do recurso de vídeo (foto ou nenhum

recurso) durante a execução do bloco.

ATENÇÃO: O valor inserido de distância, pode sofrer variações dependendo do piso em

que o robô esta se movimentando, fazendo com que o robô não execute com precisão o

valor inserido.

Curva

Figura 13 - Configuração do Bloco Curva

• Direção: indicador da direção a ser seguida pelo robô (frente ou trás);

• Lado: indicador do lado a ser seguido pelo robô (direito ou esquerdo);

17

• Abertura: indicador da abertura da curva a ser adotada pelo robô (1 – fechada; 2 – média;

3 – aberta);



Rotacionar

Figura 14 - Configuração do Bloco Rotacinar

• Graus: indicador de quantos graus o robô deve girar (12º até 95º);

• Direção: indicador da direção para a qual o robô deve girar (direita ou esquerda);



ATENÇÃO: O valor inserido de graus, pode sofrer var iações dependendo do piso em

que o robô esta se movimentando, fazendo com que o robô não execute com precisão o

valor inserido.

Ativar Motor :

Figura 15 - Configuração do Bloco Ativar Motor

18

• Motor: indicador de qual dos motores serão utilizados;

• Direção: indicador da direção a ser seguida pelo respectivo motor (no caso do motor A ou

B as opções são frente ou trás e no caso do motor C as opções são direita ou esquerda);

• Velocidade: indicador da velocidade a ser adotada pelo motor (1 – baixa; 2 – média; 3 –

alta);

• Distância: indicador da distância a ser percorrida pelo motor relacionado (1 mm até 99.999

mm);



ATENÇÃO: Os valores inseridos de distância, podem s ofrer variações dependendo do

piso em que o robô esta se movimentando, fazendo co m que o robô não execute com

precisão o valor inserido.

Tempo de Espera :

Figura 16 - Configuração do Bloco Tempo de Espera

• Tempo de espera: tempo que o robô deve ficar parado sem executar qualquer ação (1

segundo até 99 segundos);



Laço PARA :

Figura 17 - Configuração do Bloco Laço PARA

19

• Número de vezes para repetição do laço: indicador do número de vezes que será repetida

a avaliação e execução dos blocos contidos no laço (uma vez até 99 vezes).

Laço ENQUANTO :

Figura 18 - Configuração do Bloco Laço ENQUANTO

● Número máximo de vezes para repetição do laço: indicador do número de vezes máximo

que será repetida a avaliação e execução dos blocos contidos no laço (uma vez até 99

vezes);

● Construção da expressão lógica: botões com as opções disponíveis para a construção da

expressão lógica (5 sensores e operadores lógicos – NOT, AND, OR, NAND e XOR, além

de abre e fecha parênteses) e área de visualização, na qual é montada a expressão lógica.

Desvio SE :

Figura 19 - Configuração do Bloco Desvio SE

● Construção da expressão lógica: botões com as opções disponíveis para a construção da

expressão lógica (5 sensores e operadores lógicos – NOT, AND, OR, NAND e XOR, além

de abre e fecha parênteses) e área de visualização, na qual é montada a expressão lógica.

20

À medida que o usuário for selecionando os blocos que deseja inserir no seu programa, os

mesmos são incluídos na janela de Programação em Blocos, na sequência, ou se preferir,

também pode escolher o local do bloco a ser inserido. Para inserir um bloco onde desejar,

primeiramente clique com o botão direito do mouse, no qual irá aparecer um menu pop-up, em um

bloco mais próximo do lugar onde quer inserir o novo bloco, no menu pop-up que aparecer

escolha se quer inserir antes ou depois desse bloco, selecione o bloco, no menu blocos, que

deseja inserir, defina as configurações do bloco e clique em OK. A figura 20 ilustra os passos

citados acima.

Além disso, o usuário ainda pode alterar os valores dos parâmetros de seus blocos por meio

das janelas já mencionadas e/ou retirar um bloco de seu programa. Com exceção da inserção

sequencial de blocos, as demais funcionalidades mencionadas estão disponíveis no menu pop-up

sendo ele diferenciado de acordo com cada bloco.

3.1.3 Utilizando o Software

Para dar início a execução do software Curumim, o usuário deverá acionar o software por

meio de seu atalho contido em seu Desktop (área de trabalho), no menu programas ou onde ele

determinou durante a instalação do software Curumim.

Acionado o software Curumim, a primeira tela a ser exibida é a de abertura do software. Essa

tela, exibida na Figura 20, contém apenas a apresentação do software Curumim com informações

a seu respeito, como versão, propriedade e patrocínio. O tempo de exibição dessa tela é curto e

em alguns segundos será fechada e, então, aberta a tela principal do software, como ilustrado na

Figura 21.

Figura 20 – Tela exibida na abertura do software

21

Figura 21 – Tela principal do Software

Inicialmente, o usuário deve fazer as configurações de comunicação do software com o robô

por meio da opção Configurações do menu, pois essas configurações são pré-requisitos em

outras funcionalidades do software.

Para uma melhor compreensão de como utilizar o software Curumim, suas funcionalidades

foram separadas em vários tópicos, como: configurações, Novo Programa, Novo Programa em

Blocos, Salvar, Abrir e Fechar um programa em blocos, tradução do programa em blocos para

C/C++, exibição da imagem capturada pelo robô, execução do programa em blocos, novo

programa em C/C++, Salvar, Abrir e Fechar um programa em C/C++, Compilação e Execução do

programa em C/C++ e solicitação de ajuda.

3.1.4 Configurações

Antes que o usuário tenha acesso às funcionalidades principais do software Curumim, é

obrigatório ao usuário fazer a configuração da porta e endereço de origem e destino da

comunicação com o robô, já que sem essas configurações realizadas não seria possível se

comunicar com o robô e o software não funcionaria de acordo com o proposto. O usuário tem

duas opções para acionar a janela de configurações: a opção Configurações no menu e ícone

Configurações na barra de ferramentas.

Assim que selecionada a opção de Configurações , é aberta a janela de configuração. Tal

janela conta com duas abas: Comunicação e Câmera, como ilustrado na Figura 22.

22

Figura 22 - Janela de Configurações de Comunicação e de Câmera

A aba de Comunicação é obrigatória para que o usuário possa ter a sua disposição as

demais funcionalidades do software Curumim. As outras abas de configuração podem ser

preenchidas durante o uso do software, quando solicitado pelo próprio software Curumim ou

quando o usuário desejar.

Nessa aba têm-se campos para o preenchimento adequado da porta serial e endereços de

origem e destino a serem utilizados durante a comunicação com o robô. Inicialmente, o usuário

deve preencher a porta a ser utilizada. Assim que o software Curumim é inicializado ele identifica

as portas seriais disponíveis e as coloca no campo da porta serial como opções, cabendo ao

usuário identificar qual é a utilizada para ligação com o rádio base. Entretanto, isso é válido se o

rádio base já estiver ligado ao computador antes da inicialização do software. Caso contrário, é

necessário clicar no botão Detectar Portas para que o software possa identificá-las e o

usuário selecionar uma no campo Porta Serial . Escolhida a porta serial que será utilizada, o

usuário deve clicar no botão Definir Porta para registrar sua escolha. Na Figura 23 é indicado

os pontos mencionados para a escolha e registro da porta serial.

23

Figura 23 - Localização dos pontos para determinação da porta serial

O próximo passo é a determinação do endereço de origem e destino. O usuário deve pegar o

endereço contido na etiqueta do rádio base e colocar no campo do endereço de origem e pegar o

endereço contido na etiqueta do robô e colocar no campo do endereço de destino e clicar no

botão Definir Endereços para registrar tais endereços. Na Figura 24 são indicados os pontos

mencionados para a escolha e registro dos endereços.

Figura 24 - Localização dos pontos para determinação dos endereços de origem e destino

Registrados os campos, o usuário tem a sua disposição o botão Teste que serve para

verificar se o robô está respondendo ao software, andando um pouco para frente e exibindo uma

24

janela que confirma o funcionamento da comunicação. Caso isso não ocorra, o usuário deve

verificar se os dados da porta serial e endereços estão corretos, se o robô está ligado e, por fim,

se não há nenhum problema técnico com ele, como indicado pela janela que se abre nessa

situação, Figura 26.

Figura 26 - Janela de indicação de falha da comunicação entre software e robô

O usuário não é obrigado a fazer o teste, mas é recomendado que o fizesse para evitar futuros

transtornos por não saber onde está o problema.

Para finalizar, o usuário deve clicar no botão Concluir para que todas as alterações nos

campos sejam confirmadas.

Existem ainda outros dois botões na aba de Comunicação , Limpar que serve para apagar os

valores dos campos de endereços e Cancelar que serve para ignorar as alterações realizadas

nos campos dessa aba.

Na Figura 27 são indicados os botões de Teste , Concluir , Limpar e Cancelar .

Figura 27 - Localização das opções de Teste, Concluir, Limpar e Cancelar

25

Assim que concluir as alterações na configuração da comunicação, o software libera outras

funcionalidades e o usuário já pode criar um novo programa, abrir outro, etc. Durante o uso do

software o usuário pode alterar os dados da comunicação quando quiser, repetindo os passos já

mencionados.

Na aba Câmera o usuário determina o nome padrão para os arquivos de fotos que podem vir

a ser gerados pelo robô durante a execução de seus movimentos. A nomeação dos arquivos de

foto é feita pela junção do nome padrão determinado pelo usuário com uma numeração ordinária

controlada pelo software Curumim. O usuário também pode determinar o local onde as possíveis

fotos serão armazenadas, escolhendo o diretório e suas subpastas. Os campos a serem

preenchidos pelo usuário são identificados na Figura 29 que ainda indica o botão Ok onde o

usuário deverá clicar para armazenar as alterações realizadas.

Figura 29 – Tela de Configuração da Câmera

Para fechar a janela de Configurações , basta o usuário clicar no botão Fechar a Janela

que está sempre visível na parte inferior da mesma, independente da aba à qual se tenha foco,

não esquecendo que o usuário pode voltar a essa mesma janela e fazer as alterações das

informações nela contidas sempre que tiver interesse.

Quando o usuário clicar em Fechar a Janela , caso tenha clicado nos botões Definir

Porta e/ou Definir Endereços , mas não tenha clicado em Concluir , será exibida uma

janela questionando o usuário se o mesmo deseja salvar as alterações feitas para a comunicação.

Caso o usuário clique em Sim, as alterações serão salvas antes de fechar a janela de

configurações. Se clicar em Não, as configurações não serão salvas, sendo apenas fechada a

janela de configurações. Entretanto, se o usuário clicar em Cancelar , nada será efetuado,

continuando a janela de configuração aberta.

26

3.2 Iniciando a programação

3.2.1 Novo Programa

Para iniciar um novo programa, seja ele em blocos ou C/C++, o usuário tem duas opções:

selecionar o ícone de Novo na barra de ferramentas ou selecionar a opção Novo no menu

Arquivo.

Solicitado um novo programa será aberta uma janela em que o usuário deverá identificar o tipo

do programa que deseja criar: em blocos ou em C/C++, como ilustrado na Figura 30.

Figura 30 - Escolha do tipo de programação - em blocos ou em C/C++

Após a escolha entre programação C/C++ ou em blocos o usuário deverá clicar em Ok para

confirmar o interesse na criação do novo programa do tipo escolhido. Caso desista de criar um

novo programa, o usuário deve clicar em Cancelar .

Se, quando o usuário solicitar um novo programa, já houver outro aberto, seja ele em blocos

ou C/C++, é apresentada uma janela que questiona ao usuário o seu interesse em salvar o

programa atual antes de exibir a janela de escolha do tipo de programação para a criação do novo

programa, como ilustrado na Figura 31.

Figura 31 - Questionamento sobre o interesse do usuário em salvar o programa em aberto

Nessa janela, se o usuário clicar em Sim será aberta uma janela para salvar o programa em

questão e posteriormente fechado. Se clicar em Não o programa aberto será fechado sem ser

salvo. Nessas duas situações a sequência das ações segue para a solicitação do tipo do novo

27

programa. Entretanto, se o usuário clicar em Cancelar , a solicitação de novo programa é

desconsiderado e o programa que estava aberto permanece na tela.

3.2.2 Novo Programa em Blocos

Assim que confirmada a solicitação da criação de um programa em blocos serão abertas duas

janelas: a do Menu de Blocos e a da Programação em Blocos, como estão ilustradas na Figura

32. Inicialmente, o usuário deverá inserir o bloco de Início, para que inicie um programa.

Figura 32 - Novo programa em bloco

Após inserir o Bloco Início em seu novo programa, o usuário terá os demais blocos a sua

disposição, exceto o próprio Bloco Início, pois esse só pode ser inserido uma única vez e, como o

próprio nome descreve, no início. O Bloco Término também só pode ser inserido uma única vez e

no final do programa. Os demais blocos podem ser colocados repetidas vezes e em quaisquer

combinações e posições que não seja a primeira e a última.

Caso o usuário não consiga identificar cada um dos blocos do menu, somente pelo desenho, é

possível passar com o mouse por cima de cada um deles para que um hint apareça e mostre a

identificação do bloco.

3.2.3 Salvar o Programa em Blocos

Construído o programa, o usuário pode ter interesse em salvá-lo para posterior execução ou

alteração. Para tanto, o usuário tem duas opções: selecionar o ícone de salvar na barra de

ferramentas ou selecionar a opção Salvar no menu Arquivo .

28

Solicitado salvar o programa, será aberta uma janela em que o usuário deverá nomear seu

programa e determinar o local onde deseja salvar tal programa. Para confirmar o interesse em

salvar o programa, o usuário deve clicar no botão Salvar .

3.2.4 Fechar o Programa em Blocos

Se o usuário quiser fechar o programa e continuar com o software Curumim aberto, basta

clicar na opção Fechar do menu Arquivo .

3.2.5 Abrir o Programa em Blocos

Para abrir um programa o usuário tem duas opções: selecionar o ícone de abrir na barra de

ferramentas ou selecionar a opção Abrir no menu Arquivo .

Com um programa em blocos aberto, o usuário poderá fazer as inclusões, exclusões e

alterações que achar necessárias.

Quando é solicitado abrir outro programa, e se já houver um programa aberto, em blocos ou

C/C++, é apresentada uma janela que questiona ao usuário o seu interesse em salvar o programa

em aberto antes de criar um novo.

Nessa janela, se o usuário clicar em Sim será aberta uma janela para salvar o programa em

questão e posteriormente fechado. Se clicar em Não o programa aberto será fechado sem ser

salvo. Nessas duas situações a sequência das ações segue com a escolha do outro programa a

ser aberto. Entretanto, se o usuário clicar em Cancelar , a solicitação de abrir outro programa é

desconsiderada e o programa que estava aberto permanece na tela.

3.2.6 Tradução do Programa em Blocos

Quando estiver com um programa em blocos aberto, o usuário pode solicitar a visualização de

sua tradução em código C/C++. Para tanto, o usuário deve selecionar a opção Programação

C/C++ no menu Visualizar.

Após a devida seleção, é aberta uma janela, Figura 3.33, que questiona o usuário sobre qual

compilador utilizar para a compilação do programa em C/C++ quando solicitado. Feita a escolha, o

usuário deve clicar no botão Ok para confirmar a escolha ou no botão Cancelar para ignorar a

solicitação de visualização do programa em C/C++.

29

Figura 3.33 - Escolha do compilador a ser utilizado quando solicitado

Caso confirme a operação, é aberta a janela de Programação em C/C++ com o código

equivalente do programa em blocos que está aberto. Esse código foi preparado para o compilador

Microsoft Visual C++ 2005.

O usuário pode alterar o programa em C/C++, entretanto se quiser manter suas alterações é

necessário salvá-lo. Para tanto, estando com o programa em blocos aberto também, é necessário

colocar o foco do software Curumim na janela de programação em C/C++, clicando em qualquer

ponto da mesma. Após colocar o foco na janela de programação C/C++, o usuário pode solicitar

salvar o programa em C/C++ por meio de duas opções: selecionar o ícone de salvar na barra de

ferramentas ou selecionar a opção Salvar no menu Arquivo .




Se o usuário confirmar o interesse por salvar o arquivo em C/C++ então, serão fechadas todas

as janelas que estiverem abertas, exceto a janela da programação C/C++ que permanece aberta

para que o usuário possa continuar a fazer as alterações que desejar.

Caso o usuário não salve suas alterações no programa em C/C++, enquanto o programa em

blocos estiver aberto, vai perder todas as suas alterações no programa C/C++ assim que fizer

qualquer alteração, inclusão ou exclusão no programa em blocos, pois o programa C/C++ é

atualizado a cada mudança no programa em blocos.

3.2.7 Imagem Capturada pela Câmera do Robô

O usuário pode visualizar as imagens capturadas pela câmera do robô, independente de estar

com um programa em blocos ou em C/C++ aberto. Isso é possível por meio da opção Imagem do

menu Visualizar .

Assim que realizada a seleção, é aberta a janela de exibição. Nessa janela será exibida a

imagem que a câmera do robô captura a cada momento. Caso não exista nenhum dispositivo de

vídeo conectado ao computador, esta tela não será exibida, sendo apresentada uma mensagem

dizendo que é necessário conectar um dispositivo de vídeo.

30

3.2.8 Execução de Programa em Blocos

Para executar seu programa em blocos, o usuário possui três opções: selecionar o ícone de

executar na barra de ferramentas, selecionar a opção Executar no menu de mesmo nome ou

pressionar as teclas de atalho CTRL + E.

Logo que se inicia a execução do programa em blocos, é aberta a janela de mensagens que

indicará o início da execução do programa, bem como cada ação realizada pelo robô e a

indicação do término da execução do programa. Após o término da execução do programa, a

janela de mensagens fica aberta, mas o usuário pode fechá-la, sendo a mesma aberta quando for

solicitada novamente a execução de um programa em blocos.

Durante a execução do programa o usuário tem a sua disposição as opções de pausá-lo ou

pará-lo, sendo que se pausá-lo poderá retornar ao ponto de parada seguindo com a execução

normalmente a partir desse ponto, bastando para isso selecionar a execução novamente.

Para pausar, assim como parar a execução, existem três opções: selecionar o ícone de

pausar na barra de ferramentas, selecionar a opção Pausar no menu Executar ou pressionar

as teclas de atalho CTRL + P .

Da mesma forma, o usuário tem três opções para acessar a opção de parar a execução do

programa em blocos: selecionar o ícone de parar na barra de ferramentas, selecionar a opção

Parar no menu Executar ou pressionar as teclas de atalho CTRL + A .

Quando requerida a execução, o robô deve realizar as ações solicitadas. Se o mesmo não

realizá-las pode ser que os endereços de origem e destino possam estar incorretos ou a porta

serial selecionada esteja incorreta. Também pode ser que o robô ou o rádio base não estejam

ligados. Convêm ao usuário fazer essas verificações na janela de configurações e nos

equipamentos para checar esses possíveis problemas.

3.2.9 Novo Programa em C/C++

Assim que confirmada a solicitação da criação de um programa em C/C++, será aberta a

janela de escolha do compilador a ser considerado para o novo programa. Se o usuário clicar em

Cancelar da janela de escolha, a solicitação de um novo programa em C/C++ será ignorada.

Mas, se o usuário clicar em Ok, então será aberto uma janela de programação em C/C++.

3.2.10 Salvar o Programa em C/C++

Da mesma forma como para o programa em blocos, construído o programa em C/C++, o

usuário pode ter interesse em salvá-lo para posterior execução ou alteração. Para tanto, o usuário

tem duas opções: selecionar o ícone de salvar na barra de ferramentas ou selecionar a opção

Salvar no menu Arquivo .

31




3.2.11 Idioma

O software Curumim não está limitado ao idioma português, fornecendo suporte também para

o inglês e o espanhol. Para realizar a troca de idioma, basta o usuário selecionar qual lhe

interessa no menu Idioma . O idioma atualmente em uso é sempre indicado por uma marcação a

sua frente.

3.2.12 Ajuda

Caso o usuário tenha alguma dúvida a respeito do uso do software Curumim, está disponível

uma ajuda (help) com informações sobre todas as ações possíveis ao manipular o software. A

ajuda pode ser acionada selecionando-se a opção Ajuda do menu de mesmo nome.

4 Programando em Visual C++

O robô Curumim, além de ser controlado por seu software, por meio de programação em

blocos, também pode ser controlado em outros ambientes de programação da linguagem C/C++.

Sendo assim, a seguir será apresentado, passo a passo, o que o usuário precisa fazer para

construir e/ou utilizar seu programa que determina ações para o robô no ambiente Visual C++

2005 Express Edition.

4.1 Criação de um novo Projeto

Junto com o software do Curumim, acompanha um projeto já configurado, porém se o

programador quiser criar um novo projeto, a seguir é apresentado o passo a passo da criação e

configuração deste novo projeto que contém as mesmas configurações do projeto que acompanha

o software, no qual pode ser localizado no seguinte caminho: c:/Swcurumim/Programas

Exemplos/VisualC 2005.

4.1.1 Configuração do Projeto

Para realizar a configuração de um novo projeto temos que seguir os seguintes passos:

32

Passo 1. Com o Visual C++ 2005 Express Edition aberto, clique em File, New e Project...,

nessa sequência, como ilustrado na Figura 1.

Figura 1. Solicitando o início de um novo projeto.

Passo 2. Em consequência ao passo 1, a janela New Project será aberta, como exibido na

Figura 2. Como indicado nessa figura, em Project types, escolha Win32 e em Templates selecione

a opção Win32 Console Application, além de preencher os campos Name, com o nome do projeto

desejado, Location, com a localização onde a solução será guardada, e Solution Name, com o

nome que deseja dar a solução. No exemplo apresentado na Figura 2, esses três últimos campos

são preenchidos com os seguintes valores, respectivamente:

• ProjetoCurumimVC

• C:\ProgramasVC

• SoluçãoCurumimVC.

Figura 2. Janela New Projects.

33

Passo 3. A janela Win32 Application Wizard é a próxima a ser exibida, como apresentada

na Figura 3. Ela é composta de dois passos. O primeiro passo é clicar no botão Next.

Figura 3. Janela Console Wizard – Passo 1.

O segundo passo, como indicado na Figura 4, é necessário setar a opção Empty project

em Additional options e concluir clicando no botão Finish.

Figura 4. Janela Console Wizard – Passo 2.

Passo 4. Como pode ser percebido no canto esquerdo da tela do Visual C++, já é possível

verificar a pasta do projeto criado. Agora, tem-se duas opções: criar um novo programa para o

robô Curumim ou então utilizar um programa já construído no software do Curumim por meio da

tradução para a linguagem C/C++ do programa gerado em blocos.

Passo 4A . Supondo que você não tem um programa pronto, você deve clicar com o

34

botão direito do mouse sobre a pasta do projeto, como exibido na Figura 5, ir em Add e, em

seguida, em New Item... para criar um novo programa para o robô.

A janela Add New Item é aberta. Nessa janela você deve selecionar Code em

Visual C++ da opção Categories, do lado esquerdo e da opção Templates, do lado direito, deve

selecionar C++ File (.cpp), além de nomear o programa e indicar onde o mesmo deve ser salvo

(preferencialmente o diretório do projeto que já vem como padrão nesse campo de

preenchimento), como indicado na Figura 6. Para finalizar a criação do programa basta clicar no

botão Add. Será aberto o novo programa vazio para que você possa escrever seu código.

No final deste texto são apresentados os passos a serem realizados para a

construção de um programa para o robô no ambiente Visual C++ 2005 Express Edition.

Figura 5. Adicionando um novo programa em C/C++ para o Curumim.

35

Figura 6. Criando um novo programa em C/C++ para o Curumim.

Passo 4B . Mas, se você já tem um programa pronto para o robô em linguagem

C/C++, você deve clicar com o botão direto do mouse sobre a pasta do projeto, como exibido na

Figura 7, ir em Add e, em seguida, em Existing Item...

Figura 7. Adicionando o programa em C/C++ para o Curumim.

36

Agora você pode abrir seu programa em C/C++. Para tanto, dê um duplo clique em

seu arquivo localizado no lado esquerdo, como é mostrado na Figura 8. Em seguida será aberto o

programa na janela do Visual C++.

Figura 8. Abrindo o programa em C/C++ do robô Curumim.

Passo 5. É necessário adicionar o caminho em que se encontram os arquivos de includes e

também as bibliotecas necessárias para o funcionamento correto dos programas feitos em visual

studio. Para tanto, clique com o botão direto sobre a pasta do projeto e depois em Properties

como é ilustrado na Figura 9.

Figura 9. Acessando a opção Properties do projeto.

37

A janela seguinte a ser apresentada é a Property Pages, Figura 10. Com as opções C/C++

e General selecionadas do lado esquerdo da janela, você deve selecionar a opção Additional

Include Directories e clicar no botão ... que se encontra no final dessa linha. Isso fará com que a

janela Additional Includes Directories seja aberta, como indicado na Figura 11. Você deve clicar no

ícone de criar nova pasta indicado na Figura 11 e adicionar os caminhos descritos abaixo nesta

ordem:

• C:\SwCurumim • C:\SwCurumim\libdecodeqr • C:\SwCurumim\SDK\Include • C:\SwCurumim\VideoInput\bcb_cpp • C:\SwCurumim\VideoInput\bcb_include • C:\SwCurumim\VideoInput\visual_include • C:\SwCurumim\OpenCV\highgui • C:\SwCurumim\OpenCV\highgui\include • C:\SwCurumim\OpenCV\cxcore\include • C:\SwCurumim\OpenCV\cv\include

Figura 10. Janela Property Pages – C/C++ General.

38

Figura 11. Janela Additional Include Directories.

De volta a janela Property Pages, você deve selecionar agora do lado esquerdo da janela

as opções Linker e General, como ilustrado na Figura 12 e escolher a opção Additional Library

Directories. Deve então clicar no botão ... para que a janela Additional Library Directories seja

apresentada. Nessa janela você deve fornecer os seguintes caminhos nesta ordem:

• C:\SwCurumim • C:\SwCurumim\SDK\Lib • C:\SwCurumim\libdecodeqr\Debug • C:\SwCurumim\VideoInput\visual_lib • C:\SwCurumim\VideoInput\bcb_lib • C:\SwCurumim\OpenCV\visual_lib • C:\SwCurumim\OpenCV\bcb_lib

Figura 12. Janela Property Pages – Linker General.

39

Ainda com a opção Linker selecionada do lado esquerdo da janela Property Pages, agora

selecione Input e Additional Dependencies, como ilustrado na Figura 13. Da mesma forma, clique

no botão ... e então será aberta a janela Additional Dependencies, ilustrada na Figura 14, onde

você deve escrever as bibliotecas descritas abaixo:

• comcurumimvc.lib • cv.lib • cxcore.lib • highgui.lib • videoInput.lib • libdecodeqr.lib • ws2_32.lib

Figura 13. Janela Property Pages – Linker Input.

Figura 14. Janela Additional Dependencies.

Passo 6. A próxima etapa é você compilar seu programa. Primeiro salve seu projeto, indo

no menu em File e depois em Save All. Agora, compilá-lo clicando com o botão direito sobre a

pasta do projeto e escolhendo a opção Build, como indicado na Figura 15.

40

Figura 15. Compilando o programa.

Passo 7. A seguir, para fechar as configurações necessárias, você deve pegar o arquivo

compackage.dll no diretório C:\SwCurumim e copiá-lo na pasta debug da pasta do serviço que

você criou logo no começo, no caso no exemplo, C:\ProgramasVC\SoluçãoCurumimVC\debug.

Passo 8. O último passo é a execução de seu programa. Para tanto, basta selecionar a

opção de execução que se encontra no menu de acesso rápido do Visual C++, como indicado na

Figura 16.

Figura 16. Executando o programa.

Como já mencionado no Passo 4, você pode iniciar um programa para o robô diretamente

no ambiente Visual C++ 2005 Express Edition. A seguir, são apresentados os passos que você

deve realizar para a elaboração desse novo programa e na sequência é apresentada uma lista

41

com todos os comandos disponíveis para tanto.

4.1.2 Programando

Passo A. O primeiro passo é a inserção das linhas básicas do programa. As linhas a serem

incluídas, para que se possam utilizar comandos de entrada e saída de dados na tela, são:

• #include <iostream> • #include <fstream>

Passo B. O próximo passo é inserir a linha que permitirá que os comandos do robô possam

ser utilizados no decorrer da programação. A linha que deve ser inserida é:

• #include "comcurumimvc.h"

Passo C. Neste passo devem ser inseridos os includes referentes ao Vídeo, como mostrado a

seguir:

• #include <stdlib.h> • #include <stdio.h> • #include <math.h> • #include <string.h> • #include <wchar.h>

• #include <videoInput.h>

Passo D. Este passo apresenta os includes referentes a utilização do open CV, a seguir são

apresentados os includes:

• #include <cv.h> • #include <cxcore.h>

• #include <highgui.h>

Passo E. Como próximo passo é inserido um include para utilização da leitura de QRCode,

como apresentado a seguir:

• #include <decodeqr.h>

Passo F. Neste passo são inseridos variáveis e uma função para que seja atendida a

aquisição de imagens da câmera, a seguir são apresentados estes itens:

• using namespace std; • IplImage *frame = 0; • IplImage *frame_copy = 0; • IplImage *temp = 0; • IplImage *temp_h = 0; • IplImage *temp_s = 0; • IplImage *temp_v = 0;

• void applyFilterToFrame(IplImage *image);

42

Passo G. Neste passo é inserida a função para fazer a captura de imagens da câmera, esta

função é inserida no início para que assim que necessitar tirar uma foto, basta chamar esta

função. A seguir é apresentada esta função como deve ser inserida:

• void takePhoto(){ /** Variaveis para captura de imagens **/ CvCapture* capture = 0; capture = cvCaptureFromCAM(0); if (capture){ CvCapture *i_capturada = 0; IplImage *i_videoframe = 0; IplImage* img = 0; if (!cvGrabFrame(capture)){ printf( "Imagem não pode ser capturada\n\7" ); exit(0); } else { printf( "Imagem Capturada\n\7" ); } img=cvRetrieveFrame(capture); i_videoframe = cvQueryFrame(capture) ; cvSaveImage( "C:\\SwCurumim\\Foto.bmp" ,img); cvReleaseImage(&frame_copy); cvReleaseCapture(&capture); }

}

Passo H. Neste passo é apresentada a função que é responsável pela leitura do QRCode,

assim como a função de captura de imagens. Esta função é inserida para que seja apenas

solicitada no momento que for necessária a sua utilização. A seguir é apresentada esta função

como deve ser inserida:

• void readQRCode(){ IplImage *src=cvLoadImage( "C:\\SwCurumim\\Foto.bmp" ,1); cvShowImage( "C:\\SwCurumim\\Foto.bmp" ,src); printf( "libdecodeqr version %s\n" ,qr_decoder_version()); QrDecoderHandle decoder=qr_decoder_open(); short stat=qr_decoder_decode_image(decoder,src); printf( "STATUS=%04x\n" ,stat); QrCodeHeader header; if (qr_decoder_get_header(decoder,&header)){ char *buf= new char [header.byte_size+1]; qr_decoder_get_body(decoder,( unsigned char

*)buf,header.byte_size+1); printf( "%s\n" ,buf); } qr_decoder_close(decoder); cvDestroyAllWindows(); cvReleaseImage(&src);

}

OBS: Utilizando esta função é possível ler QRCode apenas da versão 2.

Passo I. Na sequência, deve ser inserida a função principal onde serão programados os

comandos que o robô deve executar. A estrutura dessa função deve ser seguida conforme

43

exemplo a seguir:

• int main(){

}

Passo I. Neste passo deve-se criar uma instância de ComCurumim já determinando a porta

em que se encontra o rádio base. A seguir é apresentada tal linha, note que nesse caso a porta

escolhida é a COM7, mas você deve colocar a que está com seu rádio base.

• ComCurumim *curumim = ComCurumim::instance( "COM7" );

Passo J. O próximo passo é determinar quais são os endereços de origem (rádio base) e de

destino (robô) por meio de setSource e setTarget, respectivamente. A seguir são exibidas as duas

linhas referentes aos endereços, sendo o valor de endereço “06.02.03.00.01” para o rádio base e

"05.0C.01.00.07" para o robô. Esses valores são exemplos e você deverá verificar os endereços

nas etiquetas que se encontram em seu rádio base e em seu robô para preencher corretamente

as linhas.

• curumim->setSource( "06.02.03.00.01" );

• curumim->setTarget( "05.0C.01.00.07" );

Passo K. Após a inclusão das linhas que preparam a comunicação entre computador e robô,

você já pode inserir os comandos diretos para o robô. Um exemplo é o comando que manda o

robô rotacionar que é apresentado a seguir:

• curumim->rotate(curumim->getTarget(),curumim->getSo urce(),-45, 0);

Passo L. Para garantir que todos os comandos serão executados sem serem interrompidos

ou ignorados, é necessário acrescentar o comando waitStopped logo após qualquer comando

direto para o robô, seguindo o exemplo anterior do comando Rotate, vamos apresentar como

ficaria este comando completo com o waitStopped:

• curumim->rotate(curumim->getTarget(),curumim->getSo urce(),-45, 0);

• curumim->waitStopped(curumim->getTarget(),curumim-> getSource());

Passo G. E por fim para finalizar a função principal devem-se inserir as seguintes linhas:

• system( "PAUSE");

• return 0; .

Após tendo visto todos os passos para criação de um programa diretamente no Visual C++

Express 2005, vamos apresentar a seguir, a união de todos os passos mostrando um programa

completo.

44

#include <iostream> #include <fstream> /* Curumim */ #include "comcurumimvc.h" /* VideoInput */ #include <stdlib.h> #include <stdio.h> #include <math.h> #include <string.h> #include <wchar.h> #include <videoInput.h> /* OpenCV */ #include <cv.h> #include <cxcore.h> #include <highgui.h> /* QRCode */ #include <decodeqr.h> using namespace std; IplImage *frame = 0; IplImage *frame_copy = 0; IplImage *temp = 0; IplImage *temp_h = 0; IplImage *temp_s = 0; IplImage *temp_v = 0; void applyFilterToFrame(IplImage *image); void takePhoto(){ /** Variaveis para captura de imagens **/ CvCapture* capture = 0; capture = cvCaptureFromCAM(0); if (capture){ CvCapture *i_capturada = 0; IplImage *i_videoframe = 0; IplImage* img = 0; if (!cvGrabFrame(capture)){ printf( "Imagem não pode ser capturada\n\7" ); exit(0); } else { printf( "Imagem Capturada\n\7" ); } img=cvRetrieveFrame(capture); i_videoframe = cvQueryFrame(capture); cvSaveImage( "C:\\SwCurumim\\Foto.bmp" ,img); cvReleaseImage(&frame_copy); cvReleaseCapture(&capture); } } void readQRCode(){ IplImage *src=cvLoadImage( "C:\\SwCurumim\\Foto.bmp" ,1); cvShowImage( "C:\\SwCurumim\\Foto.bmp" ,src); printf( "libdecodeqr version %s\n" ,qr_decoder_version()); QrDecoderHandle decoder=qr_decoder_open(); short stat=qr_decoder_decode_image(decoder,src); printf( "STATUS=%04x\n" ,stat); QrCodeHeader header; if (qr_decoder_get_header(decoder,&header)){

45

char *buf= new char [header.byte_size+1]; qr_decoder_get_body(decoder,( unsigned char

*)buf,header.byte_size+1); printf( "%s\n" ,buf); } qr_decoder_close(decoder); cvDestroyAllWindows(); cvReleaseImage(&src); } int main() { /** Comunicação com o robô Curumim **/ ComCurumim *curumim = ComCurumim::instance( "COM7" ); curumim->setSource( "06.02.03.00.01" ); curumim->setTarget( "05.0C.01.00.50" ); /** Bloco Rotacionar **/ curumim->rotate(curumim->getTarget(),curumim->get Source(),-45, 0); curumim->waitStopped(curumim->getTarget(),curumim ->getSource()); system( "PAUSE"); return 0; }

A seguir é apresentada a lista de comandos disponíveis para a construção do programa. Para

determinar a direita, esquerda, frente e trás do robô, é preciso que você imagine que está em cima

do robô. Para cada comando listado se encontram, entre parênteses, os tipos de cada parâmetro

solicitado e/ou tipo de seu retorno.

Move

O comando move faz o robô andar com os motores da frente e/ou o motor traseiro. A

assinatura de seu método é:

move ( <endRobo>, <endRbase>, <distDiant>, <distTras>, <velocidade>) ,

onde:

• <endRobo>: endereço do robô (inteiro 8 bits sem sinal);

• <endRbase>: endereço do rádio base (inteiro 8 bits sem sinal);

• <distDiant>: distância a ser percorrida pelos dois motores dianteiros, em milímetros.

Acrescente sinal negativo, caso queira que o robô vá para trás (inteiro);

• <distTras>: distância a ser percorrida pelo motor traseiro, em milímetros. Acrescente

sinal negativo, caso queira que o robô vá para esquerda (inteiro);

• <velocidade>: velocidade a ser assumida pelo(s) motor(es) que é(são) utilizado(s), em

rpm. Os valores utilizados na programação em blocos são: 100, 200 e 300 (inteiro).

Tem como retorno 1 se conseguiu realizar o movimento com sucesso e zero, caso

contrário. Esse comando gera o movimento do bloco Andar Reto (inteiro).

46

Rotate

O comando rotate possibilita ao robô rotacionar para sua esquerda ou direita. A assinatura

de seu método é:

rotate( <endRobo>, <endRbase>, <graus>, <velocidade>) , onde:



• <graus>: quantos graus o robô deve girar. Acrescente sinal negativo, caso queira que o

robô rotacione para direita. Os valores utilizados na programação em blocos são de 12

graus até 95 graus por questões de precisão do movimento por parte do robô (inteiro);

• <velocidade>: velocidade a ser assumida pelo(s) motor(es) que é(são) utilizado(s), em

rpm. O valor utilizado na programação em blocos é 0 (inteiro 8 bits sem sinal).

Tem como retorno 1 se conseguiu realizar o movimento com sucesso e zero, caso

contrário (inteiro). Rotate gera os movimentos do bloco Rotacionar.

Turn

O comando turn permite a manipulação dos três motores em separado, ou seja, é possível

controlar se deseja usar determinado motor e que valores seus parâmetros devem assumir. A

assinatura do método é:

turn( <endRobo>, <endRbase>, <distMEsq>, <distMDir>, <distMTras>,

<velMEsq>, <velMDir>, <velMTras>) , onde:



• <distMEsq>: distância a ser percorrida pelo motor dianteiro esquerdo, em milímetros.


• <distMDir>: distância a ser percorrida pelo motor dianteiro direito, em milímetros.


• <distTras>: distância a ser percorrida pelo motor traseiro, em milímetros. Acrescente

sinal negativo, caso queira que o robô vá para esquerda(inteiro);

• <velMEsq>: velocidade a ser assumida pelo motor dianteiro esquerdo, em rpm. Os

valores utilizados na programação em blocos são 100, 200 e 300. Se você pretende que o

movimento seja para trás, deve acrescentar o sinal negativo no valor da velocidade

(inteiro);

• <velMDir>: velocidade a ser assumida pelo motor dianteiro direito, em rpm. Os valores

utilizados na programação em blocos são 100, 200 e 300. Se você pretende que o

movimento seja para trás, deve acrescentar o sinal negativo no valor da velocidade

(inteiro);

• <velMTras>: velocidade a ser assumida pelo motor traseiro, em rpm. Os valores

47

utilizados na programação em blocos são 100, 200 e 300. Se você pretende que o

movimento seja para a esquerda, deve acrescentar o sinal negativo no valor da velocidade

(inteiro).

Tem como retorno 1 se conseguiu realizar o movimento com sucesso e zero, caso contrário

(inteiro). Com esse comando é possível gerar os movimentos dos blocos Curva e Ativar Motor.

Para o movimento Curva, os valores dos parâmetros da distância e velocidade do motor traseiro

são iguais a zero, enquanto que os valores da distância e da velocidade do motor dianteiro direito

são o dobro ou metade dos valores correspondentes aos do motor dianteiro esquerdo de acordo

com o lado de interesse para que o robô gire, para a esquerda ou direita, respectivamente. Já

para o movimento Ativar Motor, todos os parâmetros são preenchidos com valores diferentes de

zero, além de serem variados, não tem nenhuma relação de valor de um com o outro.

Sleep

O comando sleep é responsável pelo tempo em que nenhum comando é enviado para o

robô, ou seja, serve para que o mesmo fique parado sem fazer qualquer movimento. Sua

assinatura é a seguinte:

sleep( <tempo>) , onde:

• <tempo>: refere-se ao tempo, em milissegundos, que nenhum comando deve ser enviado

ao robô (inteiro sem sinal).

Esse comando é o bloco Tempo de Espera.

WaitStopped

Esse comando é responsável por garantir que o robô não vai pular nenhum dos comandos

a ele enviados. Deve ser sempre utilizado no programa imediatamente antes do comando de

sleep e logo após cada um dos demais comandos de movimento. Sua assinatura é:

waitStopped( <endRobo>, <endRbase>) , onde:


• <endRbase>: endereço do rádio base (inteiro 8 bits sem sinal).

Sensors

Sensors é um comando referente aos sensores, que não tem a função de enviar uma

ordem de movimento, mas sim uma solicitação da situação constatada pelo sensor que foi

escolhido. Sua assinatura é a seguinte:

sensors(<endRobo>, <endRbase>, <sensor>, <distBase>), onde:



48

• <sensor>: refere-se ao sensor (0 -- frontal direito, 1 -- frontal esquerdo, 2 -- traseiro

esquerdo, 3 -- traseiro direito ou 4 -- frontal) do qual deseja-se saber a informação de

presença ou não de obstáculo (inteiro);

• <distBase>: refere-se à distância base a ser considerada para determinar se um

obstáculo está próximo ou não de determinado sensor (inteiro). Ou seja, se o obstáculo

estiver a uma distância menor ou igual a distância base, quer dizer que o obstáculo deve

ser considerado como próximo. Caso contrário, o obstáculo é tido como distante e não é

considerado. O valor utilizado na distância base na programação em blocos é de 300

milímetros.

Esse comando possui um valor de retorno pra indicar se há ou não obstáculo à frente do

sensor escolhido de acordo com o valor da distância base que foi determinado. Ele devolve 1 no

caso de identificação de um obstáculo e zero em caso contrário (inteiro).

SetSource

O comando setSource é o responsável por armazenar o valor do endereço do rádio base.

Sua assinatura é:

setSource( <endRbase>), onde:

• <endRbase>: endereço do rádio base (ponteiro para caracter).

GetSource

O comando getSource é o responsável por recuperar o valor armazenado do endereço do

rádio base. Sua assinatura é:

getSource()

O retorno desse comando é exatamente o endereço do rádio base a ser utilizado pelos

comandos relacionados ao robô (ponteiro para inteiro 8 bits sem sinal).

SetTarget

O comando setTarget é o responsável por armazenar o valor do endereço do robô. Sua

assinatura é:

setTarget( <endRobo>), onde:

• <endRobo>: endereço do robô (ponteiro para caracter).

GetTarget

O comando getTarget é o responsável por recuperar o valor armazenado do endereço do

robô. Sua assinatura é:

getTarget()

O retorno desse comando é exatamente o endereço do robô a ser utilizado pelos

comandos relacionados ao robô (ponteiro para inteiro 8 bits sem sinal).

49

Available

O comando available retorna 1 se a porta estiver disponível para uso e zero se não puder

ser utilizada (inteiro). Sua assinatura é a seguinte:

available()

O usuário deve determinar os valores da porta serial, endereço de origem (rádio base) e

endereço de destino (robô) que são necessários para a comunicação do computador com o robô

e/ou vice-versa. Para tanto, o usuário deve inserir as três próximas linhas:

ComCurumim *c = ComCurumim::instance(“ <PortaSerial>” );

c->setSource(“ <EnderecoRadioBase>” );

c->setTarget(“ <EnderecoRobo>”) ;

Como exemplo de preenchimento dos campos <PortaSerial> , <EnderecoRadioBase> e

<EnderecoRobo> tem-se, respectivamente, os seguintes valores: COM4, 06.02.03.00.01 e

05.0C.01.00.05 .

Com as configurações da comunicação já acertadas, o usuário já pode acrescentar comandos

para o robô. A seguir, serão apresentados os comandos equivalentes de cada bloco.

Andar Reto

Para fazer o robô andar para frente ou para trás, o usuário deve usar o seguinte comando:

c->move(getTarget(), getSource(), <Distancia> , 0, <Velocidade> );

onde:

● <Distancia> -- refere-se a distância, em milímetros, a ser percorrida pelo robô;

● <Velocidade> -- refere-se a velocidade, em rpm, a ser assumida pelo robô. As

velocidades utilizadas na programação em blocos são: 100, 200 e 300.

Observação:

No caso de interesse no movimento para trás, é necessário acrescentar o sinal negativo no

campo da distância.

Rotacionar

Para fazer o robô rotacionar, para direita ou para esquerda, o usuário deve acrescentar o

seguinte comando:

50

c->rotate(getTarget(), getSource(), <Graus> , 0);

onde:

● <Graus> -- refere-se a quantos graus o robô deve rotacionar.

Observação:

No caso de interesse de rotação para a direita, é necessário acrescentar o sinal negativo no

campo de graus.

Curva

Para fazer o robô realizar uma curva para frente ou para trás à direita ou à esquerda, o usuário

deve usar o seguinte comando:

c->turn(getTarget(), getSource(), <DistMEsq> , <DistMDir> , 0,

<VelMEsq> , <VelMDir >, 0);

onde:

● <DistMEsq> -- refere-se a distância, em milímetros, a ser percorrida pelo robô com o

motor lateral esquerdo;

● <DistMDir> -- refere-se a distância, em milímetros, a ser percorrida pelo robô com o

motor lateral direito;

● <VelMEsq> -- refere-se a velocidade, em rpm, a ser assumida pelo motor lateral esquerdo

do robô. As velocidades utilizadas na programação em blocos são: 100 e 200;

● <VelMDir> -- refere-se a velocidade, em rpm, a ser assumida pelo motor lateral direito do

robô. As velocidades utilizadas na programação em blocos são: 100 e 200.

Observações:

● No caso de interesse no movimento para trás, é necessário acrescentar o sinal negativo

nos campos de velocidade;

● Os valores dos campos de distância devem ser proporcionais. Quando a curva for para a

direita, o valor da distância a ser percorrida pelo motor lateral direito deve ser a metade do

valor da distância a ser percorrida pelo motor lateral esquerdo. No caso de curva à

esquerda, a proporção é invertida;

● Os valores dos campos de velocidade devem ser proporcionais também. Quando a curva

for para a direita, a velocidade a ser assumida pelo motor lateral direito deve ser a metade

do valor da velocidade assumida pelo motor lateral esquerdo. No caso de curva à

esquerda, a proporção também é invertida;

51

Ativar Motor

Para o usuário acionar os motores separadamente, deve usar o seguinte comando:

c->turn(getTarget(), getSource(), <DistMEsq> , <DistMDir> , <DistMTras> ,

<VelMEsq> , <VelMDir> , <VelMTras> );

onde:

● <DistMEsq> -- refere-se a distância, em milímetros, a ser percorrida pelo robô com o

motor lateral esquerdo;

● <DistMDir> -- refere-se a distância, em milímetros, a ser percorrida pelo robô com o

motor lateral direito;

● <DistMTras> -- refere-se a distância, em milímetros, a ser percorrida pelo robô com o

motor traseiro;

● <VelMEsq> -- refere-se a velocidade, em rpm, a ser assumida pelo motor lateral esquerdo

do robô. As velocidades utilizadas na programação em blocos são: 100, 200 e 300;

● <VelMDir> -- refere-se a velocidade, em rpm, a ser assumida pelo motor lateral direito do

robô. As velocidades utilizadas na programação em blocos são: 100, 200 e 300;

● <VelMTras> -- refere-se a velocidade, em rpm, a ser assumida pelo motor traseiro do

robô. As velocidades utilizadas na programação em blocos são: 100, 200 e 300.

Observações:

● Havendo interesse no movimento para trás, do motor lateral esquerdo ou direito, é

necessário acrescentar o sinal negativo no campo de velocidade do motor em questão;

● Havendo interesse no movimento para a direita, do motor traseiro, é necessário

acrescentar o sinal negativo no campo de velocidade.

Tempo de Espera

Para fazer o robô ficar parado por um determinado período, o usuário deve acrescentar o

seguinte comando:

c->sleep(<Tempo>);

onde:

● <Tempo> -- refere-se ao tempo, em milissegundos, que o robô deve permanecer parado.

52

Outro comando deve ser sempre utilizado no programa imediatamente antes do comando de

tempo de espera e logo após cada um dos demais comandos de movimento:

c->waitStopped(c->turn(getTarget(), getSource());

Esse comando serve para garantir que o robô não vai pular nenhum dos comandos a ele

enviados.

Existe ainda um comando referente aos sensores, que não tem a função de enviar uma ordem

de movimento, mas sim uma solicitação da situação constatada pelo sensor que desejar. Para

tanto, o usuário deve usar o seguinte comando:

c->sensors(c->turn(getTarget(), getSource(), <Senso r>, <Dist>);

onde:

● <Sensor> -- refere-se ao sensor (0 -- frontal direito, 1 -- frontal esquerdo, 2 -- traseiro

esquerdo, 3 -- traseiro direito ou 4 -- frontal) do qual deseja-se saber a informação de

presença ou não de obstáculo;

● <Dist> -- refere-se à distância base a ser considerada para determinar se um obstáculo

está próximo ou não de determinado sensor. Ou seja, se o obstáculo estiver a uma

distância menor ou igual a distância base, quer dizer que o obstáculo deve ser considerado

como próximo. Caso contrário, o obstáculo é tido como distante e não é considerado. O

valor utilizado da distância base na programação em blocos é de 300 milímetros.

5. Integração com Microsoft Robotics Studio

O robô Curumim, como já apresentado, é controlado por meio de seu software que

disponibiliza uma programação em blocos. Além disso, o robô Curumim também pode ser

controlado por meio de outro software, mais abrangente, desenvolvido pela Microsoft que será

apresentado nos próximos tópicos.

5.1. Microsoft Robotics Studio

Robotics Studio, lançado em 2006 pela Microsoft, é um ambiente gráfico para

desenvolvimento, visualização e simulação de aplicações robóticas. Além disso, ainda conta com

o recurso de controle dos robôs por meio de interfaces via web graças ao “run-time” capaz de

executar as aplicações geradas pelo Robotics Studio. Tem por objetivo não somente o

53

desenvolvimento de softwares para a área acadêmica, mas também para áreas comerciais e de

entretenimento.

Robotics Studio foi elaborado de tal forma que permite a elaboração de programas para robôs

das mais variadas plataformas de hardware. Já é compatível com as aplicações, serviços e robôs

de empresas como CoreWare, iRobot, KUKA Robot Group, the LEGO Group, Parallax,

RoboDynamics, Robosoft, RoboticsConnection, Sensata, Sharp Logic ou Surveyor, entre outras.

Além disso, é possível que outros robôs possam ser controlados via Robotics Studio, desde que

as devidas implementações para isso sejam efetuadas.

A construção de um programa do Robotics Studio é realizada no Visual Programming

Language. Toda a programação é baseada em blocos que representam atividades básicas e

serviços disponíveis.

5.2. Visual Programming Language(VPL)

Visual Programming Language (VPL) é uma linguagem elaborada pela Microsoft para a

construção de programas do Robotics Studio. VPL possui um ambiente onde o usuário, por meio

de blocos que representam atividades básicas e serviços, constrói programas para seu robô. Não

é necessário o usuário ter um robô fisicamente, pois é possível simular o comportamento de um

suposto robô no ambiente VPL.

Com o Microsoft Robotics Studio instalado, o ambiente VPL pode ser encontrado no menu

Inicial da barra de tarefas do Sistema Operacional Windows conforme ilustrado na Figura 5.1.

Figura 5.1 - Menu em que se localiza o VPL

Ao inicializar o VPL, é exibida a janela da Figura 5.2. Essa janela possui as seguintes áreas:

54

Figura 5.2 - Visual Programming Language

● menu : área das opções gerais do software como gerenciamento dos projetos, diagramas,

help, etc;

● diagrama : área onde são montados os programas em blocos para simulação e/ou controle

dos robôs;

● atividades básicas : área onde possui blocos de controle de fluxo de dados, bem como de

dados e variáveis;

● serviços : essa área possui blocos de construção de aplicativos;

● propriedades : área de exibição e alteração das propriedades do item (bloco) selecionado

na área de diagrama;

● projeto : área de identificação dos diagramas e configurações do projeto aberto.

A seguir, serão descritos alguns blocos das áreas de atividades básicas e serviços com mais

detalhes devido a importância de seu conhecimento para a construção dos programas.

5.2.1. Área Atividades Básicas

Variable : esse bloco funciona como uma variável comum de programação. É possível

determinar e recuperar seu valor.

Calculate : faz cálculos aritméticos ou operações lógicas em cima das entradas.

55

Data: é um dado, seja ele booleano, inteiro, decimal, caracter, etc.

Join : recebe dois valores de entrada e os repassa em uma única saída.

Merge : recebe dois ou mais valores de entrada e os repassa.

If: funciona como um IF de programação, recebendo a entrada, avaliando-a de acordo com a

condição determinada e de acordo com o resultado dessa avaliação, como verdadeiro ou falso,

tem a saída correspondente.

Switch : funciona como o Switch de programação, recebendo a entrada, avaliando-a com a

opção correspondente e então determinando que saída seguir.

List : funciona como uma lista de um tipo de item determinado.

List Functions : permite modificar uma lista existente de acordo com uma determinada função

a escolha.

Comment : é um bloco que disponibiliza a inserção de comentário no diagrama. É o único

bloco das atividades básicas que não possui qualquer conexão, seja ela de entrada ou saída.

5.2.2. Área Serviços

Existem diversos serviços, porém aqui somente serão mencionados os de efetivo interesse

para futuro uso do controle do robô Curumim. Caso o usuário queira saber mais informações

sobre os demais blocos de serviços, recomenda-se o acesso à página da Microsoft Robotics

Studio1 e estude os tutoriais a respeito.

Os serviços destacados para serem descritos a seguir são:

Simple Dialog : se trata de uma janela de diálogo simples, como as encontradas em

programação. Pode ser exibida na tela durante a execução do programa em três formatos - Alert

Dialog que seria apenas a exibição do dado de entrada com um botão de Ok para que a janela

seja fechada; Prompt Dialog que exibe uma janela com botões Ok e Cancel, onde o usuário pode

digitar um texto, o qual pode ser enviado para outro bloco por meio da saída do bloco Simple

Dialog ; Confirm Dialog que exibe uma questão ao usuário que concorda (Ok) ou discorda

(Cancel).

Direction Dialog : janela de diálogo para controle de direção que conta com 5 botões - frente,

trás, direita, esquerda e pare.

Timer : tempo em que por um determinado período, o fluxo fica parado até que se termine tal

prazo e o fluxo dos blocos possa ser retomado.

5.2.3. Exemplos de uso

1 http://msdn2.microsoft.com/pt-br/robotics/default(en-us).aspx

56

Para que seja facilitada a compreensão do VPL, são descritos a seguir alguns exemplos de

programas montados com os blocos combinados de atividades básicas e serviços.

Um exemplo bem básico, por ser o primeiro a ser apresentado, é o famoso “Hello World'' ou

“Olá, mundo”. Nesse exemplo é simplesmente exibida na tela uma mensagem com um texto. Para

tanto, no VPL, é necessário dar início a um novo projeto. Com o VPL aberto, clique no menu File,

opção New para a criação de um novo projeto. Agora o ambiente já está pronto para dar início a

um novo programa.

O primeiro bloco a ser inserido é um bloco de atividade básica: Data. Para inserir um bloco na

área de Diagrama basta dar um duplo clique no bloco escolhido, ou clicar e arrastar o mesmo até

o local desejado na área de Diagrama. Inserido o bloco Data, devem ser alterados seus

parâmetros para o pretendido, conter o texto “Olá, mundo”. Dessa forma, deve-se alterar o campo

referente ao tipo de dado a ser armazenado por esse bloco. Clicando no campo que contém a

lista de tipos disponíveis, o usuário deve escolher String, como ilustrado na Figura 5.3.

Figura 5.3 - Alteração do tipo de dado armazenado pelo bloco Data

No campo de texto o usuário deve digitar “Olá, mundo”, passando assim o conteúdo do bloco

Data a ser essa frase, como exibido na Figura 5.4.

57

Figura 5.4 - Alteração do texto a ser armazenado pelo bloco Data

Tendo o dado, o que falta é como exibi-lo na tela. Para isso, é necessário inserir o bloco de

serviço Simple Dialog que é uma caixa de diálogo simples. Após a sua inserção, é necessário

fazer a ligação entre os blocos. O usuário deve procurar posicionar o bloco de serviço do lado

direito do bloco anteriormente incluído, pois a saída do bloco de Data (texto) será a entrada do

bloco Simple Dialog. Então, o usuário deve clicar na saída do bloco Data e segurar até a entrada

do bloco Simple Dialog, formando a ligação, como indicado na Figura 5.5.

Figura 5.5 - Ligação dos blocos Data e Simple Dialog

Assim que o usuário soltar o mouse no ponto de entrada do bloco Simple Dialog, é exibida

uma janela para determinação dos parâmetros dessa ligação, como mostrado na Figura 5.6. A

primeira lista é o parâmetro referente a saída do bloco Data e a segunda lista é o parâmetro

referente a entrada do bloco Simple Dialog. O usuário deve fazer a escolha de cada um dos

parâmetros de acordo com a lista de opções disponíveis e clicar no botão OK, caso contrário a

ligação não é efetuada. Nesse exemplo, para o parâmetro de Data a única opção é DataValue

que fornecerá o valor do texto para o outro bloco e para Simple Dialog a opção escolhida deve ser

Alert Dialog para que a janela seja apenas de informação.

58

Figura 5.6 - Parâmetros da ligação dos blocos Data e Simple Dialog - Connections

Após clicar em OK, é aberta uma nova janela. Essa janela trata dos dados a serem passados

pela ligação. O usuário deve escolher que deseja que a janela de diálogo do outro bloco use o

valor do conteúdo do bloco Data, ou seja, o texto, como indicado na Figura 5.7.

59

Figura 5.7 - Parâmetros da ligação dos blocos Data e Simple Dialog – Data Connections

O programa está pronto. O usuário deve salvar o projeto selecionando a opção Save do menu

File. E, para executá-lo, o usuário deve selecionar a opção Start do menu Run. Se aparecer uma

janela com uma mensagem perguntando se desbloqueia a aplicação, o usuário pode clicar no

botão para desbloquear. A janela do diagrama de blocos montado é uma janela simples com o

texto “Olá, mundo!”, como ilustrado na Figura 5.8. Para fechá-la, basta clicar no botão OK.

Figura 5.8 - Janela do programa “Olá, mundo”

Para finalizar mesmo a execução do programa, é necessário fechar a janela de execução que

foi aberta tão logo se solicitou a execução do programa, como ilustrada na Figura 5.9. Caso

60

contrário, será mantido lixo na memória utilizada pelo VPL, podendo ocasionar erros para os

próximos programas.

Figura 5.9 - Janela de informações da execução

O próximo exemplo, um pouco mais elaborado, está relacionado com o incremento de valores.

Trata-se de uma variável que é devidamente inicializada, acrescida de 1 até o valor 10, sendo que

a cada iteração o seu novo valor é mostrado.

Assim como no exemplo anterior, um novo projeto deve ser criado. Em seguida, o usuário

deve inserir no diagrama um bloco de variável. Agora é necessário definir essa variável, clicando

nos três pontos do canto inferior direito do bloco Variable inserido no diagrama. É apresentada

uma janela com os parâmetros a serem preenchidos para a definição de tal variável. Deve-se

clicar em seu botão Add e então altere o nome da variável de Field para “Teste” e alterar seu tipo

61

para int (inteiro), como é mostrado na Figura 5.10. O usuário também pode alterar os dados da

variável clicando nesses três pontos do bloco Variable.

Figura 5.10 - Inserção do bloco Variable

Definida a variável, é necessário lhe atribuir um valor. Para tanto, deve ser inserido um bloco

Data para determinar um valor. O valor do bloco Data deve ser 1 e seu tipo deve ser int. Então,

deve-se ligar esse valor (saída do bloco Data) com a variável “Teste” (entrada do bloco Variable),

como indicado na Figura 5.11. Será aberta a janela referente aos parâmetros para a ligação

desses dois blocos. Para o bloco Data deve-se selecionar DataValue já que se está interessado

em pegar seu valor e para o bloco Variable deve-se selecionar SetValue, pois esse bloco está

recebendo um valor.

62

Figura 5.11 - Ligação blocos Data e Variable

Como não existe um bloco específico para um laço, tal efeito pode ser obtido por meio da

combinação de outros blocos disponíveis. Assim, o próximo bloco a ser inserido é o Merge, ao

lado direito do bloco Variable. Ele vai servir para montar um contador em laço. O bloco Merge

pode receber mais de uma entrada, sendo seus valores mantidos na saída exatamente como

chegaram. A saída do bloco Variable deve ser ligada à entrada do bloco Merge. O campo texto do

bloco If deve ser alterado para “Teste == 10”, como ilustrado na Figura 5.12.

Figura 5.12 - Ligação blocos Data e Variable

63

O próximo passo é inserir um bloco Calculate onde será feito o acréscimo do valor. Deve ser

inserido ao lado da saída do bloco If e sua ligação será feita com a saída else do bloco If, como

indicando na Figura 5.13. Seu campo texto deve ser preenchido com “Teste + 1”.

Figura 5.13 - Inserção/Ligação bloco Calculate

O valor é acrescentado, mas não foi atualizada a variável. Para sua atualização, um outro

bloco Variable deve ser inserido, mas não para representar outra variável, mas a mesma que já foi

criada. Após sua inserção basta selecionar o mesmo nome da variável anterior que já está contido

na lista de nomes de variáveis, como indicado na Figura 5.14. Sua entrada deve estar ligada a

saída do bloco Calculate. Quando solicitada essa ligação é aberta a janela de ligação entre esses

blocos e para a entrada deve ser selecionado CalculateResult, pois se deseja o resultado da

soma e para a saída deve ser selecionado SetValue, já que a intenção é atualizar o valor da

variável.

Figura 5.14 - Inserção novo bloco Variable

64

Para fechar o looping, deve-se ligar a saída desse último bloco inserido de variável a entrada

do bloco Merge como já está o primeiro bloco Variable. Assim o laço está completo, repetindo-se

até que o valor da variável seja igual a 10, quando o mesmo deixa de realizar qualquer ação, pois

a saída do bloco If não possui nenhuma saída para quando a variável assume esse valor.

Outro exemplo que pode ser montado é o exibido na Figura 5.15. Um bloco que ainda não

havia sido inserido nos exemplos anteriores é o bloco de Switch. Embora o exemplo apenas

mostre duas entradas, é possível adicionar outras para a determinação da próxima função a ser

realizada, bastando clicar no símbolo de mais que se encontra na parte inferior do canto esquerdo

do bloco Switch. O número consultado para saber se é par ou ímpar encontra-se no primeiro bloco

Data, contando da esquerda para a direita. O usuário pode alterar seu valor, executar novamente

o programa e verificar o resultado apresentado pela caixa de diálogo que indica se o número

indicado é par ou ímpar.

Figura 5.15 - Verificação de número par ou ímpar.

5.3. Serviços para o robô Curumim

Para que o robô Curumim pudesse ser controlado pelo Microsoft Robotics Studio, foi

necessária a implementação de alguns serviços: Diferencial Motor Curumim, Rear Motor

Curumim, Sensors Curumim e Tweezer Curumim.

Os arquivos referentes a esses serviços encontram-se no diretório de instalação do Curumim

no diretório Curumim\ServicosCurumim e devem ser copiados para o diretório bin do

Microsoft Robotics Studio. Com os arquivos devidamente copiados no local indicado, os serviços

para o robô Curumim estarão disponibilizados na área de Serviços do Visual Programming

Language (VPL) prontos para serem utilizados.

65

A seguir, os serviços serão descritos para que o usuário se familiarize com cada um deles e

assim possa montar seus próprios programas para controlar o robô Curumim com o VPL.

5.3.1. Diferencial Motor Curumim

Diferencial Motor Curumim é o serviço criado para controlar os dois motores laterais do robô

Curumim, simulando um motor diferencial (motor acoplado a um diferencial mecânico que aciona

duas rodas). Com ele é possível determinar a velocidade, a direção e a distância dos motores

direito e esquerdo individualmente.

Esse serviço conta com sete valores de entrada:

● Serial Port: campo tipo string para recebimento da porta serial;

● Source: campo tipo string para recebimento do endereço do rádio base;

● Target: campo tipo string para recebimento do endereço do robô;

● DmotorRight: campo tipo inteiro para recebimento da distância, em milímetros, a ser

percorrida pelo robô com o motor direito;

● DMotorLeft: campo do tipo inteiro para recebimento da distância, em milímetros, a ser

percorrida pelo robô com o motor esquerdo;

● SMotorRight: campo tipo inteiro para recebimento da velocidade, em rpm (100, 200, 300,

etc), a ser exercida pelo robô com o motor direito, incluindo o sinal negativo caso queira

que o robô se movimente para trás;

● SMotorLeft: campo tipo inteiro para recebimento da velocidade, em rpm (100, 200, 300,

etc), a ser exercida pelo robô com o motor esquerdo, incluindo o sinal negativo caso queira

que o robô se movimente para trás.

Para inserir o bloco do Diferencial Motor Curumim em seu programa, o usuário deve localizá-lo

na área de Serviços, como indicado na Figura 5.16.

66

Figura 5.16 - Localização do serviço Diferencial Motor Curumim

Ao adicionar o bloco no diagrama, o próximo passo é fazer a inserção da atividade Join para

que essa receba todos os valores dos parâmetros de entrada do serviço Diferencial Motor

Curumim e os repasse para o mesmo. Para isso, o usuário deve localizar tal atividade na área das

Atividades Básicas, como ilustrado na Figura 5.17.

Figura 5.17 - Localização da atividade básica Join.

Por padrão, a atividade Join é inserida com dois campos. Entretanto, para o caso em questão

são necessários sete campos, os quais serão as entradas do serviço Diferencial Motor Curumim.

Para isso, é necessário clicar com o botão direito sobre a atividade e solicitar a inserção de mais

elementos até que o número de elementos seja alcançado, como indicado na Figura 5.18.

67

Figura 5.18 - Como aumentar o número de campos da atividade básica Join.

Para facilitar a identificação dos campos, é possível renomeá-los de forma que identifiquem o

seu conteúdo. Assim, o usuário pode trocar os nomes dos campos clicando neles e digitando os

novos nomes, como os sugeridos: msg para PortaSerial, msg0 para EndRadioBase, msg1 para

EndRobo, msg2 para DistMotorDir, msg3 para DistMotorEsq, msg4 para VelMotorDir e msg5 para

VelMotorEsq.

Cada um desses campos da atividade básica Join é uma entrada, mas existe apenas uma

saída dessa atividade. Para cada entrada, o usuário deve inserir uma atividade básica Data para o

dado a ser destino a cada campo de Join e ligar essa atividade à atividade Join inserida. Na

Figura 5.19 são indicados todos as ações feitas para a inserção da atividade Data referente ao

campo PortaSerial de Join. Inicialmente, localiza-se a atividade Data na área de Atividades

Básicas, na sequência é alterado o tipo do dado a ser recebido pela atividade, no caso uma string,

é preenchido seu campo com o valor “COM4” que deve indicar a porta serial que é utilizada para

comunicação do computador com o robô e ligação da saída de Data com a entrada de Join no

campo PortaSerial.

Figura 5.19 - Ligação da atividade Data com a atividade Join.

68

Os dois próximos campos, EndRadioBase e EndRobo, seguem o mesmo esquema que o do

campo PortaSerial, alterando os seus conteúdos para, nesse exemplo, “06.02.03.00.01” e

“05.0C.01.00.05”, respectivamente. Da mesma forma, os campos seguintes são montados, exceto

pelo fato de seu tipo ser int, pois são valores numéricos que envolvem distância e velocidade.

Vale lembrar que valores negativos para as distâncias apenas indicam que o motor vai ser girado

para trás e não para frente. Na Figura 5.20 são mostrados as atividades Data inseridas, bem

como seus tipos determinados, seus valores preenchidos e suas ligações efetuadas.

Figura 5.20 - Ligações das atividades Data com a atividade Join.

Com todos os campos válidos, falta fazer a ligação da saída de Join com a entrada do serviço

Diferencial Motor Curumim. Ao fazer essa ligação é aberta a janela Connections onde o usuário

deve selecionar Replace na coluna To, pois os valores repassados servirão para preencher os

parâmetros de Diferencial Motor Curumim. Após clicar OK para essa janela, outra janela (Data

Connections) será apresentada na tela com valores padrão para cada um dos parâmetros do

serviço. Assim, para cada um dos parâmetros, seu novo valor deverá ser alterado para usar o

69

valor do campo de Join correspondente, como indicado na Figura 5.21 em que é feita essa

escolha no caso do parâmetro SerialPort.

Figura 5.21 - Ligações dos campos de Join com os parâmetros de Diferencial Motor Curumim.

Depois das devidas ligações, o programa está pronto e já pode ser executado, como ilustrado

na Figura 5.22. Nesse programa o robô Curumim vai andar para frente por 30 centímetros com

velocidade de 100 rpm. Caso isso não ocorra, verifique se o robô está ligado, se suas baterias não

estão descarregadas ou mesmo se não foi inserido algum valor incorreto para a porta serial,

endereço do rádio base ou do robô.

70

Figura 5.22 - Programa envolvendo o serviço Diferencial Motor Curumim pronto para ser

executado.

5.3.2. Rear Motor Curumim

Rear Motor Curumim é o serviço responsável pelo motor traseiro do robô Curumim. É possível

determinar a velocidade, a direção e a distância desse motor. Esse serviço possui entradas iguais

aos do serviço Diferencial Motor Curumim, exceto por ter um motor a menos para controlar e sua

direção ser esquerda e direita e não frente e trás.

Os cinco valores de entrada desse serviço são:




● Dy: campo tipo inteiro para recebimento da distância, em milímetros, a ser percorrida pelo

robô com o motor traseiro;

71

● Speed: campo tipo inteiro para recebimento da velocidade, em rpm, a ser exercida pelo

robô com o motor traseiro, incluindo o sinal negativo caso queira que o robô se movimente

para a direita;

Assim como para o Diferencial Motor Curumim, para inserir o bloco do Rear Motor Curumim

em seu programa, o usuário deve localizá-lo na área de Serviços, como exibido na Figura 5.23.

Figura 5.23 - Localização do serviço Rear Motor Curumim.

O próximo passo é a inserção do bloco da atividade Join, localizando-o na área de Atividades

Básicas, como indicado na Figura 5.17, e adicionando-o ao diagrama. É necessário também fazer

a adição de mais três elementos na atividade Join, Figura 5.18, totalizando cinco elementos que

irão corresponder com os cinco parâmetros já mencionados do serviço Rear Motor Curumim. Para

facilitar a identificação dos campos, pode-se renomeá-los como: msg para PortaSerial, msg0 para

EndRadioBase, msg1 para EndRobo, msg2 para Distancia e msg3 para Velocidade. A Figura 5.24

exibe a atividade Join com os novos nomes de seus elementos.

Figura 5.24 - Renomeando os elementos da atividade Join.

Para cada um dos elementos de Join, deve ser inserida uma atividade Data com o valor a ser

transferido. Dessa forma, cinco atividades Data devem ser inseridas e ser ligadas a sua saída a

72

entrada do elemento respectivo de Join com seu valor devidamente preenchido. Na Figura 5.25

são mostradas todas as ligações entre atividades Data e Join.


Falta fazer a ligação entre a saída de Join e a entrada de Rear Motor Curumim. A janela

Connections é apresentada tão logo é feita essa ligação. Nessa janela, o usuário deve escolher

Move na coluna To para que os valores repassados por Join sirvam para preencher os campos do

serviço. Após clicar em OK, a janela Data Connections será aberta. Essa janela possui valor

padrão para cada um dos parâmetros do serviço, os quais devem ser modificados para o

corresponde elemento de Join. Na Figura 5.26 é mostrado os primeiros quatro campos já

modificados e o último referente a velocidade sendo modificado.

73

Figura 5.26 - Ligações dos campos de Join com os parâmetros de Rear Motor Curumim.

Com todas as devidas ligações e preenchimentos feitos, o programa já está pronto, Figura

5.27, para ser executado. Nesse programa, o robô Curumim vai acionar o motor traseiro para a

esquerda por 30 centímetros a uma velocidade de 100 rpm.

Figura 5.27 - Programa envolvendo o serviço Rear Motor Curumim pronto para ser executado.

74

5.3.3. Sensors Curumim

O serviço Sensors Curumim serve para solicitar os sensores do robô. Pode-se determinar de

quais sensores se deseja obter informações.

Esse serviço tem três valores de entrada:




E cinco valores de saída:

● Sensor1: campo tipo inteiro que indica a distância de um possível obstáculo em relação ao

sensor1 (dianteiro direito);


sensor2 (dianteiro esquerdo);


sensor3 (traseiro esquerdo);


sensor4 (traseiro direito);


sensor5 (frontal).

Na área de Serviços o usuário deve localizar Sensors Curumim para inserir o mesmo no

diagrama, como indicado pela Figura 5.28.

Figura 5.28 - Localização do serviço Sensors Curumim.

75

A seguir o usuário deve inserir um bloco de atividade Join, localizando-o na área de Atividades

Básicas, como indicado na Figura 5.29, e adicionando-o ao diagrama. É necessário também fazer

a adição de mais um elemento na atividade Join, Figura 5.30, totalizando três elementos que irão

corresponder com os três parâmetros já mencionados do serviço Sensors Curumim. Para facilitar

a identificação dos campos, pode-se renomeá-los como: msg para PortaSerial, msg0 para

EndRadioBase e msg1 para EndRobo. A Figura 5.29 exibe a atividade Join com os novos nomes

de seus elementos.

Figura 5.29 - Renomeando os elementos da atividade Join.

Para cada um dos elementos de Join, deve ser inserido uma atividade Data com o valor a ser

transferido. Dessa forma, cinco atividades Data devem ser inseridas e ter ligadas a sua saída a

uma entrada do elemento respectivo de Join com seu valor devidamente preenchido. Na Figura

5.30 são mostradas todas as ligações entre atividades Data e Join.


O próximo passo é fazer a ligação entre a saída de Join e a entrada de Sensors Curumim. A

janela Connections é apresentada tão logo é feita essa ligação. Nessa janela, o usuário deve

escolher Measurement na coluna To para que os valores repassados por Join sirvam para

preencher os campos do serviço. Após clicar em OK, a janela Data Connections será aberta. Essa

janela possui valor padrão para cada um dos parâmetros do serviço. Na Figura 5.31 são

mostrados os primeiros três campos que devem ser modificados por seu equivalente em Join.

Deve ser observado que nada deve ser feito com os parâmetros dos sensores, pois esses são

usados como valores de saída.

76

Figura 5.31 - Ligações dos campos de Join com os parâmetros de Sensors Curumim.

Falta serem acrescentados os blocos que irão tratar do resultado dos sensores. Para isso, um

novo bloco do serviço Sensors Curumim deve ser inserido. Quando essa ação for solicitada, uma

janela será aberta questionando o usuário sobre o interesse de criar um novo serviço ou usar

aquele mesmo que já está aberto (o diagrama já possui um bloco desse serviço), como ilustrado

na Figura 5.32. O usuário deve escolher usar o que já está aberto.

Figura 5.32 - Adicionando mais um bloco do serviço Sensors Curumim.

Após essa inserção, o usuário deve acrescentar um bloco de atividade If, como exibido na

Figura 5.33.

77

Figura 5.33 - Localização da atividade básica If.

Agora, a saída de notificação do serviço Sensors Curumim deve ser ligada a entrada da

atividade básica If, como indicado na Figura 5.34.

Figura 5.34 - Indicação para a ligação entre o serviço Sensors Curumim e a atividade básica If.

Assim que for efetuada a ligação, é apresentada a janela Connection em que o usuário deve

selecionar Measurement na coluna From, pois os dados estão vindo do serviço, como indicado na

Figura 5.35.

78

Figura 5.35 - Tipo da conexão entre If e Sensors Curumim.

Na sequência, o usuário coloca a expressão condicional que desejar no bloco da atividade If,

fazendo uso dos resultados dos sensores disponíveis que são apresentados apenas com o clique

no campo de preenchimento de If, conforme ilustrado na Figura 5.36. Um exemplo de expressão

condicional possível seria Sensor1 || Sensor2 .

79

Figura 5.36 - Preenchimento da expressão condicional da atividade básica If.

Existem duas possíveis saídas desse bloco da atividade básica If, dependendo do resultado

da avaliação de expressão condicional segue-se por uma ou pela outra. Se a expressão for

verdadeira, a saída escolhida é a primeira que está logo a frente da expressão. Caso contrário, a

saída escolhida é a segunda que está logo a frente do texto else. Deixa-se a cargo do usuário

montar sua expressão condicional, bem como a sequência de blocos para cada uma das saídas.

80

Anexo A: Entendendo a fundo o QR Code

Vamos começar pelo nome, QR Code vem do inglês Quick Response Code ou Código de

Resposta Rápida, foi criado no Japão por uma empresa subsidiária da Toyota a Denso Wave, em

1994. O QR Code é um dos códigos de duas dimensões mais utilizados, pois uma de

suas características é ser decodificado rápido.

Podemos fazer a leitura do símbolo QR Code utilizando um leitor específico para ele, um

celular com câmera ou um smartphone que rode Symbian OS, Android ou iOS. Ele consiste em

módulos pretos dispostos dentro de um quadrado com um fundo branco.

O uso do QR Code é livre de qualquer licença. “QR Code é aberto para uso e sua patente, pela

Denso-Wave, não é praticada.”

Agora vamos ao que interessa. Primeiro vamos falar da capacidade de armazenamento de

dados do QR Code.

Capacidade de armazenamento do QR

Code

Somente

números

Max. 7,089

caracteres

Alphanumerico Max. 4,296

caracteres

Binary (8 bits) Max. 2,953 bytes

Kanji, full-width

Kana

Max. 1,817

caracteres

Um QR Code deste tamanho pode armazenar mais de 300 caracteres alfanuméricos.

Veja a imagem abaixo, a mesma quantidade de dados que o código de barras de uma

dimensão, podemos guardar no QR Code símbolo, graça a sua possibilidade de armazenar

verticalmente e horizontalmente os dados.

81

Com o QR Code podemos até danificar ou sujar o símbolo que ainda teremos uma leitura dele

veja a tabela abaixo:

Correção de erros:

Nível L 7%

Nível M 15%

Nível Q 25%

Nível H 30%

Ou seja, podemos ter uma perda de 30% do símbolo e ainda conseguimos ter leitura completa

dele.

Podemos ler o símbolo de praticamente qualquer ângulo mesmo com ele distorcido, graças

aos seus marcadores de posição localizados em três cantos do código.

As versões dos símbolos do QR Code variam da versão 1 à versão 40. Cada uma delas tem

uma configuração diferente dos módulos (os módulos são os pontos pretos e brancos que formam

o QR Code).

82

“Configuração do módulo” se refere ao número de módulos que fazem parte de um símbolo,

começando com a versão 1 (21 x 21 módulos) até a versão 40 (177 x 177 módulos). A cada

versão são adicionados 4 módulos por lado.

Cada versão do símbolo QR Code tem seu máximo de capacidade de armazenamento que

varia de acordo com o nível de correção de erros.

Após determinarmos a versão e o tamanho do módulo, o tamanho do Símbolo QR Code pode

ser determinado, porém o símbolo QR Code precisa de uma margem de segurança ou “quiet

zone” onde nada é impresso.

A margem de segurança deve permanecer em branco e respeitar o tamanho de 4 módulos de

largura em todo o perímetro do símbolo.

Por ter padrões especiais de processo de mascaramento, o QR Code está habilitado para ter

células pretas e brancas bem organizadas em uma equilibrada ordem. Para “binalizar” os dados

corretamente que tenham sido lidos, é necessário organizar os módulos brancos e pretos de uma

forma bem equilibrada. Para possibilitar isso, o cálculo EX-OR será implementado entre a área de

dados e máscara padrão modular. Existem oito padrões de máscara. A avaliação será feita para

cada padrão de máscara, e o padrão de máscara com o melhor resultado, juntamente com o

resultado do cálculo EX-OR serão armazenados na área de dados reservada para a máscara.

APOSTILA DE SOFTWARE V1 - XBot€¦ · de Ferramentas possui algumas das opções contidas no Menu...

Documents

Transcript of APOSTILA DE SOFTWARE V1 - XBot€¦ · de Ferramentas possui algumas das opções contidas no Menu...