desenvolvimento de ferramentas computacionais de suporte a...
TRANSCRIPT
Desenvolvimento de ferramentas computacionais de
suporte a plataformas robóticas didáticas
Jorge Pinto Nº20556
Carlos Vicente Nº21280
Trabalho realizado sob a orientação de
Professor José Luís Sousa de Magalhães Lima
Professor Paulo Jorge Pinto Leitão
Engenharia Informática
2011/2012
iii
Desenvolvimento de ferramentas computacionais de
suporte a plataformas robóticas didáticas
Relatório da UC de Projeto
Licenciatura em Engenharia Informática
Escola Superior de Tecnologia e de Gestão
Jorge Pinto, Carlos Vicente
Julho 2012
iv
A Escola Superior de Tecnologia e Gestão não se responsabiliza pelas opiniões expressas
neste relatório.
v
Certifico que li este relatório e que na minha opinião, é adequado no seu
conteúdo e forma como demonstrador do trabalho desenvolvido no
âmbito da UC de Projeto.
___________________________________________
José Luís Lima Orientador
Certifico que li este relatório e que na minha opinião, é adequado no seu
conteúdo e forma como demonstrador do trabalho desenvolvido no
âmbito da UC de Projeto.
___________________________________________
Paulo Jorge Pinto Leitão Co-Orientador
Certifico que li este relatório e que na minha opinião, é adequado no seu
conteúdo e forma como demonstrador do trabalho desenvolvido no
âmbito da UC de Projeto.
___________________________________________
Arguente
Aceite para avaliação da UC de Projeto
vi
vii
Agradecimentos
Em primeiro lugar, queremos agradecer ao nosso orientador, Professor José Lima e ao co-
orientador, Professor Paulo Leitão, pelo o apoio continuo que nos foram dando durante a
elaboração do projeto. Também queremos agradecer às nossas famílias que sem o apoio delas
seria impossível aqui estarmos. E por fim, um agradecimento ao amigos que estiveram
sempre perto e que apoiaram durante o duro percurso que foram estes quatro anos.
A todos, os meus maiores agradecimentos!
viii
ix
Resumo
Perante a necessidade de expandir o conhecimento dos alunos de robótica da ESTIG – IPB,
para áreas inexploradas durante o percurso académico, e diminuir o custo de aquisição de
material didático para o ensino prático da robótica, foi o ponto de partida para o
desenvolvimento de um projeto que pudesse satisfazer estas duas necessidades.
Neste projeto foi construída uma plataforma robotizada móvel, usando material fiável e de
baixo custo. Foi desenvolvido uma aplicação que funciona como controlador de baixo nível,
que realiza a transição de informação entre utilizador e hardware. A transmissão de dados
com o utilizador é feita através do protocolo UDP e com a plataforma robotizada através do
protocolo série. Posteriormente foram concebidas aplicações demos em várias linguagens de
programação que possibilita a utilização da plataforma em múltiplos Sistemas Operativos.
Como resultado deste projeto foi possível deduzir que o custo de aquisição de material foi
drasticamente reduzido, tendo em conta as limitações que as aplicações comerciais possuem.
A plataforma robotizada permite o enriquecimento do conhecimento já adquirido ao longo
dos anos mas também a possibilidade de descobrir e explorar novas linguagens de
programação de forma fácil e divertida para o utilizador. Sendo que a plataforma possui
entradas para sensores, e o controlador está adaptado para a eventual utilização dos mesmos, é
possível a reestruturação da plataforma caso o utilizador deseje utilizar os sensores.
Palavras-chave:
Plataforma didática; Robô didático; Robótica; Educação.
x
xi
Abstract
Given the need to expand students' knowledge of robotics ESTIG - IPB, to areas unexplored
during the academic path, and reduce the cost of purchasing materials for the practical
teaching of robotics, was the starting point for developing a project that could meet these two
needs.
This project purpose was to build a mobile robotic platform, using reliable and low material
cost. We developed an application that works as a low-level controller, which performs the
transition of information between user and hardware. The transmission of data with the user is
made through the UDP protocol and robot platform through serial protocol. Later applications
are designed demos in various programming languages that allow the use of the platform on
multiple OS.
As a result of this project was possible to deduce that the cost of materials has been drastically
reduced, taking into account the limitations that have commercial applications. The robotic
platform allows the enrichment of knowledge already acquired over the years but also the
opportunity to discover and explore new programming languages in a fun and easy for the
user. Since the platform has inputs for sensors, and the controller is adapted to the possible
use of the same, it is possible to restructuring of the platform if user want to use the sensors.
Keywords:
Learning platform; robot teaching; Robotics; Education.
xii
xiii
Conteúdo
1 Introdução .......................................................................................................................... 1
1.1 Enquadramento ............................................................................................................. 1
1.2 Objetivo ......................................................................................................................... 3
1.3 Estrutura do Documento ............................................................................................... 4
2 Robótica Didática .............................................................................................................. 5
2.1 História .......................................................................................................................... 5
2.2 Plataformas Didáticas ................................................................................................... 8 2.2.1 Simuladores ............................................................................................................ 8
2.2.2 Robôs Manipuladores ............................................................................................. 9
2.2.3 Robôs Móveis e Autónomos ................................................................................ 11
2.2.4 Humanóides .......................................................................................................... 17
2.3 Plataformas existentes na ESTIG-IPB ........................................................................ 19
3 Arquiteturas ..................................................................................................................... 21
3.1 Hardware ..................................................................................................................... 22
3.2 Controlador de Baixo Nível ........................................................................................ 23
3.3 YawCam ..................................................................................................................... 23
4 Aplicações Demos ............................................................................................................ 25
4.1 Linguagens de Programação ....................................................................................... 25 4.1.1 Pascal .................................................................................................................... 25 4.1.2 JAVA .................................................................................................................... 26 4.1.3 C# ......................................................................................................................... 27
4.1.4 MATLAB ............................................................................................................. 28
4.2 IDE’s ........................................................................................................................... 28 4.2.1 Lazarus ................................................................................................................. 28 4.2.2 Microsoft Visual C# 2010 Express ...................................................................... 29 4.2.3 Eclipse .................................................................................................................. 29
4.2.4 NetBeans .............................................................................................................. 29
4.3 Protocolos ................................................................................................................... 30
4.3.1 Protocolo UDP ..................................................................................................... 30 4.3.2 Protocolo Série RS-232 ........................................................................................ 30 4.3.3 Comando das Rodas Motrizes .............................................................................. 31
xiv
4.3.4 Receção de Dados do Robô .................................................................................. 31
4.4 Aplicação em Pascal ................................................................................................... 32
4.5 Aplicação em Android ................................................................................................ 33
4.6 Aplicação em C# ......................................................................................................... 33
4.7 Aplicação em Java ...................................................................................................... 33
4.8 Aplicação em MATLAB ............................................................................................. 34
5 Testes................................................................................................................................. 37
5.1 Teste da Aplicação em Android .................................................................................. 37
5.2 Teste da Aplicação em Pascal ..................................................................................... 39
5.3 Demonstração genérica do Controlador de Baixo Nível ............................................ 40
6 Conclusão ......................................................................................................................... 43
6.1 Análise Crítica ............................................................................................................ 43
6.2 Trabalho Futuro .......................................................................................................... 44
A Código do Controlador de Baixo Nível ............................................................................ 1
A Aplicação Demo de Pascal ................................................................................................ 7
A Aplicação Demo de Android ........................................................................................... 15
A.1 PedirIP.java ................................................................................................................. 15
A.2 Controlo.java ............................................................................................................... 16
A.3 UDP.java ..................................................................................................................... 17
A Aplicação Demo de Matlab ............................................................................................. 19
A Aplicação Demo de Java ................................................................................................. 21
A.1 UDP.java ..................................................................................................................... 21
A.2 jfAplicacao.java .......................................................................................................... 22
A Aplicação Demo de C# .................................................................................................... 27
A.1 TemplateDemoCSharp.cs ........................................................................................... 27
xv
Lista de Figuras
Figura 1 – Primeiro Robô Didático ......................................................................................................................... 7 Figura 2 – Simulador RoboCode ............................................................................................................................. 9 Figura 3 – Robô Manipulador criado a partir de componentes do kit bioloides ................................................... 10 Figura 4 – Robô ZUG ........................................................................................................................................... 11 Figura 5 – Um exemplo das muitas montagens possíveis do Mindstorms ............................................................ 13 Figura 6 – Kit Protobot da VEX ........................................................................................................................... 14 Figura 7 – Robô Circular GT ................................................................................................................................ 14 Figura 8 – Programa de Programação visual para o Robô Circular GT ................................................................ 15 Figura 9 – Bot'n Roll ONE C ................................................................................................................................ 16 Figura 10 – NAO, robô da empresa Aldebaran ..................................................................................................... 17 Figura 11 – Exemplo do Robotis Bioloid GP ....................................................................................................... 19 Figura 12 – ABB ................................................................................................................................................... 20 Figura 13 – Modelo Arquitetónico do Projeto ...................................................................................................... 22 Figura 14 – Plataforma Robotizada Didática ........................................................................................................ 23 Figura 15 – Esquema temporal das comunicações ................................................................................................ 32 Figura 16 – Fluxograma da Plataforma Didática .................................................................................................. 35 Figura 17 – Aplicação Demo Android, primeira parte .......................................................................................... 37 Figura 18 – Aplicação Demo Android, segunda parte, juntamente com um exemplo dos eixos X e Y ................ 38 Figura 19 –Aplicação Demo Pascal, primeira parte .............................................................................................. 39 Figura 20 – Aplicação Demo Pascal, segunda parte ............................................................................................. 39 Figura 21 – Controlador de Baixo Nível para aplicações com recetor UDP ......................................................... 40 Figura 22 – Controlador de Baixo Nível com definições para aplicações sem recetor UDP ................................ 41 Figura 23 – Controlador de Baixo Nível, visualização da informação de cada roda ............................................ 42 Figura 24 – Aplicação Demo Matlab .................................................................................................................... 20 Figura 25 – Aplicação Demo em Java, 1ª Janela .................................................................................................. 22 Figura 26 – Aplicação Demo Java, 2ª Janela ........................................................................................................ 26 Figura 27 – Aplicação Demo em C#, 1ª Janela ..................................................................................................... 30 Figura 28 – Aplicação Demo em C#, 2ª Janela ..................................................................................................... 30
xvi
xvii
Lista de Abreviações
IDE – Integrated Devlopment Environment
MIT - Massachusetts Institute of Tecnology
OS – Operating System
PC – Personal Computer
PWM – Pulse width modulation
SO – Sistema Operativo
TCP – Transmission Control Protocol
UDP – User Datagram
xviii
1
Capítulo 1
1 Introdução
1.1 Enquadramento
Este trabalho foi concebido no âmbito do projeto de final de curso de Engenharia Informática,
tendo como orientador professor José Lima e co-orientador professor Paulo Leitão.
O projeto enquadra-se no contexto da robótica, no âmbito dos recursos didáticos. Pretende-se
desenvolver uma plataforma robotizada para apoio didático aos alunos de Robótica da ESTIG
(Escola Superior Tecnológica e Gestão de Bragança). Tendo em vista o enriquecimento de
conhecimentos da área por parte dos alunos da mesma.
A origem da robótica didática tem como pioneiro W.Ross Ashby, tendo desenvolvido vários
trabalhos no âmbito da Cibernética. Posteriormente, Seymour Papert desenvolveu trabalhos
intelectuais com significante relevância na área da robótica didática [1]
.
A robótica didática é uma componente importante para o progresso da aprendizagem por
parte dos alunos, podendo colocar em prática o conhecimento adquirido teoricamente.
Trazendo assim resultados positivos e enriquecedores, já que desenvolve as suas componentes
mentais lógicas e criativas. Por ter uma existência ainda bastante recente a robótica didática
possui barreiras ao nível da aceitação do seu funcionamento, mas que aos poucos vão sendo
superadas. Como refere Papert, “O esboço desta nova disciplina surgira gradualmente, e o
problema de situá-la no contexto da Escola e no ambiente de aprendizagem será melhor
apresentado quando a tivermos na nossa frente. Apresento aqui uma nova definição
preliminar da disciplina, porém apenas como uma semente para discussão, como aquele grão
2
de conhecimento necessário para que uma criança invente (e evidentemente, construa). Se
este grão constituísse a disciplina inteira um nome adequado seria “engenharia de controle”
ou até mesmo “robótica””(Papert, 1994,p.160) [2]
.
O conceito de robótica didática integra-se na teoria de Jean Piaget, que tem como fundamento
a evolução do saber através da interação com o objeto, realizando-se assim a sua própria
aprendizagem, como refere Jean Piaget (1998) “Conhecimento não procede em suas origens
nem de um sujeito consciente de si mesmo, nem de objetos já constituídos do ponto de vista
do sujeito. O conhecimento resultaria de interações que se produzem entre o sujeito e objeto.
A troca inicial entre sujeito/objeto se daria a partir da ação do sujeito. Logo, não existe
conhecimento resultante do simples registro de observações e informações, sem uma
estrutura devida às atividades do próprio sujeito.”
Sintetizando, a robótica didática tem como objetivo levar todos os alunos a procurar respostas
práticas, saindo assim da teoria e colocando em prática todos os conceitos e valores
adquiridos[1]
.
Este projeto surgiu perante algumas necessidades, designadamente:
reduzir o custo na aquisição de material didático (sendo esse sempre num valor
bastante elevado);
A construção de uma plataforma totalmente modular por parte dos utilizadores da
mesma (já que a maioria das plataformas didáticas existentes possui bastantes
restrições em torno da modulação e da utilização da mesma).
Existe um leque bastante vasto de robôs didáticos, para todo tipo de tecnologia robotizada,
como por exemplo para:
Simuladores:
o RoboCode:
Robôs Manipuladores:
o Robô Manipulador Didático baseado em componentes Bioloid.
Robôs móveis e autónomos:
o ZUG;
o Lego Mindstorms;
3
o Robô Circular GT.
Humanóides:
o NAO;
o Robotis Bioloid GP.
1.2 Objetivo
O presente projeto teve por base de desenvolvimento, oferecer aos alunos liberdade de
escolha na linguagem de programação a usar para interagir com a plataforma robotizada.
Criar uma plataforma didática personalizada pela instituição e de baixo custo, que
possibilitará a sua fabricação em série, para posteriormente poder dar apoio didático às aulas
de robótica. O desenvolvimento da plataforma passa por três etapas, sendo elas:
Criação da plataforma robotizada, sendo composta por um par de rodas motorizadas,
uma bateria, um microcontrolador Mbed NXP LPC1768 integrada num sistema de
desenvolvimento e os drivers dos motores.
Proceder a criação de uma aplicação para ser executada no PC, que se situa em cima
da plataforma robotizada. Essa aplicação é quem comunica com o robô e a aplicação
do utilizador. É criada em pascal, através da plataforma de desenvolvimento open-
source Lazarus 0.9.30.4, serve de recetor e redirecionador de informação entre
utilizador e robô.
Criação de várias aplicações exemplares, sendo elas criadas em linguagens de
programação diferentes e funcionais em SO (Sistema Operativo) distintos. Podendo
assim demonstrar o funcionamento da plataforma robotizada através de múltiplos
programas. Sendo todos eles criados exclusivamente para o funcionamento da
plataforma criada no presente projeto.
4
1.3 Estrutura do Documento
Este documento encontra-se estruturado da seguinte forma: o primeiro capítulo apresenta o
enquadramento do presente projeto e o objetivo do trabalho; no segundo capítulo dispõe a
história da robótica didática, disponibiliza também a informação de algumas plataformas
didáticas e as plataformas existentes no Instituto Politécnico de Bragança; no terceiro capítulo
apresenta a arquitetura do hardware e do controlador de baixo nível; no quarto capítulo dispõe
dos protocolos e descreve as principais plataformas e linguagens de programação usadas,
também apresenta as arquiteturas usadas para as aplicações demos; no quinto capítulo
demostra os resultados alcançados; finalmente no sexto capítulo encontra-se uma breve
conclusão do trabalho elaborado.
5
Capítulo 2
2 Robótica Didática
A robótica didática é assim nominada por envolver vários ambientes de aprendizagens, para
que os utilizadores possam criar o seu sistema robotizado. A própria robótica didática pode
ser vista por várias vertentes, podendo ser um simples simulador como também um robô com
os seus requisitos plenos.
O objetivo da robótica didática é desenvolver as capacidades mentais do utilizador, tal como o
seu pensamento lógico sem ter em vista o resultado final, mas sim o caminho percorrido até
que seja realizada uma determinada tarefa [3]
.
2.1 História
A robótica didática surge nos anos 70, com o aparecimento dos computadores nas instituições
escolares. Esse novo método de ensino não teve grande aceitação nos seus primeiros anos de
vida, já que gerou polémicas e discussões sobre o tema do porquê e o como usar
computadores no âmbito escolar, nomeadamente também preocupações com as consequências
que poderiam surgir com o novo método que estava a ser introduzido nas escolas. Para Papert
(1993) [4]
, o surgimento de computadores era um abrir portas para inúmeras ideias, com a
capacidade de dar apoio no ensino e gerar novos conhecimentos [5]
.
6
Symour Papert foi um dos apoiantes à integração da informática no ensino e um dos pioneiros
em projetos desenvolvidos para o âmbito didático, divulgando a utilização da informática
através da linguagem de programação LOGO, tendo essa sido criada no MIT.
LOGO é uma linguagem de programação que permitia simular imagens, formas e comandos,
sendo essa uma ferramenta que conseguia envolver varias áreas de estudo. Por ser de fácil
manuseamento era possível que qualquer pessoa de todas as idades interagisse programando e
criando os seus próprios programas [4]
. Como refere Papert (1985), “Programar, na visão do
autor significa nada mais, nada menos, comunicar-se com o computador, numa linguagem
que tanto ele quanto o homem podem entender” [5]
.
Papert defende que o pensamento e a aprendizagem de cada humano podem ser afetados
perante as ferramentas mecânicas, dado que a aprendizagem por essa via obriga a utilização
da criatividade, reflexão e a otimização das ideias de cada um. Assim cada aluno torna-se
criador do seu próprio conhecimento, podendo desenvolve-lo com o uso do computador,
sendo que anteriormente só tinham acesso a recursos teóricos [5]
.
Nos anos 80, Papert criou a nominada “Tartaruga” utilizando a programação da linguagem
LOGO, sendo assim possível manipulá-la. Era um robô móvel que permitia às crianças o
desenvolvimento do conhecimento através do seu próprio corpo para conseguir entender os
movimentos da Tartaruga. Com o surgimento dos PC a Tartaruga deu lugar a Tartaruga
virtual, podendo assim visualizar os movimentos da mesma no ecrã do PC. Sendo assim,
Papert juntamente com uma equipa de investigadores do MIT criam o ambiente de
programação LOGO onde inserem a Tartaruga virtual, podendo dar a oportunidade para que
os alunos tenham uma mais rápida resposta, se o seu raciocínio logico está correto ou errado
[6].
7
Figura 1 – Primeiro Robô Didático
Em meados dos anos 80, Papert começa a desistir do projeto Tartaruga, tanto virtual como
mecânico, já que esses não têm qualquer impacto nas vidas das crianças, e começou a pensar
numa forma de introduzir a cibernética nas mesmas. Para tal juntou a linguagem de
programação LOGO aos brinquedos da bem conhecida marca LEGO.
A robótica didática é dividida em dois métodos distintos, sendo eles, o método
constitrucionismo e o método instrucionista, ambos idealizados por Papert.
O método constitrucionismo descreve a aprendizagem com uma participação ativa da parte
dos alunos, sendo esse, o construtor do seu próprio conhecimento por via da interação com o
software do próprio equipamento. O aluno programando os robôs diadátios estará a
desenvolver o seu próprio conhecimento através do erro e do êxito que o seu programa terá
perante os seus resultados [5]
.
O método instrucionista está relacionado somente com a transmissão de informação para os
alunos. Neste caso o computador assume a posição de ensinar o aluno, sendo que o
aperfeiçoamento do ensino por esta via consiste em melhorar as técnicas de transmissão da
informação e acompanhar as instruções da utilização dos softwares contidos nos
equipamentos [5]
.
Hoje em dia a metodologia usada na robótica didática continua a ser a mesma, seguindo assim
o mesmo conceito desde da sua criação. O método constitrucionismo é o mais usado, já que
este obriga a colocar em prática o conhecimento adquirido nas teóricas. Para ajudar e apoiar a
evolução e a integração da robótica didática nas escolas e universidades, foram criados vários
concursos nacionais e internacionais de robótica que funciona como um chamamento
interessante para os alunos de todas as idades. Um dos principais eventos nacional é o Festival
8
Nacional de Robótica, que junta estudantes de todas as idades. Contendo várias modalidades
como FreeBots, Condução Autónoma, Futebol Robótico, Robot@fatory, Dança, Busca e
Salvamento.
O Festival Nacional de Robótica desafia colocando à prova os conhecimentos que os alunos
têm vindo a adquirir ao longo dos anos expondo em prática o conhecimento teórico. O evento
mais importante da robótica a nível internacional é o RoboCup, que em tudo se assemelha ao
Festival Nacional de Robótica, embora tenha outras competições.
2.2 Plataformas Didáticas
Existe uma ampla variedade de plataformas didáticas desde de simuladores computacionais
até robôs manipuladores, móveis e humanóides. As maiorias delas são especializadas numa
única e específica plataforma, mas existem excepções em que podem ser multiplataformas,
como por exemplo, ser robô móvel mas também robô humanóide dependendo da montagem
que é feita.
2.2.1 Simuladores
RoboCode:
O projeto RoboCode teve início no ano 2000 pelas mãos de Matthew A. Nelson.
Sendo um simulador didático cujo objetivo é criar um robô tanque de guerra para
enfrentar outros robôs, sendo que os confrontos são executados em tempo real no
simulador.
“Construir o melhor, destruir o resto!”, Este é o lema do simulador RoboCode. Esse
lema reflete bem o objetivo do simulador, já que foi concebido para que qualquer
utilizador pudesse aprender a programar, sendo possível programar os tanques em
Java mas também em C# e Scala.
Por ser o simulador de fácil compreensão, tornou-se uma plataforma cuja sua
usabilidade em universidades, como em escolas tenha sido cada vez mais frequente.
Isso para que a integração dos alunos no ensino da programação e também no ensino
da inteligência artificial, seja feito de modo divertido e simples.
9
Figura 2 – Simulador RoboCode
Sendo uma aplicação open-source permite o acesso a qualquer pessoa que esteja
interessado em adquirir o simulador. Já que o RoboCode foi concebido em Java o que
possibilita a sua execução em qualquer sistema operativo, desde de Windows, Linux,
MacOS e Unix [7]
.
Preço: Gratuito.
2.2.2 Robôs Manipuladores
Robô Manipulador Didático Baseado em Componentes Bioloid (Projeto IPB):
Este projeto foi concebido por um aluno do Instituto Politécnico de Bragança no
âmbito do mestrado do mesmo. O braço mecânico pode ser controlado através de
múltiplas linguagens de programação, como por exemplos temos as linguagens C,
C++, C#, JAVA e MATLAB. A possibilidade de programar o robô em várias
linguagens, surge pelo facto da plataforma ter sido construída através da plataforma
Bioloid que fornece bibliotecas de acesso aos servos [8]
.
10
Figura 3 – Robô Manipulador criado a partir de componentes do kit bioloides
Características:
o Quatro graus de Liberdade, acionados por quatro servomotores Dynamixel
AX-12;
o Abrir/Fechar garra, acionados por dois motores Dynamixel AX-12;
o Dimensão máxima de objeto para garra são 5cm;
o Alcance: 18,2 cm;
o Velocidade dos atuadores: de 0 a 114 rpm;
o Peso aproximado de 550gr;
o Rotação dos atuadores: -150º: 150º;
o Consumo de corrente de 0,4A em repouso e de aproximadamente 2,5A
máximo.
Preço: Não Comercializado.
11
2.2.3 Robôs Móveis e Autónomos
ZUG:
O ZUG é um robô concebido para a utilização de crianças a partir dos 10 anos de
idade, porém pode ser utilizado por pessoas de faixa etária maior, já que é usado por
alunos do ensino superior. O ZUG é usado para desenvolver a programação e o
raciocínio lógico de cada utilizador [9]
.
Figura 4 – Robô ZUG
Características:
o Comprimento: 175 mm;
o Largura: 145 mm;
o Altura: 75 mm;
o Peso: 250 g (sem pilhas);
o Alimentação: 6 pilhas AA;
o Entrada para fonte externa 9 a 12v;
o Software Basic (Incluído no CD);
o Requer porta serial RS 232 no computador.
Sensores:
o Sensor de toque frontal 220º;
12
o Sensor de luz ambiente 180º;
o Sensor de laser;
o Sensor de cores;
o Sensor de som para comando verbal.
Potenciais Clientes:
o Jovens acima de 10 anos;
o Escolas de informática;
o Colégios com ensino fundamental e médio;
o Escolas técnicas;
o Faculdades e Universidades.
Preço: sob consulta.
Lego Mindstorms NXT 2.0:
O Lego Mindstorms NXT 2.0 é uma plataforma produzida pela LEGO, sendo que o
seu conceito é baseado na elaboração de múltiplas plataformas através da
possibilidade de montagem e remontagem de robôs, sendo que a sua estrutura é toda
ela construída com peças de encaixe.
O interesse da LEGO pela robótica didática surge nos anos 80 com a criação do
departamento de educação do grupo em parceria com o MIT. Os produtos da LEGO
são usados em universidades como também em escolas já que os seus produtos
possibilitam a aprendizagem a alunos de todas as idades.
O NXT 2.0 possui um software que proporciona a programação do robô através de
blocos, em ambiente gráfico, possibilitando a programação do mesmo por utilizadores
menos experientes. A plataforma permite também ser programada em C#, C, C++,
Java, Pyton, Ruby e Matlab, sendo essas as principais linguagens que possibilitam
programar o Mindstorms NXT 2.0 [5] [4]
.
13
Figura 5 – Um exemplo das muitas montagens possíveis do Mindstorms
Características:
o NXT LEGO tijolo possui um microprocessador de 32 bits, 4 portas de entradas,
3 portas de saída, Bluetooth e USB;
o Três servomotores interactivos;
o 1 Sensor ultra-sónico;
o 2 Sensores de toque;
o 1 Sensor de cor que permite distingue cores, configurações de luz e funciona
como uma lâmpada;
o CD do software.
Preço:289.95€.
Protobot robot Kit:
A plataforma Protobot robot Kit foi concebida pela VEX, sendo um modelo base para outros
pacotes robotizados que a VEX possui para escolas. O Classroom Lab Kit with Cortex é um
exemplo disso, já que é um pacote para aulas didáticas [10]
.
Características:
o 4 2-Wire Motor 269;
o 4 Motor Controller 29;
o 1 Robot AA Battery Holder.
14
Figura 6 – Kit Protobot da VEX
Preço: 179.99€
Robô Circular GT:
O Circular GT tem como grande vantagem a oportunidade de programar em diferentes
linguagens de programação, sendo que também possui a hipótese de ser programado
num ambiente gráfico já confecionado para o devido efeito, sendo que esse é incluído
no kit no ato da sua compra. A particularidade mais saliente deste robô é a
possibilidade de possuir vários tipos de sensores.
Figura 7 – Robô Circular GT
Para a programação de baixo nível, existe a aplicação MPLAB, que pode ser adquirida
na página web da Microchip, sendo que este usa uma linguagem bastante semelhante
ao Assembly.
15
Para a programação de alto nível, o kit inclui a aplicação desenvolvida pela IdMind,
sendo que nesta aplicação o programador só terá que estruturar um conjunto de blocos,
para que este seja construído devidamente estruturado para realizar as tarefas
desejadas pelo programador [11]
.
Figura 8 – Programa de Programação visual para o Robô Circular GT
Características:
o Microcontrolador PIC 16F876A;
o Interface para 7 sensores analógicos;
o Interface de porta Série para PC;
o Interface Digital extra (3 portos I/O);
o Interface Analógico extra (4 entradas analógicas);
o Software para programação.
Sensores:
o Motores com redução 15:1;
o 7 Pares emissores e recetores de Infravermelhos;
o 2 Sensores de contacto (micro-switches);
o Rodas.
Preço: 254.10€.
16
Bot’n Roll ONE C:
O Bot’nRoll ONE C é um robô móvel, bastante semelhante com a plataforma
robotizada criada neste projeto, já que permite desenvolver as capacidades dos mais
experientes, mas também, possibilita os iniciantes na programação desenvolver os
seus conhecimentos de forma fácil e divertida.
Esta plataforma possibilita a sua programação em duas linguagens de programação, C
e Basic, sendo que para programar na linguagem C pode ser usado a ferramenta
MPLAB e a da lingugem BASIC é usado a ferramenta PICAXE.
É possível adicionar peças à plataforma, já que inclui entradas para as mesmas. O robô
é disponibilizado por peças, sendo que a montagem é toda ela realizada pelo utilizador
[12].
Figura 9 – Bot'n Roll ONE C
o Processador a 32Mhz: PICAXE 40X2;
o Programação em BASIC e PIC18F4520 para programação em C:
o Barramento I2C;
o Conector USB: para programação em BASIC e comunicação série
o Deteção de obstáculos por infravermelhos;
o 9 Entradas analógicas;
o 4 Entradas/saídas digitais;
o Dois motores 12VDC a 250rpm;
o Duas rodas motrizes;
17
o Uma roda fixa;
o Bateria: Ni-MH AA 9,6V 800mAh;
o Receptáculo para inserção de um LCD;
o Dimensões: 205 x 220 x 90 (mm);
o Massa: 1050g.
Preço: 175€.
2.2.4 Humanóides
NAO:
O NAO é um robot humanóide criado pela empresa francesa ALDEBARAN, liderada
por Bruno Maisonnier. O NAO é um componente educativo perfeito que permite a
todo o tipo de aluno de evoluir no campo da robótica.
Para utilizadores menos experientes é disponibilizado uma plataforma gráfica
chamada Chorégraphe, sendo que esta permite a fácil adaptação ao NAO, sem
necessitar de saber programar. Para utilizadores mais experientes existe a
possibilidade de programar o NAO em múltiplas linguagens através do kit de
desenvolvimento do software [13]
.
Figura 10 – NAO, robô da empresa Aldebaran
18
Características:
o Altura: 58,5 cm;
o Peso: 4,3 kl;
o Autonomia: 90 minutos;
o CPU: Intel Atom 1.6GHz;
o Controlado em Linux;
o SO Compatíveis: Windows, MacOS, Linux;
o Linguagens Programáveis: C, C++, C#, JAVA, MATLAB, Urbi, Pyton;
o Visão: 2 câmaras HD 1280*960;
o Liberdade de movimentos até 25 graus;
o Conexão: Ethernet, Wi-Fi.
Preço: Sob Consulta.
Robotis Bioloid GP:
O Robotis Bioloid GP é considerado o melhor robô humanóide com servos. Possui os
movimentos basicos de um humanóide, permitindo desenpenhar taréfas como jogar
futebol ou fazer combates. Possui uma excelente mobilidade, permitindo-o caminhar a
uma velocidade rezoavelmente elevada e também mudar de direção a uma velocidade
mais reduzida[9]
.
19
Figura 11 – Exemplo do Robotis Bioloid GP
Características:
o Servos de alta qualidade Dynamixel AX-18F;
o Estrutura em alumínio muito leve e resistente;
o Correcção automática da posição utilizando um sensor giroscópico;
o Conjunto de garra e sensores incluídos;
o Controlo remoto sem fios incluído;
o Software de programação Roboplus;
o Comunicação digital com os dispositivos servomotores ligados em Daisy
Chain.
Preço:2.520.00€
2.3 Plataformas existentes na ESTIG-IPB
A ESTIG possui múltiplas plataformas didáticas para o acompanhamento das aulas práticas
de robótica de diversos cursos existentes na instituição. Apesar do elevado custo de algumas
plataformas a ESTIG consegue concentrar esforços para o recrutamento de material didático
para uma maior evolução no terreno da robótica e programação dos seus alunos.
20
A instituição possui nas suas instalações um ABB, sendo esse um robô comercial é usado na
ESTIG com finalidade educativa. Permite a programação do mesmo para que esse execute
múltiplas tarefas. O objetivo principal do ensino com o ABB é aprender a programar por
estados, movendo peças de um ponto X ao ponto Y e vice-versa de forma repetitiva. Para este
género de tarefa a ESTIG também possui o Robô Manipulador Didático, tendo este, sido
construído por um aluno de Mestrado da própria instituição como foi referido anteriormente.
Esta plataforma de baixo custo e de fácil montagem, possibilitando à instituição replicá-la de
forma a ser usada nas aulas por grupos de alunos.
Figura 12 – ABB
Para os alunos poderem aprender a interagir com múltiplos sensores, a escola possui vários
robôs LEGO MINDSTORMS, já que esse possui alguma variedade de sensores que permite a
interação com o meio ambiente em que se está a trabalhar. Para tal, as atividades lúdicas
realizadas com essa plataforma são o labirinto, a condução autónoma e o futebol.
Perante o elevado custo financeiro que certas plataformas necessitam para serem adquiridas,
torna-se de todo impossível à instituição a aquisição das mesmas. Por esse motivo, a que uma
das finalidades deste projeto é a minimização do custo de produção, para possibilitar maior
diversidade no ensino da robótica na instituição, através da robótica didática.
21
Capítulo 3
3 Arquiteturas
Relativamente à arquitetura da aplicação essa passou por várias alterações, perante os
métodos de desenvolvimento que se usaria na mesma. Um dos métodos usados durante parte
do tempo de desenvolvimento da aplicação foi a criação de uma DLL (Dynamic-link library),
que possibilitar-nos-ia de programar aplicações para a plataforma através de qualquer
linguagem de programação que usasse a própria livraria, criada para o efeito. Uma
imperfeição, e a razão por qual fez-nos optar por outra alternativa, foi o facto de a DLL ser
limitada ao SO Microsoft Windows, criando assim um restringimento para qualquer utilizador
que queira usar a plataforma através de qualquer outro SO. Perante essa limitação foi
desenvolvido uma aplicação que permite que a plataforma seja manuseada por utilizadores de
vários tipos de dispositivos e de qualquer SO. Tendo esse fator em consideração, decidiu-se
criar uma aplicação que comunicasse via UDP ( User Datagram Protocol), usando assim a
tecnologia WIFI (wireless). Assim sendo, o controlador de baixo nível da plataforma poderá
interagir sem qualquer problema com qualquer outra aplicação que usa a tecnologia UDP
desde que esse tenha dispositivo WIFI.
Perante essas circunstâncias, este projeto foi dividido em três partes fundamentais, o
Hardware, Controlador de baixo nível e as aplicações demonstrativos denominadas como
aplicação do utilizador.
22
Figura 13 – Modelo Arquitetónico do Projeto
3.1 Hardware
Para o Hardware do robô em questão, tivemos o cuidado de criar uma plataforma simples e
eficaz, com controlo total, facilidade de montagem e principalmente de custo reduzido.
Podendo assim criar facilmente múltiplas réplicas de baixo custo para a instituição,
concretizando assim um dos objetivos fundamentais na criação do projeto. O hardware da
plataforma robotizada esta equipada com um PC em que corre o controlador de baixo nível,
sendo esta a peça chave deste projeto, com uma câmara ligada ao PC que transmite a
informação que está a ser visualizada pela plataforma via YawCam, sendo esse uma aplicação
open-source para visualização de imagem através de TCP (Transmission Control Protocol).
O Mbed contém um programa de baixo nível reprogramável que recebe toda a informação
processada e enviada pela aplicação do PC da plataforma, informação fornecida através de um
cabo USB (Universal Serial Bus) que implementa protocolo série. O Mbed está integrado
num sistema de desenvolvimento que se interliga aos drives dos motores que por sua vez são
ligados às rodas motorizadas. Neste projeto só foi usado as rodas motorizadas como motores
da plataforma, mas para projetos futuros a plataforma pode integrar alguns mais componentes
que recebam ou enviam informação desejada pelo utilizador.
23
Figura 14 – Plataforma Robotizada Didática
3.2 Controlador de Baixo Nível
A aplicação principal do nosso projeto foi desenvolvida em linguagem Pascal na plataforma
Lazarus 0.9.30.4. A sua principal funcionalidade é fazer a transmissão de informação entre
utilizador e robô, através dos protocolos UDP e Série. Essa aplicação é bastante eficaz já que
recebe e envia toda a informação que lhe é transmitida, fazendo com que ela seja só um ponto
de passagem, mas fundamental para o bom funcionamento da plataforma, sem essa aplicação
não teríamos modo de comunicar remotamente entre utilizador e a plataforma robotizada.
Através do protocolo UDP que lhe é implementado qualquer aparelho ligado remotamente ao
PC da plataforma poderá comunicar sem problema ao controlador de baixo nível, desde que
esse possui uma aplicação para o devido efeito.
3.3 YawCam
O YawCam é um software open-source escrito na linguagem de programação JAVA. O
propósito deste software é possibilitar aos utilizadores remotos o acesso em tempo real a uma
câmara que esteja conectada ao próprio software.
É um software simples e de fácil utilização, sendo que tem vários modos de funcionamento.
Permite ao utilizador transmitir imagens da câmara via http, Stream e FTP. Também contém
24
um sistema de deteção de movimento através da opção Motion, sendo que vai guardando
imagens sempre que reconhece movimento.
O programa possui também múltiplas opções podendo seleccionar a câmara a qual se deseja
conetar, sendo que também é possível alterar a qualidade das imagens a ser processada, o
texto, como também imagens que aparece na visão do utilizador. É possível criar utilizadores
com palavras-chave que permite restringir o acesso à visualização das imagens aos
utilizadores criados.
No projeto em causa, o software YawCam é usado no PC da plataforma robotizada para
transmitir as imagens da câmara que visualiza a perspetiva do robô. A transmissão de imagens
para os utilizadores da plataforma é feita através de Streaming. O acesso a essas imagens é
feito num browser, ligando-se ao IP do PC da plataforma juntamente com a porta 8081
(ex:127.0.0.1:8081), sendo a porta predefinida pelo programa, podendo ser alterado se assim
se desejar [14]
.
25
Capítulo 4
4 Aplicações Demos
Para aplicações do Utilizador, decidiu-se criar várias aplicações demos em linguagens de
programação diferentes. Para realizar demonstrações de modo a comprovar o bom
desempenho da aplicação principal com qualquer aplicação desenvolvida, em diferentes estas
plataformas e linguagens de programação.
Para as várias demos criadas foram usadas métodos de implementação e de concepção para
demonstrar a diversificação de metodologias que podem ser usadas para controlar a
plataforma, mas todas com o mesmo objetivo e com um único controlo, sendo esse das rodas
motorizadas.
4.1 Linguagens de Programação
4.1.1 Pascal
Pascal é uma linguagem de programação criada em 1969 por um professor do Instituto
Politécnico Federal de Zurique na Suíça, chamado Niklaus Wirth. O nome Pascal teve como
objetivo homenagear um célebre filósofo e matemático Blaise Pascal, tendo esse inventado
uma calculadora que era capaz de fazer quatro operações aritméticas e tinha capacidade de
suportar números até 109-1, isso já no ano de 1644.
26
A linguagem de programação Pascal faz parte da família nominada por “tipo Algol”, por ser
uma linguagem cuja descendência vem da linguagem de programação Algol-60. Algo-60 foi
criada nos anos 1958 até 1960, por um grupo de cientistas na continuação da recém criada
linguagem de programação FORTRAN, tendo essa aparecido em 1957. A linguagem
FORTRAN ainda hoje em dia é usada, mas numa versão mais recente, enquanto a linguagem
ALGO-60 por mais que tenha sido descontinuada foi uma programação que deixou as suas
marcas, pela base das suas ideias implementadas na altura, sendo que ainda hoje são usadas
por muitas linguagens de programação que dela derivam.
Em 1974 a linguagem Pascal foi sujeita a uma reestruturação, sendo a partir dessa data que a
linguagem tornou-se famosa de tal forma que começaram a surgir múltiplas variantes da
mesma. Mas o enorme número de variantes proporcionou problemas graves, já que quase
impossibilitava a portabilidade de programas, caso esses não fossem sujeitos a uma
reestruturação profunda para adequar à variante usada no computador em que o programa
tinha sido importado. Para tal, em 1983 a organização ISSO concebeu uma normalização
Pascal, para que o problema das variantes fosse resolvido.
A linguagem Pascal foi durante muitos anos considerada a melhor linguagem de programação
para aprender a programar, tendo sido usada na maioria das universidades. Hoje em dia o
mesmo já não acontece, mas continua a ter na mesma muitos adeptos no setor de
aprendizagem, já que continua a ser a melhor escolha nessa área [15]
.
4.1.2 JAVA
O projeto JAVA teve o seu início nos anos 90, quando um grupo da Sun intencionava criar
PC inteligentes, perante esta vontade a Sun tentou criar uma plataforma de desenvolvimento
em C++ que pudesse ser aplicável em múltiplos equipamentos. Porem este projeto não obteve
o êxito desejado, já que a linguagem usada criava certas restrições ao complexo projeto.
Perante essa situação o coordenador do projeto, James Gosling, optou por desenvolver uma
linguagem de programação de raiz para poder executar todos os seus objetivos do projeto. O
objetivo inicial que era a criação de PC inteligentes foi abandonado pelo elevado custo que
este trazia. O grande impacto da linguagem de programação JAVA surgiu mais tarde aquando
da expensão da internet. Tendo surgido necessidades de existir tecnologia que possibilitasse a
27
comunicação entre plataformas diferentes. Assim nasceu JAVA baseada na linguagem criada
do projeto inicial da Sun.
JAVA é uma linguagem de programação orientada a objetos, simples e robusta. A JAVA, tal
como C#, é considerada uma linguagem aperfeiçoada de C++. Sendo que retira algumas
possibilidades de erros vulgares cometidos pelo utilizador que programa em C++. A JAVA
gere automaticamente a memória, impossibilita o programador de aceder a posições de
memórias específicas, sendo que é a própria linguagem que processa a alocação e libertação
de memória.
A grande vantagem da linguagem de programação JAVA sob as outras linguagens orientadas
a objetos é a possibilidade de ser usada em todo o tipo de plataforma. Sendo assim qualquer
programa criado em JAVA numa plataforma poderá ser executado ou até reprogramado
noutra plataforma. Essa funcionalidade é caracterizada por “write once, run any where”, isso é
possível acontecer através da Java Virtual Machine. Sendo que essa interpreta o programa
criado em Java[16]
.
4.1.3 C#
C# foi criada em 2000 por uma equipa liderada por Anders Hejlsberg, para dar suporte à
plataforma Framework.Net desenvolvida pela Microsoft. Tendo esta profundas semelhanças
com C++ e Java, já que a mesma foi designada como evolução da linguagem C.
É uma linguagem de programação orientadas por objetos fortemente tipada, possuindo
interfaces, espaços de nomes, aceita sobrecarga de operadores, excepções e gere
automaticamente a memória.
Tem como funcionalidades, a separação perante referências e tipos de valores para obter um
aproveitamento mais adequado da memória. Já traz integrado um suporte para propriedades,
faz passagem de parâmetros por referência e parâmetros de saída, todos os dados derivam de
objetos e existe a possibilidade de definir eventos e delgados.
C# lê-se C Sharp, e acolheu esse nome por inspiração musical, sendo “C” representativo da
nota Dó, e “#” representa o sustenido. Isto para por C# um patamar acima na evolução perante
a linguagem já existente C++ [17]
.
28
4.1.4 MATLAB
É uma ferramenta interativa orientada à execução de tarefas que envolvem cálculos
numéricos. Permite solucionar problemas computacionais de uma forma bastante simples e
rápida. Utiliza uma linguagem de programação própria mas também aceita outras linguagens
de programação como C, Fortran e Pascal. Fornece um ambiente bastante completo, com um
vasto conjunto de funções como também boas capacidades gráficas, todas elas estruturadas e
organizadas perante áreas científicas. A versatilidade das funções desta ferramenta facilita em
muito a aplicação de conceitos para problemas de engenharia no âmbito real, como também
de matemática e ciências.
As caraterísticas desta ferramenta torna numa das aplicações mais usadas e conceituadas por
parte de investigadores e estudantes das áreas científicas e engenharia [18]
.
4.2 IDE’s
4.2.1 Lazarus
Lazarus é um IDE Open-Source para programadores em linguagem de programação Pascal,
sendo também compatível com a linguagem Delphi, que usa o código de compilador do
FreePascal.
Esta plataforma é compatível com vários SO como por exemplo Windows, MacOS e Linux.
Sendo ela open-source permite facilmente aumentar o leque de funcionalidades da mesma.
Exemplo disso é o pacote 5dpo que usamos neste projeto, foi concebido por alunos e
professores da Faculdade de Engenharia da Universidade do Porto.
A Lazarus usa componentes e classes que permite o bom funcionamento em qualquer
plataforma, isso torna-se possível com s LCL (Lazarus Compunent Library). Também existe a
possibilidade de integrar bases de dados aos programas criados em Lazarus, já que esse possui
suporte para vários programas como MySql, MSSQL, SQlite, PosterSQL, DBase e Interbase
[19] [20].
29
4.2.2 Microsoft Visual C# 2010 Express
Visual C# 2010 Express é uma IDE que pertence à Mircosoft, sendo essa uma ferramenta
gratuita e poderosa e ao mesmo tempo simplificada e fácil de usar para programadores
Windows. Foi concebida no sentido de facilitar a aprendizagem para estudantes, podendo
também ser usada por qualquer outro programador. É da família do Visual Studio 2010
Express, sendo o Visual C# uma versão reduzida da mesma. Pode ser usada para o
desenvolvimento de aplicações de nível básico e avançado que corram sobre a
Framework.NET.
4.2.3 Eclipse
Eclipse é uma IDE que nos possibilita a programação em linguagem JAVA. O seu surgimento
teve início em 2001 quando líderes de várias indústrias como a IBM, Borland, Webgain e
mais alguns consórcios criaram o eclipse.org.
No início de 2004, foi anunciado uma reestruturação da Eclipse, tornando assim a Eclipse
numa corporação sem fins lucrativos e open-source. A Elipse Foundation é financiada por
membros da própria fundação, sendo que essa emprega profissionais a tempo inteiro para
poder prestar os serviços necessários para à comunidade da Eclipse. O desenvolvimento da
plataforma não possui programadores, sendo que esse trabalho é feito por trabalhadores
independentes que se voluntariam como também pessoas contratadas por organizações.
A comunidade Eclipse disponibiliza de forma grátis o código fonte da plataforma através da
Eclipse Public License. Com a evolução da plataforma foram criados plugins que possibilita o
desenvolvimento noutras linguagens de programação como C, C++, ColdFusion e Pyton[21]
.
4.2.4 NetBeans
O NetBeans é um IDE (Integrated Development Environment ) gratuito e de código aberto
para os programadores de linguagens como Java, C, C++, PHP, Groovy, Ruby, entre outras.
Como o NetBeans é implementado em Java pode ser executado em muitos sistemas
30
operativos, como Windows, Linux, Solaris e MacOS. O NetBeans fornece uma base sólida
para a criação de projetos, possui um grande conjunto de bibliotecas, módulos e API´s
(Application Program Interface, um conjunto de rotinas, protocolos e ferramentas para a
construção de aplicativos de software) além de uma documentação vasta inclusive em
português bem organizada, estas ferramentas auxiliam o programador de forma a desenvolver
o seu software de maneira mais rápida.
4.3 Protocolos
Para o bom funcionamento da plataforma didática foi necessário a utilização de vários
protocolos de comunicação, desde da transmissão de dados entre os diversos dispositivos
usados, comunicação que permite o andamento das rodas motorizadas e a receção da
velocidade das mesmas.
4.3.1 Protocolo UDP
O UDP é um protocolo da camada de transporte, no que diz respeito aos protocolos da
Internet. O protocolo UDP só se dedica a envia a informação para o destinatário escolhido,
sendo que esse não tem nenhuma forma de saber se essa informação foi bem recebida na parte
do recetor. Este protocolo é usado para a transição de dados entre aplicação demo e o
controlador de baixo nível.
4.3.2 Protocolo Série RS-232
O Serial RS-232 é um protocolo da camada Física, no que diz respeito aos protocolos da
Internet. O protocolo Serial RS-232 usa um conjunto de bits para o envio de carateres, sendo
que usa um bit de início e um bit para o fim, no meio destes dois bits está contida a
informação desejada a transmitir. No caso do projeto em causa este protocolo é usado para
fazer a comunicação de dados entre o controlador de baixo nível e o Mbed.
31
4.3.3 Comando das Rodas Motrizes
O envio da informação para as rodas motorizadas é feita através do seguinte comando
*Velocidade,Direção#, sendo que a velocidade e a direção são dois inteiros que podem tomar
o valor de 0 a 255. Na velocidade o valor 255 atribui a velocidade máxima dianteira do robô,
sendo que o 0 atribui o valor máximo em marcha atrás possível. O estado parado é definido
com o valor 128 na primeira variável (Ex: *128,128#).
O comando das rodas é acionada de diferentes formas dependendo da formatação de cada
programa, mas sempre com o mesmo código predefinido.
Quando a informação é rececionada no MBed, esta é regenerada de forma a que seja
transformada em roda esquerda e roda direita.
4.3.4 Receção de Dados do Robô
A informação vinda do robô é recebida da seguinte forma:
*RE1, RE2, RE3, RE4, RD1, RD2, RD3, RD4, SE, SD#.
Sendo que os RE são parâmetros da roda esquerda, RD parâmetros da roda direita e os dois
últimos SE e SD são de possíveis sensores que podem ser aplicados em projetos futuros. Com
a informação recebida através dos parâmetros da roda esquerda e roda direita é possível
calcular as suas velocidades com a seguinte fórmula:
Velocidade da Roda Esquerda = RE1 SHL(8*3)+RE2 SHL(8*2)+RE3 SHL(8)+RE4.
32
Figura 15 – Esquema temporal das comunicações
4.4 Aplicação em Pascal
Foi concebida uma aplicação na mesma linguagem de programação da aplicação principal
deste projeto, tendo essa sido programada em Pascal, como já referido anteriormente. Os
motores das rodas são dirigidas através de dois “ScrollBar”, sendo um para velocidade e outro
para direcção. Para controlo total da plataforma é necessário uma página web para visualizar
as imagens transmitidas, que é automaticamente aberta após efetuada a ligação à plataforma,
juntamente com a sessão dos comandos da aplicação para o controlo remoto da mesma. Essa
aplicação também possui receptor de dados, sendo esses dos movimentos das rodas, para a
visualização dos mesmos existe uma “TextBox” onde é inserida a informação. A velocidade
das rodas é visualizada em duas “ProgressBar”.
33
4.5 Aplicação em Android
Na aplicação para SO Android foram usadas as linguagens JAVA e XML para a formatação
do conteúdo da aplicação, tendo sido programada na plataforma Eclipse. Essa aplicação
controla as rodas da plataforma a partir dos sensores acelerómetros do aparelho em causa, e a
visualização das imagens fornecidas pela câmara do robô é realizada através de uma atividade
criada para o efeito abrindo simplesmente uma página web onde é automaticamente
introduzido o IP do robô após a conecção feita anteriormente. O controlo do remoto é feita na
mesma atividade da página web, podendo assim manusear ao mesmo tempo que são
visualizadas as imagens transmitidas a tempo real pela plataforma, podendo ser para este
efeito um telemóvel ou uma tablet, desde que essa possui os sensores necessários e tecnologia
WIFI.
4.6 Aplicação em C#
A aplicação criada em C# é específica para o SO Windows, já que só se torna possível a
execução de programas realizado dessa linguagem nesse SO. Possui duas “ScrollBar” para o
controlo da velocidade e direção, sendo que a velocidade do robô pode ser observada através
de duas “ProgressBar” sendo que uma é para a roda esquerda e a outra para a roda direita.
Para o bom funcionamento da mesma é necessário introduzir a porta do utilizador, e o IP e
porta do Robô. As imagens transmitidas pelo robô são visualizadas através de um “painel”
embutido no próprio programa que possibilita abrir a página web correspondente à câmara.
4.7 Aplicação em Java
Foi criada uma aplicação em linguagem Java, sendo que essa, tal como a aplicação em Pascal
funciona em diversos SO. Assim, é possível demonstrar a diversificação que a plataforma
didática criada traz para o enriquecimento do conhecimento dos alunos.
A aplicação funciona de forma semelhante às aplicações criadas em Pascal e C#, sendo usado
duas “ScrollBars” para definir a velocidade e direção e duas “ProgressBars” para visualizar a
velocidade de cada roda.
34
Esta aplicação só envia a informação, fazendo com que seja necessário selecionar a opção
“Aplicação sem Retorno” do controlo de baixo nível (Figura 22). As imagens transmitidas
pelo robô, tal como na aplicação de Pascal, são visualizadas através de um “browser” aberto à
parte do próprio programa.
4.8 Aplicação em MATLAB
A aplicação desenvolvida em MATLAB é uma aplicação unicamente de envio de informação.
O controlo das rodas é realizado através de duas “ScrollBars”, uma para a direção e outra para
velocidade, tal como a maioria das outras aplicações, já que esse método se torna o mais
eficiente para controlar o andamento do robô. Após a inserção dos dados da porta do
utilizador e do IP do Robô, é aberta uma página web onde é visualizada a imagem da câmara
que se encontra incorporada no PC do robô a tempo real.
35
Figura 16 – Fluxograma da Plataforma Didática
36
37
Capitulo 5
5 Testes
Nos testes vai-se demonstrar uma execução de duas das aplicações demos realizadas ao longo
do desenvolvimento deste projeto. Sendo que uma delas será só de envio de informação, e
outra de envio e receção da informação. Em cada aplicação demo será realizada e explicada a
configuração de cada uma, sendo que também irá ser exemplificado os processos de execução
das mesmas. No final é explicado o funcionamento do controlador de baixo nível, sendo que
essa aplicação funciona de igual modo para os dois tipos de aplicações demos.
5.1 Teste da Aplicação em Android
Figura 17 – Aplicação Demo Android, primeira parte
38
Nesta primeira fase é introduzido o IP da aplicação robotizada e a porta do utilizador. Já que
essa aplicação não recebe informação do controlador de baixo nível, é necessário selecionar a
opção “Aplicação sem Retorno” no controlador de baixo nível (Figura 22).
Ao carregar no botão a aplicação irá ligar-se remotamente ao IP da plataforma robotizada,
passando para a página seguinte (Figura 17).
Figura 18 – Aplicação Demo Android, segunda parte, juntamente com um exemplo dos eixos X e Y
Ao ser conectado ao IP da plataforma robotizada, é aberta uma página web, onde são
visualizadas as imagens enviadas por streaming a partir do software YawCam que é
executado no PC da plataforma (Figura 18).
A informação a enviar é processada por via dos acelerómetros do próprio dispositivo móvel,
sendo que na vertical o Y significa a velocidade e o X a direcção. Mantendo o dispositivo
móvel na horizontal o X irá significar a velocidade e o Y a direcção desejada (Figura 18).
Sendo que o acelerómetro é um dispositivo de hardware e os seus valores variam entre -10 e
10, foi necessário efetuar uma operação para conjugar com os valores de 0 a 255 que são
usados na comunicação da direcção e velocidade para a plataforma.
39
5.2 Teste da Aplicação em Pascal
Figura 19 –Aplicação Demo Pascal, primeira parte
No programa demo criado na linguagem Pascal, é inserido o IP da aplicação robotizada e a
sua porta, sendo que também é necessário introduzir a porta do utilizador. Esta aplicação faz
uso da informação enviada pelo controlador de baixo nível, por esse motivo a que se torna
necessário a inserção da porta da plataforma robotizada (Figura 19).
Figura 20 – Aplicação Demo Pascal, segunda parte
Ao carregar no botão ligar da aplicação demo, é aberta a página de controlo da plataforma
juntamente com uma página web, onde pode ser visualizada a tempo real as imagens enviadas
por streaming da aplicação YawCam (Figura 20).
O controlo da plataforma é manuseado por via de duas “ScrollBars” sendo que a da vertical
controla a velocidade e a da horizontal controla a direção. Perante o valor de cada “ScrollBar”
40
vai ser calculado a velocidade de cada roda que irá aparecer nas “ProgressBars” respectivas
(Figura 21).
Toda a informação recebida por UDP pela plataforma é processada de forma a dividir cada
informação para cada uma das rodas, já que a informação recebida diz respeito a cada roda e
sensores que não foram usados neste projeto (Figura 20).
5.3 Demonstração genérica do Controlador de Baixo Nível
Figura 21 – Controlador de Baixo Nível para aplicações com recetor UDP
O funcionamento do controlo de baixo nível é bastante semelhante para os dois modos de
funcionamento das aplicações demos, sendo que para as aplicações demos que não recebem
informação só é necessário indicar na CheckBox”, que irá imediatamente bloquear o envio da
mensagem via UDP (Figura 22). Para as aplicações demos que usufruem das mensagens
enviadas pelo controlador de baixo nível necessitam de configurações extras, sendo que a
mensagem irá ser enviada para o IP do utilizador indicando a porta da plataforma móvel
(Figura 21).
O controlador de baixo nível é processado no PC que se situa sob a plataforma robotizada,
sendo que essa só funciona como um ponto de transição entre utilizador e robô. A aplicação
recebe e envia a informação do utilizador via protocolo UDP e do robô via protocolo Série
(Figura 21).
41
Nesta aplicação, quando é utilizada por um programa que usufrui da receção da informação é
necessário inserir o nome do dispositivo da porta série, a porta que está a ser utilizada pelo
controlador, e o IP juntamente com a porta da aplicação que esta a usar a plataforma
remotamente. No caso das aplicações demos que não usufruem da informação enviada pelo
controlador serão bloqueados os campos da porta do robô e do IP do cliente já que essas
informações só são utilizadas para enviar informação (Figura 22).
Figura 22 – Controlador de Baixo Nível com definições para aplicações sem recetor UDP
A aplicação demostra os valores da velocidade e da direcção recebida pelo utilizador numa
“TextBox” antes de essa ser enviada automaticamente para o hardware da plataforma. O
mesmo acontece quando recebe informação do hardware, já que é visualizada numa
“TextBox” ao mesmo tempo que essa é enviada para o utilizador (Figura 21). A informação
recebida é processada e dividida em dois campos distintos, sendo esses, roda esquerda e roda
direita (Figura 23). Parte dessa informação não é aproveitada já que diz respeito a sensores
que não são utilizados neste projeto.
O gráfico permite visualizar a velocidade de cada roda, sendo que a roda esquerda está
sinalizada a azul e roda direita a vermelho. Também é possível visualizar a velocidade média
de cada instante, sendo que esse está assinalado a verde e a diferença de velocidades de cada
roda encontra-se sinalizada a laranja (Figura 23).
42
Figura 23 – Controlador de Baixo Nível, visualização da informação de cada roda
43
Capitulo 6
6 Conclusão
6.1 Análise Crítica
Os objetivos essenciais que proporcionaram a realização do projeto foram superados de forma
eficiente, perante a dificuldade que cada um deles ofereceu.
Custo Final da Plataforma Didática:
Rodas motorizadas: 100€;
Microcontrolador Mbed: 70€;
Placa de acrílico: 5€;
Total: 175€.
Foi possível construir uma plataforma cujo seu custo não fosse muito elevado e que a sua
estrutura pudesse ser usada no ensino da robótica. Comparada com várias plataformas
didáticas foi possível concluir que a plataforma concebida no âmbito deste projeto, foi de
todas a que trazia o menor encargo económico à instituição, sendo que em casos a diferença
de custo podia chegar a ser dez vezes mais elevada.
44
A plataforma irá possibilitar aos alunos uma nova experiência no que diz respeito à
programação de plataformas robotizadas, já que a elaboração desta plataforma veio
possibilitar a construção de múltiplas aplicações em várias linguagens de programação para
comunicar com a mesma. Sendo que cada aplicação pode ser concebida de múltiplas formas,
desde que essa envia a informação como descrito no protocolo de envio de informação.
Contudo pode-se concluir que este objetivo era o mais difícil de ser alcançado já que era
necessário arranjar forma de proporcionar uma nova e aliciante forma de enriquecer o
conhecimento do aluno. Perante a possibilidade de poder programar em qualquer linguagem
de agrado do aluno e não haver bloqueio no que diz respeito ao SO, conclui-se que este
objetivo foi alcançado com sucesso.
6.2 Trabalho Futuro
Para trabalho a desenvolver futuramente existe a possibilidade de criar uma aplicação de
programação gráfica para a plataforma robotizada, com a utilização do controlador de baixo
nível e uns sensores de infravermelhos.
Sendo que os sensores retornam informação, será possível criar uma plataforma gráfica
programável por blocos. A plataforma poderá vir a ser útil para quem esteja a iniciar o seu
percurso como programador, possibilitando ao utilizador criar aplicações como seguir uma
linha ou como também encontrar a saída de um labirinto.
45
Referências bibliográficas
[1] http://lelinopontes.wordpress.com/2010/06/25/historia-da-robotica-educacionalre
[Consult. Maio de 2012].
[2] http://www.papert.org/articles/ChildrensMachine.html [Conslult. Junho de 2012].
[3] Castilho, M. Robótica na educação: com que objetivos? Universidade Federal do Rio Grande
do Sul, Porto Alegre, 2002. [Consult. Maio de 2012]. Disponível em www: <URL:
http://www.pgie.ufrgs.br/alunos_espie/espie/mariac/public_html/robot_edu.html .>
[4] http://mindstorms.lego.com/en-us/Default.aspx [Consult. Maio de 2012].
[5] Azevedo, S., Aglaé, A., Pitta, R. Minicurso: Introdução a Robótica Educacional. s.d. [Consult.
Abril de 2012]. Disponível em www: <URL:
http://www.sbpcnet.org.br/livro/62ra/minicursos/MC%20Samuel%20Azevedo.pdf .>
[6] Gonçalves, P. Protótipo de um robô móvel de baixo custo para uso educacional. Paraná:
Universidade Estadual de Maringá, 2007. Dissertação de Mestrado. [Consult. Maio de 2012].
Disponível em www:<URL: http://www.din.uem.br/arquivos/pos-graduacao/mestrado-em-
ciencia-da-computacao/dissertacoes/Paulo%20Cesar%20Goncalves.pdf .>
[7] http://robocode.sourceforge.net/docs/ReadMe.html [Consult. Junho de 2012].
[8] Barbosa, A. Desenvolvimento de Robô Manipulador Didático Baseado em Componentes
Bioloid. Bragança: Instituto Politécnico de Bragança, 2010. Relatório de estágio de Mestrado.
Disponível na Biblioteca da Escola Superior Técnologia e Gestão, Bragança, Portugal.
[9] http://www.robotica.ws [Consult. Junho de 2012].
[10] http://www.vexrobotics.com/276-2231.html [Consult. Maio de 2012].
[11] http://www.idmind.pt/pt/education/circular.php [Consult. Junho de 2012].
[12] http://www.botnroll.com/ [Consult. Junho de 2012].
[13] http://www.aldebaran-robotics.com [Consult. Maio de 2012].
[14] http://hem.bredband.net/yawcam/
[15] Guerreiro, P. Pascal – Técnicas de Programação 5ª Edição Revista. FCA – Editora de
Informática, LDA – Abril de 2002.
[16] Coelho, P. Programação em JAVA. FCA – Editora de Informática, LDA – 2009.
[17] Loureiro, H. C# 4.0 com Visual Studio 2010. FCA – Editora de Informática, LDA – Junho de
2011.
[18] Morais, V., Vieira, C. MATLAB 7&6 Curso Completo 3ª Edição. FCA – Editora de
Informática, LDA – Abril de 2006.
[19] http://lazarusbrasil.org/historia.php [Consult. Abril de 2012].
[20] http://pt.wikipedia.org/wiki/Lazarus_(ADI) [Consult. Junho de 2012].
[21] http://www.eclipse.org/org/ [Consult. Maio de 2012].
46
1
Anexo A
A Código do Controlador de Baixo Nível
unit Unit1;
{$mode objfpc}{$H+}
interface
uses
Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs,
StdCtrls,
IniPropStorage, Chart, lNetComponents, SdpoSerial, lNet, TAGraph,
TASources,
TASeries;
const grafMAX=100;
type
//Para ter uma função que devolva dois valores
Tdata2 = record
rodaesq, rodadta: string;
end;
{ TForm1 }…
private
{ private declarations }
public
{ public declarations }
dadosrec: Tdata2;
end;
var
Form1: TForm1;
PCliente, PRobo,IPCliente, IPRobo, Reccliente, Recrobo:String;
2
grafarray:Array[1..4,0..grafMAX]of integer;
ip:integer;
implementation
{$R *.lfm}
{ TForm1 }
//==Função que irá subdividir a string==//
function velocidade(frases:String):TData2;
Type
ArrayR=array[1..41] of string;
var
imprimir:ArrayR;
frase:string[41];
ler:string;
elemento:string;
esq,dir y,j,i,x,z:integer;
resultado: Tdata2;
begin
frase:=frases;
z:=length(frase);
x:=0;
ler:='';
j:=0;
while x<=z do
begin
elemento:=frase[x];
//==caso tenha um dos carateres invalidos==//
while ((elemento=',')or(elemento='#')or(elemento='*')) do
begin
x:=x+1;
elemento:=frase[x];
j:=j+1;
imprimir[j]:=ler;
ler:='';
end;
ler:=ler+elemento;
x:=x+1;
end;
//=======RODA ESQUERDA=======//
3
esq:=StrToInt(imprimir[2])shl(8*3)+StrToInt(imprimir[3])shl(8*2)+StrToInt(i
mprimir[4])shl(8*1)+StrToInt(imprimir[5]);
//======RODA DIREITA=======//
dir:=StrToInt(imprimir[6])shl(8*3)+StrToInt(imprimir[7])shl(8*2)+StrToInt(i
mprimir[8])shl(8*1)+StrToInt(imprimir[9]);
resultado.rodaesq:=IntToStr(esq);
resultado.rodadta:=inttostr(dir);
frase:='';
Result := resultado;
//========================//
end;
procedure TForm1.FormCreate(Sender: TObject);
begin
RCliente.Clear;
RRobo.Clear;
ip:=0;
end;
procedure TForm1.LUDPReceive(aSocket: TLSocket);
begin
//==ensagem recebida pelo Cliente, vai ser mostrada na TMemo do Cliente e
enviada para a porta Serie==//
LUDP.GetMessage(Reccliente);
RCliente.Text:=Reccliente;
Serial.WriteData(Reccliente);
end;
procedure TForm1.SerialRxData(Sender: TObject);
var
velrodas:Tdata2;
i,diferenca:integer;e,d:longInt;
begin
Recrobo:=Recrobo+Serial.ReadData;
Rrobo.Clear;
//==Vai ler o que recebe da porta serie, escrever no TMemo do Robo e enviar
para o cliente==//
RRobo.Text:=Recrobo;
if(Recrobo[1]='*')then
4
begin
if(Recrobo[Length(Recrobo)]='#') then
begin
velrodas:=velocidade(Recrobo);
REsquerda.Text:=velrodas.rodaesq;
RDireita.Text:=velrodas.rodadta;
e:=StrToInt(REsquerda.Text);
d:=StrToInt(RDireita.Text);
diferenca:=e-d;
if (diferenca<0)then
diferenca:=diferenca*(-1);
//====================== GRAFICO==========================//
//==Limpar os campos==//
RodaDireita.Clear;
RodaEsquerda.Clear;
LinhaMedia.Clear;
LinhaDiferenca.Clear;
//==Introduçao dos valores nos graficos==//
for i:=0 to grafMAX-1 do
begin
grafarray[1,i]:=grafarray[1,i+1]; grafarray[2,i]:=grafarray[2,i+1];
grafarray[3,i]:=grafarray[3,i+1]; grafarray[4,i]:=grafarray[4,i+1];
end;
grafarray[1,grafMAX]:=StrToInt(REsquerda.Text);
grafarray[2,grafMAX]:=StrToInt(RDireita.Text);
grafarray[3,grafMAX]:=((e+d)div 2);
grafarray[4,grafMAX]:=(diferenca);
for i:=0 to grafMAX-1 do
begin
RodaEsquerda.Addxy(i,grafarray[1,i]);
RodaDireita.Addxy(i,grafarray[2,i]);
LinhaMedia.AddXY(i,grafarray[3,i]);
LinhaDiferenca.AddXY(i,grafarray[4,i]);
end;
//======================Fim GRAFICO==========================//
if(ip=0)then
begin
LUDP.SendMessage(Recrobo,IPCliente+':'+PRobo);
end;
5
Recrobo:='';
end;
end;
end;
//=====INICIAR A APLICAÇÃO AO CARREGAR NO BOTAO==============//
procedure TForm1.BLigarClick(Sender: TObject);
begin
Recrobo:='';
PCliente:=edCPorta.Text;
IPCliente:=edCIP.Text;
PRobo:=edRPorta.Text;
//Atribuir os Valores da Porta e do IP ao LUDP
LUDP.Host:=IPRobo;
LUDP.Port:=StrToInt(PRobo);
//Por a escutar a porta do Cliente
LUDP.Listen(StrToInt(PCliente));
//Abrir a Porta Serie e atribuir nome
Serial.Device:=edDisp.Text;
Serial.Open;
end;
procedure TForm1.cbEnvioClick(Sender: TObject);
begin
if cbEnvio.Checked then
begin
cbEnvio.State:=cbChecked;
edCIP.Enabled:=False;
edRPorta.Enabled:=False;
ip:=1;
end else
begin
cbEnvio.State:=cbUnchecked;
edCIP.Enabled:=True;
edRPorta.Enabled:=True;
ip:=0;
end;
6
end;
procedure TForm1.cbRodasClick(Sender: TObject);
begin
//Caso queira ver a velocidade das rodas antes de enviar
if cbRodas.Checked then
begin
cbRodas.State:=cbChecked;
RRobo.Visible:=False;
REsquerda.Visible:=True;
RDireita.Visible:=True;
Label5.Visible:=True;
Label6.Visible:=True;
end else
begin
cbRodas.State:=cbUnchecked;
RRobo.Visible:=True;
REsquerda.Visible:=False;
RDireita.Visible:=False;
Label5.Visible:=False;
Label6.Visible:=False;
end;
end;
end.
7
Anexo B
A Aplicação Demo de Pascal
unit Unit1;
{$mode objfpc}{$H+}
interface
uses
Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs,
ComCtrls,
StdCtrls, lNetComponents, lNet, LCLIntf;
type
Tdata2 = record
rodaesq, rodadta: string;
end;
type
{ TDemoPascal }
private
{ private declarations }
public
{ public declarations }
dadosrec: Tdata2;
end;
var
DemoPascal: TDemoPascal;
//==Declaração das Variaveis Globais==//
PCliente, PRobo, IPRobo, Reccliente, Recrobo, Direcao,Velocidade:String;
implementation
8
{$R *.lfm}
{ TDemoPascal }
function funcvelocidade(frases:String):TData2;
Type
ArrayR=array[1..41] of string;
var
imprimir:ArrayR;
frase:string[41];
ler:string;
elemento:string;
y,j,i,x,z:integer;
esq,dir:integer;
resultado: Tdata2;
begin
frase:=frases;
z:=length(frase);
x:=0;
ler:='';
j:=0;
while x<=z do
begin
elemento:=frase[x];
//caso tenha um dos carateres invalidos
while ((elemento=',')or(elemento='#')or(elemento='*')) do
begin
x:=x+1;
elemento:=frase[x];
j:=j+1;
imprimir[j]:=ler;
ler:='';
end;
ler:=ler+elemento;
x:=x+1;
end;
//=======RODA ESQUERDA=======//
esq:=StrToInt(imprimir[2])shl(8*3)+StrToInt(imprimir[3])shl(8*2)+StrToInt(i
mprimir[4])shl(8*1)+StrToInt(imprimir[5]);
9
//=======RODA Direita=======//
dir:=StrToInt(imprimir[6])shl(8*3)+StrToInt(imprimir[7])shl(8*2)+StrToInt(i
mprimir[8])shl(8*1)+StrToInt(imprimir[9]);
resultado.rodaesq:=IntToStr(esq);
resultado.rodadta:=inttostr(dir);
Result := resultado;
frase:='';
end;
procedure TDemoPascal.bLigarClick(Sender: TObject);
begin
//==Definir valor das Variaveis Globais==//
PCliente:=edPortaC.Text;
PRobo:=edPortaR.Text;
IPRobo:=edIPR.Text;
//==Definir a porta que vai ser usada para enviar informação==//
LUDP.Port:=StrToInt(PCliente);
//==Escutar a Porta do Robo==//
LUDP.Listen(StrToInt(PRobo));
//==Abrir o separador de Controlo e impedir o acesso aos elementos de
introdução de dados==//
pcMenu.ActivePage:=tbControl;
tbIndex.Enabled:=False;
tbControl.Enabled:=True;
OpenURL('http://'+IPRobo+':8081');
end;
procedure TDemoPascal.FormCreate(Sender: TObject);
begin
Direcao:='128';
Velocidade:='128';
pcMenu.ActivePage:=tbIndex;
end;
procedure TDemoPascal.LUDPReceive(aSocket: TLSocket);
var
velrodas:Tdata2;
begin
LUDP.GetMessage(Recrobo);
10
//*****Para SAIR*****//
velrodas:=funcvelocidade(Recrobo);
edREsquerda.Text:=velrodas.rodaesq;
edRDireita.Text:=velrodas.rodadta;
end;
procedure TDemoPascal.sbDirecaoChange(Sender: TObject);
var
velesq,veldir:Integer;
begin
Direcao:=IntToStr(sbDirecao.Position);
LUDP.SendMessage('*'+Velocidade+','+Direcao+'#',IPRobo+':'+PCliente);
//==Definir Velocidade das Rodas==//
if(sbVelocidade.Position<128)then
begin
if(sbDirecao.Position<128)then
begin
velesq:=((strtoint(Velocidade)-(strtoint(Direcao)))*79) div 100;
pbEsquerda.Position:=velesq;
CMEsq.Text:=IntToStr(pbEsquerda.Position);
veldir:=(strtoint(Velocidade)-127)*79;
pbDireita.Position:=veldir div 100;
CMdir.Text:=IntToStr(pbDireita.Position);
end;
if(sbDirecao.Position>=128)then
begin
veldir:=((strtoint(Velocidade)-(255-strtoint(Direcao)))*79) div 100;
pbDireita.Position:=veldir;
CMdir.Text:=IntToStr(pbDireita.Position);
velesq:=(strtoint(Velocidade)-127)*79;
pbEsquerda.Position:=velesq div 100;
CMEsq.Text:=IntToStr(pbEsquerda.Position);
end;
end;
if(sbVelocidade.Position>=128)then
begin
11
if(sbDirecao.Position<128)then
begin
velesq:=((strtoint(Velocidade)-(255-strtoint(Direcao)))*79) div 100;
pbEsquerda.Position:=velesq;
CMEsq.Text:=IntToStr(pbEsquerda.Position);
veldir:=(strtoint(Velocidade)-127)*79;
pbDireita.Position:=veldir div 100;
CMdir.Text:=IntToStr(pbDireita.Position);
end;
if(sbDirecao.Position>=128)then
begin
veldir:=((strtoint(Velocidade)-(strtoint(Direcao)))*79) div 100;
pbDireita.Position:=veldir;
CMdir.Text:=IntToStr(pbDireita.Position);
velesq:=(strtoint(Velocidade)-127)*79;
pbEsquerda.Position:=velesq div 100;
CMEsq.Text:=IntToStr(pbEsquerda.Position);
end;
end;
end;
procedure TDemoPascal.sbVelocidadeChange(Sender: TObject);
var
velesq,veldir:Integer;
begin
Velocidade:=IntToStr(sbVelocidade.Position);
LUDP.SendMessage('*'+Velocidade+','+Direcao+'#',IPRobo+':'+PCliente);
//==Definir Velocidade das Rodas==//
if(sbVelocidade.Position<128)then
begin
if(sbDirecao.Position<128)then
begin
velesq:=((strtoint(Velocidade)-(strtoint(Direcao)))*79) div 100;
pbEsquerda.Position:=velesq;
CMEsq.Text:=IntToStr(pbEsquerda.Position);
veldir:=(strtoint(Velocidade)-127)*79;
pbDireita.Position:=veldir div 100;
12
CMdir.Text:=IntToStr(pbDireita.Position);
end;
if(sbDirecao.Position>=128)then
begin
veldir:=((strtoint(Velocidade)-(255-strtoint(Direcao)))*79) div 100;
pbDireita.Position:=veldir;
CMdir.Text:=IntToStr(pbDireita.Position);
velesq:=(strtoint(Velocidade)-127)*79;
pbEsquerda.Position:=velesq div 100;
CMEsq.Text:=IntToStr(pbEsquerda.Position);
end;
end;
if(sbVelocidade.Position>=128)then
begin
if(sbDirecao.Position<128)then
begin
velesq:=((strtoint(Velocidade)-(255-strtoint(Direcao)))*79) div 100;
pbEsquerda.Position:=velesq;
CMEsq.Text:=IntToStr(pbEsquerda.Position);
veldir:=(strtoint(Velocidade)-127)*79;
pbDireita.Position:=veldir div 100;
CMdir.Text:=IntToStr(pbDireita.Position);
end;
if(sbDirecao.Position>=128)then
begin
veldir:=((strtoint(Velocidade)-(strtoint(Direcao)))*79) div 100;
pbDireita.Position:=veldir;
CMdir.Text:=IntToStr(pbDireita.Position);
velesq:=(strtoint(Velocidade)-127)*79;
pbEsquerda.Position:=velesq div 100;
CMEsq.Text:=IntToStr(pbEsquerda.Position);
end;
end;
end;
13
procedure TDemoPascal.bDesligarClick(Sender: TObject);
begin
//==Abrir o separador de Indice e impedir o acesso ao controlo==//
pcMenu.ActivePage:=tbIndex;
tbIndex.Enabled:=True;
tbControl.Enabled:=False;
end;
end.
14
15
Anexo C
A Aplicação Demo de Android
A.1 PedirIP.java
package com.projeto.robowifi;
import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.ToggleButton;
public class PedirIP extends Activity {
/** Called when the activity is first created. */
EditText ip,porta;
Intent intent;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
ip=(EditText) findViewById(R.id.ETIP);
16
porta=(EditText) findViewById(R.id.ETPorta);
Button butao=(ToggleButton) findViewById(R.id.BLigar);
butao.setOnClickListener(new View.OnClickListener(){
public void onClick(View v) {
intent = new Intent().setClass(v.getContext(),
Controlo.class);
intent.putExtra("IP", ip.getText().toString());
intent.putExtra("Porta", porta.getText().toString());
startActivity(intent);
}
});
}
}
A.2 Controlo.java
package com.projeto.robowifi;
import android.R.integer;
import android.app.Activity;
import android.content.Intent;
import android.hardware.Sensor;
import android.hardware.SensorEvent;
import android.hardware.SensorEventListener;
import android.hardware.SensorManager;
import android.os.Bundle;
import android.webkit.WebView;
import com.projeto.robowifi.UDP;
public class Controlo extends Activity implements SensorEventListener {
WebView mWebView;
private Intent intent;
UDP udp;
String ip;
String porta;//Acelarometro
private SensorManager sensorManager;
private Sensor accelerometer;
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
//Acelarometro
sensorManager = (SensorManager)
this.getSystemService(SENSOR_SERVICE);
accelerometer =
sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
//
setContentView(R.layout.web);
//recebe a intent enviada
intent = getIntent();
17
//armazena os números digitados
ip = intent.getStringExtra("IP");
porta =intent.getStringExtra("Porta");
mWebView = (WebView) findViewById(R.id.webview);
mWebView.getSettings().setJavaScriptEnabled(true);
mWebView.loadUrl("http://"+ip+":8081");
}
public void onAccuracyChanged(Sensor arg0, int arg1) {
// Mudou a acurácia do sensor
//txtAcc.setText("= " + arg1);
}
public void onSensorChanged(SensorEvent event) {
float meio=128;
float xx=event.values[0];
float yy=event.values[1];
float regrax=(float) (12.7*xx);
float regray=(float) (12.7*yy);
int x=(int) ((int) meio+regrax);//event.values[0];
int y=(int) ((int) meio+regray);
UDP.runUdpClient(x,y,ip,porta);
}
@Override
protected void onPause() {
super.onPause();
sensorManager.unregisterListener(this);
}
@Override
protected void onResume() {
super.onResume();
sensorManager.registerListener(this, accelerometer,
SensorManager.SENSOR_DELAY_NORMAL);
}
}
A.3 UDP.java
package com.projeto.robowifi;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.net.UnknownHostException;
public class UDP {
//public static String ip;
//public static String porta;
//private static final int UDP_SERVER_PORT =111;
public static void runUdpClient(int x,int y,String ip,String porta)
{
18
String udpMsg = "*"+x+","+y+"#";//Mensagem
DatagramSocket ds = null;
try {
ds = new DatagramSocket();
InetAddress serverAddr = InetAddress.getByName(ip);
DatagramPacket dp;
dp = new DatagramPacket(udpMsg.getBytes(),
udpMsg.length(), serverAddr, Integer.parseInt(porta));
ds.send(dp);
} catch (SocketException e) {
e.printStackTrace();
}catch (UnknownHostException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
} finally {
if (ds != null) {
ds.close();
}
}
}
}
19
Anexo D
A Aplicação Demo de Matlab
% --- //Scroll Velocidade
function SVelocidade_Callback(hObject, eventdata, handles)
global u;
global velocidade;
global direcao;
velocidade=num2str(get(hObject,'value'));
set(handles.edvel,'string',velocidade);
f=['*',velocidade,',',direcao,'#'];
%fget(handles.edvel,'string');
fwrite(u,f);
% --- //Scroll Direçao
% --- Executes on slider movement.
function SDirecao_Callback(hObject, eventdata, handles)
global u;
global velocidade;
global direcao;
direcao=num2str(get(hObject,'value'));
set(handles.eddir,'string',direcao);
f=['*',velocidade,',',direcao,'#'];
fwrite(u,f);
%fwrite(u,fator);
% --- //Carregar no Botão Ligar
% --- Executes on button press in Bligar.
function Bligar_Callback(hObject, eventdata, handles)
20
ip=get(handles.edIP,'String');
porta=str2num(get(handles.edPortaCl,'String'));
global u;
global velocidade;
global direcao;
direcao=128;
velocidade=128;
u=udp(ip,porta);
fopen(u);
página=['http://',ip,':8081'];
web(página,'-browser');
%c=udp('172.0.0.1',101,'LocalPort',100)
%fopen(c);
%a=fread(c,512);
%set(handles.eddir,'string',a);
Figura 24 – Aplicação Demo Matlab
21
Anexo E
A Aplicação Demo de Java
A.1 UDP.java
import java.io.IOException;
import java.io.ObjectInputStream;
import java.net.*;
import sun.nio.ch.DatagramSocketAdaptor;
public class UDP {
InetAddress theHost;
Socket theSocket;
public UDP(String campo, String ip, int Porta) {
try {
int port = Porta;
theHost = InetAddress.getByName(ip);
String theHostName = theHost.getHostName();
String toSend = campo;
byte[] sendbuf = new byte[toSend.length()];
toSend.getBytes(0, toSend.length(), sendbuf, 0);
DatagramSocket clientSocket = new DatagramSocket();
DatagramPacket sendPacket = new
DatagramPacket(sendbuf, sendbuf.length, theHost, port);
clientSocket.send(sendPacket);
System.out.println("Server connection opened, going to
listen");
} catch (UnknownHostException ExecHost)
22
{
System.out.println("Unknown Host Error");
}
catch (IOException ExceIO)
{
System.out.println("Error creatin socket :
"+ExceIO.getMessage());
}
}
public static void main(String[] args) {
}
}
Figura 25 – Aplicação Demo em Java, 1ª Janela
A.2 jfAplicacao.java
import java.applet.AppletContext;
import java.awt.BorderLayout;
import java.awt.Container;
import java.net.*;
import java.net.DatagramSocket;
import java.io.*;
import java.io.StringReader;
import java.net.URI;
import java.awt.Desktop;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.JEditorPane;
import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.event.HyperlinkEvent;
import javax.swing.event.HyperlinkListener;
23
public class jfAplicacao extends javax.swing.JFrame {
int velocidade;
int direccao;
InetAddress address;
int port = 100;
int velocidadeInicial = 127;
public jfAplicacao() {
initComponents();
UpdateLabelD();
UpdateLabelV();
vScroll.setValue(127);
hSlider.setValue(127);
UpdateLabelF();
UpdateRobot();
}
layout.setVerticalGroup(
layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(layout.createSequentialGroup()
.addContainerGap()
.addComponent(jTabbedPane1)
.addContainerGap())
);
pack();
}
private void jButton1ActionPerformed(java.awt.event.ActionEvent evt)
{
UpdateRobot();
private void
vScrollAdjustmentValueChanged(java.awt.event.AdjustmentEvent evt) {
UpdateLabelD();
UpdateLabelF();
UpdateRobot();
}
private void hSliderStateChanged(javax.swing.event.ChangeEvent evt) {
UpdateLabelV();
UpdateLabelF();
UpdateRobot();
}
private void jButton2ActionPerformed(java.awt.event.ActionEvent evt)
{
try {
try {
Desktop.getDesktop().browse(new URI("http://" +
jIP.getText() + ":8081"));
} catch (URISyntaxException ex) {
24
Logger.getLogger(jfAplicacao.class.getName()).log(Level.SEVERE, null,
ex);
}
} catch (IOException ex) {
Logger.getLogger(jfAplicacao.class.getName()).log(Level.SEVERE, null,
ex);
}
}
public String GetIP() {
String ip = jIP.toString();
return ip;
}
public void UpdateRobot() {
Distancia();
String ip = jIP.getText();
int Porta = Integer.parseInt(jPortaC.getText());
String Campo = lFinal.getText();
UDP udp = new UDP(Campo, ip, Porta);
}
public void Distancia() {
if (vScroll.getValue() < 128) {
if (hSlider.getValue() < 128) {
double velesq = (vScroll.getValue() - hSlider.getValue())
* 0.79;
String velesqr = Double.toString(velesq);
resq.setText(velesqr);
double veldir = (vScroll.getValue() - 127) * 0.79;
String veldirr = Double.toString(veldir);
rdir.setText(veldirr);
}
if (hSlider.getValue() >= 128) {
double veldir = (vScroll.getValue() - (255-
hSlider.getValue())) * 0.79;
String veldirr = Double.toString(veldir);
rdir.setText(veldirr);
double velesq = (vScroll.getValue() - 127) * 0.79;
String velesqr = Double.toString(velesq);
resq.setText(velesqr);
}
}
if (vScroll.getValue() >= 128) {
if (hSlider.getValue() < 128) {
double velesq = (vScroll.getValue() - (255-
hSlider.getValue())) * 0.79;
String velesqr = Double.toString(velesq);
resq.setText(velesqr);
double veldir = (vScroll.getValue() - 127) * 0.79;
String veldirr = Double.toString(veldir);
rdir.setText(veldirr);
}
if (hSlider.getValue() >= 128) {
25
double veldir = (vScroll.getValue() - hSlider.getValue())
* 0.79;
String veldirr = Double.toString(veldir);
rdir.setText(veldirr);
double velesq = (vScroll.getValue() - 127) * 0.79;
String velesqr = Double.toString(velesq);
resq.setText(velesqr);
}
}
}
public void UpdateLabelD() {
int value = vScroll.getValue();
String st = Integer.toString(value);
this.lVel.setText(st);
}
public void UpdateLabelV() {
int value = hSlider.getValue();
String st = Integer.toString(value);
this.lDir.setText(st);
}
public void UpdateLabelF() {
int value = hSlider.getValue();
String st = Integer.toString(value);
this.lDir.setText(st);
int value2 = vScroll.getValue();
String st2 = Integer.toString(value2);
this.lVel.setText(st2);
this.lFinal.setText("*" + st2 + "," + st + "#");
}
public static void main(String args[]) {
try {
for (javax.swing.UIManager.LookAndFeelInfo info :
javax.swing.UIManager.getInstalledLookAndFeels()) {
if ("Nimbus".equals(info.getName())) {
javax.swing.UIManager.setLookAndFeel(info.getClassName());
break;
}
}
} catch (ClassNotFoundException ex) {
java.util.logging.Logger.getLogger(jfAplicacao.class.getName()).log(java.
util.logging.Level.SEVERE, null, ex);
} catch (InstantiationException ex) {
java.util.logging.Logger.getLogger(jfAplicacao.class.getName()).log(java.
util.logging.Level.SEVERE, null, ex);
} catch (IllegalAccessException ex) {
java.util.logging.Logger.getLogger(jfAplicacao.class.getName()).log(java.
util.logging.Level.SEVERE, null, ex);
} catch (javax.swing.UnsupportedLookAndFeelException ex) {
26
java.util.logging.Logger.getLogger(jfAplicacao.class.getName()).log(java.
util.logging.Level.SEVERE, null, ex);
}
java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
new jfAplicacao().setVisible(true);
}
});
}
Figura 26 – Aplicação Demo Java, 2ª Janela
27
Anexo F
A Aplicação Demo de C#
A.1 TemplateDemoCSharp.cs
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Net.Sockets;
using System.Net;
using System.Threading;
namespace WindowsFormsApplication1
{
public partial class DemoCSharp : Form
{
//Variaveis
int i = 1;
UdpClient portarobo, cliente;
IPEndPoint RemoteIpEndPoint, iep;
int velocidadeInicial = 127;
public DemoCSharp()
{
InitializeComponent();
pbDireita.Minimum = 0;
pbDireita.Maximum = 255;
pbDireita.Value = 128;
pbEsquerda.Minimum = 0;
pbEsquerda.Maximum = 255;
pbEsquerda.Value = 128;
}
28
private void Distancia()
{
if (sbVelocidade.Value < 128)
{
if (sbDirecao.Value < 128)
{
int velesq =( (sbVelocidade.Value - sbDirecao.Value)
* 79)/100;
tbDEsq.Text = velesq.ToString();
int veldir = ((sbVelocidade.Value - 127) * 79)/100;
tbDDir.Text = veldir.ToString();
pbDireita.Value = 100 + int.Parse(tbDDir.Text);
pbEsquerda.Value = 100 + int.Parse(tbDEsq.Text);
}
if (sbDirecao.Value >= 128)
{
int veldir = ((sbVelocidade.Value - (255 -
sbDirecao.Value)) * 79)/100;
tbDDir.Text = veldir.ToString();
int velesq = ((sbVelocidade.Value - 127) * 79)/100;
tbDEsq.Text = velesq.ToString();
pbDireita.Value = 100 + int.Parse(tbDDir.Text);
pbEsquerda.Value = 100 + int.Parse(tbDEsq.Text);
}
}
if (sbVelocidade.Value >= 128)
{
if (sbDirecao.Value < 128)
{
int velesq = ((sbVelocidade.Value - (255 -
sbDirecao.Value)) * 79)/100;
tbDEsq.Text = velesq.ToString();
pbEsquerda.Value = 100 + int.Parse(tbDEsq.Text);
int veldir = ((sbVelocidade.Value - 127) * 79)/100;
tbDDir.Text = veldir.ToString();
pbDireita.Value = 100 + int.Parse(tbDDir.Text);
}
if (sbDirecao.Value >= 128)
{
int veldir = ((sbVelocidade.Value - sbDirecao.Value)
* 79)/100;
tbDDir.Text = veldir.ToString();
int velesq = ((sbVelocidade.Value - 127) * 79)/100;
tbDEsq.Text = velesq.ToString();
pbDireita.Value = 100 + int.Parse(tbDDir.Text);
pbEsquerda.Value = 100+int.Parse(tbDEsq.Text);
}
}
}
private void bLigar_Click(object sender, EventArgs e)
{
if (i == 1)
{
tbMenu.SelectedTab = tbControlo;
//Robo
string ip = tbIP.Text;
portarobo = new UdpClient(int.Parse(tbPortaR.Text));
29
RemoteIpEndPoint = new IPEndPoint(IPAddress.Parse(ip),
int.Parse(tbPortaR.Text));
//Cliente
cliente = new UdpClient();
iep = new IPEndPoint(IPAddress.Parse(tbIP.Text),
int.Parse(tbPortaC.Text));
i = 0;
}
else MessageBox.Show("Ligado");
}
private void sbVelocidade_Scroll(object sender, ScrollEventArgs
e)
{
byte[] data = Encoding.ASCII.GetBytes(VelDir());
cliente.Send(data, data.Length, iep);
Distancia();
}
private string VelDir()
{
String veldir = "*" + sbVelocidade.Value + "," +
sbDirecao.Value + "#";
return veldir;
}
private void sbDirecao_Scroll(object sender, ScrollEventArgs e)
{
byte[] data = Encoding.ASCII.GetBytes(VelDir());
cliente.Send(data, data.Length, iep);
Distancia();
}
private void panel1_Paint(object sender, PaintEventArgs e)
{
webBrowser2.Navigate("http://" + tbIP.Text + ":8081");
}
}
}
30
Figura 27 – Aplicação Demo em C#, 1ª Janela
Figura 28 – Aplicação Demo em C#, 2ª Janela